diff options
1007 files changed, 411147 insertions, 17309 deletions
diff --git a/appveyor.yml b/.appveyor.yml index 9bc135873c8..9bc135873c8 100644 --- a/appveyor.yml +++ b/.appveyor.yml diff --git a/.cirrus.yml b/.cirrus.yml index 36a1b67e9c0..c8fb326c89e 100644 --- a/.cirrus.yml +++ b/.cirrus.yml @@ -6,9 +6,11 @@ # Lets workaround it by specifying a custom volume mount point. env: CIRRUS_VOLUME: /cirrus-ci-volume + LANG: C.UTF-8 task: name: Arm64 Graviton2 / $CC + skip: "changesIncludeOnly('doc/**', '**.{md,rdoc}')" arm_container: # We use the arm64 images at http://ghcr.io/ruby/ruby-ci-image . image: ghcr.io/ruby/ruby-ci-image:$CC diff --git a/.document b/.document index 2c68af227d2..6e08f42698c 100644 --- a/.document +++ b/.document @@ -17,6 +17,7 @@ dir.rb gc.rb io.rb kernel.rb +marshal.rb numeric.rb nilclass.rb pack.rb diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 00000000000..15abc79af67 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,10 @@ +# Lines starting with '#' are comments. +# Each line is a file pattern followed by one or more owners. +# Code owners will be automatically tagged as reviewers when a pull request is opened + +# YJIT sources and tests +yjit* @maximecb @xrxr @tenderlove +doc/yjit/* @maximecb @xrxr @tenderlove +bootstraptest/test_yjit* @maximecb @xrxr @tenderlove +test/ruby/test_yjit* @maximecb @xrxr @tenderlove +.github/workflows/yjit* @maximecb @xrxr @tenderlove diff --git a/.github/workflows/baseruby.yml b/.github/workflows/baseruby.yml index 788ca8f474f..24b867c7fc0 100644 --- a/.github/workflows/baseruby.yml +++ b/.github/workflows/baseruby.yml @@ -1,6 +1,20 @@ name: BASERUBY Check -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} jobs: baseruby: @@ -19,18 +33,22 @@ jobs: steps: - uses: actions/checkout@v2 + - uses: actions/cache@v2 + with: + path: .downloaded-cache + key: downloaded-cache - uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.ruby }} bundler: none - - run: echo "make=make -sj$((1 + $(nproc --all)))" >> $GITHUB_ENV + - run: echo "GNUMAKEFLAGS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV - run: sudo apt-get install build-essential autoconf bison - run: ./autogen.sh - run: ./configure --disable-install-doc - - run: $make common-srcs - - run: $make incs - - run: $make all - - run: $make test + - run: make common-srcs + - run: make incs + - run: make all + - run: make test - uses: k0kubun/action-slack@v2.0.0 with: payload: | diff --git a/.github/workflows/bundled_gems.yml b/.github/workflows/bundled_gems.yml index d46c0704cd3..81ba5cd5b48 100644 --- a/.github/workflows/bundled_gems.yml +++ b/.github/workflows/bundled_gems.yml @@ -17,7 +17,7 @@ jobs: - name: Set ENV run: | - echo "JOBS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV + echo "GNUMAKEFLAGS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV - uses: actions/checkout@v2 @@ -38,16 +38,21 @@ jobs: sudo apt-get install --no-install-recommends -q -y build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev bison autoconf ruby if: ${{ steps.diff.outcome == 'failure' }} + - uses: actions/cache@v2 + with: + path: .downloaded-cache + key: downloaded-cache + - name: Build run: | ./autogen.sh ./configure -C --disable-install-doc - make $JOBS + make if: ${{ steps.diff.outcome == 'failure' }} - name: Test bundled gems run: | - make $JOBS -s test-bundled-gems + make -s test-bundled-gems timeout-minutes: 30 env: RUBY_TESTOPTS: "-q --tty=no" @@ -56,8 +61,8 @@ jobs: - name: Commit run: | - git commit --message="Update ${{ github.workflow }} at $(date +%F)" gems/${{ github.workflow }} git pull --ff-only origin ${GITHUB_REF#refs/heads/} + git commit --message="Update ${{ github.workflow }} at $(date +%F)" gems/$file git push origin ${GITHUB_REF#refs/heads/} env: EMAIL: svn-admin@ruby-lang.org diff --git a/.github/workflows/check_dependencies.yml b/.github/workflows/check_dependencies.yml index 645da4000b4..c68e49a4641 100644 --- a/.github/workflows/check_dependencies.yml +++ b/.github/workflows/check_dependencies.yml @@ -1,10 +1,25 @@ name: Check Dependencies -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + jobs: update-deps: strategy: matrix: - os: [ubuntu-20.04, macos-latest] + os: [ubuntu-20.04] fail-fast: true runs-on: ${{ matrix.os }} steps: @@ -24,6 +39,10 @@ jobs: git config --global advice.detachedHead 0 git config --global init.defaultBranch garbage - uses: actions/checkout@v2 + - uses: actions/cache@v2 + with: + path: .downloaded-cache + key: downloaded-cache - run: ./autogen.sh - name: Run configure run: ./configure -C --disable-install-doc --disable-rubygems --with-gcc 'optflags=-O0' 'debugflags=-save-temps=obj -g' diff --git a/.github/workflows/check_misc.yml b/.github/workflows/check_misc.yml index c116011d868..2a59e74066a 100644 --- a/.github/workflows/check_misc.yml +++ b/.github/workflows/check_misc.yml @@ -1,6 +1,10 @@ name: Miscellaneous checks on: [push, pull_request] +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + jobs: checks: runs-on: ubuntu-latest diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index 19ad77d3932..d22da8e481a 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -2,16 +2,31 @@ name: "Code scanning - action" on: push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' schedule: - cron: '0 12 * * 4' +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + jobs: CodeQL-Build: # CodeQL runs on ubuntu-latest and windows-latest runs-on: ubuntu-latest + env: + enable_install_doc: no + steps: - name: Install libraries run: | @@ -22,6 +37,11 @@ jobs: - name: Checkout repository uses: actions/checkout@v2 + - uses: actions/cache@v2 + with: + path: .downloaded-cache + key: downloaded-cache + - name: Remove an obsolete rubygems vendored file run: sudo rm /usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb @@ -30,6 +50,9 @@ jobs: with: config-file: ./.github/codeql/codeql-config.yml + - name: Set ENV + run: echo "GNUMAKEFLAGS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV + - name: Autobuild uses: github/codeql-action/autobuild@v1 diff --git a/.github/workflows/compilers.yml b/.github/workflows/compilers.yml index 6ddfba05dbc..2c2b6598f76 100644 --- a/.github/workflows/compilers.yml +++ b/.github/workflows/compilers.yml @@ -1,6 +1,20 @@ name: Compilations -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} # Github actions does not support YAML anchors. This creative use of # environment variables (plus the "echo $GITHUB_ENV" hack) is to reroute that @@ -167,6 +181,7 @@ jobs: # - { key: cppflags, name: VM_DEBUG_VERIFY_METHOD_CACHE, value: '-DVM_DEBUG_VERIFY_METHOD_CACHE' } - { key: cppflags, name: MJIT_FORCE_ENABLE, value: '-DMJIT_FORCE_ENABLE' } + - { key: cppflags, name: YJIT_FORCE_ENABLE, value: '-DYJIT_FORCE_ENABLE' } name: ${{ matrix.entry.name }} runs-on: ubuntu-latest @@ -185,6 +200,10 @@ jobs: - uses: actions/checkout@v2 with: path: src + - uses: actions/cache@v2 + with: + path: src/.downloaded-cache + key: downloaded-cache - run: ./autogen.sh working-directory: src - name: Run configure @@ -199,7 +218,7 @@ jobs: - run: make test - run: make install if: ${{ matrix.entry.check }} - - run: /usr/local/bin/gem install --no-doc timezone tzinfo + - run: make prepare-gems if: ${{ matrix.entry.check }} - run: make test-tool if: ${{ matrix.entry.check }} diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml deleted file mode 100644 index 0a2d7ea73b8..00000000000 --- a/.github/workflows/macos.yml +++ /dev/null @@ -1,61 +0,0 @@ -name: macOS -on: [push, pull_request] -jobs: - make: - runs-on: macos-latest - strategy: - matrix: - test_task: [ "check", "test-bundler-parallel" ] #, "test-bundled-gems" ] matrix tests has unknown issues - fail-fast: false - env: - GITPULLOPTIONS: --no-tags origin ${{github.ref}} - steps: - - run: mkdir build - working-directory: - - name: git config - run: | - git config --global advice.detachedHead 0 - git config --global init.defaultBranch garbage - - uses: actions/checkout@v2 - with: - path: src - - name: Install libraries - run: | - brew upgrade - brew install gmp libffi openssl@1.1 zlib autoconf automake libtool readline - working-directory: src - - name: Set ENV - run: | - echo "JOBS=-j$((1 + $(sysctl -n hw.activecpu)))" >> $GITHUB_ENV - - run: ./autogen.sh - working-directory: src - - name: Run configure - run: ../src/configure -C --disable-install-doc --with-openssl-dir=$(brew --prefix openssl@1.1) --with-readline-dir=$(brew --prefix readline) - - run: make $JOBS incs - - run: make $JOBS - - run: make leaked-globals - if: ${{ matrix.test_task == 'check' }} - - run: make prepare-gems - if: ${{ matrix.test_task == 'check' }} - - run: make $JOBS -s ${{ matrix.test_task }} - timeout-minutes: 60 - env: - RUBY_TESTOPTS: "-q --tty=no" - TEST_BUNDLED_GEMS_ALLOW_FAILURES: "rexml" - - uses: k0kubun/action-slack@v2.0.0 - with: - payload: | - { - "ci": "GitHub Actions", - "env": "${{ github.workflow }} / ${{ matrix.test_task }}", - "url": "https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}", - "commit": "${{ github.sha }}", - "branch": "${{ github.ref }}".split('/').reverse()[0] - } - env: - SLACK_WEBHOOK_URL: ${{ secrets.SIMPLER_ALERTS_URL }} # ruby-lang slack: ruby/simpler-alerts-bot - if: ${{ failure() && github.event_name == 'push' }} - -defaults: - run: - working-directory: build diff --git a/.github/workflows/mingw.yml b/.github/workflows/mingw.yml index d98f532cd72..c2db3df1ade 100644 --- a/.github/workflows/mingw.yml +++ b/.github/workflows/mingw.yml @@ -1,12 +1,27 @@ name: MinGW -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} # Notes: # Actions console encoding causes issues, see test-all & test-spec steps # jobs: make: - runs-on: windows-2019 + runs-on: windows-2022 + name: ${{ github.workflow }} (${{ matrix.msystem }}) env: MSYSTEM: ${{ matrix.msystem }} MSYS2_ARCH: x86_64 @@ -39,68 +54,58 @@ jobs: - uses: actions/checkout@v2 with: path: src + - uses: actions/cache@v2 + with: + path: src/.downloaded-cache + key: downloaded-cache - name: Set up Ruby & MSYS2 - uses: MSP-Greg/setup-ruby-pkgs@ucrt + uses: MSP-Greg/ruby-setup-ruby@win-ucrt-1 with: ruby-version: ${{ matrix.base_ruby }} - setup-ruby-ref: MSP-Greg/ruby-setup-ruby/00-win-ucrt - mingw: _upgrade_ gmp libffi libyaml openssl ragel readline gcc - msys2: automake1.16 bison + - name: set env + run: | + echo "GNUMAKEFLAGS=-j$((2 * NUMBER_OF_PROCESSORS))" >> $GITHUB_ENV + echo "TEST_JOBS=$((15 * NUMBER_OF_PROCESSORS / 10))" >> $GITHUB_ENV + - name: where check run: | # show where - Write-Host - $where = 'gcc.exe', 'ragel.exe', 'make.exe', 'bison.exe', 'libcrypto-1_1-x64.dll', 'libssl-1_1-x64.dll' - foreach ($e in $where) { - $rslt = where.exe $e 2>&1 | Out-String - if ($rslt.contains($e)) { Write-Host $rslt } - else { Write-Host "`nCan't find $e" } - } - - name: misc setup, autoreconf + result=true + for e in gcc.exe ragel.exe make.exe bison.exe libcrypto-1_1-x64.dll libssl-1_1-x64.dll; do + echo '##['group']'$'\033[93m'$e$'\033[m' + where $e || result=false + echo '##['endgroup']' + done + $result + + - name: autogen run: | - mkdir install - mkdir temp - cd src - sh -c "autoreconf -fi" - working-directory: + ./autogen.sh + working-directory: src - name: configure - run: | - # Actions uses UTF8, causes test failures, similar to normal OS setup - $PSDefaultParameterValues['*:Encoding'] = 'utf8' - [Console]::OutputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - [Console]::InputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - $config_args = "--build=$env:CHOST --host=$env:CHOST --target=$env:CHOST" - Write-Host $config_args - sh -c "../src/configure --disable-install-doc --prefix=/install $config_args" - # Write-Host "-------------------------------------- config.log" - # Get-Content ./config.log | foreach {Write-Output $_} + run: > + ../src/configure --disable-install-doc --prefix=/. + --build=$CHOST --host=$CHOST --target=$CHOST - name: update run: | - $jobs = [int](2 * $env:NUMBER_OF_PROCESSORS) - make -j $jobs incs + make incs - name: download gems run: | - $jobs = [int](2 * $env:NUMBER_OF_PROCESSORS) - make -j $jobs update-gems + make update-gems - name: make all - timeout-minutes: 40 + timeout-minutes: 20 run: | - $jobs = [int](2 * $env:NUMBER_OF_PROCESSORS) - make -j $jobs + make - run: make leaked-globals - name: make install run: | - # Actions uses UTF8, causes test failures, similar to normal OS setup - $PSDefaultParameterValues['*:Encoding'] = 'utf8' - [Console]::OutputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - [Console]::InputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - make DESTDIR=.. install-nodoc + make DESTDIR=../install install-nodoc - name: test timeout-minutes: 5 @@ -108,27 +113,19 @@ jobs: make test - name: test-all - timeout-minutes: 60 + timeout-minutes: 45 run: | # Actions uses UTF8, causes test failures, similar to normal OS setup - $PSDefaultParameterValues['*:Encoding'] = 'utf8' - [Console]::OutputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - [Console]::InputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - $jobs = [int](1.5 * $env:NUMBER_OF_PROCESSORS) - if ($env:BUNDLER_VERSION) { Remove-Item env:\BUNDLER_VERSION } - make test-all TESTOPTS="-j $jobs --retry --job-status=normal --show-skip --timeout-scale=1.5" + chcp.com 437 + make test-all + env: + RUBY_TESTOPTS: -j${{env.TEST_JOBS}} --retry --job-status=normal --show-skip --timeout-scale=1.5 + BUNDLER_VERSION: - name: test-spec timeout-minutes: 10 - working-directory: src/spec/ruby run: | - $env:Path = "$pwd/../../../install/bin;$env:Path" - # Actions uses UTF8, causes test failures, similar to normal OS setup - $PSDefaultParameterValues['*:Encoding'] = 'utf8' - [Console]::OutputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - [Console]::InputEncoding = [System.Text.Encoding]::GetEncoding("IBM437") - ruby -v - ruby ../mspec/bin/mspec -I../../tool/lib -j --timeout 60 + make test-spec - uses: k0kubun/action-slack@v2.0.0 with: @@ -147,3 +144,4 @@ jobs: defaults: run: working-directory: build + shell: sh diff --git a/.github/workflows/mjit.yml b/.github/workflows/mjit.yml index 63011e78d0c..8b0011ec378 100644 --- a/.github/workflows/mjit.yml +++ b/.github/workflows/mjit.yml @@ -1,5 +1,20 @@ name: MJIT -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + jobs: make: strategy: @@ -27,6 +42,10 @@ jobs: - uses: actions/checkout@v2 with: path: src + - uses: actions/cache@v2 + with: + path: src/.downloaded-cache + key: downloaded-cache - name: Fixed world writable dirs run: | chmod -v go-w $HOME $HOME/.config @@ -34,29 +53,29 @@ jobs: sudo bash -c 'IFS=:; for d in '"$PATH"'; do chmod -v go-w $d; done' || : - name: Set ENV run: | - echo "JOBS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV + echo "GNUMAKEFLAGS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV - run: ./autogen.sh working-directory: src - name: Run configure run: ../src/configure -C --disable-install-doc cppflags=-DVM_CHECK_MODE - - run: make $JOBS incs - - run: make $JOBS - - run: sudo make $JOBS -s install + - run: make incs + - run: make + - run: sudo make -s install - run: sudo apt-get install gdb # used by test / test-all failure - name: Run test run: | ulimit -c unlimited - make $JOBS -s test RUN_OPTS="$RUN_OPTS" + make -s test RUN_OPTS="$RUN_OPTS" timeout-minutes: 60 - name: Run test-all run: | ulimit -c unlimited - make $JOBS -s test-all RUN_OPTS="$RUN_OPTS" + make -s test-all RUN_OPTS="$RUN_OPTS" timeout-minutes: 60 - name: Run test-spec run: | ulimit -c unlimited - make $JOBS -s test-spec RUN_OPTS="$RUN_OPTS" + make -s test-spec RUN_OPTS="$RUN_OPTS" timeout-minutes: 60 - uses: k0kubun/action-slack@v2.0.0 with: diff --git a/.github/workflows/spec_guards.yml b/.github/workflows/spec_guards.yml index 61ebeb33c1e..79ef8a6cc0d 100644 --- a/.github/workflows/spec_guards.yml +++ b/.github/workflows/spec_guards.yml @@ -1,6 +1,20 @@ name: Rubyspec Version Guards Check -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} jobs: rubyspec: diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml index e148b76cbec..e63e12ac0ed 100644 --- a/.github/workflows/ubuntu.yml +++ b/.github/workflows/ubuntu.yml @@ -1,5 +1,20 @@ name: Ubuntu -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + jobs: make: strategy: @@ -10,6 +25,9 @@ jobs: # - ubuntu-18.04 configure: ["", "cppflags=-DRUBY_DEBUG"] include: + - test_task: "check" + os: ubuntu-20.04 + configure: "--host=i686-$OSTYPE" - test_task: "test-all TESTS=--repeat-count=2" os: ubuntu-20.04 configure: "" @@ -21,11 +39,26 @@ jobs: steps: - run: mkdir build working-directory: + - name: Set ENV + env: + configure: ${{matrix.configure}} + run: | + echo "GNUMAKEFLAGS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV + arch=`echo " $configure" | sed '/.* --host=/!d;s///;s/[- ].*//'` + echo "SETARCH=${arch:+setarch $arch}" >> $GITHUB_ENV - name: Install libraries run: | set -x + arch="${SETARCH##* }" + arch=${arch:+:${arch/i[3-6]86/i386}} + ${arch:+sudo dpkg --add-architecture ${arch#:}} sudo apt-get update -q || : - sudo apt-get install --no-install-recommends -q -y build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev bison autoconf ruby + sudo apt-get install --no-install-recommends -q -y \ + ${arch:+cross}build-essential${arch/:/-} \ + libssl-dev${arch} libyaml-dev${arch} libreadline6-dev${arch} \ + zlib1g-dev${arch} libncurses5-dev${arch} libffi-dev${arch} \ + bison autoconf ruby + sudo apt-get install -q -y pkg-config${arch} || : - name: git config run: | git config --global advice.detachedHead 0 @@ -33,33 +66,49 @@ jobs: - uses: actions/checkout@v2 with: path: src + - uses: actions/cache@v2 + with: + path: src/.downloaded-cache + key: downloaded-cache - name: Fixed world writable dirs run: | chmod -v go-w $HOME $HOME/.config sudo chmod -R go-w /usr/share sudo bash -c 'IFS=:; for d in '"$PATH"'; do chmod -v go-w $d; done' || : - - name: Set ENV - run: | - echo "JOBS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV - run: ./autogen.sh working-directory: src - name: Run configure - run: ../src/configure -C --disable-install-doc ${{ matrix.configure }} - - run: make $JOBS incs - - run: make $JOBS - - run: make leaked-globals + env: + arch: ${{matrix.arch}} + run: >- + $SETARCH ../src/configure -C --disable-install-doc ${{ matrix.configure }} + ${arch:+--target=$arch-$OSTYPE} + - run: $SETARCH make incs + - run: $SETARCH make + - run: $SETARCH make leaked-globals if: ${{ matrix.test_task == 'check' }} - - run: make prepare-gems + - run: $SETARCH make prepare-gems if: ${{ matrix.test_task == 'check' }} - name: Create dummy files in build dir run: | - ./miniruby -e '(("a".."z").to_a+("A".."Z").to_a+("0".."9").to_a+%w[foo bar test zzz]).each{|basename|File.write("#{basename}.rb", "raise %(do not load #{basename}.rb)")}' + $SETARCH ./miniruby -e '(("a".."z").to_a+("A".."Z").to_a+("0".."9").to_a+%w[foo bar test zzz]).each{|basename|File.write("#{basename}.rb", "raise %(do not load #{basename}.rb)")}' if: ${{ matrix.test_task == 'check' }} - - run: make $JOBS -s ${{ matrix.test_task }} - timeout-minutes: 30 + - name: make ${{ matrix.test_task }} + run: | + $SETARCH make -s ${{ matrix.test_task }} ${TESTS:+TESTS=`echo "$TESTS" | sed 's| |$/ -n!/|g;s|^|-n!/|;s|$|$$/|'`} + timeout-minutes: 40 env: RUBY_TESTOPTS: "-q --tty=no" + TESTS: ${{ matrix.test_task == 'check' && matrix.skipped_tests || '' }} TEST_BUNDLED_GEMS_ALLOW_FAILURES: "" + - name: make skipped tests + run: | + $SETARCH make -s test-all TESTS=`echo "$TESTS" | sed 's| |$/ -n/|g;s|^|-n/|;s|$|$$/|'` + env: + GNUMAKEFLAGS: "" + RUBY_TESTOPTS: "-v --tty=no" + TESTS: ${{ matrix.skipped_tests }} + if: ${{ matrix.test_task == 'check' && matrix.skipped_tests != '' }} - uses: k0kubun/action-slack@v2.0.0 with: payload: | diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index 66b29920491..60f9b760eca 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -1,5 +1,20 @@ name: Windows -on: [push, pull_request] +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + jobs: make: strategy: @@ -10,7 +25,7 @@ jobs: vcvars: '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"' # - vs: 2022 # os: windows-2022 - # vcvars: '"C:\Program Files\Microsoft Visual Studio\2022\Preview\VC\Auxiliary\Build\vcvars64.bat"' + # vcvars: '"C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"' fail-fast: false runs-on: ${{ matrix.os }} name: VisualStudio ${{ matrix.vs }} @@ -65,6 +80,10 @@ jobs: - uses: actions/checkout@v2 with: path: src + - uses: actions/cache@v2 + with: + path: src/.downloaded-cache + key: downloaded-cache - name: setup env # %TEMP% is inconsistent with %TMP% and test-all expects they are consistent. # https://github.com/actions/virtual-environments/issues/712#issuecomment-613004302 @@ -73,36 +92,27 @@ jobs: call %VCVARS% set TMP=%USERPROFILE%\AppData\Local\Temp set TEMP=%USERPROFILE%\AppData\Local\Temp + set /a TEST_JOBS=(15 * %NUMBER_OF_PROCESSORS% / 10) > nul set | C:\msys64\usr\bin\sort > new.env C:\msys64\usr\bin\comm -13 old.env new.env >> %GITHUB_ENV% del *.env - name: Configure run: | ../src/win32/configure.bat --disable-install-doc --enable-bundled-libffi --with-opt-dir=C:/vcpkg/installed/x64-windows --with-openssl-dir="C:/Program Files/OpenSSL-Win64" - - name: nmake - run: | - echo ^#^#[group]incs - nmake incs - echo ^#^#[endgroup] - echo ^#^#[group]extract-extlibs - nmake extract-extlibs - echo ^#^#[endgroup] - nmake + - run: nmake incs + - run: nmake extract-extlibs + - run: nmake env: YACC: win_bison - - name: nmake test + - run: nmake test timeout-minutes: 5 - run: | - nmake test - - name: nmake test-all + - run: nmake test-all + env: + RUBY_TESTOPTS: -j${{env.TEST_JOBS}} --job-status=normal timeout-minutes: 60 - run: | - nmake test-all TESTOPTS="-j%NUMBER_OF_PROCESSORS% --job-status=normal" continue-on-error: ${{ matrix.continue-on-error || false }} - - name: nmake test-spec + - run: nmake test-spec timeout-minutes: 10 - run: | - nmake test-spec continue-on-error: ${{ matrix.continue-on-error || false }} - uses: k0kubun/action-slack@v2.0.0 with: diff --git a/.github/workflows/yjit-ubuntu.yml b/.github/workflows/yjit-ubuntu.yml new file mode 100644 index 00000000000..966f9fd1c70 --- /dev/null +++ b/.github/workflows/yjit-ubuntu.yml @@ -0,0 +1,111 @@ +name: YJIT Ubuntu +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + +jobs: + make: + strategy: + matrix: + test_task: ["check"] # "test-bundler-parallel", + os: + - ubuntu-20.04 +# - ubuntu-18.04 + yjit_opts: [ + "--yjit", + "--yjit --yjit-call-threshold=1", + ] + configure: ["", "cppflags=-DRUBY_DEBUG"] + include: + - test_task: "test-all TESTS=--repeat-count=2" + os: ubuntu-20.04 + configure: "" + yjit_enable_env: RUBY_YJIT_ENABLE + - test_task: "test-bundled-gems" + os: ubuntu-20.04 + configure: "cppflags=-DRUBY_DEBUG" + yjit_enable_env: RUBY_YJIT_ENABLE + fail-fast: false + env: + GITPULLOPTIONS: --no-tags origin ${{github.ref}} + RUN_OPTS: ${{ matrix.yjit_opts }} + RUBY_DEBUG: ci + runs-on: ${{ matrix.os }} + steps: + - run: mkdir build + working-directory: + - name: Install libraries + run: | + set -x + sudo apt-get update -q || : + sudo apt-get install --no-install-recommends -q -y build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev bison autoconf ruby + - name: git config + run: | + git config --global advice.detachedHead 0 + git config --global init.defaultBranch garbage + - uses: actions/checkout@v2 + with: + path: src + - uses: actions/cache@v2 + with: + path: src/.downloaded-cache + key: downloaded-cache + - name: Fixed world writable dirs + run: | + chmod -v go-w $HOME $HOME/.config + sudo chmod -R go-w /usr/share + sudo bash -c 'IFS=:; for d in '"$PATH"'; do chmod -v go-w $d; done' || : + - name: Set ENV + run: | + echo "GNUMAKEFLAGS=-j$((1 + $(nproc --all)))" >> $GITHUB_ENV + - run: ./autogen.sh + working-directory: src + - name: Run configure + run: ../src/configure -C --disable-install-doc ${{ matrix.configure }} + - run: make incs + - run: make + - run: make leaked-globals + if: ${{ matrix.test_task == 'check' }} + - run: make prepare-gems + if: ${{ matrix.test_task == 'check' }} + - name: Create dummy files in build dir + run: | + ./miniruby -e '(("a".."z").to_a+("A".."Z").to_a+("0".."9").to_a+%w[foo bar test zzz]).each{|basename|File.write("#{basename}.rb", "raise %(do not load #{basename}.rb)")}' + if: ${{ matrix.test_task == 'check' }} + - name: Enable YJIT through ENV + run: echo "RUBY_YJIT_ENABLE=1" >> $GITHUB_ENV + if: ${{ matrix.yjit_enable_env }} + - run: make -s ${{ matrix.test_task }} RUN_OPTS="$RUN_OPTS" + timeout-minutes: 60 + env: + RUBY_TESTOPTS: "-q --tty=no" + TEST_BUNDLED_GEMS_ALLOW_FAILURES: "" + - uses: k0kubun/action-slack@v2.0.0 + with: + payload: | + { + "ci": "GitHub Actions", + "env": "${{ matrix.os }} / ${{ matrix.test_task }}${{ matrix.configure }}", + "url": "https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}", + "commit": "${{ github.sha }}", + "branch": "${{ github.ref }}".split('/').reverse()[0] + } + env: + SLACK_WEBHOOK_URL: ${{ secrets.SIMPLER_ALERTS_URL }} # ruby-lang slack: ruby/simpler-alerts-bot + if: ${{ failure() && github.event_name == 'push' }} + +defaults: + run: + working-directory: build diff --git a/.github/workflows/yjit_asm_tests.yml b/.github/workflows/yjit_asm_tests.yml new file mode 100644 index 00000000000..58f294f1374 --- /dev/null +++ b/.github/workflows/yjit_asm_tests.yml @@ -0,0 +1,37 @@ +name: YJIT x86 assembler tests + +on: + push: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + pull_request: + paths-ignore: + - 'doc/**' + - '**.md' + - '**.rdoc' + +concurrency: + group: ${{ github.workflow }} / ${{ startsWith(github.event_name, 'pull') && github.ref_name || github.sha }} + cancel-in-progress: ${{ startsWith(github.event_name, 'pull') }} + +jobs: + test: + runs-on: ubuntu-latest + steps: + - name: Install dependencies + run: | + set -x + sudo apt-get update -q || : + sudo apt-get install --no-install-recommends -q -y build-essential + - name: git config + run: | + git config --global advice.detachedHead 0 + git config --global init.defaultBranch garbage + - uses: actions/checkout@v2 + with: + path: src + - name: Run ASM tests + run: ./misc/test_yjit_asm.sh + working-directory: src diff --git a/.gitignore b/.gitignore index 8d11d7278af..31bfd787a70 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ *.dylib *.elc *.i +*.ii *.inc *.log *.o @@ -182,6 +183,9 @@ lcov*.info /ext/-test-/win32/dln/dlntest.exp /ext/-test-/win32/dln/dlntest.lib +# /ext/-test-/gems +/ext/-test-/gems + # /ext/etc/ /ext/etc/constdefs.h diff --git a/.travis.yml b/.travis.yml index c84cb1a6d7f..eb816b815ba 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,6 +26,10 @@ cache: env: global: + # The tests skipped in `make test-all`. + - TEST_ALL_SKIPPED_TESTS= + # The tests executed separately by `make test-all`. + - TEST_ALL_SEPARATED_TESTS= # Reset timestamps early - _=$(touch NEWS && find . -type f -exec touch -r NEWS {} +) - CONFIGURE_TTY=no @@ -38,12 +42,6 @@ env: - SETARCH= - RUBY_PREFIX=/tmp/ruby-prefix - GEMS_FOR_TEST='timezone tzinfo' - # The tests skipped in `make test-all`. - - TEST_ALL_SKIPPED_TESTS= - # Run the separated tests with allowing failures. - - RUN_SEPARATED_TESTS=true - # The tests executed separately by `make test-all`. - - TEST_ALL_SEPARATED_TESTS= # https://github.com/travis-ci/travis-build/blob/e411371dda21430a60f61b8f3f57943d2fe4d344/lib/travis/build/bash/travis_apt_get_options.bash#L7 - travis_apt_get_options='--allow-downgrades --allow-remove-essential --allow-change-held-packages' - travis_apt_get_options="-yq --no-install-suggests --no-install-recommends $travis_apt_get_options" @@ -97,6 +95,9 @@ env: compiler: arm-linux-gnueabihf-gcc env: - SETARCH='setarch linux32 --verbose --32bit' + # The "TestReadline#test_interrupt_in_other_thread" started failing on arm32 + # from https://www.travis-ci.com/github/ruby/ruby/jobs/529005145 + - TEST_ALL_SKIPPED_TESTS=test_interrupt_in_other_thread before_install: - sudo dpkg --add-architecture armhf - tool/travis_retry.sh sudo bash -c "rm -rf '${TRAVIS_ROOT}/var/lib/apt/lists/'* && exec apt-get update -yq" @@ -119,12 +120,15 @@ matrix: include: # Build every commit (Allowed Failures): - <<: *arm32-linux - - <<: *arm64-linux + # Comment out as the 2nd arm64 pipeline is unstable. + # - <<: *arm64-linux - <<: *ppc64le-linux - <<: *s390x-linux allow_failures: - # The "TestReadline#test_interrupt_in_other_thread" started failing on arm32 - # from https://www.travis-ci.com/github/ruby/ruby/jobs/529005145 + # We see multiple errors indicating errors on the Travis environment itself in a short while: + # https://app.travis-ci.com/github/ruby/ruby/jobs/544382885 + # https://app.travis-ci.com/github/ruby/ruby/jobs/544361370 + # It's not a fault of Ruby's arm32 support but just Travis arm32 seems unsable. - name: arm32-linux # - name: arm64-linux # We see "Some worker was crashed." in about 40% of recent ppc64le-linux jobs @@ -199,7 +203,7 @@ script: # Run the failing tests separately returning ok status to check if it works, # visualize them. - | - if [ "${RUN_SEPARATED_TESTS}" = true -a -n "${TEST_ALL_OPTS_SEPARATED}" ]; then + if [ -n "${TEST_ALL_OPTS_SEPARATED}" ]; then $SETARCH make -s test-all -o exts TESTOPTS="$JOBS -v --tty=no ${TEST_ALL_OPTS_SEPARATED}" RUBYOPT="-w" || : fi - $SETARCH make -s test-spec MSPECOPT=-ff # not using `-j` because sometimes `mspec -j` silently dies @@ -969,6 +969,43 @@ mentioned below. {MIT License}[rdoc-label:label-MIT+License] +[lib/bundler/vendor/thor] + + Thor is under the following license. + + >>> + Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al. + + {MIT License}[rdoc-label:label-MIT+License] + +[lib/rubygems/resolver/molinillo] +[lib/bundler/vendor/molinillo] + + molinillo is under the following license. + + >>> + Copyright (c) 2014 Samuel E. Giddins segiddins@segiddins.me + + {MIT License}[rdoc-label:label-MIT+License] + +[lib/bundler/vendor/connection_pool] + + connection_pool is under the following license. + + >>> + Copyright (c) 2011 Mike Perham + + {MIT License}[rdoc-label:label-MIT+License] + +[lib/bundler/vendor/net-http-persistent] + + net-http-persistent is under the following license. + + >>> + Copyright (c) Eric Hodel, Aaron Patterson + + {MIT License}[rdoc-label:label-MIT+License] + [lib/did_you_mean] [lib/did_you_mean.rb] [test/did_you_mean] @@ -7,15 +7,24 @@ Note that each entry is kept to a minimum, see links for details. ## Language changes -* Pin operator now takes an expression. [[Feature #17411]] +* The block arguments can be now be anonymous, if the block will + only be passed to another method. [[Feature #11256]] + + ```ruby + def foo(&) + bar(&) + end + ``` + +* Pin operator now takes an expression. [[Feature #17411]] ```ruby Prime.each_cons(2).lazy.find_all{_1 in [n, ^(n + 2)]}.take(3).to_a #=> [[3, 5], [5, 7], [11, 13]] ``` -* Pin operator now supports instance, class, and global variables. - [[Feature #17724]] +* Pin operator now supports instance, class, and global variables. + [[Feature #17724]] ```ruby @n = 5 @@ -23,11 +32,11 @@ Note that each entry is kept to a minimum, see links for details. #=> [3, 5] ``` -* One-line pattern matching is no longer experimental. +* One-line pattern matching is no longer experimental. -* Multiple assignment evaluation order has been made consistent with - single assignment evaluation order. With single assignment, Ruby - uses a left-to-right evaluation order. With this code: +* Multiple assignment evaluation order has been made consistent with + single assignment evaluation order. With single assignment, Ruby + uses a left-to-right evaluation order. With this code: ```ruby foo[0] = bar @@ -42,9 +51,9 @@ Note that each entry is kept to a minimum, see links for details. In Ruby before 3.1.0, multiple assignment did not follow this evaluation order. With this code: - ```ruby - foo[0], bar.baz = a, b - ``` + ```ruby + foo[0], bar.baz = a, b + ``` Versions of Ruby before 3.1.0 would evaluate in the following order @@ -69,18 +78,22 @@ Note that each entry is kept to a minimum, see links for details. [[Bug #4443]] -* Values in Hash literals and keyword arguments can be omitted. - [[Feature #14579]] +* Values in Hash literals and keyword arguments can be omitted. + [[Feature #14579]] - For example, + For example, * `{x:, y:}` is a syntax sugar of `{x: x, y: y}`. * `foo(x:, y:)` is a syntax sugar of `foo(x: x, y: y)`. - Constant names, local variable names, and method names are allowed as - key names. Note that a reserved word is considered as a local - variable or method name even if it's a pseudo variable name such as - `self`. + Constant names, local variable names, and method names are allowed as + key names. Note that a reserved word is considered as a local + variable or method name even if it's a pseudo variable name such as + `self`. + +* non main-Ractors can get instance variables (ivars) of classes/modules + if ivars refer to shareable objects. + [[Feature #17592]] ## Command line options @@ -92,88 +105,240 @@ Outstanding ones only. * Array#intersect? is added. [[Feature #15198]] +* Class + + * Class#descendants, which returns an array of classes + directly or indirectly inheriting from the receiver, not + including the receiver or singleton classes. + [[Feature #14394]] + + ```ruby + class A; end + class B < A; end + class C < B; end + A.descendants #=> [B, C] + B.descendants #=> [C] + C.descendants #=> [] + ``` + + * Class#subclasses, which returns an array of classes + directly inheriting from the receiver, not + including singleton classes. + [[Feature #18273]] + + ```ruby + class A; end + class B < A; end + class C < B; end + class D < A; end + A.subclasses #=> [D, B] + B.subclasses #=> [C] + C.subclasses #=> [] + ``` + * Enumerable - * Enumerable#compact is added. [[Feature #17312]] + * Enumerable#compact is added. [[Feature #17312]] + + * Enumerable#tally now accepts an optional hash to count. [[Feature #17744]] + + * Enumerable#each_cons and each_slice to return a receiver. [[GH-1509]] + + ```ruby + [1, 2, 3].each_cons(2){} + # 3.0 => nil + # 3.1 => [1, 2, 3] - * Enumerable#tally now accepts an optional hash to count. [[Feature #17744]] + [1, 2, 3].each_slice(2){} + # 3.0 => nil + # 3.1 => [1, 2, 3] + ``` * Enumerator::Lazy - * Enumerator::Lazy#compact is added. [[Feature #17312]] + * Enumerator::Lazy#compact is added. [[Feature #17312]] * File - * File.dirname now accepts an optional argument for the level to - strip path components. [[Feature #12194]] + * File.dirname now accepts an optional argument for the level to + strip path components. [[Feature #12194]] + +* GC + + * "GC.measure_total_time = true" enables the measurement of GC. + Measurement can introduce overhead. It is enabled by default. + GC.measure_total_time returns the current setting. + GC.stat[:time] or GC.stat(:time) returns measured time + in milli-soconds. + + * GC.total_time returns measured time in nano-seconds. * Integer - * Integer.try_convert is added. [[Feature #15211]] + * Integer.try_convert is added. [[Feature #15211]] + +* Kernel + + + * Kernel#load now accepts a module as the second argument, + and will load the file using the given module as the top + level module. [[Feature #6210]] * MatchData - * MatchData#match is added [[Feature #18172]] + * MatchData#match is added [[Feature #18172]] - * MatchData#match_length is added [[Feature #18172]] + * MatchData#match_length is added [[Feature #18172]] * Module - * Module#prepend now modifies the ancestor chain if the receiver - already includes the argument. Module#prepend still does not - modify the ancestor chain if the receiver has already prepended - the argument. [[Bug #17423]] + * Module#prepend now modifies the ancestor chain if the receiver + already includes the argument. Module#prepend still does not + modify the ancestor chain if the receiver has already prepended + the argument. [[Bug #17423]] + + * Module#private, #public, #protected, and #module_function will + now return their arguments. If a single argument is given, it + is returned. If no arguments are given, nil is returned. If + multiple arguments are given, they are returned as an array. + [[Feature #12495]] + +* Process + + * Process.\_fork is added. This is a core method for fork(2). + Do not call this method directly; it is called by existing + fork methods: Kernel.#fork, Process.fork, and IO.popen("-"). + Application monitoring libraries can overwride this method to + hook fork event. [[Feature #17795]] * Struct - * Passing only keyword arguments to Struct#initialize is warned. - You need to use a Hash literal to set a Hash to a first member. - [[Feature #16806]] + * Passing only keyword arguments to Struct#initialize is warned. + You need to use a Hash literal to set a Hash to a first member. + [[Feature #16806]] - * StructClass#keyword_init? is added [[Feature #18008]] + * StructClass#keyword_init? is added [[Feature #18008]] * String - * Update Unicode version to 13.0.0 [[Feature #17750]] - and Emoji version to 13.0 [[Feature #18029]] + * Update Unicode version to 13.0.0 [[Feature #17750]] + and Emoji version to 13.0 [[Feature #18029]] * Queue - * Queue#initialize now accepts an Enumerable of initial values. - [[Feature #17327]] + * Queue#initialize now accepts an Enumerable of initial values. + [[Feature #17327]] * Thread - * Thread#native_thread_id is added. [[Feature #17853]] + * Thread#native_thread_id is added. [[Feature #17853]] * Thread::Backtrace - * Thread::Backtrace.limit, which returns the value to limit backtrace - length set by `--backtrace-limit` command line option, is added. - [[Feature #17479]] + * Thread::Backtrace.limit, which returns the value to limit backtrace + length set by `--backtrace-limit` command line option, is added. + [[Feature #17479]] * $LOAD_PATH - * $LOAD_PATH.resolve_feature_path does not raise. [[Feature #16043]] + * $LOAD_PATH.resolve_feature_path does not raise. [[Feature #16043]] * Fiber Scheduler - * Add support for `Addrinfo.getaddrinfo` using `address_resolve` hook. - [[Feature #17370]] + * Add support for `Addrinfo.getaddrinfo` using `address_resolve` hook. + [[Feature #17370]] + + * Introduce non-blocking `Timeout.timeout` using `timeout_after` hook. + [[Feature #17470]] - * Introduce non-blocking `Timeout.timeout` using `timeout_after` hook. - [[Feature #17470]] + * Introduce new scheduler hooks `io_read` and `io_write` along with a + low level `IO::Buffer` for zero-copy read/write. [[Feature #18020]] - * IO hooks `io_wait`, `io_read`, `io_write`, receive the original IO object - where possible. [[Bug #18003]] + * IO hooks `io_wait`, `io_read`, `io_write`, receive the original IO object + where possible. [[Bug #18003]] - * Make `Monitor` fiber-safe. [[Bug #17827]] + * Make `Monitor` fiber-safe. [[Bug #17827]] - * Replace copy coroutine with pthread implementation. [[Feature #18015]] + * Replace copy coroutine with pthread implementation. [[Feature #18015]] + +* Refinement + + * New class which represents a module created by Module#refine. + `include` and `prepend` are deprecated, and `import_methods` is added + instead. [[Bug #17429]] ## Stdlib updates -Outstanding ones only. +* The following default gem are updated. + * RubyGems + * Bundler + * RDoc 6.3.2 + * ReLine + * JSON 2.6.1 + * Psych 4.0.2 + * FileUtils 1.6.0 + * Fiddle 1.1.0 + * StringIO 3.0.1 + * IO::Console 0.5.9 + * IO::Wait 0.2.0 + * CSV 3.2.1 + * Etc 1.3.0 + * Date 3.2.2 + * Zlib 2.1.1 + * StringScanner 3.0.1 + * IpAddr 1.2.3 + * Logger 1.4.4 + * OStruct 0.5.0 + * Irb + * Racc 1.6.0 + * Delegate 0.2.0 + * Benchmark 0.2.0 + * CGI 0.3.1 + * Readline(C-ext) 0.1.3 + * Timeout 0.2.0 + * YAML 0.2.0 + * URI 0.11.0 + * OpenSSL + * DidYouMean + * Weakref 0.1.1 + * Tempfile 0.1.2 + * TmpDir 0.1.2 + * English 0.7.1 + * Net::Protocol 0.1.2 + * Net::Http 0.2.0 + * BigDecimal + * OptionParser 0.2.0 + * Set 1.0.2 + * Find 0.1.1 + * Rinda 0.1.1 + * Erb 2.2.3 + * NKF 0.1.1 + * Base64 0.1.1 + * OpenUri 0.2.0 + * SecureRandom 0.1.1 + * Resolv 0.2.1 + * Resolv::Replace 0.1.0 + * Time 0.2.0 + * PP 0.2.1 + * Prettyprint 0.1.1 + * Drb 2.1.0 + * Pathname 0.2.0 + * Digest 3.1.0.pre3 + * Un 0.2.0 +* The following bundled gems are updated. + * minitest 5.14.4 + * power_assert 2.0.1 + * rake 13.0.6 + * test-unit 3.5.1 + * rbs 1.8.0 + * typeprof 0.20.4 +* The following default gems are now bundled gems. + * net-ftp + * net-imap + * net-pop + * net-smtp + * matrix + * prime ## Compatibility issues @@ -189,12 +354,29 @@ Excluding feature bug fixes. * `ERB#initialize` warns `safe_level` and later arguments even without -w. [[Feature #14256]] +* `lib/debug.rb` is replaced with `debug.gem` + +* `Kernel#pp` in `lib/pp.rb` uses the width of `IO#winsize` by default. + This means that the output width is automatically changed depending on + your terminal size. [[Feature #12913]] + ## C API updates * Documented. [[GH-4815]] +* `rb_gc_force_recycle` is deprecated and has been changed to a no-op. + [[Feature #18290]] + ## Implementation improvements +* `instance_eval` and `instance_exec` now only allocate a singleton class when + required, avoiding extra objects and improving performance. [[GH-5146]] + +* The performance of `Struct` accessors is improved. [[GH-5131]] + +* `mandatory_only?` builtin special form to improve performance on + builtin methods. [[GH-5112]] + ### JIT * The default `--jit-max-cache` is changed from 100 to 10000. @@ -210,12 +392,58 @@ Excluding feature bug fixes. * `RubyVM::MJIT` is renamed to `RubyVM::JIT`. [[Feature #17490]] +### YJIT: New experimental in-process JIT compiler + +New JIT compiler available as an experimental feature. [[Feature #18229]] + +See [this blog post](https://shopify.engineering/yjit-just-in-time-compiler-cruby +) introducing the project. + +* Disabled by default, use `--yjit` command-line option to enable YJIT. + +* Performance improvements on most real-world software, up to 22% on railsbench, 39% on liquid-render. + +* Fast warm-up times. + +* Limited to macOS & Linux on x86-64 platforms for now. + ## Static analysis ### RBS ### TypeProf +* [Experimental IDE support](https://github.com/ruby/typeprof/blob/master/doc/ide.md) has been implemented. +* Many bug fixes and performance improvements since Ruby 3.0.0. + +## Debugger + +* A new debugger [debug.gem](https://github.com/ruby/debug) is bundled. + debug.gem is fast debugger implementation and it provides many features + like remote debugging, colorful REPL, IDE (VSCode) integration and more. + It replaces `lib/debug.rb` standard library. + +* `rdbg` command is also installed into `bin/` directory to start and control + debugging execution. + +## error_highlight + +A built-in gem, error_highlight, has been introduced. +It includes fine-grained error location in backtrace: + +``` +$ ruby test.rb +test.rb:1:in `<main>': undefined method `time' for 1:Integer (NoMethodError) + +1.time {} + ^^^^^ +Did you mean? times +``` + +This gem is enabled by default. +You can disable it by using a command-line option `--disable-error_highlight`. +See [the repository](https://github.com/ruby/error_highlight) in detail. + ## Miscellaneous changes * lib/objspace/trace.rb is added, which is a tool for tracing the object @@ -229,8 +457,13 @@ Excluding feature bug fixes. `$VERBOSE` is `nil`. [[Feature #17798]] [Bug #4443]: https://bugs.ruby-lang.org/issues/4443 +[Feature #6210]: https://bugs.ruby-lang.org/issues/6210 +[Feature #11256]: https://bugs.ruby-lang.org/issues/11256 [Feature #12194]: https://bugs.ruby-lang.org/issues/12194 +[Feature #12495]: https://bugs.ruby-lang.org/issues/12495 +[Feature #12913]: https://bugs.ruby-lang.org/issues/12913 [Feature #14256]: https://bugs.ruby-lang.org/issues/14256 +[Feature #14394]: https://bugs.ruby-lang.org/issues/14394 [Feature #14579]: https://bugs.ruby-lang.org/issues/14579 [Feature #15198]: https://bugs.ruby-lang.org/issues/15198 [Feature #15211]: https://bugs.ruby-lang.org/issues/15211 @@ -238,22 +471,33 @@ Excluding feature bug fixes. [Feature #16806]: https://bugs.ruby-lang.org/issues/16806 [Feature #17312]: https://bugs.ruby-lang.org/issues/17312 [Feature #17327]: https://bugs.ruby-lang.org/issues/17327 +[Feature #17370]: https://bugs.ruby-lang.org/issues/17370 [Feature #17411]: https://bugs.ruby-lang.org/issues/17411 [Bug #17423]: https://bugs.ruby-lang.org/issues/17423 +[Bug #17429]: https://bugs.ruby-lang.org/issues/17429 +[Feature #17470]: https://bugs.ruby-lang.org/issues/17470 [Feature #17479]: https://bugs.ruby-lang.org/issues/17479 [Feature #17490]: https://bugs.ruby-lang.org/issues/17490 +[Feature #17592]: https://bugs.ruby-lang.org/issues/17592 [Feature #17724]: https://bugs.ruby-lang.org/issues/17724 [Feature #17744]: https://bugs.ruby-lang.org/issues/17744 +[Feature #17750]: https://bugs.ruby-lang.org/issues/17750 [Feature #17762]: https://bugs.ruby-lang.org/issues/17762 +[Feature #17795]: https://bugs.ruby-lang.org/issues/17795 [Feature #17798]: https://bugs.ruby-lang.org/issues/17798 -[Bug #18003]: https://bugs.ruby-lang.org/issues/18003 -[Feature #17370]: https://bugs.ruby-lang.org/issues/17370 -[Feature #17470]: https://bugs.ruby-lang.org/issues/17470 -[Feature #17750]: https://bugs.ruby-lang.org/issues/17750 -[Feature #17853]: https://bugs.ruby-lang.org/issues/17853 [Bug #17827]: https://bugs.ruby-lang.org/issues/17827 +[Feature #17853]: https://bugs.ruby-lang.org/issues/17853 +[Bug #18003]: https://bugs.ruby-lang.org/issues/18003 [Feature #18008]: https://bugs.ruby-lang.org/issues/18008 [Feature #18015]: https://bugs.ruby-lang.org/issues/18015 +[Feature #18020]: https://bugs.ruby-lang.org/issues/18020 [Feature #18029]: https://bugs.ruby-lang.org/issues/18029 [Feature #18172]: https://bugs.ruby-lang.org/issues/18172 +[Feature #18229]: https://bugs.ruby-lang.org/issues/18229 +[Feature #18273]: https://bugs.ruby-lang.org/issues/18273 +[Feature #18290]: https://bugs.ruby-lang.org/issues/18290 +[GH-1509]: https://github.com/ruby/ruby/pull/1509 [GH-4815]: https://github.com/ruby/ruby/pull/4815 +[GH-5112]: https://github.com/ruby/ruby/pull/5112 +[GH-5131]: https://github.com/ruby/ruby/pull/5131 +[GH-5146]: https://github.com/ruby/ruby/pull/5146 diff --git a/README.md b/README.md index 8d23de8b7a8..15e98475e86 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ It is simple, straightforward, and extensible. * Dynamic Loading of Object Files (on some architectures) * Highly Portable (works on many Unix-like/POSIX compatible platforms as well as Windows, macOS, etc.) cf. - https://github.com/ruby/ruby/blob/master/doc/contributing.rdoc#label-Platform+Maintainers + https://github.com/ruby/ruby/blob/master/doc/maintainers.rdoc#label-Platform+Maintainers ## How to get Ruby @@ -92,7 +92,7 @@ is required. ## How to compile and install 1. If you want to use Microsoft Visual C++ to compile Ruby, read - [win32/README.win32](win32/README.win32) instead of this document. + [win32/README.win32](rdoc-ref:win32/README.win32) instead of this document. 2. Run `./autogen.sh` to generate configure, when you build the source checked out from the Git repository. @@ -164,7 +164,7 @@ to remove old configuration after installing them in such case. ## Copying -See the file [COPYING](COPYING). +See the file [COPYING](rdoc-ref:COPYING). ## Feedback @@ -178,7 +178,7 @@ Bugs should be reported at https://bugs.ruby-lang.org. Read [HowToReport] for mo ## Contributing -See the file [CONTRIBUTING.md](CONTRIBUTING.md) +See the file [CONTRIBUTING.md](rdoc-ref:CONTRIBUTING) ## The Author diff --git a/addr2line.c b/addr2line.c index d99102407dd..f660be91296 100644 --- a/addr2line.c +++ b/addr2line.c @@ -2138,7 +2138,7 @@ found_mach_header: char *strtab = file + cmd->stroff, *sname = 0; uint32_t j; uintptr_t saddr = 0; - /* kprintf("[%2d]: %x/symtab %p\n", i, cmd->cmd, p); */ + /* kprintf("[%2d]: %x/symtab %p\n", i, cmd->cmd, (void *)p); */ for (j = 0; j < cmd->nsyms; j++) { uintptr_t symsize, d; struct LP(nlist) *e = &nl[j]; @@ -514,13 +514,9 @@ rb_ary_decrement_share(VALUE shared_root) { if (shared_root) { long num = ARY_SHARED_ROOT_REFCNT(shared_root) - 1; - if (num == 0) { - rb_ary_free(shared_root); - rb_gc_force_recycle(shared_root); - } - else if (num > 0) { + if (num > 0) { ARY_SET_SHARED_ROOT_REFCNT(shared_root, num); - } + } } } @@ -3466,7 +3462,7 @@ rb_ary_bsearch_index(VALUE ary) satisfied = 1; smaller = 1; } - else if (v == Qfalse || v == Qnil) { + else if (!RTEST(v)) { smaller = 0; } else if (rb_obj_is_kind_of(v, rb_cNumeric)) { @@ -6341,7 +6337,7 @@ rb_ary_shuffle(rb_execution_context_t *ec, VALUE ary, VALUE randgen) } static VALUE -rb_ary_sample(rb_execution_context_t *ec, VALUE ary, VALUE randgen, VALUE nv, VALUE to_array) +ary_sample(rb_execution_context_t *ec, VALUE ary, VALUE randgen, VALUE nv, VALUE to_array) { VALUE result; long n, len, i, j, k, idx[10]; @@ -6471,6 +6467,12 @@ rb_ary_sample(rb_execution_context_t *ec, VALUE ary, VALUE randgen, VALUE nv, VA } static VALUE +ary_sample0(rb_execution_context_t *ec, VALUE ary) +{ + return ary_sample(ec, ary, rb_cRandom, Qfalse, Qfalse); +} + +static VALUE rb_ary_cycle_size(VALUE self, VALUE args, VALUE eobj) { long mul; @@ -6479,7 +6481,7 @@ rb_ary_cycle_size(VALUE self, VALUE args, VALUE eobj) n = RARRAY_AREF(args, 0); } if (RARRAY_LEN(self) == 0) return INT2FIX(0); - if (n == Qnil) return DBL2NUM(HUGE_VAL); + if (NIL_P(n)) return DBL2NUM(HUGE_VAL); mul = NUM2LONG(n); if (mul <= 0) return INT2FIX(0); n = LONG2FIX(mul); @@ -7344,7 +7346,7 @@ rb_ary_drop(VALUE ary, VALUE n) } result = rb_ary_subseq(ary, pos, RARRAY_LEN(ary)); - if (result == Qnil) result = rb_ary_new(); + if (NIL_P(result)) result = rb_ary_new(); return result; } @@ -7841,13 +7843,20 @@ rb_ary_deconstruct(VALUE ary) * * == Creating Arrays * - * A new array can be created by using the literal constructor - * <code>[]</code>. Arrays can contain different types of objects. For + * You can create an \Array object explicitly with: + * + * - An {array literal}[doc/syntax/literals_rdoc.html#label-Array+Literals]. + * + * You can convert certain objects to Arrays with: + * + * - \Method {Array}[Kernel.html#method-i-Array]. + * + * An \Array can contain different types of objects. For * example, the array below contains an Integer, a String and a Float: * * ary = [1, "two", 3.0] #=> [1, "two", 3.0] * - * An array can also be created by explicitly calling Array.new with zero, one + * An array can also be created by calling Array.new with zero, one * (the initial size of the Array) or two arguments (the initial size and a * default object). * @@ -8244,7 +8253,7 @@ rb_ary_deconstruct(VALUE ary) * - With string argument +field_separator+, a new string that is equivalent to * <tt>join(field_separator)</tt>. * #abbrev:: Returns a hash of unambiguous abbreviations for elements. - * #pack:: Packs the the elements into a binary sequence. + * #pack:: Packs the elements into a binary sequence. * #sum:: Returns a sum of elements according to either <tt>+</tt> or a given block. */ @@ -58,6 +58,12 @@ class Array # a.sample(random: Random.new(1)) #=> 6 # a.sample(4, random: Random.new(1)) #=> [6, 10, 9, 2] def sample(n = (ary = false), random: Random) - Primitive.rb_ary_sample(random, n, ary) + if Primitive.mandatory_only? + # Primitive.cexpr! %{ rb_ary_sample(self, rb_cRandom, Qfalse, Qfalse) } + Primitive.ary_sample0 + else + # Primitive.cexpr! %{ rb_ary_sample(self, random, n, ary) } + Primitive.ary_sample(random, n, ary) + end end end @@ -195,12 +195,12 @@ script_lines(VALUE path) static VALUE ast_s_of(rb_execution_context_t *ec, VALUE module, VALUE body, VALUE keep_script_lines) { - VALUE path, node, lines; + VALUE path, node, lines = Qnil; int node_id; if (rb_frame_info_p(body)) { - rb_frame_info_get(body, &path, &node_id); - if (NIL_P(path)) return Qnil; + rb_frame_info_get(body, &path, &lines, &node_id); + if (NIL_P(path) && NIL_P(lines)) return Qnil; } else { const rb_iseq_t *iseq = NULL; @@ -220,10 +220,11 @@ ast_s_of(rb_execution_context_t *ec, VALUE module, VALUE body, VALUE keep_script rb_raise(rb_eArgError, "cannot get AST for method defined in eval"); } path = rb_iseq_path(iseq); + lines = iseq->body->variable.script_lines; node_id = iseq->body->location.node_id; } - if (!NIL_P(lines = script_lines(path))) { + if (!NIL_P(lines) || !NIL_P(lines = script_lines(path))) { node = rb_ast_parse_array(lines, keep_script_lines); } else if (RSTRING_LEN(path) == 2 && memcmp(RSTRING_PTR(path), "-e", 2) == 0) { @@ -297,7 +298,7 @@ dump_block(rb_ast_t *ast, const NODE *node) do { rb_ary_push(ary, NEW_CHILD(ast, node->nd_head)); } while (node->nd_next && - nd_type(node->nd_next) == NODE_BLOCK && + nd_type_p(node->nd_next, NODE_BLOCK) && (node = node->nd_next, 1)); if (node->nd_next) { rb_ary_push(ary, NEW_CHILD(ast, node->nd_next)); @@ -312,7 +313,7 @@ dump_array(rb_ast_t *ast, const NODE *node) VALUE ary = rb_ary_new(); rb_ary_push(ary, NEW_CHILD(ast, node->nd_head)); - while (node->nd_next && nd_type(node->nd_next) == NODE_LIST) { + while (node->nd_next && nd_type_p(node->nd_next, NODE_LIST)) { node = node->nd_next; rb_ary_push(ary, NEW_CHILD(ast, node->nd_head)); } @@ -398,7 +399,7 @@ node_children(rb_ast_t *ast, const NODE *node) while (1) { rb_ary_push(ary, NEW_CHILD(ast, node->nd_1st)); - if (!node->nd_2nd || nd_type(node->nd_2nd) != (int)type) + if (!node->nd_2nd || !nd_type_p(node->nd_2nd, type)) break; node = node->nd_2nd; } @@ -599,11 +600,11 @@ node_children(rb_ast_t *ast, const NODE *node) } case NODE_SCOPE: { - ID *tbl = node->nd_tbl; - int i, size = tbl ? (int)*tbl++ : 0; + rb_ast_id_table_t *tbl = node->nd_tbl; + int i, size = tbl ? tbl->size : 0; VALUE locals = rb_ary_new_capa(size); for (i = 0; i < size; i++) { - rb_ary_push(locals, var_name(tbl[i])); + rb_ary_push(locals, var_name(tbl->ids[i])); } return rb_ary_new_from_args(3, locals, NEW_CHILD(ast, node->nd_args), NEW_CHILD(ast, node->nd_body)); } diff --git a/autogen.sh b/autogen.sh index 44a1922cb05..f8cdf3c0c1e 100755 --- a/autogen.sh +++ b/autogen.sh @@ -6,4 +6,12 @@ case "$0" in *) srcdir="";; esac -exec ${AUTORECONF:-autoreconf} --install --symlink "$@" ${srcdir:+"$srcdir"} +symlink='--install --symlink' +case " $* " in + *" -i "*|*" --install "*) + # reset to copy missing standard auxiliary files, instead of symlinks + symlink= + ;; +esac + +exec ${AUTORECONF:-autoreconf} ${symlink} "$@" ${srcdir:+"$srcdir"} diff --git a/benchmark/array_sample.yml b/benchmark/array_sample.yml new file mode 100644 index 00000000000..1cd2b34794b --- /dev/null +++ b/benchmark/array_sample.yml @@ -0,0 +1,4 @@ +prelude: ary = (1..10_000).to_a +benchmark: + - ary.sample + - ary.sample(2) diff --git a/benchmark/buffer_get.yml b/benchmark/buffer_get.yml new file mode 100644 index 00000000000..e375dcf85dc --- /dev/null +++ b/benchmark/buffer_get.yml @@ -0,0 +1,9 @@ +benchmark: + - name: buffer.get + prelude: buffer = IO::Buffer.new(32, IO::Buffer::MAPPED) + script: buffer.get(:U32, 0) + loop_count: 20000000 + - name: string.unpack + prelude: string = "\0" * 32 + script: string.unpack("C") + loop_count: 20000000 diff --git a/benchmark/hash_aref_array.rb b/benchmark/hash_aref_array.rb new file mode 100644 index 00000000000..ac7a683d954 --- /dev/null +++ b/benchmark/hash_aref_array.rb @@ -0,0 +1,5 @@ +h = {} +arrays = (0..99).each_slice(10).to_a +#STDERR.puts arrays.inspect +arrays.each { |s| h[s] = s } +200_000.times { arrays.each { |s| h[s] } } diff --git a/benchmark/time_at.yml b/benchmark/time_at.yml new file mode 100644 index 00000000000..3247efbe774 --- /dev/null +++ b/benchmark/time_at.yml @@ -0,0 +1,7 @@ +prelude: | + # frozen_string_literal: true +benchmark: + - 'Time.at(0)' + - 'Time.at(0, 500)' + - 'Time.at(0, in: "+09:00")' + - 'Time.at(0, 500, in: "+09:00")' diff --git a/benchmark/vm_dstr_ary.rb b/benchmark/vm_dstr_ary.rb new file mode 100644 index 00000000000..1d3aa3b97b0 --- /dev/null +++ b/benchmark/vm_dstr_ary.rb @@ -0,0 +1,6 @@ +i = 0 +x = y = [] +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_bool.rb b/benchmark/vm_dstr_bool.rb new file mode 100644 index 00000000000..631ca54755c --- /dev/null +++ b/benchmark/vm_dstr_bool.rb @@ -0,0 +1,7 @@ +i = 0 +x = true +y = false +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_class_module.rb b/benchmark/vm_dstr_class_module.rb new file mode 100644 index 00000000000..becf0861c7d --- /dev/null +++ b/benchmark/vm_dstr_class_module.rb @@ -0,0 +1,10 @@ +i = 0 +class A; end unless defined?(A) +module B; end unless defined?(B) +x = A +y = B +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end + diff --git a/benchmark/vm_dstr_digit.rb b/benchmark/vm_dstr_digit.rb new file mode 100644 index 00000000000..caaa395192b --- /dev/null +++ b/benchmark/vm_dstr_digit.rb @@ -0,0 +1,7 @@ +i = 0 +x = 0 +y = 9 +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_int.rb b/benchmark/vm_dstr_int.rb new file mode 100644 index 00000000000..ed380d75953 --- /dev/null +++ b/benchmark/vm_dstr_int.rb @@ -0,0 +1,5 @@ +i = 0 +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{i}bar#{i}baz" +end diff --git a/benchmark/vm_dstr_nil.rb b/benchmark/vm_dstr_nil.rb new file mode 100644 index 00000000000..ec4f5d6c677 --- /dev/null +++ b/benchmark/vm_dstr_nil.rb @@ -0,0 +1,6 @@ +i = 0 +x = y = nil +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_obj.rb b/benchmark/vm_dstr_obj.rb new file mode 100644 index 00000000000..fb78637ead6 --- /dev/null +++ b/benchmark/vm_dstr_obj.rb @@ -0,0 +1,6 @@ +i = 0 +x = y = Object.new +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_obj_def.rb b/benchmark/vm_dstr_obj_def.rb new file mode 100644 index 00000000000..99ff7b98fbb --- /dev/null +++ b/benchmark/vm_dstr_obj_def.rb @@ -0,0 +1,8 @@ +i = 0 +o = Object.new +def o.to_s; -""; end +x = y = o +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_str.rb b/benchmark/vm_dstr_str.rb new file mode 100644 index 00000000000..45fc1078926 --- /dev/null +++ b/benchmark/vm_dstr_str.rb @@ -0,0 +1,6 @@ +i = 0 +x = y = "" +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_dstr_sym.rb b/benchmark/vm_dstr_sym.rb new file mode 100644 index 00000000000..484b8f8150f --- /dev/null +++ b/benchmark/vm_dstr_sym.rb @@ -0,0 +1,6 @@ +i = 0 +x = y = :z +while i<6_000_000 # benchmark loop 2 + i += 1 + str = "foo#{x}bar#{y}baz" +end diff --git a/benchmark/vm_ivar_of_class.yml b/benchmark/vm_ivar_of_class.yml new file mode 100644 index 00000000000..172e28b2fd3 --- /dev/null +++ b/benchmark/vm_ivar_of_class.yml @@ -0,0 +1,12 @@ +prelude: | + class C + @a = 1 + def self.a + _a = @a; _a = @a; _a = @a; _a = @a; _a = @a; + _a = @a; _a = @a; _a = @a; _a = @a; _a = @a; + end + end +benchmark: + vm_ivar_of_class: | + a = C.a +loop_count: 30000000 diff --git a/benchmark/vm_ivar_of_class_set.yml b/benchmark/vm_ivar_of_class_set.yml new file mode 100644 index 00000000000..2ea5199423b --- /dev/null +++ b/benchmark/vm_ivar_of_class_set.yml @@ -0,0 +1,11 @@ +prelude: | + class C + @a = 1 + def self.a o + @a = o; @a = o; @a = o; @a = o; @a = o; @a = o; + end + end +benchmark: + vm_ivar_of_class_set: | + a = C.a(nil) +loop_count: 30000000 @@ -1641,11 +1641,13 @@ rb_big_sq_fast(VALUE x) /* balancing multiplication by slicing larger argument */ static void -bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn, BDIGIT *wds, size_t wn, mulfunc_t *mulfunc) +bary_mul_balance_with_mulfunc(BDIGIT *const zds, const size_t zn, + const BDIGIT *const xds, const size_t xn, + const BDIGIT *const yds, const size_t yn, + BDIGIT *wds, size_t wn, mulfunc_t *const mulfunc) { VALUE work = 0; - size_t yn0 = yn; - size_t r, n; + size_t n; assert(xn + yn <= zn); assert(xn <= yn); @@ -1653,14 +1655,20 @@ bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t BDIGITS_ZERO(zds, xn); + if (wn < xn) { + const size_t r = (yn % xn) ? (yn % xn) : xn; + if ((2 * xn + yn + r) > zn) { + wn = xn; + wds = ALLOCV_N(BDIGIT, work, wn); + } + } + n = 0; - while (yn > 0) { - BDIGIT *tds; - size_t tn; - r = xn > yn ? yn : xn; - tn = xn + r; + while (yn > n) { + const size_t r = (xn > (yn - n) ? (yn - n) : xn); + const size_t tn = (xn + r); if (2 * (xn + r) <= zn - n) { - tds = zds + n + xn + r; + BDIGIT *const tds = zds + n + xn + r; mulfunc(tds, tn, xds, xn, yds + n, r, wds, wn); BDIGITS_ZERO(zds + n + xn, r); bary_add(zds + n, tn, @@ -1668,21 +1676,25 @@ bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t tds, tn); } else { + BDIGIT *const tds = zds + n; if (wn < xn) { + /* xn is invariant, only once here */ +#if 0 wn = xn; wds = ALLOCV_N(BDIGIT, work, wn); +#else + rb_bug("wds is not enough: %" PRIdSIZE " for %" PRIdSIZE, wn, xn); +#endif } - tds = zds + n; MEMCPY(wds, zds + n, BDIGIT, xn); mulfunc(tds, tn, xds, xn, yds + n, r, wds+xn, wn-xn); bary_add(zds + n, tn, zds + n, tn, wds, xn); } - yn -= r; n += r; } - BDIGITS_ZERO(zds+xn+yn0, zn - (xn+yn0)); + BDIGITS_ZERO(zds+xn+yn, zn - (xn+yn)); if (work) ALLOCV_END(work); @@ -6922,8 +6934,6 @@ rb_big_isqrt(VALUE n) bary_small_rshift(xds, xds, xn, 1, carry); tn = BIGNUM_LEN(t); } - rb_big_realloc(t, 0); - rb_gc_force_recycle(t); } RBASIC_SET_CLASS_RAW(x, rb_cInteger); return x; diff --git a/bootstraptest/test_eval.rb b/bootstraptest/test_eval.rb index 5d2593c3060..efc22efff40 100644 --- a/bootstraptest/test_eval.rb +++ b/bootstraptest/test_eval.rb @@ -116,6 +116,33 @@ assert_equal %q{1}, %q{ Const } } +assert_equal %q{1}, %q{ + class TrueClass + Const = 1 + end + true.instance_eval %{ + Const + } +} +assert_equal %q{[:Const]}, %q{ + mod = Module.new + mod.instance_eval %{ + Const = 1 + } + raise if defined?(Module::Const) + mod.singleton_class.constants +} +assert_equal %q{can't define singleton}, %q{ + begin + 123.instance_eval %{ + Const = 1 + } + "bad" + rescue TypeError => e + raise "bad" if defined?(Integer::Const) + e.message + end +} assert_equal %q{top}, %q{ Const = :top class C diff --git a/bootstraptest/test_insns.rb b/bootstraptest/test_insns.rb index 31fdc29d024..91fba9b011b 100644 --- a/bootstraptest/test_insns.rb +++ b/bootstraptest/test_insns.rb @@ -120,6 +120,7 @@ tests = [ [ 'dup', %q{ x = y = true; x }, ], [ 'dupn', %q{ Object::X ||= true }, ], [ 'reverse', %q{ q, (w, e), r = 1, [2, 3], 4; e == 3 }, ], + [ 'swap', %q{ !!defined?([[]]) }, ], [ 'swap', <<-'},', ], # { x = [[false, true]] for i, j in x # here diff --git a/bootstraptest/test_ractor.rb b/bootstraptest/test_ractor.rb index 01d02dce775..ef1e6afcac2 100644 --- a/bootstraptest/test_ractor.rb +++ b/bootstraptest/test_ractor.rb @@ -187,6 +187,28 @@ assert_equal '[:ok, :ok, :ok]', %q{ }.map(&:take) } +# Ractor.make_shareable issue for locals in proc [Bug #18023] +assert_equal '[:a, :b, :c, :d, :e]', %q{ + v1, v2, v3, v4, v5 = :a, :b, :c, :d, :e + closure = Proc.new { [v1, v2, v3, v4, v5] } + + Ractor.make_shareable(closure).call +} + +# Ractor.make_shareable issue for locals in proc [Bug #18023] +assert_equal '[:a, :b, :c, :d, :e, :f, :g]', %q{ + a = :a + closure = -> { + b, c, d = :b, :c, :d + -> { + e, f, g = :e, :f, :g + -> { [a, b, c, d, e, f, g] } + }.call + }.call + + Ractor.make_shareable(closure).call +} + ### ### # Ractor still has several memory corruption so skip huge number of tests @@ -906,7 +928,7 @@ assert_equal 'ArgumentError', %q{ } # ivar in shareable-objects are not allowed to access from non-main Ractor -assert_equal 'can not access instance variables of classes/modules from non-main Ractors', %q{ +assert_equal "can not get unshareable values from instance variables of classes/modules from non-main Ractors", %q{ class C @iv = 'str' end @@ -1000,6 +1022,53 @@ assert_equal '11', %q{ }.join } +# and instance variables of classes/modules are accessible if they refer shareable objects +assert_equal '333', %q{ + class C + @int = 1 + @str = '-1000'.dup + @fstr = '100'.freeze + + def self.int = @int + def self.str = @str + def self.fstr = @fstr + end + + module M + @int = 2 + @str = '-2000'.dup + @fstr = '200'.freeze + + def self.int = @int + def self.str = @str + def self.fstr = @fstr + end + + a = Ractor.new{ C.int }.take + b = Ractor.new do + C.str.to_i + rescue Ractor::IsolationError + 10 + end.take + c = Ractor.new do + C.fstr.to_i + end.take + + d = Ractor.new{ M.int }.take + e = Ractor.new do + M.str.to_i + rescue Ractor::IsolationError + 20 + end.take + f = Ractor.new do + M.fstr.to_i + end.take + + + # 1 + 10 + 100 + 2 + 20 + 200 + a + b + c + d + e + f +} + # cvar in shareable-objects are not allowed to access from non-main Ractor assert_equal 'can not access class variables from non-main Ractors', %q{ class C @@ -1061,7 +1130,7 @@ assert_equal 'can not set constants with non-shareable objects by non-main Racto } # define_method is not allowed -assert_equal "defined in a different Ractor", %q{ +assert_equal "defined with an un-shareable Proc in a different Ractor", %q{ str = "foo" define_method(:buggy){|i| str << "#{i}"} begin @@ -1433,4 +1502,40 @@ assert_equal "ok", %q{ "ok" } +assert_equal "ok", %q{ + def foo(*); ->{ super }; end + begin + Ractor.make_shareable(foo) + rescue Ractor::IsolationError + "ok" + end +} + +assert_equal "ok", %q{ + def foo(**); ->{ super }; end + begin + Ractor.make_shareable(foo) + rescue Ractor::IsolationError + "ok" + end +} + +assert_equal "ok", %q{ + def foo(...); ->{ super }; end + begin + Ractor.make_shareable(foo) + rescue Ractor::IsolationError + "ok" + end +} + +assert_equal "ok", %q{ + def foo((x), (y)); ->{ super }; end + begin + Ractor.make_shareable(foo([], [])) + rescue Ractor::IsolationError + "ok" + end +} + end # if !ENV['GITHUB_WORKFLOW'] diff --git a/bootstraptest/test_yjit.rb b/bootstraptest/test_yjit.rb new file mode 100644 index 00000000000..e50d78a9dc5 --- /dev/null +++ b/bootstraptest/test_yjit.rb @@ -0,0 +1,2660 @@ +assert_equal '[nil, nil, nil, nil, nil, nil]', %q{ + [NilClass, TrueClass, FalseClass, Integer, Float, Symbol].each do |klass| + klass.class_eval("def foo = @foo") + end + + [nil, true, false, 0xFABCAFE, 0.42, :cake].map do |instance| + instance.foo + instance.foo + end +} + +assert_equal '0', %q{ + # This is a regression test for incomplete invalidation from + # opt_setinlinecache. This test might be brittle, so + # feel free to remove it in the future if it's too annoying. + # This test assumes --yjit-call-threshold=2. + module M + Foo = 1 + def foo + Foo + end + + def pin_self_type_then_foo + _ = @foo + foo + end + + def only_ints + 1 + self + foo + end + end + + class Integer + include M + end + + class Sub + include M + end + + foo_method = M.instance_method(:foo) + + dbg = ->(message) do + return # comment this out to get printouts + + $stderr.puts RubyVM::YJIT.disasm(foo_method) + $stderr.puts message + end + + 2.times { 42.only_ints } + + dbg["There should be two versions of getinlineache"] + + module M + remove_const(:Foo) + end + + dbg["There should be no getinlinecaches"] + + 2.times do + 42.only_ints + rescue NameError => err + _ = "caught name error #{err}" + end + + dbg["There should be one version of getinlineache"] + + 2.times do + Sub.new.pin_self_type_then_foo + rescue NameError + _ = 'second specialization' + end + + dbg["There should be two versions of getinlineache"] + + module M + Foo = 1 + end + + dbg["There should still be two versions of getinlineache"] + + 42.only_ints + + dbg["There should be no getinlinecaches"] + + # Find name of the first VM instruction in M#foo. + insns = RubyVM::InstructionSequence.of(foo_method).to_a + if defined?(RubyVM::YJIT.blocks_for) && (insns.last.find { Array === _1 }&.first == :opt_getinlinecache) + RubyVM::YJIT.blocks_for(RubyVM::InstructionSequence.of(foo_method)) + .filter { _1.iseq_start_index == 0 }.count + else + 0 # skip the test + end +} + +# Check that frozen objects are respected +assert_equal 'great', %q{ + class Foo + attr_accessor :bar + def initialize + @bar = 1 + freeze + end + end + + foo = Foo.new + + 5.times do + begin + foo.bar = 2 + rescue FrozenError + end + end + + foo.bar == 1 ? "great" : "NG" +} + +# Check that global variable set works +assert_equal 'string', %q{ + def foo + $foo = "string" + end + + foo +} + +# Check that exceptions work when setting global variables +assert_equal 'rescued', %q{ + def set_var + $var = 100 + rescue + :rescued + end + + set_var + trace_var(:$var) { raise } + set_var +} + +# Check that global variables work +assert_equal 'string', %q{ + $foo = "string" + + def foo + $foo + end + + foo +} + +# Check that exceptions work when getting global variable +assert_equal 'rescued', %q{ + module Warning + def warn(message) + raise + end + end + + def get_var + $= + rescue + :rescued + end + + $VERBOSE = true + get_var + get_var +} + +# Check that global tracepoints work +assert_equal 'true', %q{ + def foo + 1 + end + + foo + foo + foo + + called = false + + tp = TracePoint.new(:return) { |event| + if event.method_id == :foo + called = true + end + } + tp.enable + foo + tp.disable + called +} + +# Check that local tracepoints work +assert_equal 'true', %q{ + def foo + 1 + end + + foo + foo + foo + + called = false + + tp = TracePoint.new(:return) { |_| called = true } + tp.enable(target: method(:foo)) + foo + tp.disable + called +} + +# Make sure that optional param methods return the correct value +assert_equal '1', %q{ + def m(ary = []) + yield(ary) + end + + # Warm the JIT with a 0 param call + 2.times { m { } } + m(1) { |v| v } +} + +# Test for topn +assert_equal 'array', %q{ + def threequals(a) + case a + when Array + "array" + when Hash + "hash" + else + "unknown" + end + end + + threequals([]) + threequals([]) + threequals([]) +} + +# Test for opt_mod +assert_equal '2', %q{ + def mod(a, b) + a % b + end + + mod(7, 5) + mod(7, 5) +} + +# Test for opt_mult +assert_equal '12', %q{ + def mult(a, b) + a * b + end + + mult(6, 2) + mult(6, 2) +} + +# Test for opt_div +assert_equal '3', %q{ + def div(a, b) + a / b + end + + div(6, 2) + div(6, 2) +} + +# BOP redefined methods work when JIT compiled +assert_equal 'false', %q{ + def less_than x + x < 10 + end + + class Integer + def < x + false + end + end + + less_than 2 + less_than 2 + less_than 2 +} + +# BOP redefinition works on Integer#< +assert_equal 'false', %q{ + def less_than x + x < 10 + end + + less_than 2 + less_than 2 + + class Integer + def < x + false + end + end + + less_than 2 +} + +# Putobject, less-than operator, fixnums +assert_equal '2', %q{ + def check_index(index) + if 0x40000000 < index + raise "wat? #{index}" + end + index + end + check_index 2 + check_index 2 +} + +# foo leaves a temp on the stack before the call +assert_equal '6', %q{ + def bar + return 5 + end + + def foo + return 1 + bar + end + + foo() + retval = foo() +} + +# Method with one arguments +# foo leaves a temp on the stack before the call +assert_equal '7', %q{ + def bar(a) + return a + 1 + end + + def foo + return 1 + bar(5) + end + + foo() + retval = foo() +} + +# Method with two arguments +# foo leaves a temp on the stack before the call +assert_equal '0', %q{ + def bar(a, b) + return a - b + end + + def foo + return 1 + bar(1, 2) + end + + foo() + retval = foo() +} + +# Passing argument types to callees +assert_equal '8.5', %q{ + def foo(x, y) + x + y + end + + def bar + foo(7, 1.5) + end + + bar + bar +} + +# Recursive Ruby-to-Ruby calls +assert_equal '21', %q{ + def fib(n) + if n < 2 + return n + end + + return fib(n-1) + fib(n-2) + end + + r = fib(8) +} + +# Ruby-to-Ruby call and C call +assert_normal_exit %q{ + def bar + puts('hi!') + end + + def foo + bar + end + + foo() + foo() +} + +# Method aliasing +assert_equal '42', %q{ + class Foo + def method_a + 42 + end + + alias method_b method_a + + def method_a + :somethingelse + end + end + + @obj = Foo.new + + def test + @obj.method_b + end + + test + test +} + +# Method aliasing with method from parent class +assert_equal '777', %q{ + class A + def method_a + 777 + end + end + + class B < A + alias method_b method_a + end + + @obj = B.new + + def test + @obj.method_b + end + + test + test +} + +# The hash method is a C function and uses the self argument +assert_equal 'true', %q{ + def lehashself + hash + end + + a = lehashself + b = lehashself + a == b +} + +# Method redefinition (code invalidation) test +assert_equal '1', %q{ + def ret1 + return 1 + end + + klass = Class.new do + def alias_then_hash(klass, method_to_redefine) + # Redefine the method to be ret1 + klass.alias_method(method_to_redefine, :ret1) + hash + end + end + + instance = klass.new + + i = 0 + while i < 12 + if i < 11 + # Redefine the bar method + instance.alias_then_hash(klass, :bar) + else + # Redefine the hash method to be ret1 + retval = instance.alias_then_hash(klass, :hash) + end + i += 1 + end + + retval +} + +# Code invalidation and opt_getinlinecache +assert_normal_exit %q{ + class Foo; end + + # Uses the class constant Foo + def use_constant(arg) + [Foo.new, arg] + end + + def propagate_type + i = Array.new + i.itself # make it remember that i is on-heap + use_constant(i) + end + + propagate_type + propagate_type + use_constant(Foo.new) + class Jo; end # bump global constant state + use_constant(3) +} + +# Method redefinition (code invalidation) and GC +assert_equal '7', %q{ + def bar() + return 5 + end + + def foo() + bar() + end + + foo() + foo() + + def bar() + return 7 + end + + 4.times { GC.start } + + foo() + foo() +} + +# Method redefinition with two block versions +assert_equal '7', %q{ + def bar() + return 5 + end + + def foo(n) + return ((n < 5)? 5:false), bar() + end + + foo(4) + foo(4) + foo(10) + foo(10) + + def bar() + return 7 + end + + 4.times { GC.start } + + foo(4) + foo(4)[1] +} + +# Method redefinition while the method is on the stack +assert_equal '[777, 1]', %q{ + def foo + redef() + 777 + end + + def redef + # Redefine the global foo + eval("def foo; 1; end", TOPLEVEL_BINDING) + + # Collect dead code + GC.stress = true + GC.start + + # But we will return to the original foo, + # which remains alive because it's on the stack + end + + # Must produce [777, 1] + [foo, foo] +} + +# Test for GC safety. Don't invalidate dead iseqs. +assert_normal_exit %q{ + Class.new do + def foo + itself + end + + new.foo + new.foo + new.foo + new.foo + end + + 4.times { GC.start } + def itself + self + end +} + +# test setinstancevariable on extended objects +assert_equal '1', %q{ + class Extended + attr_reader :one + + def write_many + @a = 1 + @b = 2 + @c = 3 + @d = 4 + @one = 1 + end + end + + foo = Extended.new + foo.write_many + foo.write_many + foo.write_many +} + +# test setinstancevariable on embedded objects +assert_equal '1', %q{ + class Embedded + attr_reader :one + + def write_one + @one = 1 + end + end + + foo = Embedded.new + foo.write_one + foo.write_one + foo.write_one +} + +# test setinstancevariable after extension +assert_equal '[10, 11, 12, 13, 1]', %q{ + class WillExtend + attr_reader :one + + def make_extended + @foo1 = 10 + @foo2 = 11 + @foo3 = 12 + @foo4 = 13 + end + + def write_one + @one = 1 + end + + def read_all + [@foo1, @foo2, @foo3, @foo4, @one] + end + end + + foo = WillExtend.new + foo.write_one + foo.write_one + foo.make_extended + foo.write_one + foo.read_all +} + +# test setinstancevariable on frozen object +assert_equal 'object was not modified', %q{ + class WillFreeze + def write + @ivar = 1 + end + end + + wf = WillFreeze.new + wf.write + wf.write + wf.freeze + + begin + wf.write + rescue FrozenError + "object was not modified" + end +} + +# Test getinstancevariable and inline caches +assert_equal '6', %q{ + class Foo + def initialize + @x1 = 1 + @x2 = 1 + @x2 = 1 + @x3 = 1 + @x4 = 3 + end + + def bar + x = 1 + @x4 + @x4 + end + end + + f = Foo.new + f.bar + f.bar +} + +# Test that getinstancevariable codegen checks for extended table size +assert_equal "nil\n", %q{ + class A + def read + @ins1000 + end + end + + ins = A.new + other = A.new + 10.times { other.instance_variable_set(:"@otr#{_1}", 'value') } + 1001.times { ins.instance_variable_set(:"@ins#{_1}", 'value') } + + ins.read + ins.read + ins.read + + p other.read +} + +# Test that opt_aref checks the class of the receiver +assert_equal 'special', %q{ + def foo(array) + array[30] + end + + foo([]) + foo([]) + + special = [] + def special.[](idx) + 'special' + end + + foo(special) +} + +# Test that object references in generated code get marked and moved +assert_equal "good", %q{ + def bar + "good" + end + + def foo + bar + end + + foo + foo + + begin + GC.verify_compaction_references(double_heap: true, toward: :empty) + rescue NotImplementedError + # in case compaction isn't supported + end + + foo +} + +# Test polymorphic getinstancevariable. T_OBJECT -> T_STRING +assert_equal 'ok', %q{ + @hello = @h1 = @h2 = @h3 = @h4 = 'ok' + str = "" + str.instance_variable_set(:@hello, 'ok') + + public def get + @hello + end + + get + get + str.get + str.get +} + +# Test polymorphic getinstancevariable, two different classes +assert_equal 'ok', %q{ + class Embedded + def initialize + @ivar = 0 + end + + def get + @ivar + end + end + + class Extended < Embedded + def initialize + @v1 = @v2 = @v3 = @v4 = @ivar = 'ok' + end + end + + embed = Embedded.new + extend = Extended.new + + embed.get + embed.get + extend.get + extend.get +} + +# Test megamorphic getinstancevariable +assert_equal 'ok', %q{ + parent = Class.new do + def initialize + @hello = @h1 = @h2 = @h3 = @h4 = 'ok' + end + + def get + @hello + end + end + + subclasses = 300.times.map { Class.new(parent) } + subclasses.each { _1.new.get } + parent.new.get +} + +# Test polymorphic opt_aref. array -> hash +assert_equal '[42, :key]', %q{ + def index(obj, idx) + obj[idx] + end + + index([], 0) # get over compilation threshold + + [ + index([42], 0), + index({0=>:key}, 0), + ] +} + +# Test polymorphic opt_aref. hash -> array -> custom class +assert_equal '[nil, nil, :custom]', %q{ + def index(obj, idx) + obj[idx] + end + + custom = Object.new + def custom.[](_idx) + :custom + end + + index({}, 0) # get over compilation threshold + + [ + index({}, 0), + index([], 0), + index(custom, 0) + ] +} + +# Test polymorphic opt_aref. array -> custom class +assert_equal '[42, :custom]', %q{ + def index(obj, idx) + obj[idx] + end + + custom = Object.new + def custom.[](_idx) + :custom + end + + index([], 0) # get over compilation threshold + + [ + index([42], 0), + index(custom, 0) + ] +} + +# Test custom hash method with opt_aref +assert_equal '[nil, :ok]', %q{ + def index(obj, idx) + obj[idx] + end + + custom = Object.new + def custom.hash + 42 + end + + h = {custom => :ok} + + [ + index(h, 0), + index(h, custom) + ] +} + +# Test default value block for Hash with opt_aref +assert_equal '[42, :default]', %q{ + def index(obj, idx) + obj[idx] + end + + h = Hash.new { :default } + h[0] = 42 + + [ + index(h, 0), + index(h, 1) + ] +} + +# A regression test for making sure cfp->sp is proper when +# hitting stubs. See :stub-sp-flush: +assert_equal 'ok', %q{ + class D + def foo + Object.new + end + end + + GC.stress = true + 10.times do + D.new.foo + # ^ + # This hits a stub with sp_offset > 0 + end + + :ok +} + +# Test polymorphic callsite, cfunc -> iseq +assert_equal '[Cfunc, Iseq]', %q{ + public def call_itself + itself # the polymorphic callsite + end + + class Cfunc; end + + class Iseq + def itself + self + end + end + + call_itself # cross threshold + + [Cfunc.call_itself, Iseq.call_itself] +} + +# Test polymorphic callsite, iseq -> cfunc +assert_equal '[Iseq, Cfunc]', %q{ + public def call_itself + itself # the polymorphic callsite + end + + class Cfunc; end + + class Iseq + def itself + self + end + end + + call_itself # cross threshold + + [Iseq.call_itself, Cfunc.call_itself] +} + +# attr_reader method +assert_equal '[100, 299]', %q{ + class A + attr_reader :foo + + def initialize + @foo = 100 + end + + # Make it extended + def fill! + @bar = @jojo = @as = @sdfsdf = @foo = 299 + end + end + + def bar(ins) + ins.foo + end + + ins = A.new + oth = A.new + oth.fill! + + bar(ins) + bar(oth) + + [bar(ins), bar(oth)] +} + +# get ivar on object, then on hash +assert_equal '[42, 100]', %q{ + class Hash + attr_accessor :foo + end + + class A + attr_reader :foo + + def initialize + @foo = 42 + end + end + + def use(val) + val.foo + end + + + h = {} + h.foo = 100 + obj = A.new + + use(obj) + [use(obj), use(h)] +} + +# get ivar on String +assert_equal '[nil, nil, 42, 42]', %q{ + # @foo to exercise the getinstancevariable instruction + public def get_foo + @foo + end + + get_foo + get_foo # compile it for the top level object + + class String + attr_reader :foo + end + + def run + str = String.new + + getter = str.foo + insn = str.get_foo + + str.instance_variable_set(:@foo, 42) + + [getter, insn, str.foo, str.get_foo] + end + + run + run +} + +# splatting an empty array on a getter +assert_equal '42', %q{ + @foo = 42 + module Kernel + attr_reader :foo + end + + def run + foo(*[]) + end + + run + run +} + +# getinstancevariable on Symbol +assert_equal '[nil, nil]', %q{ + # @foo to exercise the getinstancevariable instruction + public def get_foo + @foo + end + + dyn_sym = ("a" + "b").to_sym + sym = :static + + # compile get_foo + dyn_sym.get_foo + dyn_sym.get_foo + + [dyn_sym.get_foo, sym.get_foo] +} + +# attr_reader on Symbol +assert_equal '[nil, nil]', %q{ + class Symbol + attr_reader :foo + end + + public def get_foo + foo + end + + dyn_sym = ("a" + "b").to_sym + sym = :static + + # compile get_foo + dyn_sym.get_foo + dyn_sym.get_foo + + [dyn_sym.get_foo, sym.get_foo] +} + +# passing too few arguments to method with optional parameters +assert_equal 'raised', %q{ + def opt(a, b = 0) + end + + def use + opt + end + + use rescue nil + begin + use + :ng + rescue ArgumentError + :raised + end +} + +# passing too many arguments to method with optional parameters +assert_equal 'raised', %q{ + def opt(a, b = 0) + end + + def use + opt(1, 2, 3, 4) + end + + use rescue nil + begin + use + :ng + rescue ArgumentError + :raised + end +} + +# test calling Ruby method with a block +assert_equal '[1, 2, 42]', %q{ + def thing(a, b) + [a, b, yield] + end + + def use + thing(1,2) { 42 } + end + + use + use +} + +# test calling C method with a block +assert_equal '[42, 42]', %q{ + def use(array, initial) + array.reduce(initial) { |a, b| a + b } + end + + use([], 0) + [use([2, 2], 38), use([14, 14, 14], 0)] +} + +# test calling block param +assert_equal '[1, 2, 42]', %q{ + def foo(&block) + block.call + end + + [foo {1}, foo {2}, foo {42}] +} + +# test calling block param failing +assert_equal '42', %q{ + def foo(&block) + block.call + end + + foo {} # warmup + + begin + foo + rescue NoMethodError => e + 42 if nil == e.receiver + end +} + +# test calling method taking block param +assert_equal '[Proc, 1, 2, 3, Proc]', %q{ + def three(a, b, c, &block) + [a, b, c, block.class] + end + + def zero(&block) + block.class + end + + def use_three + three(1, 2, 3) {} + end + + def use_zero + zero {} + end + + use_three + use_zero + + [use_zero] + use_three +} + +# test building empty array +assert_equal '[]', %q{ + def build_arr + [] + end + + build_arr + build_arr +} + +# test building array of one element +assert_equal '[5]', %q{ + def build_arr(val) + [val] + end + + build_arr(5) + build_arr(5) +} + +# test building array of several element +assert_equal '[5, 5, 5, 5, 5]', %q{ + def build_arr(val) + [val, val, val, val, val] + end + + build_arr(5) + build_arr(5) +} + +# test building empty hash +assert_equal '{}', %q{ + def build_hash + {} + end + + build_hash + build_hash +} + +# test building hash with values +assert_equal '{:foo=>:bar}', %q{ + def build_hash(val) + { foo: val } + end + + build_hash(:bar) + build_hash(:bar) +} + +# test string interpolation with known types +assert_equal 'foobar', %q{ + def make_str + foo = -"foo" + bar = -"bar" + "#{foo}#{bar}" + end + + make_str + make_str +} + +# test string interpolation with unknown types +assert_equal 'foobar', %q{ + def make_str(foo, bar) + "#{foo}#{bar}" + end + + make_str("foo", "bar") + make_str("foo", "bar") +} + +# test string interpolation with known non-strings +assert_equal 'foo123', %q{ + def make_str + foo = -"foo" + bar = 123 + "#{foo}#{bar}" + end + + make_str + make_str +} + +# test string interpolation with unknown non-strings +assert_equal 'foo123', %q{ + def make_str(foo, bar) + "#{foo}#{bar}" + end + + make_str("foo", 123) + make_str("foo", 123) +} + +# test string interpolation with overridden to_s +assert_equal 'foo', %q{ + class String + def to_s + "bad" + end + end + + def make_str(foo) + "#{foo}" + end + + make_str("foo") + make_str("foo") +} + + +# test invokebuiltin as used in struct assignment +assert_equal '123', %q{ + def foo(obj) + obj.foo = 123 + end + + struct = Struct.new(:foo) + obj = struct.new + foo(obj) + foo(obj) +} + +# test invokebuiltin_delegate as used inside Dir.open +assert_equal '.', %q{ + def foo(path) + Dir.open(path).path + end + + foo(".") + foo(".") +} + +# test invokebuiltin_delegate_leave in method called from jit +assert_normal_exit %q{ + def foo(obj) + obj.clone + end + + foo(Object.new) + foo(Object.new) +} + +# test invokebuiltin_delegate_leave in method called from cfunc +assert_normal_exit %q{ + def foo(obj) + [obj].map(&:clone) + end + + foo(Object.new) + foo(Object.new) +} + +# defining TrueClass#! +assert_equal '[false, false, :ok]', %q{ + def foo(obj) + !obj + end + + x = foo(true) + y = foo(true) + + class TrueClass + def ! + :ok + end + end + + z = foo(true) + + [x, y, z] +} + +# defining FalseClass#! +assert_equal '[true, true, :ok]', %q{ + def foo(obj) + !obj + end + + x = foo(false) + y = foo(false) + + class FalseClass + def ! + :ok + end + end + + z = foo(false) + + [x, y, z] +} + +# defining NilClass#! +assert_equal '[true, true, :ok]', %q{ + def foo(obj) + !obj + end + + x = foo(nil) + y = foo(nil) + + class NilClass + def ! + :ok + end + end + + z = foo(nil) + + [x, y, z] +} + +# polymorphic opt_not +assert_equal '[true, true, false, false, false, false, false]', %q{ + def foo(obj) + !obj + end + + foo(0) + [foo(nil), foo(false), foo(true), foo([]), foo(0), foo(4.2), foo(:sym)] +} + +# getlocal with 2 levels +assert_equal '7', %q{ + def foo(foo, bar) + while foo > 0 + while bar > 0 + return foo + bar + end + end + end + + foo(5,2) + foo(5,2) +} + +# test pattern matching +assert_equal '[:ok, :ok]', %q{ + class C + def destructure_keys + {} + end + end + + pattern_match = ->(i) do + case i + in a: 0 + :ng + else + :ok + end + end + + [{}, C.new].map(&pattern_match) +} + +# Call to object with singleton +assert_equal '123', %q{ + obj = Object.new + def obj.foo + 123 + end + + def foo(obj) + obj.foo() + end + + foo(obj) + foo(obj) +} + +# Call method on an object that has a non-material +# singleton class. +# TODO: assert that it takes no side exits? This +# test case revealed that we were taking exits unnecessarily. +assert_normal_exit %q{ + def foo(obj) + obj.itself + end + + o = Object.new.singleton_class + foo(o) + foo(o) +} + +# Call to singleton class +assert_equal '123', %q{ + class Foo + def self.foo + 123 + end + end + + def foo(obj) + obj.foo() + end + + foo(Foo) + foo(Foo) +} + +# invokesuper edge case +assert_equal '[:A, [:A, :B]]', %q{ + class B + def foo = :B + end + + class A < B + def foo = [:A, super()] + end + + A.new.foo + A.new.foo # compile A#foo + + class C < A + define_method(:bar, A.instance_method(:foo)) + end + + C.new.bar +} + +# Same invokesuper bytecode, multiple destinations +assert_equal '[:Forward, :SecondTerminus]', %q{ + module Terminus + def foo = :Terminus + end + + module SecondTerminus + def foo = :SecondTerminus + end + + + module Forward + def foo = [:Forward, super] + end + + class B + include SecondTerminus + end + + class A < B + include Terminus + include Forward + end + + A.new.foo + A.new.foo # compile + + class B + include Forward + alias bar foo + end + + # A.ancestors.take(5) == [A, Forward, Terminus, B, Forward, SecondTerminus] + + A.new.bar +} + +# invokesuper calling into itself +assert_equal '[:B, [:B, :m]]', %q{ + module M + def foo = :m + end + + class B + include M + def foo = [:B, super] + end + + ins = B.new + ins.singleton_class # materialize the singleton class + ins.foo + ins.foo # compile + + ins.singleton_class.define_method(:bar, B.instance_method(:foo)) + ins.bar +} + +# invokesuper changed ancestor +assert_equal '[:A, [:M, :B]]', %q{ + class B + def foo + :B + end + end + + class A < B + def foo + [:A, super] + end + end + + module M + def foo + [:M, super] + end + end + + ins = A.new + ins.foo + ins.foo + A.include(M) + ins.foo +} + +# invokesuper changed ancestor via prepend +assert_equal '[:A, [:M, :B]]', %q{ + class B + def foo + :B + end + end + + class A < B + def foo + [:A, super] + end + end + + module M + def foo + [:M, super] + end + end + + ins = A.new + ins.foo + ins.foo + B.prepend(M) + ins.foo +} + +# invokesuper replaced method +assert_equal '[:A, :Btwo]', %q{ + class B + def foo + :B + end + end + + class A < B + def foo + [:A, super] + end + end + + ins = A.new + ins.foo + ins.foo + class B + def foo + :Btwo + end + end + ins.foo +} + +# Call to fixnum +assert_equal '[true, false]', %q{ + def is_odd(obj) + obj.odd? + end + + is_odd(1) + is_odd(1) + + [is_odd(123), is_odd(456)] +} + +# Call to bignum +assert_equal '[true, false]', %q{ + def is_odd(obj) + obj.odd? + end + + bignum = 99999999999999999999 + is_odd(bignum) + is_odd(bignum) + + [is_odd(bignum), is_odd(bignum+1)] +} + +# Call to fixnum and bignum +assert_equal '[true, false, true, false]', %q{ + def is_odd(obj) + obj.odd? + end + + bignum = 99999999999999999999 + is_odd(bignum) + is_odd(bignum) + is_odd(123) + is_odd(123) + + [is_odd(123), is_odd(456), is_odd(bignum), is_odd(bignum+1)] +} + +# Call to static and dynamic symbol +assert_equal 'bar', %q{ + def to_string(obj) + obj.to_s + end + + to_string(:foo) + to_string(:foo) + to_string((-"bar").to_sym) + to_string((-"bar").to_sym) +} + +# Call to flonum and heap float +assert_equal '[nil, nil, nil, 1]', %q{ + def is_inf(obj) + obj.infinite? + end + + is_inf(0.0) + is_inf(0.0) + is_inf(1e256) + is_inf(1e256) + + [ + is_inf(0.0), + is_inf(1.0), + is_inf(1e256), + is_inf(1.0/0.0) + ] +} + +assert_equal '[1, 2, 3, 4, 5]', %q{ + def splatarray + [*(1..5)] + end + + splatarray + splatarray +} + +assert_equal '[1, 1, 2, 1, 2, 3]', %q{ + def expandarray + arr = [1, 2, 3] + + a, = arr + b, c, = arr + d, e, f = arr + + [a, b, c, d, e, f] + end + + expandarray + expandarray +} + +assert_equal '[1, 1]', %q{ + def expandarray_useless_splat + arr = (1..10).to_a + + a, * = arr + b, (*) = arr + + [a, b] + end + + expandarray_useless_splat + expandarray_useless_splat +} + +assert_equal '[:not_heap, nil, nil]', %q{ + def expandarray_not_heap + a, b, c = :not_heap + [a, b, c] + end + + expandarray_not_heap + expandarray_not_heap +} + +assert_equal '[:not_array, nil, nil]', %q{ + def expandarray_not_array(obj) + a, b, c = obj + [a, b, c] + end + + obj = Object.new + def obj.to_ary + [:not_array] + end + + expandarray_not_array(obj) + expandarray_not_array(obj) +} + +assert_equal '[1, 2, nil]', %q{ + def expandarray_rhs_too_small + a, b, c = [1, 2] + [a, b, c] + end + + expandarray_rhs_too_small + expandarray_rhs_too_small +} + +assert_equal '[1, [2]]', %q{ + def expandarray_splat + a, *b = [1, 2] + [a, b] + end + + expandarray_splat + expandarray_splat +} + +assert_equal '2', %q{ + def expandarray_postarg + *, a = [1, 2] + a + end + + expandarray_postarg + expandarray_postarg +} + +assert_equal '10', %q{ + obj = Object.new + val = nil + obj.define_singleton_method(:to_ary) { val = 10; [] } + + def expandarray_always_call_to_ary(object) + * = object + end + + expandarray_always_call_to_ary(obj) + expandarray_always_call_to_ary(obj) + + val +} + +# regression test of local type change +assert_equal '1.1', %q{ +def bar(baz, quux) + if baz.integer? + baz, quux = quux, nil + end + baz.to_s +end + +bar(123, 1.1) +bar(123, 1.1) +} + +# test enabling a line TracePoint in a C method call +assert_equal '[[:line, true]]', %q{ + events = [] + events.instance_variable_set( + :@tp, + TracePoint.new(:line) { |tp| events << [tp.event, tp.lineno] if tp.path == __FILE__ } + ) + def events.to_str + @tp.enable; '' + end + + # Stay in generated code while enabling tracing + def events.compiled(obj) + String(obj) + @tp.disable; __LINE__ + end + + line = events.compiled(events) + events[0][-1] = (events[0][-1] == line) + + events +} + +# test enabling a c_return TracePoint in a C method call +assert_equal '[[:c_return, :String, :string_alias, "events_to_str"]]', %q{ + events = [] + events.instance_variable_set(:@tp, TracePoint.new(:c_return) { |tp| events << [tp.event, tp.method_id, tp.callee_id, tp.return_value] }) + def events.to_str + @tp.enable; 'events_to_str' + end + + # Stay in generated code while enabling tracing + alias string_alias String + def events.compiled(obj) + string_alias(obj) + @tp.disable + end + + events.compiled(events) + + events +} + +# test enabling a TracePoint that targets a particular line in a C method call +assert_equal '[true]', %q{ + events = [] + events.instance_variable_set(:@tp, TracePoint.new(:line) { |tp| events << tp.lineno }) + def events.to_str + @tp.enable(target: method(:compiled)) + '' + end + + # Stay in generated code while enabling tracing + def events.compiled(obj) + String(obj) + __LINE__ + end + + line = events.compiled(events) + events[0] = (events[0] == line) + + events +} + +# test enabling tracing in the middle of splatarray +assert_equal '[true]', %q{ + events = [] + obj = Object.new + obj.instance_variable_set(:@tp, TracePoint.new(:line) { |tp| events << tp.lineno }) + def obj.to_a + @tp.enable(target: method(:compiled)) + [] + end + + # Enable tracing in the middle of the splatarray instruction + def obj.compiled(obj) + * = *obj + __LINE__ + end + + obj.compiled([]) + line = obj.compiled(obj) + events[0] = (events[0] == line) + + events +} + +# test enabling tracing in the middle of opt_aref. Different since the codegen +# for it ends in a jump. +assert_equal '[true]', %q{ + def lookup(hash, tp) + hash[42] + tp.disable; __LINE__ + end + + lines = [] + tp = TracePoint.new(:line) { lines << _1.lineno if _1.path == __FILE__ } + + lookup(:foo, tp) + lookup({}, tp) + + enable_tracing_on_missing = Hash.new { tp.enable } + + expected_line = lookup(enable_tracing_on_missing, tp) + + lines[0] = true if lines[0] == expected_line + + lines +} + +# test enabling c_call tracing before compiling +assert_equal '[[:c_call, :itself]]', %q{ + def shouldnt_compile + itself + end + + events = [] + tp = TracePoint.new(:c_call) { |tp| events << [tp.event, tp.method_id] } + + # assume first call compiles + tp.enable { shouldnt_compile } + + events +} + +# test enabling c_return tracing before compiling +assert_equal '[[:c_return, :itself, main]]', %q{ + def shouldnt_compile + itself + end + + events = [] + tp = TracePoint.new(:c_return) { |tp| events << [tp.event, tp.method_id, tp.return_value] } + + # assume first call compiles + tp.enable { shouldnt_compile } + + events +} + +# test enabling tracing for a suspended fiber +assert_equal '[[:return, 42]]', %q{ + def traced_method + Fiber.yield + 42 + end + + events = [] + tp = TracePoint.new(:return) { events << [_1.event, _1.return_value] } + # assume first call compiles + fiber = Fiber.new { traced_method } + fiber.resume + tp.enable(target: method(:traced_method)) + fiber.resume + + events +} + +# test compiling on non-tracing ractor then running on a tracing one +assert_equal '[:itself]', %q{ + def traced_method + itself + end + + + tracing_ractor = Ractor.new do + # 1: start tracing + events = [] + tp = TracePoint.new(:c_call) { events << _1.method_id } + tp.enable + Ractor.yield(nil) + + # 3: run compiled method on tracing ractor + Ractor.yield(nil) + traced_method + + events + ensure + tp&.disable + end + + tracing_ractor.take + + # 2: compile on non tracing ractor + traced_method + + tracing_ractor.take + tracing_ractor.take +} + +# Try to hit a lazy branch stub while another ractor enables tracing +assert_equal '42', %q{ + def compiled(arg) + if arg + arg + 1 + else + itself + itself + end + end + + ractor = Ractor.new do + compiled(false) + Ractor.yield(nil) + compiled(41) + end + + tp = TracePoint.new(:line) { itself } + ractor.take + tp.enable + + ractor.take +} + +# Test equality with changing types +assert_equal '[true, false, false, false]', %q{ + def eq(a, b) + a == b + end + + [ + eq("foo", "foo"), + eq("foo", "bar"), + eq(:foo, "bar"), + eq("foo", :bar) + ] +} + +# Redefined String eq +assert_equal 'true', %q{ + class String + def ==(other) + true + end + end + + def eq(a, b) + a == b + end + + eq("foo", "bar") + eq("foo", "bar") +} + +# Redefined Integer eq +assert_equal 'true', %q{ + class Integer + def ==(other) + true + end + end + + def eq(a, b) + a == b + end + + eq(1, 2) + eq(1, 2) +} + +# aset on array with invalid key +assert_normal_exit %q{ + def foo(arr) + arr[:foo] = 123 + end + + foo([1]) rescue nil + foo([1]) rescue nil +} + +# test ractor exception on when setting ivar +assert_equal '42', %q{ + class A + def self.foo + _foo = 1 + _bar = 2 + begin + @bar = _foo + _bar + rescue Ractor::IsolationError + 42 + end + end + end + + A.foo + A.foo + + Ractor.new { A.foo }.take +} + +assert_equal '["plain", "special", "sub", "plain"]', %q{ + def foo(arg) + arg.to_s + end + + class Sub < String + end + + special = String.new("special") + special.singleton_class + + [ + foo("plain"), + foo(special), + foo(Sub.new("sub")), + foo("plain") + ] +} + +assert_equal '["sub", "sub"]', %q{ + def foo(arg) + arg.to_s + end + + class Sub < String + def to_s + super + end + end + + sub = Sub.new("sub") + + [foo(sub), foo(sub)] +} + +assert_equal '[1]', %q{ + def kwargs(value:) + value + end + + 5.times.map { kwargs(value: 1) }.uniq +} + +assert_equal '[[1, 2]]', %q{ + def kwargs(left:, right:) + [left, right] + end + + 5.times.flat_map do + [ + kwargs(left: 1, right: 2), + kwargs(right: 2, left: 1) + ] + end.uniq +} + +assert_equal '[[1, 2]]', %q{ + def kwargs(lead, kwarg:) + [lead, kwarg] + end + + 5.times.map { kwargs(1, kwarg: 2) }.uniq +} + +# leading and keyword arguments are swapped into the right order +assert_equal '[[1, 2, 3, 4, 5, 6]]', %q{ + def kwargs(five, six, a:, b:, c:, d:) + [a, b, c, d, five, six] + end + + 5.times.flat_map do + [ + kwargs(5, 6, a: 1, b: 2, c: 3, d: 4), + kwargs(5, 6, a: 1, b: 2, d: 4, c: 3), + kwargs(5, 6, a: 1, c: 3, b: 2, d: 4), + kwargs(5, 6, a: 1, c: 3, d: 4, b: 2), + kwargs(5, 6, a: 1, d: 4, b: 2, c: 3), + kwargs(5, 6, a: 1, d: 4, c: 3, b: 2), + kwargs(5, 6, b: 2, a: 1, c: 3, d: 4), + kwargs(5, 6, b: 2, a: 1, d: 4, c: 3), + kwargs(5, 6, b: 2, c: 3, a: 1, d: 4), + kwargs(5, 6, b: 2, c: 3, d: 4, a: 1), + kwargs(5, 6, b: 2, d: 4, a: 1, c: 3), + kwargs(5, 6, b: 2, d: 4, c: 3, a: 1), + kwargs(5, 6, c: 3, a: 1, b: 2, d: 4), + kwargs(5, 6, c: 3, a: 1, d: 4, b: 2), + kwargs(5, 6, c: 3, b: 2, a: 1, d: 4), + kwargs(5, 6, c: 3, b: 2, d: 4, a: 1), + kwargs(5, 6, c: 3, d: 4, a: 1, b: 2), + kwargs(5, 6, c: 3, d: 4, b: 2, a: 1), + kwargs(5, 6, d: 4, a: 1, b: 2, c: 3), + kwargs(5, 6, d: 4, a: 1, c: 3, b: 2), + kwargs(5, 6, d: 4, b: 2, a: 1, c: 3), + kwargs(5, 6, d: 4, b: 2, c: 3, a: 1), + kwargs(5, 6, d: 4, c: 3, a: 1, b: 2), + kwargs(5, 6, d: 4, c: 3, b: 2, a: 1) + ] + end.uniq +} + +# implicit hashes get skipped and don't break compilation +assert_equal '[[:key]]', %q{ + def implicit(hash) + hash.keys + end + + 5.times.map { implicit(key: :value) }.uniq +} + +# default values on keywords don't mess up argument order +assert_equal '[2]', %q{ + def default_value + 1 + end + + def default_expression(value: default_value) + value + end + + 5.times.map { default_expression(value: 2) }.uniq +} + +# constant default values on keywords +assert_equal '[3]', %q{ + def default_expression(value: 3) + value + end + + 5.times.map { default_expression }.uniq +} + +# non-constant default values on keywords +assert_equal '[3]', %q{ + def default_value + 3 + end + + def default_expression(value: default_value) + value + end + + 5.times.map { default_expression }.uniq +} + +# reordered optional kwargs +assert_equal '[[100, 1]]', %q{ + def foo(capacity: 100, max: nil) + [capacity, max] + end + + 5.times.map { foo(max: 1) }.uniq +} + +# invalid lead param +assert_equal 'ok', %q{ + def bar(baz: 2) + baz + end + + def foo + bar(1, baz: 123) + end + + begin + foo + foo + rescue ArgumentError => e + print "ok" + end +} + +# reordered required kwargs +assert_equal '[[1, 2, 3, 4]]', %q{ + def foo(default1: 1, required1:, default2: 3, required2:) + [default1, required1, default2, required2] + end + + 5.times.map { foo(required1: 2, required2: 4) }.uniq +} + +# reordered default expression kwargs +assert_equal '[[:one, :two, 3]]', %q{ + def foo(arg1: (1+0), arg2: (2+0), arg3: (3+0)) + [arg1, arg2, arg3] + end + + 5.times.map { foo(arg2: :two, arg1: :one) }.uniq +} + +# complex kwargs +assert_equal '[[1, 2, 3, 4]]', %q{ + def foo(required:, specified: 999, simple_default: 3, complex_default: "4".to_i) + [required, specified, simple_default, complex_default] + end + + 5.times.map { foo(specified: 2, required: 1) }.uniq +} + +# attr_reader on frozen object +assert_equal 'false', %q{ + class Foo + attr_reader :exception + + def failed? + !exception.nil? + end + end + + foo = Foo.new.freeze + foo.failed? + foo.failed? +} + +# regression test for doing kwarg shuffle before checking for interrupts +assert_equal 'ok', %q{ + def new_media_drop(attributes:, product_drop:, context:, sources:) + nil.nomethod rescue nil # force YJIT to bail to side exit + + [attributes, product_drop, context, sources] + end + + def load_medias(product_drop: nil, raw_medias:, context:) + raw_medias.map do |raw_media| + case new_media_drop(context: context, attributes: raw_media, product_drop: product_drop, sources: []) + in [Hash, ProductDrop, Context, Array] + else + raise "bad shuffle" + end + end + end + + class Context; end + + class ProductDrop + attr_reader :title + def initialize(title) + @title = title + end + end + + # Make a thread so we have thread switching interrupts + th = Thread.new do + while true; end + end + 1_000.times do |i| + load_medias(product_drop: ProductDrop.new("foo"), raw_medias: [{}, {}], context: Context.new) + end + th.kill.join + + :ok +} + +# regression test for tracing attr_accessor methods. +assert_equal "true", %q{ + c = Class.new do + attr_accessor :x + alias y x + alias y= x= + end + obj = c.new + + ar_meth = obj.method(:x) + aw_meth = obj.method(:x=) + aar_meth = obj.method(:y) + aaw_meth = obj.method(:y=) + events = [] + trace = TracePoint.new(:c_call, :c_return){|tp| + next if tp.path != __FILE__ + next if tp.method_id == :call + case tp.event + when :c_call + events << [tp.event, tp.method_id, tp.callee_id] + when :c_return + events << [tp.event, tp.method_id, tp.callee_id, tp.return_value] + end + } + test_proc = proc do + obj.x = 1 + obj.x + obj.y = 2 + obj.y + aw_meth.call(1) + ar_meth.call + aaw_meth.call(2) + aar_meth.call + end + test_proc.call # populate call caches + trace.enable(&test_proc) + expected = [ + [:c_call, :x=, :x=], + [:c_return, :x=, :x=, 1], + [:c_call, :x, :x], + [:c_return, :x, :x, 1], + [:c_call, :x=, :y=], + [:c_return, :x=, :y=, 2], + [:c_call, :x, :y], + [:c_return, :x, :y, 2], + ] * 2 + + expected == events +} + +# duphash +assert_equal '{:foo=>123}', %q{ + def foo + {foo: 123} + end + + foo + foo +} + +# newhash +assert_equal '{:foo=>2}', %q{ + def foo + {foo: 1+1} + end + + foo + foo +} + +# block invalidation edge case +assert_equal 'undef', %q{ + class A + def foo(arg) + arg.times { A.remove_method(:bar) } + self + end + + def bar + 4 + end + + def use(arg) + # two consecutive sends. When bar is removed, the return address + # for calling it is already on foo's control frame + foo(arg).bar + rescue NoMethodError + :undef + end + end + + A.new.use 0 + A.new.use 0 + A.new.use 1 +} + +# block invalidation edge case +assert_equal 'ok', %q{ + class A + Good = :ng + def foo(arg) + arg.times { A.const_set(:Good, :ok) } + self + end + + def id(arg) + arg + end + + def use(arg) + # send followed by an opt_getinlinecache. + # The return address remains on the control frame + # when opt_getinlinecache is invalidated. + foo(arg).id(Good) + end + end + + A.new.use 0 + A.new.use 0 + A.new.use 1 +} + +assert_equal 'ok', %q{ + # test hitting a branch stub when out of memory + def nimai(jita) + if jita + :ng + else + :ok + end + end + + nimai(true) + nimai(true) + + RubyVM::YJIT.simulate_oom! if defined?(RubyVM::YJIT) + + nimai(false) +} + +assert_equal 'new', %q{ + # test block invalidation while out of memory + def foo + :old + end + + def test + foo + end + + test + test + + RubyVM::YJIT.simulate_oom! if defined?(RubyVM::YJIT) + + def foo + :new + end + + test +} + +assert_equal 'ok', %q{ + # Try to compile new method while OOM + def foo + :ok + end + + RubyVM::YJIT.simulate_oom! if defined?(RubyVM::YJIT) + + foo + foo +} + +# struct aref embedded +assert_equal '2', %q{ + def foo(s) + s.foo + end + + S = Struct.new(:foo) + foo(S.new(1)) + foo(S.new(2)) +} + +# struct aref non-embedded +assert_equal '4', %q{ + def foo(s) + s.d + end + + S = Struct.new(:a, :b, :c, :d, :e) + foo(S.new(1,2,3,4,5)) + foo(S.new(1,2,3,4,5)) +} + +# struct aset embedded +assert_equal '123', %q{ + def foo(s) + s.foo = 123 + end + + s = Struct.new(:foo).new + foo(s) + s = Struct.new(:foo).new + foo(s) + s.foo +} + +# struct aset non-embedded +assert_equal '[1, 2, 3, 4, 5]', %q{ + def foo(s) + s.a = 1 + s.b = 2 + s.c = 3 + s.d = 4 + s.e = 5 + end + + S = Struct.new(:a, :b, :c, :d, :e) + s = S.new + foo(s) + s = S.new + foo(s) + [s.a, s.b, s.c, s.d, s.e] +} + +# struct aref too many args +assert_equal 'ok', %q{ + def foo(s) + s.foo(:bad) + end + + s = Struct.new(:foo).new + foo(s) rescue :ok + foo(s) rescue :ok +} + +# struct aset too many args +assert_equal 'ok', %q{ + def foo(s) + s.set_foo(123, :bad) + end + + s = Struct.new(:foo) do + alias :set_foo :foo= + end + foo(s) rescue :ok + foo(s) rescue :ok +} diff --git a/bootstraptest/test_yjit_30k_ifelse.rb b/bootstraptest/test_yjit_30k_ifelse.rb new file mode 100644 index 00000000000..c3afa95e4dd --- /dev/null +++ b/bootstraptest/test_yjit_30k_ifelse.rb @@ -0,0 +1,241023 @@ +# This is a torture test for the JIT. +# There are 30K tiny methods with if-else statements in a 30-deep call hierarchy. +assert_equal '100000', %q{ + +def fun_l0_n0(x) + if (x < 1) + fun_l1_n310(x) + else + fun_l1_n485(x) + end +end + +def fun_l0_n1(x) + if (x < 1) + fun_l1_n930(x) + else + fun_l1_n418(x) + end +end + +def fun_l0_n2(x) + if (x < 1) + fun_l1_n549(x) + else + fun_l1_n44(x) + end +end + +def fun_l0_n3(x) + if (x < 1) + fun_l1_n394(x) + else + fun_l1_n447(x) + end +end + +def fun_l0_n4(x) + if (x < 1) + fun_l1_n683(x) + else + fun_l1_n547(x) + end +end + +def fun_l0_n5(x) + if (x < 1) + fun_l1_n320(x) + else + fun_l1_n896(x) + end +end + +def fun_l0_n6(x) + if (x < 1) + fun_l1_n649(x) + else + fun_l1_n243(x) + end +end + +def fun_l0_n7(x) + if (x < 1) + fun_l1_n100(x) + else + fun_l1_n243(x) + end +end + +def fun_l0_n8(x) + if (x < 1) + fun_l1_n839(x) + else + fun_l1_n720(x) + end +end + +def fun_l0_n9(x) + if (x < 1) + fun_l1_n177(x) + else + fun_l1_n555(x) + end +end + +def fun_l0_n10(x) + if (x < 1) + fun_l1_n814(x) + else + fun_l1_n900(x) + end +end + +def fun_l0_n11(x) + if (x < 1) + fun_l1_n585(x) + else + fun_l1_n901(x) + end +end + +def fun_l0_n12(x) + if (x < 1) + fun_l1_n952(x) + else + fun_l1_n270(x) + end +end + +def fun_l0_n13(x) + if (x < 1) + fun_l1_n172(x) + else + fun_l1_n209(x) + end +end + +def fun_l0_n14(x) + if (x < 1) + fun_l1_n514(x) + else + fun_l1_n414(x) + end +end + +def fun_l0_n15(x) + if (x < 1) + fun_l1_n190(x) + else + fun_l1_n100(x) + end +end + +def fun_l0_n16(x) + if (x < 1) + fun_l1_n696(x) + else + fun_l1_n997(x) + end +end + +def fun_l0_n17(x) + if (x < 1) + fun_l1_n568(x) + else + fun_l1_n820(x) + end +end + +def fun_l0_n18(x) + if (x < 1) + fun_l1_n837(x) + else + fun_l1_n588(x) + end +end + +def fun_l0_n19(x) + if (x < 1) + fun_l1_n206(x) + else + fun_l1_n126(x) + end +end + +def fun_l0_n20(x) + if (x < 1) + fun_l1_n317(x) + else + fun_l1_n722(x) + end +end + +def fun_l0_n21(x) + if (x < 1) + fun_l1_n614(x) + else + fun_l1_n372(x) + end +end + +def fun_l0_n22(x) + if (x < 1) + fun_l1_n530(x) + else + fun_l1_n862(x) + end +end + +def fun_l0_n23(x) + if (x < 1) + fun_l1_n889(x) + else + fun_l1_n271(x) + end +end + +def fun_l0_n24(x) + if (x < 1) + fun_l1_n996(x) + else + fun_l1_n717(x) + end +end + +def fun_l0_n25(x) + if (x < 1) + fun_l1_n726(x) + else + fun_l1_n939(x) + end +end + +def fun_l0_n26(x) + if (x < 1) + fun_l1_n316(x) + else + fun_l1_n293(x) + end +end + +def fun_l0_n27(x) + if (x < 1) + fun_l1_n90(x) + else + fun_l1_n596(x) + end +end + +def fun_l0_n28(x) + if (x < 1) + fun_l1_n743(x) + else + fun_l1_n782(x) + end +end + +def fun_l0_n29(x) + if (x < 1) + fun_l1_n896(x) + else + fun_l1_n247(x) + end +end + +def fun_l0_n30(x) + if (x < 1) + fun_l1_n2(x) + else + fun_l1_n377(x) + end +end + +def fun_l0_n31(x) + if (x < 1) + fun_l1_n380(x) + else + fun_l1_n655(x) + end +end + +def fun_l0_n32(x) + if (x < 1) + fun_l1_n572(x) + else + fun_l1_n778(x) + end +end + +def fun_l0_n33(x) + if (x < 1) + fun_l1_n485(x) + else + fun_l1_n282(x) + end +end + +def fun_l0_n34(x) + if (x < 1) + fun_l1_n703(x) + else + fun_l1_n179(x) + end +end + +def fun_l0_n35(x) + if (x < 1) + fun_l1_n281(x) + else + fun_l1_n572(x) + end +end + +def fun_l0_n36(x) + if (x < 1) + fun_l1_n48(x) + else + fun_l1_n286(x) + end +end + +def fun_l0_n37(x) + if (x < 1) + fun_l1_n539(x) + else + fun_l1_n86(x) + end +end + +def fun_l0_n38(x) + if (x < 1) + fun_l1_n918(x) + else + fun_l1_n778(x) + end +end + +def fun_l0_n39(x) + if (x < 1) + fun_l1_n832(x) + else + fun_l1_n94(x) + end +end + +def fun_l0_n40(x) + if (x < 1) + fun_l1_n213(x) + else + fun_l1_n580(x) + end +end + +def fun_l0_n41(x) + if (x < 1) + fun_l1_n413(x) + else + fun_l1_n793(x) + end +end + +def fun_l0_n42(x) + if (x < 1) + fun_l1_n451(x) + else + fun_l1_n779(x) + end +end + +def fun_l0_n43(x) + if (x < 1) + fun_l1_n118(x) + else + fun_l1_n778(x) + end +end + +def fun_l0_n44(x) + if (x < 1) + fun_l1_n162(x) + else + fun_l1_n901(x) + end +end + +def fun_l0_n45(x) + if (x < 1) + fun_l1_n157(x) + else + fun_l1_n280(x) + end +end + +def fun_l0_n46(x) + if (x < 1) + fun_l1_n748(x) + else + fun_l1_n881(x) + end +end + +def fun_l0_n47(x) + if (x < 1) + fun_l1_n529(x) + else + fun_l1_n732(x) + end +end + +def fun_l0_n48(x) + if (x < 1) + fun_l1_n417(x) + else + fun_l1_n483(x) + end +end + +def fun_l0_n49(x) + if (x < 1) + fun_l1_n743(x) + else + fun_l1_n525(x) + end +end + +def fun_l0_n50(x) + if (x < 1) + fun_l1_n14(x) + else + fun_l1_n309(x) + end +end + +def fun_l0_n51(x) + if (x < 1) + fun_l1_n436(x) + else + fun_l1_n304(x) + end +end + +def fun_l0_n52(x) + if (x < 1) + fun_l1_n623(x) + else + fun_l1_n590(x) + end +end + +def fun_l0_n53(x) + if (x < 1) + fun_l1_n696(x) + else + fun_l1_n53(x) + end +end + +def fun_l0_n54(x) + if (x < 1) + fun_l1_n807(x) + else + fun_l1_n523(x) + end +end + +def fun_l0_n55(x) + if (x < 1) + fun_l1_n607(x) + else + fun_l1_n609(x) + end +end + +def fun_l0_n56(x) + if (x < 1) + fun_l1_n721(x) + else + fun_l1_n994(x) + end +end + +def fun_l0_n57(x) + if (x < 1) + fun_l1_n472(x) + else + fun_l1_n818(x) + end +end + +def fun_l0_n58(x) + if (x < 1) + fun_l1_n30(x) + else + fun_l1_n954(x) + end +end + +def fun_l0_n59(x) + if (x < 1) + fun_l1_n223(x) + else + fun_l1_n148(x) + end +end + +def fun_l0_n60(x) + if (x < 1) + fun_l1_n761(x) + else + fun_l1_n40(x) + end +end + +def fun_l0_n61(x) + if (x < 1) + fun_l1_n57(x) + else + fun_l1_n858(x) + end +end + +def fun_l0_n62(x) + if (x < 1) + fun_l1_n114(x) + else + fun_l1_n767(x) + end +end + +def fun_l0_n63(x) + if (x < 1) + fun_l1_n287(x) + else + fun_l1_n752(x) + end +end + +def fun_l0_n64(x) + if (x < 1) + fun_l1_n16(x) + else + fun_l1_n229(x) + end +end + +def fun_l0_n65(x) + if (x < 1) + fun_l1_n230(x) + else + fun_l1_n954(x) + end +end + +def fun_l0_n66(x) + if (x < 1) + fun_l1_n98(x) + else + fun_l1_n320(x) + end +end + +def fun_l0_n67(x) + if (x < 1) + fun_l1_n878(x) + else + fun_l1_n985(x) + end +end + +def fun_l0_n68(x) + if (x < 1) + fun_l1_n32(x) + else + fun_l1_n648(x) + end +end + +def fun_l0_n69(x) + if (x < 1) + fun_l1_n453(x) + else + fun_l1_n466(x) + end +end + +def fun_l0_n70(x) + if (x < 1) + fun_l1_n787(x) + else + fun_l1_n802(x) + end +end + +def fun_l0_n71(x) + if (x < 1) + fun_l1_n656(x) + else + fun_l1_n347(x) + end +end + +def fun_l0_n72(x) + if (x < 1) + fun_l1_n358(x) + else + fun_l1_n336(x) + end +end + +def fun_l0_n73(x) + if (x < 1) + fun_l1_n291(x) + else + fun_l1_n536(x) + end +end + +def fun_l0_n74(x) + if (x < 1) + fun_l1_n795(x) + else + fun_l1_n606(x) + end +end + +def fun_l0_n75(x) + if (x < 1) + fun_l1_n21(x) + else + fun_l1_n720(x) + end +end + +def fun_l0_n76(x) + if (x < 1) + fun_l1_n513(x) + else + fun_l1_n300(x) + end +end + +def fun_l0_n77(x) + if (x < 1) + fun_l1_n358(x) + else + fun_l1_n332(x) + end +end + +def fun_l0_n78(x) + if (x < 1) + fun_l1_n712(x) + else + fun_l1_n906(x) + end +end + +def fun_l0_n79(x) + if (x < 1) + fun_l1_n555(x) + else + fun_l1_n850(x) + end +end + +def fun_l0_n80(x) + if (x < 1) + fun_l1_n320(x) + else + fun_l1_n892(x) + end +end + +def fun_l0_n81(x) + if (x < 1) + fun_l1_n191(x) + else + fun_l1_n187(x) + end +end + +def fun_l0_n82(x) + if (x < 1) + fun_l1_n457(x) + else + fun_l1_n718(x) + end +end + +def fun_l0_n83(x) + if (x < 1) + fun_l1_n314(x) + else + fun_l1_n697(x) + end +end + +def fun_l0_n84(x) + if (x < 1) + fun_l1_n459(x) + else + fun_l1_n500(x) + end +end + +def fun_l0_n85(x) + if (x < 1) + fun_l1_n912(x) + else + fun_l1_n992(x) + end +end + +def fun_l0_n86(x) + if (x < 1) + fun_l1_n523(x) + else + fun_l1_n201(x) + end +end + +def fun_l0_n87(x) + if (x < 1) + fun_l1_n30(x) + else + fun_l1_n829(x) + end +end + +def fun_l0_n88(x) + if (x < 1) + fun_l1_n223(x) + else + fun_l1_n799(x) + end +end + +def fun_l0_n89(x) + if (x < 1) + fun_l1_n289(x) + else + fun_l1_n289(x) + end +end + +def fun_l0_n90(x) + if (x < 1) + fun_l1_n961(x) + else + fun_l1_n694(x) + end +end + +def fun_l0_n91(x) + if (x < 1) + fun_l1_n423(x) + else + fun_l1_n848(x) + end +end + +def fun_l0_n92(x) + if (x < 1) + fun_l1_n612(x) + else + fun_l1_n358(x) + end +end + +def fun_l0_n93(x) + if (x < 1) + fun_l1_n148(x) + else + fun_l1_n312(x) + end +end + +def fun_l0_n94(x) + if (x < 1) + fun_l1_n771(x) + else + fun_l1_n205(x) + end +end + +def fun_l0_n95(x) + if (x < 1) + fun_l1_n573(x) + else + fun_l1_n692(x) + end +end + +def fun_l0_n96(x) + if (x < 1) + fun_l1_n66(x) + else + fun_l1_n936(x) + end +end + +def fun_l0_n97(x) + if (x < 1) + fun_l1_n429(x) + else + fun_l1_n949(x) + end +end + +def fun_l0_n98(x) + if (x < 1) + fun_l1_n737(x) + else + fun_l1_n338(x) + end +end + +def fun_l0_n99(x) + if (x < 1) + fun_l1_n335(x) + else + fun_l1_n739(x) + end +end + +def fun_l0_n100(x) + if (x < 1) + fun_l1_n989(x) + else + fun_l1_n735(x) + end +end + +def fun_l0_n101(x) + if (x < 1) + fun_l1_n559(x) + else + fun_l1_n478(x) + end +end + +def fun_l0_n102(x) + if (x < 1) + fun_l1_n261(x) + else + fun_l1_n162(x) + end +end + +def fun_l0_n103(x) + if (x < 1) + fun_l1_n400(x) + else + fun_l1_n156(x) + end +end + +def fun_l0_n104(x) + if (x < 1) + fun_l1_n747(x) + else + fun_l1_n361(x) + end +end + +def fun_l0_n105(x) + if (x < 1) + fun_l1_n717(x) + else + fun_l1_n522(x) + end +end + +def fun_l0_n106(x) + if (x < 1) + fun_l1_n513(x) + else + fun_l1_n150(x) + end +end + +def fun_l0_n107(x) + if (x < 1) + fun_l1_n710(x) + else + fun_l1_n602(x) + end +end + +def fun_l0_n108(x) + if (x < 1) + fun_l1_n866(x) + else + fun_l1_n111(x) + end +end + +def fun_l0_n109(x) + if (x < 1) + fun_l1_n725(x) + else + fun_l1_n448(x) + end +end + +def fun_l0_n110(x) + if (x < 1) + fun_l1_n703(x) + else + fun_l1_n127(x) + end +end + +def fun_l0_n111(x) + if (x < 1) + fun_l1_n420(x) + else + fun_l1_n666(x) + end +end + +def fun_l0_n112(x) + if (x < 1) + fun_l1_n647(x) + else + fun_l1_n567(x) + end +end + +def fun_l0_n113(x) + if (x < 1) + fun_l1_n543(x) + else + fun_l1_n992(x) + end +end + +def fun_l0_n114(x) + if (x < 1) + fun_l1_n12(x) + else + fun_l1_n470(x) + end +end + +def fun_l0_n115(x) + if (x < 1) + fun_l1_n25(x) + else + fun_l1_n917(x) + end +end + +def fun_l0_n116(x) + if (x < 1) + fun_l1_n201(x) + else + fun_l1_n110(x) + end +end + +def fun_l0_n117(x) + if (x < 1) + fun_l1_n222(x) + else + fun_l1_n747(x) + end +end + +def fun_l0_n118(x) + if (x < 1) + fun_l1_n990(x) + else + fun_l1_n794(x) + end +end + +def fun_l0_n119(x) + if (x < 1) + fun_l1_n712(x) + else + fun_l1_n5(x) + end +end + +def fun_l0_n120(x) + if (x < 1) + fun_l1_n28(x) + else + fun_l1_n89(x) + end +end + +def fun_l0_n121(x) + if (x < 1) + fun_l1_n341(x) + else + fun_l1_n983(x) + end +end + +def fun_l0_n122(x) + if (x < 1) + fun_l1_n123(x) + else + fun_l1_n452(x) + end +end + +def fun_l0_n123(x) + if (x < 1) + fun_l1_n514(x) + else + fun_l1_n949(x) + end +end + +def fun_l0_n124(x) + if (x < 1) + fun_l1_n280(x) + else + fun_l1_n281(x) + end +end + +def fun_l0_n125(x) + if (x < 1) + fun_l1_n512(x) + else + fun_l1_n772(x) + end +end + +def fun_l0_n126(x) + if (x < 1) + fun_l1_n911(x) + else + fun_l1_n693(x) + end +end + +def fun_l0_n127(x) + if (x < 1) + fun_l1_n633(x) + else + fun_l1_n574(x) + end +end + +def fun_l0_n128(x) + if (x < 1) + fun_l1_n318(x) + else + fun_l1_n266(x) + end +end + +def fun_l0_n129(x) + if (x < 1) + fun_l1_n677(x) + else + fun_l1_n10(x) + end +end + +def fun_l0_n130(x) + if (x < 1) + fun_l1_n994(x) + else + fun_l1_n48(x) + end +end + +def fun_l0_n131(x) + if (x < 1) + fun_l1_n335(x) + else + fun_l1_n473(x) + end +end + +def fun_l0_n132(x) + if (x < 1) + fun_l1_n641(x) + else + fun_l1_n48(x) + end +end + +def fun_l0_n133(x) + if (x < 1) + fun_l1_n914(x) + else + fun_l1_n818(x) + end +end + +def fun_l0_n134(x) + if (x < 1) + fun_l1_n479(x) + else + fun_l1_n761(x) + end +end + +def fun_l0_n135(x) + if (x < 1) + fun_l1_n186(x) + else + fun_l1_n692(x) + end +end + +def fun_l0_n136(x) + if (x < 1) + fun_l1_n325(x) + else + fun_l1_n279(x) + end +end + +def fun_l0_n137(x) + if (x < 1) + fun_l1_n493(x) + else + fun_l1_n293(x) + end +end + +def fun_l0_n138(x) + if (x < 1) + fun_l1_n788(x) + else + fun_l1_n364(x) + end +end + +def fun_l0_n139(x) + if (x < 1) + fun_l1_n565(x) + else + fun_l1_n63(x) + end +end + +def fun_l0_n140(x) + if (x < 1) + fun_l1_n128(x) + else + fun_l1_n299(x) + end +end + +def fun_l0_n141(x) + if (x < 1) + fun_l1_n782(x) + else + fun_l1_n195(x) + end +end + +def fun_l0_n142(x) + if (x < 1) + fun_l1_n696(x) + else + fun_l1_n117(x) + end +end + +def fun_l0_n143(x) + if (x < 1) + fun_l1_n263(x) + else + fun_l1_n683(x) + end +end + +def fun_l0_n144(x) + if (x < 1) + fun_l1_n633(x) + else + fun_l1_n92(x) + end +end + +def fun_l0_n145(x) + if (x < 1) + fun_l1_n626(x) + else + fun_l1_n201(x) + end +end + +def fun_l0_n146(x) + if (x < 1) + fun_l1_n296(x) + else + fun_l1_n425(x) + end +end + +def fun_l0_n147(x) + if (x < 1) + fun_l1_n395(x) + else + fun_l1_n750(x) + end +end + +def fun_l0_n148(x) + if (x < 1) + fun_l1_n164(x) + else + fun_l1_n580(x) + end +end + +def fun_l0_n149(x) + if (x < 1) + fun_l1_n904(x) + else + fun_l1_n264(x) + end +end + +def fun_l0_n150(x) + if (x < 1) + fun_l1_n383(x) + else + fun_l1_n558(x) + end +end + +def fun_l0_n151(x) + if (x < 1) + fun_l1_n522(x) + else + fun_l1_n735(x) + end +end + +def fun_l0_n152(x) + if (x < 1) + fun_l1_n496(x) + else + fun_l1_n562(x) + end +end + +def fun_l0_n153(x) + if (x < 1) + fun_l1_n374(x) + else + fun_l1_n561(x) + end +end + +def fun_l0_n154(x) + if (x < 1) + fun_l1_n314(x) + else + fun_l1_n368(x) + end +end + +def fun_l0_n155(x) + if (x < 1) + fun_l1_n456(x) + else + fun_l1_n189(x) + end +end + +def fun_l0_n156(x) + if (x < 1) + fun_l1_n46(x) + else + fun_l1_n620(x) + end +end + +def fun_l0_n157(x) + if (x < 1) + fun_l1_n259(x) + else + fun_l1_n742(x) + end +end + +def fun_l0_n158(x) + if (x < 1) + fun_l1_n881(x) + else + fun_l1_n786(x) + end +end + +def fun_l0_n159(x) + if (x < 1) + fun_l1_n607(x) + else + fun_l1_n177(x) + end +end + +def fun_l0_n160(x) + if (x < 1) + fun_l1_n824(x) + else + fun_l1_n415(x) + end +end + +def fun_l0_n161(x) + if (x < 1) + fun_l1_n443(x) + else + fun_l1_n787(x) + end +end + +def fun_l0_n162(x) + if (x < 1) + fun_l1_n124(x) + else + fun_l1_n529(x) + end +end + +def fun_l0_n163(x) + if (x < 1) + fun_l1_n696(x) + else + fun_l1_n96(x) + end +end + +def fun_l0_n164(x) + if (x < 1) + fun_l1_n775(x) + else + fun_l1_n549(x) + end +end + +def fun_l0_n165(x) + if (x < 1) + fun_l1_n860(x) + else + fun_l1_n212(x) + end +end + +def fun_l0_n166(x) + if (x < 1) + fun_l1_n378(x) + else + fun_l1_n904(x) + end +end + +def fun_l0_n167(x) + if (x < 1) + fun_l1_n15(x) + else + fun_l1_n640(x) + end +end + +def fun_l0_n168(x) + if (x < 1) + fun_l1_n771(x) + else + fun_l1_n861(x) + end +end + +def fun_l0_n169(x) + if (x < 1) + fun_l1_n468(x) + else + fun_l1_n586(x) + end +end + +def fun_l0_n170(x) + if (x < 1) + fun_l1_n477(x) + else + fun_l1_n674(x) + end +end + +def fun_l0_n171(x) + if (x < 1) + fun_l1_n509(x) + else + fun_l1_n64(x) + end +end + +def fun_l0_n172(x) + if (x < 1) + fun_l1_n612(x) + else + fun_l1_n828(x) + end +end + +def fun_l0_n173(x) + if (x < 1) + fun_l1_n440(x) + else + fun_l1_n204(x) + end +end + +def fun_l0_n174(x) + if (x < 1) + fun_l1_n259(x) + else + fun_l1_n947(x) + end +end + +def fun_l0_n175(x) + if (x < 1) + fun_l1_n402(x) + else + fun_l1_n588(x) + end +end + +def fun_l0_n176(x) + if (x < 1) + fun_l1_n245(x) + else + fun_l1_n540(x) + end +end + +def fun_l0_n177(x) + if (x < 1) + fun_l1_n869(x) + else + fun_l1_n249(x) + end +end + +def fun_l0_n178(x) + if (x < 1) + fun_l1_n830(x) + else + fun_l1_n210(x) + end +end + +def fun_l0_n179(x) + if (x < 1) + fun_l1_n692(x) + else + fun_l1_n222(x) + end +end + +def fun_l0_n180(x) + if (x < 1) + fun_l1_n220(x) + else + fun_l1_n281(x) + end +end + +def fun_l0_n181(x) + if (x < 1) + fun_l1_n523(x) + else + fun_l1_n618(x) + end +end + +def fun_l0_n182(x) + if (x < 1) + fun_l1_n44(x) + else + fun_l1_n422(x) + end +end + +def fun_l0_n183(x) + if (x < 1) + fun_l1_n944(x) + else + fun_l1_n230(x) + end +end + +def fun_l0_n184(x) + if (x < 1) + fun_l1_n678(x) + else + fun_l1_n121(x) + end +end + +def fun_l0_n185(x) + if (x < 1) + fun_l1_n73(x) + else + fun_l1_n398(x) + end +end + +def fun_l0_n186(x) + if (x < 1) + fun_l1_n121(x) + else + fun_l1_n689(x) + end +end + +def fun_l0_n187(x) + if (x < 1) + fun_l1_n946(x) + else + fun_l1_n613(x) + end +end + +def fun_l0_n188(x) + if (x < 1) + fun_l1_n987(x) + else + fun_l1_n785(x) + end +end + +def fun_l0_n189(x) + if (x < 1) + fun_l1_n181(x) + else + fun_l1_n644(x) + end +end + +def fun_l0_n190(x) + if (x < 1) + fun_l1_n623(x) + else + fun_l1_n679(x) + end +end + +def fun_l0_n191(x) + if (x < 1) + fun_l1_n784(x) + else + fun_l1_n274(x) + end +end + +def fun_l0_n192(x) + if (x < 1) + fun_l1_n71(x) + else + fun_l1_n773(x) + end +end + +def fun_l0_n193(x) + if (x < 1) + fun_l1_n516(x) + else + fun_l1_n496(x) + end +end + +def fun_l0_n194(x) + if (x < 1) + fun_l1_n608(x) + else + fun_l1_n460(x) + end +end + +def fun_l0_n195(x) + if (x < 1) + fun_l1_n25(x) + else + fun_l1_n437(x) + end +end + +def fun_l0_n196(x) + if (x < 1) + fun_l1_n410(x) + else + fun_l1_n674(x) + end +end + +def fun_l0_n197(x) + if (x < 1) + fun_l1_n949(x) + else + fun_l1_n708(x) + end +end + +def fun_l0_n198(x) + if (x < 1) + fun_l1_n714(x) + else + fun_l1_n119(x) + end +end + +def fun_l0_n199(x) + if (x < 1) + fun_l1_n41(x) + else + fun_l1_n865(x) + end +end + +def fun_l0_n200(x) + if (x < 1) + fun_l1_n383(x) + else + fun_l1_n90(x) + end +end + +def fun_l0_n201(x) + if (x < 1) + fun_l1_n581(x) + else + fun_l1_n273(x) + end +end + +def fun_l0_n202(x) + if (x < 1) + fun_l1_n350(x) + else + fun_l1_n425(x) + end +end + +def fun_l0_n203(x) + if (x < 1) + fun_l1_n259(x) + else + fun_l1_n922(x) + end +end + +def fun_l0_n204(x) + if (x < 1) + fun_l1_n448(x) + else + fun_l1_n741(x) + end +end + +def fun_l0_n205(x) + if (x < 1) + fun_l1_n86(x) + else + fun_l1_n618(x) + end +end + +def fun_l0_n206(x) + if (x < 1) + fun_l1_n412(x) + else + fun_l1_n646(x) + end +end + +def fun_l0_n207(x) + if (x < 1) + fun_l1_n196(x) + else + fun_l1_n496(x) + end +end + +def fun_l0_n208(x) + if (x < 1) + fun_l1_n777(x) + else + fun_l1_n150(x) + end +end + +def fun_l0_n209(x) + if (x < 1) + fun_l1_n20(x) + else + fun_l1_n718(x) + end +end + +def fun_l0_n210(x) + if (x < 1) + fun_l1_n934(x) + else + fun_l1_n416(x) + end +end + +def fun_l0_n211(x) + if (x < 1) + fun_l1_n803(x) + else + fun_l1_n636(x) + end +end + +def fun_l0_n212(x) + if (x < 1) + fun_l1_n93(x) + else + fun_l1_n791(x) + end +end + +def fun_l0_n213(x) + if (x < 1) + fun_l1_n76(x) + else + fun_l1_n172(x) + end +end + +def fun_l0_n214(x) + if (x < 1) + fun_l1_n103(x) + else + fun_l1_n381(x) + end +end + +def fun_l0_n215(x) + if (x < 1) + fun_l1_n433(x) + else + fun_l1_n349(x) + end +end + +def fun_l0_n216(x) + if (x < 1) + fun_l1_n154(x) + else + fun_l1_n740(x) + end +end + +def fun_l0_n217(x) + if (x < 1) + fun_l1_n927(x) + else + fun_l1_n886(x) + end +end + +def fun_l0_n218(x) + if (x < 1) + fun_l1_n804(x) + else + fun_l1_n6(x) + end +end + +def fun_l0_n219(x) + if (x < 1) + fun_l1_n921(x) + else + fun_l1_n121(x) + end +end + +def fun_l0_n220(x) + if (x < 1) + fun_l1_n732(x) + else + fun_l1_n224(x) + end +end + +def fun_l0_n221(x) + if (x < 1) + fun_l1_n818(x) + else + fun_l1_n105(x) + end +end + +def fun_l0_n222(x) + if (x < 1) + fun_l1_n162(x) + else + fun_l1_n700(x) + end +end + +def fun_l0_n223(x) + if (x < 1) + fun_l1_n57(x) + else + fun_l1_n734(x) + end +end + +def fun_l0_n224(x) + if (x < 1) + fun_l1_n283(x) + else + fun_l1_n87(x) + end +end + +def fun_l0_n225(x) + if (x < 1) + fun_l1_n623(x) + else + fun_l1_n363(x) + end +end + +def fun_l0_n226(x) + if (x < 1) + fun_l1_n962(x) + else + fun_l1_n660(x) + end +end + +def fun_l0_n227(x) + if (x < 1) + fun_l1_n255(x) + else + fun_l1_n536(x) + end +end + +def fun_l0_n228(x) + if (x < 1) + fun_l1_n377(x) + else + fun_l1_n249(x) + end +end + +def fun_l0_n229(x) + if (x < 1) + fun_l1_n527(x) + else + fun_l1_n691(x) + end +end + +def fun_l0_n230(x) + if (x < 1) + fun_l1_n781(x) + else + fun_l1_n494(x) + end +end + +def fun_l0_n231(x) + if (x < 1) + fun_l1_n889(x) + else + fun_l1_n967(x) + end +end + +def fun_l0_n232(x) + if (x < 1) + fun_l1_n509(x) + else + fun_l1_n910(x) + end +end + +def fun_l0_n233(x) + if (x < 1) + fun_l1_n354(x) + else + fun_l1_n5(x) + end +end + +def fun_l0_n234(x) + if (x < 1) + fun_l1_n423(x) + else + fun_l1_n788(x) + end +end + +def fun_l0_n235(x) + if (x < 1) + fun_l1_n632(x) + else + fun_l1_n705(x) + end +end + +def fun_l0_n236(x) + if (x < 1) + fun_l1_n955(x) + else + fun_l1_n908(x) + end +end + +def fun_l0_n237(x) + if (x < 1) + fun_l1_n329(x) + else + fun_l1_n2(x) + end +end + +def fun_l0_n238(x) + if (x < 1) + fun_l1_n767(x) + else + fun_l1_n766(x) + end +end + +def fun_l0_n239(x) + if (x < 1) + fun_l1_n304(x) + else + fun_l1_n507(x) + end +end + +def fun_l0_n240(x) + if (x < 1) + fun_l1_n845(x) + else + fun_l1_n777(x) + end +end + +def fun_l0_n241(x) + if (x < 1) + fun_l1_n69(x) + else + fun_l1_n260(x) + end +end + +def fun_l0_n242(x) + if (x < 1) + fun_l1_n194(x) + else + fun_l1_n412(x) + end +end + +def fun_l0_n243(x) + if (x < 1) + fun_l1_n974(x) + else + fun_l1_n922(x) + end +end + +def fun_l0_n244(x) + if (x < 1) + fun_l1_n532(x) + else + fun_l1_n530(x) + end +end + +def fun_l0_n245(x) + if (x < 1) + fun_l1_n554(x) + else + fun_l1_n656(x) + end +end + +def fun_l0_n246(x) + if (x < 1) + fun_l1_n253(x) + else + fun_l1_n235(x) + end +end + +def fun_l0_n247(x) + if (x < 1) + fun_l1_n754(x) + else + fun_l1_n775(x) + end +end + +def fun_l0_n248(x) + if (x < 1) + fun_l1_n89(x) + else + fun_l1_n129(x) + end +end + +def fun_l0_n249(x) + if (x < 1) + fun_l1_n284(x) + else + fun_l1_n642(x) + end +end + +def fun_l0_n250(x) + if (x < 1) + fun_l1_n67(x) + else + fun_l1_n867(x) + end +end + +def fun_l0_n251(x) + if (x < 1) + fun_l1_n926(x) + else + fun_l1_n442(x) + end +end + +def fun_l0_n252(x) + if (x < 1) + fun_l1_n196(x) + else + fun_l1_n583(x) + end +end + +def fun_l0_n253(x) + if (x < 1) + fun_l1_n966(x) + else + fun_l1_n810(x) + end +end + +def fun_l0_n254(x) + if (x < 1) + fun_l1_n984(x) + else + fun_l1_n752(x) + end +end + +def fun_l0_n255(x) + if (x < 1) + fun_l1_n941(x) + else + fun_l1_n744(x) + end +end + +def fun_l0_n256(x) + if (x < 1) + fun_l1_n785(x) + else + fun_l1_n610(x) + end +end + +def fun_l0_n257(x) + if (x < 1) + fun_l1_n622(x) + else + fun_l1_n730(x) + end +end + +def fun_l0_n258(x) + if (x < 1) + fun_l1_n453(x) + else + fun_l1_n641(x) + end +end + +def fun_l0_n259(x) + if (x < 1) + fun_l1_n407(x) + else + fun_l1_n818(x) + end +end + +def fun_l0_n260(x) + if (x < 1) + fun_l1_n252(x) + else + fun_l1_n205(x) + end +end + +def fun_l0_n261(x) + if (x < 1) + fun_l1_n940(x) + else + fun_l1_n678(x) + end +end + +def fun_l0_n262(x) + if (x < 1) + fun_l1_n350(x) + else + fun_l1_n496(x) + end +end + +def fun_l0_n263(x) + if (x < 1) + fun_l1_n688(x) + else + fun_l1_n193(x) + end +end + +def fun_l0_n264(x) + if (x < 1) + fun_l1_n366(x) + else + fun_l1_n790(x) + end +end + +def fun_l0_n265(x) + if (x < 1) + fun_l1_n592(x) + else + fun_l1_n93(x) + end +end + +def fun_l0_n266(x) + if (x < 1) + fun_l1_n189(x) + else + fun_l1_n467(x) + end +end + +def fun_l0_n267(x) + if (x < 1) + fun_l1_n813(x) + else + fun_l1_n7(x) + end +end + +def fun_l0_n268(x) + if (x < 1) + fun_l1_n516(x) + else + fun_l1_n271(x) + end +end + +def fun_l0_n269(x) + if (x < 1) + fun_l1_n0(x) + else + fun_l1_n121(x) + end +end + +def fun_l0_n270(x) + if (x < 1) + fun_l1_n634(x) + else + fun_l1_n726(x) + end +end + +def fun_l0_n271(x) + if (x < 1) + fun_l1_n192(x) + else + fun_l1_n468(x) + end +end + +def fun_l0_n272(x) + if (x < 1) + fun_l1_n278(x) + else + fun_l1_n355(x) + end +end + +def fun_l0_n273(x) + if (x < 1) + fun_l1_n354(x) + else + fun_l1_n87(x) + end +end + +def fun_l0_n274(x) + if (x < 1) + fun_l1_n643(x) + else + fun_l1_n806(x) + end +end + +def fun_l0_n275(x) + if (x < 1) + fun_l1_n389(x) + else + fun_l1_n559(x) + end +end + +def fun_l0_n276(x) + if (x < 1) + fun_l1_n283(x) + else + fun_l1_n539(x) + end +end + +def fun_l0_n277(x) + if (x < 1) + fun_l1_n0(x) + else + fun_l1_n351(x) + end +end + +def fun_l0_n278(x) + if (x < 1) + fun_l1_n813(x) + else + fun_l1_n513(x) + end +end + +def fun_l0_n279(x) + if (x < 1) + fun_l1_n501(x) + else + fun_l1_n967(x) + end +end + +def fun_l0_n280(x) + if (x < 1) + fun_l1_n727(x) + else + fun_l1_n232(x) + end +end + +def fun_l0_n281(x) + if (x < 1) + fun_l1_n946(x) + else + fun_l1_n693(x) + end +end + +def fun_l0_n282(x) + if (x < 1) + fun_l1_n260(x) + else + fun_l1_n525(x) + end +end + +def fun_l0_n283(x) + if (x < 1) + fun_l1_n957(x) + else + fun_l1_n817(x) + end +end + +def fun_l0_n284(x) + if (x < 1) + fun_l1_n91(x) + else + fun_l1_n735(x) + end +end + +def fun_l0_n285(x) + if (x < 1) + fun_l1_n71(x) + else + fun_l1_n24(x) + end +end + +def fun_l0_n286(x) + if (x < 1) + fun_l1_n594(x) + else + fun_l1_n747(x) + end +end + +def fun_l0_n287(x) + if (x < 1) + fun_l1_n869(x) + else + fun_l1_n414(x) + end +end + +def fun_l0_n288(x) + if (x < 1) + fun_l1_n182(x) + else + fun_l1_n835(x) + end +end + +def fun_l0_n289(x) + if (x < 1) + fun_l1_n188(x) + else + fun_l1_n949(x) + end +end + +def fun_l0_n290(x) + if (x < 1) + fun_l1_n35(x) + else + fun_l1_n259(x) + end +end + +def fun_l0_n291(x) + if (x < 1) + fun_l1_n593(x) + else + fun_l1_n810(x) + end +end + +def fun_l0_n292(x) + if (x < 1) + fun_l1_n680(x) + else + fun_l1_n564(x) + end +end + +def fun_l0_n293(x) + if (x < 1) + fun_l1_n57(x) + else + fun_l1_n91(x) + end +end + +def fun_l0_n294(x) + if (x < 1) + fun_l1_n945(x) + else + fun_l1_n807(x) + end +end + +def fun_l0_n295(x) + if (x < 1) + fun_l1_n442(x) + else + fun_l1_n123(x) + end +end + +def fun_l0_n296(x) + if (x < 1) + fun_l1_n536(x) + else + fun_l1_n987(x) + end +end + +def fun_l0_n297(x) + if (x < 1) + fun_l1_n519(x) + else + fun_l1_n657(x) + end +end + +def fun_l0_n298(x) + if (x < 1) + fun_l1_n204(x) + else + fun_l1_n437(x) + end +end + +def fun_l0_n299(x) + if (x < 1) + fun_l1_n289(x) + else + fun_l1_n385(x) + end +end + +def fun_l0_n300(x) + if (x < 1) + fun_l1_n629(x) + else + fun_l1_n803(x) + end +end + +def fun_l0_n301(x) + if (x < 1) + fun_l1_n576(x) + else + fun_l1_n921(x) + end +end + +def fun_l0_n302(x) + if (x < 1) + fun_l1_n466(x) + else + fun_l1_n475(x) + end +end + +def fun_l0_n303(x) + if (x < 1) + fun_l1_n658(x) + else + fun_l1_n333(x) + end +end + +def fun_l0_n304(x) + if (x < 1) + fun_l1_n728(x) + else + fun_l1_n749(x) + end +end + +def fun_l0_n305(x) + if (x < 1) + fun_l1_n68(x) + else + fun_l1_n552(x) + end +end + +def fun_l0_n306(x) + if (x < 1) + fun_l1_n633(x) + else + fun_l1_n958(x) + end +end + +def fun_l0_n307(x) + if (x < 1) + fun_l1_n79(x) + else + fun_l1_n386(x) + end +end + +def fun_l0_n308(x) + if (x < 1) + fun_l1_n831(x) + else + fun_l1_n176(x) + end +end + +def fun_l0_n309(x) + if (x < 1) + fun_l1_n770(x) + else + fun_l1_n334(x) + end +end + +def fun_l0_n310(x) + if (x < 1) + fun_l1_n21(x) + else + fun_l1_n643(x) + end +end + +def fun_l0_n311(x) + if (x < 1) + fun_l1_n673(x) + else + fun_l1_n298(x) + end +end + +def fun_l0_n312(x) + if (x < 1) + fun_l1_n753(x) + else + fun_l1_n817(x) + end +end + +def fun_l0_n313(x) + if (x < 1) + fun_l1_n299(x) + else + fun_l1_n350(x) + end +end + +def fun_l0_n314(x) + if (x < 1) + fun_l1_n190(x) + else + fun_l1_n519(x) + end +end + +def fun_l0_n315(x) + if (x < 1) + fun_l1_n934(x) + else + fun_l1_n416(x) + end +end + +def fun_l0_n316(x) + if (x < 1) + fun_l1_n695(x) + else + fun_l1_n377(x) + end +end + +def fun_l0_n317(x) + if (x < 1) + fun_l1_n194(x) + else + fun_l1_n747(x) + end +end + +def fun_l0_n318(x) + if (x < 1) + fun_l1_n145(x) + else + fun_l1_n761(x) + end +end + +def fun_l0_n319(x) + if (x < 1) + fun_l1_n223(x) + else + fun_l1_n237(x) + end +end + +def fun_l0_n320(x) + if (x < 1) + fun_l1_n907(x) + else + fun_l1_n653(x) + end +end + +def fun_l0_n321(x) + if (x < 1) + fun_l1_n216(x) + else + fun_l1_n67(x) + end +end + +def fun_l0_n322(x) + if (x < 1) + fun_l1_n658(x) + else + fun_l1_n948(x) + end +end + +def fun_l0_n323(x) + if (x < 1) + fun_l1_n358(x) + else + fun_l1_n926(x) + end +end + +def fun_l0_n324(x) + if (x < 1) + fun_l1_n533(x) + else + fun_l1_n252(x) + end +end + +def fun_l0_n325(x) + if (x < 1) + fun_l1_n284(x) + else + fun_l1_n670(x) + end +end + +def fun_l0_n326(x) + if (x < 1) + fun_l1_n327(x) + else + fun_l1_n298(x) + end +end + +def fun_l0_n327(x) + if (x < 1) + fun_l1_n837(x) + else + fun_l1_n890(x) + end +end + +def fun_l0_n328(x) + if (x < 1) + fun_l1_n941(x) + else + fun_l1_n794(x) + end +end + +def fun_l0_n329(x) + if (x < 1) + fun_l1_n859(x) + else + fun_l1_n970(x) + end +end + +def fun_l0_n330(x) + if (x < 1) + fun_l1_n282(x) + else + fun_l1_n569(x) + end +end + +def fun_l0_n331(x) + if (x < 1) + fun_l1_n33(x) + else + fun_l1_n525(x) + end +end + +def fun_l0_n332(x) + if (x < 1) + fun_l1_n847(x) + else + fun_l1_n540(x) + end +end + +def fun_l0_n333(x) + if (x < 1) + fun_l1_n485(x) + else + fun_l1_n756(x) + end +end + +def fun_l0_n334(x) + if (x < 1) + fun_l1_n396(x) + else + fun_l1_n781(x) + end +end + +def fun_l0_n335(x) + if (x < 1) + fun_l1_n225(x) + else + fun_l1_n417(x) + end +end + +def fun_l0_n336(x) + if (x < 1) + fun_l1_n906(x) + else + fun_l1_n301(x) + end +end + +def fun_l0_n337(x) + if (x < 1) + fun_l1_n863(x) + else + fun_l1_n409(x) + end +end + +def fun_l0_n338(x) + if (x < 1) + fun_l1_n103(x) + else + fun_l1_n460(x) + end +end + +def fun_l0_n339(x) + if (x < 1) + fun_l1_n787(x) + else + fun_l1_n434(x) + end +end + +def fun_l0_n340(x) + if (x < 1) + fun_l1_n308(x) + else + fun_l1_n875(x) + end +end + +def fun_l0_n341(x) + if (x < 1) + fun_l1_n146(x) + else + fun_l1_n566(x) + end +end + +def fun_l0_n342(x) + if (x < 1) + fun_l1_n837(x) + else + fun_l1_n770(x) + end +end + +def fun_l0_n343(x) + if (x < 1) + fun_l1_n668(x) + else + fun_l1_n60(x) + end +end + +def fun_l0_n344(x) + if (x < 1) + fun_l1_n305(x) + else + fun_l1_n388(x) + end +end + +def fun_l0_n345(x) + if (x < 1) + fun_l1_n796(x) + else + fun_l1_n920(x) + end +end + +def fun_l0_n346(x) + if (x < 1) + fun_l1_n257(x) + else + fun_l1_n229(x) + end +end + +def fun_l0_n347(x) + if (x < 1) + fun_l1_n740(x) + else + fun_l1_n372(x) + end +end + +def fun_l0_n348(x) + if (x < 1) + fun_l1_n698(x) + else + fun_l1_n63(x) + end +end + +def fun_l0_n349(x) + if (x < 1) + fun_l1_n4(x) + else + fun_l1_n119(x) + end +end + +def fun_l0_n350(x) + if (x < 1) + fun_l1_n186(x) + else + fun_l1_n352(x) + end +end + +def fun_l0_n351(x) + if (x < 1) + fun_l1_n619(x) + else + fun_l1_n583(x) + end +end + +def fun_l0_n352(x) + if (x < 1) + fun_l1_n2(x) + else + fun_l1_n275(x) + end +end + +def fun_l0_n353(x) + if (x < 1) + fun_l1_n843(x) + else + fun_l1_n986(x) + end +end + +def fun_l0_n354(x) + if (x < 1) + fun_l1_n865(x) + else + fun_l1_n64(x) + end +end + +def fun_l0_n355(x) + if (x < 1) + fun_l1_n732(x) + else + fun_l1_n332(x) + end +end + +def fun_l0_n356(x) + if (x < 1) + fun_l1_n642(x) + else + fun_l1_n559(x) + end +end + +def fun_l0_n357(x) + if (x < 1) + fun_l1_n385(x) + else + fun_l1_n532(x) + end +end + +def fun_l0_n358(x) + if (x < 1) + fun_l1_n672(x) + else + fun_l1_n721(x) + end +end + +def fun_l0_n359(x) + if (x < 1) + fun_l1_n663(x) + else + fun_l1_n590(x) + end +end + +def fun_l0_n360(x) + if (x < 1) + fun_l1_n240(x) + else + fun_l1_n743(x) + end +end + +def fun_l0_n361(x) + if (x < 1) + fun_l1_n301(x) + else + fun_l1_n943(x) + end +end + +def fun_l0_n362(x) + if (x < 1) + fun_l1_n108(x) + else + fun_l1_n975(x) + end +end + +def fun_l0_n363(x) + if (x < 1) + fun_l1_n554(x) + else + fun_l1_n135(x) + end +end + +def fun_l0_n364(x) + if (x < 1) + fun_l1_n360(x) + else + fun_l1_n821(x) + end +end + +def fun_l0_n365(x) + if (x < 1) + fun_l1_n992(x) + else + fun_l1_n158(x) + end +end + +def fun_l0_n366(x) + if (x < 1) + fun_l1_n439(x) + else + fun_l1_n506(x) + end +end + +def fun_l0_n367(x) + if (x < 1) + fun_l1_n229(x) + else + fun_l1_n714(x) + end +end + +def fun_l0_n368(x) + if (x < 1) + fun_l1_n459(x) + else + fun_l1_n874(x) + end +end + +def fun_l0_n369(x) + if (x < 1) + fun_l1_n799(x) + else + fun_l1_n406(x) + end +end + +def fun_l0_n370(x) + if (x < 1) + fun_l1_n791(x) + else + fun_l1_n669(x) + end +end + +def fun_l0_n371(x) + if (x < 1) + fun_l1_n99(x) + else + fun_l1_n344(x) + end +end + +def fun_l0_n372(x) + if (x < 1) + fun_l1_n585(x) + else + fun_l1_n388(x) + end +end + +def fun_l0_n373(x) + if (x < 1) + fun_l1_n35(x) + else + fun_l1_n369(x) + end +end + +def fun_l0_n374(x) + if (x < 1) + fun_l1_n41(x) + else + fun_l1_n378(x) + end +end + +def fun_l0_n375(x) + if (x < 1) + fun_l1_n372(x) + else + fun_l1_n406(x) + end +end + +def fun_l0_n376(x) + if (x < 1) + fun_l1_n247(x) + else + fun_l1_n563(x) + end +end + +def fun_l0_n377(x) + if (x < 1) + fun_l1_n998(x) + else + fun_l1_n302(x) + end +end + +def fun_l0_n378(x) + if (x < 1) + fun_l1_n955(x) + else + fun_l1_n333(x) + end +end + +def fun_l0_n379(x) + if (x < 1) + fun_l1_n554(x) + else + fun_l1_n863(x) + end +end + +def fun_l0_n380(x) + if (x < 1) + fun_l1_n248(x) + else + fun_l1_n297(x) + end +end + +def fun_l0_n381(x) + if (x < 1) + fun_l1_n85(x) + else + fun_l1_n726(x) + end +end + +def fun_l0_n382(x) + if (x < 1) + fun_l1_n75(x) + else + fun_l1_n990(x) + end +end + +def fun_l0_n383(x) + if (x < 1) + fun_l1_n353(x) + else + fun_l1_n218(x) + end +end + +def fun_l0_n384(x) + if (x < 1) + fun_l1_n103(x) + else + fun_l1_n192(x) + end +end + +def fun_l0_n385(x) + if (x < 1) + fun_l1_n659(x) + else + fun_l1_n996(x) + end +end + +def fun_l0_n386(x) + if (x < 1) + fun_l1_n528(x) + else + fun_l1_n654(x) + end +end + +def fun_l0_n387(x) + if (x < 1) + fun_l1_n857(x) + else + fun_l1_n638(x) + end +end + +def fun_l0_n388(x) + if (x < 1) + fun_l1_n311(x) + else + fun_l1_n877(x) + end +end + +def fun_l0_n389(x) + if (x < 1) + fun_l1_n406(x) + else + fun_l1_n191(x) + end +end + +def fun_l0_n390(x) + if (x < 1) + fun_l1_n464(x) + else + fun_l1_n684(x) + end +end + +def fun_l0_n391(x) + if (x < 1) + fun_l1_n878(x) + else + fun_l1_n635(x) + end +end + +def fun_l0_n392(x) + if (x < 1) + fun_l1_n863(x) + else + fun_l1_n486(x) + end +end + +def fun_l0_n393(x) + if (x < 1) + fun_l1_n587(x) + else + fun_l1_n387(x) + end +end + +def fun_l0_n394(x) + if (x < 1) + fun_l1_n553(x) + else + fun_l1_n789(x) + end +end + +def fun_l0_n395(x) + if (x < 1) + fun_l1_n420(x) + else + fun_l1_n148(x) + end +end + +def fun_l0_n396(x) + if (x < 1) + fun_l1_n802(x) + else + fun_l1_n845(x) + end +end + +def fun_l0_n397(x) + if (x < 1) + fun_l1_n749(x) + else + fun_l1_n742(x) + end +end + +def fun_l0_n398(x) + if (x < 1) + fun_l1_n929(x) + else + fun_l1_n458(x) + end +end + +def fun_l0_n399(x) + if (x < 1) + fun_l1_n908(x) + else + fun_l1_n188(x) + end +end + +def fun_l0_n400(x) + if (x < 1) + fun_l1_n932(x) + else + fun_l1_n854(x) + end +end + +def fun_l0_n401(x) + if (x < 1) + fun_l1_n29(x) + else + fun_l1_n666(x) + end +end + +def fun_l0_n402(x) + if (x < 1) + fun_l1_n877(x) + else + fun_l1_n518(x) + end +end + +def fun_l0_n403(x) + if (x < 1) + fun_l1_n639(x) + else + fun_l1_n618(x) + end +end + +def fun_l0_n404(x) + if (x < 1) + fun_l1_n177(x) + else + fun_l1_n487(x) + end +end + +def fun_l0_n405(x) + if (x < 1) + fun_l1_n536(x) + else + fun_l1_n860(x) + end +end + +def fun_l0_n406(x) + if (x < 1) + fun_l1_n626(x) + else + fun_l1_n894(x) + end +end + +def fun_l0_n407(x) + if (x < 1) + fun_l1_n533(x) + else + fun_l1_n367(x) + end +end + +def fun_l0_n408(x) + if (x < 1) + fun_l1_n146(x) + else + fun_l1_n546(x) + end +end + +def fun_l0_n409(x) + if (x < 1) + fun_l1_n872(x) + else + fun_l1_n387(x) + end +end + +def fun_l0_n410(x) + if (x < 1) + fun_l1_n726(x) + else + fun_l1_n973(x) + end +end + +def fun_l0_n411(x) + if (x < 1) + fun_l1_n168(x) + else + fun_l1_n783(x) + end +end + +def fun_l0_n412(x) + if (x < 1) + fun_l1_n895(x) + else + fun_l1_n901(x) + end +end + +def fun_l0_n413(x) + if (x < 1) + fun_l1_n235(x) + else + fun_l1_n593(x) + end +end + +def fun_l0_n414(x) + if (x < 1) + fun_l1_n328(x) + else + fun_l1_n693(x) + end +end + +def fun_l0_n415(x) + if (x < 1) + fun_l1_n882(x) + else + fun_l1_n290(x) + end +end + +def fun_l0_n416(x) + if (x < 1) + fun_l1_n433(x) + else + fun_l1_n220(x) + end +end + +def fun_l0_n417(x) + if (x < 1) + fun_l1_n966(x) + else + fun_l1_n74(x) + end +end + +def fun_l0_n418(x) + if (x < 1) + fun_l1_n750(x) + else + fun_l1_n547(x) + end +end + +def fun_l0_n419(x) + if (x < 1) + fun_l1_n94(x) + else + fun_l1_n794(x) + end +end + +def fun_l0_n420(x) + if (x < 1) + fun_l1_n68(x) + else + fun_l1_n970(x) + end +end + +def fun_l0_n421(x) + if (x < 1) + fun_l1_n663(x) + else + fun_l1_n388(x) + end +end + +def fun_l0_n422(x) + if (x < 1) + fun_l1_n686(x) + else + fun_l1_n67(x) + end +end + +def fun_l0_n423(x) + if (x < 1) + fun_l1_n210(x) + else + fun_l1_n64(x) + end +end + +def fun_l0_n424(x) + if (x < 1) + fun_l1_n375(x) + else + fun_l1_n205(x) + end +end + +def fun_l0_n425(x) + if (x < 1) + fun_l1_n832(x) + else + fun_l1_n325(x) + end +end + +def fun_l0_n426(x) + if (x < 1) + fun_l1_n819(x) + else + fun_l1_n601(x) + end +end + +def fun_l0_n427(x) + if (x < 1) + fun_l1_n588(x) + else + fun_l1_n875(x) + end +end + +def fun_l0_n428(x) + if (x < 1) + fun_l1_n682(x) + else + fun_l1_n523(x) + end +end + +def fun_l0_n429(x) + if (x < 1) + fun_l1_n972(x) + else + fun_l1_n891(x) + end +end + +def fun_l0_n430(x) + if (x < 1) + fun_l1_n90(x) + else + fun_l1_n655(x) + end +end + +def fun_l0_n431(x) + if (x < 1) + fun_l1_n393(x) + else + fun_l1_n454(x) + end +end + +def fun_l0_n432(x) + if (x < 1) + fun_l1_n435(x) + else + fun_l1_n860(x) + end +end + +def fun_l0_n433(x) + if (x < 1) + fun_l1_n516(x) + else + fun_l1_n246(x) + end +end + +def fun_l0_n434(x) + if (x < 1) + fun_l1_n216(x) + else + fun_l1_n78(x) + end +end + +def fun_l0_n435(x) + if (x < 1) + fun_l1_n357(x) + else + fun_l1_n61(x) + end +end + +def fun_l0_n436(x) + if (x < 1) + fun_l1_n289(x) + else + fun_l1_n507(x) + end +end + +def fun_l0_n437(x) + if (x < 1) + fun_l1_n182(x) + else + fun_l1_n289(x) + end +end + +def fun_l0_n438(x) + if (x < 1) + fun_l1_n69(x) + else + fun_l1_n549(x) + end +end + +def fun_l0_n439(x) + if (x < 1) + fun_l1_n275(x) + else + fun_l1_n723(x) + end +end + +def fun_l0_n440(x) + if (x < 1) + fun_l1_n469(x) + else + fun_l1_n243(x) + end +end + +def fun_l0_n441(x) + if (x < 1) + fun_l1_n595(x) + else + fun_l1_n624(x) + end +end + +def fun_l0_n442(x) + if (x < 1) + fun_l1_n655(x) + else + fun_l1_n896(x) + end +end + +def fun_l0_n443(x) + if (x < 1) + fun_l1_n926(x) + else + fun_l1_n503(x) + end +end + +def fun_l0_n444(x) + if (x < 1) + fun_l1_n875(x) + else + fun_l1_n110(x) + end +end + +def fun_l0_n445(x) + if (x < 1) + fun_l1_n832(x) + else + fun_l1_n154(x) + end +end + +def fun_l0_n446(x) + if (x < 1) + fun_l1_n538(x) + else + fun_l1_n75(x) + end +end + +def fun_l0_n447(x) + if (x < 1) + fun_l1_n183(x) + else + fun_l1_n718(x) + end +end + +def fun_l0_n448(x) + if (x < 1) + fun_l1_n680(x) + else + fun_l1_n93(x) + end +end + +def fun_l0_n449(x) + if (x < 1) + fun_l1_n147(x) + else + fun_l1_n924(x) + end +end + +def fun_l0_n450(x) + if (x < 1) + fun_l1_n702(x) + else + fun_l1_n830(x) + end +end + +def fun_l0_n451(x) + if (x < 1) + fun_l1_n750(x) + else + fun_l1_n447(x) + end +end + +def fun_l0_n452(x) + if (x < 1) + fun_l1_n520(x) + else + fun_l1_n69(x) + end +end + +def fun_l0_n453(x) + if (x < 1) + fun_l1_n132(x) + else + fun_l1_n877(x) + end +end + +def fun_l0_n454(x) + if (x < 1) + fun_l1_n247(x) + else + fun_l1_n69(x) + end +end + +def fun_l0_n455(x) + if (x < 1) + fun_l1_n180(x) + else + fun_l1_n645(x) + end +end + +def fun_l0_n456(x) + if (x < 1) + fun_l1_n658(x) + else + fun_l1_n487(x) + end +end + +def fun_l0_n457(x) + if (x < 1) + fun_l1_n276(x) + else + fun_l1_n528(x) + end +end + +def fun_l0_n458(x) + if (x < 1) + fun_l1_n30(x) + else + fun_l1_n456(x) + end +end + +def fun_l0_n459(x) + if (x < 1) + fun_l1_n986(x) + else + fun_l1_n552(x) + end +end + +def fun_l0_n460(x) + if (x < 1) + fun_l1_n874(x) + else + fun_l1_n396(x) + end +end + +def fun_l0_n461(x) + if (x < 1) + fun_l1_n524(x) + else + fun_l1_n335(x) + end +end + +def fun_l0_n462(x) + if (x < 1) + fun_l1_n471(x) + else + fun_l1_n578(x) + end +end + +def fun_l0_n463(x) + if (x < 1) + fun_l1_n173(x) + else + fun_l1_n456(x) + end +end + +def fun_l0_n464(x) + if (x < 1) + fun_l1_n872(x) + else + fun_l1_n745(x) + end +end + +def fun_l0_n465(x) + if (x < 1) + fun_l1_n387(x) + else + fun_l1_n776(x) + end +end + +def fun_l0_n466(x) + if (x < 1) + fun_l1_n119(x) + else + fun_l1_n428(x) + end +end + +def fun_l0_n467(x) + if (x < 1) + fun_l1_n416(x) + else + fun_l1_n738(x) + end +end + +def fun_l0_n468(x) + if (x < 1) + fun_l1_n762(x) + else + fun_l1_n694(x) + end +end + +def fun_l0_n469(x) + if (x < 1) + fun_l1_n27(x) + else + fun_l1_n562(x) + end +end + +def fun_l0_n470(x) + if (x < 1) + fun_l1_n12(x) + else + fun_l1_n812(x) + end +end + +def fun_l0_n471(x) + if (x < 1) + fun_l1_n865(x) + else + fun_l1_n94(x) + end +end + +def fun_l0_n472(x) + if (x < 1) + fun_l1_n346(x) + else + fun_l1_n39(x) + end +end + +def fun_l0_n473(x) + if (x < 1) + fun_l1_n309(x) + else + fun_l1_n158(x) + end +end + +def fun_l0_n474(x) + if (x < 1) + fun_l1_n828(x) + else + fun_l1_n229(x) + end +end + +def fun_l0_n475(x) + if (x < 1) + fun_l1_n554(x) + else + fun_l1_n121(x) + end +end + +def fun_l0_n476(x) + if (x < 1) + fun_l1_n818(x) + else + fun_l1_n390(x) + end +end + +def fun_l0_n477(x) + if (x < 1) + fun_l1_n88(x) + else + fun_l1_n73(x) + end +end + +def fun_l0_n478(x) + if (x < 1) + fun_l1_n709(x) + else + fun_l1_n680(x) + end +end + +def fun_l0_n479(x) + if (x < 1) + fun_l1_n271(x) + else + fun_l1_n439(x) + end +end + +def fun_l0_n480(x) + if (x < 1) + fun_l1_n493(x) + else + fun_l1_n562(x) + end +end + +def fun_l0_n481(x) + if (x < 1) + fun_l1_n642(x) + else + fun_l1_n221(x) + end +end + +def fun_l0_n482(x) + if (x < 1) + fun_l1_n838(x) + else + fun_l1_n345(x) + end +end + +def fun_l0_n483(x) + if (x < 1) + fun_l1_n411(x) + else + fun_l1_n266(x) + end +end + +def fun_l0_n484(x) + if (x < 1) + fun_l1_n916(x) + else + fun_l1_n791(x) + end +end + +def fun_l0_n485(x) + if (x < 1) + fun_l1_n392(x) + else + fun_l1_n68(x) + end +end + +def fun_l0_n486(x) + if (x < 1) + fun_l1_n834(x) + else + fun_l1_n783(x) + end +end + +def fun_l0_n487(x) + if (x < 1) + fun_l1_n398(x) + else + fun_l1_n627(x) + end +end + +def fun_l0_n488(x) + if (x < 1) + fun_l1_n904(x) + else + fun_l1_n167(x) + end +end + +def fun_l0_n489(x) + if (x < 1) + fun_l1_n54(x) + else + fun_l1_n28(x) + end +end + +def fun_l0_n490(x) + if (x < 1) + fun_l1_n24(x) + else + fun_l1_n9(x) + end +end + +def fun_l0_n491(x) + if (x < 1) + fun_l1_n497(x) + else + fun_l1_n297(x) + end +end + +def fun_l0_n492(x) + if (x < 1) + fun_l1_n951(x) + else + fun_l1_n534(x) + end +end + +def fun_l0_n493(x) + if (x < 1) + fun_l1_n213(x) + else + fun_l1_n808(x) + end +end + +def fun_l0_n494(x) + if (x < 1) + fun_l1_n904(x) + else + fun_l1_n94(x) + end +end + +def fun_l0_n495(x) + if (x < 1) + fun_l1_n799(x) + else + fun_l1_n817(x) + end +end + +def fun_l0_n496(x) + if (x < 1) + fun_l1_n45(x) + else + fun_l1_n860(x) + end +end + +def fun_l0_n497(x) + if (x < 1) + fun_l1_n482(x) + else + fun_l1_n783(x) + end +end + +def fun_l0_n498(x) + if (x < 1) + fun_l1_n78(x) + else + fun_l1_n785(x) + end +end + +def fun_l0_n499(x) + if (x < 1) + fun_l1_n174(x) + else + fun_l1_n87(x) + end +end + +def fun_l0_n500(x) + if (x < 1) + fun_l1_n608(x) + else + fun_l1_n7(x) + end +end + +def fun_l0_n501(x) + if (x < 1) + fun_l1_n157(x) + else + fun_l1_n718(x) + end +end + +def fun_l0_n502(x) + if (x < 1) + fun_l1_n823(x) + else + fun_l1_n549(x) + end +end + +def fun_l0_n503(x) + if (x < 1) + fun_l1_n13(x) + else + fun_l1_n502(x) + end +end + +def fun_l0_n504(x) + if (x < 1) + fun_l1_n119(x) + else + fun_l1_n191(x) + end +end + +def fun_l0_n505(x) + if (x < 1) + fun_l1_n503(x) + else + fun_l1_n974(x) + end +end + +def fun_l0_n506(x) + if (x < 1) + fun_l1_n893(x) + else + fun_l1_n582(x) + end +end + +def fun_l0_n507(x) + if (x < 1) + fun_l1_n403(x) + else + fun_l1_n228(x) + end +end + +def fun_l0_n508(x) + if (x < 1) + fun_l1_n640(x) + else + fun_l1_n362(x) + end +end + +def fun_l0_n509(x) + if (x < 1) + fun_l1_n629(x) + else + fun_l1_n824(x) + end +end + +def fun_l0_n510(x) + if (x < 1) + fun_l1_n84(x) + else + fun_l1_n330(x) + end +end + +def fun_l0_n511(x) + if (x < 1) + fun_l1_n91(x) + else + fun_l1_n523(x) + end +end + +def fun_l0_n512(x) + if (x < 1) + fun_l1_n696(x) + else + fun_l1_n126(x) + end +end + +def fun_l0_n513(x) + if (x < 1) + fun_l1_n905(x) + else + fun_l1_n496(x) + end +end + +def fun_l0_n514(x) + if (x < 1) + fun_l1_n766(x) + else + fun_l1_n523(x) + end +end + +def fun_l0_n515(x) + if (x < 1) + fun_l1_n798(x) + else + fun_l1_n698(x) + end +end + +def fun_l0_n516(x) + if (x < 1) + fun_l1_n124(x) + else + fun_l1_n356(x) + end +end + +def fun_l0_n517(x) + if (x < 1) + fun_l1_n289(x) + else + fun_l1_n782(x) + end +end + +def fun_l0_n518(x) + if (x < 1) + fun_l1_n483(x) + else + fun_l1_n586(x) + end +end + +def fun_l0_n519(x) + if (x < 1) + fun_l1_n878(x) + else + fun_l1_n37(x) + end +end + +def fun_l0_n520(x) + if (x < 1) + fun_l1_n48(x) + else + fun_l1_n216(x) + end +end + +def fun_l0_n521(x) + if (x < 1) + fun_l1_n805(x) + else + fun_l1_n846(x) + end +end + +def fun_l0_n522(x) + if (x < 1) + fun_l1_n422(x) + else + fun_l1_n190(x) + end +end + +def fun_l0_n523(x) + if (x < 1) + fun_l1_n168(x) + else + fun_l1_n272(x) + end +end + +def fun_l0_n524(x) + if (x < 1) + fun_l1_n766(x) + else + fun_l1_n125(x) + end +end + +def fun_l0_n525(x) + if (x < 1) + fun_l1_n56(x) + else + fun_l1_n224(x) + end +end + +def fun_l0_n526(x) + if (x < 1) + fun_l1_n540(x) + else + fun_l1_n303(x) + end +end + +def fun_l0_n527(x) + if (x < 1) + fun_l1_n846(x) + else + fun_l1_n955(x) + end +end + +def fun_l0_n528(x) + if (x < 1) + fun_l1_n571(x) + else + fun_l1_n640(x) + end +end + +def fun_l0_n529(x) + if (x < 1) + fun_l1_n650(x) + else + fun_l1_n107(x) + end +end + +def fun_l0_n530(x) + if (x < 1) + fun_l1_n240(x) + else + fun_l1_n139(x) + end +end + +def fun_l0_n531(x) + if (x < 1) + fun_l1_n975(x) + else + fun_l1_n970(x) + end +end + +def fun_l0_n532(x) + if (x < 1) + fun_l1_n753(x) + else + fun_l1_n147(x) + end +end + +def fun_l0_n533(x) + if (x < 1) + fun_l1_n269(x) + else + fun_l1_n292(x) + end +end + +def fun_l0_n534(x) + if (x < 1) + fun_l1_n791(x) + else + fun_l1_n69(x) + end +end + +def fun_l0_n535(x) + if (x < 1) + fun_l1_n469(x) + else + fun_l1_n58(x) + end +end + +def fun_l0_n536(x) + if (x < 1) + fun_l1_n526(x) + else + fun_l1_n265(x) + end +end + +def fun_l0_n537(x) + if (x < 1) + fun_l1_n681(x) + else + fun_l1_n646(x) + end +end + +def fun_l0_n538(x) + if (x < 1) + fun_l1_n377(x) + else + fun_l1_n969(x) + end +end + +def fun_l0_n539(x) + if (x < 1) + fun_l1_n935(x) + else + fun_l1_n556(x) + end +end + +def fun_l0_n540(x) + if (x < 1) + fun_l1_n498(x) + else + fun_l1_n439(x) + end +end + +def fun_l0_n541(x) + if (x < 1) + fun_l1_n451(x) + else + fun_l1_n35(x) + end +end + +def fun_l0_n542(x) + if (x < 1) + fun_l1_n32(x) + else + fun_l1_n795(x) + end +end + +def fun_l0_n543(x) + if (x < 1) + fun_l1_n732(x) + else + fun_l1_n530(x) + end +end + +def fun_l0_n544(x) + if (x < 1) + fun_l1_n176(x) + else + fun_l1_n735(x) + end +end + +def fun_l0_n545(x) + if (x < 1) + fun_l1_n34(x) + else + fun_l1_n989(x) + end +end + +def fun_l0_n546(x) + if (x < 1) + fun_l1_n534(x) + else + fun_l1_n705(x) + end +end + +def fun_l0_n547(x) + if (x < 1) + fun_l1_n997(x) + else + fun_l1_n883(x) + end +end + +def fun_l0_n548(x) + if (x < 1) + fun_l1_n379(x) + else + fun_l1_n33(x) + end +end + +def fun_l0_n549(x) + if (x < 1) + fun_l1_n454(x) + else + fun_l1_n516(x) + end +end + +def fun_l0_n550(x) + if (x < 1) + fun_l1_n678(x) + else + fun_l1_n652(x) + end +end + +def fun_l0_n551(x) + if (x < 1) + fun_l1_n13(x) + else + fun_l1_n864(x) + end +end + +def fun_l0_n552(x) + if (x < 1) + fun_l1_n178(x) + else + fun_l1_n996(x) + end +end + +def fun_l0_n553(x) + if (x < 1) + fun_l1_n865(x) + else + fun_l1_n703(x) + end +end + +def fun_l0_n554(x) + if (x < 1) + fun_l1_n306(x) + else + fun_l1_n24(x) + end +end + +def fun_l0_n555(x) + if (x < 1) + fun_l1_n110(x) + else + fun_l1_n123(x) + end +end + +def fun_l0_n556(x) + if (x < 1) + fun_l1_n367(x) + else + fun_l1_n117(x) + end +end + +def fun_l0_n557(x) + if (x < 1) + fun_l1_n967(x) + else + fun_l1_n662(x) + end +end + +def fun_l0_n558(x) + if (x < 1) + fun_l1_n68(x) + else + fun_l1_n47(x) + end +end + +def fun_l0_n559(x) + if (x < 1) + fun_l1_n154(x) + else + fun_l1_n344(x) + end +end + +def fun_l0_n560(x) + if (x < 1) + fun_l1_n835(x) + else + fun_l1_n577(x) + end +end + +def fun_l0_n561(x) + if (x < 1) + fun_l1_n393(x) + else + fun_l1_n419(x) + end +end + +def fun_l0_n562(x) + if (x < 1) + fun_l1_n632(x) + else + fun_l1_n630(x) + end +end + +def fun_l0_n563(x) + if (x < 1) + fun_l1_n9(x) + else + fun_l1_n109(x) + end +end + +def fun_l0_n564(x) + if (x < 1) + fun_l1_n65(x) + else + fun_l1_n123(x) + end +end + +def fun_l0_n565(x) + if (x < 1) + fun_l1_n156(x) + else + fun_l1_n921(x) + end +end + +def fun_l0_n566(x) + if (x < 1) + fun_l1_n88(x) + else + fun_l1_n743(x) + end +end + +def fun_l0_n567(x) + if (x < 1) + fun_l1_n92(x) + else + fun_l1_n27(x) + end +end + +def fun_l0_n568(x) + if (x < 1) + fun_l1_n462(x) + else + fun_l1_n988(x) + end +end + +def fun_l0_n569(x) + if (x < 1) + fun_l1_n241(x) + else + fun_l1_n199(x) + end +end + +def fun_l0_n570(x) + if (x < 1) + fun_l1_n429(x) + else + fun_l1_n530(x) + end +end + +def fun_l0_n571(x) + if (x < 1) + fun_l1_n412(x) + else + fun_l1_n530(x) + end +end + +def fun_l0_n572(x) + if (x < 1) + fun_l1_n100(x) + else + fun_l1_n270(x) + end +end + +def fun_l0_n573(x) + if (x < 1) + fun_l1_n326(x) + else + fun_l1_n191(x) + end +end + +def fun_l0_n574(x) + if (x < 1) + fun_l1_n151(x) + else + fun_l1_n354(x) + end +end + +def fun_l0_n575(x) + if (x < 1) + fun_l1_n322(x) + else + fun_l1_n534(x) + end +end + +def fun_l0_n576(x) + if (x < 1) + fun_l1_n995(x) + else + fun_l1_n658(x) + end +end + +def fun_l0_n577(x) + if (x < 1) + fun_l1_n193(x) + else + fun_l1_n444(x) + end +end + +def fun_l0_n578(x) + if (x < 1) + fun_l1_n527(x) + else + fun_l1_n517(x) + end +end + +def fun_l0_n579(x) + if (x < 1) + fun_l1_n885(x) + else + fun_l1_n218(x) + end +end + +def fun_l0_n580(x) + if (x < 1) + fun_l1_n789(x) + else + fun_l1_n711(x) + end +end + +def fun_l0_n581(x) + if (x < 1) + fun_l1_n848(x) + else + fun_l1_n321(x) + end +end + +def fun_l0_n582(x) + if (x < 1) + fun_l1_n389(x) + else + fun_l1_n360(x) + end +end + +def fun_l0_n583(x) + if (x < 1) + fun_l1_n319(x) + else + fun_l1_n972(x) + end +end + +def fun_l0_n584(x) + if (x < 1) + fun_l1_n421(x) + else + fun_l1_n659(x) + end +end + +def fun_l0_n585(x) + if (x < 1) + fun_l1_n462(x) + else + fun_l1_n302(x) + end +end + +def fun_l0_n586(x) + if (x < 1) + fun_l1_n122(x) + else + fun_l1_n50(x) + end +end + +def fun_l0_n587(x) + if (x < 1) + fun_l1_n795(x) + else + fun_l1_n622(x) + end +end + +def fun_l0_n588(x) + if (x < 1) + fun_l1_n719(x) + else + fun_l1_n390(x) + end +end + +def fun_l0_n589(x) + if (x < 1) + fun_l1_n916(x) + else + fun_l1_n925(x) + end +end + +def fun_l0_n590(x) + if (x < 1) + fun_l1_n541(x) + else + fun_l1_n139(x) + end +end + +def fun_l0_n591(x) + if (x < 1) + fun_l1_n610(x) + else + fun_l1_n509(x) + end +end + +def fun_l0_n592(x) + if (x < 1) + fun_l1_n217(x) + else + fun_l1_n452(x) + end +end + +def fun_l0_n593(x) + if (x < 1) + fun_l1_n456(x) + else + fun_l1_n888(x) + end +end + +def fun_l0_n594(x) + if (x < 1) + fun_l1_n987(x) + else + fun_l1_n462(x) + end +end + +def fun_l0_n595(x) + if (x < 1) + fun_l1_n571(x) + else + fun_l1_n429(x) + end +end + +def fun_l0_n596(x) + if (x < 1) + fun_l1_n751(x) + else + fun_l1_n773(x) + end +end + +def fun_l0_n597(x) + if (x < 1) + fun_l1_n181(x) + else + fun_l1_n340(x) + end +end + +def fun_l0_n598(x) + if (x < 1) + fun_l1_n6(x) + else + fun_l1_n39(x) + end +end + +def fun_l0_n599(x) + if (x < 1) + fun_l1_n814(x) + else + fun_l1_n320(x) + end +end + +def fun_l0_n600(x) + if (x < 1) + fun_l1_n931(x) + else + fun_l1_n535(x) + end +end + +def fun_l0_n601(x) + if (x < 1) + fun_l1_n99(x) + else + fun_l1_n154(x) + end +end + +def fun_l0_n602(x) + if (x < 1) + fun_l1_n981(x) + else + fun_l1_n817(x) + end +end + +def fun_l0_n603(x) + if (x < 1) + fun_l1_n975(x) + else + fun_l1_n364(x) + end +end + +def fun_l0_n604(x) + if (x < 1) + fun_l1_n112(x) + else + fun_l1_n226(x) + end +end + +def fun_l0_n605(x) + if (x < 1) + fun_l1_n995(x) + else + fun_l1_n95(x) + end +end + +def fun_l0_n606(x) + if (x < 1) + fun_l1_n930(x) + else + fun_l1_n77(x) + end +end + +def fun_l0_n607(x) + if (x < 1) + fun_l1_n899(x) + else + fun_l1_n957(x) + end +end + +def fun_l0_n608(x) + if (x < 1) + fun_l1_n844(x) + else + fun_l1_n119(x) + end +end + +def fun_l0_n609(x) + if (x < 1) + fun_l1_n861(x) + else + fun_l1_n74(x) + end +end + +def fun_l0_n610(x) + if (x < 1) + fun_l1_n521(x) + else + fun_l1_n46(x) + end +end + +def fun_l0_n611(x) + if (x < 1) + fun_l1_n258(x) + else + fun_l1_n208(x) + end +end + +def fun_l0_n612(x) + if (x < 1) + fun_l1_n620(x) + else + fun_l1_n427(x) + end +end + +def fun_l0_n613(x) + if (x < 1) + fun_l1_n583(x) + else + fun_l1_n400(x) + end +end + +def fun_l0_n614(x) + if (x < 1) + fun_l1_n933(x) + else + fun_l1_n810(x) + end +end + +def fun_l0_n615(x) + if (x < 1) + fun_l1_n154(x) + else + fun_l1_n879(x) + end +end + +def fun_l0_n616(x) + if (x < 1) + fun_l1_n715(x) + else + fun_l1_n862(x) + end +end + +def fun_l0_n617(x) + if (x < 1) + fun_l1_n178(x) + else + fun_l1_n285(x) + end +end + +def fun_l0_n618(x) + if (x < 1) + fun_l1_n458(x) + else + fun_l1_n217(x) + end +end + +def fun_l0_n619(x) + if (x < 1) + fun_l1_n655(x) + else + fun_l1_n405(x) + end +end + +def fun_l0_n620(x) + if (x < 1) + fun_l1_n470(x) + else + fun_l1_n306(x) + end +end + +def fun_l0_n621(x) + if (x < 1) + fun_l1_n755(x) + else + fun_l1_n425(x) + end +end + +def fun_l0_n622(x) + if (x < 1) + fun_l1_n426(x) + else + fun_l1_n737(x) + end +end + +def fun_l0_n623(x) + if (x < 1) + fun_l1_n79(x) + else + fun_l1_n55(x) + end +end + +def fun_l0_n624(x) + if (x < 1) + fun_l1_n437(x) + else + fun_l1_n79(x) + end +end + +def fun_l0_n625(x) + if (x < 1) + fun_l1_n691(x) + else + fun_l1_n198(x) + end +end + +def fun_l0_n626(x) + if (x < 1) + fun_l1_n703(x) + else + fun_l1_n585(x) + end +end + +def fun_l0_n627(x) + if (x < 1) + fun_l1_n966(x) + else + fun_l1_n425(x) + end +end + +def fun_l0_n628(x) + if (x < 1) + fun_l1_n516(x) + else + fun_l1_n744(x) + end +end + +def fun_l0_n629(x) + if (x < 1) + fun_l1_n40(x) + else + fun_l1_n942(x) + end +end + +def fun_l0_n630(x) + if (x < 1) + fun_l1_n528(x) + else + fun_l1_n440(x) + end +end + +def fun_l0_n631(x) + if (x < 1) + fun_l1_n139(x) + else + fun_l1_n403(x) + end +end + +def fun_l0_n632(x) + if (x < 1) + fun_l1_n421(x) + else + fun_l1_n510(x) + end +end + +def fun_l0_n633(x) + if (x < 1) + fun_l1_n718(x) + else + fun_l1_n388(x) + end +end + +def fun_l0_n634(x) + if (x < 1) + fun_l1_n67(x) + else + fun_l1_n342(x) + end +end + +def fun_l0_n635(x) + if (x < 1) + fun_l1_n943(x) + else + fun_l1_n941(x) + end +end + +def fun_l0_n636(x) + if (x < 1) + fun_l1_n170(x) + else + fun_l1_n527(x) + end +end + +def fun_l0_n637(x) + if (x < 1) + fun_l1_n336(x) + else + fun_l1_n496(x) + end +end + +def fun_l0_n638(x) + if (x < 1) + fun_l1_n730(x) + else + fun_l1_n10(x) + end +end + +def fun_l0_n639(x) + if (x < 1) + fun_l1_n939(x) + else + fun_l1_n940(x) + end +end + +def fun_l0_n640(x) + if (x < 1) + fun_l1_n73(x) + else + fun_l1_n439(x) + end +end + +def fun_l0_n641(x) + if (x < 1) + fun_l1_n460(x) + else + fun_l1_n828(x) + end +end + +def fun_l0_n642(x) + if (x < 1) + fun_l1_n90(x) + else + fun_l1_n113(x) + end +end + +def fun_l0_n643(x) + if (x < 1) + fun_l1_n972(x) + else + fun_l1_n15(x) + end +end + +def fun_l0_n644(x) + if (x < 1) + fun_l1_n417(x) + else + fun_l1_n228(x) + end +end + +def fun_l0_n645(x) + if (x < 1) + fun_l1_n876(x) + else + fun_l1_n152(x) + end +end + +def fun_l0_n646(x) + if (x < 1) + fun_l1_n404(x) + else + fun_l1_n147(x) + end +end + +def fun_l0_n647(x) + if (x < 1) + fun_l1_n802(x) + else + fun_l1_n824(x) + end +end + +def fun_l0_n648(x) + if (x < 1) + fun_l1_n771(x) + else + fun_l1_n421(x) + end +end + +def fun_l0_n649(x) + if (x < 1) + fun_l1_n807(x) + else + fun_l1_n955(x) + end +end + +def fun_l0_n650(x) + if (x < 1) + fun_l1_n221(x) + else + fun_l1_n367(x) + end +end + +def fun_l0_n651(x) + if (x < 1) + fun_l1_n955(x) + else + fun_l1_n401(x) + end +end + +def fun_l0_n652(x) + if (x < 1) + fun_l1_n203(x) + else + fun_l1_n909(x) + end +end + +def fun_l0_n653(x) + if (x < 1) + fun_l1_n154(x) + else + fun_l1_n535(x) + end +end + +def fun_l0_n654(x) + if (x < 1) + fun_l1_n420(x) + else + fun_l1_n393(x) + end +end + +def fun_l0_n655(x) + if (x < 1) + fun_l1_n232(x) + else + fun_l1_n981(x) + end +end + +def fun_l0_n656(x) + if (x < 1) + fun_l1_n873(x) + else + fun_l1_n510(x) + end +end + +def fun_l0_n657(x) + if (x < 1) + fun_l1_n919(x) + else + fun_l1_n706(x) + end +end + +def fun_l0_n658(x) + if (x < 1) + fun_l1_n429(x) + else + fun_l1_n112(x) + end +end + +def fun_l0_n659(x) + if (x < 1) + fun_l1_n547(x) + else + fun_l1_n712(x) + end +end + +def fun_l0_n660(x) + if (x < 1) + fun_l1_n498(x) + else + fun_l1_n695(x) + end +end + +def fun_l0_n661(x) + if (x < 1) + fun_l1_n801(x) + else + fun_l1_n659(x) + end +end + +def fun_l0_n662(x) + if (x < 1) + fun_l1_n796(x) + else + fun_l1_n229(x) + end +end + +def fun_l0_n663(x) + if (x < 1) + fun_l1_n11(x) + else + fun_l1_n620(x) + end +end + +def fun_l0_n664(x) + if (x < 1) + fun_l1_n652(x) + else + fun_l1_n416(x) + end +end + +def fun_l0_n665(x) + if (x < 1) + fun_l1_n655(x) + else + fun_l1_n331(x) + end +end + +def fun_l0_n666(x) + if (x < 1) + fun_l1_n846(x) + else + fun_l1_n1(x) + end +end + +def fun_l0_n667(x) + if (x < 1) + fun_l1_n55(x) + else + fun_l1_n32(x) + end +end + +def fun_l0_n668(x) + if (x < 1) + fun_l1_n241(x) + else + fun_l1_n627(x) + end +end + +def fun_l0_n669(x) + if (x < 1) + fun_l1_n234(x) + else + fun_l1_n996(x) + end +end + +def fun_l0_n670(x) + if (x < 1) + fun_l1_n235(x) + else + fun_l1_n761(x) + end +end + +def fun_l0_n671(x) + if (x < 1) + fun_l1_n990(x) + else + fun_l1_n236(x) + end +end + +def fun_l0_n672(x) + if (x < 1) + fun_l1_n970(x) + else + fun_l1_n595(x) + end +end + +def fun_l0_n673(x) + if (x < 1) + fun_l1_n294(x) + else + fun_l1_n440(x) + end +end + +def fun_l0_n674(x) + if (x < 1) + fun_l1_n597(x) + else + fun_l1_n956(x) + end +end + +def fun_l0_n675(x) + if (x < 1) + fun_l1_n942(x) + else + fun_l1_n352(x) + end +end + +def fun_l0_n676(x) + if (x < 1) + fun_l1_n309(x) + else + fun_l1_n294(x) + end +end + +def fun_l0_n677(x) + if (x < 1) + fun_l1_n752(x) + else + fun_l1_n447(x) + end +end + +def fun_l0_n678(x) + if (x < 1) + fun_l1_n890(x) + else + fun_l1_n497(x) + end +end + +def fun_l0_n679(x) + if (x < 1) + fun_l1_n808(x) + else + fun_l1_n881(x) + end +end + +def fun_l0_n680(x) + if (x < 1) + fun_l1_n966(x) + else + fun_l1_n460(x) + end +end + +def fun_l0_n681(x) + if (x < 1) + fun_l1_n104(x) + else + fun_l1_n262(x) + end +end + +def fun_l0_n682(x) + if (x < 1) + fun_l1_n425(x) + else + fun_l1_n177(x) + end +end + +def fun_l0_n683(x) + if (x < 1) + fun_l1_n15(x) + else + fun_l1_n458(x) + end +end + +def fun_l0_n684(x) + if (x < 1) + fun_l1_n760(x) + else + fun_l1_n997(x) + end +end + +def fun_l0_n685(x) + if (x < 1) + fun_l1_n496(x) + else + fun_l1_n223(x) + end +end + +def fun_l0_n686(x) + if (x < 1) + fun_l1_n363(x) + else + fun_l1_n543(x) + end +end + +def fun_l0_n687(x) + if (x < 1) + fun_l1_n758(x) + else + fun_l1_n473(x) + end +end + +def fun_l0_n688(x) + if (x < 1) + fun_l1_n854(x) + else + fun_l1_n999(x) + end +end + +def fun_l0_n689(x) + if (x < 1) + fun_l1_n336(x) + else + fun_l1_n388(x) + end +end + +def fun_l0_n690(x) + if (x < 1) + fun_l1_n930(x) + else + fun_l1_n478(x) + end +end + +def fun_l0_n691(x) + if (x < 1) + fun_l1_n423(x) + else + fun_l1_n83(x) + end +end + +def fun_l0_n692(x) + if (x < 1) + fun_l1_n797(x) + else + fun_l1_n427(x) + end +end + +def fun_l0_n693(x) + if (x < 1) + fun_l1_n907(x) + else + fun_l1_n1(x) + end +end + +def fun_l0_n694(x) + if (x < 1) + fun_l1_n601(x) + else + fun_l1_n809(x) + end +end + +def fun_l0_n695(x) + if (x < 1) + fun_l1_n252(x) + else + fun_l1_n233(x) + end +end + +def fun_l0_n696(x) + if (x < 1) + fun_l1_n36(x) + else + fun_l1_n796(x) + end +end + +def fun_l0_n697(x) + if (x < 1) + fun_l1_n893(x) + else + fun_l1_n926(x) + end +end + +def fun_l0_n698(x) + if (x < 1) + fun_l1_n511(x) + else + fun_l1_n88(x) + end +end + +def fun_l0_n699(x) + if (x < 1) + fun_l1_n573(x) + else + fun_l1_n718(x) + end +end + +def fun_l0_n700(x) + if (x < 1) + fun_l1_n475(x) + else + fun_l1_n539(x) + end +end + +def fun_l0_n701(x) + if (x < 1) + fun_l1_n238(x) + else + fun_l1_n253(x) + end +end + +def fun_l0_n702(x) + if (x < 1) + fun_l1_n731(x) + else + fun_l1_n225(x) + end +end + +def fun_l0_n703(x) + if (x < 1) + fun_l1_n594(x) + else + fun_l1_n16(x) + end +end + +def fun_l0_n704(x) + if (x < 1) + fun_l1_n732(x) + else + fun_l1_n354(x) + end +end + +def fun_l0_n705(x) + if (x < 1) + fun_l1_n812(x) + else + fun_l1_n218(x) + end +end + +def fun_l0_n706(x) + if (x < 1) + fun_l1_n731(x) + else + fun_l1_n343(x) + end +end + +def fun_l0_n707(x) + if (x < 1) + fun_l1_n134(x) + else + fun_l1_n752(x) + end +end + +def fun_l0_n708(x) + if (x < 1) + fun_l1_n899(x) + else + fun_l1_n854(x) + end +end + +def fun_l0_n709(x) + if (x < 1) + fun_l1_n120(x) + else + fun_l1_n193(x) + end +end + +def fun_l0_n710(x) + if (x < 1) + fun_l1_n22(x) + else + fun_l1_n254(x) + end +end + +def fun_l0_n711(x) + if (x < 1) + fun_l1_n527(x) + else + fun_l1_n921(x) + end +end + +def fun_l0_n712(x) + if (x < 1) + fun_l1_n820(x) + else + fun_l1_n96(x) + end +end + +def fun_l0_n713(x) + if (x < 1) + fun_l1_n145(x) + else + fun_l1_n226(x) + end +end + +def fun_l0_n714(x) + if (x < 1) + fun_l1_n643(x) + else + fun_l1_n407(x) + end +end + +def fun_l0_n715(x) + if (x < 1) + fun_l1_n349(x) + else + fun_l1_n450(x) + end +end + +def fun_l0_n716(x) + if (x < 1) + fun_l1_n954(x) + else + fun_l1_n707(x) + end +end + +def fun_l0_n717(x) + if (x < 1) + fun_l1_n723(x) + else + fun_l1_n762(x) + end +end + +def fun_l0_n718(x) + if (x < 1) + fun_l1_n299(x) + else + fun_l1_n332(x) + end +end + +def fun_l0_n719(x) + if (x < 1) + fun_l1_n493(x) + else + fun_l1_n521(x) + end +end + +def fun_l0_n720(x) + if (x < 1) + fun_l1_n39(x) + else + fun_l1_n17(x) + end +end + +def fun_l0_n721(x) + if (x < 1) + fun_l1_n297(x) + else + fun_l1_n800(x) + end +end + +def fun_l0_n722(x) + if (x < 1) + fun_l1_n758(x) + else + fun_l1_n135(x) + end +end + +def fun_l0_n723(x) + if (x < 1) + fun_l1_n471(x) + else + fun_l1_n351(x) + end +end + +def fun_l0_n724(x) + if (x < 1) + fun_l1_n381(x) + else + fun_l1_n281(x) + end +end + +def fun_l0_n725(x) + if (x < 1) + fun_l1_n624(x) + else + fun_l1_n162(x) + end +end + +def fun_l0_n726(x) + if (x < 1) + fun_l1_n143(x) + else + fun_l1_n417(x) + end +end + +def fun_l0_n727(x) + if (x < 1) + fun_l1_n623(x) + else + fun_l1_n19(x) + end +end + +def fun_l0_n728(x) + if (x < 1) + fun_l1_n687(x) + else + fun_l1_n574(x) + end +end + +def fun_l0_n729(x) + if (x < 1) + fun_l1_n225(x) + else + fun_l1_n871(x) + end +end + +def fun_l0_n730(x) + if (x < 1) + fun_l1_n830(x) + else + fun_l1_n273(x) + end +end + +def fun_l0_n731(x) + if (x < 1) + fun_l1_n95(x) + else + fun_l1_n864(x) + end +end + +def fun_l0_n732(x) + if (x < 1) + fun_l1_n902(x) + else + fun_l1_n522(x) + end +end + +def fun_l0_n733(x) + if (x < 1) + fun_l1_n564(x) + else + fun_l1_n55(x) + end +end + +def fun_l0_n734(x) + if (x < 1) + fun_l1_n481(x) + else + fun_l1_n880(x) + end +end + +def fun_l0_n735(x) + if (x < 1) + fun_l1_n87(x) + else + fun_l1_n693(x) + end +end + +def fun_l0_n736(x) + if (x < 1) + fun_l1_n72(x) + else + fun_l1_n396(x) + end +end + +def fun_l0_n737(x) + if (x < 1) + fun_l1_n920(x) + else + fun_l1_n852(x) + end +end + +def fun_l0_n738(x) + if (x < 1) + fun_l1_n342(x) + else + fun_l1_n959(x) + end +end + +def fun_l0_n739(x) + if (x < 1) + fun_l1_n682(x) + else + fun_l1_n714(x) + end +end + +def fun_l0_n740(x) + if (x < 1) + fun_l1_n264(x) + else + fun_l1_n325(x) + end +end + +def fun_l0_n741(x) + if (x < 1) + fun_l1_n621(x) + else + fun_l1_n339(x) + end +end + +def fun_l0_n742(x) + if (x < 1) + fun_l1_n46(x) + else + fun_l1_n766(x) + end +end + +def fun_l0_n743(x) + if (x < 1) + fun_l1_n333(x) + else + fun_l1_n353(x) + end +end + +def fun_l0_n744(x) + if (x < 1) + fun_l1_n930(x) + else + fun_l1_n964(x) + end +end + +def fun_l0_n745(x) + if (x < 1) + fun_l1_n785(x) + else + fun_l1_n114(x) + end +end + +def fun_l0_n746(x) + if (x < 1) + fun_l1_n402(x) + else + fun_l1_n803(x) + end +end + +def fun_l0_n747(x) + if (x < 1) + fun_l1_n878(x) + else + fun_l1_n870(x) + end +end + +def fun_l0_n748(x) + if (x < 1) + fun_l1_n683(x) + else + fun_l1_n287(x) + end +end + +def fun_l0_n749(x) + if (x < 1) + fun_l1_n816(x) + else + fun_l1_n849(x) + end +end + +def fun_l0_n750(x) + if (x < 1) + fun_l1_n523(x) + else + fun_l1_n555(x) + end +end + +def fun_l0_n751(x) + if (x < 1) + fun_l1_n270(x) + else + fun_l1_n660(x) + end +end + +def fun_l0_n752(x) + if (x < 1) + fun_l1_n786(x) + else + fun_l1_n749(x) + end +end + +def fun_l0_n753(x) + if (x < 1) + fun_l1_n567(x) + else + fun_l1_n325(x) + end +end + +def fun_l0_n754(x) + if (x < 1) + fun_l1_n502(x) + else + fun_l1_n610(x) + end +end + +def fun_l0_n755(x) + if (x < 1) + fun_l1_n336(x) + else + fun_l1_n354(x) + end +end + +def fun_l0_n756(x) + if (x < 1) + fun_l1_n435(x) + else + fun_l1_n484(x) + end +end + +def fun_l0_n757(x) + if (x < 1) + fun_l1_n849(x) + else + fun_l1_n42(x) + end +end + +def fun_l0_n758(x) + if (x < 1) + fun_l1_n294(x) + else + fun_l1_n483(x) + end +end + +def fun_l0_n759(x) + if (x < 1) + fun_l1_n14(x) + else + fun_l1_n9(x) + end +end + +def fun_l0_n760(x) + if (x < 1) + fun_l1_n860(x) + else + fun_l1_n645(x) + end +end + +def fun_l0_n761(x) + if (x < 1) + fun_l1_n577(x) + else + fun_l1_n0(x) + end +end + +def fun_l0_n762(x) + if (x < 1) + fun_l1_n28(x) + else + fun_l1_n834(x) + end +end + +def fun_l0_n763(x) + if (x < 1) + fun_l1_n147(x) + else + fun_l1_n177(x) + end +end + +def fun_l0_n764(x) + if (x < 1) + fun_l1_n429(x) + else + fun_l1_n646(x) + end +end + +def fun_l0_n765(x) + if (x < 1) + fun_l1_n474(x) + else + fun_l1_n22(x) + end +end + +def fun_l0_n766(x) + if (x < 1) + fun_l1_n264(x) + else + fun_l1_n549(x) + end +end + +def fun_l0_n767(x) + if (x < 1) + fun_l1_n351(x) + else + fun_l1_n813(x) + end +end + +def fun_l0_n768(x) + if (x < 1) + fun_l1_n798(x) + else + fun_l1_n684(x) + end +end + +def fun_l0_n769(x) + if (x < 1) + fun_l1_n202(x) + else + fun_l1_n982(x) + end +end + +def fun_l0_n770(x) + if (x < 1) + fun_l1_n611(x) + else + fun_l1_n52(x) + end +end + +def fun_l0_n771(x) + if (x < 1) + fun_l1_n754(x) + else + fun_l1_n7(x) + end +end + +def fun_l0_n772(x) + if (x < 1) + fun_l1_n98(x) + else + fun_l1_n149(x) + end +end + +def fun_l0_n773(x) + if (x < 1) + fun_l1_n358(x) + else + fun_l1_n603(x) + end +end + +def fun_l0_n774(x) + if (x < 1) + fun_l1_n604(x) + else + fun_l1_n318(x) + end +end + +def fun_l0_n775(x) + if (x < 1) + fun_l1_n831(x) + else + fun_l1_n635(x) + end +end + +def fun_l0_n776(x) + if (x < 1) + fun_l1_n738(x) + else + fun_l1_n563(x) + end +end + +def fun_l0_n777(x) + if (x < 1) + fun_l1_n570(x) + else + fun_l1_n671(x) + end +end + +def fun_l0_n778(x) + if (x < 1) + fun_l1_n945(x) + else + fun_l1_n840(x) + end +end + +def fun_l0_n779(x) + if (x < 1) + fun_l1_n116(x) + else + fun_l1_n942(x) + end +end + +def fun_l0_n780(x) + if (x < 1) + fun_l1_n835(x) + else + fun_l1_n244(x) + end +end + +def fun_l0_n781(x) + if (x < 1) + fun_l1_n427(x) + else + fun_l1_n556(x) + end +end + +def fun_l0_n782(x) + if (x < 1) + fun_l1_n280(x) + else + fun_l1_n926(x) + end +end + +def fun_l0_n783(x) + if (x < 1) + fun_l1_n674(x) + else + fun_l1_n560(x) + end +end + +def fun_l0_n784(x) + if (x < 1) + fun_l1_n978(x) + else + fun_l1_n139(x) + end +end + +def fun_l0_n785(x) + if (x < 1) + fun_l1_n928(x) + else + fun_l1_n11(x) + end +end + +def fun_l0_n786(x) + if (x < 1) + fun_l1_n829(x) + else + fun_l1_n239(x) + end +end + +def fun_l0_n787(x) + if (x < 1) + fun_l1_n732(x) + else + fun_l1_n829(x) + end +end + +def fun_l0_n788(x) + if (x < 1) + fun_l1_n968(x) + else + fun_l1_n596(x) + end +end + +def fun_l0_n789(x) + if (x < 1) + fun_l1_n214(x) + else + fun_l1_n158(x) + end +end + +def fun_l0_n790(x) + if (x < 1) + fun_l1_n566(x) + else + fun_l1_n390(x) + end +end + +def fun_l0_n791(x) + if (x < 1) + fun_l1_n936(x) + else + fun_l1_n31(x) + end +end + +def fun_l0_n792(x) + if (x < 1) + fun_l1_n291(x) + else + fun_l1_n835(x) + end +end + +def fun_l0_n793(x) + if (x < 1) + fun_l1_n300(x) + else + fun_l1_n658(x) + end +end + +def fun_l0_n794(x) + if (x < 1) + fun_l1_n609(x) + else + fun_l1_n156(x) + end +end + +def fun_l0_n795(x) + if (x < 1) + fun_l1_n419(x) + else + fun_l1_n534(x) + end +end + +def fun_l0_n796(x) + if (x < 1) + fun_l1_n401(x) + else + fun_l1_n281(x) + end +end + +def fun_l0_n797(x) + if (x < 1) + fun_l1_n538(x) + else + fun_l1_n905(x) + end +end + +def fun_l0_n798(x) + if (x < 1) + fun_l1_n427(x) + else + fun_l1_n978(x) + end +end + +def fun_l0_n799(x) + if (x < 1) + fun_l1_n851(x) + else + fun_l1_n57(x) + end +end + +def fun_l0_n800(x) + if (x < 1) + fun_l1_n836(x) + else + fun_l1_n306(x) + end +end + +def fun_l0_n801(x) + if (x < 1) + fun_l1_n414(x) + else + fun_l1_n679(x) + end +end + +def fun_l0_n802(x) + if (x < 1) + fun_l1_n645(x) + else + fun_l1_n115(x) + end +end + +def fun_l0_n803(x) + if (x < 1) + fun_l1_n884(x) + else + fun_l1_n801(x) + end +end + +def fun_l0_n804(x) + if (x < 1) + fun_l1_n713(x) + else + fun_l1_n974(x) + end +end + +def fun_l0_n805(x) + if (x < 1) + fun_l1_n301(x) + else + fun_l1_n589(x) + end +end + +def fun_l0_n806(x) + if (x < 1) + fun_l1_n912(x) + else + fun_l1_n766(x) + end +end + +def fun_l0_n807(x) + if (x < 1) + fun_l1_n656(x) + else + fun_l1_n765(x) + end +end + +def fun_l0_n808(x) + if (x < 1) + fun_l1_n517(x) + else + fun_l1_n964(x) + end +end + +def fun_l0_n809(x) + if (x < 1) + fun_l1_n878(x) + else + fun_l1_n69(x) + end +end + +def fun_l0_n810(x) + if (x < 1) + fun_l1_n527(x) + else + fun_l1_n841(x) + end +end + +def fun_l0_n811(x) + if (x < 1) + fun_l1_n564(x) + else + fun_l1_n541(x) + end +end + +def fun_l0_n812(x) + if (x < 1) + fun_l1_n754(x) + else + fun_l1_n681(x) + end +end + +def fun_l0_n813(x) + if (x < 1) + fun_l1_n21(x) + else + fun_l1_n561(x) + end +end + +def fun_l0_n814(x) + if (x < 1) + fun_l1_n547(x) + else + fun_l1_n631(x) + end +end + +def fun_l0_n815(x) + if (x < 1) + fun_l1_n956(x) + else + fun_l1_n889(x) + end +end + +def fun_l0_n816(x) + if (x < 1) + fun_l1_n817(x) + else + fun_l1_n957(x) + end +end + +def fun_l0_n817(x) + if (x < 1) + fun_l1_n622(x) + else + fun_l1_n827(x) + end +end + +def fun_l0_n818(x) + if (x < 1) + fun_l1_n7(x) + else + fun_l1_n208(x) + end +end + +def fun_l0_n819(x) + if (x < 1) + fun_l1_n411(x) + else + fun_l1_n742(x) + end +end + +def fun_l0_n820(x) + if (x < 1) + fun_l1_n676(x) + else + fun_l1_n144(x) + end +end + +def fun_l0_n821(x) + if (x < 1) + fun_l1_n489(x) + else + fun_l1_n963(x) + end +end + +def fun_l0_n822(x) + if (x < 1) + fun_l1_n645(x) + else + fun_l1_n953(x) + end +end + +def fun_l0_n823(x) + if (x < 1) + fun_l1_n974(x) + else + fun_l1_n75(x) + end +end + +def fun_l0_n824(x) + if (x < 1) + fun_l1_n295(x) + else + fun_l1_n249(x) + end +end + +def fun_l0_n825(x) + if (x < 1) + fun_l1_n141(x) + else + fun_l1_n633(x) + end +end + +def fun_l0_n826(x) + if (x < 1) + fun_l1_n317(x) + else + fun_l1_n152(x) + end +end + +def fun_l0_n827(x) + if (x < 1) + fun_l1_n570(x) + else + fun_l1_n377(x) + end +end + +def fun_l0_n828(x) + if (x < 1) + fun_l1_n392(x) + else + fun_l1_n477(x) + end +end + +def fun_l0_n829(x) + if (x < 1) + fun_l1_n277(x) + else + fun_l1_n276(x) + end +end + +def fun_l0_n830(x) + if (x < 1) + fun_l1_n579(x) + else + fun_l1_n648(x) + end +end + +def fun_l0_n831(x) + if (x < 1) + fun_l1_n8(x) + else + fun_l1_n25(x) + end +end + +def fun_l0_n832(x) + if (x < 1) + fun_l1_n724(x) + else + fun_l1_n617(x) + end +end + +def fun_l0_n833(x) + if (x < 1) + fun_l1_n771(x) + else + fun_l1_n619(x) + end +end + +def fun_l0_n834(x) + if (x < 1) + fun_l1_n23(x) + else + fun_l1_n127(x) + end +end + +def fun_l0_n835(x) + if (x < 1) + fun_l1_n322(x) + else + fun_l1_n327(x) + end +end + +def fun_l0_n836(x) + if (x < 1) + fun_l1_n7(x) + else + fun_l1_n600(x) + end +end + +def fun_l0_n837(x) + if (x < 1) + fun_l1_n796(x) + else + fun_l1_n782(x) + end +end + +def fun_l0_n838(x) + if (x < 1) + fun_l1_n937(x) + else + fun_l1_n899(x) + end +end + +def fun_l0_n839(x) + if (x < 1) + fun_l1_n16(x) + else + fun_l1_n349(x) + end +end + +def fun_l0_n840(x) + if (x < 1) + fun_l1_n622(x) + else + fun_l1_n960(x) + end +end + +def fun_l0_n841(x) + if (x < 1) + fun_l1_n295(x) + else + fun_l1_n176(x) + end +end + +def fun_l0_n842(x) + if (x < 1) + fun_l1_n302(x) + else + fun_l1_n639(x) + end +end + +def fun_l0_n843(x) + if (x < 1) + fun_l1_n342(x) + else + fun_l1_n373(x) + end +end + +def fun_l0_n844(x) + if (x < 1) + fun_l1_n5(x) + else + fun_l1_n787(x) + end +end + +def fun_l0_n845(x) + if (x < 1) + fun_l1_n89(x) + else + fun_l1_n951(x) + end +end + +def fun_l0_n846(x) + if (x < 1) + fun_l1_n954(x) + else + fun_l1_n982(x) + end +end + +def fun_l0_n847(x) + if (x < 1) + fun_l1_n971(x) + else + fun_l1_n917(x) + end +end + +def fun_l0_n848(x) + if (x < 1) + fun_l1_n845(x) + else + fun_l1_n343(x) + end +end + +def fun_l0_n849(x) + if (x < 1) + fun_l1_n684(x) + else + fun_l1_n683(x) + end +end + +def fun_l0_n850(x) + if (x < 1) + fun_l1_n670(x) + else + fun_l1_n256(x) + end +end + +def fun_l0_n851(x) + if (x < 1) + fun_l1_n405(x) + else + fun_l1_n123(x) + end +end + +def fun_l0_n852(x) + if (x < 1) + fun_l1_n809(x) + else + fun_l1_n691(x) + end +end + +def fun_l0_n853(x) + if (x < 1) + fun_l1_n937(x) + else + fun_l1_n92(x) + end +end + +def fun_l0_n854(x) + if (x < 1) + fun_l1_n735(x) + else + fun_l1_n948(x) + end +end + +def fun_l0_n855(x) + if (x < 1) + fun_l1_n684(x) + else + fun_l1_n566(x) + end +end + +def fun_l0_n856(x) + if (x < 1) + fun_l1_n508(x) + else + fun_l1_n35(x) + end +end + +def fun_l0_n857(x) + if (x < 1) + fun_l1_n865(x) + else + fun_l1_n930(x) + end +end + +def fun_l0_n858(x) + if (x < 1) + fun_l1_n937(x) + else + fun_l1_n241(x) + end +end + +def fun_l0_n859(x) + if (x < 1) + fun_l1_n938(x) + else + fun_l1_n108(x) + end +end + +def fun_l0_n860(x) + if (x < 1) + fun_l1_n491(x) + else + fun_l1_n119(x) + end +end + +def fun_l0_n861(x) + if (x < 1) + fun_l1_n991(x) + else + fun_l1_n198(x) + end +end + +def fun_l0_n862(x) + if (x < 1) + fun_l1_n846(x) + else + fun_l1_n513(x) + end +end + +def fun_l0_n863(x) + if (x < 1) + fun_l1_n279(x) + else + fun_l1_n229(x) + end +end + +def fun_l0_n864(x) + if (x < 1) + fun_l1_n52(x) + else + fun_l1_n765(x) + end +end + +def fun_l0_n865(x) + if (x < 1) + fun_l1_n35(x) + else + fun_l1_n572(x) + end +end + +def fun_l0_n866(x) + if (x < 1) + fun_l1_n4(x) + else + fun_l1_n645(x) + end +end + +def fun_l0_n867(x) + if (x < 1) + fun_l1_n112(x) + else + fun_l1_n758(x) + end +end + +def fun_l0_n868(x) + if (x < 1) + fun_l1_n924(x) + else + fun_l1_n251(x) + end +end + +def fun_l0_n869(x) + if (x < 1) + fun_l1_n558(x) + else + fun_l1_n818(x) + end +end + +def fun_l0_n870(x) + if (x < 1) + fun_l1_n804(x) + else + fun_l1_n746(x) + end +end + +def fun_l0_n871(x) + if (x < 1) + fun_l1_n111(x) + else + fun_l1_n407(x) + end +end + +def fun_l0_n872(x) + if (x < 1) + fun_l1_n973(x) + else + fun_l1_n384(x) + end +end + +def fun_l0_n873(x) + if (x < 1) + fun_l1_n102(x) + else + fun_l1_n199(x) + end +end + +def fun_l0_n874(x) + if (x < 1) + fun_l1_n735(x) + else + fun_l1_n903(x) + end +end + +def fun_l0_n875(x) + if (x < 1) + fun_l1_n95(x) + else + fun_l1_n720(x) + end +end + +def fun_l0_n876(x) + if (x < 1) + fun_l1_n864(x) + else + fun_l1_n970(x) + end +end + +def fun_l0_n877(x) + if (x < 1) + fun_l1_n729(x) + else + fun_l1_n207(x) + end +end + +def fun_l0_n878(x) + if (x < 1) + fun_l1_n104(x) + else + fun_l1_n209(x) + end +end + +def fun_l0_n879(x) + if (x < 1) + fun_l1_n566(x) + else + fun_l1_n918(x) + end +end + +def fun_l0_n880(x) + if (x < 1) + fun_l1_n457(x) + else + fun_l1_n104(x) + end +end + +def fun_l0_n881(x) + if (x < 1) + fun_l1_n745(x) + else + fun_l1_n476(x) + end +end + +def fun_l0_n882(x) + if (x < 1) + fun_l1_n346(x) + else + fun_l1_n642(x) + end +end + +def fun_l0_n883(x) + if (x < 1) + fun_l1_n78(x) + else + fun_l1_n210(x) + end +end + +def fun_l0_n884(x) + if (x < 1) + fun_l1_n864(x) + else + fun_l1_n439(x) + end +end + +def fun_l0_n885(x) + if (x < 1) + fun_l1_n0(x) + else + fun_l1_n414(x) + end +end + +def fun_l0_n886(x) + if (x < 1) + fun_l1_n217(x) + else + fun_l1_n444(x) + end +end + +def fun_l0_n887(x) + if (x < 1) + fun_l1_n193(x) + else + fun_l1_n788(x) + end +end + +def fun_l0_n888(x) + if (x < 1) + fun_l1_n30(x) + else + fun_l1_n793(x) + end +end + +def fun_l0_n889(x) + if (x < 1) + fun_l1_n222(x) + else + fun_l1_n936(x) + end +end + +def fun_l0_n890(x) + if (x < 1) + fun_l1_n758(x) + else + fun_l1_n52(x) + end +end + +def fun_l0_n891(x) + if (x < 1) + fun_l1_n796(x) + else + fun_l1_n424(x) + end +end + +def fun_l0_n892(x) + if (x < 1) + fun_l1_n627(x) + else + fun_l1_n284(x) + end +end + +def fun_l0_n893(x) + if (x < 1) + fun_l1_n42(x) + else + fun_l1_n193(x) + end +end + +def fun_l0_n894(x) + if (x < 1) + fun_l1_n90(x) + else + fun_l1_n158(x) + end +end + +def fun_l0_n895(x) + if (x < 1) + fun_l1_n878(x) + else + fun_l1_n396(x) + end +end + +def fun_l0_n896(x) + if (x < 1) + fun_l1_n665(x) + else + fun_l1_n731(x) + end +end + +def fun_l0_n897(x) + if (x < 1) + fun_l1_n618(x) + else + fun_l1_n152(x) + end +end + +def fun_l0_n898(x) + if (x < 1) + fun_l1_n64(x) + else + fun_l1_n697(x) + end +end + +def fun_l0_n899(x) + if (x < 1) + fun_l1_n354(x) + else + fun_l1_n657(x) + end +end + +def fun_l0_n900(x) + if (x < 1) + fun_l1_n79(x) + else + fun_l1_n794(x) + end +end + +def fun_l0_n901(x) + if (x < 1) + fun_l1_n623(x) + else + fun_l1_n392(x) + end +end + +def fun_l0_n902(x) + if (x < 1) + fun_l1_n529(x) + else + fun_l1_n708(x) + end +end + +def fun_l0_n903(x) + if (x < 1) + fun_l1_n900(x) + else + fun_l1_n830(x) + end +end + +def fun_l0_n904(x) + if (x < 1) + fun_l1_n424(x) + else + fun_l1_n564(x) + end +end + +def fun_l0_n905(x) + if (x < 1) + fun_l1_n557(x) + else + fun_l1_n612(x) + end +end + +def fun_l0_n906(x) + if (x < 1) + fun_l1_n725(x) + else + fun_l1_n166(x) + end +end + +def fun_l0_n907(x) + if (x < 1) + fun_l1_n534(x) + else + fun_l1_n159(x) + end +end + +def fun_l0_n908(x) + if (x < 1) + fun_l1_n50(x) + else + fun_l1_n201(x) + end +end + +def fun_l0_n909(x) + if (x < 1) + fun_l1_n568(x) + else + fun_l1_n276(x) + end +end + +def fun_l0_n910(x) + if (x < 1) + fun_l1_n0(x) + else + fun_l1_n324(x) + end +end + +def fun_l0_n911(x) + if (x < 1) + fun_l1_n926(x) + else + fun_l1_n524(x) + end +end + +def fun_l0_n912(x) + if (x < 1) + fun_l1_n498(x) + else + fun_l1_n650(x) + end +end + +def fun_l0_n913(x) + if (x < 1) + fun_l1_n593(x) + else + fun_l1_n860(x) + end +end + +def fun_l0_n914(x) + if (x < 1) + fun_l1_n726(x) + else + fun_l1_n440(x) + end +end + +def fun_l0_n915(x) + if (x < 1) + fun_l1_n422(x) + else + fun_l1_n627(x) + end +end + +def fun_l0_n916(x) + if (x < 1) + fun_l1_n346(x) + else + fun_l1_n932(x) + end +end + +def fun_l0_n917(x) + if (x < 1) + fun_l1_n403(x) + else + fun_l1_n58(x) + end +end + +def fun_l0_n918(x) + if (x < 1) + fun_l1_n989(x) + else + fun_l1_n579(x) + end +end + +def fun_l0_n919(x) + if (x < 1) + fun_l1_n933(x) + else + fun_l1_n434(x) + end +end + +def fun_l0_n920(x) + if (x < 1) + fun_l1_n899(x) + else + fun_l1_n377(x) + end +end + +def fun_l0_n921(x) + if (x < 1) + fun_l1_n17(x) + else + fun_l1_n637(x) + end +end + +def fun_l0_n922(x) + if (x < 1) + fun_l1_n551(x) + else + fun_l1_n693(x) + end +end + +def fun_l0_n923(x) + if (x < 1) + fun_l1_n861(x) + else + fun_l1_n248(x) + end +end + +def fun_l0_n924(x) + if (x < 1) + fun_l1_n171(x) + else + fun_l1_n75(x) + end +end + +def fun_l0_n925(x) + if (x < 1) + fun_l1_n233(x) + else + fun_l1_n444(x) + end +end + +def fun_l0_n926(x) + if (x < 1) + fun_l1_n310(x) + else + fun_l1_n941(x) + end +end + +def fun_l0_n927(x) + if (x < 1) + fun_l1_n363(x) + else + fun_l1_n567(x) + end +end + +def fun_l0_n928(x) + if (x < 1) + fun_l1_n632(x) + else + fun_l1_n840(x) + end +end + +def fun_l0_n929(x) + if (x < 1) + fun_l1_n368(x) + else + fun_l1_n713(x) + end +end + +def fun_l0_n930(x) + if (x < 1) + fun_l1_n37(x) + else + fun_l1_n355(x) + end +end + +def fun_l0_n931(x) + if (x < 1) + fun_l1_n907(x) + else + fun_l1_n784(x) + end +end + +def fun_l0_n932(x) + if (x < 1) + fun_l1_n591(x) + else + fun_l1_n844(x) + end +end + +def fun_l0_n933(x) + if (x < 1) + fun_l1_n996(x) + else + fun_l1_n943(x) + end +end + +def fun_l0_n934(x) + if (x < 1) + fun_l1_n631(x) + else + fun_l1_n643(x) + end +end + +def fun_l0_n935(x) + if (x < 1) + fun_l1_n875(x) + else + fun_l1_n89(x) + end +end + +def fun_l0_n936(x) + if (x < 1) + fun_l1_n842(x) + else + fun_l1_n595(x) + end +end + +def fun_l0_n937(x) + if (x < 1) + fun_l1_n921(x) + else + fun_l1_n271(x) + end +end + +def fun_l0_n938(x) + if (x < 1) + fun_l1_n222(x) + else + fun_l1_n170(x) + end +end + +def fun_l0_n939(x) + if (x < 1) + fun_l1_n567(x) + else + fun_l1_n463(x) + end +end + +def fun_l0_n940(x) + if (x < 1) + fun_l1_n456(x) + else + fun_l1_n192(x) + end +end + +def fun_l0_n941(x) + if (x < 1) + fun_l1_n32(x) + else + fun_l1_n951(x) + end +end + +def fun_l0_n942(x) + if (x < 1) + fun_l1_n14(x) + else + fun_l1_n135(x) + end +end + +def fun_l0_n943(x) + if (x < 1) + fun_l1_n15(x) + else + fun_l1_n234(x) + end +end + +def fun_l0_n944(x) + if (x < 1) + fun_l1_n119(x) + else + fun_l1_n33(x) + end +end + +def fun_l0_n945(x) + if (x < 1) + fun_l1_n859(x) + else + fun_l1_n497(x) + end +end + +def fun_l0_n946(x) + if (x < 1) + fun_l1_n178(x) + else + fun_l1_n369(x) + end +end + +def fun_l0_n947(x) + if (x < 1) + fun_l1_n64(x) + else + fun_l1_n356(x) + end +end + +def fun_l0_n948(x) + if (x < 1) + fun_l1_n279(x) + else + fun_l1_n244(x) + end +end + +def fun_l0_n949(x) + if (x < 1) + fun_l1_n728(x) + else + fun_l1_n548(x) + end +end + +def fun_l0_n950(x) + if (x < 1) + fun_l1_n3(x) + else + fun_l1_n698(x) + end +end + +def fun_l0_n951(x) + if (x < 1) + fun_l1_n665(x) + else + fun_l1_n198(x) + end +end + +def fun_l0_n952(x) + if (x < 1) + fun_l1_n812(x) + else + fun_l1_n964(x) + end +end + +def fun_l0_n953(x) + if (x < 1) + fun_l1_n851(x) + else + fun_l1_n877(x) + end +end + +def fun_l0_n954(x) + if (x < 1) + fun_l1_n415(x) + else + fun_l1_n379(x) + end +end + +def fun_l0_n955(x) + if (x < 1) + fun_l1_n806(x) + else + fun_l1_n919(x) + end +end + +def fun_l0_n956(x) + if (x < 1) + fun_l1_n207(x) + else + fun_l1_n798(x) + end +end + +def fun_l0_n957(x) + if (x < 1) + fun_l1_n269(x) + else + fun_l1_n416(x) + end +end + +def fun_l0_n958(x) + if (x < 1) + fun_l1_n654(x) + else + fun_l1_n236(x) + end +end + +def fun_l0_n959(x) + if (x < 1) + fun_l1_n392(x) + else + fun_l1_n623(x) + end +end + +def fun_l0_n960(x) + if (x < 1) + fun_l1_n889(x) + else + fun_l1_n279(x) + end +end + +def fun_l0_n961(x) + if (x < 1) + fun_l1_n476(x) + else + fun_l1_n201(x) + end +end + +def fun_l0_n962(x) + if (x < 1) + fun_l1_n799(x) + else + fun_l1_n570(x) + end +end + +def fun_l0_n963(x) + if (x < 1) + fun_l1_n802(x) + else + fun_l1_n114(x) + end +end + +def fun_l0_n964(x) + if (x < 1) + fun_l1_n197(x) + else + fun_l1_n422(x) + end +end + +def fun_l0_n965(x) + if (x < 1) + fun_l1_n37(x) + else + fun_l1_n691(x) + end +end + +def fun_l0_n966(x) + if (x < 1) + fun_l1_n775(x) + else + fun_l1_n854(x) + end +end + +def fun_l0_n967(x) + if (x < 1) + fun_l1_n373(x) + else + fun_l1_n306(x) + end +end + +def fun_l0_n968(x) + if (x < 1) + fun_l1_n154(x) + else + fun_l1_n122(x) + end +end + +def fun_l0_n969(x) + if (x < 1) + fun_l1_n497(x) + else + fun_l1_n456(x) + end +end + +def fun_l0_n970(x) + if (x < 1) + fun_l1_n621(x) + else + fun_l1_n931(x) + end +end + +def fun_l0_n971(x) + if (x < 1) + fun_l1_n963(x) + else + fun_l1_n613(x) + end +end + +def fun_l0_n972(x) + if (x < 1) + fun_l1_n613(x) + else + fun_l1_n508(x) + end +end + +def fun_l0_n973(x) + if (x < 1) + fun_l1_n466(x) + else + fun_l1_n929(x) + end +end + +def fun_l0_n974(x) + if (x < 1) + fun_l1_n247(x) + else + fun_l1_n610(x) + end +end + +def fun_l0_n975(x) + if (x < 1) + fun_l1_n674(x) + else + fun_l1_n609(x) + end +end + +def fun_l0_n976(x) + if (x < 1) + fun_l1_n963(x) + else + fun_l1_n601(x) + end +end + +def fun_l0_n977(x) + if (x < 1) + fun_l1_n728(x) + else + fun_l1_n242(x) + end +end + +def fun_l0_n978(x) + if (x < 1) + fun_l1_n515(x) + else + fun_l1_n113(x) + end +end + +def fun_l0_n979(x) + if (x < 1) + fun_l1_n734(x) + else + fun_l1_n271(x) + end +end + +def fun_l0_n980(x) + if (x < 1) + fun_l1_n837(x) + else + fun_l1_n733(x) + end +end + +def fun_l0_n981(x) + if (x < 1) + fun_l1_n326(x) + else + fun_l1_n213(x) + end +end + +def fun_l0_n982(x) + if (x < 1) + fun_l1_n733(x) + else + fun_l1_n198(x) + end +end + +def fun_l0_n983(x) + if (x < 1) + fun_l1_n989(x) + else + fun_l1_n700(x) + end +end + +def fun_l0_n984(x) + if (x < 1) + fun_l1_n266(x) + else + fun_l1_n348(x) + end +end + +def fun_l0_n985(x) + if (x < 1) + fun_l1_n931(x) + else + fun_l1_n646(x) + end +end + +def fun_l0_n986(x) + if (x < 1) + fun_l1_n435(x) + else + fun_l1_n747(x) + end +end + +def fun_l0_n987(x) + if (x < 1) + fun_l1_n474(x) + else + fun_l1_n638(x) + end +end + +def fun_l0_n988(x) + if (x < 1) + fun_l1_n615(x) + else + fun_l1_n283(x) + end +end + +def fun_l0_n989(x) + if (x < 1) + fun_l1_n410(x) + else + fun_l1_n289(x) + end +end + +def fun_l0_n990(x) + if (x < 1) + fun_l1_n633(x) + else + fun_l1_n77(x) + end +end + +def fun_l0_n991(x) + if (x < 1) + fun_l1_n153(x) + else + fun_l1_n255(x) + end +end + +def fun_l0_n992(x) + if (x < 1) + fun_l1_n447(x) + else + fun_l1_n239(x) + end +end + +def fun_l0_n993(x) + if (x < 1) + fun_l1_n837(x) + else + fun_l1_n582(x) + end +end + +def fun_l0_n994(x) + if (x < 1) + fun_l1_n385(x) + else + fun_l1_n939(x) + end +end + +def fun_l0_n995(x) + if (x < 1) + fun_l1_n236(x) + else + fun_l1_n497(x) + end +end + +def fun_l0_n996(x) + if (x < 1) + fun_l1_n63(x) + else + fun_l1_n721(x) + end +end + +def fun_l0_n997(x) + if (x < 1) + fun_l1_n457(x) + else + fun_l1_n376(x) + end +end + +def fun_l0_n998(x) + if (x < 1) + fun_l1_n362(x) + else + fun_l1_n478(x) + end +end + +def fun_l0_n999(x) + if (x < 1) + fun_l1_n554(x) + else + fun_l1_n422(x) + end +end + +def fun_l1_n0(x) + if (x < 1) + fun_l2_n498(x) + else + fun_l2_n461(x) + end +end + +def fun_l1_n1(x) + if (x < 1) + fun_l2_n424(x) + else + fun_l2_n137(x) + end +end + +def fun_l1_n2(x) + if (x < 1) + fun_l2_n325(x) + else + fun_l2_n95(x) + end +end + +def fun_l1_n3(x) + if (x < 1) + fun_l2_n917(x) + else + fun_l2_n469(x) + end +end + +def fun_l1_n4(x) + if (x < 1) + fun_l2_n730(x) + else + fun_l2_n147(x) + end +end + +def fun_l1_n5(x) + if (x < 1) + fun_l2_n796(x) + else + fun_l2_n907(x) + end +end + +def fun_l1_n6(x) + if (x < 1) + fun_l2_n555(x) + else + fun_l2_n309(x) + end +end + +def fun_l1_n7(x) + if (x < 1) + fun_l2_n475(x) + else + fun_l2_n193(x) + end +end + +def fun_l1_n8(x) + if (x < 1) + fun_l2_n317(x) + else + fun_l2_n284(x) + end +end + +def fun_l1_n9(x) + if (x < 1) + fun_l2_n297(x) + else + fun_l2_n370(x) + end +end + +def fun_l1_n10(x) + if (x < 1) + fun_l2_n66(x) + else + fun_l2_n959(x) + end +end + +def fun_l1_n11(x) + if (x < 1) + fun_l2_n833(x) + else + fun_l2_n250(x) + end +end + +def fun_l1_n12(x) + if (x < 1) + fun_l2_n640(x) + else + fun_l2_n588(x) + end +end + +def fun_l1_n13(x) + if (x < 1) + fun_l2_n91(x) + else + fun_l2_n294(x) + end +end + +def fun_l1_n14(x) + if (x < 1) + fun_l2_n166(x) + else + fun_l2_n943(x) + end +end + +def fun_l1_n15(x) + if (x < 1) + fun_l2_n352(x) + else + fun_l2_n363(x) + end +end + +def fun_l1_n16(x) + if (x < 1) + fun_l2_n84(x) + else + fun_l2_n278(x) + end +end + +def fun_l1_n17(x) + if (x < 1) + fun_l2_n308(x) + else + fun_l2_n341(x) + end +end + +def fun_l1_n18(x) + if (x < 1) + fun_l2_n713(x) + else + fun_l2_n575(x) + end +end + +def fun_l1_n19(x) + if (x < 1) + fun_l2_n81(x) + else + fun_l2_n301(x) + end +end + +def fun_l1_n20(x) + if (x < 1) + fun_l2_n516(x) + else + fun_l2_n164(x) + end +end + +def fun_l1_n21(x) + if (x < 1) + fun_l2_n900(x) + else + fun_l2_n963(x) + end +end + +def fun_l1_n22(x) + if (x < 1) + fun_l2_n472(x) + else + fun_l2_n288(x) + end +end + +def fun_l1_n23(x) + if (x < 1) + fun_l2_n587(x) + else + fun_l2_n515(x) + end +end + +def fun_l1_n24(x) + if (x < 1) + fun_l2_n506(x) + else + fun_l2_n711(x) + end +end + +def fun_l1_n25(x) + if (x < 1) + fun_l2_n935(x) + else + fun_l2_n177(x) + end +end + +def fun_l1_n26(x) + if (x < 1) + fun_l2_n485(x) + else + fun_l2_n368(x) + end +end + +def fun_l1_n27(x) + if (x < 1) + fun_l2_n984(x) + else + fun_l2_n290(x) + end +end + +def fun_l1_n28(x) + if (x < 1) + fun_l2_n36(x) + else + fun_l2_n837(x) + end +end + +def fun_l1_n29(x) + if (x < 1) + fun_l2_n752(x) + else + fun_l2_n311(x) + end +end + +def fun_l1_n30(x) + if (x < 1) + fun_l2_n215(x) + else + fun_l2_n376(x) + end +end + +def fun_l1_n31(x) + if (x < 1) + fun_l2_n533(x) + else + fun_l2_n92(x) + end +end + +def fun_l1_n32(x) + if (x < 1) + fun_l2_n386(x) + else + fun_l2_n283(x) + end +end + +def fun_l1_n33(x) + if (x < 1) + fun_l2_n268(x) + else + fun_l2_n256(x) + end +end + +def fun_l1_n34(x) + if (x < 1) + fun_l2_n348(x) + else + fun_l2_n464(x) + end +end + +def fun_l1_n35(x) + if (x < 1) + fun_l2_n25(x) + else + fun_l2_n33(x) + end +end + +def fun_l1_n36(x) + if (x < 1) + fun_l2_n387(x) + else + fun_l2_n341(x) + end +end + +def fun_l1_n37(x) + if (x < 1) + fun_l2_n580(x) + else + fun_l2_n476(x) + end +end + +def fun_l1_n38(x) + if (x < 1) + fun_l2_n33(x) + else + fun_l2_n33(x) + end +end + +def fun_l1_n39(x) + if (x < 1) + fun_l2_n861(x) + else + fun_l2_n52(x) + end +end + +def fun_l1_n40(x) + if (x < 1) + fun_l2_n740(x) + else + fun_l2_n943(x) + end +end + +def fun_l1_n41(x) + if (x < 1) + fun_l2_n956(x) + else + fun_l2_n159(x) + end +end + +def fun_l1_n42(x) + if (x < 1) + fun_l2_n445(x) + else + fun_l2_n775(x) + end +end + +def fun_l1_n43(x) + if (x < 1) + fun_l2_n667(x) + else + fun_l2_n282(x) + end +end + +def fun_l1_n44(x) + if (x < 1) + fun_l2_n185(x) + else + fun_l2_n210(x) + end +end + +def fun_l1_n45(x) + if (x < 1) + fun_l2_n490(x) + else + fun_l2_n21(x) + end +end + +def fun_l1_n46(x) + if (x < 1) + fun_l2_n751(x) + else + fun_l2_n639(x) + end +end + +def fun_l1_n47(x) + if (x < 1) + fun_l2_n431(x) + else + fun_l2_n917(x) + end +end + +def fun_l1_n48(x) + if (x < 1) + fun_l2_n187(x) + else + fun_l2_n170(x) + end +end + +def fun_l1_n49(x) + if (x < 1) + fun_l2_n780(x) + else + fun_l2_n77(x) + end +end + +def fun_l1_n50(x) + if (x < 1) + fun_l2_n546(x) + else + fun_l2_n759(x) + end +end + +def fun_l1_n51(x) + if (x < 1) + fun_l2_n453(x) + else + fun_l2_n951(x) + end +end + +def fun_l1_n52(x) + if (x < 1) + fun_l2_n989(x) + else + fun_l2_n716(x) + end +end + +def fun_l1_n53(x) + if (x < 1) + fun_l2_n652(x) + else + fun_l2_n36(x) + end +end + +def fun_l1_n54(x) + if (x < 1) + fun_l2_n187(x) + else + fun_l2_n760(x) + end +end + +def fun_l1_n55(x) + if (x < 1) + fun_l2_n706(x) + else + fun_l2_n927(x) + end +end + +def fun_l1_n56(x) + if (x < 1) + fun_l2_n666(x) + else + fun_l2_n295(x) + end +end + +def fun_l1_n57(x) + if (x < 1) + fun_l2_n424(x) + else + fun_l2_n447(x) + end +end + +def fun_l1_n58(x) + if (x < 1) + fun_l2_n408(x) + else + fun_l2_n337(x) + end +end + +def fun_l1_n59(x) + if (x < 1) + fun_l2_n567(x) + else + fun_l2_n765(x) + end +end + +def fun_l1_n60(x) + if (x < 1) + fun_l2_n241(x) + else + fun_l2_n701(x) + end +end + +def fun_l1_n61(x) + if (x < 1) + fun_l2_n831(x) + else + fun_l2_n382(x) + end +end + +def fun_l1_n62(x) + if (x < 1) + fun_l2_n634(x) + else + fun_l2_n908(x) + end +end + +def fun_l1_n63(x) + if (x < 1) + fun_l2_n696(x) + else + fun_l2_n48(x) + end +end + +def fun_l1_n64(x) + if (x < 1) + fun_l2_n528(x) + else + fun_l2_n110(x) + end +end + +def fun_l1_n65(x) + if (x < 1) + fun_l2_n767(x) + else + fun_l2_n973(x) + end +end + +def fun_l1_n66(x) + if (x < 1) + fun_l2_n963(x) + else + fun_l2_n673(x) + end +end + +def fun_l1_n67(x) + if (x < 1) + fun_l2_n927(x) + else + fun_l2_n309(x) + end +end + +def fun_l1_n68(x) + if (x < 1) + fun_l2_n851(x) + else + fun_l2_n160(x) + end +end + +def fun_l1_n69(x) + if (x < 1) + fun_l2_n575(x) + else + fun_l2_n800(x) + end +end + +def fun_l1_n70(x) + if (x < 1) + fun_l2_n396(x) + else + fun_l2_n382(x) + end +end + +def fun_l1_n71(x) + if (x < 1) + fun_l2_n508(x) + else + fun_l2_n763(x) + end +end + +def fun_l1_n72(x) + if (x < 1) + fun_l2_n360(x) + else + fun_l2_n848(x) + end +end + +def fun_l1_n73(x) + if (x < 1) + fun_l2_n878(x) + else + fun_l2_n83(x) + end +end + +def fun_l1_n74(x) + if (x < 1) + fun_l2_n573(x) + else + fun_l2_n284(x) + end +end + +def fun_l1_n75(x) + if (x < 1) + fun_l2_n999(x) + else + fun_l2_n954(x) + end +end + +def fun_l1_n76(x) + if (x < 1) + fun_l2_n182(x) + else + fun_l2_n997(x) + end +end + +def fun_l1_n77(x) + if (x < 1) + fun_l2_n802(x) + else + fun_l2_n409(x) + end +end + +def fun_l1_n78(x) + if (x < 1) + fun_l2_n163(x) + else + fun_l2_n417(x) + end +end + +def fun_l1_n79(x) + if (x < 1) + fun_l2_n328(x) + else + fun_l2_n688(x) + end +end + +def fun_l1_n80(x) + if (x < 1) + fun_l2_n699(x) + else + fun_l2_n356(x) + end +end + +def fun_l1_n81(x) + if (x < 1) + fun_l2_n44(x) + else + fun_l2_n302(x) + end +end + +def fun_l1_n82(x) + if (x < 1) + fun_l2_n597(x) + else + fun_l2_n892(x) + end +end + +def fun_l1_n83(x) + if (x < 1) + fun_l2_n494(x) + else + fun_l2_n547(x) + end +end + +def fun_l1_n84(x) + if (x < 1) + fun_l2_n631(x) + else + fun_l2_n922(x) + end +end + +def fun_l1_n85(x) + if (x < 1) + fun_l2_n797(x) + else + fun_l2_n874(x) + end +end + +def fun_l1_n86(x) + if (x < 1) + fun_l2_n209(x) + else + fun_l2_n365(x) + end +end + +def fun_l1_n87(x) + if (x < 1) + fun_l2_n516(x) + else + fun_l2_n371(x) + end +end + +def fun_l1_n88(x) + if (x < 1) + fun_l2_n654(x) + else + fun_l2_n88(x) + end +end + +def fun_l1_n89(x) + if (x < 1) + fun_l2_n70(x) + else + fun_l2_n521(x) + end +end + +def fun_l1_n90(x) + if (x < 1) + fun_l2_n666(x) + else + fun_l2_n749(x) + end +end + +def fun_l1_n91(x) + if (x < 1) + fun_l2_n504(x) + else + fun_l2_n339(x) + end +end + +def fun_l1_n92(x) + if (x < 1) + fun_l2_n734(x) + else + fun_l2_n277(x) + end +end + +def fun_l1_n93(x) + if (x < 1) + fun_l2_n300(x) + else + fun_l2_n826(x) + end +end + +def fun_l1_n94(x) + if (x < 1) + fun_l2_n733(x) + else + fun_l2_n560(x) + end +end + +def fun_l1_n95(x) + if (x < 1) + fun_l2_n834(x) + else + fun_l2_n644(x) + end +end + +def fun_l1_n96(x) + if (x < 1) + fun_l2_n183(x) + else + fun_l2_n238(x) + end +end + +def fun_l1_n97(x) + if (x < 1) + fun_l2_n372(x) + else + fun_l2_n753(x) + end +end + +def fun_l1_n98(x) + if (x < 1) + fun_l2_n208(x) + else + fun_l2_n543(x) + end +end + +def fun_l1_n99(x) + if (x < 1) + fun_l2_n38(x) + else + fun_l2_n974(x) + end +end + +def fun_l1_n100(x) + if (x < 1) + fun_l2_n620(x) + else + fun_l2_n503(x) + end +end + +def fun_l1_n101(x) + if (x < 1) + fun_l2_n248(x) + else + fun_l2_n189(x) + end +end + +def fun_l1_n102(x) + if (x < 1) + fun_l2_n489(x) + else + fun_l2_n390(x) + end +end + +def fun_l1_n103(x) + if (x < 1) + fun_l2_n452(x) + else + fun_l2_n22(x) + end +end + +def fun_l1_n104(x) + if (x < 1) + fun_l2_n542(x) + else + fun_l2_n135(x) + end +end + +def fun_l1_n105(x) + if (x < 1) + fun_l2_n988(x) + else + fun_l2_n118(x) + end +end + +def fun_l1_n106(x) + if (x < 1) + fun_l2_n817(x) + else + fun_l2_n534(x) + end +end + +def fun_l1_n107(x) + if (x < 1) + fun_l2_n812(x) + else + fun_l2_n206(x) + end +end + +def fun_l1_n108(x) + if (x < 1) + fun_l2_n514(x) + else + fun_l2_n300(x) + end +end + +def fun_l1_n109(x) + if (x < 1) + fun_l2_n482(x) + else + fun_l2_n376(x) + end +end + +def fun_l1_n110(x) + if (x < 1) + fun_l2_n571(x) + else + fun_l2_n758(x) + end +end + +def fun_l1_n111(x) + if (x < 1) + fun_l2_n971(x) + else + fun_l2_n811(x) + end +end + +def fun_l1_n112(x) + if (x < 1) + fun_l2_n23(x) + else + fun_l2_n844(x) + end +end + +def fun_l1_n113(x) + if (x < 1) + fun_l2_n865(x) + else + fun_l2_n149(x) + end +end + +def fun_l1_n114(x) + if (x < 1) + fun_l2_n930(x) + else + fun_l2_n327(x) + end +end + +def fun_l1_n115(x) + if (x < 1) + fun_l2_n67(x) + else + fun_l2_n442(x) + end +end + +def fun_l1_n116(x) + if (x < 1) + fun_l2_n278(x) + else + fun_l2_n653(x) + end +end + +def fun_l1_n117(x) + if (x < 1) + fun_l2_n457(x) + else + fun_l2_n179(x) + end +end + +def fun_l1_n118(x) + if (x < 1) + fun_l2_n384(x) + else + fun_l2_n594(x) + end +end + +def fun_l1_n119(x) + if (x < 1) + fun_l2_n361(x) + else + fun_l2_n770(x) + end +end + +def fun_l1_n120(x) + if (x < 1) + fun_l2_n24(x) + else + fun_l2_n269(x) + end +end + +def fun_l1_n121(x) + if (x < 1) + fun_l2_n57(x) + else + fun_l2_n2(x) + end +end + +def fun_l1_n122(x) + if (x < 1) + fun_l2_n421(x) + else + fun_l2_n339(x) + end +end + +def fun_l1_n123(x) + if (x < 1) + fun_l2_n623(x) + else + fun_l2_n985(x) + end +end + +def fun_l1_n124(x) + if (x < 1) + fun_l2_n609(x) + else + fun_l2_n530(x) + end +end + +def fun_l1_n125(x) + if (x < 1) + fun_l2_n565(x) + else + fun_l2_n155(x) + end +end + +def fun_l1_n126(x) + if (x < 1) + fun_l2_n135(x) + else + fun_l2_n971(x) + end +end + +def fun_l1_n127(x) + if (x < 1) + fun_l2_n691(x) + else + fun_l2_n503(x) + end +end + +def fun_l1_n128(x) + if (x < 1) + fun_l2_n555(x) + else + fun_l2_n67(x) + end +end + +def fun_l1_n129(x) + if (x < 1) + fun_l2_n95(x) + else + fun_l2_n192(x) + end +end + +def fun_l1_n130(x) + if (x < 1) + fun_l2_n432(x) + else + fun_l2_n771(x) + end +end + +def fun_l1_n131(x) + if (x < 1) + fun_l2_n993(x) + else + fun_l2_n539(x) + end +end + +def fun_l1_n132(x) + if (x < 1) + fun_l2_n809(x) + else + fun_l2_n902(x) + end +end + +def fun_l1_n133(x) + if (x < 1) + fun_l2_n95(x) + else + fun_l2_n928(x) + end +end + +def fun_l1_n134(x) + if (x < 1) + fun_l2_n781(x) + else + fun_l2_n832(x) + end +end + +def fun_l1_n135(x) + if (x < 1) + fun_l2_n231(x) + else + fun_l2_n392(x) + end +end + +def fun_l1_n136(x) + if (x < 1) + fun_l2_n102(x) + else + fun_l2_n449(x) + end +end + +def fun_l1_n137(x) + if (x < 1) + fun_l2_n196(x) + else + fun_l2_n909(x) + end +end + +def fun_l1_n138(x) + if (x < 1) + fun_l2_n449(x) + else + fun_l2_n190(x) + end +end + +def fun_l1_n139(x) + if (x < 1) + fun_l2_n638(x) + else + fun_l2_n149(x) + end +end + +def fun_l1_n140(x) + if (x < 1) + fun_l2_n523(x) + else + fun_l2_n297(x) + end +end + +def fun_l1_n141(x) + if (x < 1) + fun_l2_n476(x) + else + fun_l2_n161(x) + end +end + +def fun_l1_n142(x) + if (x < 1) + fun_l2_n893(x) + else + fun_l2_n686(x) + end +end + +def fun_l1_n143(x) + if (x < 1) + fun_l2_n958(x) + else + fun_l2_n899(x) + end +end + +def fun_l1_n144(x) + if (x < 1) + fun_l2_n104(x) + else + fun_l2_n912(x) + end +end + +def fun_l1_n145(x) + if (x < 1) + fun_l2_n332(x) + else + fun_l2_n579(x) + end +end + +def fun_l1_n146(x) + if (x < 1) + fun_l2_n40(x) + else + fun_l2_n468(x) + end +end + +def fun_l1_n147(x) + if (x < 1) + fun_l2_n771(x) + else + fun_l2_n314(x) + end +end + +def fun_l1_n148(x) + if (x < 1) + fun_l2_n340(x) + else + fun_l2_n203(x) + end +end + +def fun_l1_n149(x) + if (x < 1) + fun_l2_n952(x) + else + fun_l2_n265(x) + end +end + +def fun_l1_n150(x) + if (x < 1) + fun_l2_n11(x) + else + fun_l2_n303(x) + end +end + +def fun_l1_n151(x) + if (x < 1) + fun_l2_n394(x) + else + fun_l2_n317(x) + end +end + +def fun_l1_n152(x) + if (x < 1) + fun_l2_n140(x) + else + fun_l2_n906(x) + end +end + +def fun_l1_n153(x) + if (x < 1) + fun_l2_n75(x) + else + fun_l2_n485(x) + end +end + +def fun_l1_n154(x) + if (x < 1) + fun_l2_n842(x) + else + fun_l2_n370(x) + end +end + +def fun_l1_n155(x) + if (x < 1) + fun_l2_n346(x) + else + fun_l2_n833(x) + end +end + +def fun_l1_n156(x) + if (x < 1) + fun_l2_n433(x) + else + fun_l2_n373(x) + end +end + +def fun_l1_n157(x) + if (x < 1) + fun_l2_n978(x) + else + fun_l2_n99(x) + end +end + +def fun_l1_n158(x) + if (x < 1) + fun_l2_n540(x) + else + fun_l2_n987(x) + end +end + +def fun_l1_n159(x) + if (x < 1) + fun_l2_n785(x) + else + fun_l2_n478(x) + end +end + +def fun_l1_n160(x) + if (x < 1) + fun_l2_n282(x) + else + fun_l2_n222(x) + end +end + +def fun_l1_n161(x) + if (x < 1) + fun_l2_n29(x) + else + fun_l2_n946(x) + end +end + +def fun_l1_n162(x) + if (x < 1) + fun_l2_n314(x) + else + fun_l2_n758(x) + end +end + +def fun_l1_n163(x) + if (x < 1) + fun_l2_n861(x) + else + fun_l2_n799(x) + end +end + +def fun_l1_n164(x) + if (x < 1) + fun_l2_n403(x) + else + fun_l2_n413(x) + end +end + +def fun_l1_n165(x) + if (x < 1) + fun_l2_n160(x) + else + fun_l2_n794(x) + end +end + +def fun_l1_n166(x) + if (x < 1) + fun_l2_n114(x) + else + fun_l2_n238(x) + end +end + +def fun_l1_n167(x) + if (x < 1) + fun_l2_n806(x) + else + fun_l2_n233(x) + end +end + +def fun_l1_n168(x) + if (x < 1) + fun_l2_n871(x) + else + fun_l2_n53(x) + end +end + +def fun_l1_n169(x) + if (x < 1) + fun_l2_n644(x) + else + fun_l2_n503(x) + end +end + +def fun_l1_n170(x) + if (x < 1) + fun_l2_n172(x) + else + fun_l2_n289(x) + end +end + +def fun_l1_n171(x) + if (x < 1) + fun_l2_n920(x) + else + fun_l2_n851(x) + end +end + +def fun_l1_n172(x) + if (x < 1) + fun_l2_n552(x) + else + fun_l2_n822(x) + end +end + +def fun_l1_n173(x) + if (x < 1) + fun_l2_n747(x) + else + fun_l2_n265(x) + end +end + +def fun_l1_n174(x) + if (x < 1) + fun_l2_n287(x) + else + fun_l2_n762(x) + end +end + +def fun_l1_n175(x) + if (x < 1) + fun_l2_n627(x) + else + fun_l2_n951(x) + end +end + +def fun_l1_n176(x) + if (x < 1) + fun_l2_n459(x) + else + fun_l2_n962(x) + end +end + +def fun_l1_n177(x) + if (x < 1) + fun_l2_n214(x) + else + fun_l2_n145(x) + end +end + +def fun_l1_n178(x) + if (x < 1) + fun_l2_n620(x) + else + fun_l2_n995(x) + end +end + +def fun_l1_n179(x) + if (x < 1) + fun_l2_n136(x) + else + fun_l2_n283(x) + end +end + +def fun_l1_n180(x) + if (x < 1) + fun_l2_n377(x) + else + fun_l2_n672(x) + end +end + +def fun_l1_n181(x) + if (x < 1) + fun_l2_n218(x) + else + fun_l2_n434(x) + end +end + +def fun_l1_n182(x) + if (x < 1) + fun_l2_n522(x) + else + fun_l2_n525(x) + end +end + +def fun_l1_n183(x) + if (x < 1) + fun_l2_n648(x) + else + fun_l2_n725(x) + end +end + +def fun_l1_n184(x) + if (x < 1) + fun_l2_n579(x) + else + fun_l2_n974(x) + end +end + +def fun_l1_n185(x) + if (x < 1) + fun_l2_n10(x) + else + fun_l2_n514(x) + end +end + +def fun_l1_n186(x) + if (x < 1) + fun_l2_n829(x) + else + fun_l2_n754(x) + end +end + +def fun_l1_n187(x) + if (x < 1) + fun_l2_n380(x) + else + fun_l2_n401(x) + end +end + +def fun_l1_n188(x) + if (x < 1) + fun_l2_n839(x) + else + fun_l2_n453(x) + end +end + +def fun_l1_n189(x) + if (x < 1) + fun_l2_n553(x) + else + fun_l2_n553(x) + end +end + +def fun_l1_n190(x) + if (x < 1) + fun_l2_n972(x) + else + fun_l2_n187(x) + end +end + +def fun_l1_n191(x) + if (x < 1) + fun_l2_n275(x) + else + fun_l2_n11(x) + end +end + +def fun_l1_n192(x) + if (x < 1) + fun_l2_n1(x) + else + fun_l2_n927(x) + end +end + +def fun_l1_n193(x) + if (x < 1) + fun_l2_n569(x) + else + fun_l2_n557(x) + end +end + +def fun_l1_n194(x) + if (x < 1) + fun_l2_n380(x) + else + fun_l2_n187(x) + end +end + +def fun_l1_n195(x) + if (x < 1) + fun_l2_n297(x) + else + fun_l2_n813(x) + end +end + +def fun_l1_n196(x) + if (x < 1) + fun_l2_n565(x) + else + fun_l2_n514(x) + end +end + +def fun_l1_n197(x) + if (x < 1) + fun_l2_n473(x) + else + fun_l2_n64(x) + end +end + +def fun_l1_n198(x) + if (x < 1) + fun_l2_n182(x) + else + fun_l2_n363(x) + end +end + +def fun_l1_n199(x) + if (x < 1) + fun_l2_n660(x) + else + fun_l2_n506(x) + end +end + +def fun_l1_n200(x) + if (x < 1) + fun_l2_n834(x) + else + fun_l2_n348(x) + end +end + +def fun_l1_n201(x) + if (x < 1) + fun_l2_n403(x) + else + fun_l2_n432(x) + end +end + +def fun_l1_n202(x) + if (x < 1) + fun_l2_n115(x) + else + fun_l2_n145(x) + end +end + +def fun_l1_n203(x) + if (x < 1) + fun_l2_n637(x) + else + fun_l2_n4(x) + end +end + +def fun_l1_n204(x) + if (x < 1) + fun_l2_n951(x) + else + fun_l2_n753(x) + end +end + +def fun_l1_n205(x) + if (x < 1) + fun_l2_n703(x) + else + fun_l2_n563(x) + end +end + +def fun_l1_n206(x) + if (x < 1) + fun_l2_n614(x) + else + fun_l2_n563(x) + end +end + +def fun_l1_n207(x) + if (x < 1) + fun_l2_n210(x) + else + fun_l2_n139(x) + end +end + +def fun_l1_n208(x) + if (x < 1) + fun_l2_n471(x) + else + fun_l2_n346(x) + end +end + +def fun_l1_n209(x) + if (x < 1) + fun_l2_n922(x) + else + fun_l2_n54(x) + end +end + +def fun_l1_n210(x) + if (x < 1) + fun_l2_n494(x) + else + fun_l2_n41(x) + end +end + +def fun_l1_n211(x) + if (x < 1) + fun_l2_n87(x) + else + fun_l2_n190(x) + end +end + +def fun_l1_n212(x) + if (x < 1) + fun_l2_n458(x) + else + fun_l2_n885(x) + end +end + +def fun_l1_n213(x) + if (x < 1) + fun_l2_n48(x) + else + fun_l2_n225(x) + end +end + +def fun_l1_n214(x) + if (x < 1) + fun_l2_n706(x) + else + fun_l2_n694(x) + end +end + +def fun_l1_n215(x) + if (x < 1) + fun_l2_n116(x) + else + fun_l2_n233(x) + end +end + +def fun_l1_n216(x) + if (x < 1) + fun_l2_n279(x) + else + fun_l2_n857(x) + end +end + +def fun_l1_n217(x) + if (x < 1) + fun_l2_n643(x) + else + fun_l2_n289(x) + end +end + +def fun_l1_n218(x) + if (x < 1) + fun_l2_n535(x) + else + fun_l2_n833(x) + end +end + +def fun_l1_n219(x) + if (x < 1) + fun_l2_n478(x) + else + fun_l2_n793(x) + end +end + +def fun_l1_n220(x) + if (x < 1) + fun_l2_n57(x) + else + fun_l2_n64(x) + end +end + +def fun_l1_n221(x) + if (x < 1) + fun_l2_n36(x) + else + fun_l2_n74(x) + end +end + +def fun_l1_n222(x) + if (x < 1) + fun_l2_n438(x) + else + fun_l2_n616(x) + end +end + +def fun_l1_n223(x) + if (x < 1) + fun_l2_n900(x) + else + fun_l2_n744(x) + end +end + +def fun_l1_n224(x) + if (x < 1) + fun_l2_n780(x) + else + fun_l2_n213(x) + end +end + +def fun_l1_n225(x) + if (x < 1) + fun_l2_n916(x) + else + fun_l2_n471(x) + end +end + +def fun_l1_n226(x) + if (x < 1) + fun_l2_n236(x) + else + fun_l2_n980(x) + end +end + +def fun_l1_n227(x) + if (x < 1) + fun_l2_n28(x) + else + fun_l2_n291(x) + end +end + +def fun_l1_n228(x) + if (x < 1) + fun_l2_n35(x) + else + fun_l2_n353(x) + end +end + +def fun_l1_n229(x) + if (x < 1) + fun_l2_n404(x) + else + fun_l2_n254(x) + end +end + +def fun_l1_n230(x) + if (x < 1) + fun_l2_n641(x) + else + fun_l2_n464(x) + end +end + +def fun_l1_n231(x) + if (x < 1) + fun_l2_n592(x) + else + fun_l2_n646(x) + end +end + +def fun_l1_n232(x) + if (x < 1) + fun_l2_n162(x) + else + fun_l2_n215(x) + end +end + +def fun_l1_n233(x) + if (x < 1) + fun_l2_n219(x) + else + fun_l2_n772(x) + end +end + +def fun_l1_n234(x) + if (x < 1) + fun_l2_n304(x) + else + fun_l2_n963(x) + end +end + +def fun_l1_n235(x) + if (x < 1) + fun_l2_n610(x) + else + fun_l2_n716(x) + end +end + +def fun_l1_n236(x) + if (x < 1) + fun_l2_n151(x) + else + fun_l2_n498(x) + end +end + +def fun_l1_n237(x) + if (x < 1) + fun_l2_n288(x) + else + fun_l2_n261(x) + end +end + +def fun_l1_n238(x) + if (x < 1) + fun_l2_n139(x) + else + fun_l2_n18(x) + end +end + +def fun_l1_n239(x) + if (x < 1) + fun_l2_n559(x) + else + fun_l2_n148(x) + end +end + +def fun_l1_n240(x) + if (x < 1) + fun_l2_n520(x) + else + fun_l2_n250(x) + end +end + +def fun_l1_n241(x) + if (x < 1) + fun_l2_n42(x) + else + fun_l2_n196(x) + end +end + +def fun_l1_n242(x) + if (x < 1) + fun_l2_n16(x) + else + fun_l2_n540(x) + end +end + +def fun_l1_n243(x) + if (x < 1) + fun_l2_n539(x) + else + fun_l2_n890(x) + end +end + +def fun_l1_n244(x) + if (x < 1) + fun_l2_n559(x) + else + fun_l2_n423(x) + end +end + +def fun_l1_n245(x) + if (x < 1) + fun_l2_n110(x) + else + fun_l2_n711(x) + end +end + +def fun_l1_n246(x) + if (x < 1) + fun_l2_n151(x) + else + fun_l2_n407(x) + end +end + +def fun_l1_n247(x) + if (x < 1) + fun_l2_n118(x) + else + fun_l2_n209(x) + end +end + +def fun_l1_n248(x) + if (x < 1) + fun_l2_n764(x) + else + fun_l2_n932(x) + end +end + +def fun_l1_n249(x) + if (x < 1) + fun_l2_n991(x) + else + fun_l2_n828(x) + end +end + +def fun_l1_n250(x) + if (x < 1) + fun_l2_n354(x) + else + fun_l2_n53(x) + end +end + +def fun_l1_n251(x) + if (x < 1) + fun_l2_n63(x) + else + fun_l2_n292(x) + end +end + +def fun_l1_n252(x) + if (x < 1) + fun_l2_n874(x) + else + fun_l2_n544(x) + end +end + +def fun_l1_n253(x) + if (x < 1) + fun_l2_n336(x) + else + fun_l2_n57(x) + end +end + +def fun_l1_n254(x) + if (x < 1) + fun_l2_n302(x) + else + fun_l2_n90(x) + end +end + +def fun_l1_n255(x) + if (x < 1) + fun_l2_n122(x) + else + fun_l2_n888(x) + end +end + +def fun_l1_n256(x) + if (x < 1) + fun_l2_n326(x) + else + fun_l2_n616(x) + end +end + +def fun_l1_n257(x) + if (x < 1) + fun_l2_n77(x) + else + fun_l2_n622(x) + end +end + +def fun_l1_n258(x) + if (x < 1) + fun_l2_n785(x) + else + fun_l2_n229(x) + end +end + +def fun_l1_n259(x) + if (x < 1) + fun_l2_n504(x) + else + fun_l2_n766(x) + end +end + +def fun_l1_n260(x) + if (x < 1) + fun_l2_n857(x) + else + fun_l2_n823(x) + end +end + +def fun_l1_n261(x) + if (x < 1) + fun_l2_n72(x) + else + fun_l2_n875(x) + end +end + +def fun_l1_n262(x) + if (x < 1) + fun_l2_n215(x) + else + fun_l2_n549(x) + end +end + +def fun_l1_n263(x) + if (x < 1) + fun_l2_n232(x) + else + fun_l2_n96(x) + end +end + +def fun_l1_n264(x) + if (x < 1) + fun_l2_n183(x) + else + fun_l2_n351(x) + end +end + +def fun_l1_n265(x) + if (x < 1) + fun_l2_n906(x) + else + fun_l2_n154(x) + end +end + +def fun_l1_n266(x) + if (x < 1) + fun_l2_n234(x) + else + fun_l2_n547(x) + end +end + +def fun_l1_n267(x) + if (x < 1) + fun_l2_n882(x) + else + fun_l2_n802(x) + end +end + +def fun_l1_n268(x) + if (x < 1) + fun_l2_n844(x) + else + fun_l2_n430(x) + end +end + +def fun_l1_n269(x) + if (x < 1) + fun_l2_n781(x) + else + fun_l2_n738(x) + end +end + +def fun_l1_n270(x) + if (x < 1) + fun_l2_n88(x) + else + fun_l2_n439(x) + end +end + +def fun_l1_n271(x) + if (x < 1) + fun_l2_n334(x) + else + fun_l2_n508(x) + end +end + +def fun_l1_n272(x) + if (x < 1) + fun_l2_n871(x) + else + fun_l2_n562(x) + end +end + +def fun_l1_n273(x) + if (x < 1) + fun_l2_n328(x) + else + fun_l2_n356(x) + end +end + +def fun_l1_n274(x) + if (x < 1) + fun_l2_n654(x) + else + fun_l2_n511(x) + end +end + +def fun_l1_n275(x) + if (x < 1) + fun_l2_n309(x) + else + fun_l2_n840(x) + end +end + +def fun_l1_n276(x) + if (x < 1) + fun_l2_n729(x) + else + fun_l2_n72(x) + end +end + +def fun_l1_n277(x) + if (x < 1) + fun_l2_n993(x) + else + fun_l2_n858(x) + end +end + +def fun_l1_n278(x) + if (x < 1) + fun_l2_n664(x) + else + fun_l2_n50(x) + end +end + +def fun_l1_n279(x) + if (x < 1) + fun_l2_n225(x) + else + fun_l2_n403(x) + end +end + +def fun_l1_n280(x) + if (x < 1) + fun_l2_n780(x) + else + fun_l2_n396(x) + end +end + +def fun_l1_n281(x) + if (x < 1) + fun_l2_n114(x) + else + fun_l2_n114(x) + end +end + +def fun_l1_n282(x) + if (x < 1) + fun_l2_n568(x) + else + fun_l2_n610(x) + end +end + +def fun_l1_n283(x) + if (x < 1) + fun_l2_n539(x) + else + fun_l2_n990(x) + end +end + +def fun_l1_n284(x) + if (x < 1) + fun_l2_n773(x) + else + fun_l2_n622(x) + end +end + +def fun_l1_n285(x) + if (x < 1) + fun_l2_n695(x) + else + fun_l2_n101(x) + end +end + +def fun_l1_n286(x) + if (x < 1) + fun_l2_n239(x) + else + fun_l2_n242(x) + end +end + +def fun_l1_n287(x) + if (x < 1) + fun_l2_n191(x) + else + fun_l2_n839(x) + end +end + +def fun_l1_n288(x) + if (x < 1) + fun_l2_n246(x) + else + fun_l2_n179(x) + end +end + +def fun_l1_n289(x) + if (x < 1) + fun_l2_n300(x) + else + fun_l2_n975(x) + end +end + +def fun_l1_n290(x) + if (x < 1) + fun_l2_n436(x) + else + fun_l2_n14(x) + end +end + +def fun_l1_n291(x) + if (x < 1) + fun_l2_n33(x) + else + fun_l2_n303(x) + end +end + +def fun_l1_n292(x) + if (x < 1) + fun_l2_n462(x) + else + fun_l2_n399(x) + end +end + +def fun_l1_n293(x) + if (x < 1) + fun_l2_n782(x) + else + fun_l2_n521(x) + end +end + +def fun_l1_n294(x) + if (x < 1) + fun_l2_n995(x) + else + fun_l2_n944(x) + end +end + +def fun_l1_n295(x) + if (x < 1) + fun_l2_n700(x) + else + fun_l2_n250(x) + end +end + +def fun_l1_n296(x) + if (x < 1) + fun_l2_n866(x) + else + fun_l2_n566(x) + end +end + +def fun_l1_n297(x) + if (x < 1) + fun_l2_n373(x) + else + fun_l2_n881(x) + end +end + +def fun_l1_n298(x) + if (x < 1) + fun_l2_n382(x) + else + fun_l2_n729(x) + end +end + +def fun_l1_n299(x) + if (x < 1) + fun_l2_n878(x) + else + fun_l2_n192(x) + end +end + +def fun_l1_n300(x) + if (x < 1) + fun_l2_n65(x) + else + fun_l2_n434(x) + end +end + +def fun_l1_n301(x) + if (x < 1) + fun_l2_n513(x) + else + fun_l2_n617(x) + end +end + +def fun_l1_n302(x) + if (x < 1) + fun_l2_n972(x) + else + fun_l2_n482(x) + end +end + +def fun_l1_n303(x) + if (x < 1) + fun_l2_n533(x) + else + fun_l2_n774(x) + end +end + +def fun_l1_n304(x) + if (x < 1) + fun_l2_n439(x) + else + fun_l2_n351(x) + end +end + +def fun_l1_n305(x) + if (x < 1) + fun_l2_n181(x) + else + fun_l2_n74(x) + end +end + +def fun_l1_n306(x) + if (x < 1) + fun_l2_n117(x) + else + fun_l2_n962(x) + end +end + +def fun_l1_n307(x) + if (x < 1) + fun_l2_n499(x) + else + fun_l2_n183(x) + end +end + +def fun_l1_n308(x) + if (x < 1) + fun_l2_n358(x) + else + fun_l2_n226(x) + end +end + +def fun_l1_n309(x) + if (x < 1) + fun_l2_n227(x) + else + fun_l2_n425(x) + end +end + +def fun_l1_n310(x) + if (x < 1) + fun_l2_n724(x) + else + fun_l2_n278(x) + end +end + +def fun_l1_n311(x) + if (x < 1) + fun_l2_n784(x) + else + fun_l2_n888(x) + end +end + +def fun_l1_n312(x) + if (x < 1) + fun_l2_n952(x) + else + fun_l2_n849(x) + end +end + +def fun_l1_n313(x) + if (x < 1) + fun_l2_n921(x) + else + fun_l2_n31(x) + end +end + +def fun_l1_n314(x) + if (x < 1) + fun_l2_n469(x) + else + fun_l2_n856(x) + end +end + +def fun_l1_n315(x) + if (x < 1) + fun_l2_n89(x) + else + fun_l2_n949(x) + end +end + +def fun_l1_n316(x) + if (x < 1) + fun_l2_n216(x) + els |