pax_global_header00006660000000000000000000000064141721345500014514gustar00rootroot0000000000000052 comment=42ad7e94ea0ddb9a1b420698bedebba9f5a99ac5 Imath-3.1.4/000077500000000000000000000000001417213455000125635ustar00rootroot00000000000000Imath-3.1.4/.clang-format000066400000000000000000000066731417213455000151520ustar00rootroot00000000000000--- Language: Cpp BasedOnStyle: LLVM AccessModifierOffset: -2 AlignAfterOpenBracket: Align AlignConsecutiveAssignments: true AlignConsecutiveDeclarations: false AlignEscapedNewlines: Right AlignOperands: true AlignTrailingComments: true AllowAllArgumentsOnNextLine: false AllowAllConstructorInitializersOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: false AllowShortBlocksOnASingleLine: false AllowShortCaseLabelsOnASingleLine: false AllowShortFunctionsOnASingleLine: InlineOnly AllowShortIfStatementsOnASingleLine: false AllowShortLoopsOnASingleLine: false AlwaysBreakAfterDefinitionReturnType: TopLevel AlwaysBreakAfterReturnType: None AlwaysBreakBeforeMultilineStrings: false AlwaysBreakTemplateDeclarations: MultiLine BinPackArguments: false BinPackParameters: false BraceWrapping: AfterCaseLabel: true AfterClass: true AfterControlStatement: true AfterEnum: true AfterFunction: true AfterNamespace: true AfterObjCDeclaration: true AfterStruct: true AfterUnion: true AfterExternBlock: false BeforeCatch: true BeforeElse: true IndentBraces: false SplitEmptyFunction: false SplitEmptyRecord: false SplitEmptyNamespace: false BreakBeforeBinaryOperators: None BreakBeforeBraces: Custom BreakBeforeInheritanceComma: false BreakInheritanceList: BeforeColon BreakBeforeTernaryOperators: true BreakConstructorInitializers: BeforeColon BreakAfterJavaFieldAnnotations: false BreakStringLiterals: false ColumnLimit: 100 CommentPragmas: '^ IWYU pragma:' CompactNamespaces: false ConstructorInitializerAllOnOneLineOrOnePerLine: true ConstructorInitializerIndentWidth: 4 ContinuationIndentWidth: 4 Cpp11BracedListStyle: false DerivePointerAlignment: false DisableFormat: false FixNamespaceComments: true ForEachMacros: - foreach - Q_FOREACH - BOOST_FOREACH IncludeBlocks: Preserve IncludeCategories: - Regex: '^"(llvm|llvm-c|clang|clang-c)/' Priority: 2 - Regex: '^(<|"(gtest|gmock|isl|json)/)' Priority: 3 - Regex: '.*' Priority: 1 IncludeIsMainRegex: '(Test|_test)?$' IndentCaseLabels: false IndentPPDirectives: AfterHash IndentWidth: 4 IndentWrappedFunctionNames: false JavaScriptQuotes: Leave JavaScriptWrapImports: true KeepEmptyLinesAtTheStartOfBlocks: true MacroBlockBegin: '' MacroBlockEnd: '' MaxEmptyLinesToKeep: 1 NamespaceIndentation: None ObjCBinPackProtocolList: Auto ObjCBlockIndentWidth: 4 ObjCSpaceAfterProperty: true ObjCSpaceBeforeProtocolList: true PenaltyBreakAssignment: 8 PenaltyBreakBeforeFirstCallParameter: 8 PenaltyBreakComment: 1000 PenaltyBreakFirstLessLess: 120 PenaltyBreakString: 1000 PenaltyBreakTemplateDeclaration: 10 PenaltyExcessCharacter: 1000000 PenaltyReturnTypeOnItsOwnLine: 20 PointerAlignment: Left ReflowComments: false SortIncludes: true SortUsingDeclarations: true SpaceAfterCStyleCast: true SpaceAfterTemplateKeyword: true SpaceBeforeAssignmentOperators: true SpaceBeforeCpp11BracedList: true SpaceBeforeCtorInitializerColon: true SpaceBeforeInheritanceColon: true SpaceBeforeParens: NonEmptyParentheses SpaceBeforeRangeBasedForLoopColon: true SpaceInEmptyBlock: false SpaceInEmptyParentheses: false SpacesBeforeTrailingComments: 1 SpacesInAngles: false SpacesInContainerLiterals: true SpacesInCStyleCastParentheses: false SpacesInParentheses: false SpacesInSquareBrackets: false SpacesInConditionalStatement: false Standard: Cpp11 TabWidth: 4 UseTab: Never ... Imath-3.1.4/.git-blame-ignore-revs000066400000000000000000000002441417213455000166630ustar00rootroot00000000000000# Disable clang-format in half.cpp 344334aef268206ed1d46399ea85ab276f3f13e6 # Tune .clang-format to match existing style c6014892de1acccca0deada8ab3353cd290e9fbc Imath-3.1.4/.github/000077500000000000000000000000001417213455000141235ustar00rootroot00000000000000Imath-3.1.4/.github/workflows/000077500000000000000000000000001417213455000161605ustar00rootroot00000000000000Imath-3.1.4/.github/workflows/analysis_workflow.yml000066400000000000000000000113521417213455000224620ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # # GitHub Actions workflow file # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions name: Analysis on: schedule: # Weekly Sunday build - cron: "0 0 * * 0" workflow_dispatch: jobs: # --------------------------------------------------------------------------- # SonarCloud static analysis # --------------------------------------------------------------------------- linux_sonarcloud: name: 'SonarCloud Linux CentOS 7 VFX CY2021 ' # GH-hosted VM. The build runs in CentOS 7 'container' defined below. runs-on: ubuntu-latest container: # DockerHub: https://hub.docker.com/u/aswf # Source: https://github.com/AcademySoftwareFoundation/aswf-docker image: aswf/ci-openexr:2021 env: CXX: g++ CC: gcc steps: # TODO: Remove this workaround following resolution of: # https://github.com/AcademySoftwareFoundation/aswf-docker/issues/43 - name: Setup container run: sudo rm -rf /usr/local/lib64/cmake/glew - name: Checkout uses: actions/checkout@v2 with: fetch-depth: 50 - name: Create build directories run: | mkdir _install mkdir _build shell: bash - name: Configure run: | cmake .. \ -DCMAKE_INSTALL_PREFIX=../_install \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_CXX_STANDARD=14 \ -DCMAKE_CXX_FLAGS="-g -O0 -fprofile-arcs -ftest-coverage" \ -DCMAKE_CXX_OUTPUT_EXTENSION_REPLACE=ON \ -DCMAKE_EXE_LINKER_FLAGS="-lgcov" \ -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \ -DBUILD_SHARED_LIBS='OFF' \ -DPYTHON='ON' working-directory: _build - name: Build Imath with build-wrapper shell: bash run: | build-wrapper-linux-x86-64 --out-dir bw_output cmake --build . --target install --config Release working-directory: _build - name: Test run: | ctest -T Test \ -C Release \ --timeout 7200 \ --output-on-failure \ -VV working-directory: _build - name: Coverage run: share/ci/scripts/linux/run_gcov.sh shell: bash - name: Sonar-scanner env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} run: sonar-scanner -X -Dsonar.login=$SONAR_TOKEN # ------------------------------------------------------------------------------ # Valgrind memcheck test # ------------------------------------------------------------------------------ linux_valgrind: name: 'Valgrind Linux CentOS 7 VFX CY2021 ' # GH-hosted VM. The build runs in CentOS 7 'container' defined below. runs-on: ubuntu-latest container: # DockerHub: https://hub.docker.com/u/aswf # Source: https://github.com/AcademySoftwareFoundation/aswf-docker image: aswf/ci-openexr:2021 env: CXX: g++ CC: gcc steps: # TODO: Remove this workaround following resolution of: # https://github.com/AcademySoftwareFoundation/aswf-docker/issues/43 - name: Setup container run: sudo rm -rf /usr/local/lib64/cmake/glew - name: Checkout uses: actions/checkout@v2 with: fetch-depth: 50 - name: Create build directories run: | mkdir _install mkdir _build shell: bash - name: Install Dependencies run: | share/ci/scripts/linux/install_valgrind.sh shell: bash - name: Configure run: | cmake .. \ -DCMAKE_INSTALL_PREFIX=../_install \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_CXX_STANDARD=14 \ -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \ -DBUILD_SHARED_LIBS='OFF' \ -DOPENEXR_BUILD_UTILS='ON' \ -DOPENEXR_RUN_FUZZ_TESTS='OFF' \ -DPYTHON='ON' working-directory: _build - name: Build run: | cmake --build . \ --target install \ --config Release working-directory: _build - name: Valgrind memcheck tests run: | ctest -C Release \ --timeout 50000 \ --force-new-ctest-process \ --test-action memcheck \ --output-on-failure \ -VV working-directory: _build - name: Valgrind memcheck test results run: | share/ci/scripts/linux/log_valgrind.sh _build shell: bash Imath-3.1.4/.github/workflows/ci_workflow.yml000066400000000000000000000413531417213455000212360ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # # GitHub Actions workflow file # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions name: CI on: push: # Jobs are skipped when ONLY Markdown (*.md) files are changed paths-ignore: - '**.md' pull_request: paths-ignore: - '**.md' jobs: # Linux jobs run in Docker containers, so the latest OS version is OK. macOS # and Windows jobs need to be locked to specific virtual environment # versions to mitigate issues from OS updates, and will require maintenance # as OS versions are retired. # # GH Actions (Free plan) supports 20 concurrent jobs, with 5 concurrent macOS # jobs. This workflow tries to utilize (but not exceed) that budget to # promote timely CI. # --------------------------------------------------------------------------- # Linux # --------------------------------------------------------------------------- # TODO: Add ARM build. Add sanitize build. linux: name: 'Linux CentOS 7 VFX CY${{ matrix.vfx-cy }} <${{ matrix.compiler-desc }} config=${{ matrix.build-type }}, shared=${{ matrix.build-shared }}, cxx=${{ matrix.cxx-standard }}>' # GH-hosted VM. The build runs in CentOS 7 'container' defined below. runs-on: ubuntu-latest container: # DockerHub: https://hub.docker.com/u/aswf # Source: https://github.com/AcademySoftwareFoundation/aswf-docker image: aswf/ci-openexr:${{ matrix.vfx-cy }} strategy: matrix: build: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18] include: # ------------------------------------------------------------------- # GCC, VFX CY2021 # ------------------------------------------------------------------- # C++11, Python 3.7 - build: 11 build-type: Release build-shared: 'ON' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2021 # Debug - build: 12 build-type: Debug build-shared: 'ON' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2021 # C++14 - build: 13 build-type: Release build-shared: 'ON' cxx-standard: 14 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2021 # Static - build: 14 build-type: Release build-shared: 'OFF' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2021 # ------------------------------------------------------------------- # GCC, VFX CY2020 # ------------------------------------------------------------------- # C++11, Python 3.7 - build: 1 build-type: Release build-shared: 'ON' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2020 # Debug - build: 2 build-type: Debug build-shared: 'ON' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2020 # C++14 - build: 3 build-type: Release build-shared: 'ON' cxx-standard: 14 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2020 # Static - build: 4 build-type: Release build-shared: 'OFF' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2020 # ------------------------------------------------------------------- # GCC, VFX CY2019 # ------------------------------------------------------------------- # Python 2.7 - build: 5 build-type: Release build-shared: 'ON' use-python2: 'ON' cxx-standard: 11 cxx-compiler: g++ cc-compiler: gcc compiler-desc: GCC 6.3.1 vfx-cy: 2019 # ------------------------------------------------------------------- # Clang, VFX CY2021 # ------------------------------------------------------------------- # C++11, Python 3.7 - build: 15 build-type: Release build-shared: 'ON' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2021 # Debug - build: 16 build-type: Debug build-shared: 'ON' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2021 # C++14 - build: 17 build-type: Release build-shared: 'ON' cxx-standard: 14 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2021 # Static - build: 18 build-type: Release build-shared: 'OFF' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2021 # ------------------------------------------------------------------- # Clang, VFX CY2020 # ------------------------------------------------------------------- # C++11, Python 3.7 - build: 6 build-type: Release build-shared: 'ON' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2020 # Debug - build: 7 build-type: Debug build-shared: 'ON' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2020 # C++14 - build: 8 build-type: Release build-shared: 'ON' cxx-standard: 14 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2020 # Static - build: 9 build-type: Release build-shared: 'OFF' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2020 # ------------------------------------------------------------------- # Clang, VFX CY2019 # ------------------------------------------------------------------- # Python 2.7 - build: 10 build-type: Release build-shared: 'ON' use-python2: 'ON' cxx-standard: 11 cxx-compiler: clang++ cc-compiler: clang compiler-desc: Clang 7 vfx-cy: 2019 env: CXX: ${{ matrix.cxx-compiler }} CC: ${{ matrix.cc-compiler }} steps: - name: Checkout uses: actions/checkout@v2 - name: Create build directories run: | mkdir _install mkdir _build mkdir _examples - name: Configure run: | cmake .. \ -DCMAKE_INSTALL_PREFIX=../_install \ -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ -DCMAKE_CXX_STANDARD=${{ matrix.cxx-standard }} \ -DCMAKE_CXX_FLAGS=${{ matrix.cxx-flags }} \ -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \ -DBUILD_SHARED_LIBS=${{ matrix.build-shared }} \ -DPYTHON='ON' \ -DUSE_PYTHON2=${{ matrix.use-python2 }} working-directory: _build - name: Build run: | cmake --build . \ --target install \ --config ${{ matrix.build-type }} working-directory: _build - name: Examples run: | # Make sure we can build the tests when configured as a # standalone application linking against the just-installed # Imath library. cmake ../src/ImathTest \ -DCMAKE_PREFIX_PATH=../../_install \ -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ -DCMAKE_CXX_STANDARD=${{ matrix.cxx-standard }} \ -DCMAKE_CXX_FLAGS=${{ matrix.cxx-flags }} cmake --build . \ --config ${{ matrix.build-type }} # Confirm the tests run #./bin/ImathTest # Confirm the python module loads. Query the site-packages directory and substitute ../_install export PYTHONPATH=`python -c "import site; print('../_install%s' % site.USER_SITE[len(site.USER_BASE):])"` python -c "import imath;print(imath.__version__)" working-directory: _examples - name: Test run: | ctest -T Test ${{ matrix.exclude-tests }} \ -C ${{ matrix.build-type }} \ --timeout 7200 \ --output-on-failure \ -VV working-directory: _build # --------------------------------------------------------------------------- # macOS # --------------------------------------------------------------------------- macos_no_python: name: 'macOS 10.15 ' runs-on: macos-10.15 strategy: matrix: build: [1, 2, 3, 4] include: # C++11 - build: 1 build-type: Release build-shared: 'ON' build-docs: 'ON' cxx-standard: 11 exclude-tests: # Debug - build: 2 build-type: Debug build-shared: 'ON' build-docs: 'OFF' cxx-standard: 11 exclude-tests: # C++14 - build: 3 build-type: Release build-shared: 'ON' build-docs: 'OFF' cxx-standard: 14 exclude-tests: # Static - build: 4 build-type: Debug build-shared: 'OFF' build-docs: 'OFF' cxx-standard: 11 exclude-tests: steps: ## - name: Setup Python ## uses: actions/setup-python@v1 ## with: ## python-version: ${{ matrix.python-version }} - name: Checkout uses: actions/checkout@v2 - name: Create build directories run: | mkdir _install mkdir _build mkdir _examples ## - name: Install Dependences ## run: | ## share/ci/scripts/macos/install_boost.sh ## shell: bash - name: Configure run: | cmake ../. \ -DCMAKE_INSTALL_PREFIX=../_install \ -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ -DCMAKE_CXX_STANDARD=${{ matrix.cxx-standard }} \ -DCMAKE_CXX_FLAGS=${{ matrix.cxx-flags }} \ -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \ -DBUILD_SHARED_LIBS=${{ matrix.build-shared }} working-directory: _build - name: Build run: | cmake --build . \ --target install \ --config ${{ matrix.build-type }} \ -- -j2 working-directory: _build - name: Examples run: | # Make sure we can build the tests when configured as a # standalone application linking against the just-installed # Imath library. cmake ../src/ImathTest \ -DCMAKE_PREFIX_PATH=../../_install \ -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ -DCMAKE_CXX_STANDARD=${{ matrix.cxx-standard }} \ -DCMAKE_CXX_FLAGS=${{ matrix.cxx-flags }} cmake --build . \ --config ${{ matrix.build-type }} # Confirm the tests run ./bin/ImathTest working-directory: _examples - name: Test run: | ctest -T Test ${{matrix.exclude-tests }} \ -C ${{matrix.build-type}} \ --timeout 7200 \ --output-on-failure \ -VV working-directory: _build # --------------------------------------------------------------------------- # Windows # --------------------------------------------------------------------------- # TODO: Figure out how to get CMake to use Python 3.7.7. # Boost 1.70.0 will only make boost python for 3.7. # CMake finds Python 3.8 on the VM when configuring, then does not find # a corresponding boost python38 module. # TODO: Determine why tests hang in Debug job. # TODO: Fix boost script to install from sourceforge. windows: name: 'Windows 2019 ' runs-on: windows-2019 strategy: matrix: build: [1, 3, 4] include: # C++11, Python 3.7 - build: 1 build-type: Release build-shared: 'ON' build-docs: 'ON' cxx-standard: 11 exclude-tests: # Debug - ## - build: 2 ## build-type: Debug ## build-shared: 'ON' ## build-docs: 'OFF' ## cxx-standard: 11 ## exclude-tests: # C++14 - build: 3 build-type: Release build-shared: 'ON' build-docs: 'OFF' cxx-standard: 14 exclude-tests: # C++14, Static - build: 4 build-type: Release build-shared: 'OFF' build-docs: 'OFF' cxx-standard: 14 exclude-tests: # # Static # - build: 4 # build-type: Release # build-shared: 'OFF' # build-docs: 'OFF' # cxx-standard: 11 # python-version: 3.7.7 # boost-version: 1.70.0 # zlib-version: 1.2.11 # zlib-lib: zlibstatic.lib # exclude-tests: '' steps: # - name: Setup Python # uses: actions/setup-python@v1 # with: # python-version: ${{ matrix.python-version }} - name: Checkout uses: actions/checkout@v2 - name: Create build directories run: | mkdir _install mkdir _build shell: bash # - name: Install Dependences # run: | # share/ci/scripts/windows/install_python.ps1 ${{ matrix.python-version }} $HOME # share/ci/scripts/windows/install_boost.ps1 ${{ matrix.boost-version }} $HOME 3.8 # share/ci/scripts/windows/install_zlib.ps1 ${{ matrix.zlib-version }} $HOME # shell: powershell - name: Configure run: | cmake ../. \ -DCMAKE_INSTALL_PREFIX=../_install \ -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ -DCMAKE_CXX_STANDARD=${{ matrix.cxx-standard }} \ -DCMAKE_CXX_FLAGS=${{ matrix.cxx-flags }} \ -DCMAKE_VERBOSE_MAKEFILE:BOOL='OFF' \ -DBUILD_SHARED_LIBS=${{ matrix.build-shared }} # NB: removed trailing slash from these lines # -DBOOST_ROOT:FILEPATH=$BOOST_ROOT # -DZLIB_ROOT:FILEPATH="$ZLIB_ROOT" # -DZLIB_LIBRARY:FILEPATH="$ZLIB_ROOT/lib/${{ matrix.zlib-lib }}" # -DPYTHON='ON' # -DPython_EXECUTABLE:FILEPATH="$PYTHON_ROOT" # -DPython_INCLUDE_DIR:FILEPATH="$PYTHON_ROOT/include" # -DPython_LIBRARY:"$PYTHON_ROOT\libs" shell: bash working-directory: _build - name: Build run: | cmake --build . \ --target install \ --config ${{ matrix.build-type }} shell: bash working-directory: _build - name: Test run: | ctest -T Test ${{ matrix.exclude-tests }} \ -C ${{ matrix.build-type }} \ --timeout 7200 \ --output-on-failure \ -VV shell: bash working-directory: _build Imath-3.1.4/.gitignore000066400000000000000000000000311417213455000145450ustar00rootroot00000000000000build/ _build/ _install/ Imath-3.1.4/CHANGES.md000066400000000000000000000511431417213455000141610ustar00rootroot00000000000000# Imath Release Notes * [Version 3.1.4](#version-314-january-21-2022) January 21, 2022 * [Version 3.1.3](#version-313-september-2-2021) September 2, 2021 * [Version 3.1.2](#version-312-july-31-2021) July 31, 2021 * [Version 3.1.1](#version-311-july-20-2021) July 20, 2021 * [Version 3.1.0](#version-310-july-13-2021) July 13, 2021 * [Version 3.0.5](#version-305-june-29-2021) June 29, 2021 * [Version 3.0.4](#version-304-june-1-2021) June 1, 2021 * [Version 3.0.2](#version-302-may-16-2021) May 16, 2021 * [Version 3.0.1](#version-301-april-1-2021) April 1, 2021 * [Version 3.0.1-beta](#version-301-beta-march-28-2021) March 28, 2021 * [Version 3.0.0-beta](#version-300-beta-march-15-2021) March 15, 2021 * [Inherited History from OpenEXR](#inherited-history-from-openexr) ## Version 3.1.4 (January 21, 2022) Patch release with miscellaneous bug/doc/build fixes. * \[[#229](https://github.com/AcademySoftwareFoundation/Imath/pull/229)\] Remove some simple typos in the code * \[[#228](https://github.com/AcademySoftwareFoundation/Imath/pull/228)\] Added missing check _M_IX86 or _M_X64 when using __lzcnt. * \[[#224](https://github.com/AcademySoftwareFoundation/Imath/pull/224)\] SolveNormalizedCubic fix to return proper real root * \[[#223](https://github.com/AcademySoftwareFoundation/Imath/pull/223)\] Add docs target only if not a subproject * \[[#222](https://github.com/AcademySoftwareFoundation/Imath/pull/222)\] Fix docs race condition and make installation optional * \[[#220](https://github.com/AcademySoftwareFoundation/Imath/pull/220)\] Remove dead PyImath code and references to ilmbase * \[[#219](https://github.com/AcademySoftwareFoundation/Imath/pull/219)\] Use equalWithAbsError instead of equal operator for float * \[[#218](https://github.com/AcademySoftwareFoundation/Imath/pull/218)\] Fix sphinx warnings and man page filenames * \[[#215](https://github.com/AcademySoftwareFoundation/Imath/pull/215)\] Adding missing stdexcept header * \[[#214](https://github.com/AcademySoftwareFoundation/Imath/pull/214)\] Use .x instead of operator[] for better SIMD auto-vectorization * \[[#213](https://github.com/AcademySoftwareFoundation/Imath/pull/213)\] Remove extra project layer for the pyimath code * \[[#209](https://github.com/AcademySoftwareFoundation/Imath/pull/209)\] Successor/predecessor functions use isnan() and isinf() * \[[#207](https://github.com/AcademySoftwareFoundation/Imath/pull/207)\] Fix python imath export * \[[#202](https://github.com/AcademySoftwareFoundation/Imath/pull/202)\] Cuda safety fixes * \[[#185](https://github.com/AcademySoftwareFoundation/Imath/pull/185)\] Sort Imath source files * \[[#182](https://github.com/AcademySoftwareFoundation/Imath/pull/182)\] Fix formatting in release notes ## Version 3.1.3 (September 2, 2021) Patch release with miscellaneous fixes * \[[#204](https://github.com/AcademySoftwareFoundation/Imath/pull/204)\] Fix undefined access of a vector when empty * \[[#203](https://github.com/AcademySoftwareFoundation/Imath/pull/203)\] Require sphinx 4.0.3 * \[[#201](https://github.com/AcademySoftwareFoundation/Imath/pull/201)\] Build sphinx/doxygen docs with CMake * \[[#200](https://github.com/AcademySoftwareFoundation/Imath/pull/200)\] Use PYIMATH_OVERRIDE_PYTHON_INSTALL_DIR to specify destination python modules * \[[#199](https://github.com/AcademySoftwareFoundation/Imath/pull/199)\] Guard `__has_attribute` for compilers that don't support it * \[[#198](https://github.com/AcademySoftwareFoundation/Imath/pull/198)\] Cuda safety fixes * \[[#194](https://github.com/AcademySoftwareFoundation/Imath/pull/194)\] Replace stray Imath:: with IMATH_INTERNAL_NAMESPACE:: ## Version 3.1.2 (July 31, 2021) Patch release that fixes a Windows header issue. * \[[#190](https://github.com/AcademySoftwareFoundation/Imath/pull/190)\] Improve handling of ``#include <*intrin.h>`` ## Version 3.1.1 (July 20, 2021) Patch release that fixes a build failure on ARM64 macOS * \[[#184](https://github.com/AcademySoftwareFoundation/Imath/pull/184)\] Include ```` only if ``__x86_64__`` ## Version 3.1.0 (July 13, 2021) Minor release with new features: * Optimized half-to-float and float-to-half conversion, using F16C SSE instruction set if available. Non-SSE conversion eliminates the float-to-half exponent lookup table, and half-to-float conversion provides a compile-time-optional bit shifting that is slower but eliminates the need for the lookup table, for applications where memory is limited. Half-to-float and float-to-half conversion is also available as C-language functions ``imath_half_to_float()`` and ``imath_float_to_half()``. All new conversions produced identical results, and new options are off by default to ensure backwards compatibility. See https://imath.readthedocs.io for more info. * ``noexcept`` specifier can be eliminated at compile-time via the ``IMATH_USE_NOEXCEPT`` CMake option. * Python bindings: * FixedArray objects support a "read only" state. * FixedArray objects support python buffer protocol. * Optimized 4x4 matrix multiplication. ### Merged Pull Requests * \[[#181](https://github.com/AcademySoftwareFoundation/Imath/pull/181)\] Clean up half lookup-table options and related docs * \[[#179](https://github.com/AcademySoftwareFoundation/Imath/pull/179)\] Remove dead code from half * \[[#178](https://github.com/AcademySoftwareFoundation/Imath/pull/178)\] Update Imath docs for 3.1 * \[[#177](https://github.com/AcademySoftwareFoundation/Imath/pull/177)\] v3.1.0 release notes * \[[#175](https://github.com/AcademySoftwareFoundation/Imath/pull/175)\] Clean up library VERSION and SOVERSION * \[[#173](https://github.com/AcademySoftwareFoundation/Imath/pull/173)\] Update README.md and INSTALL.md for 3.1 * \[[#172](https://github.com/AcademySoftwareFoundation/Imath/pull/172)\] Use CMAKE_INSTALL_FULL_LIBDIR/INCLUDEDIR for pkgconfig * \[[#169](https://github.com/AcademySoftwareFoundation/Imath/pull/169)\] Add testInterop to test list in define_imath_test() * \[[#168](https://github.com/AcademySoftwareFoundation/Imath/pull/168)\] Push/pop Windows warning pragma * \[[#167](https://github.com/AcademySoftwareFoundation/Imath/pull/167)\] Clean up cmake lib symlink message * \[[#166](https://github.com/AcademySoftwareFoundation/Imath/pull/166)\] Fix non-versioned library symlinks in debug build. * \[[#165](https://github.com/AcademySoftwareFoundation/Imath/pull/165)\] Use CMAKE__POSTFIX for .pc file lib suffix. * \[[#162](https://github.com/AcademySoftwareFoundation/Imath/pull/162)\] silence a few warnings noticed with -Weverything * \[[#160](https://github.com/AcademySoftwareFoundation/Imath/pull/160)\] Clean up analysis_workflow.yml * \[[#159](https://github.com/AcademySoftwareFoundation/Imath/pull/159)\] Add new macros to Doxyfile PREDEFINED * \[[#158](https://github.com/AcademySoftwareFoundation/Imath/pull/158)\] Improve 4x4 matrix multiplication * \[[#157](https://github.com/AcademySoftwareFoundation/Imath/pull/157)\] IMATH_NOEXCEPT macro to make noexcept a compile-time option * \[[#156](https://github.com/AcademySoftwareFoundation/Imath/pull/156)\] PyImath read-only FixedArray state & python buffer protocol support * \[[#155](https://github.com/AcademySoftwareFoundation/Imath/pull/155)\] Release notes for v3.0.4 * \[[#153](https://github.com/AcademySoftwareFoundation/Imath/pull/153)\] Configure ImathTest as optional standalone program * \[[#150](https://github.com/AcademySoftwareFoundation/Imath/pull/150)\] Add __version__ attr to imath and imathnumpy python modules * \[[#141](https://github.com/AcademySoftwareFoundation/Imath/pull/141)\] Enable C and lighter weight half <-> float conversion ## Version 3.0.5 (June 29, 2021) Patch release that fixes problems with library symlinks and pkg-config. Otherwise, no code changes. * \[[#172](https://github.com/AcademySoftwareFoundation/Imath/pull/172)\] Use CMAKE_INSTALL_FULL_LIBDIR/INCLUDEDIR for pkgconfig * \[[#166](https://github.com/AcademySoftwareFoundation/Imath/pull/166)\] Fix non-versioned library symlinks in debug build. * \[[#165](https://github.com/AcademySoftwareFoundation/Imath/pull/165)\] Use CMAKE__POSTFIX for .pc file lib suffix. ## Version 3.0.4 (June 1, 2021) Patch release that corrects a problem with the release version number of v3.0.2: * \[[#147](https://github.com/AcademySoftwareFoundation/Imath/pull/147)\] Add #define for IMATH_VERSION_RELEASE_TYPE * \[[#145](https://github.com/AcademySoftwareFoundation/Imath/pull/145)\] Set IMATH_VERSION from Imath_VERSION instead of CMAKE_PROJECT_VERSION ## Version 3.0.2 (May 16, 2021) Patch release with miscellaneous bug/build fixes: * \[[#142](https://github.com/AcademySoftwareFoundation/Imath/pull/142)\] Fix order of ${IMATH_SOVERSION}.${IMATH_SOREVISION}.${IMATH_SOAGE} * \[[#140](https://github.com/AcademySoftwareFoundation/Imath/pull/140)\] Fix regression in succf()/predf() * \[[#139](https://github.com/AcademySoftwareFoundation/Imath/pull/139)\] Clean up setting of Imath version * \[[#137](https://github.com/AcademySoftwareFoundation/Imath/pull/137)\] Don't impose C++14 on downstream projects * \[[#135](https://github.com/AcademySoftwareFoundation/Imath/pull/135)\] Add section on python bindings * \[[#133](https://github.com/AcademySoftwareFoundation/Imath/pull/133)\] Lib version ## Version 3.0.1 (April 1, 2021) First release of Imath independent of OpenEXR. See the [porting guide](docs/PortingGuide2-3.md) for details about differences from previous releases. Summary: * Imath includes the half type, formerly in a separate Half library. * Headers are installed in ``Imath/`` subdirectory. * All appropriate methods are marked constexpr, noexcept * Appropriate declaration include CUDA ``__host__`` and ``__device__`` directives. * Throwing methods throw std exceptions instead of ``Iex``. * New Vec and Matrix interoperability constructors for conversion from other similar type objects. * Symbol linkage visibility is limited to specific public symbols. * python bindings are off by default, available by setting ``PYTHON=ON``. * Deprecated features: - ``std::numeric_limits`` replaces ``Imath::limits``. - ``Int64`` and ``SInt64`` are deprecated in favor of ``uint64_t`` and ``int64_t``. ## Version 3.0.1-beta (March 28, 2021) Beta patch release: * \[[#131](https://github.com/AcademySoftwareFoundation/Imath/pull/131)\] #if IMATH_FOREIGN_VECTOR_INTEROP around type detectors * \[[#130](https://github.com/AcademySoftwareFoundation/Imath/pull/130)\] Forward declarations only if header is not included ## Version 3.0.0-beta (March 15, 2021) First release of Imath independent of OpenEXR. See the [porting guide](docs/PortingGuide2-3.md) for details about differences from previous releases. Summary and Key Changes: * Imath includes the half type, formerly in a separate Half library. * Headers are installed in ``Imath/`` subdirectory. * Header files have been pruned of extraneous ``#include``'s, which may require updates to application source code. * All appropriate methods are marked constexpr, noexcept * Appropriate declaration include CUDA ``__host__`` and ``__device__`` directives. * Throwing methods throw std exceptions instead of ``Iex``. * New Vec and Matrix interoperability constructors for conversion from other similar type objects. * Symbol linkage visibility is limited to specific public symbols. * Python bindings are off by default, available by setting ``PYTHON=ON``. * Deprecated features: - ``std::numeric_limits`` replaces ``Imath::limits``. - ``Int64`` and ``SInt64`` are deprecated in favor of ``uint64_t`` and ``int64_t``. ### Merged Pull Requests * \[[#119](https://github.com/AcademySoftwareFoundation/Imath/pull/119)\] Enable policy 77 if possible. * \[[#117](https://github.com/AcademySoftwareFoundation/Imath/pull/117)\] Add/fix rst source for readthedocs * \[[#116](https://github.com/AcademySoftwareFoundation/Imath/pull/116)\] Add/fix doxygen comments * \[[#115](https://github.com/AcademySoftwareFoundation/Imath/pull/115)\] Add =delete for the int64_t Vec specializations * \[[#114](https://github.com/AcademySoftwareFoundation/Imath/pull/114)\] Disable analysis on PR/push * \[[#113](https://github.com/AcademySoftwareFoundation/Imath/pull/113)\] Clean up cmake/config * \[[#111](https://github.com/AcademySoftwareFoundation/Imath/pull/111)\] Rename IMATH_IMATH_NAMESPACE option to IMATH_NAMESPACE * \[[#110](https://github.com/AcademySoftwareFoundation/Imath/pull/110)\] Remove PyImathConfigInternal * \[[#109](https://github.com/AcademySoftwareFoundation/Imath/pull/109)\] build one python binding only * \[[#107](https://github.com/AcademySoftwareFoundation/Imath/pull/107)\] Add int64_t specializations of Vec and Box. * \[[#106](https://github.com/AcademySoftwareFoundation/Imath/pull/106)\] Replace Int64/SInt64 with uint64_t/int64_t * \[[#103](https://github.com/AcademySoftwareFoundation/Imath/pull/103)\] Drop support for exception-handling in PyImath * \[[#102](https://github.com/AcademySoftwareFoundation/Imath/pull/102)\] cmake improvements and fixes * \[[#100](https://github.com/AcademySoftwareFoundation/Imath/pull/100)\] Replace Iex::OverflowExc with std::invalid_argument * \[[#98](https://github.com/AcademySoftwareFoundation/Imath/pull/98)\] constexpr Vec2, Vec3, Vec4 constructors * \[[#97](https://github.com/AcademySoftwareFoundation/Imath/pull/97)\] restore original behavior of Matrix33::setScale() * \[[#95](https://github.com/AcademySoftwareFoundation/Imath/pull/95)\] Build fixups for Visual Studio 2015 * \[[#94](https://github.com/AcademySoftwareFoundation/Imath/pull/94)\] Add background and file/class-specific details to porting guide * \[[#93](https://github.com/AcademySoftwareFoundation/Imath/pull/93)\] Fix typo in comment in testHalfLimits * \[[#92](https://github.com/AcademySoftwareFoundation/Imath/pull/92)\] Replace ILMBASE_HAVE_LARGE_STACK with IMATH_HAVE_LARGE_STACK * \[[#91](https://github.com/AcademySoftwareFoundation/Imath/pull/91)\] Interoperability constructors * \[[#90](https://github.com/AcademySoftwareFoundation/Imath/pull/90)\] Fix compiler errors from recent changes * \[[#89](https://github.com/AcademySoftwareFoundation/Imath/pull/89)\] First stab at Imath 2->3 porting guide * \[[#88](https://github.com/AcademySoftwareFoundation/Imath/pull/88)\] PyImath installs headers into Imath subdirectory * \[[#87](https://github.com/AcademySoftwareFoundation/Imath/pull/87)\] constexpr as much of half as possible * \[[#83](https://github.com/AcademySoftwareFoundation/Imath/pull/83)\] Replace NOTICE with STATUS for CMake messages * \[[#82](https://github.com/AcademySoftwareFoundation/Imath/pull/82)\] Clean up Imath::Limits and numeric_limits issues * \[[#81](https://github.com/AcademySoftwareFoundation/Imath/pull/81)\] Reformat all Imath header comments to doxygen style * \[[#77](https://github.com/AcademySoftwareFoundation/Imath/pull/77)\] Change copyright notices to standard SPDX format * \[[#76](https://github.com/AcademySoftwareFoundation/Imath/pull/76)\] Incorrect constexpr in Imath::limits, and missing test. * \[[#75](https://github.com/AcademySoftwareFoundation/Imath/pull/75)\] CI: add VFX2021 jobs, enable coverage analysis * \[[#74](https://github.com/AcademySoftwareFoundation/Imath/pull/74)\] noexcept all the things * \[[#73](https://github.com/AcademySoftwareFoundation/Imath/pull/73)\] Simplify definition of IMATH_RESTRICT for modern supported compilers * \[[#72](https://github.com/AcademySoftwareFoundation/Imath/pull/72)\] Eliminate normalize and length methods for Vec * \[[#70](https://github.com/AcademySoftwareFoundation/Imath/pull/70)\] Adding missing header * \[[#69](https://github.com/AcademySoftwareFoundation/Imath/pull/69)\] [#bugfix] Install error on windows #68 * \[[#67](https://github.com/AcademySoftwareFoundation/Imath/pull/67)\] Fix two typos in m22 tests causing out of bounds references * \[[#66](https://github.com/AcademySoftwareFoundation/Imath/pull/66)\] Use likely/unlikely to improve certain vector ops * \[[#65](https://github.com/AcademySoftwareFoundation/Imath/pull/65)\] Deprecate Math in favor of std:: * \[[#60](https://github.com/AcademySoftwareFoundation/Imath/pull/60)\] Make Matrix implementation more SIMD friendly * \[[#59](https://github.com/AcademySoftwareFoundation/Imath/pull/59)\] Imath::Vec -- omit exception-throwing methods from Cuda side * \[[#58](https://github.com/AcademySoftwareFoundation/Imath/pull/58)\] Make separate test calls for each test * \[[#57](https://github.com/AcademySoftwareFoundation/Imath/pull/57)\] Fixes the subproject test * \[[#56](https://github.com/AcademySoftwareFoundation/Imath/pull/56)\] Initial support for C wrappers * \[[#55](https://github.com/AcademySoftwareFoundation/Imath/pull/55)\] Fix non-linux platform CI * \[[#54](https://github.com/AcademySoftwareFoundation/Imath/pull/54)\] Combination of Half/Imath and HalfTest/ImathTest directories. * \[[#53](https://github.com/AcademySoftwareFoundation/Imath/pull/53)\] Stoped sonar cloud from running on PR * \[[#52](https://github.com/AcademySoftwareFoundation/Imath/pull/52)\] Fix problems with ImathInterval, and add test * \[[#51](https://github.com/AcademySoftwareFoundation/Imath/pull/51)\] First pass at sphinx/breathe/doxygen documentation * \[[#50](https://github.com/AcademySoftwareFoundation/Imath/pull/50)\] Removed all references to PYIMATH_VERSION, as it is redundant. * \[[#48](https://github.com/AcademySoftwareFoundation/Imath/pull/48)\] Set version to 3.0.0 and SOCURRENT to 26 * \[[#47](https://github.com/AcademySoftwareFoundation/Imath/pull/47)\] Added Exc variants of all methods in frustum that required them. * \[[#46](https://github.com/AcademySoftwareFoundation/Imath/pull/46)\] Movement of all source directories into one top level src/ * \[[#44](https://github.com/AcademySoftwareFoundation/Imath/pull/44)\] Fix copy/paste typos in Doxyfile and conf.py * \[[#43](https://github.com/AcademySoftwareFoundation/Imath/pull/43)\] Initial Doxygen/sphinx/breathe/readthedocs configuration * \[[#42](https://github.com/AcademySoftwareFoundation/Imath/pull/42)\] Made various Imath/ header methods inline * \[[#41](https://github.com/AcademySoftwareFoundation/Imath/pull/41)\] __host__ __device__ CUDA macro added to all header functions under Imath/ * \[[#40](https://github.com/AcademySoftwareFoundation/Imath/pull/40)\] Update INSTALL info on namespaces and cmake options * \[[#39](https://github.com/AcademySoftwareFoundation/Imath/pull/39)\] Clean up of repo docs. * \[[#38](https://github.com/AcademySoftwareFoundation/Imath/pull/38)\] Added CUDA __host__ __device__ with macro to Vector, Matrix, Limits, \xe2\x80\xa6 * \[[#37](https://github.com/AcademySoftwareFoundation/Imath/pull/37)\] Add .git-blame-ignore-revs to ignore reformatting * \[[#36](https://github.com/AcademySoftwareFoundation/Imath/pull/36)\] Disable clang-format for python bindings * \[[#32](https://github.com/AcademySoftwareFoundation/Imath/pull/32)\] Tune .clang-format to match existing style * \[[#30](https://github.com/AcademySoftwareFoundation/Imath/pull/30)\] Changed analysis sonarcloud tests, run on pull request. * \[[#29](https://github.com/AcademySoftwareFoundation/Imath/pull/29)\] Added CI testing and made necessary changes to pass those tests. * \[[#27](https://github.com/AcademySoftwareFoundation/Imath/pull/27)\] Simplest CUDA half type conflict resolution implementation. * \[[#25](https://github.com/AcademySoftwareFoundation/Imath/pull/25)\] Used macros to allow compilation with C++11 and constexpr * \[[#24](https://github.com/AcademySoftwareFoundation/Imath/pull/24)\] b"removed pragma to disable clang's -Wself-assign-overloaded" * \[[#23](https://github.com/AcademySoftwareFoundation/Imath/pull/23)\] changed assert()\] to throw, which is what the original Iex macro ASSERT()\] macro did * \[[#21](https://github.com/AcademySoftwareFoundation/Imath/pull/21)\] First pass at adding constexpr where useful * \[[#20](https://github.com/AcademySoftwareFoundation/Imath/pull/20)\] Speedtest and Inversion python bindings for Arrays * \[[#19](https://github.com/AcademySoftwareFoundation/Imath/pull/19)\] clean up Imath repo docs * \[[#18](https://github.com/AcademySoftwareFoundation/Imath/pull/18)\] Transfer of PyImath history and source to Imath * \[[#17](https://github.com/AcademySoftwareFoundation/Imath/pull/17)\] fixed typo in README.md * \[[#15](https://github.com/AcademySoftwareFoundation/Imath/pull/15)\] further edits of README.md * \[[#14](https://github.com/AcademySoftwareFoundation/Imath/pull/14)\] First complete draft of README.md for the Imath project ## Inherited History from OpenEXR History dated before May 9th, 2020 has been inherited from https://github.com/AcademySoftwareFoundation/openexr, omitting commits (via [git-filter-repo](https://github.com/newren/git-filter-repo)) not pertaining to files now a part of the Imath project. Imath-3.1.4/CMakeLists.txt000066400000000000000000000075641417213455000153370ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. cmake_minimum_required(VERSION 3.12) if(POLICY CMP0074) cmake_policy(SET CMP0074 NEW) endif() if(POLICY CMP0077) # enable variables set outside to override options cmake_policy(SET CMP0077 NEW) endif() # Imath version project(Imath VERSION 3.1.4 LANGUAGES C CXX) set(IMATH_VERSION_RELEASE_TYPE "" CACHE STRING "Extra version tag string for Imath build, such as -dev, -beta1, etc.") set(IMATH_VERSION ${Imath_VERSION}) set(IMATH_VERSION_API "${Imath_VERSION_MAJOR}_${Imath_VERSION_MINOR}") # Library/shared-object version using libtool versioning policy. # See https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html # # Library API version (CMake's library VERSION attribute) is of the # form CURRENT.REVISION.AGE; the CMake SOVERSION attribute corresonds # to just CURRENT. These produce a .so and a symlink symlink, e.g.: # libImath-3_1.so.29 -> libImath-3_1.so.29.0.0 # ^ ^ ^ ^ # | | | | # CURRENT | | AGE # | REVISION # CURRENT # When updating: # 1. no API change: CURRENT.REVISION+1.AGE # 2. API added: CURRENT+1.0.AGE+1 # 3. API changed: CURRENT+1.0.0 # set(IMATH_LIBTOOL_CURRENT 29) set(IMATH_LIBTOOL_REVISION 3) set(IMATH_LIBTOOL_AGE 0) set(IMATH_LIB_VERSION "${IMATH_LIBTOOL_CURRENT}.${IMATH_LIBTOOL_REVISION}.${IMATH_LIBTOOL_AGE}") set(IMATH_LIB_SOVERSION ${IMATH_LIBTOOL_CURRENT}) # ImathSetup.cmake declares all the configuration variables visible # in cmake-gui or similar and the rest of the global # project setup. Check the context to see what is configurable. include(config/ImathSetup.cmake) message(STATUS "Configure ${IMATH_PACKAGE_NAME}, library API version: ${IMATH_LIB_VERSION}") # Config headers and package config files add_subdirectory(config) # Utility function for the repeated boilerplate of defining the libraries include(config/LibraryDefine.cmake) # Source code is in src/Imath add_subdirectory(src/Imath) # Imath_DIR points to the location of ImathConfig.cmake, which tells # downstream projects where to find Imath, via find_package(Imath). set(Imath_DIR "${CMAKE_CURRENT_BINARY_DIR}/config" CACHE PATH "" FORCE) # Add an empty ImathTargets.cmake file for the config to use. It can # be empty since we already defined the targets in add_subdirectory(). file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/config/ImathTargets.cmake" "# Dummy file") option(PYTHON "Set ON to compile PyImath bindings") if (PYTHON) add_subdirectory(src/python) endif() option(DOCS "Set ON to build html documentation") if (DOCS AND NOT IMATH_IS_SUBPROJECT) option(INSTALL_DOCS "Set ON to install html documentation" ON) add_subdirectory(docs) endif() # If you want to use ctest to configure, build and # upload the results, cmake has builtin support for # submitting to CDash, or any server who speaks the # same protocol # # These settings will need to be set for your environment, # and then a script such as the example in # # cmake/SampleCTestScript.cmake # # edited and placed into the CI system, then run: # # cmake -S cmake/SampleCTestScript.cmake # # [or whatever you name the file you edit] # #set(CTEST_PROJECT_NAME "Imath") #set(CTEST_NIGHTLY_START_TIME "01:01:01 UTC") #set(CTEST_DROP_METHOD "http") # there are others... #set(CTEST_DROP_SITE "open.cdash.org") #set(CTEST_DROP_LOCATION "/submit.php?project=MyProject") #set(CTEST_DROP_SITE_CDASH TRUE) include(CTest) if(BUILD_TESTING AND NOT IMATH_IS_SUBPROJECT) enable_testing() add_subdirectory(src/ImathTest) endif() # Including this module will add a `clang-format` target to the build # if the clang-format executable can be found. Only do this if we are # top level. if(NOT IMATH_IS_SUBPROJECT) include(cmake/clang-format.cmake) endif() Imath-3.1.4/CODE_OF_CONDUCT.md000066400000000000000000000040741417213455000153670ustar00rootroot00000000000000# Code of Conduct Imath is a sub-project of the OpenEXR project, which abides by Linux Foundation's code of conduct, which you can read in full [here](https://lfprojects.org/policies/code-of-conduct). Our covenant includes: * Treat each other with respect, professionalism, fairness, and sensitivity to our many differences and strengths, including in situations of high pressure and urgency. * Never harass or bully anyone verbally, physically or sexually. * Never discriminate on the basis of personal characteristics or group membership. * Communicate constructively and avoid demeaning or insulting behavior or language. * Seek, accept, and offer objective work criticism, and acknowledge properly the contributions of others. * Be honest about your own qualifications, and about any circumstances that might lead to conflicts of interest. * Respect the privacy of others and the confidentiality of data you access. * With respect to cultural differences, be conservative in what you do and liberal in what you accept from others, but not to the point of accepting disrespectful, unprofessional or unfair or unwelcome behavior or advances. * Promote the rules of this Code and take action (especially if you are in a leadership position) to bring the discussion back to a more civil level whenever inappropriate behaviors are observed. * Stay on topic: Make sure that you are posting to the correct channel and avoid off-topic discussions. Remember when you update an issue or respond to an email you are potentially sending to a large number of people. * Step down considerately: participants in every project come and go, and LF Projects is no different. When you leave or disengage from the project, in whole or in part, we ask that you do so in a way that minimizes disruption to the project. This means you should tell people you are leaving and take the proper steps to ensure that others can pick up where you left off. To report incidents or to appeal reports of incidents, send email to the Manager of LF Projects at manager@lfprojects.org. Imath-3.1.4/CONTRIBUTING.md000066400000000000000000000365241417213455000150260ustar00rootroot00000000000000# Contributing to Imath Thank you for your interest in contributing to Imath. This document explains our contribution process and procedures: * [Getting Information](#Getting-Information) * [Legal Requirements](#Legal-Requirements) * [Development Workflow](#Development-Workflow) * [Coding Style](#Coding-Style) * [Versioning Policy](#Versioning-Policy) * [Creating a Release](#Creating-a-Release) Imath is a sub-project of [OpenEXR](https://github.com/AcademySoftwareFoundation/openexr) and follows OpenEXR's governance and contribution policies. For a description of the roles and responsibilities of the various members of the OpeneEXR community, see [GOVERNANCE.md](https://github.com/AcademySoftwareFoundation/openexr/blob/master/GOVERNANCE.md), and for further details, see the OpenEXR project's [Technical Charter](https://github.com/AcademySoftwareFoundation/openexr/blob/master/ASWF/charter/OpenEXR-Technical-Charter.md). Briefly, a "contributor" is anyone who submits content to the project, a "committer" is someone who reviews and approves such submissions, and the Technical Steering Committee provides general project oversight. ## Getting Information There are two primary ways to connect with the Imath project: * The [openexr-dev](https://lists.aswf.io/g/openexr-dev) mail list: This is a development focused mail list with a deep history of technical conversations and decisions that have shaped the project. * [GitHub Issues](https://github.com/AcademySoftwareFoundation/Imath/issues): GitHub Issues are used both to track bugs and to discuss feature requests. ### How to Ask for Help If you have trouble installing, building, or using the library, but there's not yet reason to suspect you've encountered a genuine bug, start by posting a question to the [openexr-dev](http://lists.aswf.io/openexr-dev) mailing list. This is the place for question such has "How do I...". ### How to Report a Bug Imath use GitHub's issue tracking system for bugs and enhancements: https://github.com/AcademySoftwareFoundation/Imath/issues If you are submitting a bug report, please be sure to note which version of Imath you are using, on what platform (OS/version, which compiler you used, and any special build flags or other unusual environmental issues). Please give a specific account of * what you tried * what happened * what you expected to happen instead with enough detail that others can reproduce the problem. ### How to Request a Change Open a GitHub issue: https://github.com/AcademySoftwareFoundation/Imath/issues. Describe the situation and the objective in as much detail as possible. Feature requests will almost certainly spawn a discussion among the project community. ### How to Report a Security Vulnerability If you think you've found a potential vulnerability in Imath, please refer to [SECURITY.md](SECURITY.md) to responsibly disclose it. ### How to Contribute a Bug Fix or Change To contribute code to the project, first read over the [GOVERNANCE.md](https://github.com/AcademySoftwareFoundation/openexr/blob/master/GOVERNANCE.md) page to understand the roles involved. You'll need: * A good knowledge of git. * A fork of the GitHub repo. * An understanding of the project's development workflow. * Legal authorization, that is, you need to have signed a contributor License Agreement. See below for details. ## Legal Requirements Imath is a project of the Academy Software Foundation and follows the open source software best practice policies of the Linux Foundation. ### License Imath is licensed under the [BSD-3-Clause](LICENSE.md) license. Contributions to the library should abide by that standard license. ### Contributor License Agreements Developers who wish to contribute code to be considered for inclusion in the Imath distribution must first complete a **Contributor License Agreement** for the OpenEXR project. Imath uses EasyCLA for managing CLAs, which automatically checks to ensure CLAs are signed by a contributor before a commit can be merged. * If you are an individual writing the code on your own time and you're SURE you are the sole owner of any intellectual property you contribute, you can [sign the CLA as an individual contributor](https://github.com/communitybridge/easycla/blob/master/contributors/sign-a-cla-as-an-individual-contributor-to-github.md). * If you are writing the code as part of your job, or if there is any possibility that your employers might think they own any intellectual property you create, then you should use the [Corporate Contributor Licence Agreement](https://github.com/communitybridge/easycla/blob/master/contributors/contribute-to-a-github-company-project.md). The Imath CLAs are the standard forms used by Linux Foundation projects and [recommended by the ASWF TAC](https://github.com/AcademySoftwareFoundation/tac/blob/master/process/contributing.md#contributor-license-agreement-cla). ### Commit Sign-Off Every commit must be signed off. That is, every commit log message must include a “`Signed-off-by`†line (generated, for example, with “`git commit --signoff`â€), indicating that the committer wrote the code and has the right to release it under the [BSD-3-Clause](LICENSE.md) license. See https://github.com/AcademySoftwareFoundation/tac/blob/master/process/contributing.md#contribution-sign-off for more information on this requirement. ## Development Workflow ### Git Basics Working with Imath requires understanding a significant amount of Git and GitHub based terminology. If you’re unfamiliar with these tools or their lingo, please look at the [GitHub Glossary](https://help.github.com/articles/github-glossary/) or browse [GitHub Help](https://help.github.com/). To contribute, you need a GitHub account. This is needed in order to push changes to the upstream repository, via a pull request. You will also need Git installed on your local development machine. If you need setup assistance, please see the official [Git Documentation](https://git-scm.com/doc). ### Repository Structure and Commit Policy The Imath repository uses a simple branching and merging strategy. All development work is done directly on the master branch. The master branch represents the bleeding-edge of the project and most contributions should be done on top of it. After sufficient work is done on the master branch and the Imath leadership determines that a release is due, we will bump the relevant internal versioning and tag a commit with the corresponding version number, e.g. v2.0.1. Each minor version also has its own “Release Branchâ€, e.g. RB-1.1. This marks a branch of code dedicated to that ``major.minor version``, which allows upstream bug fixes to be cherry-picked to a given version while still allowing the master branch to continue forward onto higher versions. This basic repository structure keeps maintenance low, while remaining simple to understand. To reiterate, the master branch represents the latest development version, so beware that it may include untested features and is not generally stable enough for release. To retrieve a stable version of the source code, use one of the release branches. ### The Git Workflow This development workflow is sometimes referred to as [OneFlow](https://www.endoflineblog.com/oneflow-a-git-branching-model-and-workflow). It leads to a simple, clean, linear edit history in the repo. The Imath GitHub repo allows rebase merging and disallows merge commits and squash merging. This ensures that the repo edit history remains linear, avoiding the "bubbles" characteristic of the [GitFlow](https://www.endoflineblog.com/gitflow-considered-harmful) workflow. ### Use the Fork, Luke. In a typical workflow, you should **fork** the Imath repository to your account. This creates a copy of the repository under your user namespace and serves as the “home base†for your development branches, from which you will submit **pull requests** to the upstream repository to be merged. Once your Git environment is operational, the next step is to locally **clone** your forked Imath repository, and add a **remote** pointing to the upstream Imath repository. These topics are covered in the GitHub documentation [Cloning a repository](https://help.github.com/articles/cloning-a-repository/) and [Configuring a remote for a fork](https://help.github.com/articles/configuring-a-remote-for-a-fork/), but again, if you need assistance feel free to reach out on the openexr-dev@lists.aswf.io mail list. ### Pull Requests Contributions should be submitted as Github pull requests. See [Creating a pull request](https://help.github.com/articles/creating-a-pull-request/) if you're unfamiliar with this concept. The development cycle for a code change should follow this protocol: 1. Create a topic branch in your local repository, following the naming format "feature/" or "bugfix/". 2. Make changes, compile, and test thoroughly. Code style should match existing style and conventions, and changes should be focused on the topic the pull request will be addressing. Make unrelated changes in a separate topic branch with a separate pull request. 3. Push commits to your fork. 4. Create a Github pull request from your topic branch. 5. Pull requests will be reviewed by project committers and contributors, who may discuss, offer constructive feedback, request changes, or approve the work. 6. Upon receiving the required number of committer approvals (as outlined in [Required Approvals](#required-approvals)), a committer other than the PR contributor may merge changes into the master branch. ### Code Review and Required Approvals Modifications of the contents of the Imath repository are made on a collaborative basis. Anyone with a GitHub account may propose a modification via pull request and it will be considered by the project committers. Pull requests must meet a minimum number of committer approvals prior to being merged. Rather than having a hard rule for all PRs, the requirement is based on the complexity and risk of the proposed changes, factoring in the length of time the PR has been open to discussion. The following guidelines outline the project's established approval rules for merging: * Core design decisions, large new features, or anything that might be perceived as changing the overall direction of the project should be discussed at length in the mail list before any PR is submitted, in order to: solicit feedback, try to get as much consensus as possible, and alert all the stakeholders to be on the lookout for the eventual PR when it appears. * Small changes (bug fixes, docs, tests, cleanups) can be approved and merged by a single committer. * Big changes that can alter behavior, add major features, or present a high degree of risk should be signed off by TWO committers, ideally one of whom should be the "owner" for that section of the codebase (if a specific owner has been designated). If the person submitting the PR is him/herself the "owner" of that section of the codebase, then only one additional committer approval is sufficient. But in either case, a 48 hour minimum is helpful to give everybody a chance to see it, unless it's a critical emergency fix (which would probably put it in the previous "small fix" category, rather than a "big feature"). * Escape valve: big changes can nonetheless be merged by a single committer if the PR has been open for over two weeks without any unaddressed objections from other committers. At some point, we have to assume that the people who know and care are monitoring the PRs and that an extended period without objections is really assent. Approval must be from committers who are not authors of the change. If one or more committers oppose a proposed change, then the change cannot be accepted unless: * Discussions and/or additional changes result in no committers objecting to the change. Previously-objecting committers do not necessarily have to sign-off on the change, but they should not be opposed to it. * The change is escalated to the TSC and the TSC votes to approve the change. This should only happen if disagreements between committers cannot be resolved through discussion. Committers may opt to elevate significant or controversial modifications to the TSC by assigning the `tsc-review` label to a pull request or issue. The TSC should serve as the final arbiter where required. ### Test Policy All functionality in the library must be covered by an automated test. Each library has a companion ``Test`` project, i.e. ``ImathTest`` and ``HalfTest``. This test suite is collectively expected to validate the behavior of very part of the library. * Any new functionality should be accompanied by a test that validates its behavior. * Any change to existing functionality should have tests added if they don't already exist. The test should should be run, via ``make test``, before submitting a pull request. ## Coding Style #### Formatting Code formattting is controlled by ``clang-format``, with the style specified via the project [.clang-format](https://github.com/AcademySoftwareFoundation/Imath/blob/master/.clang-format) file. * Indent with spaces, never tabs. Each indent level should be 4 spaces. * Function return types go on a separate line: template constexpr inline T abs (T a) { return (a > T (0)) ? a : -a; } * Use a space between function names and the following parentheses unless there are no arguments: V3f v (0.0); v.normalize(); * Place curly braces on their own lines: #### Naming Conventions * In general, classes and template type names should start with upper case and capitalize new words: `class CustomerList;` * In general, local variables should use camelCase. Macros and constants should use `ALL_CAPS`. * Member fields in a class should start with an underscore. No other variables should begin with underscore. #### File conventions C++ implementation should be named `*.cpp`. Headers should be named `.h`. All headers should contain: #pragma once #### Type Conventions Because Imath must deal properly with large images, whose width and/or height approach the maximum allowable in 32-bit signed integers, take special care that integer arithmatic doesn't overlow, and make it as clear as possible exactly what the code is doing, especially in the edge cases. To clarify the intention, prefer to cast between types using ``static_cast<>()`` rather than the basic C-style ``()`` notation: // good: size_t x = static_cast (y); // bad: x = (size_t) y; x = size_t (y); Prefer to use ``std::numeric_limits<>`` instead of preprocesser define's such as ``INT_MAX``: // good: if (x > std::numeric_limits::max()) std::cout << "That's too freakin' high.\n"; // bad: if (x > INT_MAX) #### Copyright Notices All new source files should begin with a copyright and license referencing the OpenEXR project: // Copyright (c) Contributors to the OpenEXR Project. All rights reserved. // SPDX-License-Identifier: BSD-3-Clause #### Comments and Doxygen Use C++ comments (starting line with `//`) rather than C comments (`/* ... */`). For public APIs, use Doxygen-style comments (start with `///`), such as: /// Explanation of a class. Note THREE slashes! /// Also, you need at least two lines like this. If you don't have enough /// for two lines, make one line blank like this: /// class myclass { .... float foo; ///< Doxygen comments on same line look like this } Imath-3.1.4/CONTRIBUTORS.md000066400000000000000000000012251417213455000150420ustar00rootroot00000000000000This is a list of contributors to the OpenEXR project, sorted alphabetically by first name. If you know of missing, please email: info@openexr.com. * Andrew Kunz * Antonio Rojas * Cary Phillips * Christina Tempelaar-Lietz * Daniel Kaneider * Ed Hanway * Eric Wimmer * Florian Kainz * Gregorio Litenstein * Harry Mallon * Huibean Luo * Jens Lindgren * Ji Hun Yu * Jonathan Stone * Kimball Thurston * Larry Gritz * Liam Fernandez * Mark Sisson * Nicholas Yue * Nick Porcino * Nick Rasmussen * Nicolas Chauvet * Owen Thompson * Peter Hillman * Piotr Stanczyk * Ralph Potter * Simon Boorer * Thanh Ha * Thorsten Kaufmann * Yujie Shu Imath-3.1.4/INSTALL.md000066400000000000000000000275571417213455000142330ustar00rootroot00000000000000# Building and Installation ## Download To build the latest release of Imath, download the source (.zip or .tar.gz) from the releases page https://github.com/AcademySoftwareFoundation/Imath/releases. To build from the latest development version, clone the GitHub repo directly via: % git clone https://github.com/AcademySoftwareFoundation/Imath.git The ``master`` branch is the most recent development version, which may be unstable, but the ``release`` branch always points to the most recent and most modern, stable, released version. **Note:** The GitHub repository identifies a "latest" release, which GitHub defines as the release containing the most recent commit, which may correspond to a patch for an earlier minor release. Therefore, the release labled "latest" is not always the most modern or preferable version. If you want the most modern release, use the ``releases`` branch. In the instructions that follow, we will refer to the top-level directory of the source code tree as ``$source_directory``. ## Prerequisites Make sure these are installed on your system before building Imath: * Imath requires CMake version 3.12 or newer * C++ compiler that supports C++11 ## Linux/macOS Quick Start To build via CMake, first choose a location for the build directory, which we will refer to as ``$build_directory``. % mkdir $build_directory % cd $build_directory % cmake $source_directory % make % make install Note that the CMake configuration prefers to apply an out-of-tree build process, since there may be multiple build configurations (i.e. debug and release), one per folder, all pointing at once source tree, hence the ``$build_directory`` noted above, referred to in CMake parlance as the *build directory*. You can place this directory wherever you like. See the [CMake Configuration Options](#CMake-Configuration-Options) section below for the most common configuration options especially the install directory. Note that with no arguments, as above, ``make install`` installs the header files in ``/usr/local/include``, the object libraries in ``/usr/local/lib``, and the executable programs in ``/usr/local/bin``. ## Windows Quick Start Under Windows, if you are using a command line-based setup, such as cygwin, you can of course follow the above. For Visual Studio, CMake generators are "multiple configuration", so you don't even have to set the build type, although you will most likely need to specify the install location. Install Directory By default, ``make install`` installs the headers, libraries, and programs into ``/usr/local``, but you can specify a local install directory to CMake via the ``CMAKE_INSTALL_PREFIX`` variable: % cmake .. -DCMAKE_INSTALL_PREFIX=$install_directory ## Documentation The Imath documentation at [imath.readthedocs.io](https://imath.readthedocs.io) is generated via [Sphinx](https://www.sphinx-doc.org) with the [Breathe](https://breathe.readthedocs.io) extension using information extracted from header comments by [Doxgen](https://www.doxygen.nl). To build the documentation locally from the source headers and ``.rst`` files, set the CMake option ``DOCS=ON``. This adds ``Doxygen`` and ``Sphinx`` CMake targets. Local documentation generation is off by default. Building the documentation requires that sphinx, breathe, and doxygen are installed. ## Python Bindings To build and install the optional Python bindings for Imath, set the CMake option ``PYTHON=ON``. The Python bindings require that ``boost_python`` is installed. By default, the bindings build for Python 3. To build with python 2, set the CMake option ``USE_PYTHON2=ON``. ## Library Names By default the installed libraries follow a pattern for how they are named. This is done to enable multiple versions of the library to be installed and targeted by different builds depending on the needs of the project. A simple example of this would be to have different versions of the library installed to allow for applications targeting different VFX Platform years to co-exist. If you are building dynamic libraries, once you have configured, built, and installed the libraries, you should see something like the following pattern of symlinks and files in the install lib folder: libImath.so -> libImath-3_1.so libImath-3_1.so -> libImath-3_1.so.29 libImath-3_1.so.29 -> libImath-3_1.29.0.1 The actual shared object file is appended with the library interface version name, formed according to the [libtool versioning scheme](https://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html): ``current.revision.age``. Note that the ``libImath.so`` symlink is ommitted if the ``IMATH_INSTALL_SYM_LINK`` option is disabled. You can configure the ``IMATH_LIB_SUFFIX``, although it defaults to the library major and minor version, so in the case of a ``3.1`` release, it would default to ``-3_1``. You would then link your programs against this versioned library to have maximum safety (i.e. `-lImath-3_1`), and the pkg-config and CMake configuration files included with find_package should set this up. The versioned libraries will have the ``-d`` suffix when the ``CMAKE_BUILD_TYPE`` is ``Debug``. ## Custom Namespaces Normally, all Imath symbols are in the ``Imath`` namespace, but you can control this at CMake time via the ``IMATH_NAMESPACE`` and ``IMATH_INTERNAL_NAMESPACE`` CMake settings. These settings specify an ``IMATH_INTERNAL_NAMESPACE`` preprocessor definition that places all of the Imath symbols within the given namespace rather than the standard ``Imath`` namespace. Those symbols are made available to client code through the ``IMATH_NAMESPACE`` in addition to the ``IMATH_INTERNAL_NAMESPACE``. See ``Imath/ImathConfig.h`` for details. To ensure source code compatibility, the ``IMATH_NAMESPACE`` defaults to ``Imath`` and then ``using namespace IMATH_INTERNAL_NAMESPACE;`` brings all of the declarations from the ``IMATH_INTERNAL_NAMESPACE`` into the ``IMATH_NAMESPACE``. This means that client code can continue to use syntax like ``Imath::V3f``, but at link time it will resolve to a mangled symbol based on the ``IMATH_INTERNAL_NAMESPACE``. As an example, if one needed to build against a newer version of Imath and have it run alongside an older version in the same application, it is possible to use an internal namespace to prevent collisions between the older versions of Imath symbols and the newer ones. To do this, the following could be defined at build time: % cmake -DIMATH_INTERNAL_NAMESPACE=Imath_v2 $source_directory This means that declarations inside Imath headers look like this (after the preprocessor has done its work): namespace Imath_v2 { ... class declarations ... } namespace Imath { using namespace Imath_v2; } ## Cross Compiling / Specifying Specific Compilers When either cross-compiling for a different platform, or when specifying a compiler set to match the VFX reference platform (https://vfxplatform.com/), CMake provides the idea of a *toolchain*, which may be useful instead of having to remember a chain of configuration options. This also means that platform-specific compiler names and options are kept out of the main ``CMakeList.txt`` file, which provides better isolation. A toolchain file is simply a CMake script that sets compiler and related flags and is run early in the configuration step, prior to CMake's automatic discovery step. These options can still be set on the command line if that is clearer, but a theoretical toolchain file for compiling for VFX Platform 2021 is provided in the source tree at ``cmake/Toolchain-Linux-VFX_Platform21.cmake`` which will hopefully provide a guide how this might work. For cross-compiling for additional platforms, there is also an included sample script in ``cmake/Toolchain-mingw.cmake`` which shows how cross compiling from Linux for Windows may work. The compiler names and paths may need to be changed for your environment. More documentation: * Toolchains: https://cmake.org/cmake/help/v3.12/manual/cmake-toolchains.7.html * Cross compiling: https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/ ## CMake Configuration Options The default CMake configuration options are stored in ``Imath/config/ImathSetup.cmake``. To see a complete set of option variables, run: % cmake -LAH $source_directory Via standard cmake operation, you can customize these options three ways: 1. Modify the ``.cmake`` files in place. 2. Use the UI ``cmake-gui`` or ``ccmake``. 2. Specify them as command-line arguments via -D when you invoke cmake. ### Imath Configuration Settings: ``IMATH_CXX_STANDARD`` C++ standard to compile against. Default is ``14``. ``IMATH_HALF_USE_LOOKUP_TABLE`` Use the half-to-float conversion lookup table. Default is ``ON`` for backwards compatibility. With the value of ``OFF``, use a bit-shift conversion algorithm. Note that this setting is overriden when compiler flags enable the F16C SSE instruction set. ``IMATH_USE_DEFAULT_VISIBILITY`` Use default visibility, which makes all symbols visible in compiled objects. Default is ``OFF``, in which case only designated necessary symbols are marked for export. ``IMATH_USE_NOEXCEPT`` Use the ``noexcept`` specifier of appropriate methods. Default is ``ON``. With the value of ``OFF``, the ``noexcept`` specifier is omitted, for situations in which it is not desireable. ``IMATH_ENABLE_LARGE_STACK`` Enables the ``halfFunction`` object to place the lookup tables on the stack rather than allocating heap memory. Default is ``OFF``. ``IMATH_VERSION_RELEASE_TYPE`` A string to append to the version number in the internal package name macro IMATH_PACKAGE_STRING. Default is the empty string, but can be set to, for example, "-dev" during development (e.g. "3.1.0-dev"). ``IMATH_INSTALL_SYM_LINK`` Install an unversioned symbolic link (i.e. libImath.so) to the versioned library. ``IMATH_INSTALL_PKG_CONFIG`` Install Imath.pc file. Default is ``ON``. ``IMATH_NAMESPACE`` Public namespace alias for Imath. Default is ``Imath``. ``IMATH_INTERNAL_NAMESPACE`` Real namespace for Imath that will end up in compiled symbols. Default is ``Imath__``. ``IMATH_NAMESPACE_CUSTOM`` Whether the namespace has been customized (so external users know). Default is ``NO``. ``IMATH_LIB_SUFFIX`` String added to the end of all the versioned libraries. Default is ``-_`` ``IMATH_OUTPUT_SUBDIR`` Destination sub-folder of the include path for install. Default is ``Imath``. ``DOCS`` Build the html documentation. Default is ``OFF``. ``PYTHON`` Build the optional Imath python bindings. Default is ``OFF``. The Python bindings require that ``boost_python`` is installed. ``USE_PYTHON2`` If ``ON`` and ``PYTHON`` is also ``ON``, build the bindings for Python 2. Default is ``OFF``, implying that the default bindings are built for Python 3. ``PYIMATH_OVERRIDE_PYTHON_INSTALL_DIR`` Custom destination for installatation of ``imath.so`` and ``imathnumpy.so`` modules. By default, they go into either ``site-packages`` or ``dist-packages`. To enable half-to-float conversion using the F16C SSE instruction set for g++ and clang when installing Imath, add the ``-mf16c`` compiler option: % cmake -DCMAKE_CXX_FLAGS="-mf16c" See the [Imath Technical Documentation](https://imath.readthedocs.io/en/latest) for more information about the half-float conversion process. ### Common CMake Settings: * ``BUILD_SHARED_LIBS`` - CMake standard variable to select a static or shared build. Default is ``ON``. * ``BUILD_TESTING`` - Build the runtime test suite. Default is ``ON``. ## CMake Tips and Tricks: If you have ninja (https://ninja-build.org/) installed, it is faster than make. You can generate ninja files using CMake when doing the initial generation: % cmake -G “Ninja†.. If you would like to confirm compile flags, you don’t have to specify the verbose configuration up front, you can instead run % make VERBOSE=1 Imath-3.1.4/LICENSE.md000066400000000000000000000027311417213455000141720ustar00rootroot00000000000000Copyright Contributors to the OpenEXR Project. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Imath-3.1.4/README.md000066400000000000000000000132241417213455000140440ustar00rootroot00000000000000[![License](https://img.shields.io/github/license/AcademySoftwareFoundation/Imath)](LICENSE.md) [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/2799/badge)](https://bestpractices.coreinfrastructure.org/projects/2799) [![Build Status](https://dev.azure.com/academysoftwarefoundation/Academy%20Software%20Foundation/_apis/build/status/academysoftwarefoundation.Imath)](https://dev.azure.com/academysoftwarefoundation/Academy%20Software%20Foundation/_build?definitionId=4&_a=summary) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=AcademySoftwareFoundation_Imath&metric=alert_status)](https://sonarcloud.io/dashboard?id=AcademySoftwareFoundation_Imath) # Imath Imath is a basic, light-weight, and efficient C++ representation of 2D and 3D vectors and matrices and other simple but useful mathematical objects, functions, and data types common in computer graphics applications, including the “half†16-bit floating-point type. Imath also includes optional python bindings for all types and functions, including optimized implementations of vector and matrix arrays. ### Project Mission The goals of the Imath project are simplicity, ease of use, correctness and verifiability, performance, and breadth of adoption. Imath is not intended to be a comprehensive linear algebra or numerical analysis package. ### Features * half: 16-bit floating-point type * Vector: V2s, V2i, V2i64, V2f, V2d, V3s, V3i, V4i64, V3f, V3d, V4s, V4i, V4i64, V4f, V4d * Matrix: M22f, M22d, M33f, M33d, M44f, M44d * Bounding box: Box2s, Box2i, Box2i64, Box2f, Box2d, Box3s, Box3i, Box3i64, Box3f, Box3d * Color: C3h, C3f, C3c, C4f, C4h, C4c * Euler angles: Eulerf, Eulerd * Quaternion: Quatf, Quatd * Viewing frustum: Frustrumf, Frustumd * Interval: Intervals, Intervali, Intervalf, Intervald * Line: Line3f, Line3d * Plane: Plane3f, Plane3d * Sphere: Sphere3f, Sphere3d * Shear: Shear3f, Shear3d, Shear6f, Shear6 * Miscellaneous math functions ### New Features in 3.1 The 3.1 release of Imath introduces optimized half-to-float and float-to-half conversion using the F16C SSE instruction set extension, if available. These single-instruction conversions offer a 5-10x speedup for float-to-half and 2x speedup for half-to-float over Imath/half's traditional table-based conversion (timings depend on the data). In the absence of the F16C instruction set, the lookup-table-based conversion from half to float is still the default, but Imath 3.1 also introduces an optimized bit-shift conversion algorithm as a compile-time option that does not require lookup tables, for architectures where memory is limited. The float-to-half conversion also no longer requires an exponent lookup table, further reducing memory requirements. These new conversions generate the same values as the tranditional methods, which ensures backwards compatibility. See [INSTALL.md](INSTALL.md#imath-configuration-settings) for more installation and configuation options. Also, ``half.h`` can now be included in pure C code for a definition of the type and for conversions between half and float. ### Supported Platforms Imath builds on Linux, macOS, Microsoft Windows, and is cross-compilable on other systems. ### About Imath Imath was originally developed at Industrial Light & Magic in the early 2000's and was originally distributed as open source as a part of the [OpenEXR](https://github.com/AcademySoftwareFoundation/openexr) project. Imath continues to be maintained as a sub-project of OpenEXR, which is now a project of the [Academy Software Foundation](https://www.aswf.io). See the OpenEXR project's [GOVERNANCE.md](https://github.com/AcademySoftwareFoundation/openexr/blob/master/GOVERNANCE.md) for more information about how the project operates. The OpenEXR project is dedicated to promoting a harassment-free community. Read our [code of conduct](CODE_OF_CONDUCT.md). ### Developer Quick Start Technical documentation for the Imath classes and functions can be found at [imath.readthedocs.io](https://imath.readthedocs.io). See [INSTALL.md](INSTALL.md) for instructions on downloading and building Imath from source. If you encounter problems compiling code or building projects written with an earlier release of Imath, the [porting guide](https://github.com/AcademySoftwareFoundation/Imath/blob/master/docs/PortingGuide2-3.md) explains some of the differences and how to address them. ### A Note about Versioning Because Imath was originally distributed as a part of OpenEXR, it has already had two major release versions, as a part of OpenEXR v1.* and v2.*. To avoid confusion with these original releases, the first version of Imath released independently of OpenEXR is Version v3.0. To be clear, the versioning and release of Imath is no longer tied to OpenEXR. ### Getting Help Connect with the project through: * The openexr-dev@lists.aswf.io mail list: This is a development focused mail list with a deep history of technical conversations and decisions that have shaped the project. Subscribe at [openexr-dev@lists.aswf.io](https://lists.aswf.io/g/openexr-dev). * Slack: [#openexr](https://academysoftwarefdn.slack.com/archives/CMLRW4N73) * GitHub Issues: GitHub issues are used both to track bugs and to discuss feature requests. Submit an issue here: https://github.com/AcademySoftwareFoundation/imath/issues. ### Getting Involved The OpenEXR developer community welcomes contributions to the project. See [CONTRIBUTING.md](CONTRIBUTING.md) for more information about contributing to Imath and OpenEXR. ## License Imath is released under OpenEXR's [BSD-3-Clause](LICENSE.md) license. --- ![aswf](https://github.com/AcademySoftwareFoundation/openexr/blob/master/ASWF/images/aswf.png) Imath-3.1.4/SECURITY.md000066400000000000000000000011001417213455000143440ustar00rootroot00000000000000# Security Policy ## Reporting a Vulnerability If you think you've found a potential vulnerability in Imath, please report it by emailing security@openexr.org. Only OpenEXR Technical Steering Committee members and Academy Software Foundation project management have access to these messages. Include detailed steps to reproduce the issue, and any other information that could aid an investigation. Our policy is to respond to vulernability reports within 14 days. Our policy is to address critical security vulnerabilities rapidly and post patches as quickly as possible. Imath-3.1.4/cmake/000077500000000000000000000000001417213455000136435ustar00rootroot00000000000000Imath-3.1.4/cmake/FindSphinx.cmake000066400000000000000000000007251417213455000167230ustar00rootroot00000000000000#Look for an executable called sphinx-build find_program(SPHINX_EXECUTABLE NAMES sphinx-build DOC "Path to sphinx-build executable") include(FindPackageHandleStandardArgs) #Handle standard arguments to find_package like REQUIRED and QUIET find_package_handle_standard_args(Sphinx "Failed to find sphinx-build executable" SPHINX_EXECUTABLE) Imath-3.1.4/cmake/SampleCTestScript.cmake000066400000000000000000000044041417213455000202200ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # This is a sample cmake test script that can be used to integrate into # a larger CI setup if you are building your own versions of OpenEXR # and also use a cdash (or cdash compliant) results server. # # There are also settings in the CMakeLists.txt you may wish to # just set in there, or replicate here. # Running ctest -S thisscript.cmake will build into the binary directory # and run a few different tests based on what commands are specified # (and the steps below). It is best to read the ctest docs to # understand all these settings, and how to control it, this is merely # provided as a sample # An edited version (or multiple) are intended to be placed in the CI # system, and putting O.S. / configuration specific control to this file # instead of having to put it into the make CMakeLists.txt tree # somehow. # this contains the path to the source tree. This may come in as an # environment variable from the CI system, but you are free to have # any path in here set(CTEST_SOURCE_DIRECTORY "$ENV{PATH_TO_OPENEXR_TREE}") # Similarly, this is scratch space used to configure, build # and run the various tests. # For CI builds, it is recommended to make sure this is a # unique tree for each build set(CTEST_BINARY_DIRECTORY "/tmp/ctest") # set an override for any compile flags to enable coverage # NB: This can make some of the auxiliary binaries such as the # dwa lookup table generator quite slow #set(ENV{CXXFLAGS} "--coverage") # If you have alternate build systems, you can control that here #set(CTEST_CMAKE_GENERATOR "Ninja") set(CTEST_USE_LAUNCHERS 1) # The various paths to programs to run coverage and memory checks set(CTEST_COVERAGE_COMMAND "gcov") set(CTEST_MEMORYCHECK_COMMAND "valgrind") #set(CTEST_MEMORYCHECK_TYPE "ThreadSanitizer") # # any of the usual configurations (Debug, Release, etc). # We do not attempt to create any alternate configurations set(CTEST_CONFIGURATION_TYPE "RelWithDebInfo") # can be Continuous, Nightly, or Experimental (see the cmake docs) ctest_start("Continuous") # applies the various ctest steps ctest_configure() ctest_build() ctest_test() ctest_coverage() ctest_memcheck() # This uploads the results to the server you configured ctest_submit() Imath-3.1.4/cmake/Toolchain-Linux-VFX_Platform21.cmake000066400000000000000000000024101417213455000223270ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # This is only an example of a theoretical toolchain file # that might be used for compiling to target a VFX # reference platform (https://vfxplatform.com) that is # consistent with the CY2021 spec. # # A toolchain file is loaded early in the cmake configure # process to enable compiler checks to use the appropriate # compilers. # # Read the docs to understand more: # https://cmake.org/cmake/help/v3.12/manual/cmake-toolchains.7.html # # Then to run, do something like # mkdir vfx_2021 # cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-Linux-VFX_Platform21.cmake -DCMAKE_INSTALL_PREFIX=/path/to/vfx_2021 .. # (plus any other settings you'd like) # make # make test # make install # by not setting this, it will assume it's a mostly standard linux environment #set(CMAKE_SYSTEM_NAME Linux) set(CMAKE_C_COMPILER gcc-9.3.1) set(CMAKE_CXX_COMPILER g++-9.3.1) set(CMAKE_FIND_ROOT_PATH /my/vfx_2021/libraries) set(CMAKE_CXX_STANDARD 14) # read the docs to understand whether this is what you want # if you use system libraries for some things, it may not be!!! #set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) #set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) #set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) Imath-3.1.4/cmake/Toolchain-mingw.cmake000066400000000000000000000021431417213455000177040ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # This is only an example of cross compiling, but to compile for windows # under linux, have the relevant bits installed, and # validate the find path below # # Then to run, do something like # mkdir win32_cross # cd win32_cross # cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw.cmake -DCMAKE_INSTALL_PREFIX=/tmp/win32 .. # or for static libs only # cmake -DBUILD_SHARED_LIBS=OFF -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw.cmake -DCMAKE_INSTALL_PREFIX=/tmp/win32 .. # make # set(CMAKE_SYSTEM_NAME Windows) set(CMAKE_CROSSCOMPILING_EMULATOR wine) set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc) set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++) set(CMAKE_RC_COMPILER x86_64-w64-mingw32-windres) set(CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++ -static") set(CMAKE_SHARED_LINKER_FLAGS "-static-libgcc -static-libstdc++ -static") set(CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32) set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) Imath-3.1.4/cmake/clang-format.cmake000066400000000000000000000044111417213455000172170ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # # This module was partially adapted from OpenImageIO, also under the # same BSD-3-Clause license. ########################################################################### # clang-format options # # clang-format is a source code reformatter that is part of the LLVM tools. # It can be used to check adherence to project code formatting rules and # correct any deviations. If clang-format is found on the system, a # "clang-format" build target will trigger a reformatting. # set (CLANG_FORMAT_ROOT "" CACHE PATH "clang-format executable's directory (will search if not specified") set (CLANG_FORMAT_INCLUDES "*.h" "*.cpp" CACHE STRING "Glob patterns to include for clang-format") set (CLANG_FORMAT_EXCLUDES "" CACHE STRING "Glob patterns to exclude for clang-format") # Look for clang-format. If not in the ordinary execution path, you can # hint at it with either CLANG_FORMAT_ROOT or LLVM_ROOT (as a CMake variable # or as an environment variable). find_program (CLANG_FORMAT_EXE NAMES clang-format bin/clang-format HINTS ${CLANG_FORMAT_ROOT} ENV CLANG_FORMAT_ROOT LLVM_ROOT ENV LLVM_ROOT DOC "Path to clang-format executable") # If clang-format was found, set up a custom `clang-format` target that will # reformat all source code with filenames patterns matching # CLANG_FORMAT_INCLUDES and excluding CLANG_FORMAT_EXCLUDES. if (CLANG_FORMAT_EXE) message (STATUS "clang-format found: ${CLANG_FORMAT_EXE}") # Start with the list of files to include when formatting... file (GLOB_RECURSE FILES_TO_FORMAT ${CLANG_FORMAT_INCLUDES}) # ... then process any list of excludes we are given foreach (_pat ${CLANG_FORMAT_EXCLUDES}) file (GLOB_RECURSE _excl ${_pat}) list (REMOVE_ITEM FILES_TO_FORMAT ${_excl}) endforeach () #message (STATUS "clang-format file list: ${FILES_TO_FORMAT}") file (COPY ${CMAKE_CURRENT_SOURCE_DIR}/.clang-format DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) add_custom_target (clang-format COMMAND "${CLANG_FORMAT_EXE}" -i -style=file ${FILES_TO_FORMAT} ) else () message (STATUS "clang-format not found.") endif () Imath-3.1.4/config/000077500000000000000000000000001417213455000140305ustar00rootroot00000000000000Imath-3.1.4/config/CMakeLists.txt000066400000000000000000000050471417213455000165760ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. if (IMATH_ENABLE_LARGE_STACK) set(IMATH_HAVE_LARGE_STACK ON) endif() if (IMATH_USE_DEFAULT_VISIBILITY) set(IMATH_ENABLE_API_VISIBILITY OFF) else() set(IMATH_ENABLE_API_VISIBILITY ON) endif() configure_file(ImathConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/ImathConfig.h) add_library(ImathConfig INTERFACE) target_include_directories(ImathConfig INTERFACE $ $ $) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/ImathConfig.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${IMATH_OUTPUT_SUBDIR} ) install(TARGETS ImathConfig EXPORT ${PROJECT_NAME}) add_library(Imath::Config ALIAS ImathConfig) if(IMATH_INSTALL_PKG_CONFIG) # use a helper function to avoid variable pollution, but pretty simple function(imath_pkg_config_help pcinfile) set(prefix ${CMAKE_INSTALL_PREFIX}) set(exec_prefix "\${prefix}") set(libdir ${CMAKE_INSTALL_FULL_LIBDIR}) set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR}) string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE) set(LIB_SUFFIX_DASH ${IMATH_LIB_SUFFIX}${CMAKE_${uppercase_CMAKE_BUILD_TYPE}_POSTFIX}) string(REPLACE ".in" "" pcout ${pcinfile}) configure_file(${pcinfile} ${CMAKE_CURRENT_BINARY_DIR}/${pcout} @ONLY) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${pcout} DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig ) endfunction() imath_pkg_config_help(Imath.pc.in) else() message(STATUS "pkg-config generation disabled") endif() # # The main export of the configuration: this is the cmake equivalent # of a pkg-config file and replaces the Find*.cmake of the "old" cmake # include(CMakePackageConfigHelpers) configure_package_config_file(ImathConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} ) write_basic_package_version_file("${PROJECT_NAME}ConfigVersion.cmake" VERSION ${IMATH_VERSION} COMPATIBILITY SameMajorVersion ) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} ) install(EXPORT ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} FILE ${PROJECT_NAME}Targets.cmake NAMESPACE ${PROJECT_NAME}:: EXPORT_LINK_INTERFACE_LIBRARIES ) Imath-3.1.4/config/Imath.pc.in000066400000000000000000000006611417213455000160260ustar00rootroot00000000000000## ## SPDX-License-Identifier: BSD-3-Clause ## Copyright Contributors to the OpenEXR Project. ## prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ libsuffix=@LIB_SUFFIX_DASH@ Name: Imath Description: Imath library: vector/matrix and math operations, plus the half type. Version: @IMATH_VERSION@ Requires: Conflicts: Libs: -L${libdir} -lImath${libsuffix} Cflags: -I${includedir} -I${includedir}/Imath Imath-3.1.4/config/ImathConfig.cmake.in000066400000000000000000000001751417213455000176320ustar00rootroot00000000000000@PACKAGE_INIT@ include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake") check_required_components("@PROJECT_NAME@") Imath-3.1.4/config/ImathConfig.h.in000066400000000000000000000127701417213455000170050ustar00rootroot00000000000000// SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // This file is auto-generated by the cmake configure step #ifndef INCLUDED_IMATH_CONFIG_H #define INCLUDED_IMATH_CONFIG_H 1 #pragma once // // Options / configuration based on O.S. / compiler // // // Define whether the half-to-float conversion should use the lookup // table method. Note that this is overriden by F16C compiler // flags. It is also overrided by the IMATH_HALF_NO_LOOKUP_TABLE // macro, if defined. // #cmakedefine IMATH_HALF_USE_LOOKUP_TABLE // // Define if the target system has support for large // stack sizes. // #cmakedefine IMATH_HAVE_LARGE_STACK ////////////////////// // // C++ namespace configuration / options // Current (internal) library namepace name and corresponding public // client namespaces. #define IMATH_INTERNAL_NAMESPACE_CUSTOM @IMATH_NAMESPACE_CUSTOM@ #define IMATH_INTERNAL_NAMESPACE @IMATH_INTERNAL_NAMESPACE@ #define IMATH_NAMESPACE_CUSTOM @IMATH_NAMESPACE_CUSTOM@ #define IMATH_NAMESPACE @IMATH_NAMESPACE@ // // Version information // #define IMATH_VERSION_STRING "@IMATH_VERSION@" #define IMATH_PACKAGE_STRING "@IMATH_PACKAGE_NAME@" #define IMATH_VERSION_MAJOR @Imath_VERSION_MAJOR@ #define IMATH_VERSION_MINOR @Imath_VERSION_MINOR@ #define IMATH_VERSION_PATCH @Imath_VERSION_PATCH@ #define IMATH_VERSION_RELEASE_TYPE "@IMATH_VERSION_RELEASE_TYPE@" #define IMATH_VERSION_HEX ((uint32_t(IMATH_VERSION_MAJOR) << 24) | \ (uint32_t(IMATH_VERSION_MINOR) << 16) | \ (uint32_t(IMATH_VERSION_PATCH) << 8)) // IMATH_LIB_VERSION is the library API version: SOCURRENT.SOAGE.SOREVISION #define IMATH_LIB_VERSION_STRING "@IMATH_LIB_VERSION@" // // Code that depends on the v2 ExcMath mechanism of signal handlers // that throw exceptions is incompatible with noexcept, since // floating-point overflow and underflow can occur in a wide variety // of computations within Imath functions now marked with // noexcept. Code that needs to accomodate the exception-handling // behavior can build with the IMATH_USE_NOEXCEPT off. // #cmakedefine01 IMATH_USE_NOEXCEPT #if IMATH_USE_NOEXCEPT #define IMATH_NOEXCEPT noexcept #else #define IMATH_NOEXCEPT #endif // // By default, opt into the interoparability constructors and assignments. // If this causes problems, it can be disabled by defining this symbol to // be 0 prior to including any Imath headers. // // If no such definition is found, we enable automatically unless we are // using gcc 4.x, which appears to have bugs that prevent the interop // templates from compiling correctly. // #ifndef IMATH_FOREIGN_VECTOR_INTEROP # if defined(__GNUC__) && __GNUC__ == 4 && !defined(__clang__) # define IMATH_FOREIGN_VECTOR_INTEROP 0 # else # define IMATH_FOREIGN_VECTOR_INTEROP 1 # endif #endif // // Decorator that makes a function available for both CPU and GPU, when // compiling for Cuda. // #ifdef __CUDACC__ #define IMATH_HOSTDEVICE __host__ __device__ #else #define IMATH_HOSTDEVICE #endif // // Some compilers define a special intrinsic to use in conditionals that can // speed up extremely performance-critical spots if the conditional is // usually (or rarely) is true. You use it by replacing // if (x) ... // with // if (IMATH_LIKELY(x)) ... // if you think x will usually be true // or // if (IMATH_UNLIKELY(x)) ... // if you think x will rarely be true // // Caveat: Programmers are notoriously bad at guessing this, so it should be // used only with thorough benchmarking. // #if defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) # ifdef __cplusplus # define IMATH_LIKELY(x) (__builtin_expect(static_cast(x), true)) # define IMATH_UNLIKELY(x) (__builtin_expect(static_cast(x), false)) # else # define IMATH_LIKELY(x) (__builtin_expect((x), 1)) # define IMATH_UNLIKELY(x) (__builtin_expect((x), 0)) # endif #else # define IMATH_LIKELY(x) (x) # define IMATH_UNLIKELY(x) (x) #endif // On modern versions of gcc & clang, __has_attribute can test support for // __attribute__((attr)). Make sure it's safe for other compilers. #ifndef __has_attribute # define __has_attribute(x) 0 #endif // // Simple way to mark things as deprecated. // When we are sure that C++14 is our true minimum, then we can just // directly use [[deprecated(msg)]]. // #if defined(_MSC_VER) # define IMATH_DEPRECATED(msg) __declspec(deprecated(msg)) #elif defined(__cplusplus) && __cplusplus >= 201402L # define IMATH_DEPRECATED(msg) [[deprecated(msg)]] #elif defined(__GNUC__) || defined(__clang__) # define IMATH_DEPRECATED(msg) __attribute__((deprecated(msg))) #else # define IMATH_DEPRECATED(msg) /* unsupported on this platform */ #endif // Whether the user configured the library to have symbol visibility // tagged #cmakedefine IMATH_ENABLE_API_VISIBILITY // MSVC does not do the same visibility attributes, and when we are // compiling a static library we won't be in DLL mode, but just don't // define these and the export headers will work out #if ! defined(_MSC_VER) && defined(IMATH_ENABLE_API_VISIBILITY) # define IMATH_PUBLIC_SYMBOL_ATTRIBUTE __attribute__ ((__visibility__ ("default"))) # define IMATH_PRIVATE_SYMBOL_ATTRIBUTE __attribute__ ((__visibility__ ("hidden"))) // clang differs from gcc and has type visibility which is needed for enums and templates # if __has_attribute(__type_visibility__) # define IMATH_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE __attribute__ ((__type_visibility__ ("default"))) # endif #endif #endif // INCLUDED_IMATH_CONFIG_H Imath-3.1.4/config/ImathSetup.cmake000066400000000000000000000125411417213455000171200ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. include(GNUInstallDirs) # Target configuration if(NOT "${CMAKE_PROJECT_NAME}" STREQUAL "${PROJECT_NAME}") set(IMATH_IS_SUBPROJECT ON) message(STATUS "Imath is configuring as a cmake sub project") endif() option(IMATH_HALF_USE_LOOKUP_TABLE "Convert half-to-float using a lookup table (on by default)" ON) option(IMATH_USE_DEFAULT_VISIBILITY "Makes the compile use default visibility (by default compiles tidy, hidden-by-default)" OFF) # This is primarily for the halfFunction code that enables a stack # object (if you enable this) that contains a LUT of the function option(IMATH_ENABLE_LARGE_STACK "Enables code to take advantage of large stack support" OFF) # Option to make it possible to build without the noexcept specifier option(IMATH_USE_NOEXCEPT "Compile with noexcept specifier" ON) # What C++ standard to compile for. VFX Platform 18 is c++14, so # that's the default. set(tmp 14) if(CMAKE_CXX_STANDARD) set(tmp ${CMAKE_CXX_STANDARD}) endif() set(IMATH_CXX_STANDARD "${tmp}" CACHE STRING "C++ standard to compile against") set(tmp) # Namespace-related settings: allows one to customize the namespace # generated, and to version the namespaces. set(IMATH_NAMESPACE_CUSTOM "0" CACHE STRING "Whether the namespace has been customized (so external users know)") set(IMATH_INTERNAL_NAMESPACE "Imath_${IMATH_VERSION_API}" CACHE STRING "Real namespace for Imath that will end up in compiled symbols") set(IMATH_NAMESPACE "Imath" CACHE STRING "Public namespace alias for Imath") set(IMATH_PACKAGE_NAME "Imath ${IMATH_VERSION}${IMATH_VERSION_RELEASE_TYPE}" CACHE STRING "Public string / label for displaying package") # Whether to generate and install a pkg-config file Imath.pc on if(WIN32) option(IMATH_INSTALL_PKG_CONFIG "Install Imath.pc file" OFF) option(IMATH_INSTALL_SYM_LINK "Create symbolic links for shared objects" OFF) else() option(IMATH_INSTALL_PKG_CONFIG "Install Imath.pc file" ON) option(IMATH_INSTALL_SYM_LINK "Create symbolic links for shared objects" ON) endif() # # Build related options # # This variable is for use in install lines. Care must be taken when # changing this, as many things assume this is "Imath". set(IMATH_OUTPUT_SUBDIR Imath CACHE STRING "Destination sub-folder of the include path for install") # This does not seem to be available as a per-target property, but is # pretty harmless to set globally. set(CMAKE_INCLUDE_CURRENT_DIR ON) # Suffix for debug configuration libraries (if you should choose to # install those) set(CMAKE_DEBUG_POSTFIX "_d" CACHE STRING "Suffix for debug builds") # Usual cmake option to build shared libraries or not option(BUILD_SHARED_LIBS "Build shared library" ON) # Suffix to append to root name, this helps with version management # but can be turned off if you don't care, or otherwise customized set(IMATH_LIB_SUFFIX "-${IMATH_VERSION_API}" CACHE STRING "string added to the end of all the libraries") # When building static, the additional string to add to the library name such # that a static build of Imath is easily distinguishable. # To use the static library, you would use # -lImath_static (or target_link_libraries(xxx Imath::Imath_static)) set(IMATH_STATIC_LIB_SUFFIX "_static" CACHE STRING "name to append to static library (in addition to normal suffix)") # rpath related setup. Make sure we force an rpath to the rpath we're compiling set(CMAKE_SKIP_BUILD_RPATH FALSE) set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) # Add the automatically determined parts of the rpath which point to # directories outside the build tree to the install RPATH set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) if(APPLE) set(CMAKE_MACOSX_RPATH ON) endif() # If the user sets an install rpath then just use that, or otherwise # set one for them. if(NOT CMAKE_INSTALL_RPATH) list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir) if("${isSystemDir}" STREQUAL "-1") if("${CMAKE_SYSTEM}" MATCHES "Linux") get_filename_component(tmpSysPath "${CMAKE_INSTALL_FULL_LIBDIR}" NAME) if(NOT tmpSysPath) set(tmpSysPath "lib") endif() set(CMAKE_INSTALL_RPATH "\\\$ORIGIN/../${tmpSysPath};${CMAKE_INSTALL_FULL_LIBDIR}") set(tmpSysPath) elseif(APPLE) set(CMAKE_INSTALL_RPATH "@loader_path/../lib;@executable_path/../lib;${CMAKE_INSTALL_FULL_LIBDIR}") else() set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_FULL_LIBDIR}") endif() endif() set(isSystemDir) endif() # Set a default build type if not set if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Release' as none was specified.") set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE) # Set the possible values of build type for cmake-gui set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") endif() # Code check related features option(IMATH_USE_CLANG_TIDY "Check if clang-tidy is available, and enable that" OFF) if(IMATH_USE_CLANG_TIDY) find_program(IMATH_CLANG_TIDY_BIN clang-tidy) if(IMATH_CLANG_TIDY_BIN-NOTFOUND) message(FATAL_ERROR "clang-tidy processing requested, but no clang-tidy found") endif() # TODO: Need to define the list of valid checks and add a file with said list set(CMAKE_CXX_CLANG_TIDY ${IMATH_CLANG_TIDY_BIN}; -header-filter=.; -checks=*; ) endif() Imath-3.1.4/config/LibraryDefine.cmake000066400000000000000000000107661417213455000175630ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. include(CheckLibraryExists) check_library_exists(m sin "" HAVE_LIB_M) if (HAVE_LIB_M) set(IMATH_EXTRA_LIBS m) endif() # NB: This function has a number if Imath specific names / variables # in it, so be careful copying... function(IMATH_DEFINE_LIBRARY libname) set(options) set(oneValueArgs PRIV_EXPORT CURDIR CURBINDIR) set(multiValueArgs SOURCES HEADERS DEPENDENCIES PRIVATE_DEPS) cmake_parse_arguments(IMATH_CURLIB "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) if (MSVC) set(_imath_extra_flags "/EHsc") endif() set(objlib ${libname}) add_library(${objlib} ${IMATH_CURLIB_HEADERS} ${IMATH_CURLIB_SOURCES}) # Use ${IMATH_CXX_STANDARD} to determine the standard we use to compile # Imath itself. But the headers only require C++11 features, so that's # all we need to pass on as interface reqirements to downstream projects. # For example, it's fine for an Imath built with C++14 to be called from # an app that is compiled with C++11; Imath needn't force the app to # also use C++14. target_compile_features(${objlib} PRIVATE cxx_std_${IMATH_CXX_STANDARD} INTERFACE cxx_std_11 ) if(IMATH_CURLIB_PRIV_EXPORT AND BUILD_SHARED_LIBS) target_compile_definitions(${objlib} PRIVATE ${IMATH_CURLIB_PRIV_EXPORT}) if(WIN32) target_compile_definitions(${objlib} PUBLIC IMATH_DLL) endif() endif() if(IMATH_CURLIB_CURDIR) target_include_directories(${objlib} INTERFACE $) endif() if(IMATH_CURLIB_CURBINDIR) target_include_directories(${objlib} PRIVATE $) endif() target_link_libraries(${objlib} PUBLIC ${PROJECT_NAME}::Config ${IMATH_CURLIB_DEPENDENCIES}) if(IMATH_CURLIB_PRIVATE_DEPS) target_link_libraries(${objlib} PRIVATE ${IMATH_CURLIB_PRIVATE_DEPS}) endif() set_target_properties(${objlib} PROPERTIES CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF POSITION_INDEPENDENT_CODE ON ) if (NOT IMATH_USE_DEFAULT_VISIBILITY) set_target_properties(${objlib} PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON ) else() target_compile_definitions(${objlib} PUBLIC IMATH_USE_DEFAULT_VISIBILITY) endif() if (_imath_extra_flags) target_compile_options(${objlib} PUBLIC ${_imath_extra_flags}) endif() set_property(TARGET ${objlib} PROPERTY PUBLIC_HEADER ${IMATH_CURLIB_HEADERS}) if(BUILD_SHARED_LIBS) set_target_properties(${libname} PROPERTIES SOVERSION ${IMATH_LIB_SOVERSION} VERSION ${IMATH_LIB_VERSION} ) endif() if(IMATH_EXTRA_LIBS) target_link_libraries(${libname} PUBLIC ${IMATH_EXTRA_LIBS}) endif() set_target_properties(${libname} PROPERTIES OUTPUT_NAME "${libname}${IMATH_LIB_SUFFIX}" RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" ) add_library(${PROJECT_NAME}::${libname} ALIAS ${libname}) install(TARGETS ${libname} EXPORT ${PROJECT_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${IMATH_OUTPUT_SUBDIR} ) if(BUILD_SHARED_LIBS AND (NOT "${IMATH_LIB_SUFFIX}" STREQUAL "") AND IMATH_INSTALL_SYM_LINK) string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE) set(verlibname ${CMAKE_SHARED_LIBRARY_PREFIX}${libname}${IMATH_LIB_SUFFIX}${CMAKE_${uppercase_CMAKE_BUILD_TYPE}_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}) set(baselibname ${CMAKE_SHARED_LIBRARY_PREFIX}${libname}${CMAKE_${uppercase_CMAKE_BUILD_TYPE}_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}) if(WIN32) install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E chdir \"\$ENV\{DESTDIR\}${CMAKE_INSTALL_FULL_BINDIR}\" ${CMAKE_COMMAND} -E create_symlink ${verlibname} ${baselibname})") install(CODE "message(STATUS \"Creating symlink ${CMAKE_INSTALL_FULL_BINDIR}/${baselibname} -> ${verlibname}\")") else() install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E chdir \"\$ENV\{DESTDIR\}${CMAKE_INSTALL_FULL_LIBDIR}\" ${CMAKE_COMMAND} -E create_symlink ${verlibname} ${baselibname})") install(CODE "message(STATUS \"Creating symlink ${CMAKE_INSTALL_FULL_LIBDIR}/${baselibname} -> ${verlibname}\")") endif() set(verlibname) set(baselibname) endif() endfunction() Imath-3.1.4/docs/000077500000000000000000000000001417213455000135135ustar00rootroot00000000000000Imath-3.1.4/docs/CMakeLists.txt000066400000000000000000000035671417213455000162660ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH}) find_package(Doxygen REQUIRED) find_package(Sphinx REQUIRED) set(DOXYGEN_INPUT_DIR ${PROJECT_SOURCE_DIR}/src/Imath) set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/doxygen) set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/html/index.html) set(DOXYFILE_IN ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in) set(DOXYFILE_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile) set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}) set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR}/sphinx) set(SPHINX_INDEX_FILE ${SPHINX_BUILD}/index.html) configure_file(${DOXYFILE_IN} ${DOXYFILE_OUT} @ONLY) file(MAKE_DIRECTORY ${DOXYGEN_OUTPUT_DIR}) add_custom_command(OUTPUT ${DOXYGEN_INDEX_FILE} COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYFILE_OUT} COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/fixmanpages.sh ${DOXYGEN_OUTPUT_DIR} MAIN_DEPENDENCY ${DOXYFILE_OUT} ${DOXYFILE_IN} COMMENT "Running doxygen" VERBATIM) add_custom_command(OUTPUT ${SPHINX_INDEX_FILE} COMMAND ${SPHINX_EXECUTABLE} -b html # Tell Breathe where to find the Doxygen output -Dbreathe_projects.Imath=${DOXYGEN_OUTPUT_DIR}/xml ${SPHINX_SOURCE} ${SPHINX_BUILD} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS ${DOXYGEN_INDEX_FILE} MAIN_DEPENDENCY conf.py COMMENT "Generating documentation with Sphinx") add_custom_target(docs ALL DEPENDS ${SPHINX_INDEX_FILE} ${DOXYGEN_INDEX_FILE}) # Add an install target to install the docs if(INSTALL_DOCS) include(GNUInstallDirs) install(DIRECTORY ${SPHINX_BUILD} DESTINATION ${CMAKE_INSTALL_DOCDIR}) endif() Imath-3.1.4/docs/Doxyfile.in000066400000000000000000000021751417213455000156330ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. PROJECT_NAME = "Imath" GENERATE_LATEX = NO GENERATE_MAN = NO GENERATE_RTF = NO CASE_SENSE_NAMES = NO INPUT = "@DOXYGEN_INPUT_DIR@" OUTPUT_DIRECTORY = "@DOXYGEN_OUTPUT_DIR@" RECURSIVE = YES QUIET = YES JAVADOC_AUTOBRIEF = YES GENERATE_HTML = NO GENERATE_XML = YES DISTRIBUTE_GROUP_DOC = YES MACRO_EXPANSION = YES ENABLE_PREPROCESSING = YES WARN_IF_UNDOCUMENTED = NO PREDEFINED = IMATH_CONSTEXPR14=constexpr \ IMATH_HOSTDEVICE= \ IMATH_INTERNAL_NAMESPACE=Imath \ IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER="namespace Imath {" \ IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT="}" \ IMATH_INTERNAL_NAMESPACE_HEADER_ENTER="namespace Imath {" \ IMATH_INTERNAL_NAMESPACE_HEADER_EXIT="}" \ IMATH_NOEXCEPT="noexcept" \ IMATH_EXPORT="" \ IMATH_EXPORT_ENUM= \ IMATH_EXPORT_TYPE= \ IMATH_EXPORT_TEMPLATE_TYPE= \ imath_half_bits_t=half \ __cplusplus=1 Imath-3.1.4/docs/Makefile000066400000000000000000000152361417213455000151620ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/ReadTheDocs-Breathe.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/ReadTheDocs-Breathe.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/ReadTheDocs-Breathe" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/ReadTheDocs-Breathe" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." Imath-3.1.4/docs/PortingGuide2-3.md000066400000000000000000000435401417213455000166650ustar00rootroot00000000000000# OpenEXR/Imath 2.x to 3.x Porting Guide This porting guide outlines the several areas where switching from OpenEXR 2.x to OpenEXR 3.x + Imath 3.x will require source code or build changes of downstream software. In each case, we will often explain both how to change if you are expecting 3.x only hereafter, or usually a more complex accommodation if you want to keep compatibility with both 2.x and 3.x. ## OpenEXR and Imath Are Different Packages If your use of OpenEXR was only for the sake of using the math classes and utilities, maybe you were unhappy that you needed to download and build the full OpenEXR dependency. You are in luck -- now Imath is a separate, very lightweight open source package. You can use Imath functionality without needing any of OpenEXR, which as of 3.x only includes the parts you need to read and write OpenEXR image files. The parts of "IlmBase" that were `Imath` and `half` are now repackaged as the `Imath` library. The `IlmThread` and `Iex` libraries have been folded into the OpenEXR package, since they were were not necessary to the rest of Imath. When building OpenEXR 3.x, note that if Imath 3.x library is not found already installed at build time, it will be automatically downloaded and built as part of the OpenEXR build. ## Background Why is this happening? Here is the relevant history. The OpenEXR project has historically consisted of four separate subprojects: * OpenEXR - the Imf image format * IlmBase - supporting utilities (Imath, Half, Iex, IlmThread) * PyIlmBase - python bindings for the IlmBase libraries * OpenEXR_Viewers - code for an example EXR image viewer Prior to the 2.4 release in 2019, OpenEXR relied primarily on the Gnu autotools build system and was released as four separate tarballs (ilmbase, pyilmbase, openexr, openexr_viewers) that were constructed via the Gnu tools. This gave direct access to the "IlmBase" libraries independent of the OpenEXR format library. The project also included CMake files but CMake support was incomplete. With the adoption of OpenEXR by the Academy Software Foundation in 2019, the technical steering committee made several key changes: 1. Drop support for autotools in favor of CMake. A significant portion of the OpenEXR user base uses Windows, which the Gnu autotools does not support. Supporting two build systems is a maintenance burden that the TSC opted to avoid. We now assume that all modern users of OpenEXR can reasonably be expected to rely on CMake. 2. Rely on GitHub's automatic release packaging mechanism. This packages the entire contents of package in a single tarball. Separate tarballs are no longer generated by the Gnu autotools setup. 3. Deprecate the OpenEXR_Viewers code. It was impossibly out of date and of little modern value. Thus, with the 2.4 release, the "IlmBase" libraries are no longer distributed in a form that is readily separable from the rest of OpenEXR. The build and installation process for the overall OpenEXR project is complicated by the fact it consists of four separate projects, which added signifcant complexity to the CMake setup. Because Imath is generally useful to the community, the TSC decided to simplify the configuration by separating Imath into its own independent project, maintained and released independently of OpenEXR, and introducing it as a new external dependency of OpenEXR. To further simplify matters, the new Imath library includes the half data type directly, rather than maintaining it in a separate library. Also, the community at large has a strong desire for simple vector/matrix utilities that are unencumbered by Iex, the IlmBase library that provides higher-level exception classes, and even further, a clear delineation between functionality that (1) relies on exception handlings and (2) is free from exceptions. As a result, support for Iex has been removed from Imath, and the Iex library is now packaged as a component of OpenEXR. The Imath python bindings are a part of Imath as a configuration option, although support is off by default to simplify the build process for most users. ## New Library Names and Repository Structures The new repositories place all source code under the `src` top-level subdirectory. ### Imath: src ├── Imath ├── ImathTest └── python ├── config ├── PyImath ├── PyImathNumpy ├── PyImathTest ├── PyImathNumpyTest └── PyImathSpeedTest ### OpenEXR: The 'IlmImf' library has been renamed 'OpenEXR'. No header files have changed names, only their locations in the repo have changes. src ├── bin │ ├── exr2aces │ ├── exrbuild │ ├── exrcheck │ ├── exrenvmap │ ├── exrheader │ ├── exrmakepreview │ ├── exrmaketiled │ ├── exrmultipart │ ├── exrmultiview │ └── exrstdattr ├── lib │ ├── Iex │ ├── IexMath │ ├── IlmThread │ ├── OpenEXR │ └── OpenEXRUtil ├── examples └── test ├── IexTest ├── OpenEXRTest ├── OpenEXRUtilTest └── OpenEXRFuzzTest ## Finding and Using OpenEXR and Imath CMake Configs ### OpenEXR/Imath 3.x only If you are *only* concerned with OpenEXR/Imath 3.x going forward, this is the recommended way to find the libraries in a downstream project that uses the CMake build system: find_package(Imath CONFIG) find_package(OpenEXR CONFIG) Note that the second line may be omitted if you only need the Imath portions. And then your project can reference the imported targets like this: target_link_libraries (my_target PRIVATE OpenEXR::OpenEXR Imath::Imath Imath::Half ) You only need the parts you use, so for example, if you only need Half and Imath, you can omit the OpenEXR target. Also note that in our example above, we have used the `PRIVATE` label, but you should specify them as `PUBLIC` if you are exposing those classes in your own package's public interface. ### Accommodating OpenEXR/Imath 3.x or OpenEXR 2.x On the other hand, to accommodate both 2.x and 3.x, it's admittedly inconvenient because the packages and the import targets have changed their names. We have found the following idioms to work: Finding either/both packages: # First, try to find just the right config files find_package(Imath CONFIG) if (NOT TARGET Imath::Imath) # Couldn't find Imath::Imath, maybe it's older and has IlmBase? find_package(IlmBase CONFIG) endif () find_package(OpenEXR CONFIG) To link against them, we use CMake generator expressions so that we can reference *both* sets of targets, but it will only use the ones corresponding to the package version that was found. target_link_libraries (my_target PRIVATE # For OpenEXR/Imath 3.x: $<$:OpenEXR::OpenEXR> $<$:Imath::Imath> $<$:Imath::Half> # For OpenEXR 2.4/2.5: $<$:OpenEXR::IlmImf> $<$:IlmBase::Imath> $<$:IlmBase::Half> $<$:IlmBase::IlmThread> $<$:IlmBase::Iex> ) Again, you can eliminate the references to any of the individual libaries that you don't actually need for your application. ### Simultaneous Static/Shared Build The OpenEXR 2.x CMake configuration had options to simultaneously build both shared and statically linked libraries. This has been deprecated. A CMake configuration setting specifies whether to build static or shared, but if you want both, you will need to run cmake and build twice. ### Simultaneous Python 2/3 Build The PyIlmBase 2.x CMake configuration had options to simultaneously build both python2 and python3 bindings. This has been deprecated. A CMake configuration setting specifies whether to build for python 2 or python 3, but if you want both, you will need to run cmake and build twice. ## Imath Include Files Are in a Different Subdirectory Imath 3.0 will copy its headers to some `include/Imath` subdirectory instead of the old `include/OpenEXR`. ### OpenEXR/Imath 3.x only If you know that you are only using Imath 3.x, then just change any include directions, like this: #include #include to the new locations: #include #include ### Accommodating OpenEXR/Imath 3.x or OpenEXR 2.x If you want your software to be able to build against either OpenEXR 2.x or 3.x (depending on which dependency is available at build time), we recommend using a more complicated idiom: // The version can reliably be found in this header file from OpenEXR, // for both 2.x and 3.x: #include #define COMBINED_OPENEXR_VERSION ((10000*OPENEXR_VERSION_MAJOR) + \ (100*OPENEXR_VERSION_MINOR) + \ OPENEXR_VERSION_PATCH) // There's just no easy way to have an `#include` that works in both // cases, so we use the version to switch which set of include files we // use. #if COMBINED_OPENEXR_VERSION >= 20599 /* 2.5.99: pre-3.0 */ # include # include #else // OpenEXR 2.x, use the old locations # include # include #endif ## Include Files Include Fewer Other Headers Extraneous ``#include`` statements have been removed from some header files, which can lead to compile failures in application code that previously included certain headers indirectly. For example, the Imath header files no longer include ``float.h``, so application code that references symbols such as ``FLT_MAX`` may need to add an explicit ``#include `` or equivalent. If your application code reports compile errors due to undefined or incompletely-defined Imath or OpenEXR data types, locate the Imath or OpenEXR header file that defines the type and include it explicitly. ## Symbols Are Hidden by Default To reduce library size and make linkage behavior similar across platforms, Imath and OpenEXR now build with directives that make symbol visibility hidden by default, with specific externally-visible symbols explicitly marked for export. See the [Symbol Visibility](https://github.com/AcademySoftwareFoundation/openexr/blob/master/docs/SymbolVisibility.md) doc and the appropriate ``*Export.h`` header file for more details. ## Imath Now Uses Standard C++ Exceptions and `noexcept` In OpenEXR 2.x, the Imath functions that threw exceptions used to throw various Iex varieties. In Imath 3.x, these functions just throw `std::exception` varieties that correspond to the failure (e.g., `std::invalid_argument`, `std::domain_error`, etc.). For that reason, all of the Iex exceptions are now only part of the OpenEXR library (where they are still used in the same manner they were for OpenEXR 2.x). Imath 3.x has very few functions that throw exceptions. Each is clearly marked as such, and each has a version that does not throw exceptions (so that it may be used from code where exceptions are avoided). The functions that do not throw exceptions are now marked `noexcept`. ## Some Headers and Classes Have Been Removed from Imath 3.x * The `Math` class (and `ImathMath.h` header file) are deprecated. All of the `Math` functionality is subsumed by C++11 `std::` math functions. For example, calls to `Imath::Math::abs(x)` should be replaced with `std::abs(x)`. * The `Limits` class (and the `ImathLimits.h` and `ImathHalfLimits.h` headers) have been removed entirely. All uses of `Limits<>` should be replaced with the appropriate `std::numeric_limits<>` method call. The Imath-specific versions predated C++11, and were not only redundant in a C++11 world, but also potentially confusing because some of their functions behaved quite differently than the `std::numeric_limits` method with the same name. We are following the precept that if C++11 does something in a standard way, we should not define our own equivalent function (and especially not define it in a way that doesn't match the standard behavior). * `Vec::normalize()` and `length()` methods, for integer `T` types, have been removed. Also the standalone `project()` and `orthogonal()` functions are no longer defined for vectors made of integer elements. These all had behavior that was hard to understand and probably useless. They still work as expected for vectors of floating-point types. * The ``Int64`` and ``SInt64`` types are deprecated in favor of the now-standard ``int64_t`` and ``uint64_t``. ## File/Class-specific changes: ### `half` in half.h * The half type is now in the `Imath` namespace, but a compile-time option puts it in the global namespace, except when compiling for CUDA, in which case the 'half' type refers to the CUDA type: #ifndef __CUDACC__ using half = IMATH_INTERNAL_NAMESPACE::half; #else #include #endif If you desire to use Imath::half inside a CUDA kernal, you can refer to it via the namespace, or define `CUDA_NO_HALF` to avoid the CUDA type altogether. * `HALF_MIN` has changed value. It is now the smallest **normalized** positive value, returned by `std::numeric_limits::min()`. * New constructor from a bit pattern: enum FromBitsTag { FromBits }; constexpr half(FromBitsTag, unsigned short bits) noexcept; ### `Imath::Box` in ImathBox.h * `baseTypeMin()` is replaced with `baseTypeLowest()` ### `Color3`, `Color4` in ImathColor.h * `baseTypeMin()` is replaced with `baseTypeLowest()` ### `Imath::Frustum` in ImathFrustum.h Akin to the `Vec` classes, there are now seperate API calls for throwing and non-throwing functions: These functions previously threw exceptions but now do not throw and are marked `noexcept`: * `Frustum::projectionMatrix() noexcept` * `Frustum::aspect() noexcept` * `Frustum::set() noexcept` * `Frustum::projectPointToScreen() noexcept` * `Frustum::ZToDepth() noexcept` * `Frustum::DepthToZ() noexcept` * `Frustum::screenRadius() noexcept` * `Frustum::localToScreen() noexcept` These functions throw `std::domain_error` exceptions when the associated frustum is degenerate: * `Frustum::projectionMatrixExc()` * `Frustum::aspectExc()` * `Frustum::setExc()` * `Frustum::projectPointToScreenExc()` * `Frustum::ZToDepthExc()` * `Frustum::DepthToZExc()` * `Frustum::screenRadiusExc()` * `Frustum::localToScreenExc()` ### `Imath::Interval` in ImathInterval.h New methods/functions: * `Interval::operator !=` * `Interval::makeInfinite()` * `IntervalisInfinite()` * `operator<< (std::ostream& s, const Interval&)` ### ImathMatrixAlgo.h * `checkForZeroScaleInRow()` and `extractAndRemoveScalingAndShear()` throw `std::domain_error` exceptions instead of `Iex::ZeroScale` ### `Matrix22`, `Matrix33`, `Matrix44` in ImathMatrix.h * `baseTypeMin()` is replaced with `baseTypeLowest()` * `invert(bool singExc = false)` is replace by: - `invert() noexcept` - `invert(bool)` which optionally throws an `std::invalid_argument` exception. * `inverse(bool singExc = false)` is replace by: - `inverse() noexcept` - `inverse(bool)` which optionally throws an `std::invalid_argument` exception. * `gjInvert(bool singExc = false)` is replace by: - `gjInvert()` noexcept - `gjInvert(bool)` which optionally throws an `std::invalid_argument` exception. * `gJinverse(bool singExc = false)` is replace by: - `gjInverse()` noexcept - `gjInverse(bool)` which optionally throws an `std::invalid_argument` exception. New functions: * `operator<< (std::ostream& s, const Matrix22&)` * `operator<< (std::ostream& s, const Matrix33&)` * `operator<< (std::ostream& s, const Matrix44&)` Other changes: * Initialization loops unrolled for efficiency * inline added where appropriate ### ImathRoots.h * When compiling for CUDA, the `complex` type comes from `thrust` rather than `std` ### `Shear6` in ImathShear.h * `baseTypeMin()` is replaced with `baseTypeLowest()` ### ImathVecAlgo.h The following functions are no longer defined for integer-based vectors, because such behavior is not clearly defined: * `project (const Vec& s, const Vec& t)` * `orgthogonal (const Vec& s, const Vec& t)` * `reflect (const Vec& s, const Vec& t)` ### `Vec2`, `Vec3`, `Vec4` in ImathVec.h * `baseTypeMin()` is replaced with `baseTypeLowest()` * The following methods are removed (via `= delete`) for integer-based vectors because the behavior is not clearly defined and thus prone to confusion: - `length()` - although the length is indeed defined, its proper value is floating point and can thus not be represented by the 'T' return type. - `normalize()` - `normalizeExc()` - `normalizeNonNull()` - `normalized()` - `normalizedExc()` - `normalizedNonNull()` * Interoperability Constructors: The Vec and Matrix classes now have constructors that take as an argument any data object of similar size and layout. ## Python Changes: In general, the changes at the C++ level are reflected in the python bindings. In particular: * The following methods are removed for integer-based vector and matrix objects and arrays: - `length()` - `normalize()` - `normalizeExc()` - `normalizeNonNull()` - `normalized()` - `normalizedExc()` - `normalizedNonNull()` * `baseTypeMin()` is replaced with `baseTypeLowest()` for: - `Vec2`, `Vec3`, `Vec4` - `Color3`, `Color4` - `Matrix22`, `Matrix33`, `Matrix44` - `Box` - `Shear6` Imath-3.1.4/docs/classes/000077500000000000000000000000001417213455000151505ustar00rootroot00000000000000Imath-3.1.4/docs/classes/Box.rst000066400000000000000000000021421417213455000164310ustar00rootroot00000000000000Box ### .. code-block:: #include The ``Box`` class template represents 2D and 3D axis-aligned bounding boxes, with predefined typedefs for boxes of type ``short``, ``int``, ``int64_t``, ``float``, and ``double``. The box is defined by minimum and maximum values along each axis, represented by ``Vec2`` for the ``Box2`` types and by ``Vec3`` for ``Box3`` types. There are also various utility functions that operate on bounding boxes defined in ``ImathBoxAlgo.h`` and described in :ref:`Box Functions `. Example: .. literalinclude:: ../examples/Box.cpp :language: c++ .. doxygentypedef:: Box2s .. doxygentypedef:: Box2i .. doxygentypedef:: Box2i64 .. doxygentypedef:: Box2f .. doxygentypedef:: Box2d .. doxygentypedef:: Box3s .. doxygentypedef:: Box3i .. doxygentypedef:: Box3i64 .. doxygentypedef:: Box3f .. doxygentypedef:: Box3d .. doxygenclass:: Imath::Box :undoc-members: :members: .. doxygenclass:: Imath::Box< Vec2< T > > :undoc-members: :members: .. doxygenclass:: Imath::Box< Vec3< T > > :undoc-members: :members: Imath-3.1.4/docs/classes/Color3.rst000066400000000000000000000015071417213455000170460ustar00rootroot00000000000000Color3 ###### .. code-block:: #include The ``Color3`` class template represents a 3-component color, with pre-defined typedefs of ``unsigned char``, ``half``, and ``float``. The ``Color3`` class inherits from ``Vec3`` and thus has fields named ``x``, ``y``, and ``z``. The class itself implies no specific interpretation of the values. There are also various utility functions that operate on colors defined in ``ImathColorAlgo.h`` and described in :ref:`Color Functions `. Example: .. literalinclude:: ../examples/Color3.cpp :language: c++ .. doxygentypedef:: Color3c .. doxygentypedef:: Color3h .. doxygentypedef:: Color3f .. doxygentypedef:: C3c .. doxygentypedef:: C3h .. doxygentypedef:: C3f .. doxygenclass:: Imath::Color3 :undoc-members: :members: Imath-3.1.4/docs/classes/Color4.rst000066400000000000000000000017001417213455000170420ustar00rootroot00000000000000Color4 ###### .. code-block:: #include The ``Color4`` class template represents a 4-component color (red, green, blue, and alpha), with pre-defined typedefs of ``unsigned char``, ``half``, and ``float``. The ``Color4`` class is *not* derived from ``Vec4``. Its fields are named ``r``, ``g``, ``b``, and ``a``. The class itself implies no specific interpretation of the values. There are also various utility functions that operate on colors defined in ``ImathColorAlgo.h`` and described in :ref:`Color Functions `. Example: .. literalinclude:: ../examples/Color4.cpp :language: c++ .. doxygentypedef:: Color4c .. doxygentypedef:: Color4h .. doxygentypedef:: Color4f .. doxygentypedef:: C4c .. doxygentypedef:: C4h .. doxygentypedef:: C4f .. doxygenclass:: Imath::Color4 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Color4& v) Imath-3.1.4/docs/classes/Euler.rst000066400000000000000000000013551417213455000167620ustar00rootroot00000000000000Euler ##### .. code-block:: #include The ``Euler`` class template represents an euler angle rotation/orientation, with predefined typedefs of type ``float`` and ``double``. The ``Euler`` class is derived from ``Imath::Vec3`` and thus has fields named ``x``, ``y``, and ``z``, which correspond to the first, second, and third rotation angles in a specified order, which, depending on the order, may not correspond directly to x, y, or z rotations. Example: .. literalinclude:: ../examples/Euler.cpp :language: c++ .. doxygentypedef:: Eulerf .. doxygentypedef:: Eulerd .. doxygenclass:: Imath::Euler :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& o, const Euler& euler) Imath-3.1.4/docs/classes/Frustum.rst000066400000000000000000000006601417213455000173510ustar00rootroot00000000000000Frustum ####### .. code-block:: #include The ``Frustum`` class template represents a 3D viewing frustum, with predefined typedefs of type ``float`` and ``double``. Example: .. literalinclude:: ../examples/Frustum.cpp :language: c++ .. doxygentypedef:: Frustumf .. doxygentypedef:: Frustumd .. doxygenclass:: Imath::Frustum :undoc-members: :members: Imath-3.1.4/docs/classes/Interval.rst000066400000000000000000000012161417213455000174660ustar00rootroot00000000000000Interval ######## .. code-block:: #include The ``Interval`` class template represents a scalar interval, with predefined typedefs for ``short``, ``int``, ``float``, and ``double``. An ``Interval`` is essentially a ``Box`` that allows ``T`` to be a scalar. Example: .. literalinclude:: ../examples/Interval.cpp :language: c++ .. doxygentypedef:: Intervals .. doxygentypedef:: Intervali .. doxygentypedef:: Intervalf .. doxygentypedef:: Intervald .. doxygenclass:: Imath::Interval :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Interval& v) Imath-3.1.4/docs/classes/Line3.rst000066400000000000000000000012111417213455000166470ustar00rootroot00000000000000Line3 ##### .. code-block:: #include The ``Line3`` class template represents a line in 3D space, with predefined typedefs for lines of type ``float`` and ``double``. There are also various utility functions that operate on ``Line3`` objects defined in ``ImathLineAlgo.h`` and described in :ref:`Line Functions `. Example: .. literalinclude:: ../examples/Line3.cpp :language: c++ .. doxygentypedef:: Line3f .. doxygentypedef:: Line3d .. doxygenclass:: Imath::Line3 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Line3& line) Imath-3.1.4/docs/classes/Matrix22.rst000066400000000000000000000021521417213455000173120ustar00rootroot00000000000000Matrix22 ######## .. code-block:: #include The ``Matrix22`` class template represents a 2x2 matrix, with predefined typedefs for ``float`` and ``double``. There are also various utility functions that operate on matrices defined in ``ImathMatrixAlgo.h`` and described in :ref:`Matrix Functions `. Individual components of a matrix ``M`` may be referenced as either ``M[j][i]`` or ``M.x[j][i]``. While the latter is a little awkward, it has an advantage when used in loops that may be auto-vectorized or explicitly vectorized by ``#pragma omp simd`` or other such hints, because the function call and pointer casting of ``operator[]`` can confuse the compiler just enough to prevent vectorization of the loop, whereas directly addressing the real underlying array (``M.x[j][i]``) does not. Example: .. literalinclude:: ../examples/Matrix22.cpp :language: c++ .. doxygentypedef:: M22f .. doxygentypedef:: M22d .. doxygenclass:: Imath::Matrix22 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Matrix22& m) Imath-3.1.4/docs/classes/Matrix33.rst000066400000000000000000000021431417213455000173140ustar00rootroot00000000000000Matrix33 ######## .. code-block:: #include The ``Matrix33`` class template represents a 3x3 matrix, with predefined typedefs for ``float`` and ``double``. There are also various utility functions that operate on matrices defined in ``ImathMatrixAlgo.h`` and described in :ref:`Matrix Functions `. Individual components of a matrix ``M`` may be referenced as either ``M[j][i]`` or ``M.x[j][i]``. While the latter is a little awkward, it has an advantage when used in loops that may be auto-vectorized or explicitly vectorized by ``#pragma omp simd`` or other such hints, because the function call and pointer casting of ``operator[]`` can confuse the compiler just enough to prevent vectorization of the loop, whereas directly addressing the real underlying array (``M.x[j][i]``) does not. Example: .. literalinclude:: ../examples/Matrix33.cpp :language: c++ .. doxygentypedef:: M33f .. doxygentypedef:: M33d .. doxygenclass:: Imath::Matrix33 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Matrix33& m) Imath-3.1.4/docs/classes/Matrix44.rst000066400000000000000000000021471417213455000173220ustar00rootroot00000000000000Matrix44 ######## .. code-block:: #include The ``Matrix44`` class template represents a 4x4 matrix, with predefined typedefs for ``float`` and ``double``. There are also various utility functions that operate on matrices defined in ``ImathMatrixAlgo.h`` and described in :ref:`Matrix Functions `. Individual components of a matrix ``M`` may be referenced as either ``M[j][i]`` or ``M.x[j][i]``. While the latter is a little awkward, it has an advantage when used in loops that may be auto-vectorized or explicitly vectorized by ``#pragma omp simd`` or other such hints, because the function call and pointer casting of ``operator[]`` can confuse the compiler just enough to prevent vectorization of the loop, whereas directly addressing the real underlying array (``M.x[j][i]``) does not. Example: .. literalinclude:: ../examples/Matrix44.cpp :language: c++ .. doxygentypedef:: M44f .. doxygentypedef:: M44d .. doxygenclass:: Imath::Matrix44 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Matrix44& m) Imath-3.1.4/docs/classes/Plane3.rst000066400000000000000000000007541417213455000170320ustar00rootroot00000000000000Plane3 ###### .. code-block:: #include The ``Plane3`` class template represents a plane in 3D space, with predefined typedefs for planes of type ``float`` and ``double``. Example: .. literalinclude:: ../examples/Plane3.cpp :language: c++ .. doxygentypedef:: Plane3f .. doxygentypedef:: Plane3d .. doxygenclass:: Imath::Plane3 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Plane3& plane) Imath-3.1.4/docs/classes/Quat.rst000066400000000000000000000006711417213455000166200ustar00rootroot00000000000000Quat #### .. code-block:: #include The ``Quat`` class template represents a quaterion rotation/orientation, with predefined typedefs for ``float`` and ``double``. Example: .. literalinclude:: ../examples/Quat.cpp :language: c++ .. doxygentypedef:: Quatf .. doxygenclass:: Imath::Quat :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Quat& q) Imath-3.1.4/docs/classes/Rand32.rst000066400000000000000000000004331417213455000167330ustar00rootroot00000000000000Rand32 ###### .. code-block:: #include The ``Rand32`` class is a fast pseudo-random number generator that generates a uniformly distributed sequence with a period length of :math:`2^32`. .. doxygenclass:: Imath::Rand32 :undoc-members: :members: Imath-3.1.4/docs/classes/Rand48.rst000066400000000000000000000004761417213455000167510ustar00rootroot00000000000000Rand48 ###### .. code-block:: #include The ``Rand48`` class is a fast pseudo-random number generator based on the C Standard Library functions erand48(), nrand48() & company. It generates a uniformly distributed sequence. .. doxygenclass:: Imath::Rand48 :undoc-members: :members: Imath-3.1.4/docs/classes/Shear6.rst000066400000000000000000000007001417213455000170270ustar00rootroot00000000000000Shear6 ###### .. code-block:: #include The ``Shear6`` class template represent a 3D shear transformation, with predefined typedefs for ``float`` and ``double``. Example: .. literalinclude:: ../examples/Shear6.cpp :language: c++ .. doxygentypedef:: Shear6f .. doxygenclass:: Imath::Shear6 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Shear6& h) Imath-3.1.4/docs/classes/Sphere3.rst000066400000000000000000000006041417213455000172130ustar00rootroot00000000000000Sphere3 ####### .. code-block:: #include The ``Sphere3`` class template represents a sphere in 3D space, with predefined typedefs for lines of type ``float`` and ``double``. Example: .. literalinclude:: ../examples/Sphere3.cpp :language: c++ .. doxygentypedef:: Sphere3f .. doxygenclass:: Imath::Sphere3 :undoc-members: :members: Imath-3.1.4/docs/classes/Vec2.rst000066400000000000000000000034031417213455000165010ustar00rootroot00000000000000Vec2 #### .. code-block:: #include The ``Vec2`` class template represents a 2D vector, with predefined typedefs for vectors of type ``short``, ``int``, ``int64_t``, ``float``, and ``double``. Note that the integer specializations of ``Vec2`` lack the ``length()`` and ``normalize()`` methods that are present in the ``float`` and ``double`` versions, because the results don't fit into integer quantities. There are also various utility functions that operate on vectors defined in ``ImathVecAlgo.h`` and described in :ref:`Vector Functions `. Individual components of a vector ``V`` may be referenced as either ``V[i]`` or ``V.x``, ``V.y``. Obviously, the ``[]`` notation is more suited to looping over components, or in cases where a variable determines which coordinate is needed. However, when the coordinate is known, it can be more efficient to directly address the components, such as ``V.y`` rather than ``V[1]``. While both appear to do the same thing (and indeed do generate the same machine operations for ordinary scalar code), when used inside loops that you hope to parallelize (either through compiler auto-vectorization or explicit hints such as ``#pragma omp simd``), the function call and pointer casting of ``operator[]`` can confuse the compiler just enough to prevent vectorization of the loop. Example: .. literalinclude:: ../examples/Vec2.cpp :language: c++ .. doxygentypedef:: V2s .. doxygentypedef:: V2i .. doxygentypedef:: V2i64 .. doxygentypedef:: V2f .. doxygentypedef:: V2d .. doxygenclass:: Imath::Vec2 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Vec2& v) Imath-3.1.4/docs/classes/Vec3.rst000066400000000000000000000034141417213455000165040ustar00rootroot00000000000000Vec3 #### .. code-block:: #include The ``Vec3`` class template represents a 3D vector, with predefined typedefs for vectors of type ``short``, ``int``, ``int64_t``, ``float``, and ``double``. Note that the integer specializations of ``Vec3`` lack the ``length()`` and ``normalize()`` methods that are present in the ``float`` and ``double`` versions, because the results don't fit into integer quantities. There are also various utility functions that operate on vectors defined in ``ImathVecAlgo.h`` and described in :ref:`Vector Functions `. Individual components of a vector ``V`` may be referenced as either ``V[i]`` or ``V.x``, ``V.y``, ``V.z``. Obviously, the ``[]`` notation is more suited to looping over components, or in cases where a variable determines which coordinate is needed. However, when the coordinate is known, it can be more efficient to directly address the components, such as ``V.y`` rather than ``V[1]``. While both appear to do the same thing (and indeed do generate the same machine operations for ordinary scalar code), when used inside loops that you hope to parallelize (either through compiler auto-vectorization or explicit hints such as ``#pragma omp simd``), the function call and pointer casting of ``operator[]`` can confuse the compiler just enough to prevent vectorization of the loop. Example: .. literalinclude:: ../examples/Vec3.cpp :language: c++ .. doxygentypedef:: V3s .. doxygentypedef:: V3i .. doxygentypedef:: V3i64 .. doxygentypedef:: V3f .. doxygentypedef:: V3d .. doxygenclass:: Imath::Vec3 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Vec3& v) Imath-3.1.4/docs/classes/Vec4.rst000066400000000000000000000034241417213455000165060ustar00rootroot00000000000000Vec4 #### .. code-block:: #include The ``Vec4`` class template represents a 4D vector, with predefined typedefs for vectors of type ``short``, ``int``, ``int64_t``, ``float``, and ``double``. Note that the integer specializations of ``Vec4`` lack the ``length()`` and ``normalize()`` methods that are present in the ``float`` and ``double`` versions, because the results don't fit into integer quantities. There are also various utility functions that operate on vectors defined in ``ImathVecAlgo.h`` and described in :ref:`Vector Functions `. Individual components of a vector ``V`` may be referenced as either ``V[i]`` or ``V.x``, ``V.y``, ``V.z``, ``V.w``. Obviously, the ``[]`` notation is more suited to looping over components, or in cases where a variable determines which coordinate is needed. However, when the coordinate is known, it can be more efficient to directly address the components, such as ``V.y`` rather than ``V[1]``. While both appear to do the same thing (and indeed do generate the same machine operations for ordinary scalar code), when used inside loops that you hope to parallelize (either through compiler auto-vectorization or explicit hints such as ``#pragma omp simd``), the function call and pointer casting of ``operator[]`` can confuse the compiler just enough to prevent vectorization of the loop. Example: .. literalinclude:: ../examples/Vec4.cpp :language: c++ .. doxygentypedef:: V4s .. doxygentypedef:: V4i .. doxygentypedef:: V4i64 .. doxygentypedef:: V4f .. doxygentypedef:: V4d .. doxygenclass:: Imath::Vec4 :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& s, const Vec4& v) Imath-3.1.4/docs/classes/half.rst000066400000000000000000000013051417213455000166130ustar00rootroot00000000000000The half Class ############## .. code-block:: #include ``half`` is a 16-bit floating point number. See :doc:`../float` for an explanation of the representation. See :doc:`../functions/half_c` for C-language functions for conversion between ``half`` and ``float``. Also, see :doc:`../half_conversion` for information about building Imath with support for the F16C SSE instruction set. Example: .. literalinclude:: ../examples/half.cpp :language: c++ .. doxygenclass:: Imath::half :undoc-members: :members: .. doxygenfunction:: operator<<(std::ostream& os, Imath::half h) .. doxygenfunction:: operator>>(std::ostream& is, Imath::half& h) Imath-3.1.4/docs/conf.py000066400000000000000000000223231417213455000150140ustar00rootroot00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # ReadTheDocs-Breathe documentation build configuration file, created by # sphinx-quickstart on Mon Feb 10 20:03:57 2014. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # hack for readthedocs to cause it to run doxygen first # https://github.com/rtfd/readthedocs.org/issues/388 on_rtd = os.environ.get('READTHEDOCS', None) == 'True' if on_rtd: with open("Doxyfile.in", "r") as file: filedata = file.read() doxygen_output_dir = "_build" filedata = filedata.replace('@DOXYGEN_INPUT_DIR@', "../src/Imath") filedata = filedata.replace('@DOXYGEN_OUTPUT_DIR@', "doxygen") with open("Doxyfile", "w") as file: file.write(filedata) from subprocess import call call('doxygen') # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.viewcode', 'breathe', ] # Breathe extension variables breathe_projects = { "Imath": "doxygen/xml" } breathe_default_project = "Imath" # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'Imath' copyright = '2021, Contributors to the OpenEXR Project' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # project_Imath_VERSION = "project(Imath VERSION " release = None for l in open ("../CMakeLists.txt"): if l.startswith (project_Imath_VERSION): release = l.split (' ')[2] break if release == None: print ("Error in conf.py: can't find Imath VERSION in ../CMakeList.txt") exit(-1) v = release.split('.') # The short X.Y version. version = "%s.%s" % (v[0], v[1]) # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. #html_theme = 'agogo' #html_theme = 'default' # good #html_theme = 'nature' # too green html_theme = 'bizstyle' # OK #html_theme = 'sphinxdoc' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = "Imath Documentation" # A shorter title for the navigation bar. Default is the same as html_title. html_short_title = "Imath" # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = "images/imath-logo-blue.png" # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". #html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'Imath' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ('index', 'Imath.tex', 'Imath Documentation', 'Contributors to the OpenEXR Project', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'imath', 'Imath Documentation', ['Contributors to the OpenEXR Project'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'Imath', 'Imath Documentation', 'Contributors to the OpenEXR Project', 'Imath', '2D and 3D vectors and matrices, half 16-bit floating-point type', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False Imath-3.1.4/docs/examples/000077500000000000000000000000001417213455000153315ustar00rootroot00000000000000Imath-3.1.4/docs/examples/Box.cpp000066400000000000000000000010371417213455000165660ustar00rootroot00000000000000#include void box_example() { Imath::V3f a (0, 0, 0); Imath::V3f b (1, 1, 1); Imath::V3f c (2, 9, 2); Imath::Box3f box (a); assert (box.isEmpty()); assert (!box.isInfinite()); assert (!box.hasVolume()); box.extendBy (c); assert (box.size() == (c-a)); assert (box.intersects (b)); assert (box.max[0] > box.min[0]); assert (box.max[1] > box.min[1]); assert (box.max[2] > box.min[2]); assert (box.hasVolume()); assert (box.majorAxis() == 1); } Imath-3.1.4/docs/examples/CMakeLists.txt000066400000000000000000000007501417213455000200730ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. cmake_minimum_required(VERSION 3.10) project(imath-examples) find_package(Imath) add_executable(imath-examples main.cpp Color3.cpp Color4.cpp Euler.cpp Frustum.cpp Interval.cpp Line3.cpp Matrix22.cpp Matrix33.cpp Matrix44.cpp Plane3.cpp Quat.cpp Shear6.cpp Sphere3.cpp Vec2.cpp Vec3.cpp Vec4.cpp half.cpp ) target_link_libraries(imath-examples Imath::Imath) Imath-3.1.4/docs/examples/Color3.cpp000066400000000000000000000004121417213455000171730ustar00rootroot00000000000000#include void color3_example() { Imath::C3c r (255, 0, 0); Imath::C3c g (0, 255, 0); Imath::C3c b (0, 0, 255); Imath::C3c c = r + g + b; assert (c.x == 255); assert (c.x == 255); assert (c.x == 255); } Imath-3.1.4/docs/examples/Color4.cpp000066400000000000000000000005161417213455000172010ustar00rootroot00000000000000#include void color4_example() { Imath::C4f r (1.0f, 0.0f, 0.0f, 1.0f); Imath::C4f g (0.0f, 1.0f, 0.0f, 1.0f); Imath::C4f b (0.0f, 0.0f, 1.0f, 1.0f); Imath::C4f w = r + g + b; assert (w.r == 1.0f); assert (w.g == 1.0f); assert (w.b == 1.0f); assert (w.a == 3.0f); } Imath-3.1.4/docs/examples/Euler.cpp000066400000000000000000000010731417213455000171120ustar00rootroot00000000000000#include #include void euler_example() { int i, j, k; Imath::Eulerf xyz (Imath::Eulerf::XYZ); xyz.angleOrder (i, j, k); assert (i == 0 && j == 1 && k == 2); Imath::Eulerf xzy (Imath::Eulerf::XZY); xzy.angleOrder (i, j, k); assert (i == 0 && j == 2 && k == 1); Imath::Eulerf e1 (0.0f, 0.0f, 0.1f + 2 * M_PI); Imath::Eulerf e2 (0.0f, 0.0f, 0.1f); e1.makeNear (e2); Imath::V3f v = e2.toXYZVector(); assert (v.equalWithAbsError (Imath::V3f (0.0f, 0.0f, 0.1f), 0.00001f)); } Imath-3.1.4/docs/examples/Frustum.cpp000066400000000000000000000007631417213455000175100ustar00rootroot00000000000000#include void frustum_example() { float near = 1.7f; float far = 567.0f; float left = -3.5f; float right = 2.0f; float top = 0.9f; float bottom = -1.3f; Imath::Frustumf frustum (near, far, left, right, top, bottom, false); Imath::M44f m = frustum.projectionMatrix(); Imath::V3f p (1.0f, 1.0f, 1.0f); Imath::V2f s = frustum.projectPointToScreen (p); assert (s.equalWithAbsError (Imath::V2f (-0.345455f, -1.36364f), 0.0001f)); } Imath-3.1.4/docs/examples/Interval.cpp000066400000000000000000000004711417213455000176230ustar00rootroot00000000000000#include void interval_example() { Imath::Intervalf v; assert (v.isEmpty()); assert (!v.hasVolume()); assert (!v.isInfinite()); v.extendBy (1.0f); assert (!v.isEmpty()); v.extendBy (2.0f); assert (v.hasVolume()); assert (v.intersects (1.5f)); } Imath-3.1.4/docs/examples/Line3.cpp000066400000000000000000000010461417213455000170100ustar00rootroot00000000000000#include void line3_example() { Imath::V3f a (0.0f, 0.0f, 0.0f); Imath::V3f b (1.0f, 1.0f, 1.0f); Imath::Line3f line (a, b); assert (line.pos == a); assert (line.dir == (b-a).normalized()); Imath::V3f c (0.5f, 0.5f, 0.5f); float f = line.distanceTo (c); assert (Imath::equalWithAbsError (f, 0.0f, 0.0001f)); Imath::V3f p = line (0.5f); // midpoint, i.e. 0.5 units from a along (b-a) assert (p.equalWithAbsError (Imath::V3f (0.288675f, 0.288675f, 0.288675f), 0.0001f)); } Imath-3.1.4/docs/examples/Matrix22.cpp000066400000000000000000000010041417213455000174400ustar00rootroot00000000000000#include #include void matrix22_example() { Imath::M22f M (Imath::UNINITIALIZED); // uninitialized M.makeIdentity(); assert (M[0][0] == 1.0f); assert (M[0][1] == 0.0f); Imath::M22f Minv = M.inverse(); Imath::M22f R; assert (R == Imath::identity22f); R.rotate (M_PI/4); M = R * M; Imath::V2f v2 (1.0f, 0.0f); Imath::V2f r2 = v2 * M; assert (r2.equalWithAbsError (Imath::V2f (0.707107f, 0.707107f), 1e-6f)); } Imath-3.1.4/docs/examples/Matrix33.cpp000066400000000000000000000010211417213455000174410ustar00rootroot00000000000000#include #include void matrix33_example() { Imath::M33f M (Imath::UNINITIALIZED); // uninitialized M.makeIdentity(); assert (M[0][0] == 1.0f); assert (M[0][1] == 0.0f); Imath::M33f Minv = M.inverse(); Imath::M33f R; assert (R == Imath::identity33f); R.rotate (M_PI/4); M = R * M; Imath::V3f v3 (1.0f, 0.0f, 0.0f); Imath::V3f r3 = v3 * M; assert (r3.equalWithAbsError (Imath::V3f (0.707107f, 0.7071070f, 0.0f), 1e-6f)); } Imath-3.1.4/docs/examples/Matrix44.cpp000066400000000000000000000013211417213455000174460ustar00rootroot00000000000000#include #include void matrix44_example() { Imath::M44f M (Imath::UNINITIALIZED); // uninitialized M.makeIdentity(); assert (M[0][0] == 1.0f); assert (M[0][1] == 0.0f); Imath::M44f Minv = M.inverse(); Imath::M44f R; assert (R == Imath::identity44f); R.rotate (Imath::V3f (0.02f, M_PI/4, 0.0f)); M = R * M; Imath::V3f v3 (1.0f, 0.0f, 0.0f); Imath::V4f v4 (1.0f, 0.0f, 0.0f, 1.0f); Imath::V3f r3 = v3 * M; assert (r3.equalWithAbsError (Imath::V3f (0.707107f, 0.0f, -0.7071070f), 1e-6f)); Imath::V4f r4 = v4 * M; assert (r4.equalWithAbsError (Imath::V4f (0.707107f, 0.0f, -0.7071070f, 1.0f), 1e-6f)); } Imath-3.1.4/docs/examples/Plane3.cpp000066400000000000000000000006441417213455000171630ustar00rootroot00000000000000#include void plane3_example() { Imath::V3f a (1.0f, 0.0f, 0.0f); Imath::V3f b (0.0f, 1.0f, 0.0f); Imath::V3f c (0.0f, 0.0f, 1.0f); Imath::Plane3f p (a, b, c); Imath::V3f n (1.0f, 1.0f, 1.0f); n.normalize(); assert (p.normal == n); Imath::V3f o (0.0f, 0.0f, 0.0f); float d = p.distanceTo (o); assert (Imath::equalWithAbsError (d, -0.57735f, 1e-6f)); } Imath-3.1.4/docs/examples/Quat.cpp000066400000000000000000000004271417213455000167520ustar00rootroot00000000000000#include void quat_example() { Imath::Quatf q (2.0f, 3.0f, 4.0f, 5.0f); assert (q.r == 2.0f && q.v == Imath::V3f (3.0f, 4.0f, 5.0f)); Imath::Quatf r (1.0f, 0.0f, 0.0f, 1.0f); assert (r.inverse() == Imath::Quatf (0.5f, 0.0f, 0.0f, -0.5f)); } Imath-3.1.4/docs/examples/Shear6.cpp000066400000000000000000000003111417213455000171600ustar00rootroot00000000000000#include #include void shear6_example() { Imath::Shear6f s (0.330f, 0.710f, 0.010f, 0.999f, -0.531f, -0.012f); Imath::M44f M; M.setShear (s); } Imath-3.1.4/docs/examples/Sphere3.cpp000066400000000000000000000007531417213455000173530ustar00rootroot00000000000000#include void sphere3_example() { Imath::V3f center (1.0f, 1.0f, 1.0f); float radius = 2.0f; Imath::Sphere3f s (center, radius); assert (s.center == center); assert (s.radius == radius); Imath::Line3f line (Imath::V3f (0.0f, 0.0f, 0.0f), Imath::V3f (1.0f, 1.0f, 1.0f)); Imath::V3f v; assert (s.intersect (line, v)); assert (v.equalWithAbsError (Imath::V3f(2.1547f, 2.1547f, 2.1547f), 1e-6f)); } Imath-3.1.4/docs/examples/Vec2.cpp000066400000000000000000000004661417213455000166420ustar00rootroot00000000000000#include void vec2_example() { Imath::V2f a (1.0f, 2.0f); Imath::V2f b; // b is uninitialized b.x = a[0]; b.y = a[1]; assert (a == b); assert (a.length() == sqrt (a ^ a)); a.normalize(); assert (Imath::equalWithAbsError (a.length(), 1.0f, 1e-6f)); } Imath-3.1.4/docs/examples/Vec3.cpp000066400000000000000000000005141417213455000166350ustar00rootroot00000000000000#include void vec3_example() { Imath::V3f a (1.0f, 2.0f, 3.0f); Imath::V3f b; // b is uninitialized b.x = a[0]; b.y = a[1]; b.z = a[2]; assert (a == b); assert (a.length() == sqrt (a ^ a)); a.normalize(); assert (Imath::equalWithAbsError (a.length(), 1.0f, 1e-6f)); } Imath-3.1.4/docs/examples/Vec4.cpp000066400000000000000000000005421417213455000166370ustar00rootroot00000000000000#include void vec4_example() { Imath::V4f a (1.0f, 2.0f, 3.0f, 4.0f); Imath::V4f b; // b is uninitialized b.x = a[0]; b.y = a[1]; b.z = a[2]; b.w = a[3]; assert (a == b); assert (a.length() == sqrt (a ^ a)); a.normalize(); assert (Imath::equalWithAbsError (a.length(), 1.0f, 1e-6f)); } Imath-3.1.4/docs/examples/gl.cpp000066400000000000000000000002241417213455000164350ustar00rootroot00000000000000#include void gl_example() { Imath::M44f M; glPushMatrix (M); Imath::V3f v (0.0f, 1.0f, 2.0f); glVertex (v); } Imath-3.1.4/docs/examples/half.c000066400000000000000000000002261417213455000164070ustar00rootroot00000000000000#include void half_example() { float f = 3.5f; half h = imath_float_to_half (f) float hh = imath_half_to_float (h) } Imath-3.1.4/docs/examples/half.cpp000066400000000000000000000002311417213455000167430ustar00rootroot00000000000000#include #include void half_example() { half a (3.5); float b (a + sqrt (a)); a += b; b += a; b = a + 7; } Imath-3.1.4/docs/examples/main.cpp000066400000000000000000000020041417213455000167550ustar00rootroot00000000000000// SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. #include void color3_example(); void color4_example(); void euler_example(); void frustum_example(); void interval_example(); void line3_example(); void matrix22_example(); void matrix33_example(); void matrix44_example(); void plane3_example(); void quat_example(); void shear6_example(); void sphere3_example(); void vec2_example(); void vec3_example(); void vec4_example(); void half_example(); int main (int argc, char* argv[]) { std::cout << "imath examples..." << std::endl; color3_example(); color4_example(); euler_example(); frustum_example(); interval_example(); line3_example(); matrix22_example(); matrix33_example(); matrix44_example(); plane3_example(); quat_example(); shear6_example(); sphere3_example(); vec2_example(); vec3_example(); vec4_example(); half_example(); std::cout << "done." << std::endl; return 0; } Imath-3.1.4/docs/fixmanpages.sh000077500000000000000000000006601417213455000163560ustar00rootroot00000000000000#!/bin/bash # Fix the names of doxygen-generated man page files: # * Strip "_ Vec" and "_ T _ _" from "Imath_Box_ Vec2_ T _ _.3" # * and rename "Imath_*" to "Imath::*" if [ -d $1/man/man3 ]; then cd $1/man/man3 echo cd $1/man/man3 shopt -s nullglob for file in Imath_*.3; do new=`echo $file | sed -e 's/_ T _ _//g' -e 's/_ Vec//g' -e s/_/::/g` echo /bin/mv "$file" $new /bin/mv "$file" $new done fi Imath-3.1.4/docs/float.rst000066400000000000000000000113261417213455000153550ustar00rootroot00000000000000Floating Point Representation ############################# The half type is a 16-bit floating number, compatible with the IEEE 754-2008 binary16 type. Representation of a 32-bit float -------------------------------- We assume that a float, ``f``, is an IEEE 754 single-precision floating point number, whose bits are arranged as follows: .. code-block:: 31 (msb) | | 30 23 | | | | | | 22 0 (lsb) | | | | | X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX s e m ``s`` is the sign-bit, ``e`` is the exponent and ``m`` is the significand. If ``e`` is between 1 and 254, ``f`` is a normalized number: f = (-1)\ :sup:`s` * 2\ :sup:`e-127` * 1.m If ``e`` is 0, and ``m`` is not zero, ``f`` is a denormalized number: f = (-1)\ :sup:`s` * 2\ :sup:`-126` * 0.m If ``e`` and ``m`` are both zero, ``f`` is zero: f = 0.0 If ``e`` is 255, ``f`` is an "infinity" or "not a number" (NAN), depending on whether ``m`` is zero or not. Examples: .. code-block:: 0 00000000 00000000000000000000000 = 0.0 0 01111110 00000000000000000000000 = 0.5 0 01111111 00000000000000000000000 = 1.0 0 10000000 00000000000000000000000 = 2.0 0 10000000 10000000000000000000000 = 3.0 1 10000101 11110000010000000000000 = -124.0625 0 11111111 00000000000000000000000 = +infinity 1 11111111 00000000000000000000000 = -infinity 0 11111111 10000000000000000000000 = NAN 1 11111111 11111111111111111111111 = NAN Representation of a 16-bit half ------------------------------- Here is the bit-layout for a half number, ``h``: .. code-block:: 15 (msb) | | 14 10 | | | | | | 9 0 (lsb) | | | | | X XXXXX XXXXXXXXXX s e m ``s`` is the sign-bit, ``e`` is the exponent and ``m`` is the significand. If ``e`` is between 1 and 30, ``h`` is a normalized number: h = (-1)\ :sup:`s` * 2\ :sup:`e-15` * 1.m If ``e`` is 0, and ``m`` is not zero, ``h`` is a denormalized number: h = (-1) :sup:`s` * 2\ :sup:`-14` * 0.m If ``e`` and ``m`` are both zero, ``h`` is zero: h = 0.0 If ``e`` is 31, ``h`` is an "infinity" or "not a number" (NAN), depending on whether ``m`` is zero or not. Examples: .. code-block:: 0 00000 0000000000 = 0.0 0 01110 0000000000 = 0.5 0 01111 0000000000 = 1.0 0 10000 0000000000 = 2.0 0 10000 1000000000 = 3.0 1 10101 1111000001 = -124.0625 0 11111 0000000000 = +infinity 1 11111 0000000000 = -infinity 0 11111 1000000000 = NAN 1 11111 1111111111 = NAN Conversion via Lookup Table --------------------------- Converting from half to float is performed by default using a lookup table. There are only 65,536 different half numbers; each of these numbers has been converted and stored in a table pointed to by the ``imath_half_to_float_table`` pointer. Prior to Imath v3.1, conversion from float to half was accomplished with the help of an exponent look table, but this is now replaced with explicit bit shifting. Conversion via Hardware ----------------------- For Imath v3.1, the conversion routines have been extended to use F16C SSE instructions whenever present and enabled by compiler flags. Conversion via Bit-Shifting --------------------------- If F16C SSE instructions are not available, conversion can be accomplished by a bit-shifting algorithm. For half-to-float conversion, this is generally slower than the lookup table, but it may be preferable when memory limits preclude storing of the 65,536-entry lookup table. The lookup table symbol is included in the compilation even if ``IMATH_HALF_USE_LOOKUP_TABLE`` is false, because application code using the exported ``half.h`` may choose to enable the use of the table. An implementation can eliminate the table from compilation by defining the ``IMATH_HALF_NO_LOOKUP_TABLE`` preprocessor symbol. Simply add: .. code-block:: #define IMATH_HALF_NO_LOOKUP_TABLE before including ``half.h``, or define the symbol on the compile command line. Furthermore, an implementation wishing to receive ``FE_OVERFLOW`` and ``FE_UNDERFLOW`` floating point exceptions when converting float to half by the bit-shift algorithm can define the preprocessor symbol ``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to including ``half.h``: .. code-block:: #define IMATH_HALF_ENABLE_FP_EXCEPTIONS Conversion Performance Comparison --------------------------------- Testing on a Core i9, the timings are approximately: - half to float: * table: 0.71 ns / call * no table: 1.06 ns / call * f16c: 0.45 ns / call - float-to-half: * original: 5.2 ns / call * no exp table + opt: 1.27 ns / call * f16c: 0.45 ns / call **Note:** the timing above depends on the distribution of the floats in question. Imath-3.1.4/docs/functions/000077500000000000000000000000001417213455000155235ustar00rootroot00000000000000Imath-3.1.4/docs/functions/box.rst000066400000000000000000000011011417213455000170360ustar00rootroot00000000000000.. _box-functions: Box Functions ############# Functions that operate on bounding boxes. .. code-block:: #include .. doxygenfunction:: clip .. doxygenfunction:: closestPointInBox .. doxygenfunction:: transform(const Box>& box, const Matrix44& m) noexcept .. doxygenfunction:: affineTransform(const Box>& box, const Matrix44& m) noexcept .. doxygenfunction:: findEntryAndExitPoints .. doxygenfunction:: intersects(const Box>& b, const Line3& r, Vec3& ip) noexcept Imath-3.1.4/docs/functions/color.rst000066400000000000000000000013251417213455000173740ustar00rootroot00000000000000.. _color-functions: Color Functions ############### Functions that operate on colors. .. code-block:: #include .. doxygenfunction:: hsv2rgb(const Vec3& hsv) noexcept .. doxygenfunction:: hsv2rgb(const Color4& hsv) noexcept .. doxygenfunction:: rgb2hsv(const Color4 &rgb) noexcept .. doxygenfunction:: rgb2hsv(const Vec3 &rgb) noexcept .. doxygenfunction:: rgb2packed(const Color4 &c) noexcept .. doxygenfunction:: rgb2packed(const Vec3 &c) noexcept .. doxygenfunction:: packed2rgb(PackedColor packed, Color4 &out) noexcept .. doxygenfunction:: packed2rgb(PackedColor packed, Vec3 &out) noexcept Imath-3.1.4/docs/functions/frame.rst000066400000000000000000000004351417213455000173510ustar00rootroot00000000000000.. _frame-functions: Frame Functions ############### Functions to compute coordinate frames. .. code-block:: #include .. doxygenfunction:: firstFrame .. doxygenfunction:: nextFrame .. doxygenfunction:: lastFrame Imath-3.1.4/docs/functions/gl.rst000066400000000000000000000022431417213455000166600ustar00rootroot00000000000000.. _gl-functions: GL Functions ############ Functions that wrap OpenGL calls to accept Imath vectors and matrices. .. code-block:: #include Example: .. literalinclude:: ../examples/gl.cpp :language: c++ .. doxygenfunction:: glVertex(const Imath::V2f &v) .. doxygenfunction:: glVertex(const Imath::V3f &v) .. doxygenfunction:: glNormal(const Imath::V3f &v) .. doxygenfunction:: glColor(const Imath::V3f &v) .. doxygenfunction:: glTranslate .. doxygenfunction:: glTexCoord .. doxygenfunction:: throwBadMatrix .. doxygenfunction:: glMultMatrix( const Imath::M44f &m ) .. doxygenfunction:: glMultMatrix( const Imath::M44f *m ) .. doxygenfunction:: glLoadMatrix(const Imath::M44f &m) .. doxygenfunction:: glLoadMatrix(const Imath::M44f *m) .. doxygenclass:: Imath::GLPushMatrix :members: :undoc-members: .. doxygenclass:: Imath::GLPushAttrib :members: :undoc-members: .. doxygenclass:: Imath::GLBegin :members: :undoc-members: Imath-3.1.4/docs/functions/glu.rst000066400000000000000000000004021417213455000170400ustar00rootroot00000000000000.. _glu-functions: GLU Functions ############# Functions that wrap GLU calls to accept Imath vectors. .. code-block:: #include .. doxygenfunction:: gluLookAt(const Imath::V3f& pos, const Imath::V3f& interest, const Imath::V3f& up) Imath-3.1.4/docs/functions/half_c.rst000066400000000000000000000006641417213455000174770ustar00rootroot00000000000000C-language half-float Conversion ################################ The ``half.h`` header can be included in pure C code: .. literalinclude:: ../examples/half.c :language: c The only C-language operations supported for the ``half`` type are conversion to and from ``float``. No arithmetic operations are currently implemented in the C interface. .. doxygenfunction:: imath_half_to_float .. doxygenfunction:: imath_float_to_half Imath-3.1.4/docs/functions/line.rst000066400000000000000000000010571417213455000172070ustar00rootroot00000000000000.. _line-functions: Line3 Functions ############### .. code-block:: #include Functions that operate on the ``Line3`` object. .. doxygenfunction:: closestPoints .. doxygenfunction:: intersect(const Line3& line, const Vec3&v0, const Vec3& v1, const Vec3& v2, Vec3& pt, Vec3& barycentric, bool& front) noexcept .. doxygenfunction:: closestVertex(const Vec3& v0, const Vec3& v1, const Vec3& v2, const Line3& l) noexcept .. doxygenfunction:: rotatePoint Imath-3.1.4/docs/functions/matrix.rst000066400000000000000000000103461417213455000175650ustar00rootroot00000000000000.. _matrix-functions: Matrix Functions ################ .. code-block:: #include Functions that operate on matrices .. doxygenfunction:: extractScaling(const Matrix44& mat, Vec3& scl, bool exc) .. doxygenfunction:: sansScaling(const Matrix44& mat, bool exc) .. doxygenfunction:: removeScaling(Matrix44& mat, bool exc) .. doxygenfunction:: extractScalingAndShear(const Matrix44& mat, Vec3& scl, Vec3& shr, bool exc) .. doxygenfunction:: sansScalingAndShear(const Matrix44& mat, bool exc) .. doxygenfunction:: sansScalingAndShear(Matrix44& result, const Matrix44& mat, bool exc) .. doxygenfunction:: removeScalingAndShear(Matrix44& mat, bool exc) .. doxygenfunction:: extractAndRemoveScalingAndShear(Matrix44& mat, Vec3& scl, Vec3& shr, bool exc) .. doxygenfunction:: extractEulerXYZ(const Matrix44& mat, Vec3& rot) .. doxygenfunction:: extractEulerZYX(const Matrix44& mat, Vec3& rot) .. doxygenfunction:: extractQuat(const Matrix44& mat) .. doxygenfunction:: extractSHRT(const Matrix44& mat, Vec3& s, Vec3& h, Vec3& r, Vec3& t, bool exc, typename Euler::Order rOrder) .. doxygenfunction:: extractSHRT(const Matrix44& mat, Vec3& s, Vec3& h, Vec3& r, Vec3& t, bool exc) .. doxygenfunction:: extractSHRT(const Matrix44& mat, Vec3& s, Vec3& h, Euler& r, Vec3& t, bool exc) .. doxygenfunction:: checkForZeroScaleInRow(const T& scl, const Vec3& row, bool exc) .. doxygenfunction:: outerProduct(const Vec4& a, const Vec4& b) .. doxygenfunction:: rotationMatrix(const Vec3& fromDirection, const Vec3& toDirection) .. doxygenfunction:: rotationMatrixWithUpDir(const Vec3& fromDir, const Vec3& toDir, const Vec3& upDir) .. doxygenfunction:: alignZAxisWithTargetDir(Matrix44& result, Vec3 targetDir, Vec3 upDir) .. doxygenfunction:: computeLocalFrame(const Vec3& p, const Vec3& xDir, const Vec3& normal) .. doxygenfunction:: addOffset(const Matrix44& inMat, const Vec3& tOffset, const Vec3& rOffset, const Vec3& sOffset, const Vec3& ref) .. doxygenfunction:: computeRSMatrix(bool keepRotateA, bool keepScaleA, const Matrix44& A, const Matrix44& B) .. doxygenfunction:: extractScaling(const Matrix33& mat, Vec2& scl, bool exc) .. doxygenfunction:: sansScaling(const Matrix33& mat, bool exc) .. doxygenfunction:: removeScaling(Matrix33& mat, bool exc) .. doxygenfunction:: extractScalingAndShear(const Matrix33& mat, Vec2& scl, T& shr, bool exc) .. doxygenfunction:: sansScalingAndShear(const Matrix33& mat, bool exc) .. doxygenfunction:: removeScalingAndShear(Matrix33& mat, bool exc) .. doxygenfunction:: extractAndRemoveScalingAndShear(Matrix33& mat, Vec2& scl, T& shr, bool exc) .. doxygenfunction:: extractEuler(const Matrix22& mat, T& rot) .. doxygenfunction:: extractEuler(const Matrix33& mat, T& rot) .. doxygenfunction:: extractSHRT(const Matrix33& mat, Vec2& s, T& h, T& r, Vec2& t, bool exc) .. doxygenfunction:: checkForZeroScaleInRow(const T& scl, const Vec2& row, bool exc) .. doxygenfunction:: outerProduct(const Vec3& a, const Vec3& b) .. doxygenfunction:: procrustesRotationAndTranslation(const Vec3* A, const Vec3* B, const T* weights, const size_t numPoints, const bool doScaling) .. doxygenfunction:: procrustesRotationAndTranslation(const Vec3* A, const Vec3* B, const size_t numPoints, const bool doScaling) .. doxygenfunction:: jacobiSVD(const Matrix33& A, Matrix33& U, Vec3& S, Matrix33& V, const T tol, const bool forcePositiveDeterminant) .. doxygenfunction:: jacobiSVD(const Matrix44& A, Matrix44& U, Vec4& S, Matrix44& V, const T tol, const bool forcePositiveDeterminant) .. doxygenfunction:: jacobiEigenSolver(Matrix33& A, Vec3& S, Matrix33& V, const T tol) .. doxygenfunction:: jacobiEigenSolver(Matrix33& A, Vec3& S, Matrix33& V) .. doxygenfunction:: jacobiEigenSolver(Matrix44& A, Vec4& S, Matrix44& V, const T tol) .. doxygenfunction:: jacobiEigenSolver(Matrix44& A, Vec4& S, Matrix44& V) .. doxygenfunction:: maxEigenVector(TM& A, TV& S) .. doxygenfunction:: minEigenVector(TM& A, TV& S) Imath-3.1.4/docs/functions/random.rst000066400000000000000000000011321417213455000175320ustar00rootroot00000000000000.. _random-number-functions: Random Numbers ############## Functions to compute pseudo-random numbers. .. code-block:: #include .. doxygenfunction:: solidSphereRand .. doxygenfunction:: hollowSphereRand .. doxygenfunction:: gaussSphereRand .. doxygenfunction:: gaussRand .. doxygenfunction:: erand48 .. doxygenfunction:: drand48 .. doxygenfunction:: nrand48 .. doxygenfunction:: lrand48 .. doxygenfunction:: srand48 Imath-3.1.4/docs/functions/roots.rst000066400000000000000000000004711417213455000174250ustar00rootroot00000000000000.. _roots: Roots ##### Functions to compute roots of simple equations. .. code-block:: #include .. doxygenfunction:: solveLinear .. doxygenfunction:: solveQuadratic .. doxygenfunction:: solveNormalizedCubic .. doxygenfunction:: solveCubic Imath-3.1.4/docs/functions/vec.rst000066400000000000000000000004251417213455000170330ustar00rootroot00000000000000.. _vector-functions: Vector Functions ################ .. code-block:: #include Functions that operate on vectors. .. doxygenfunction:: closestVertex(const Vec& v0, const Vec& v1, const Vec& v2, const Vec& p) noexcept Imath-3.1.4/docs/half_conversion.rst000066400000000000000000000047141417213455000174320ustar00rootroot00000000000000.. _half-float-conversion-configuration-options: half-float Conversion Configuration Options ########################################### The Imath library supports three options for conversion between 16-bit half and 32-bit float: 1. Conversion from half to float via a 16-bit lookup table. Prior to Imath v3.1, this was the only method supported. 2. F16C SSE instructions: single-instruction conversion for machine architectures that support it. When available, this is the fastest option, by far. 3. Bit-shift conversion algorithm. To use the F16C SSE instruction set on an architecture that supports it, simply provide the appropriate compiler flags when building an application that includes ``half.h``. For g++ and clang, for example: :: % cmake -DCMAKE_CXX_FLAGS="-m16fc" When code including ``half.h`` is compiled with F16C enabled, it will automatically perform conversions using the instruction set. F16C compiler flags take precedence over other lookup-table-related Imath CMake settings. On architectures that do not support F16C, you may choose at compile-time between the bit-shift conversion and lookup table conversion via the ``IMATH_HALF_USE_LOOKUP_TABLE`` CMake option: :: % cmake -DIMATH_HALF_USE_LOOKUP_TABLE=OFF Note that when building and installing the Imath library itself, the 65,536-entry lookup table symbol will be compiled into the library even if the ``IMATH_HALF_USE_LOOKUP_TABLE`` setting is false. This allows applications using that installed Imath library downstream to choose at compile time which conversion method to use. Applications with memory limitations that cannot accomodate the conversion lookup table can eliminate it from the library by building Imath with the C preprocessor define ``IMATH_HALF_NO_LOOKUP_TABLE`` defined. Note that this is a compile-time option, not a CMake setting (making it possible for application code to choose the desired behavior). Simply add: :: #define IMATH_HALF_NO_LOOKUP_TABLE before including ``half.h``, or define the symbol on the compile command line. Furthermore, an implementation wishing to receive ``FE_OVERFLOW`` and ``FE_UNDERFLOW`` floating point exceptions when converting float to half by the bit-shift algorithm can define the preprocessor symbol ``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to including ``half.h``: :: #define IMATH_HALF_ENABLE_FP_EXCEPTIONS By default, no exceptions are raised on overflow and underflow. Imath-3.1.4/docs/half_limits.rst000066400000000000000000000023561417213455000165460ustar00rootroot00000000000000half Limits ########### ``HALF_DENORM_MIN`` Smallest positive denormalized half. ``HALF_NRM_MIN`` Smallest positive normalized half. ``HALF_MIN`` Smallest positive normalized half. ``HALF_MAX`` Largest positive half. ``HALF_EPSILON`` Smallest positive e for which half(1.0 + e) != half(1.0) ``HALF_MANT_DIG`` Number of digits in mantissa (significand + hidden leading 1) ``HALF_DIG`` Number of base 10 digits that can be represented without change: floor( (``HALF_MANT_DIG`` - 1) * log10(2) ) => 3.01... -> 3 ``HALF_DECIMAL_DIG`` Number of base-10 digits that are necessary to uniquely represent all distinct values: ceil(``HALF_MANT_DIG`` * log10(2) + 1) => 4.31... -> 5 ``HALF_RADIX`` Base of the exponent. ``HALF_DENORM_MIN_EXP`` Minimum negative integer such that ``HALF_RADIX`` raised to the power of one less than that integer is a normalized half. ``HALF_MAX_EXP`` Maximum positive integer such that ``HALF_RADIX`` raised to the power of one less than that integer is a normalized half. ``HALF_DENORM_MIN_10_EXP`` Minimum positive integer such that 10 raised to that power is a normalized half. ``HALF_MAX_10_EXP`` Maximum positive integer such that 10 raised to that power is a normalized half. Imath-3.1.4/docs/images/000077500000000000000000000000001417213455000147605ustar00rootroot00000000000000Imath-3.1.4/docs/images/imath-logo-black.png000066400000000000000000000063271417213455000206100ustar00rootroot00000000000000‰PNG  IHDR–Mpˆ žIDATxÚíÝ!p»ÀñˆŠ DEE¨¨¨@T ˜A *®¨@ *D¢@ *D¢¸â D¢x¢@T **¼“i:·×–ݳÉnzÎï?óÍËÜK²ÙÝüO²É—Б[£x>ŠO£8ůÇ£ø2Š­QÜÑL€Ic~oGqrN~WÅÇQ,j6À$Gxß ð×o£Ä5͸ŠQ|ë9>µ¨ßJÚ¯1㤥 ·*o@f^t̸ñ­aÝâtèa†òNBóï†;·€:ˆ?®×;ÄmMH„M;þÝŒeŒb†dà[Çw~]a“޹@¹M>"@„DXEÇÿº@¹M¾Å!"$Â*:þƒBeÏ!"Dí"œ-Xö]"@„¨]„· –ýˆ!¦Y„z‰ž¸b|¯C” añŽ¡`Ù«DLüˆë⺋0r\¨ì%"ˆqDøOr4(—"$B"l‡¡lnÍõÂyÓ Ü®¹F‰ B"œÞ+\¯Ù'Ïèù|£}ä÷#B€‰³±–Q„[=µ'DH„D˜•·!Ojµ™žêK„!f% ì}‡îK8ÝŽÑD!aÆzž´¬cÜ”{£çö$B€‰‹fúÐ@ˆû£x0P{!@„DH„ʼn'×Ç…4/Ã龿q1Ìã0üÉÏD!áTC„!!DH„DH„D!!N¼c ¸ˆi5½Üçã~8Mr>3PÝn§çô÷zÅïË+¡ßm5¥¹•®éþ×{÷Ò½š'‰áBºç]p¯¥û}{À÷‰pbEÅWän‡Ó=šMÓÛÅÿöUzqK±œžçx]ÓÓKb"ö˜àýé(n^ƒö¿‘Þ½çátíAh¿­(ÆÑ(>§û¸^áµáÿ2“î{|‡>¥û÷«åû·~°Îꦯ—wC·Ø¿Ç$аk’ð¦©çâÈîMËð²øOÆ©¡¹Qêx÷ÃøÛ]æÒ³{T¨n;©Œ¡ˆ#€‡¡ÌqdM~|H÷>÷ôí¯Š£&.|ïÎâgz‡L!^Ñi½ï¡ó9NÓ5mˆÈauû:ŠÅ¦žãèï{%rØÍ8B$Â?‹p.ͼœôxÝ_®Ég"$ÂÞD8“¦†~G k §Ö>öÜ9†~’4ÄvÜ“àÇ™f|H„ÅE¸–y ´ís¾¦"$Â3 ´y›iš«¾Íݰ“ˆßKæ¬] Í ¯;N£áÅ"Œ³o+¸þïaŠ¿!†ôkpèÑÈA¸xEÛ£ž§Š.ŠíBÓ [\[›xßA†Døÿ"Œâù\Q|$B"œVÖ ÁË–½?©¤^'™§Ho_“Qà8 ¬ˆ°™3ü=%â á´‰ðCe/c\}"‰oDH„D(.‹wž‘ùP.@ßñNlÜ%B"$BqÙ&û<+ô}õ,]X_Ó¯ûD8±ñ‚‰Åe‘cOál’ê¸Âûdú æ²2bª®¸ý$îS+µs™'2>!á¿+ÈvRgºœ:³…ôϸ>žÚ0T>̘ {#Mᜯ×bš²Û.Ôù/ezVÖZ^ïn߸§œå/ýš¹=^a±o°/Ó³¼tÁ3W?Oÿ]‰ò!N»“dšvºK¡Ÿ.qʯMæüÙÔQç\¥w?ãóò)óõ6âËŒmrаÜ8’^o]À|hQÖYÔ Â£ô¼¶ÍýWY¿+PŸ©ÙFA„DxÑ‚¹1;Ø¿ Jðs?âZÆzä<]üN¸:‹KÉdÈke˜û°ßI?ð²D]ÛñaÈ»íhjò!ž}tíäã¯þ…ß„îÇÅlU(‹îáÐn5fÖ3µÉjæzM“2·_Î}÷”@„Dxö2æZ.ý8ó}ÛÈT¯¹gÛBnÞ ÿ®òÜý‰“cŸ{ö´ˆ°Ô©¹öª!NãTÊRÆ6¸‘qzf#óýÉ‘å½Ð{¸†9$õN†6É”|DXò装g áTˆð¤Ð½Ì±’ôUz=¬T„CŸÞu%énæúLºCùïo9N¸'B"œ îj‡ßãJÈa±RMׇ{D8èLÇEä8¹…‰p*D¸S¨6*½_7ˆ0k?@„õ>CËDH„D8¬×+¾_DH„Ó Ây"$B"$Âë.ÂÙôž=KS—{éYùþÛ³#ße㢕˜íg%´Ë@C„“'ÂÏ:!aïXü.÷Æ…]WýÅÿ?æ‹|þ¼Q›‰‰‰pðU£OB¹Ô]?Ó¨r™‰‰‰°6ÆiÌÿ`ÓT^DH„DH„DH„ƒtb›!oBð6' < B"$B"$B"ª› uœ%¹I„DH„DH„D8D'ö¾ žÅ!!aŸØËŠ$xþLA"$B"$B"$ÂâØƒ %˜#ˆ‰‰ÿÈl(·=‚‰‰‰°znN¨‰‰‰ èKz‡ã çñd³ýñŸ·ÂéÅXßסì^E"$B"$B"$Â+y˜ùYŽ)ؖǨG”c\¬sD„DH„DH„DØg'–k»Äaýueno‰‰‰ûêÄrŒÀCþSÍãH5Gf"$B"$B"$ÂKYÊPf”ÕJ¡öXÍ C"$B"$B"$ÂKYËPæNáçö5!!a©NìY†2ïVÚ!!!—LÇï“ÄÆe.½÷Çë”[„oC¿"Ü%B"$B"$²ØLÈóÝëüªÈ8ʼše‰«N$Áä>‹°„7záQh—½‡‰‰Çài¡Nü8MqÆ{ù2½Ó/Ò¿Ç|KžL_J„+=‹°m>W"$B"$B"sTx0@ßGäáL¡‘ëUñ’‰‰Ëwbq¤sˆ° oz¾†}"$B"$B"ì§Û¬Pd‡Špy€vhš†‰‰;²ê‘àn¨/³Ìïzn‹¦|ˆ‰‰°#3Lý]oS]já|†Ñj›xG„DH„DH„ývb/Â0Œß)72Öc¯àýŠ«9{j—DH„DH„DØ'÷÷}ïQ‚q;Årf!ï~¯ô$ÃXF“tkDH„DH„D˜™˜íe;”]Q§Ÿ†‹7Ž×.ÂÈÒ(>lŸÏ© #B"$B"$Â;±ÛáôÛaÎÑϧpºd¶àí^Oï×Ljÿ¯Ûç ý2Ë¡º¦"Ädr#Ék7´_,ò=ýOFqs‚Ûè^E·Íœs’F¯B»l2 B"$B ÈBzçâHb#ü›Fm3ýÙ_áô¨¡¹)þáp'µÃzj—³6ÚH¿3.¶ù‰€‰€‰€‰€‰€‰€5‚€A„0}"Œé‰ÖÇŒµŠÛãn‡ë7¿&À5a—¨¹ãßÑ@„D¨=€‰P{!!!!!!!!!À5åV8=I¢ÏX©¸=µÀõâ¿ÛæG¤ª˜„(IEND®B`‚Imath-3.1.4/docs/images/imath-logo-blue.png000066400000000000000000000074351417213455000204640ustar00rootroot00000000000000‰PNG  IHDR–MpˆäIDATxÚíÝ/lÇÀñ‚ǾT¯R@AAAAAA@@A¤‚€‚¦·g==8RAAA@A@À‹TP©»kë©À          À  À À ÀÀ ogo]§ÿÜÝÎì­ï>_i({;»3ßÙßü~o½€6¬ÜÜzo5Ëﮋ_ײb¯:^…c5+þ¬þ|¶–•ßUUKŠKÿùß¿Ãâ‡Jv‡ò;ý(_Êò´àÜfx•Ü^L&À£#ÌYžiAÀ‰¬eùíJÏ»<²椿ïâpóZ³ìùjÆã`†¥Õ>· ölkXþ·…df=žOòÛÂrhõow#œï`Òï†Õ¿Ýîk{èáåºê·³o¯—ïkE"œhà_"žsç­ë÷.!€ö+iõjN›>¿¡‰ðÌm½ü(Áy7&xÀ‰aD8*Ä>ï$ßâˆa?D˜;)Î}ùæƒËD€ÑoÞÚ^IuîKëåÇD€Ñk†ì1ÉÎ=*¿ BDˆåá =Í8büI‹#©hˆ“ükëå•Tç^n~J„Àbϸ¸F„8×"¬W»l2'ƒÏ·>$B€‰½áÚ¨ø%úy‡ÅË p"ˆ‰p¢c7enÍ&QÜÙ`Vn}ÞÖ¹F‰ B"\Fùõ¤?l¼…b7¢ºÈïG„!F£IlI„åwu`"ˆ‰0¢ ÇÅxÛ§V› á6DH„DØ;­ŽŠ[Ò Fŷ;¿í ³:Ì¿œwåg"ˆ‰pÙ;0DH„DH„D!!!@„DH„D¸à" €ÖËBU&-ÞÑ1*>©“œw´‡óŸ„ïÅá9ýçï ß—/7¯u¹­&5¡tY}MU›¿q¯;´Eu¯Â7v"<ÿ" Ïo¸ç«£â³7û^ùE¸ßuÌÄœúá⊰N}—ßXÍò¼Þ£9az»ñ¿Í›¬ík!×Ï󓉫— ‹—!Áû +¾¾8üþݾ7Øú^Õþw›ýµ;So+{Õñ´¹}»v"ü•ÌÆ/uùý ¤¹¯¦éá^×eèª>l¤>G"lŠs>u,¢Û' Ÿ,õ\˜Ù…¤åSvÀŽü÷XKC—o>¸¼6,¿i„Ð:muü\ WûÔGƒ¤ª6»]Ý«ÇÕïÛOX% –wSIq|?›-¯e/åøÐ•C¿«_V [Ä*<ÕË߃EZYlŽ+MGëè‹)ÂÖe£¶Ïše5{7ã׆ÌòßfÝîØ<»{‰¤°Î1·ŽfÃüßIÊ‘MðBPßóêÞÇ^¾Ãµ$R‹°yñü)ñ5ï×3gK§DH„Ç‹0 Z-SÛM¶„•ÖË5Ó]óFäÊ$'ý¶?.eùsXz®fÅ‹^bX<Š5C$³E^¾š•—ƒ¯ýÙyø,@„DØ«·Ãf©q¿ÛHžM¶´V/v9@îv’¤¡N#˜Ù…àgYf ³S"L+ºÚNÌ%Ð)ŸóÎ_úˆû(ÂðÍ v›OµLsÊ·¹:P`~ƒÄNÊœµu´çäGó;FŃ6ËhDx‚om¯Ä¨²áx±´ß ‰ÃÿÞ{0Ù9.¢-„‚w¼TtÌ2iž§Y­ƒz/ÁÃv?Î*C"|S„ÍËçÓþ´Cù˜‰p)EØ ö¾:*¿êÉ qs‰4ü_çb8C€N&¦ß=ïßËNùáR‰°‰LëMg Á3‡ÑšÍ&ýþÌ–†Å£8}nóÓ‰÷9ööÈoa«eæ;½ ˆ:æ›ð\#¦‰ç0#ìã·¨;aÆÔCYì· BV—Ž‘’ͧÝ^A„oìYíïý–ß!᜿ŽkJöò·µNЄǟûû2œáÂω‰ÐqR0ÁöÏH3+Ü[ŽŠÏˆp1KëåÇDH„Dè8v“}”çd¼W3ú÷Õ×R†u²üfîD¸ Ïzâ|­DH„DxŽ({ om¯©Î*¼:È©–i~#æ¤s„T]u%‚°O-Õ>Ì ¿á¹[ýxL„DH„GÉ‹·ë½|Õ€Wfëå•:[–_ Uæ•3$ÈÑ‹a çõßÂÒÃ’]ôdŇÏ~(-:“È4×['¡ÏoÌ\= É_:«€O‰ ½O„i¾ÁFÅ·áYÏÜÏx}œßmªQ¤ˆ’~I„D¸ì"Ü­Cä'tÇI‚; pÙŸ*sþ8wçý¨Qz£â“xýïÌAl?z¥€º¤OñmÄ6Ù™ä´a&}R­Ä7Ž–/0Ͷ iŽžˆpo\®lºÜŸã}©åÃØ¿gi¶Q!2SyJëYZ2 >5┳¯Îª‹‡YõiY\R&CnÚ$Š cû]‚z„Ç'·hÙŽÍŒ?Ú¶£¥É?J„Dø·ÙGËA¾yë¾Q8l9h[.¦IgÖ+{«ÙÐ4ј-Ͻgoº "Dø÷Y`Ìö‹ùÒ·4؉;c¬p馊Â\³˜G]Ä7ζ…¨"l ÖîFav]'Ê,>òì%a’ª±öª!.ë(ÄH ‡³ÂxË3q$x´t%ËÿF’~R¸Í¡Hêi˳óJJ¾$"LVú¨Iæ½O„DH„“ÖLp/ãD’N8í7”>ŠpÞUÂ[G’FÊú," /Š©¿¿Å¨pO„D¸"Œ<€ý®ößãRÈ¡Éøß?Ι‡Oˆp~+ÇŽí*·!.ËŒp;M;ä·ûx¿š`"Œ4aŸ¡°ï—‰ç*Âöш=»GDH„çJ„MN["$B"$Âs,Â"­êgãTjõÒå“f~}{Êanѧá»lZ Ù~.7¯M“†O„1žu"$B"$Âî±ë÷.Ô)µÆm£þöC¾È°å¬ÚDH„DH„DH„sm‚R¥îÚ¯g•'$È&B"$B"$B"œã†úÍkkYþ{‡ ¦ßHåE„DH„DH„D8—AlmT܉š|ŠÊu% "$B"$B"$¹ bãåó¯%Y‰˜‰‰‰°óA,T–èQÖ‰;ÄšZ€}+L»C„DH„DH„D˜| ßåú\¥‰‰‰0Ý vk{%áö"$B"$B"$Â~‹°‰}E„DH„DH„D¸|"ÏwèYèáÂy¨¬q¸?0ü¹rsë½ñÅê^ŒŠ‰÷*!!!žL¤:ˆGý/¤`;!KÌi96Á:{DH„DH„DH„ b·Kì†Ù_Û6¸|óÁåÁ°ø‰‰‰°“A,Ò l7vUóf¦z@„DH„DH„D˜l|¾õa„sÔ¥•’Œ›ŸF!!!á "Ìò,F¢ì¤ÏmLC„DH„DH„D˜`ÖmwÎKëåÇ}ˆ‰‰»Ì~HÒM„DH„DH„Dx>E˜åyËó=ïë8@„DH„DH„DH„=a¨¨A„DH„DH„‹³4J„Ó×Yü…‰‰{"ÂÁ2ﬗ"œî»êaº9"$B"$B"œ³£lŸ•_a–G‰‰‰p B6˜ɵ“=´·¶W*Yÿ¶x",ÂKÈ©'º~ï +¾&B"$B"$ÂÔ)Ö†Å˶ç]Íò»)$)jT®fÅ‘úýAVªŽ«¯_sHX¾–å·ÿ:Ïzy…‰‰“æ-Fyއå7±Ú¡®DÑ~&˜jFµïGÿîK„DH„DH„Óö³:Ÿg”ç8Ìà‚Äf½þPy¢®a˜öµúDäʼ`ˆ‰‰0å výÞ…Hß½þŠŠ¬g™£â“I²Î„¨Óµ,¿Ñf/L"ÏóÛÏ÷¦ÉÞC„DH„DH„³Ìr²âëƒx˜Ù5KœÛ¡èî¸b}ݯ·ë¾i+Ó'a¨´Ñ±§ÊçJ„DH„DH„³0žît=ÀwtDaÓV{]^Cx‰ B"$B"$ÂăX3Ó9 ÂIfÐåV§"¬fÕDH„DH„DØÁ ¶6*îôPd»}áx‹CÇË£f£!B"$B"$¶ý®}"}Ë,st¯"m;‰œÁ‡‰‰#|ëzéïØ~<,~¿¥¯" 3´³ÕiÒ²=$B"$B"$±š9ãJØ¢ñw4é<üà¢IŸš´Û¤e‘Œ›çš´ß¤«ÐŽ÷MZ9À8Hp¹I_CÿÄQâºn“Ìf“N;Nú(ßJÚ \õ#Ã4µZm<ùE¸ºç´eÙâtèY†ü®Ú>7l~î Öx¨¦ß\oÒÆé¾(a[eÌós“¦ˆ@†~ótÈ6¿!ŠDxÚ¢\KòÝh‘/ B"¬B„¯ äû¡E¾D€‰° ~.”÷, BT-Âæÿ§ æ½J„ˆµ‹p¡`Þψb’E¸A„@õýR\1~"$Ââ"¼W0ï5"Æ~ĵM„¸Ó"Låº(”÷"ˆqDøŸù~k‘/DH„DØŠ³PðlÍt QnÞ´ÈwسF‰ B"œ>,\®éçœÑïÄóFïwO"ˆ‰0[ÙÖ3Šp·£x!@„DH„YË·ŸA‚ñmöS•—"$B"ÌZ¾©&½¢Â}ŠÛ1:Œ'DH„DXD†Ûé9_?ÄM¹3Ç“"$B",VÖøj¦w-„xÒ¤Ç#Š'DH„DX¼Ìsi!Í«´ïï m{ø3ŒøÍÏD!á¤Ç“"$B"$B"ˆ‰‰ B"$B"o¦€â"¦µt,Þõô(rÞÕÎÊv?ÖÓÊŸ/¯t¹­¦ƒk]H×ôè†ëýž¦{5G„w_„¡÷–žxÏŸÜp¯Ÿ¥û}Tí‰plE˜Ä÷¸I{ifÛãíâÏîĆ[°lK©>‡öo/ù–xÿ«Iów þ3©ƒ{™ö×~`[Qä¼IÓ}ܨíÚ‰ð_ùM¥û¾“9ïóxÉOé^Ç/¬Ózê;$´ð4WGf8$|·e>qd÷¦Ïø+þÉ55Ô|Îl“^$!ä8öï&-WÖFç›´Ù¤÷Mº åø”;_ð:ÚÖË«!¯å¼dÿЕS»ÛK_Ør?ëõ8͈Œ»s¶ò1áÁa9h1ÊzW¨ã=t»Kàv&1ß—˜ÇÛe< e^GÖæ A¼çK¦o«¥&&¾+|É—© ™:%B"¼¥ÓzÛAÿ§0×ú¼æ8•wÖAÙ¾4iqSÏqô÷µ?å!áïE˜¾à½É0"îw&`ž‰ÿ$ò¢ðÜM#õ–Skï;îÏB7¯ïŠqÿ³#Á2Íø”ËŠ0-âú6¢Ë?ëúKa•"L«ÐŽGÔ/o{6— Œª“ˆÏg Ö™•Ð~áÑ(y=Ì4Þ,Â4 °_A¾NìsC"$Âô9‹ŒF¢p¦o¸ÆgOÝÄ^¡iÐÝ ®­Þ*C"ü·Ó—Ï…á=áDа ~gû§ë{^I¹®rN‘†Þþ®»0 üít:&ÂÔîN+ Ås"$ÂIá»Êc\<3›®m­²ÑÒQ¦:²Úïs¬•M"Š­PÏ‚¨Ÿ9#\1M„D8 ÖÈV1Õ&‹Ëa;ˆÐ{sÊåÜ£øe‰‡Š_ͼ B"$ÂÑŸžTZ¶Gc½“ûôÇ–S"$B"į8ÌPGæB¹ƒºæ Ž-«DH„Dˆ›ø’©ž¼(P¶‹ðãȰ®¦_OˆplÙ&B"$BüŠ™ õ$nø2„ðÞ%™ÆÐnÉ#Õ·ŸÄ}j¥öa.áXòž‰{œ§N !Âña¦ºN„DH„DØm'z‡ÄE Mš.8E{ÜQûšJuëKÆø|NŸéd" »(BŒm=šIò:`±È×ô{Ï›4?Æ1z˜FÑýžœs•F;¡Ód@„DH„m½º—:þ8rÙ ?ŽQÛJÿö¤IËqŠu‚¿8,§8l¤¸|Ñfú·øœq±Ÿ‘ˆ‰ˆ‰ˆ‰ˆ‰ˆ‰ˆ‰ˆ‰ˆDD"€‰áN:­a´^q`_ - Porting Help: `Imath/OpenEXR Version 2->3 Porting Guide `_ - License: `BSD License `_ Introduction ############ .. toctree:: :maxdepth: 3 intro install The half Type ############# .. toctree:: :maxdepth: 1 classes/half half_limits functions/half_c half_conversion float Imath Classes ############# .. toctree:: :maxdepth: 3 classes/Box classes/Color3 classes/Color4 classes/Euler classes/Frustum classes/Interval classes/Line3 classes/Matrix22 classes/Matrix33 classes/Matrix44 classes/Plane3 classes/Quat classes/Rand32 classes/Rand48 classes/Shear6 classes/Sphere3 classes/Vec2 classes/Vec3 classes/Vec4 Imath Functions ############### .. toctree:: :maxdepth: 3 functions/box functions/color functions/frame functions/gl functions/glu functions/line functions/matrix functions/random functions/roots functions/vec :ref:`genindex` Imath-3.1.4/docs/install.rst000066400000000000000000000046121417213455000157160ustar00rootroot00000000000000Install Options ############### When installing Imath from source, take note of the following CMake options: ``IMATH_CXX_STANDARD`` C++ standard to compile against. Default is ``14``. ``IMATH_HALF_USE_LOOKUP_TABLE`` Use the half-to-float conversion lookup table. Default is ``ON`` for backwards compatibility. With the value of ``OFF``, use a bit-shift conversion algorithm. Note that this setting is overriden when compiler flags enable the F16C SSE instruction set. ``IMATH_USE_DEFAULT_VISIBILITY`` Use default visibility, which makes all symbols visible in compiled objects. Default is ``OFF``, in which case only designated necessary symbols are marked for export. ``IMATH_USE_NOEXCEPT`` Use the ``noexcept`` specifier of appropriate methods. Default is ``ON``. With the value of ``OFF``, the ``noexcept`` specifier is omitted, for situations in which it is not desireable. ``IMATH_ENABLE_LARGE_STACK`` Enables the ``halfFunction`` object to place the lookup tables on the stack rather than allocating heap memory. Default is ``OFF``. ``IMATH_VERSION_RELEASE_TYPE`` A string to append to the version number in the internal package name macro IMATH_PACKAGE_STRING. Default is the empty string, but can be set to, for example, "-dev" during development (e.g. "3.1.0-dev"). ``IMATH_INSTALL_SYM_LINK`` Install an unversioned symbolic link (i.e. libImath.so) to the versioned library. ``IMATH_INSTALL_PKG_CONFIG`` Install Imath.pc file. Default is ``ON``. ``IMATH_NAMESPACE`` Public namespace alias for Imath. Default is ``Imath``. ``IMATH_INTERNAL_NAMESPACE`` Real namespace for Imath that will end up in compiled symbols. Default is ``Imath__``. ``IMATH_NAMESPACE_CUSTOM`` Whether the namespace has been customized (so external users know). Default is ``NO``. ``IMATH_LIB_SUFFIX`` String added to the end of all the versioned libraries. Default is ``-_`` ``IMATH_OUTPUT_SUBDIR`` Destination sub-folder of the include path for install. Default is ``Imath``. To enable half-to-float conversion using the F16C SSE instruction set for g++ and clang when installing Imath, add the ``-mf16c`` compiler option: :: % cmake -DCMAKE_CXX_FLAGS="-mf16c" See :ref:`half-float Conversion Configuration Options ` for more information about the half-float conversion process. Imath-3.1.4/docs/intro.rst000066400000000000000000000102071417213455000154000ustar00rootroot00000000000000Overview ######## Imath is a basic, light-weight, and efficient C++ representation of 2D and 3D vectors and matrices and other simple but useful mathematical objects, functions, and data types common in computer graphics applications, including the ``half`` 16-bit floating-point type. Imath also includes optional python bindings for all types and functions, including optimized implementations of vector and matrix arrays. The Imath library emphasizes simplicity, ease of use, correctness and verifiability, performance, and breadth of adoption. Imath is not intended to be a comprehensive linear algebra or numerical analysis package. Imath is not `Eigen `_! It's not a full-featured linear algebra package, and it doesn't represent vectors and matrices of arbitrary dimension. Its greatest utility is as a geometric data representation, primarily for 2D images and 3D scenes and coordinate transformations, along with an accompanying set of utility methods and functions. Example ------- A basic program: .. code-block:: #include #include int main() { Imath::V3f v (3.0, 4.0, 5.0); v.normalize(); Imath::M33f M; M.translate (1.0, 2.0, 3.0); Imath::V3f p = v * M; std::cout << "What's your vector, Victor? " << p << std::endl; return 0; } Matrices Are Row-Major ---------------------- Imath stores matrices in row-major layout, originally inspired by compatibility with OpenGL matrices. A matrix described as: .. math:: \begin{bmatrix} m_{00} & m_{01} & m_{02} & m_{03} \\ m_{10} & m_{11} & m_{12} & m_{13} \\ m_{20} & m_{21} & m_{22} & m_{23} \\ m_{30} & m_{31} & m_{32} & m_{33} \\ \end{bmatrix} is laid out in memory as: .. list-table:: :widths: 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 :header-rows: 1 * - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 11 - 12 - 13 - 14 - 15 * - :math:`m_{00}` - :math:`m_{01}` - :math:`m_{02}` - :math:`m_{03}` - :math:`m_{10}` - :math:`m_{11}` - :math:`m_{12}` - :math:`m_{13}` - :math:`m_{20}` - :math:`m_{21}` - :math:`m_{22}` - :math:`m_{23}` - :math:`m_{30}` - :math:`m_{31}` - :math:`m_{32}` - :math:`m_{33}` A matrix representing a homogeneous transform has a right-hand column of :math:`\begin{bmatrix} 0 & 0 & 0 & 1\end{bmatrix}` and the translation component across the bottom row. As a result, it is best to think of Imath vectors as row-vectors, and vector-matrix multiplication with the vector on the left and matrix on the right: .. math:: \begin{bmatrix} v_{0}' & v_{1}' & v_{2}' & 1' \end{bmatrix} = \begin{bmatrix} v_{0} & v_{1} & v_{2} & 1 \end{bmatrix} \begin{bmatrix} m_{00} & m_{01} & m_{02} & 0 \\ m_{10} & m_{11} & m_{12} & 0 \\ m_{20} & m_{21} & m_{22} & 0 \\ m_{30} & m_{31} & m_{32} & 1 \end{bmatrix} This further implies that you should interpret local transformations as pre-multiplication: .. code-block:: M44f M; M.translate (tx, ty, tz); m.rotate (r, 0, 0); m.scale (s); .. math:: \begin{bmatrix} m_{00} & m_{01} & m_{02} & m_{03} \\ m_{10} & m_{11} & m_{12} & m_{13} \\ m_{20} & m_{21} & m_{22} & m_{23} \\ m_{30} & m_{31} & m_{32} & m_{33} \\ \end{bmatrix} = \begin{bmatrix} s & 0 & 0 & 0 \\ 0 & s & 0 & 0 \\ 0 & 0 & s & 0 \\ 0 & 0 & 0 & 1 \\ \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & \cos(r) & \sin(r) & 0 \\ 0 & -\sin(r) & \cos(r) & 0 \\ 0 & 0 & 0 & 1 \\ \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ tx & ty & tz & 1 \\ \end{bmatrix} About ----- Imath originated at Industrial Light & Magic in the late 1990's and early 2000's, and it was originally distributed publicly as a component of `OpenEXR `_. Imath is now a project of the `Academy Software Foundation `_ and is still maintained by the OpenEXR project. Imath is Version 3 because it was previously distributed as a component of OpenEXR v1 and v2. Imath-3.1.4/docs/requirements.txt000066400000000000000000000000301417213455000167700ustar00rootroot00000000000000breathe sphinx == 4.0.3 Imath-3.1.4/share/000077500000000000000000000000001417213455000136655ustar00rootroot00000000000000Imath-3.1.4/share/ci/000077500000000000000000000000001417213455000142605ustar00rootroot00000000000000Imath-3.1.4/share/ci/scripts/000077500000000000000000000000001417213455000157475ustar00rootroot00000000000000Imath-3.1.4/share/ci/scripts/linux/000077500000000000000000000000001417213455000171065ustar00rootroot00000000000000Imath-3.1.4/share/ci/scripts/linux/install_boost.sh000077500000000000000000000013631417213455000223240ustar00rootroot00000000000000#!/usr/bin/env bash set -ex BOOST_VERSION="$1" BOOST_MAJOR_MINOR=$(echo "${BOOST_VERSION}" | cut -d. -f-2) BOOST_MAJOR=$(echo "${BOOST_VERSION}" | cut -d. -f-1) BOOST_MINOR=$(echo "${BOOST_MAJOR_MINOR}" | cut -d. -f2-) BOOST_PATCH=$(echo "${BOOST_VERSION}" | cut -d. -f3-) BOOST_VERSION_U="${BOOST_MAJOR}_${BOOST_MINOR}_${BOOST_PATCH}" mkdir _boost cd _boost wget -q https://sourceforge.net/projects/boost/files/boost/${BOOST_VERSION}/boost_${BOOST_VERSION_U}.tar.gz tar -xzf boost_${BOOST_VERSION_U}.tar.gz cd boost_${BOOST_VERSION_U} sh bootstrap.sh ./b2 install -j4 variant=release toolset=gcc \ --with-system \ --with-regex \ --with-filesystem \ --with-thread \ --with-python \ --prefix=/usr/local cd ../.. rm -rf _boost Imath-3.1.4/share/ci/scripts/linux/install_cmake.sh000077500000000000000000000005771417213455000222640ustar00rootroot00000000000000#!/usr/bin/env bash set -ex echo "Updating to newer cmake to enable python-3" CMAKE_VERSION="$1" curl --location "https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-Linux-x86_64.sh" -o /tmp/cmake.sh cd /tmp && sh cmake.sh --skip-license --prefix=/usr/local --exclude-subdir rm /tmp/cmake.sh echo $(ls /usr/local/bin) echo $(which cmake) Imath-3.1.4/share/ci/scripts/linux/install_gdb.sh000077500000000000000000000005611417213455000217310ustar00rootroot00000000000000#!/usr/bin/env bash set -ex GDB_VERSION="8.3" echo "Installing gdb-${GDB_VERSION}" wget -q https://ftp.gnu.org/gnu/gdb/gdb-${GDB_VERSION}.tar.xz tar -xvf gdb-${GDB_VERSION}.tar.xz cd gdb-${GDB_VERSION} # Build gdb ./configure --prefix=/usr \ --with-system-readline \ --with-python=/usr/bin/python3 && make sudo make -C gdb install cd .. Imath-3.1.4/share/ci/scripts/linux/install_six.sh000077500000000000000000000005061417213455000217770ustar00rootroot00000000000000#!/usr/bin/env bash set -ex SIX_VERSION="1.12.0" echo "Installing six-${SIX_VERSION}" wget -q https://files.pythonhosted.org/packages/source/s/six/six-${SIX_VERSION}.tar.gz tar -xvf six-${SIX_VERSION}.tar.gz cd six-${SIX_VERSION} # Install six python3 setup.py build sudo python3 setup.py install --optimize=1 cd .. Imath-3.1.4/share/ci/scripts/linux/install_sonar.sh000077500000000000000000000013141417213455000223140ustar00rootroot00000000000000#!/usr/bin/env bash set -ex SONAR_VERSION="$1" mkdir _sonar cd _sonar wget https://sonarcloud.io/static/cpp/build-wrapper-linux-x86.zip unzip build-wrapper-linux-x86.zip mv build-wrapper-linux-x86 /var/opt/. ln -s /var/opt/build-wrapper-linux-x86/build-wrapper-linux-x86-64 /usr/bin/build-wrapper-linux-x86-64 echo $(build-wrapper-linux-x86-64 --help) wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-${SONAR_VERSION}-linux.zip unzip sonar-scanner-cli-${SONAR_VERSION}-linux.zip mv sonar-scanner-${SONAR_VERSION}-linux /var/opt/. ln -s /var/opt/sonar-scanner-${SONAR_VERSION}-linux/bin/sonar-scanner /usr/bin/sonar-scanner echo $(sonar-scanner --help) cd .. rm -rf _sonar Imath-3.1.4/share/ci/scripts/linux/install_valgrind.sh000077500000000000000000000011551417213455000230030ustar00rootroot00000000000000#!/usr/bin/env bash set -ex VALGRIND_VERSION="3.15.0" echo "Updating to Valgrind ${VALGRIND_VERSION}" wget -q https://sourceware.org/ftp/valgrind/valgrind-${VALGRIND_VERSION}.tar.bz2 tar -xjf valgrind-${VALGRIND_VERSION}.tar.bz2 cd valgrind-${VALGRIND_VERSION} # Build valgrind sed -i 's|/doc/valgrind||' docs/Makefile.in && ./configure --prefix=/usr \ --datadir=/usr/share/doc/valgrind-${VALGRIND_VERSION} && make # Test the build - disabled # NOTE: if enabled, must install prerequisites gedb-8.3 and six-1.12.0 # make regtest # Install valgrind sudo make install echo $(which valgrind) cd .. Imath-3.1.4/share/ci/scripts/linux/log_valgrind.sh000077500000000000000000000004651417213455000221210ustar00rootroot00000000000000#!/usr/bin/env bash set -ex LOGDIR="$1" if [[ -d ${LOGDIR}/Testing/Temporary ]]; then for log in ${LOGDIR}/Testing/Temporary/MemoryChecker.*.log; do echo "========================== " ${log##*/} " ==========================" cat $log echo done else echo "Memcheck log files not found." fi Imath-3.1.4/share/ci/scripts/linux/run_gcov.sh000077500000000000000000000006271417213455000212740ustar00rootroot00000000000000!/usr/bin/env bash set -ex mkdir _coverage cd _coverage # The sed command below converts from: # ../_build/src/OpenEXR/CMakeFiles/OpenColorIO.dir/ops/Exponent.gcno # to: # ../src/OpenEXR/ops/Exponent.cpp for g in $(find ../_build -name "*.gcno" -type f); do gcov -l -p -o $(dirname "$g") $(echo "$g" | sed -e 's/\/_build\//\//' -e 's/\.gcno/\.cpp/' -e 's/\/CMakeFiles.*\.dir\//\//') done cd .. Imath-3.1.4/share/ci/scripts/macos/000077500000000000000000000000001417213455000170515ustar00rootroot00000000000000Imath-3.1.4/share/ci/scripts/macos/install_boost.sh000077500000000000000000000001621417213455000222630ustar00rootroot00000000000000#!/usr/bin/env bash set -ex brew update brew install boost brew install boost-python brew install boost-python3 Imath-3.1.4/share/ci/scripts/macos/install_python.sh000077500000000000000000000021641417213455000224620ustar00rootroot00000000000000#!/usr/bin/env bash set -ex PYTHON_VERSION="$1" PYTHON_MAJOR="$(echo ${PYTHON_VERSION} | cut -f 1 -d .)" MACOS_MAJOR="$(sw_vers -productVersion | cut -f 1 -d .)" MACOS_MINOR="$(sw_vers -productVersion | cut -f 2 -d .)" echo "Installing Python ${PYTHON_VERSION} Major ${PYTHON_MAJOR}" # This workaround is needed for building Python on macOS >= 10.14: # https://developer.apple.com/documentation/xcode_release_notes/xcode_10_release_notes if [[ "$MACOS_MAJOR" -gt 9 && "$MACOS_MINOR" -gt 13 ]]; then sudo installer \ -pkg /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_${MACOS_MAJOR}.${MACOS_MINOR}.pkg \ -target / fi unset CFLAGS brew update brew install pyenv openssl CFLAGS="-I/usr/local/Cellar/openssl/1.0.2s/include" LDFLAGS="-L/usr/local/Cellar/openssl/1.0.2s/lib" echo 'eval "$(pyenv init -)"' >> .bash_profile source .bash_profile env PYTHON_CONFIGURE_OPTS="--enable-framework" pyenv install -v ${PYTHON_VERSION} pyenv global ${PYTHON_VERSION} sudo pip install --upgrade pip if [[ $PYTHON_MAJOR -eq 2 ]]; then sudo pip install numpy else sudo pip3 install numpy fi Imath-3.1.4/share/ci/scripts/windows/000077500000000000000000000000001417213455000174415ustar00rootroot00000000000000Imath-3.1.4/share/ci/scripts/windows/install_boost.ps1000077500000000000000000000040211417213455000227420ustar00rootroot00000000000000# # TODO: fix this script to work with sourceforge archive! # $homeDir = (pwd) $boostVersion = $Args[0] $boostWorkingDir = $Args[1] $pythonVersion = $Args[2] $boostRoot = "${boostWorkingDir}\_boost" $boostMajorMinor = [io.path]::GetFileNameWithoutExtension("$boostVersion") $boostVersionConcise = $boostVersion -replace '[.]','' $boostArray = $boostVersion -split "\." $boostMajor = $boostArray[0] $boostMinor = $boostArray[1] $boostPatch = $boostArray[2]; $boostVersionU = "boost_${boostMajor}_${boostMinor}_${boostPatch}" $boostArchive = "https://sourceforge.net/projects/boost/files/boost-binaries/1.70.0/boost_1_70_0-msvc-14.1-64.exe" $boostBuildPath = "${boostRoot}\boost-${boostVersion}\${boostVersionU}" $pythonMajor = ($pythonVersion -split '\.')[0] $pythonMinor = ($pythonVersion -split '\.')[1] $pythonMajorMinor = "${pythonMajor}.${pythonMinor}" Write-Host "boostRoot ${boostRoot}" Write-Host "boostBuildPath ${boostBuildPath}" Write-Host "pythonMajorMinor ${pythonMajorMinor}" if (-NOT (Test-Path $boostRoot)) { New-Item -ItemType Directory $boostRoot } cd $boostRoot # Retrieve/expand archive Write-Host "Retrieving ${boostArchive}" Invoke-WebRequest $boostArchive -OutFile "boost-${boostVersion}.zip" Write-Host "Expanding archive boost-${boostVersion}.zip" Expand-Archive "boost-${boostVersion}.zip" cd "${boostBuildPath}\tools\build" # Configure and install boost echo "Configuring boost..." & .\bootstrap.bat --with-python-version=$pythonMajorMinor & .\b2 install -j4 variant=release toolset=msvc ` --prefix=$boostBuildPath ` --address-model=64 $env:Path = "${boostBuildPath}\bin;${boostBuildPath};$env:Path" cd $boostBuildPath # Build boost-python2 libs echo "Building boost python..." & b2 --with-python ` --address-model=64 ` --prefix=$boostBuildPath ` toolset=msvc cd $homeDir $env:BOOST_ROOT = $boostBuildPath echo "BOOST_ROOT = ${env:BOOST_ROOT}" echo "::set-env name=BOOST_ROOT::$boostBuildPath" echo "::add-path::$boostBuildPath" Imath-3.1.4/share/ci/scripts/windows/install_cmake.ps1000077500000000000000000000007041417213455000227000ustar00rootroot00000000000000$cmakeVersion = $Args[0] $cmakeMajorMinor = [io.path]::GetFileNameWithoutExtension("$cmakeVersion") Invoke-WebRequest "https://cmake.org/files/v${cmakeMajorMinor}/cmake-${cmakeVersion}-win64-x64.zip" -OutFile "C:\cmake-${cmakeVersion}-win64-x64.zip" Expand-Archive "C:\cmake-${cmakeVersion}-win64-x64.zip" -DestinationPath C:\ Rename-Item -Path "C:\cmake-${cmakeVersion}-win64-x64" -NewName C:\_cmake Write-Host "##vso[task.prependpath]C:\_cmake\bin" Imath-3.1.4/share/ci/scripts/windows/install_python.ps1000077500000000000000000000021331417213455000231370ustar00rootroot00000000000000$homeDir = (pwd) $pythonVersion = $Args[0] $pythonWorkingDir = $Args[1] $pythonMajor = ($pythonVersion -split '\.')[0] $pythonMinor = ($pythonVersion -split '\.')[1] $pythonRoot = "${pythonWorkingDir}\_python${pythonMajor}${pythonMinor}" Write-Host "Installing python version ${pythonVersion} ${pythonRoot}" if (-NOT (Test-Path $pythonRoot)) { New-Item -ItemType Directory $pythonRoot } cd $pythonRoot if ($pythonMajor -eq "3") { Invoke-WebRequest "https://www.python.org/ftp/python/${pythonVersion}/python-${pythonVersion}.exe" -OutFile "python-${pythonVersion}-amd64.exe" Invoke-Expression "./python-${pythonVersion}-amd64.exe /quiet /l* _python.log TargetDir=${pythonRoot} PrependPath=1" } else { Invoke-WebRequest "https://www.python.org/ftp/python/${pythonVersion}/python-${pythonVersion}.amd64.msi" -OutFile "python-${pythonVersion}-amd64.msi" msiexec /i "python-${pythonVersion}-amd64.msi" /quiet /l* _python.log TARGETDIR="${pythonRoot}" PrependPath=1 } cd $homeDir echo "::set-env name=PYTHON_ROOT::$pythonRoot" echo "::add-path::$pythonRoot" echo "::add-path::$pythonRoot/Scripts"Imath-3.1.4/share/ci/scripts/windows/install_zlib.ps1000077500000000000000000000023041417213455000225560ustar00rootroot00000000000000$homeDir = (pwd) $zlibVersion = $Args[0] $zlibWorkingDir = $Args[1] $zlibMajorMinor = [io.path]::GetFileNameWithoutExtension("$zlibVersion") $zlibVersionConcise = $zlibVersion -replace '[.]','' $zlibArchive = "https://www.zlib.net/zlib${zlibVersionConcise}.zip" $zlibRoot = "${zlibWorkingDir}\_zlib" $zlibBuildPath = "${zlibWorkingDir}\zlib-${zlibVersion}" $zlibDllPath = "${zlibRoot}\bin" $msbuild = "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin\msbuild.exe" Write-Host "Retrieving ${zlibArchive}" Invoke-WebRequest "${zlibArchive}" -OutFile "${zlibBuildPath}.zip" Write-Host "Expanding archive ${zlibBuildPath}.zip" Expand-Archive "${zlibBuildPath}.zip" -DestinationPath "${zlibWorkingDir}" if (-NOT (Test-Path $zlibRoot)) { New-Item -ItemType Directory $zlibRoot } cd $zlibBuildPath mkdir _build cd _build cmake .. -G"Visual Studio 16 2019" -DCMAKE_INSTALL_PREFIX="${zlibRoot}" Write-Host "Building ${zlibBuildPath}\_build\INSTALL.vcxproj" -foregroundcolor green & "${msbuild}" "${zlibBuildPath}\_build\INSTALL.vcxproj" /P:Configuration=Release cd $homeDir echo "::set-env name=ZLIB_ROOT::$zlibRoot" echo "::add-path::$zlibDllPath" Imath-3.1.4/sonar-project.properties000066400000000000000000000015401417213455000174670ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. # # SonarCloud analysis configuration file # https://sonarcloud.io/documentation/analysis/analysis-parameters sonar.host.url=https://sonarcloud.io # Required metadata sonar.organization=academysoftwarefoundation sonar.projectKey=AcademySoftwareFoundation_Imath sonar.projectName=Imath sonar.projectVersion=3.0 # Project links sonar.links.homepage=http://openexr.com sonar.links.ci=https://github.com/AcademySoftwareFoundation/imath/actions sonar.links.scm=https://github.com/AcademySoftwareFoundation/imath sonar.links.issue=https://github.com/AcademySoftwareFoundation/imath/issues # Source properties sonar.exclusions=src/bindings/java/**,*.java # C/C++ analyzer properties sonar.cfamily.build-wrapper-output=_build/bw_output sonar.cfamily.gcov.reportsPath=_coverage Imath-3.1.4/src/000077500000000000000000000000001417213455000133525ustar00rootroot00000000000000Imath-3.1.4/src/Imath/000077500000000000000000000000001417213455000144145ustar00rootroot00000000000000Imath-3.1.4/src/Imath/.cvsignore000066400000000000000000000002451417213455000164150ustar00rootroot00000000000000Makefile Makefile.in config.h.in config.h config.log config.status configure libtool stamp-h aclocal.m4 OpenEXR.pc autom4te.cache ltmain.sh stamp-h.in depcomp .deps Imath-3.1.4/src/Imath/CMakeLists.txt000066400000000000000000000016321417213455000171560ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. imath_define_library(Imath PRIV_EXPORT IMATH_EXPORTS CURDIR ${CMAKE_CURRENT_SOURCE_DIR} SOURCES half.cpp ImathColorAlgo.cpp ImathFun.cpp ImathMatrixAlgo.cpp ImathRandom.cpp toFloat.h HEADERS half.h halfFunction.h halfLimits.h ImathBox.h ImathBoxAlgo.h ImathColor.h ImathColorAlgo.h ImathEuler.h ImathExport.h ImathForward.h ImathFrame.h ImathFrustum.h ImathFrustumTest.h ImathFun.h ImathGL.h ImathGLU.h ImathInt64.h ImathInterval.h ImathLine.h ImathLineAlgo.h ImathMath.h ImathMatrix.h ImathMatrixAlgo.h ImathNamespace.h ImathPlane.h ImathPlatform.h ImathQuat.h ImathRandom.h ImathRoots.h ImathShear.h ImathSphere.h ImathTypeTraits.h ImathVec.h ImathVecAlgo.h ) Imath-3.1.4/src/Imath/ImathBox.h000066400000000000000000000571661417213455000163170ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Axis-aligned bounding box // #ifndef INCLUDED_IMATHBOX_H #define INCLUDED_IMATHBOX_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// The `Box` template represents an axis-aligned bounding box defined by /// minimum and maximum values of type `V`. The `min` and `max` members are /// public. /// /// The type `V` is typically an Imath vector (i.e. `V2i`, `V3f`, etc) and must /// implement an index `operator[]` that returns a type (typically as scalar) /// that supports assignment, comparison, and arithmetic operators. /// /// `V` must also provide a constructor that takes a float and/or double for /// use in initializing the box. /// /// `V` must also provide a function `V::dimensions()` which returns the /// number of dimensions in the class (since its assumed its a vector) -- /// preferably, this returns a constant expression, typically 2 or 3. /// template class IMATH_EXPORT_TEMPLATE_TYPE Box { public: /// @{ /// @name Direct access to bounds /// The minimum value of the box. V min; /// The maximum value of the box. V max; /// @} /// @{ /// @name Constructors /// Construct an empty bounding box. This initializes the mimimum to /// std::numeric_limits::max() and the maximum to /// std::numeric_limits::lowest(). IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT; /// Construct a bounding box that contains a single point. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const V& point) IMATH_NOEXCEPT; /// Construct a bounding box with the given minimum and maximum values. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const V& minV, const V& maxV) IMATH_NOEXCEPT; /// @} /// @{ /// @name Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Box& src) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Box& src) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Manipulation /// Set the box to be empty. A box is empty if the mimimum is greater /// than the maximum. makeEmpty() sets the mimimum to `V::baseTypeMax()` /// and the maximum to `V::baseTypeLowest()`. IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT; /// Extend the box to include the given point. IMATH_HOSTDEVICE void extendBy (const V& point) IMATH_NOEXCEPT; /// Extend the box to include the given box. IMATH_HOSTDEVICE void extendBy (const Box& box) IMATH_NOEXCEPT; /// Make the box include the entire range of `V`. IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT; /// @} /// @{ /// @name Query /// Return the size of the box. The size is of type `V`, defined /// as `(max-min)`. An empty box has a size of `V(0)`, i.e. 0 in /// each dimension. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 V size() const IMATH_NOEXCEPT; /// Return the center of the box. The center is defined as /// `(max+min)/2`. The center of an empty box is undefined. IMATH_HOSTDEVICE constexpr V center() const IMATH_NOEXCEPT; /// Return true if the given point is inside the box, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const V& point) const IMATH_NOEXCEPT; /// Return true if the given box is inside the box, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box& box) const IMATH_NOEXCEPT; /// Return the major axis of the box. The major axis is the dimension with /// the greatest difference between maximum and minimum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT; /// Return true if the box is empty, false otherwise. An empty box's /// minimum is greater than its maximum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT; /// Return true if the box is larger than a single point, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT; /// Return true if the box contains all points, false otherwise. /// An infinite box has a mimimum of`V::baseTypeLowest()` /// and a maximum of `V::baseTypeMax()`. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT; /// @} }; //-------------------- // Convenient typedefs //-------------------- /// 2D box of base type `short`. typedef Box Box2s; /// 2D box of base type `int`. typedef Box Box2i; /// 2D box of base type `int64_t`. typedef Box Box2i64; /// 2D box of base type `float`. typedef Box Box2f; /// 2D box of base type `double`. typedef Box Box2d; /// 3D box of base type `short`. typedef Box Box3s; /// 3D box of base type `int`. typedef Box Box3i; /// 3D box of base type `int64_t`. typedef Box Box3i64; /// 3D box of base type `float`. typedef Box Box3f; /// 3D box of base type `double`. typedef Box Box3d; template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box::Box() IMATH_NOEXCEPT { makeEmpty(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box::Box (const V& point) IMATH_NOEXCEPT { min = point; max = point; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box::Box (const V& minV, const V& maxV) IMATH_NOEXCEPT { min = minV; max = maxV; } template IMATH_HOSTDEVICE constexpr inline bool Box::operator== (const Box& src) const IMATH_NOEXCEPT { return (min == src.min && max == src.max); } template IMATH_HOSTDEVICE constexpr inline bool Box::operator!= (const Box& src) const IMATH_NOEXCEPT { return (min != src.min || max != src.max); } template IMATH_HOSTDEVICE inline void Box::makeEmpty() IMATH_NOEXCEPT { min = V (V::baseTypeMax()); max = V (V::baseTypeLowest()); } template IMATH_HOSTDEVICE inline void Box::makeInfinite() IMATH_NOEXCEPT { min = V (V::baseTypeLowest()); max = V (V::baseTypeMax()); } template IMATH_HOSTDEVICE inline void Box::extendBy (const V& point) IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (point[i] < min[i]) min[i] = point[i]; if (point[i] > max[i]) max[i] = point[i]; } } template IMATH_HOSTDEVICE inline void Box::extendBy (const Box& box) IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (box.min[i] < min[i]) min[i] = box.min[i]; if (box.max[i] > max[i]) max[i] = box.max[i]; } } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box::intersects (const V& point) const IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (point[i] < min[i] || point[i] > max[i]) return false; } return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box::intersects (const Box& box) const IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (box.max[i] < min[i] || box.min[i] > max[i]) return false; } return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline V Box::size() const IMATH_NOEXCEPT { if (isEmpty()) return V (0); return max - min; } template IMATH_HOSTDEVICE constexpr inline V Box::center() const IMATH_NOEXCEPT { return (max + min) / 2; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box::isEmpty() const IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (max[i] < min[i]) return true; } return false; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box::isInfinite() const IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (min[i] != V::baseTypeLowest() || max[i] != V::baseTypeMax()) return false; } return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box::hasVolume() const IMATH_NOEXCEPT { for (unsigned int i = 0; i < min.dimensions(); i++) { if (max[i] <= min[i]) return false; } return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline unsigned int Box::majorAxis() const IMATH_NOEXCEPT { unsigned int major = 0; V s = size(); for (unsigned int i = 1; i < min.dimensions(); i++) { if (s[i] > s[major]) major = i; } return major; } //------------------------------------------------------------------- // // Partial class specializations for Imath::Vec2 and Imath::Vec3 // //------------------------------------------------------------------- template class Box; /// /// The Box> template represents a 2D bounding box defined by /// minimum and maximum values of type Vec2. The min and max members are /// public. /// template class IMATH_EXPORT_TEMPLATE_TYPE Box> { public: /// @{ /// @name Direct access to bounds /// The minimum value of the box. Vec2 min; /// The maximum value of the box. Vec2 max; /// @} /// @{ /// @name Constructors and Assignment /// Empty by default IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT; /// Construct a bounding box that contains a single point. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec2& point) IMATH_NOEXCEPT; /// Construct a bounding box with the given minimum and maximum points IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec2& minT, const Vec2& maxT) IMATH_NOEXCEPT; /// @} /// @{ /// @name Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Box>& src) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Box>& src) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Manipulation /// Set the Box to be empty. A Box is empty if the mimimum is /// greater than the maximum. makeEmpty() sets the mimimum to /// std::numeric_limits::max() and the maximum to /// std::numeric_limits::lowest(). IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT; /// Extend the Box to include the given point. IMATH_HOSTDEVICE void extendBy (const Vec2& point) IMATH_NOEXCEPT; /// Extend the Box to include the given box. IMATH_HOSTDEVICE void extendBy (const Box>& box) IMATH_NOEXCEPT; /// Make the box include the entire range of T. IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT; /// @} /// @{ /// @name Query /// Return the size of the box. The size is of type `V`, defined as /// `(max-min)`. An empty box has a size of `V(0)`, i.e. 0 in each dimension. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec2 size() const IMATH_NOEXCEPT; /// Return the center of the box. The center is defined as /// `(max+min)/2`. The center of an empty box is undefined. IMATH_HOSTDEVICE constexpr Vec2 center() const IMATH_NOEXCEPT; /// Return true if the given point is inside the box, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Vec2& point) const IMATH_NOEXCEPT; /// Return true if the given box is inside the box, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box>& box) const IMATH_NOEXCEPT; /// Return the major axis of the box. The major axis is the dimension with /// the greatest difference between maximum and minimum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT; /// Return true if the box is empty, false otherwise. An empty box's /// minimum is greater than its maximum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT; /// Return true if the box is larger than a single point, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT; /// Return true if the box contains all points, false otherwise. /// An infinite box has a mimimum of `V::baseTypeMin()` /// and a maximum of `V::baseTypeMax()`. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT; /// @} }; //---------------- // Implementation //---------------- template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box>::Box() IMATH_NOEXCEPT { makeEmpty(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box>::Box (const Vec2& point) IMATH_NOEXCEPT { min = point; max = point; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box>::Box (const Vec2& minT, const Vec2& maxT) IMATH_NOEXCEPT { min = minT; max = maxT; } template IMATH_HOSTDEVICE constexpr inline bool Box>::operator== (const Box>& src) const IMATH_NOEXCEPT { return (min == src.min && max == src.max); } template IMATH_HOSTDEVICE constexpr inline bool Box>::operator!= (const Box>& src) const IMATH_NOEXCEPT { return (min != src.min || max != src.max); } template IMATH_HOSTDEVICE inline void Box>::makeEmpty() IMATH_NOEXCEPT { min = Vec2 (Vec2::baseTypeMax()); max = Vec2 (Vec2::baseTypeLowest()); } template IMATH_HOSTDEVICE inline void Box>::makeInfinite() IMATH_NOEXCEPT { min = Vec2 (Vec2::baseTypeLowest()); max = Vec2 (Vec2::baseTypeMax()); } template IMATH_HOSTDEVICE inline void Box>::extendBy (const Vec2& point) IMATH_NOEXCEPT { if (point[0] < min[0]) min[0] = point[0]; if (point[0] > max[0]) max[0] = point[0]; if (point[1] < min[1]) min[1] = point[1]; if (point[1] > max[1]) max[1] = point[1]; } template IMATH_HOSTDEVICE inline void Box>::extendBy (const Box>& box) IMATH_NOEXCEPT { if (box.min[0] < min[0]) min[0] = box.min[0]; if (box.max[0] > max[0]) max[0] = box.max[0]; if (box.min[1] < min[1]) min[1] = box.min[1]; if (box.max[1] > max[1]) max[1] = box.max[1]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::intersects (const Vec2& point) const IMATH_NOEXCEPT { if (point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1]) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::intersects (const Box>& box) const IMATH_NOEXCEPT { if (box.max[0] < min[0] || box.min[0] > max[0] || box.max[1] < min[1] || box.min[1] > max[1]) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec2 Box>::size() const IMATH_NOEXCEPT { if (isEmpty()) return Vec2 (0); return max - min; } template IMATH_HOSTDEVICE constexpr inline Vec2 Box>::center() const IMATH_NOEXCEPT { return (max + min) / 2; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::isEmpty() const IMATH_NOEXCEPT { if (max[0] < min[0] || max[1] < min[1]) return true; return false; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::isInfinite() const IMATH_NOEXCEPT { if (min[0] != std::numeric_limits::lowest() || max[0] != std::numeric_limits::max() || min[1] != std::numeric_limits::lowest() || max[1] != std::numeric_limits::max()) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::hasVolume() const IMATH_NOEXCEPT { if (max[0] <= min[0] || max[1] <= min[1]) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline unsigned int Box>::majorAxis() const IMATH_NOEXCEPT { unsigned int major = 0; Vec2 s = size(); if (s[1] > s[major]) major = 1; return major; } /// /// The Box template represents a 3D bounding box defined by /// minimum and maximum values of type Vec3. /// template class IMATH_EXPORT_TEMPLATE_TYPE Box> { public: /// @{ /// @name Direct access to bounds /// The minimum value of the box. Vec3 min; /// The maximum value of the box. Vec3 max; /// @} /// @{ /// @name Constructors /// Empty by default IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box() IMATH_NOEXCEPT; /// Construct a bounding box that contains a single point. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec3& point) IMATH_NOEXCEPT; /// Construct a bounding box with the given minimum and maximum points IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Box (const Vec3& minT, const Vec3& maxT) IMATH_NOEXCEPT; /// @} /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Box>& src) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Box>& src) const IMATH_NOEXCEPT; /// Set the Box to be empty. A Box is empty if the mimimum is /// greater than the maximum. makeEmpty() sets the mimimum to /// std::numeric_limits::max() and the maximum to /// std::numeric_limits::lowest(). IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT; /// Extend the Box to include the given point. IMATH_HOSTDEVICE void extendBy (const Vec3& point) IMATH_NOEXCEPT; /// Extend the Box to include the given box. IMATH_HOSTDEVICE void extendBy (const Box>& box) IMATH_NOEXCEPT; /// Make the box include the entire range of T. IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT; /// Return the size of the box. The size is of type `V`, defined as /// (max-min). An empty box has a size of V(0), i.e. 0 in each dimension. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 size() const IMATH_NOEXCEPT; /// Return the center of the box. The center is defined as /// (max+min)/2. The center of an empty box is undefined. IMATH_HOSTDEVICE constexpr Vec3 center() const IMATH_NOEXCEPT; /// Return true if the given point is inside the box, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Vec3& point) const IMATH_NOEXCEPT; /// Return true if the given box is inside the box, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box>& box) const IMATH_NOEXCEPT; /// Return the major axis of the box. The major axis is the dimension with /// the greatest difference between maximum and minimum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 unsigned int majorAxis() const IMATH_NOEXCEPT; /// Return true if the box is empty, false otherwise. An empty box's /// minimum is greater than its maximum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT; /// Return true if the box is larger than a single point, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT; /// Return true if the box contains all points, false otherwise. /// An infinite box has a mimimum of`V::baseTypeMin()` /// and a maximum of `V::baseTypeMax()`. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT; }; //---------------- // Implementation //---------------- template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box>::Box() IMATH_NOEXCEPT { makeEmpty(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box>::Box (const Vec3& point) IMATH_NOEXCEPT { min = point; max = point; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Box>::Box (const Vec3& minT, const Vec3& maxT) IMATH_NOEXCEPT { min = minT; max = maxT; } template IMATH_HOSTDEVICE constexpr inline bool Box>::operator== (const Box>& src) const IMATH_NOEXCEPT { return (min == src.min && max == src.max); } template IMATH_HOSTDEVICE constexpr inline bool Box>::operator!= (const Box>& src) const IMATH_NOEXCEPT { return (min != src.min || max != src.max); } template IMATH_HOSTDEVICE inline void Box>::makeEmpty() IMATH_NOEXCEPT { min = Vec3 (Vec3::baseTypeMax()); max = Vec3 (Vec3::baseTypeLowest()); } template IMATH_HOSTDEVICE inline void Box>::makeInfinite() IMATH_NOEXCEPT { min = Vec3 (Vec3::baseTypeLowest()); max = Vec3 (Vec3::baseTypeMax()); } template IMATH_HOSTDEVICE inline void Box>::extendBy (const Vec3& point) IMATH_NOEXCEPT { if (point[0] < min[0]) min[0] = point[0]; if (point[0] > max[0]) max[0] = point[0]; if (point[1] < min[1]) min[1] = point[1]; if (point[1] > max[1]) max[1] = point[1]; if (point[2] < min[2]) min[2] = point[2]; if (point[2] > max[2]) max[2] = point[2]; } template IMATH_HOSTDEVICE inline void Box>::extendBy (const Box>& box) IMATH_NOEXCEPT { if (box.min[0] < min[0]) min[0] = box.min[0]; if (box.max[0] > max[0]) max[0] = box.max[0]; if (box.min[1] < min[1]) min[1] = box.min[1]; if (box.max[1] > max[1]) max[1] = box.max[1]; if (box.min[2] < min[2]) min[2] = box.min[2]; if (box.max[2] > max[2]) max[2] = box.max[2]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::intersects (const Vec3& point) const IMATH_NOEXCEPT { if (point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1] || point[2] < min[2] || point[2] > max[2]) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::intersects (const Box>& box) const IMATH_NOEXCEPT { if (box.max[0] < min[0] || box.min[0] > max[0] || box.max[1] < min[1] || box.min[1] > max[1] || box.max[2] < min[2] || box.min[2] > max[2]) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3 Box>::size() const IMATH_NOEXCEPT { if (isEmpty()) return Vec3 (0); return max - min; } template IMATH_HOSTDEVICE constexpr inline Vec3 Box>::center() const IMATH_NOEXCEPT { return (max + min) / 2; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::isEmpty() const IMATH_NOEXCEPT { if (max[0] < min[0] || max[1] < min[1] || max[2] < min[2]) return true; return false; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::isInfinite() const IMATH_NOEXCEPT { if (min[0] != std::numeric_limits::lowest() || max[0] != std::numeric_limits::max() || min[1] != std::numeric_limits::lowest() || max[1] != std::numeric_limits::max() || min[2] != std::numeric_limits::lowest() || max[2] != std::numeric_limits::max()) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Box>::hasVolume() const IMATH_NOEXCEPT { if (max[0] <= min[0] || max[1] <= min[1] || max[2] <= min[2]) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline unsigned int Box>::majorAxis() const IMATH_NOEXCEPT { unsigned int major = 0; Vec3 s = size(); if (s[1] > s[major]) major = 1; if (s[2] > s[major]) major = 2; return major; } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHBOX_H Imath-3.1.4/src/Imath/ImathBoxAlgo.h000066400000000000000000000557231417213455000171170ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Axis-aligned bounding box utility functions // #ifndef INCLUDED_IMATHBOXALGO_H #define INCLUDED_IMATHBOXALGO_H #include "ImathNamespace.h" #include "ImathBox.h" #include "ImathLineAlgo.h" #include "ImathMatrix.h" #include "ImathPlane.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// Clip the coordinates of a point, `p`, against a `Box`, `box`. /// Return the closest point to `p` that is inside the box. /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T clip (const T& p, const Box& box) IMATH_NOEXCEPT { T q; for (int i = 0; i < int (box.min.dimensions()); i++) { if (p[i] < box.min[i]) q[i] = box.min[i]; else if (p[i] > box.max[i]) q[i] = box.max[i]; else q[i] = p[i]; } return q; } /// /// Return the point in or on the `Box`, `box`, that is closesest to /// the point, `p`. /// template IMATH_HOSTDEVICE constexpr inline T closestPointInBox (const T& p, const Box& box) IMATH_NOEXCEPT { return clip (p, box); } /// /// Return the point on the surface of the `Box`, `box`, that is /// closest to point `p`. /// /// If the box is empty, return `p`. /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 closestPointOnBox (const Vec3& p, const Box>& box) IMATH_NOEXCEPT { if (box.isEmpty()) return p; Vec3 q = closestPointInBox (p, box); if (q == p) { Vec3 d1 = p - box.min; Vec3 d2 = box.max - p; Vec3 d ((d1.x < d2.x) ? d1.x : d2.x, (d1.y < d2.y) ? d1.y : d2.y, (d1.z < d2.z) ? d1.z : d2.z); if (d.x < d.y && d.x < d.z) { q.x = (d1.x < d2.x) ? box.min.x : box.max.x; } else if (d.y < d.z) { q.y = (d1.y < d2.y) ? box.min.y : box.max.y; } else { q.z = (d1.z < d2.z) ? box.min.z : box.max.z; } } return q; } /// /// Transform a 3D box by a matrix, and compute a new box that /// tightly encloses the transformed box. Return the transformed box. /// /// If `m` is an affine transform, then we use James Arvo's fast /// method as described in "Graphics Gems", Academic Press, 1990, /// pp. 548-550. /// /// A transformed empty box is still empty, and a transformed infinite box /// is still infinite. /// template IMATH_HOSTDEVICE Box> transform (const Box>& box, const Matrix44& m) IMATH_NOEXCEPT { if (box.isEmpty() || box.isInfinite()) return box; // // If the last column of m is (0 0 0 1) then m is an affine // transform, and we use the fast Graphics Gems trick. // if (m[0][3] == 0 && m[1][3] == 0 && m[2][3] == 0 && m[3][3] == 1) { Box> newBox; for (int i = 0; i < 3; i++) { newBox.min[i] = newBox.max[i] = (S) m[3][i]; for (int j = 0; j < 3; j++) { S a, b; a = (S) m[j][i] * box.min[j]; b = (S) m[j][i] * box.max[j]; if (a < b) { newBox.min[i] += a; newBox.max[i] += b; } else { newBox.min[i] += b; newBox.max[i] += a; } } } return newBox; } // // M is a projection matrix. Do things the naive way: // Transform the eight corners of the box, and find an // axis-parallel box that encloses the transformed corners. // Vec3 points[8]; points[0][0] = points[1][0] = points[2][0] = points[3][0] = box.min[0]; points[4][0] = points[5][0] = points[6][0] = points[7][0] = box.max[0]; points[0][1] = points[1][1] = points[4][1] = points[5][1] = box.min[1]; points[2][1] = points[3][1] = points[6][1] = points[7][1] = box.max[1]; points[0][2] = points[2][2] = points[4][2] = points[6][2] = box.min[2]; points[1][2] = points[3][2] = points[5][2] = points[7][2] = box.max[2]; Box> newBox; for (int i = 0; i < 8; i++) newBox.extendBy (points[i] * m); return newBox; } /// /// Transform a 3D box by a matrix, and compute a new box that /// tightly encloses the transformed box. The transformed box is /// returned in the `result` argument. /// /// If m is an affine transform, then we use James Arvo's fast /// method as described in "Graphics Gems", Academic Press, 1990, /// pp. 548-550. /// /// A transformed empty box is still empty, and a transformed infinite /// box is still infinite /// template IMATH_HOSTDEVICE void transform (const Box>& box, const Matrix44& m, Box>& result) IMATH_NOEXCEPT { if (box.isEmpty() || box.isInfinite()) { return; } // // If the last column of m is (0 0 0 1) then m is an affine // transform, and we use the fast Graphics Gems trick. // if (m[0][3] == 0 && m[1][3] == 0 && m[2][3] == 0 && m[3][3] == 1) { for (int i = 0; i < 3; i++) { result.min[i] = result.max[i] = (S) m[3][i]; for (int j = 0; j < 3; j++) { S a, b; a = (S) m[j][i] * box.min[j]; b = (S) m[j][i] * box.max[j]; if (a < b) { result.min[i] += a; result.max[i] += b; } else { result.min[i] += b; result.max[i] += a; } } } return; } // // M is a projection matrix. Do things the naive way: // Transform the eight corners of the box, and find an // axis-parallel box that encloses the transformed corners. // Vec3 points[8]; points[0][0] = points[1][0] = points[2][0] = points[3][0] = box.min[0]; points[4][0] = points[5][0] = points[6][0] = points[7][0] = box.max[0]; points[0][1] = points[1][1] = points[4][1] = points[5][1] = box.min[1]; points[2][1] = points[3][1] = points[6][1] = points[7][1] = box.max[1]; points[0][2] = points[2][2] = points[4][2] = points[6][2] = box.min[2]; points[1][2] = points[3][2] = points[5][2] = points[7][2] = box.max[2]; for (int i = 0; i < 8; i++) result.extendBy (points[i] * m); } /// /// Transform a 3D box by a matrix whose rightmost column `(0 0 0 1)`, /// and compute a new box that tightly encloses the transformed /// box. Return the transformed box. /// /// As in the transform() function, use James Arvo's fast method if /// possible. /// /// A transformed empty or infinite box is still empty or infinite. /// template IMATH_HOSTDEVICE Box> affineTransform (const Box>& box, const Matrix44& m) IMATH_NOEXCEPT { if (box.isEmpty() || box.isInfinite()) return box; Box> newBox; for (int i = 0; i < 3; i++) { newBox.min[i] = newBox.max[i] = (S) m[3][i]; for (int j = 0; j < 3; j++) { S a, b; a = (S) m[j][i] * box.min[j]; b = (S) m[j][i] * box.max[j]; if (a < b) { newBox.min[i] += a; newBox.max[i] += b; } else { newBox.min[i] += b; newBox.max[i] += a; } } } return newBox; } /// /// Transform a 3D box by a matrix whose rightmost column is /// `(0 0 0 1)`, and compute a new box that tightly encloses /// the transformed box. Return the transformed box in the `result` /// argument. /// /// As in the transform() function, use James Arvo's fast method if /// possible. /// /// A transformed empty or infinite box is still empty or infinite. /// template IMATH_HOSTDEVICE void affineTransform (const Box>& box, const Matrix44& m, Box>& result) IMATH_NOEXCEPT { if (box.isEmpty()) { result.makeEmpty(); return; } if (box.isInfinite()) { result.makeInfinite(); return; } for (int i = 0; i < 3; i++) { result.min[i] = result.max[i] = (S) m[3][i]; for (int j = 0; j < 3; j++) { S a, b; a = (S) m[j][i] * box.min[j]; b = (S) m[j][i] * box.max[j]; if (a < b) { result.min[i] += a; result.max[i] += b; } else { result.min[i] += b; result.max[i] += a; } } } } /// /// Compute the points where a ray, `r`, enters and exits a 3D box, `b`: /// /// Return true if the ray starts inside the box or if the ray starts /// outside and intersects the box, or return false otherwise (that /// is, if the ray does not intersect the box). /// /// The entry and exit points are the points on two of the faces of /// the box when the function returns true (the entry end exit points /// may be on either side of the ray's origin), or undefined if the /// the function returns false. /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool findEntryAndExitPoints (const Line3& r, const Box>& b, Vec3& entry, Vec3& exit) IMATH_NOEXCEPT { if (b.isEmpty()) { // // No ray intersects an empty box // return false; } // // The following description assumes that the ray's origin is outside // the box, but the code below works even if the origin is inside the // box: // // Between one and three "frontfacing" sides of the box are oriented // towards the ray's origin, and between one and three "backfacing" // sides are oriented away from the ray's origin. // We intersect the ray with the planes that contain the sides of the // box, and compare the distances between the ray's origin and the // ray-plane intersections. The ray intersects the box if the most // distant frontfacing intersection is nearer than the nearest // backfacing intersection. If the ray does intersect the box, then // the most distant frontfacing ray-plane intersection is the entry // point and the nearest backfacing ray-plane intersection is the // exit point. // const T TMAX = std::numeric_limits::max(); T tFrontMax = -TMAX; T tBackMin = TMAX; // // Minimum and maximum X sides. // if (r.dir.x >= 0) { T d1 = b.max.x - r.pos.x; T d2 = b.min.x - r.pos.x; if (r.dir.x > 1 || (abs (d1) < TMAX * r.dir.x && abs (d2) < TMAX * r.dir.x)) { T t1 = d1 / r.dir.x; T t2 = d2 / r.dir.x; if (tBackMin > t1) { tBackMin = t1; exit.x = b.max.x; exit.y = clamp (r.pos.y + t1 * r.dir.y, b.min.y, b.max.y); exit.z = clamp (r.pos.z + t1 * r.dir.z, b.min.z, b.max.z); } if (tFrontMax < t2) { tFrontMax = t2; entry.x = b.min.x; entry.y = clamp (r.pos.y + t2 * r.dir.y, b.min.y, b.max.y); entry.z = clamp (r.pos.z + t2 * r.dir.z, b.min.z, b.max.z); } } else if (r.pos.x < b.min.x || r.pos.x > b.max.x) { return false; } } else // r.dir.x < 0 { T d1 = b.min.x - r.pos.x; T d2 = b.max.x - r.pos.x; if (r.dir.x < -1 || (abs (d1) < -TMAX * r.dir.x && abs (d2) < -TMAX * r.dir.x)) { T t1 = d1 / r.dir.x; T t2 = d2 / r.dir.x; if (tBackMin > t1) { tBackMin = t1; exit.x = b.min.x; exit.y = clamp (r.pos.y + t1 * r.dir.y, b.min.y, b.max.y); exit.z = clamp (r.pos.z + t1 * r.dir.z, b.min.z, b.max.z); } if (tFrontMax < t2) { tFrontMax = t2; entry.x = b.max.x; entry.y = clamp (r.pos.y + t2 * r.dir.y, b.min.y, b.max.y); entry.z = clamp (r.pos.z + t2 * r.dir.z, b.min.z, b.max.z); } } else if (r.pos.x < b.min.x || r.pos.x > b.max.x) { return false; } } // // Minimum and maximum Y sides. // if (r.dir.y >= 0) { T d1 = b.max.y - r.pos.y; T d2 = b.min.y - r.pos.y; if (r.dir.y > 1 || (abs (d1) < TMAX * r.dir.y && abs (d2) < TMAX * r.dir.y)) { T t1 = d1 / r.dir.y; T t2 = d2 / r.dir.y; if (tBackMin > t1) { tBackMin = t1; exit.x = clamp (r.pos.x + t1 * r.dir.x, b.min.x, b.max.x); exit.y = b.max.y; exit.z = clamp (r.pos.z + t1 * r.dir.z, b.min.z, b.max.z); } if (tFrontMax < t2) { tFrontMax = t2; entry.x = clamp (r.pos.x + t2 * r.dir.x, b.min.x, b.max.x); entry.y = b.min.y; entry.z = clamp (r.pos.z + t2 * r.dir.z, b.min.z, b.max.z); } } else if (r.pos.y < b.min.y || r.pos.y > b.max.y) { return false; } } else // r.dir.y < 0 { T d1 = b.min.y - r.pos.y; T d2 = b.max.y - r.pos.y; if (r.dir.y < -1 || (abs (d1) < -TMAX * r.dir.y && abs (d2) < -TMAX * r.dir.y)) { T t1 = d1 / r.dir.y; T t2 = d2 / r.dir.y; if (tBackMin > t1) { tBackMin = t1; exit.x = clamp (r.pos.x + t1 * r.dir.x, b.min.x, b.max.x); exit.y = b.min.y; exit.z = clamp (r.pos.z + t1 * r.dir.z, b.min.z, b.max.z); } if (tFrontMax < t2) { tFrontMax = t2; entry.x = clamp (r.pos.x + t2 * r.dir.x, b.min.x, b.max.x); entry.y = b.max.y; entry.z = clamp (r.pos.z + t2 * r.dir.z, b.min.z, b.max.z); } } else if (r.pos.y < b.min.y || r.pos.y > b.max.y) { return false; } } // // Minimum and maximum Z sides. // if (r.dir.z >= 0) { T d1 = b.max.z - r.pos.z; T d2 = b.min.z - r.pos.z; if (r.dir.z > 1 || (abs (d1) < TMAX * r.dir.z && abs (d2) < TMAX * r.dir.z)) { T t1 = d1 / r.dir.z; T t2 = d2 / r.dir.z; if (tBackMin > t1) { tBackMin = t1; exit.x = clamp (r.pos.x + t1 * r.dir.x, b.min.x, b.max.x); exit.y = clamp (r.pos.y + t1 * r.dir.y, b.min.y, b.max.y); exit.z = b.max.z; } if (tFrontMax < t2) { tFrontMax = t2; entry.x = clamp (r.pos.x + t2 * r.dir.x, b.min.x, b.max.x); entry.y = clamp (r.pos.y + t2 * r.dir.y, b.min.y, b.max.y); entry.z = b.min.z; } } else if (r.pos.z < b.min.z || r.pos.z > b.max.z) { return false; } } else // r.dir.z < 0 { T d1 = b.min.z - r.pos.z; T d2 = b.max.z - r.pos.z; if (r.dir.z < -1 || (abs (d1) < -TMAX * r.dir.z && abs (d2) < -TMAX * r.dir.z)) { T t1 = d1 / r.dir.z; T t2 = d2 / r.dir.z; if (tBackMin > t1) { tBackMin = t1; exit.x = clamp (r.pos.x + t1 * r.dir.x, b.min.x, b.max.x); exit.y = clamp (r.pos.y + t1 * r.dir.y, b.min.y, b.max.y); exit.z = b.min.z; } if (tFrontMax < t2) { tFrontMax = t2; entry.x = clamp (r.pos.x + t2 * r.dir.x, b.min.x, b.max.x); entry.y = clamp (r.pos.y + t2 * r.dir.y, b.min.y, b.max.y); entry.z = b.max.z; } } else if (r.pos.z < b.min.z || r.pos.z > b.max.z) { return false; } } return tFrontMax <= tBackMin; } /// /// Intersect a ray, `r`, with a 3D box, `b, and compute the intersection /// point, returned in `ip`. /// /// The intersection point is /// - the ray's origin if the ray starts inside the box /// - a point on one of the faces of the box if the ray /// starts outside the box /// - undefined when intersect() returns false /// /// @return /// - true if the ray starts inside the box or if the /// ray starts outside and intersects the box /// - false if the ray starts outside the box and intersects it, /// but the intersection is behind the ray's origin. /// - false if the ray starts outside and does not intersect it /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box>& b, const Line3& r, Vec3& ip) IMATH_NOEXCEPT { if (b.isEmpty()) { // // No ray intersects an empty box // return false; } if (b.intersects (r.pos)) { // // The ray starts inside the box // ip = r.pos; return true; } // // The ray starts outside the box. Between one and three "frontfacing" // sides of the box are oriented towards the ray, and between one and // three "backfacing" sides are oriented away from the ray. // We intersect the ray with the planes that contain the sides of the // box, and compare the distances between ray's origin and the ray-plane // intersections. // The ray intersects the box if the most distant frontfacing intersection // is nearer than the nearest backfacing intersection. If the ray does // intersect the box, then the most distant frontfacing ray-plane // intersection is the ray-box intersection. // const T TMAX = std::numeric_limits::max(); T tFrontMax = -1; T tBackMin = TMAX; // // Minimum and maximum X sides. // if (r.dir.x > 0) { if (r.pos.x > b.max.x) return false; T d = b.max.x - r.pos.x; if (r.dir.x > 1 || d < TMAX * r.dir.x) { T t = d / r.dir.x; if (tBackMin > t) tBackMin = t; } if (r.pos.x <= b.min.x) { T d = b.min.x - r.pos.x; T t = (r.dir.x > 1 || d < TMAX * r.dir.x) ? d / r.dir.x : TMAX; if (tFrontMax < t) { tFrontMax = t; ip.x = b.min.x; ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y); ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z); } } } else if (r.dir.x < 0) { if (r.pos.x < b.min.x) return false; T d = b.min.x - r.pos.x; if (r.dir.x < -1 || d > TMAX * r.dir.x) { T t = d / r.dir.x; if (tBackMin > t) tBackMin = t; } if (r.pos.x >= b.max.x) { T d = b.max.x - r.pos.x; T t = (r.dir.x < -1 || d > TMAX * r.dir.x) ? d / r.dir.x : TMAX; if (tFrontMax < t) { tFrontMax = t; ip.x = b.max.x; ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y); ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z); } } } else // r.dir.x == 0 { if (r.pos.x < b.min.x || r.pos.x > b.max.x) return false; } // // Minimum and maximum Y sides. // if (r.dir.y > 0) { if (r.pos.y > b.max.y) return false; T d = b.max.y - r.pos.y; if (r.dir.y > 1 || d < TMAX * r.dir.y) { T t = d / r.dir.y; if (tBackMin > t) tBackMin = t; } if (r.pos.y <= b.min.y) { T d = b.min.y - r.pos.y; T t = (r.dir.y > 1 || d < TMAX * r.dir.y) ? d / r.dir.y : TMAX; if (tFrontMax < t) { tFrontMax = t; ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x); ip.y = b.min.y; ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z); } } } else if (r.dir.y < 0) { if (r.pos.y < b.min.y) return false; T d = b.min.y - r.pos.y; if (r.dir.y < -1 || d > TMAX * r.dir.y) { T t = d / r.dir.y; if (tBackMin > t) tBackMin = t; } if (r.pos.y >= b.max.y) { T d = b.max.y - r.pos.y; T t = (r.dir.y < -1 || d > TMAX * r.dir.y) ? d / r.dir.y : TMAX; if (tFrontMax < t) { tFrontMax = t; ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x); ip.y = b.max.y; ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z); } } } else // r.dir.y == 0 { if (r.pos.y < b.min.y || r.pos.y > b.max.y) return false; } // // Minimum and maximum Z sides. // if (r.dir.z > 0) { if (r.pos.z > b.max.z) return false; T d = b.max.z - r.pos.z; if (r.dir.z > 1 || d < TMAX * r.dir.z) { T t = d / r.dir.z; if (tBackMin > t) tBackMin = t; } if (r.pos.z <= b.min.z) { T d = b.min.z - r.pos.z; T t = (r.dir.z > 1 || d < TMAX * r.dir.z) ? d / r.dir.z : TMAX; if (tFrontMax < t) { tFrontMax = t; ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x); ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y); ip.z = b.min.z; } } } else if (r.dir.z < 0) { if (r.pos.z < b.min.z) return false; T d = b.min.z - r.pos.z; if (r.dir.z < -1 || d > TMAX * r.dir.z) { T t = d / r.dir.z; if (tBackMin > t) tBackMin = t; } if (r.pos.z >= b.max.z) { T d = b.max.z - r.pos.z; T t = (r.dir.z < -1 || d > TMAX * r.dir.z) ? d / r.dir.z : TMAX; if (tFrontMax < t) { tFrontMax = t; ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x); ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y); ip.z = b.max.z; } } } else // r.dir.z == 0 { if (r.pos.z < b.min.z || r.pos.z > b.max.z) return false; } return tFrontMax <= tBackMin; } /// /// Return whether the the ray `ray` interects the 3D box `box`. /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Box>& box, const Line3& ray) IMATH_NOEXCEPT { Vec3 ignored; return intersects (box, ray, ignored); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHBOXALGO_H Imath-3.1.4/src/Imath/ImathColor.h000066400000000000000000000444531417213455000166400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // 3-channel and 4-channel color representations // #ifndef INCLUDED_IMATHCOLOR_H #define INCLUDED_IMATHCOLOR_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathVec.h" #include "half.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// 3-channel color class that inherits from Vec3. /// /// This class does not impose interpretation on the channels, which /// can represent either rgb or hsv color values. /// /// Note: because Color3 inherits from Vec3, its member fields are /// called `x`, `y`, and `z`. template class IMATH_EXPORT_TEMPLATE_TYPE Color3 : public Vec3 { public: /// @{ /// @name Constructors and Assignemt /// No initialization by default IMATH_HOSTDEVICE Color3() IMATH_NOEXCEPT; /// Initialize to (a a a) IMATH_HOSTDEVICE constexpr explicit Color3 (T a) IMATH_NOEXCEPT; /// Initialize to (a b c) IMATH_HOSTDEVICE constexpr Color3 (T a, T b, T c) IMATH_NOEXCEPT; /// Construct from Color3 IMATH_HOSTDEVICE constexpr Color3 (const Color3& c) IMATH_NOEXCEPT; /// Construct from Vec3 template IMATH_HOSTDEVICE constexpr Color3 (const Vec3& v) IMATH_NOEXCEPT; /// Destructor IMATH_HOSTDEVICE ~Color3() = default; /// Component-wise assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator= (const Color3& c) IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator+= (const Color3& c) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Color3 operator+ (const Color3& c) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator-= (const Color3& c) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Color3 operator- (const Color3& c) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Color3 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator*= (const Color3& c) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Color3 operator* (const Color3& c) const IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Color3 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator/= (const Color3& c) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color3& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Color3 operator/ (const Color3& c) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Color3 operator/ (T a) const IMATH_NOEXCEPT; /// @} }; /// /// A 4-channel color class: 3 channels plus alpha. /// /// For convenience, the fields are named `r`, `g`, and `b`, although /// this class does not impose interpretation on the channels, which /// can represent either rgb or hsv color values. /// template class IMATH_EXPORT_TEMPLATE_TYPE Color4 { public: /// @{ /// @name Direct access to elements T r, g, b, a; /// @} /// @{ /// @name Constructors and Assignment /// No initialization by default IMATH_HOSTDEVICE Color4() IMATH_NOEXCEPT; /// Initialize to `(a a a a)` IMATH_HOSTDEVICE IMATH_CONSTEXPR14 explicit Color4 (T a) IMATH_NOEXCEPT; /// Initialize to `(a b c d)` IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Color4 (T a, T b, T c, T d) IMATH_NOEXCEPT; /// Construct from Color4 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Color4 (const Color4& v) IMATH_NOEXCEPT; /// Construct from Color4 template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Color4 (const Color4& v) IMATH_NOEXCEPT; /// Destructor IMATH_HOSTDEVICE ~Color4() = default; /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator= (const Color4& v) IMATH_NOEXCEPT; /// Component-wise value IMATH_HOSTDEVICE T& operator[] (int i) IMATH_NOEXCEPT; /// Component-wise value IMATH_HOSTDEVICE const T& operator[] (int i) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality template IMATH_HOSTDEVICE constexpr bool operator== (const Color4& v) const IMATH_NOEXCEPT; /// Inequality template IMATH_HOSTDEVICE constexpr bool operator!= (const Color4& v) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator+= (const Color4& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Color4 operator+ (const Color4& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator-= (const Color4& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Color4 operator- (const Color4& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Color4 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator*= (const Color4& v) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Color4 operator* (const Color4& v) const IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Color4 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator/= (const Color4& v) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Color4& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Color4 operator/ (const Color4& v) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Color4 operator/ (T a) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Number of dimensions (channels), i.e. 4 for a Color4 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 4; } /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// The base type: In templates that accept a parameter `V` (could /// be a Color4), you can refer to `T` as `V::BaseType` typedef T BaseType; /// @{ /// @name Compatibilty with Sb /// Set the value template IMATH_HOSTDEVICE void setValue (S a, S b, S c, S d) IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE void setValue (const Color4& v) IMATH_NOEXCEPT; /// Return the value template IMATH_HOSTDEVICE void getValue (S& a, S& b, S& c, S& d) const IMATH_NOEXCEPT; /// Return the value template IMATH_HOSTDEVICE void getValue (Color4& v) const IMATH_NOEXCEPT; /// Return raw pointer to the value IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT; /// Return raw pointer to the value IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT; /// @} }; /// Stream output, as "(r g b a)" template std::ostream& operator<< (std::ostream& s, const Color4& v); /// Reverse multiplication: S * Color4 template IMATH_HOSTDEVICE constexpr Color4 operator* (S a, const Color4& v) IMATH_NOEXCEPT; /// 3 float channels typedef Color3 Color3f; /// 3 half channels typedef Color3 Color3h; /// 3 8-bit integer channels typedef Color3 Color3c; /// 3 half channels typedef Color3 C3h; /// 3 float channels typedef Color3 C3f; /// 3 8-bit integer channels typedef Color3 C3c; /// 4 float channels typedef Color4 Color4f; /// 4 half channels typedef Color4 Color4h; /// 4 8-bit integer channels typedef Color4 Color4c; /// 4 float channels typedef Color4 C4f; /// 4 half channels typedef Color4 C4h; /// 4 8-bit integer channels typedef Color4 C4c; /// Packed 32-bit integer typedef unsigned int PackedColor; // // Implementation of Color3 // template IMATH_HOSTDEVICE inline Color3::Color3() IMATH_NOEXCEPT : Vec3() { // empty } template IMATH_HOSTDEVICE constexpr inline Color3::Color3 (T a) IMATH_NOEXCEPT : Vec3 (a) { // empty } template IMATH_HOSTDEVICE constexpr inline Color3::Color3 (T a, T b, T c) IMATH_NOEXCEPT : Vec3 (a, b, c) { // empty } template IMATH_HOSTDEVICE constexpr inline Color3::Color3 (const Color3& c) IMATH_NOEXCEPT : Vec3 (c) { // empty } template template IMATH_HOSTDEVICE constexpr inline Color3::Color3 (const Vec3& v) IMATH_NOEXCEPT : Vec3 (v) { //empty } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator= (const Color3& c) IMATH_NOEXCEPT { *((Vec3*) this) = c; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator+= (const Color3& c) IMATH_NOEXCEPT { *((Vec3*) this) += c; return *this; } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator+ (const Color3& c) const IMATH_NOEXCEPT { return Color3 (*(Vec3*) this + (const Vec3&) c); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator-= (const Color3& c) IMATH_NOEXCEPT { *((Vec3*) this) -= c; return *this; } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator- (const Color3& c) const IMATH_NOEXCEPT { return Color3 (*(Vec3*) this - (const Vec3&) c); } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator-() const IMATH_NOEXCEPT { return Color3 (-(*(Vec3*) this)); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::negate() IMATH_NOEXCEPT { ((Vec3*) this)->negate(); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator*= (const Color3& c) IMATH_NOEXCEPT { *((Vec3*) this) *= c; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator*= (T a) IMATH_NOEXCEPT { *((Vec3*) this) *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator* (const Color3& c) const IMATH_NOEXCEPT { return Color3 (*(Vec3*) this * (const Vec3&) c); } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator* (T a) const IMATH_NOEXCEPT { return Color3 (*(Vec3*) this * a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator/= (const Color3& c) IMATH_NOEXCEPT { *((Vec3*) this) /= c; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color3& Color3::operator/= (T a) IMATH_NOEXCEPT { *((Vec3*) this) /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator/ (const Color3& c) const IMATH_NOEXCEPT { return Color3 (*(Vec3*) this / (const Vec3&) c); } template IMATH_HOSTDEVICE constexpr inline Color3 Color3::operator/ (T a) const IMATH_NOEXCEPT { return Color3 (*(Vec3*) this / a); } // // Implementation of Color4 // template IMATH_HOSTDEVICE inline T& Color4::operator[] (int i) IMATH_NOEXCEPT { return (&r)[i]; } template IMATH_HOSTDEVICE inline const T& Color4::operator[] (int i) const IMATH_NOEXCEPT { return (&r)[i]; } template IMATH_HOSTDEVICE inline Color4::Color4() IMATH_NOEXCEPT { // empty } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Color4::Color4 (T x) IMATH_NOEXCEPT { r = g = b = a = x; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Color4::Color4 (T x, T y, T z, T w) IMATH_NOEXCEPT { r = x; g = y; b = z; a = w; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Color4::Color4 (const Color4& v) IMATH_NOEXCEPT { r = v.r; g = v.g; b = v.b; a = v.a; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Color4::Color4 (const Color4& v) IMATH_NOEXCEPT { r = T (v.r); g = T (v.g); b = T (v.b); a = T (v.a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator= (const Color4& v) IMATH_NOEXCEPT { r = v.r; g = v.g; b = v.b; a = v.a; return *this; } template template IMATH_HOSTDEVICE inline void Color4::setValue (S x, S y, S z, S w) IMATH_NOEXCEPT { r = T (x); g = T (y); b = T (z); a = T (w); } template template IMATH_HOSTDEVICE inline void Color4::setValue (const Color4& v) IMATH_NOEXCEPT { r = T (v.r); g = T (v.g); b = T (v.b); a = T (v.a); } template template IMATH_HOSTDEVICE inline void Color4::getValue (S& x, S& y, S& z, S& w) const IMATH_NOEXCEPT { x = S (r); y = S (g); z = S (b); w = S (a); } template template IMATH_HOSTDEVICE inline void Color4::getValue (Color4& v) const IMATH_NOEXCEPT { v.r = S (r); v.g = S (g); v.b = S (b); v.a = S (a); } template IMATH_HOSTDEVICE inline T* Color4::getValue() IMATH_NOEXCEPT { return (T*) &r; } template IMATH_HOSTDEVICE inline const T* Color4::getValue() const IMATH_NOEXCEPT { return (const T*) &r; } template template IMATH_HOSTDEVICE constexpr inline bool Color4::operator== (const Color4& v) const IMATH_NOEXCEPT { return r == v.r && g == v.g && b == v.b && a == v.a; } template template IMATH_HOSTDEVICE constexpr inline bool Color4::operator!= (const Color4& v) const IMATH_NOEXCEPT { return r != v.r || g != v.g || b != v.b || a != v.a; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator+= (const Color4& v) IMATH_NOEXCEPT { r += v.r; g += v.g; b += v.b; a += v.a; return *this; } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator+ (const Color4& v) const IMATH_NOEXCEPT { return Color4 (r + v.r, g + v.g, b + v.b, a + v.a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator-= (const Color4& v) IMATH_NOEXCEPT { r -= v.r; g -= v.g; b -= v.b; a -= v.a; return *this; } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator- (const Color4& v) const IMATH_NOEXCEPT { return Color4 (r - v.r, g - v.g, b - v.b, a - v.a); } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator-() const IMATH_NOEXCEPT { return Color4 (-r, -g, -b, -a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::negate() IMATH_NOEXCEPT { r = -r; g = -g; b = -b; a = -a; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator*= (const Color4& v) IMATH_NOEXCEPT { r *= v.r; g *= v.g; b *= v.b; a *= v.a; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator*= (T x) IMATH_NOEXCEPT { r *= x; g *= x; b *= x; a *= x; return *this; } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator* (const Color4& v) const IMATH_NOEXCEPT { return Color4 (r * v.r, g * v.g, b * v.b, a * v.a); } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator* (T x) const IMATH_NOEXCEPT { return Color4 (r * x, g * x, b * x, a * x); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator/= (const Color4& v) IMATH_NOEXCEPT { r /= v.r; g /= v.g; b /= v.b; a /= v.a; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Color4& Color4::operator/= (T x) IMATH_NOEXCEPT { r /= x; g /= x; b /= x; a /= x; return *this; } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator/ (const Color4& v) const IMATH_NOEXCEPT { return Color4 (r / v.r, g / v.g, b / v.b, a / v.a); } template IMATH_HOSTDEVICE constexpr inline Color4 Color4::operator/ (T x) const IMATH_NOEXCEPT { return Color4 (r / x, g / x, b / x, a / x); } template std::ostream& operator<< (std::ostream& s, const Color4& v) { return s << '(' << v.r << ' ' << v.g << ' ' << v.b << ' ' << v.a << ')'; } // // Implementation of reverse multiplication // template IMATH_HOSTDEVICE constexpr inline Color4 operator* (S x, const Color4& v) IMATH_NOEXCEPT { return Color4 (x * v.r, x * v.g, x * v.b, x * v.a); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHCOLOR_H Imath-3.1.4/src/Imath/ImathColorAlgo.cpp000066400000000000000000000072131417213455000177670ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // /// /// @file ImathColorAlgo.cpp /// /// @brief Implementation of non-template items declared in ImathColorAlgo.h /// #include "ImathColorAlgo.h" IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER Vec3 hsv2rgb_d (const Vec3& hsv) IMATH_NOEXCEPT { double hue = hsv.x; double sat = hsv.y; double val = hsv.z; double x = 0.0, y = 0.0, z = 0.0; if (hue == 1) hue = 0; else hue *= 6; int i = int (std::floor (hue)); double f = hue - i; double p = val * (1 - sat); double q = val * (1 - (sat * f)); double t = val * (1 - (sat * (1 - f))); switch (i) { case 0: x = val; y = t; z = p; break; case 1: x = q; y = val; z = p; break; case 2: x = p; y = val; z = t; break; case 3: x = p; y = q; z = val; break; case 4: x = t; y = p; z = val; break; case 5: x = val; y = p; z = q; break; } return Vec3 (x, y, z); } Color4 hsv2rgb_d (const Color4& hsv) IMATH_NOEXCEPT { double hue = hsv.r; double sat = hsv.g; double val = hsv.b; double r = 0.0, g = 0.0, b = 0.0; if (hue == 1) hue = 0; else hue *= 6; int i = int (std::floor (hue)); double f = hue - i; double p = val * (1 - sat); double q = val * (1 - (sat * f)); double t = val * (1 - (sat * (1 - f))); switch (i) { case 0: r = val; g = t; b = p; break; case 1: r = q; g = val; b = p; break; case 2: r = p; g = val; b = t; break; case 3: r = p; g = q; b = val; break; case 4: r = t; g = p; b = val; break; case 5: r = val; g = p; b = q; break; } return Color4 (r, g, b, hsv.a); } Vec3 rgb2hsv_d (const Vec3& c) IMATH_NOEXCEPT { const double& x = c.x; const double& y = c.y; const double& z = c.z; double max = (x > y) ? ((x > z) ? x : z) : ((y > z) ? y : z); double min = (x < y) ? ((x < z) ? x : z) : ((y < z) ? y : z); double range = max - min; double val = max; double sat = 0; double hue = 0; if (max != 0) sat = range / max; if (sat != 0) { double h; if (x == max) h = (y - z) / range; else if (y == max) h = 2 + (z - x) / range; else h = 4 + (x - y) / range; hue = h / 6.; if (hue < 0.) hue += 1.0; } return Vec3 (hue, sat, val); } Color4 rgb2hsv_d (const Color4& c) IMATH_NOEXCEPT { const double& r = c.r; const double& g = c.g; const double& b = c.b; double max = (r > g) ? ((r > b) ? r : b) : ((g > b) ? g : b); double min = (r < g) ? ((r < b) ? r : b) : ((g < b) ? g : b); double range = max - min; double val = max; double sat = 0; double hue = 0; if (max != 0) sat = range / max; if (sat != 0) { double h; if (r == max) h = (g - b) / range; else if (g == max) h = 2 + (b - r) / range; else h = 4 + (r - g) / range; hue = h / 6.; if (hue < 0.) hue += 1.0; } return Color4 (hue, sat, val, c.a); } IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT Imath-3.1.4/src/Imath/ImathColorAlgo.h000066400000000000000000000175041417213455000174400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Color conversion functions and general color algorithms // #ifndef INCLUDED_IMATHCOLORALGO_H #define INCLUDED_IMATHCOLORALGO_H #include "ImathNamespace.h" #include "ImathExport.h" #include "ImathColor.h" #include "ImathMath.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER // // Non-templated helper routines for color conversion. // These routines eliminate type warnings under g++. // /// /// Convert 3-channel hsv to rgb. Non-templated helper routine. IMATH_EXPORT Vec3 hsv2rgb_d (const Vec3& hsv) IMATH_NOEXCEPT; /// /// Convert 4-channel hsv to rgb (with alpha). Non-templated helper routine. IMATH_EXPORT Color4 hsv2rgb_d (const Color4& hsv) IMATH_NOEXCEPT; /// /// Convert 3-channel rgb to hsv. Non-templated helper routine. IMATH_EXPORT Vec3 rgb2hsv_d (const Vec3& rgb) IMATH_NOEXCEPT; /// /// Convert 4-channel rgb to hsv. Non-templated helper routine. IMATH_EXPORT Color4 rgb2hsv_d (const Color4& rgb) IMATH_NOEXCEPT; /// /// Convert 3-channel hsv to rgb. /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 hsv2rgb (const Vec3& hsv) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { Vec3 v = Vec3 (hsv.x / double (std::numeric_limits::max()), hsv.y / double (std::numeric_limits::max()), hsv.z / double (std::numeric_limits::max())); Vec3 c = hsv2rgb_d (v); return Vec3 ((T) (c.x * std::numeric_limits::max()), (T) (c.y * std::numeric_limits::max()), (T) (c.z * std::numeric_limits::max())); } else { Vec3 v = Vec3 (hsv.x, hsv.y, hsv.z); Vec3 c = hsv2rgb_d (v); return Vec3 ((T) c.x, (T) c.y, (T) c.z); } } /// /// Convert 4-channel hsv to rgb (with alpha). /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Color4 hsv2rgb (const Color4& hsv) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { Color4 v = Color4 (hsv.r / float (std::numeric_limits::max()), hsv.g / float (std::numeric_limits::max()), hsv.b / float (std::numeric_limits::max()), hsv.a / float (std::numeric_limits::max())); Color4 c = hsv2rgb_d (v); return Color4 ((T) (c.r * std::numeric_limits::max()), (T) (c.g * std::numeric_limits::max()), (T) (c.b * std::numeric_limits::max()), (T) (c.a * std::numeric_limits::max())); } else { Color4 v = Color4 (hsv.r, hsv.g, hsv.b, hsv.a); Color4 c = hsv2rgb_d (v); return Color4 ((T) c.r, (T) c.g, (T) c.b, (T) c.a); } } /// /// Convert 3-channel rgb to hsv. /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 rgb2hsv (const Vec3& rgb) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { Vec3 v = Vec3 (rgb.x / double (std::numeric_limits::max()), rgb.y / double (std::numeric_limits::max()), rgb.z / double (std::numeric_limits::max())); Vec3 c = rgb2hsv_d (v); return Vec3 ((T) (c.x * std::numeric_limits::max()), (T) (c.y * std::numeric_limits::max()), (T) (c.z * std::numeric_limits::max())); } else { Vec3 v = Vec3 (rgb.x, rgb.y, rgb.z); Vec3 c = rgb2hsv_d (v); return Vec3 ((T) c.x, (T) c.y, (T) c.z); } } /// /// Convert 4-channel rgb to hsv (with alpha). /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Color4 rgb2hsv (const Color4& rgb) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { Color4 v = Color4 (rgb.r / float (std::numeric_limits::max()), rgb.g / float (std::numeric_limits::max()), rgb.b / float (std::numeric_limits::max()), rgb.a / float (std::numeric_limits::max())); Color4 c = rgb2hsv_d (v); return Color4 ((T) (c.r * std::numeric_limits::max()), (T) (c.g * std::numeric_limits::max()), (T) (c.b * std::numeric_limits::max()), (T) (c.a * std::numeric_limits::max())); } else { Color4 v = Color4 (rgb.r, rgb.g, rgb.b, rgb.a); Color4 c = rgb2hsv_d (v); return Color4 ((T) c.r, (T) c.g, (T) c.b, (T) c.a); } } /// /// Convert 3-channel rgb to PackedColor /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 PackedColor rgb2packed (const Vec3& c) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { float x = c.x / float (std::numeric_limits::max()); float y = c.y / float (std::numeric_limits::max()); float z = c.z / float (std::numeric_limits::max()); return rgb2packed (V3f (x, y, z)); } else { // clang-format off return ( (PackedColor) (c.x * 255) | (((PackedColor) (c.y * 255)) << 8) | (((PackedColor) (c.z * 255)) << 16) | 0xFF000000 ); // clang-format on } } /// /// Convert 4-channel rgb to PackedColor (with alpha) /// template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 PackedColor rgb2packed (const Color4& c) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { float r = c.r / float (std::numeric_limits::max()); float g = c.g / float (std::numeric_limits::max()); float b = c.b / float (std::numeric_limits::max()); float a = c.a / float (std::numeric_limits::max()); return rgb2packed (C4f (r, g, b, a)); } else { // clang-format off return ( (PackedColor) (c.r * 255) | (((PackedColor) (c.g * 255)) << 8) | (((PackedColor) (c.b * 255)) << 16) | (((PackedColor) (c.a * 255)) << 24)); // clang-format on } } /// /// Convert PackedColor to 3-channel rgb. Return the result in the /// `out` parameter. /// template IMATH_HOSTDEVICE void packed2rgb (PackedColor packed, Vec3& out) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { T f = std::numeric_limits::max() / ((PackedColor) 0xFF); out.x = (packed & 0xFF) * f; out.y = ((packed & 0xFF00) >> 8) * f; out.z = ((packed & 0xFF0000) >> 16) * f; } else { T f = T (1) / T (255); out.x = (packed & 0xFF) * f; out.y = ((packed & 0xFF00) >> 8) * f; out.z = ((packed & 0xFF0000) >> 16) * f; } } /// /// Convert PackedColor to 4-channel rgb (with alpha). Return the /// result in the `out` parameter. /// template IMATH_HOSTDEVICE void packed2rgb (PackedColor packed, Color4& out) IMATH_NOEXCEPT { if (std::numeric_limits::is_integer) { T f = std::numeric_limits::max() / ((PackedColor) 0xFF); out.r = (packed & 0xFF) * f; out.g = ((packed & 0xFF00) >> 8) * f; out.b = ((packed & 0xFF0000) >> 16) * f; out.a = ((packed & 0xFF000000) >> 24) * f; } else { T f = T (1) / T (255); out.r = (packed & 0xFF) * f; out.g = ((packed & 0xFF00) >> 8) * f; out.b = ((packed & 0xFF0000) >> 16) * f; out.a = ((packed & 0xFF000000) >> 24) * f; } } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHCOLORALGO_H Imath-3.1.4/src/Imath/ImathEuler.h000066400000000000000000000644621417213455000166400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Euler angle representation of rotation/orientation // #ifndef INCLUDED_IMATHEULER_H #define INCLUDED_IMATHEULER_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathMath.h" #include "ImathMatrix.h" #include "ImathQuat.h" #include "ImathVec.h" #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER // Disable MS VC++ warnings about conversion from double to float # pragma warning(push) # pragma warning(disable : 4244) #endif /// /// Template class `Euler` /// /// The Euler class represents euler angle orientations. The class /// inherits from Vec3 to it can be freely cast. The additional /// information is the euler priorities rep. This class is /// essentially a rip off of Ken Shoemake's GemsIV code. It has /// been modified minimally to make it more understandable, but /// hardly enough to make it easy to grok completely. /// /// There are 24 possible combonations of Euler angle /// representations of which 12 are common in CG and you will /// probably only use 6 of these which in this scheme are the /// non-relative-non-repeating types. /// /// The representations can be partitioned according to two /// criteria: /// /// 1) Are the angles measured relative to a set of fixed axis /// or relative to each other (the latter being what happens /// when rotation matrices are multiplied together and is /// almost ubiquitous in the cg community) /// /// 2) Is one of the rotations repeated (ala XYX rotation) /// /// When you construct a given representation from scratch you /// must order the angles according to their priorities. So, the /// easiest is a softimage or aerospace (yaw/pitch/roll) ordering /// of ZYX. /// /// float x_rot = 1; /// float y_rot = 2; /// float z_rot = 3; /// /// Eulerf angles(z_rot, y_rot, x_rot, Eulerf::ZYX); /// /// or: /// /// Eulerf angles( V3f(z_rot,y_rot,z_rot), Eulerf::ZYX ); /// /// /// If instead, the order was YXZ for instance you would have to /// do this: /// /// float x_rot = 1; /// float y_rot = 2; /// float z_rot = 3; /// /// Eulerf angles(y_rot, x_rot, z_rot, Eulerf::YXZ); /// /// or: /// /// /// Eulerf angles( V3f(y_rot,x_rot,z_rot), Eulerf::YXZ ); /// /// Notice how the order you put the angles into the three slots /// should correspond to the enum (YXZ) ordering. The input angle /// vector is called the "ijk" vector -- not an "xyz" vector. The /// ijk vector order is the same as the enum. If you treat the /// Euler as a Vec3 (which it inherts from) you will find the /// angles are ordered in the same way, i.e.: /// /// V3f v = angles; /// v.x == y_rot, v.y == x_rot, v.z == z_rot /// /// If you just want the x, y, and z angles stored in a vector in /// that order, you can do this: /// /// V3f v = angles.toXYZVector() /// v.x == x_rot, v.y == y_rot, v.z == z_rot /// /// If you want to set the Euler with an XYZVector use the /// optional layout argument: /// /// Eulerf angles(x_rot, y_rot, z_rot, Eulerf::YXZ, Eulerf::XYZLayout); /// /// This is the same as: /// /// Eulerf angles(y_rot, x_rot, z_rot, Eulerf::YXZ); /// /// Note that this won't do anything intelligent if you have a /// repeated axis in the euler angles (e.g. XYX) /// /// If you need to use the "relative" versions of these, you will /// need to use the "r" enums. /// /// The units of the rotation angles are assumed to be radians. /// template class IMATH_EXPORT_TEMPLATE_TYPE Euler : public Vec3 { public: using Vec3::x; using Vec3::y; using Vec3::z; /// /// All 24 possible orderings /// enum IMATH_EXPORT_ENUM Order { XYZ = 0x0101, // "usual" orderings XZY = 0x0001, YZX = 0x1101, YXZ = 0x1001, ZXY = 0x2101, ZYX = 0x2001, XZX = 0x0011, // first axis repeated XYX = 0x0111, YXY = 0x1011, YZY = 0x1111, ZYZ = 0x2011, ZXZ = 0x2111, XYZr = 0x2000, // relative orderings -- not common XZYr = 0x2100, YZXr = 0x1000, YXZr = 0x1100, ZXYr = 0x0000, ZYXr = 0x0100, XZXr = 0x2110, // relative first axis repeated XYXr = 0x2010, YXYr = 0x1110, YZYr = 0x1010, ZYZr = 0x0110, ZXZr = 0x0010, // |||| // VVVV // ABCD // Legend: // A -> Initial Axis (0==x, 1==y, 2==z) // B -> Parity Even (1==true) // C -> Initial Repeated (1==true) // D -> Frame Static (1==true) // Legal = XYZ | XZY | YZX | YXZ | ZXY | ZYX | XZX | XYX | YXY | YZY | ZYZ | ZXZ | XYZr | XZYr | YZXr | YXZr | ZXYr | ZYXr | XZXr | XYXr | YXYr | YZYr | ZYZr | ZXZr, Min = 0x0000, Max = 0x2111, Default = XYZ }; /// /// Axes /// enum IMATH_EXPORT_ENUM Axis { X = 0, Y = 1, Z = 2 }; /// /// Layout /// enum IMATH_EXPORT_ENUM InputLayout { XYZLayout, IJKLayout }; /// @{ /// @name Constructors /// /// All default to `ZYX` non-relative (ala Softimage 3D/Maya), /// where there is no argument to specify it. /// /// The Euler-from-matrix constructors assume that the matrix does /// not include shear or non-uniform scaling, but the constructors /// do not examine the matrix to verify this assumption. If necessary, /// you can adjust the matrix by calling the removeScalingAndShear() /// function, defined in ImathMatrixAlgo.h. /// No initialization by default IMATH_HOSTDEVICE constexpr Euler() IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (const Euler&) IMATH_NOEXCEPT; /// Construct from given Order IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (Order p) IMATH_NOEXCEPT; /// Construct from vector, order, layout IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (const Vec3& v, Order o = Default, InputLayout l = IJKLayout) IMATH_NOEXCEPT; /// Construct from explicit axes, order, layout IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (T i, T j, T k, Order o = Default, InputLayout l = IJKLayout) IMATH_NOEXCEPT; /// Copy constructor with new Order IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (const Euler& euler, Order newp) IMATH_NOEXCEPT; /// Construct from Matrix33 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (const Matrix33&, Order o = Default) IMATH_NOEXCEPT; /// Construct from Matrix44 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Euler (const Matrix44&, Order o = Default) IMATH_NOEXCEPT; /// Destructor IMATH_HOSTDEVICE ~Euler() = default; /// @} /// @{ /// @name Query /// Return whether the given value is a legal Order IMATH_HOSTDEVICE constexpr static bool legal (Order) IMATH_NOEXCEPT; /// Return the order IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Order order() const IMATH_NOEXCEPT; /// Return frameStatic IMATH_HOSTDEVICE constexpr bool frameStatic() const { return _frameStatic; } /// Return intialRepeated IMATH_HOSTDEVICE constexpr bool initialRepeated() const { return _initialRepeated; } /// Return partityEven IMATH_HOSTDEVICE constexpr bool parityEven() const { return _parityEven; } /// Return initialAxis IMATH_HOSTDEVICE constexpr Axis initialAxis() const { return _initialAxis; } /// Unpack angles from ijk form IMATH_HOSTDEVICE void angleOrder (int& i, int& j, int& k) const IMATH_NOEXCEPT; /// Determine mapping from xyz to ijk (reshuffle the xyz to match the order) IMATH_HOSTDEVICE void angleMapping (int& i, int& j, int& k) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Set Value /// Set the order. This does NOT convert the angles, but it /// does reorder the input vector. IMATH_HOSTDEVICE void setOrder (Order) IMATH_NOEXCEPT; /// Set the euler value: set the first angle to `v[0]`, the second to /// `v[1]`, the third to `v[2]`. IMATH_HOSTDEVICE void setXYZVector (const Vec3&) IMATH_NOEXCEPT; /// Set the value. IMATH_HOSTDEVICE void set (Axis initial, bool relative, bool parityEven, bool firstRepeats) IMATH_NOEXCEPT; /// @} /// @{ /// @name Assignments and Conversions /// /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Euler& operator= (const Euler&) IMATH_NOEXCEPT; /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Euler& operator= (const Vec3&) IMATH_NOEXCEPT; /// Assign from Matrix33, assumed to be affine IMATH_HOSTDEVICE void extract (const Matrix33&) IMATH_NOEXCEPT; /// Assign from Matrix44, assumed to be affine IMATH_HOSTDEVICE void extract (const Matrix44&) IMATH_NOEXCEPT; /// Assign from Quaternion IMATH_HOSTDEVICE void extract (const Quat&) IMATH_NOEXCEPT; /// Convert to Matrix33 IMATH_HOSTDEVICE Matrix33 toMatrix33() const IMATH_NOEXCEPT; /// Convert to Matrix44 IMATH_HOSTDEVICE Matrix44 toMatrix44() const IMATH_NOEXCEPT; /// Convert to Quat IMATH_HOSTDEVICE Quat toQuat() const IMATH_NOEXCEPT; /// Reorder the angles so that the X rotation comes first, /// followed by the Y and Z in cases like XYX ordering, the /// repeated angle will be in the "z" component IMATH_HOSTDEVICE Vec3 toXYZVector() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Utility Methods /// /// Utility methods for getting continuous rotations. None of these /// methods change the orientation given by its inputs (or at least /// that is the intent). /// Convert an angle to its equivalent in [-PI, PI] IMATH_HOSTDEVICE IMATH_CONSTEXPR14 static float angleMod (T angle) IMATH_NOEXCEPT; /// Adjust xyzRot so that its components differ from targetXyzRot by no more than +/-PI IMATH_HOSTDEVICE static void simpleXYZRotation (Vec3& xyzRot, const Vec3& targetXyzRot) IMATH_NOEXCEPT; /// Adjust xyzRot so that its components differ from targetXyzRot by as little as possible. /// Note that xyz here really means ijk, because the order must be provided. IMATH_HOSTDEVICE static void nearestRotation (Vec3& xyzRot, const Vec3& targetXyzRot, Order order = XYZ) IMATH_NOEXCEPT; /// Adjusts "this" Euler so that its components differ from target /// by as little as possible. This method might not make sense for /// Eulers with different order and it probably doesn't work for /// repeated axis and relative orderings (TODO). IMATH_HOSTDEVICE void makeNear (const Euler& target) IMATH_NOEXCEPT; /// @} protected: /// relative or static rotations bool _frameStatic : 1; /// init axis repeated as last bool _initialRepeated : 1; /// "parity of axis permutation" bool _parityEven : 1; #if defined _WIN32 || defined _WIN64 /// First axis of rotation Axis _initialAxis; #else /// First axis of rotation Axis _initialAxis : 2; #endif }; // // Convenient typedefs // /// Euler of type float typedef Euler Eulerf; /// Euler of type double typedef Euler Eulerd; // // Implementation // /// @cond Doxygen_Suppress template IMATH_HOSTDEVICE inline void Euler::angleOrder (int& i, int& j, int& k) const IMATH_NOEXCEPT { i = _initialAxis; j = _parityEven ? (i + 1) % 3 : (i > 0 ? i - 1 : 2); k = _parityEven ? (i > 0 ? i - 1 : 2) : (i + 1) % 3; } template IMATH_HOSTDEVICE inline void Euler::angleMapping (int& i, int& j, int& k) const IMATH_NOEXCEPT { int m[3]; m[_initialAxis] = 0; m[(_initialAxis + 1) % 3] = _parityEven ? 1 : 2; m[(_initialAxis + 2) % 3] = _parityEven ? 2 : 1; i = m[0]; j = m[1]; k = m[2]; } template IMATH_HOSTDEVICE inline void Euler::setXYZVector (const Vec3& v) IMATH_NOEXCEPT { int i, j, k; angleMapping (i, j, k); (*this)[i] = v.x; (*this)[j] = v.y; (*this)[k] = v.z; } template IMATH_HOSTDEVICE inline Vec3 Euler::toXYZVector() const IMATH_NOEXCEPT { int i, j, k; angleMapping (i, j, k); return Vec3 ((*this)[i], (*this)[j], (*this)[k]); } template IMATH_HOSTDEVICE constexpr inline Euler::Euler() IMATH_NOEXCEPT : Vec3 (0, 0, 0), _frameStatic (true), _initialRepeated (false), _parityEven (true), _initialAxis (X) {} template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (typename Euler::Order p) IMATH_NOEXCEPT : Vec3 (0, 0, 0), _frameStatic (true), _initialRepeated (false), _parityEven (true), _initialAxis (X) { setOrder (p); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (const Vec3& v, typename Euler::Order p, typename Euler::InputLayout l) IMATH_NOEXCEPT { setOrder (p); if (l == XYZLayout) setXYZVector (v); else { x = v.x; y = v.y; z = v.z; } } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (const Euler& euler) IMATH_NOEXCEPT { operator= (euler); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (const Euler& euler, Order p) IMATH_NOEXCEPT { setOrder (p); Matrix33 M = euler.toMatrix33(); extract (M); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (T xi, T yi, T zi, typename Euler::Order p, typename Euler::InputLayout l) IMATH_NOEXCEPT { setOrder (p); if (l == XYZLayout) setXYZVector (Vec3 (xi, yi, zi)); else { x = xi; y = yi; z = zi; } } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (const Matrix33& M, typename Euler::Order p) IMATH_NOEXCEPT { setOrder (p); extract (M); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Euler::Euler (const Matrix44& M, typename Euler::Order p) IMATH_NOEXCEPT { setOrder (p); extract (M); } template IMATH_HOSTDEVICE inline void Euler::extract (const Quat& q) IMATH_NOEXCEPT { extract (q.toMatrix33()); } template IMATH_HOSTDEVICE void Euler::extract (const Matrix33& M) IMATH_NOEXCEPT { int i, j, k; angleOrder (i, j, k); if (_initialRepeated) { // // Extract the first angle, x. // x = std::atan2 (M[j][i], M[k][i]); // // Remove the x rotation from M, so that the remaining // rotation, N, is only around two axes, and gimbal lock // cannot occur. // Vec3 r (0, 0, 0); r[i] = (_parityEven ? -x : x); Matrix44 N; N.rotate (r); N = N * Matrix44 (M[0][0], M[0][1], M[0][2], 0, M[1][0], M[1][1], M[1][2], 0, M[2][0], M[2][1], M[2][2], 0, 0, 0, 0, 1); // // Extract the other two angles, y and z, from N. // T sy = std::sqrt (N[j][i] * N[j][i] + N[k][i] * N[k][i]); y = std::atan2 (sy, N[i][i]); z = std::atan2 (N[j][k], N[j][j]); } else { // // Extract the first angle, x. // x = std::atan2 (M[j][k], M[k][k]); // // Remove the x rotation from M, so that the remaining // rotation, N, is only around two axes, and gimbal lock // cannot occur. // Vec3 r (0, 0, 0); r[i] = (_parityEven ? -x : x); Matrix44 N; N.rotate (r); N = N * Matrix44 (M[0][0], M[0][1], M[0][2], 0, M[1][0], M[1][1], M[1][2], 0, M[2][0], M[2][1], M[2][2], 0, 0, 0, 0, 1); // // Extract the other two angles, y and z, from N. // T cy = std::sqrt (N[i][i] * N[i][i] + N[i][j] * N[i][j]); y = std::atan2 (-N[i][k], cy); z = std::atan2 (-N[j][i], N[j][j]); } if (!_parityEven) *this *= -1; if (!_frameStatic) { T t = x; x = z; z = t; } } template IMATH_HOSTDEVICE void Euler::extract (const Matrix44& M) IMATH_NOEXCEPT { int i, j, k; angleOrder (i, j, k); if (_initialRepeated) { // // Extract the first angle, x. // x = std::atan2 (M[j][i], M[k][i]); // // Remove the x rotation from M, so that the remaining // rotation, N, is only around two axes, and gimbal lock // cannot occur. // Vec3 r (0, 0, 0); r[i] = (_parityEven ? -x : x); Matrix44 N; N.rotate (r); N = N * M; // // Extract the other two angles, y and z, from N. // T sy = std::sqrt (N[j][i] * N[j][i] + N[k][i] * N[k][i]); y = std::atan2 (sy, N[i][i]); z = std::atan2 (N[j][k], N[j][j]); } else { // // Extract the first angle, x. // x = std::atan2 (M[j][k], M[k][k]); // // Remove the x rotation from M, so that the remaining // rotation, N, is only around two axes, and gimbal lock // cannot occur. // Vec3 r (0, 0, 0); r[i] = (_parityEven ? -x : x); Matrix44 N; N.rotate (r); N = N * M; // // Extract the other two angles, y and z, from N. // T cy = std::sqrt (N[i][i] * N[i][i] + N[i][j] * N[i][j]); y = std::atan2 (-N[i][k], cy); z = std::atan2 (-N[j][i], N[j][j]); } if (!_parityEven) *this *= -1; if (!_frameStatic) { T t = x; x = z; z = t; } } template IMATH_HOSTDEVICE Matrix33 Euler::toMatrix33() const IMATH_NOEXCEPT { int i, j, k; angleOrder (i, j, k); Vec3 angles; if (_frameStatic) angles = (*this); else angles = Vec3 (z, y, x); if (!_parityEven) angles *= -1.0; T ci = std::cos (angles.x); T cj = std::cos (angles.y); T ch = std::cos (angles.z); T si = std::sin (angles.x); T sj = std::sin (angles.y); T sh = std::sin (angles.z); T cc = ci * ch; T cs = ci * sh; T sc = si * ch; T ss = si * sh; Matrix33 M; if (_initialRepeated) { M[i][i] = cj; M[j][i] = sj * si; M[k][i] = sj * ci; M[i][j] = sj * sh; M[j][j] = -cj * ss + cc; M[k][j] = -cj * cs - sc; M[i][k] = -sj * ch; M[j][k] = cj * sc + cs; M[k][k] = cj * cc - ss; } else { M[i][i] = cj * ch; M[j][i] = sj * sc - cs; M[k][i] = sj * cc + ss; M[i][j] = cj * sh; M[j][j] = sj * ss + cc; M[k][j] = sj * cs - sc; M[i][k] = -sj; M[j][k] = cj * si; M[k][k] = cj * ci; } return M; } template IMATH_HOSTDEVICE Matrix44 Euler::toMatrix44() const IMATH_NOEXCEPT { int i, j, k; angleOrder (i, j, k); Vec3 angles; if (_frameStatic) angles = (*this); else angles = Vec3 (z, y, x); if (!_parityEven) angles *= -1.0; T ci = std::cos (angles.x); T cj = std::cos (angles.y); T ch = std::cos (angles.z); T si = std::sin (angles.x); T sj = std::sin (angles.y); T sh = std::sin (angles.z); T cc = ci * ch; T cs = ci * sh; T sc = si * ch; T ss = si * sh; Matrix44 M; if (_initialRepeated) { M[i][i] = cj; M[j][i] = sj * si; M[k][i] = sj * ci; M[i][j] = sj * sh; M[j][j] = -cj * ss + cc; M[k][j] = -cj * cs - sc; M[i][k] = -sj * ch; M[j][k] = cj * sc + cs; M[k][k] = cj * cc - ss; } else { M[i][i] = cj * ch; M[j][i] = sj * sc - cs; M[k][i] = sj * cc + ss; M[i][j] = cj * sh; M[j][j] = sj * ss + cc; M[k][j] = sj * cs - sc; M[i][k] = -sj; M[j][k] = cj * si; M[k][k] = cj * ci; } return M; } template IMATH_HOSTDEVICE Quat Euler::toQuat() const IMATH_NOEXCEPT { Vec3 angles; int i, j, k; angleOrder (i, j, k); if (_frameStatic) angles = (*this); else angles = Vec3 (z, y, x); if (!_parityEven) angles.y = -angles.y; T ti = angles.x * 0.5; T tj = angles.y * 0.5; T th = angles.z * 0.5; T ci = std::cos (ti); T cj = std::cos (tj); T ch = std::cos (th); T si = std::sin (ti); T sj = std::sin (tj); T sh = std::sin (th); T cc = ci * ch; T cs = ci * sh; T sc = si * ch; T ss = si * sh; T parity = _parityEven ? 1.0 : -1.0; Quat q; Vec3 a; if (_initialRepeated) { a[i] = cj * (cs + sc); a[j] = sj * (cc + ss) * parity, // NOSONAR - suppress SonarCloud bug report. a[k] = sj * (cs - sc); q.r = cj * (cc - ss); } else { a[i] = cj * sc - sj * cs, a[j] = (cj * ss + sj * cc) * parity, // NOSONAR - suppress SonarCloud bug report. a[k] = cj * cs - sj * sc; q.r = cj * cc + sj * ss; } q.v = a; return q; } template IMATH_HOSTDEVICE constexpr inline bool Euler::legal (typename Euler::Order order) IMATH_NOEXCEPT { return (order & ~Legal) ? false : true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 typename Euler::Order Euler::order() const IMATH_NOEXCEPT { int foo = (_initialAxis == Z ? 0x2000 : (_initialAxis == Y ? 0x1000 : 0)); if (_parityEven) foo |= 0x0100; if (_initialRepeated) foo |= 0x0010; if (_frameStatic) foo++; return (Order) foo; } template IMATH_HOSTDEVICE inline void Euler::setOrder (typename Euler::Order p) IMATH_NOEXCEPT { set (p & 0x2000 ? Z : (p & 0x1000 ? Y : X), // initial axis !(p & 0x1), // static? !!(p & 0x100), // permutation even? !!(p & 0x10)); // initial repeats? } template IMATH_HOSTDEVICE inline void Euler::set (typename Euler::Axis axis, bool relative, bool parityEven, bool firstRepeats) IMATH_NOEXCEPT { _initialAxis = axis; _frameStatic = !relative; _parityEven = parityEven; _initialRepeated = firstRepeats; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Euler& Euler::operator= (const Euler& euler) IMATH_NOEXCEPT { x = euler.x; y = euler.y; z = euler.z; _initialAxis = euler._initialAxis; _frameStatic = euler._frameStatic; _parityEven = euler._parityEven; _initialRepeated = euler._initialRepeated; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Euler& Euler::operator= (const Vec3& v) IMATH_NOEXCEPT { x = v.x; y = v.y; z = v.z; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline float Euler::angleMod (T angle) IMATH_NOEXCEPT { const T pi = static_cast (M_PI); angle = fmod (T (angle), T (2 * pi)); if (angle < -pi) angle += 2 * pi; if (angle > +pi) angle -= 2 * pi; return angle; } template IMATH_HOSTDEVICE inline void Euler::simpleXYZRotation (Vec3& xyzRot, const Vec3& targetXyzRot) IMATH_NOEXCEPT { Vec3 d = xyzRot - targetXyzRot; xyzRot[0] = targetXyzRot[0] + angleMod (d[0]); xyzRot[1] = targetXyzRot[1] + angleMod (d[1]); xyzRot[2] = targetXyzRot[2] + angleMod (d[2]); } template IMATH_HOSTDEVICE void Euler::nearestRotation (Vec3& xyzRot, const Vec3& targetXyzRot, Order order) IMATH_NOEXCEPT { int i, j, k; Euler e (0, 0, 0, order); e.angleOrder (i, j, k); simpleXYZRotation (xyzRot, targetXyzRot); Vec3 otherXyzRot; otherXyzRot[i] = M_PI + xyzRot[i]; otherXyzRot[j] = M_PI - xyzRot[j]; otherXyzRot[k] = M_PI + xyzRot[k]; simpleXYZRotation (otherXyzRot, targetXyzRot); Vec3 d = xyzRot - targetXyzRot; Vec3 od = otherXyzRot - targetXyzRot; T dMag = d.dot (d); T odMag = od.dot (od); if (odMag < dMag) { xyzRot = otherXyzRot; } } template IMATH_HOSTDEVICE void Euler::makeNear (const Euler& target) IMATH_NOEXCEPT { Vec3 xyzRot = toXYZVector(); Vec3 targetXyz; if (order() != target.order()) { Euler targetSameOrder = Euler (target, order()); targetXyz = targetSameOrder.toXYZVector(); } else { targetXyz = target.toXYZVector(); } nearestRotation (xyzRot, targetXyz, order()); setXYZVector (xyzRot); } /// @endcond /// Stream ouput, as "(x y z i j k)" template std::ostream& operator<< (std::ostream& o, const Euler& euler) { char a[3] = { 'X', 'Y', 'Z' }; const char* r = euler.frameStatic() ? "" : "r"; int i, j, k; euler.angleOrder (i, j, k); if (euler.initialRepeated()) k = i; return o << "(" << euler.x << " " << euler.y << " " << euler.z << " " << a[i] << a[j] << a[k] << r << ")"; } #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER # pragma warning(pop) #endif IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHEULER_H Imath-3.1.4/src/Imath/ImathExport.h000066400000000000000000000041241417213455000170320ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMATHEXPORT_H #define INCLUDED_IMATHEXPORT_H #include "ImathConfig.h" /// \defgroup ExportMacros Macros to manage symbol visibility /// /// There is more information about the motivation for these macros /// documented in the OpenEXR source tree /// (https://github.com/AcademySoftwareFoundation/openexr) under /// docs/SymbolVisibility.md /// /// Imath only needs a couple of the possible macros outlined in the /// above document, and due to it largely being inline only, does not /// have much to do. /// /// @{ #if defined(IMATH_DLL) // when building Imath as a DLL for Windows, we have to control the // typical DLL export / import things. Luckily, the typeinfo is all // automatic there, so only have to deal with symbols, except Windows // has some weirdness with DLLs and extern const, so we have to // provide a macro to handle that. # if defined(IMATH_EXPORTS) # define IMATH_EXPORT __declspec(dllexport) # define IMATH_EXPORT_CONST extern __declspec(dllexport) # else # define IMATH_EXPORT __declspec(dllimport) # define IMATH_EXPORT_CONST extern __declspec(dllimport) # endif // DLLs don't support these types of visibility controls, just leave them as empty # define IMATH_EXPORT_TYPE # define IMATH_EXPORT_ENUM # define IMATH_EXPORT_TEMPLATE_TYPE #else # ifdef IMATH_PUBLIC_SYMBOL_ATTRIBUTE # define IMATH_EXPORT IMATH_PUBLIC_SYMBOL_ATTRIBUTE # define IMATH_EXPORT_CONST extern const IMATH_PUBLIC_SYMBOL_ATTRIBUTE # else # define IMATH_EXPORT # define IMATH_EXPORT_CONST extern const # endif # ifdef IMATH_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE # define IMATH_EXPORT_ENUM IMATH_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE # define IMATH_EXPORT_TEMPLATE_TYPE IMATH_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE # define IMATH_EXPORT_TYPE IMATH_PUBLIC_TYPE_VISIBILITY_ATTRIBUTE # else # define IMATH_EXPORT_ENUM # define IMATH_EXPORT_TEMPLATE_TYPE IMATH_EXPORT # define IMATH_EXPORT_TYPE IMATH_EXPORT # endif #endif // IMATH_DLL /// @} #endif // INCLUDED_IMATHEXPORT_H Imath-3.1.4/src/Imath/ImathForward.h000066400000000000000000000043631417213455000171620ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMATHFORWARD_H #define INCLUDED_IMATHFORWARD_H #include "ImathNamespace.h" #include "ImathExport.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// @cond Doxygen_Suppress // // Basic template type declarations. // // // Note: declarations with attributes generate warnings with // -Wattributes or -Wall if the type is already defined, i.e. the // header is already included. To avoid the warning, only make the // forward declaration if the header has not yet been included. // #ifndef INCLUDED_IMATHBOX_H template class IMATH_EXPORT_TEMPLATE_TYPE Box; #endif #ifndef INCLUDED_IMATHCOLOR_H template class IMATH_EXPORT_TEMPLATE_TYPE Color3; template class IMATH_EXPORT_TEMPLATE_TYPE Color4; #endif #ifndef INCLUDED_IMATHEULER_H template class IMATH_EXPORT_TEMPLATE_TYPE Euler; #endif #ifndef INCLUDED_IMATHFRUSTUM_H template class IMATH_EXPORT_TEMPLATE_TYPE Frustum; #endif #ifndef INCLUDED_IMATHFRUSTUMTEST_H template class IMATH_EXPORT_TEMPLATE_TYPE FrustumTest; #endif #ifndef INCLUDED_IMATHINTERVAL_H template class IMATH_EXPORT_TEMPLATE_TYPE Interval; #endif #ifndef INCLUDED_IMATHLINE_H template class IMATH_EXPORT_TEMPLATE_TYPE Line3; #endif #ifndef INCLUDED_IMATHMATRIX_H template class IMATH_EXPORT_TEMPLATE_TYPE Matrix33; template class IMATH_EXPORT_TEMPLATE_TYPE Matrix44; #endif #ifndef INCLUDED_IMATHPLANE_H template class IMATH_EXPORT_TEMPLATE_TYPE Plane3; #endif #ifndef INCLUDED_IMATHQUAT_H template class IMATH_EXPORT_TEMPLATE_TYPE Quat; #endif #ifndef INCLUDED_IMATHSHEAR_H template class IMATH_EXPORT_TEMPLATE_TYPE Shear6; #endif #ifndef INCLUDED_IMATHSPHERE_H template class IMATH_EXPORT_TEMPLATE_TYPE Sphere3; #endif #ifndef INCLUDED_IMATHVEC_H template class IMATH_EXPORT_TEMPLATE_TYPE Vec2; template class IMATH_EXPORT_TEMPLATE_TYPE Vec3; template class IMATH_EXPORT_TEMPLATE_TYPE Vec4; #endif #ifndef INCLUDED_IMATHRANDOM_H class IMATH_EXPORT_TYPE Rand32; class IMATH_EXPORT_TYPE Rand48; #endif /// @endcond IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHFORWARD_H Imath-3.1.4/src/Imath/ImathFrame.h000066400000000000000000000134621417213455000166100ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Functions for computing reference frames. // #ifndef INCLUDED_IMATHFRAME_H #define INCLUDED_IMATHFRAME_H #include "ImathNamespace.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// @cond Doxygen_Suppress template class Vec3; template class Matrix44; /// @endcond /// /// @{ /// @name Functions for computing reference frames /// /// These methods compute a set of reference frames, defined by their /// transformation matrix, along a curve. It is designed so that the /// array of points and the array of matrices used to fetch these /// routines don't need to be ordered as the curve. /// /// A typical usage would be : /// /// m[0] = IMATH_INTERNAL_NAMESPACE::firstFrame( p[0], p[1], p[2] ); /// for( int i = 1; i < n - 1; i++ ) /// { /// m[i] = IMATH_INTERNAL_NAMESPACE::nextFrame( m[i-1], p[i-1], p[i], t[i-1], t[i] ); /// } /// m[n-1] = IMATH_INTERNAL_NAMESPACE::lastFrame( m[n-2], p[n-2], p[n-1] ); /// /// See Graphics Gems I for the underlying algorithm. template Matrix44 constexpr firstFrame (const Vec3&, // First point const Vec3&, // Second point const Vec3&) IMATH_NOEXCEPT; // Third point template Matrix44 constexpr nextFrame (const Matrix44&, // Previous matrix const Vec3&, // Previous point const Vec3&, // Current point Vec3&, // Previous tangent Vec3&) IMATH_NOEXCEPT; // Current tangent template Matrix44 constexpr lastFrame (const Matrix44&, // Previous matrix const Vec3&, // Previous point const Vec3&) IMATH_NOEXCEPT; // Last point /// /// Compute the first reference frame along a curve. /// /// This function returns the transformation matrix to the reference /// frame defined by the three points `pi`, `pj` and `pk`. Note that /// if the two vectors <`pi`,`pj`> and <`pi`,`pk`> are colinears, an /// arbitrary twist value will be choosen. /// /// Throw `std::domain_error` if `pi` and `pj` are equal. /// /// @param pi /// First point /// @param pj /// Second point /// @param pk /// Third point /// template Matrix44 constexpr firstFrame (const Vec3& pi, // first point const Vec3& pj, // secont point const Vec3& pk) IMATH_NOEXCEPT // third point { Vec3 t = pj - pi; t.normalizeExc(); Vec3 n = t.cross (pk - pi); n.normalize(); if (n.length() == 0.0f) { int i = fabs (t[0]) < fabs (t[1]) ? 0 : 1; if (fabs (t[2]) < fabs (t[i])) i = 2; Vec3 v (0.0, 0.0, 0.0); v[i] = 1.0; n = t.cross (v); n.normalize(); } Vec3 b = t.cross (n); Matrix44 M; M[0][0] = t[0]; M[0][1] = t[1]; M[0][2] = t[2]; M[0][3] = 0.0, M[1][0] = n[0]; M[1][1] = n[1]; M[1][2] = n[2]; M[1][3] = 0.0, M[2][0] = b[0]; M[2][1] = b[1]; M[2][2] = b[2]; M[2][3] = 0.0, M[3][0] = pi[0]; M[3][1] = pi[1]; M[3][2] = pi[2]; M[3][3] = 1.0; return M; } /// /// Compute the next reference frame along a curve. /// /// This function returns the transformation matrix to the next reference /// frame defined by the previously computed transformation matrix and the /// new point and tangent vector along the curve. /// /// @param Mi /// The previous matrix /// @param pi /// The previous point /// @param pj /// The current point /// @param ti /// The previous tangent vector /// @param tj /// The current tangent vector template Matrix44 constexpr nextFrame (const Matrix44& Mi, // Previous matrix const Vec3& pi, // Previous point const Vec3& pj, // Current point Vec3& ti, // Previous tangent vector Vec3& tj) IMATH_NOEXCEPT // Current tangent vector { Vec3 a (0.0, 0.0, 0.0); /// Rotation axis. T r = 0.0; // Rotation angle. if (ti.length() != 0.0 && tj.length() != 0.0) { ti.normalize(); tj.normalize(); T dot = ti.dot (tj); // // This is *really* necessary : // if (dot > 1.0) dot = 1.0; else if (dot < -1.0) dot = -1.0; r = acosf (dot); a = ti.cross (tj); } if (a.length() != 0.0 && r != 0.0) { Matrix44 R; R.setAxisAngle (a, r); Matrix44 Tj; Tj.translate (pj); Matrix44 Ti; Ti.translate (-pi); return Mi * Ti * R * Tj; } else { Matrix44 Tr; Tr.translate (pj - pi); return Mi * Tr; } } /// /// Compute the last reference frame along a curve. /// /// This function returns the transformation matrix to the last reference /// frame defined by the previously computed transformation matrix and the /// last point along the curve. /// /// @param Mi /// The previous matrix /// @param pi /// The previous point /// @param pj /// The last point template Matrix44 constexpr lastFrame (const Matrix44& Mi, // Previous matrix const Vec3& pi, // Previous point const Vec3& pj) IMATH_NOEXCEPT // Last point { Matrix44 Tr; Tr.translate (pj - pi); return Mi * Tr; } /// @} IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHFRAME_H Imath-3.1.4/src/Imath/ImathFrustum.h000066400000000000000000000731231417213455000172230ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A viewing frustum class // #ifndef INCLUDED_IMATHFRUSTUM_H #define INCLUDED_IMATHFRUSTUM_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathFun.h" #include "ImathLine.h" #include "ImathMatrix.h" #include "ImathPlane.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// Template class `Frustum` /// /// The frustum is always located with the eye point at the origin /// facing down -Z. This makes the Frustum class compatable with /// OpenGL (or anything that assumes a camera looks down -Z, hence /// with a right-handed coordinate system) but not with RenderMan /// which assumes the camera looks down +Z. Additional functions are /// provided for conversion from and from various camera coordinate /// spaces. /// /// nearPlane/farPlane: near/far are keywords used by Microsoft's /// compiler, so we use nearPlane/farPlane instead to avoid /// issues. template class IMATH_EXPORT_TEMPLATE_TYPE Frustum { public: /// @{ /// @name Constructors and Assignment /// /// Initialize with default values: /// near=0.1, far=1000.0, left=-1.0, right=1.0, top=1.0, bottom=-1.0, ortho=false IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Frustum() IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Frustum (const Frustum&) IMATH_NOEXCEPT; /// Initialize to specific values IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Frustum (T nearPlane, T farPlane, T left, T right, T top, T bottom, bool ortho = false) IMATH_NOEXCEPT; /// Initialize with fov and aspect IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Frustum (T nearPlane, T farPlane, T fovx, T fovy, T aspect) IMATH_NOEXCEPT; /// Destructor virtual ~Frustum() IMATH_NOEXCEPT; /// Component-wise assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Frustum& operator= (const Frustum&) IMATH_NOEXCEPT; /// @} /// @{ /// @name Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Frustum& src) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Frustum& src) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Query /// Return true if the frustum is orthographic, false if perspective IMATH_HOSTDEVICE constexpr bool orthographic() const IMATH_NOEXCEPT { return _orthographic; } /// Return the near clipping plane IMATH_HOSTDEVICE constexpr T nearPlane() const IMATH_NOEXCEPT { return _nearPlane; } /// Return the near clipping plane IMATH_HOSTDEVICE constexpr T hither() const IMATH_NOEXCEPT { return _nearPlane; } /// Return the far clipping plane IMATH_HOSTDEVICE constexpr T farPlane() const IMATH_NOEXCEPT { return _farPlane; } /// Return the far clipping plane IMATH_HOSTDEVICE constexpr T yon() const IMATH_NOEXCEPT { return _farPlane; } /// Return the left of the frustum IMATH_HOSTDEVICE constexpr T left() const IMATH_NOEXCEPT { return _left; } /// Return the right of the frustum IMATH_HOSTDEVICE constexpr T right() const IMATH_NOEXCEPT { return _right; } /// Return the bottom of the frustum IMATH_HOSTDEVICE constexpr T bottom() const IMATH_NOEXCEPT { return _bottom; } /// Return the top of the frustum IMATH_HOSTDEVICE constexpr T top() const IMATH_NOEXCEPT { return _top; } /// Return the field of view in X IMATH_HOSTDEVICE constexpr T fovx() const IMATH_NOEXCEPT; /// Return the field of view in Y IMATH_HOSTDEVICE constexpr T fovy() const IMATH_NOEXCEPT; /// Return the aspect ratio IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T aspect() const IMATH_NOEXCEPT; /// Return the aspect ratio. Throw an exception if the aspect /// ratio is undefined. IMATH_CONSTEXPR14 T aspectExc() const; /// Return the project matrix that the frustum defines IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 projectionMatrix() const IMATH_NOEXCEPT; /// Return the project matrix that the frustum defines. Throw an /// exception if the frustum is degenerate. IMATH_CONSTEXPR14 Matrix44 projectionMatrixExc() const; /// Return true if the frustum is degenerate. IMATH_HOSTDEVICE constexpr bool degenerate() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Set Value /// Set functions change the entire state of the Frustum IMATH_HOSTDEVICE void set (T nearPlane, T farPlane, T left, T right, T top, T bottom, bool ortho = false) IMATH_NOEXCEPT; /// Set functions change the entire state of the Frustum using /// field of view and aspect ratio IMATH_HOSTDEVICE void set (T nearPlane, T farPlane, T fovx, T fovy, T aspect) IMATH_NOEXCEPT; /// Set functions change the entire state of the Frustum using /// field of view and aspect ratio. Throw an exception if `fovx` /// and/or `fovy` are invalid. void setExc (T nearPlane, T farPlane, T fovx, T fovy, T aspect); /// Set the near and far clipping planes IMATH_HOSTDEVICE void modifyNearAndFar (T nearPlane, T farPlane) IMATH_NOEXCEPT; /// Set the ortographic state IMATH_HOSTDEVICE void setOrthographic (bool) IMATH_NOEXCEPT; /// Set the planes in p to be the six bounding planes of the frustum, in /// the following order: top, right, bottom, left, near, far. /// Note that the planes have normals that point out of the frustum. IMATH_HOSTDEVICE void planes (Plane3 p[6]) const IMATH_NOEXCEPT; /// Set the planes in p to be the six bounding planes of the /// frustum, in the following order: top, right, bottom, left, /// near, far. Note that the planes have normals that point out /// of the frustum. Apply the given matrix to transform the /// frustum before setting the planes. IMATH_HOSTDEVICE void planes (Plane3 p[6], const Matrix44& M) const IMATH_NOEXCEPT; /// Takes a rectangle in the screen space (i.e., -1 <= left <= right <= 1 /// and -1 <= bottom <= top <= 1) of this Frustum, and returns a new /// Frustum whose near clipping-plane window is that rectangle in local /// space. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 IMATH_HOSTDEVICE Frustum window (T left, T right, T top, T bottom) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Utility Methods /// Project a point in screen spaced to 3d ray IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Line3 projectScreenToRay (const Vec2&) const IMATH_NOEXCEPT; /// Project a 3D point into screen coordinates IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec2 projectPointToScreen (const Vec3&) const IMATH_NOEXCEPT; /// Project a 3D point into screen coordinates. Throw an /// exception if the point cannot be projected. IMATH_CONSTEXPR14 Vec2 projectPointToScreenExc (const Vec3&) const; /// Map a z value to its depth in the frustum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T ZToDepth (long zval, long min, long max) const IMATH_NOEXCEPT; /// Map a z value to its depth in the frustum. IMATH_CONSTEXPR14 T ZToDepthExc (long zval, long min, long max) const; /// Map a normalized z value to its depth in the frustum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T normalizedZToDepth (T zval) const IMATH_NOEXCEPT; /// Map a normalized z value to its depth in the frustum. Throw an /// exception on error. IMATH_CONSTEXPR14 T normalizedZToDepthExc (T zval) const; /// Map depth to z value. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 long DepthToZ (T depth, long zmin, long zmax) const IMATH_NOEXCEPT; /// Map depth to z value. Throw an exception on error. IMATH_CONSTEXPR14 long DepthToZExc (T depth, long zmin, long zmax) const; /// Compute worldRadius IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T worldRadius (const Vec3& p, T radius) const IMATH_NOEXCEPT; /// Compute worldRadius. Throw an exception on error. IMATH_CONSTEXPR14 T worldRadiusExc (const Vec3& p, T radius) const; /// Compute screen radius IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T screenRadius (const Vec3& p, T radius) const IMATH_NOEXCEPT; /// Compute screen radius. Throw an exception on error. IMATH_CONSTEXPR14 T screenRadiusExc (const Vec3& p, T radius) const; /// @} protected: /// Map point from screen space to local space IMATH_HOSTDEVICE constexpr Vec2 screenToLocal (const Vec2&) const IMATH_NOEXCEPT; /// Map point from local space to screen space IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec2 localToScreen (const Vec2&) const IMATH_NOEXCEPT; /// Map point from local space to screen space. Throw an exception /// on error. IMATH_CONSTEXPR14 Vec2 localToScreenExc (const Vec2&) const; protected: /// @cond Doxygen_Suppress T _nearPlane; T _farPlane; T _left; T _right; T _top; T _bottom; bool _orthographic; /// @endcond }; template IMATH_CONSTEXPR14 inline Frustum::Frustum() IMATH_NOEXCEPT { set (T (0.1), T (1000.0), T (-1.0), T (1.0), T (1.0), T (-1.0), false); } template IMATH_CONSTEXPR14 inline Frustum::Frustum (const Frustum& f) IMATH_NOEXCEPT { *this = f; } template IMATH_CONSTEXPR14 inline Frustum::Frustum (T n, T f, T l, T r, T t, T b, bool o) IMATH_NOEXCEPT { set (n, f, l, r, t, b, o); } template IMATH_CONSTEXPR14 inline Frustum::Frustum (T nearPlane, T farPlane, T fovx, T fovy, T aspect) IMATH_NOEXCEPT { set (nearPlane, farPlane, fovx, fovy, aspect); } template Frustum::~Frustum() IMATH_NOEXCEPT {} template IMATH_CONSTEXPR14 inline const Frustum& Frustum::operator= (const Frustum& f) IMATH_NOEXCEPT { _nearPlane = f._nearPlane; _farPlane = f._farPlane; _left = f._left; _right = f._right; _top = f._top; _bottom = f._bottom; _orthographic = f._orthographic; return *this; } template constexpr inline bool Frustum::operator== (const Frustum& src) const IMATH_NOEXCEPT { return _nearPlane == src._nearPlane && _farPlane == src._farPlane && _left == src._left && _right == src._right && _top == src._top && _bottom == src._bottom && _orthographic == src._orthographic; } template constexpr inline bool Frustum::operator!= (const Frustum& src) const IMATH_NOEXCEPT { return !operator== (src); } template inline void Frustum::set (T n, T f, T l, T r, T t, T b, bool o) IMATH_NOEXCEPT { _nearPlane = n; _farPlane = f; _left = l; _right = r; _bottom = b; _top = t; _orthographic = o; } template inline void Frustum::modifyNearAndFar (T n, T f) IMATH_NOEXCEPT { if (_orthographic) { _nearPlane = n; } else { Line3 lowerLeft (Vec3 (0, 0, 0), Vec3 (_left, _bottom, -_nearPlane)); Line3 upperRight (Vec3 (0, 0, 0), Vec3 (_right, _top, -_nearPlane)); Plane3 nearPlane (Vec3 (0, 0, -1), n); Vec3 ll = Vec3 (0, 0, 0); Vec3 ur = Vec3 (0, 0, 0); nearPlane.intersect (lowerLeft, ll); nearPlane.intersect (upperRight, ur); _left = ll.x; _right = ur.x; _top = ur.y; _bottom = ll.y; _nearPlane = n; _farPlane = f; } _farPlane = f; } template inline void Frustum::setOrthographic (bool ortho) IMATH_NOEXCEPT { _orthographic = ortho; } template inline void Frustum::setExc (T nearPlane, T farPlane, T fovx, T fovy, T aspect) { if (fovx != T (0) && fovy != T (0)) throw std::domain_error ("fovx and fovy cannot both be non-zero."); const T two = static_cast (2); if (fovx != T (0)) { _right = nearPlane * std::tan (fovx / two); _left = -_right; _top = ((_right - _left) / aspect) / two; _bottom = -_top; } else { _top = nearPlane * std::tan (fovy / two); _bottom = -_top; _right = (_top - _bottom) * aspect / two; _left = -_right; } _nearPlane = nearPlane; _farPlane = farPlane; _orthographic = false; } template inline void Frustum::set (T nearPlane, T farPlane, T fovx, T fovy, T aspect) IMATH_NOEXCEPT { const T two = static_cast (2); if (fovx != T (0)) { _right = nearPlane * std::tan (fovx / two); _left = -_right; _top = ((_right - _left) / aspect) / two; _bottom = -_top; } else { _top = nearPlane * std::tan (fovy / two); _bottom = -_top; _right = (_top - _bottom) * aspect / two; _left = -_right; } _nearPlane = nearPlane; _farPlane = farPlane; _orthographic = false; } template constexpr inline T Frustum::fovx() const IMATH_NOEXCEPT { return std::atan2 (_right, _nearPlane) - std::atan2 (_left, _nearPlane); } template constexpr inline T Frustum::fovy() const IMATH_NOEXCEPT { return std::atan2 (_top, _nearPlane) - std::atan2 (_bottom, _nearPlane); } template IMATH_CONSTEXPR14 inline T Frustum::aspectExc() const { T rightMinusLeft = _right - _left; T topMinusBottom = _top - _bottom; if (abs (topMinusBottom) < T (1) && abs (rightMinusLeft) > std::numeric_limits::max() * abs (topMinusBottom)) { throw std::domain_error ("Bad viewing frustum: " "aspect ratio cannot be computed."); } return rightMinusLeft / topMinusBottom; } template IMATH_CONSTEXPR14 inline T Frustum::aspect() const IMATH_NOEXCEPT { T rightMinusLeft = _right - _left; T topMinusBottom = _top - _bottom; return rightMinusLeft / topMinusBottom; } template IMATH_CONSTEXPR14 inline Matrix44 Frustum::projectionMatrixExc() const { T rightPlusLeft = _right + _left; T rightMinusLeft = _right - _left; T topPlusBottom = _top + _bottom; T topMinusBottom = _top - _bottom; T farPlusNear = _farPlane + _nearPlane; T farMinusNear = _farPlane - _nearPlane; if ((abs (rightMinusLeft) < T (1) && abs (rightPlusLeft) > std::numeric_limits::max() * abs (rightMinusLeft)) || (abs (topMinusBottom) < T (1) && abs (topPlusBottom) > std::numeric_limits::max() * abs (topMinusBottom)) || (abs (farMinusNear) < 1 && abs (farPlusNear) > std::numeric_limits::max() * abs (farMinusNear))) { throw std::domain_error ("Bad viewing frustum: " "projection matrix cannot be computed."); } if (_orthographic) { T tx = -rightPlusLeft / rightMinusLeft; T ty = -topPlusBottom / topMinusBottom; T tz = -farPlusNear / farMinusNear; if ((abs (rightMinusLeft) < T (1) && T (2) > std::numeric_limits::max() * abs (rightMinusLeft)) || (abs (topMinusBottom) < T (1) && T (2) > std::numeric_limits::max() * abs (topMinusBottom)) || (abs (farMinusNear) < T (1) && T (2) > std::numeric_limits::max() * abs (farMinusNear))) { throw std::domain_error ("Bad viewing frustum: " "projection matrix cannot be computed."); } T A = T (2) / rightMinusLeft; T B = T (2) / topMinusBottom; T C = T (-2) / farMinusNear; return Matrix44 (A, 0, 0, 0, 0, B, 0, 0, 0, 0, C, 0, tx, ty, tz, 1.f); } else { T A = rightPlusLeft / rightMinusLeft; T B = topPlusBottom / topMinusBottom; T C = -farPlusNear / farMinusNear; T farTimesNear = T (-2) * _farPlane * _nearPlane; if (abs (farMinusNear) < T (1) && abs (farTimesNear) > std::numeric_limits::max() * abs (farMinusNear)) { throw std::domain_error ("Bad viewing frustum: " "projection matrix cannot be computed."); } T D = farTimesNear / farMinusNear; T twoTimesNear = T (2) * _nearPlane; if ((abs (rightMinusLeft) < T (1) && abs (twoTimesNear) > std::numeric_limits::max() * abs (rightMinusLeft)) || (abs (topMinusBottom) < T (1) && abs (twoTimesNear) > std::numeric_limits::max() * abs (topMinusBottom))) { throw std::domain_error ("Bad viewing frustum: " "projection matrix cannot be computed."); } T E = twoTimesNear / rightMinusLeft; T F = twoTimesNear / topMinusBottom; return Matrix44 (E, 0, 0, 0, 0, F, 0, 0, A, B, C, -1, 0, 0, D, 0); } } template IMATH_CONSTEXPR14 inline Matrix44 Frustum::projectionMatrix() const IMATH_NOEXCEPT { T rightPlusLeft = _right + _left; T rightMinusLeft = _right - _left; T topPlusBottom = _top + _bottom; T topMinusBottom = _top - _bottom; T farPlusNear = _farPlane + _nearPlane; T farMinusNear = _farPlane - _nearPlane; if (_orthographic) { T tx = -rightPlusLeft / rightMinusLeft; T ty = -topPlusBottom / topMinusBottom; T tz = -farPlusNear / farMinusNear; T A = T (2) / rightMinusLeft; T B = T (2) / topMinusBottom; T C = T (-2) / farMinusNear; return Matrix44 (A, 0, 0, 0, 0, B, 0, 0, 0, 0, C, 0, tx, ty, tz, 1.f); } else { T A = rightPlusLeft / rightMinusLeft; T B = topPlusBottom / topMinusBottom; T C = -farPlusNear / farMinusNear; T farTimesNear = T (-2) * _farPlane * _nearPlane; T D = farTimesNear / farMinusNear; T twoTimesNear = T (2) * _nearPlane; T E = twoTimesNear / rightMinusLeft; T F = twoTimesNear / topMinusBottom; return Matrix44 (E, 0, 0, 0, 0, F, 0, 0, A, B, C, -1, 0, 0, D, 0); } } template constexpr inline bool Frustum::degenerate() const IMATH_NOEXCEPT { return (_nearPlane == _farPlane) || (_left == _right) || (_top == _bottom); } template IMATH_CONSTEXPR14 inline Frustum Frustum::window (T l, T r, T t, T b) const IMATH_NOEXCEPT { // move it to 0->1 space Vec2 bl = screenToLocal (Vec2 (l, b)); Vec2 tr = screenToLocal (Vec2 (r, t)); return Frustum (_nearPlane, _farPlane, bl.x, tr.x, tr.y, bl.y, _orthographic); } template constexpr inline Vec2 Frustum::screenToLocal (const Vec2& s) const IMATH_NOEXCEPT { return Vec2 (_left + (_right - _left) * (1.f + s.x) / 2.f, _bottom + (_top - _bottom) * (1.f + s.y) / 2.f); } template IMATH_CONSTEXPR14 inline Vec2 Frustum::localToScreenExc (const Vec2& p) const { T leftPlusRight = _left - T (2) * p.x + _right; T leftMinusRight = _left - _right; T bottomPlusTop = _bottom - T (2) * p.y + _top; T bottomMinusTop = _bottom - _top; if ((abs (leftMinusRight) < T (1) && abs (leftPlusRight) > std::numeric_limits::max() * abs (leftMinusRight)) || (abs (bottomMinusTop) < T (1) && abs (bottomPlusTop) > std::numeric_limits::max() * abs (bottomMinusTop))) { throw std::domain_error ("Bad viewing frustum: " "local-to-screen transformation cannot be computed"); } return Vec2 (leftPlusRight / leftMinusRight, bottomPlusTop / bottomMinusTop); } template IMATH_CONSTEXPR14 inline Vec2 Frustum::localToScreen (const Vec2& p) const IMATH_NOEXCEPT { T leftPlusRight = _left - T (2) * p.x + _right; T leftMinusRight = _left - _right; T bottomPlusTop = _bottom - T (2) * p.y + _top; T bottomMinusTop = _bottom - _top; return Vec2 (leftPlusRight / leftMinusRight, bottomPlusTop / bottomMinusTop); } template IMATH_CONSTEXPR14 inline Line3 Frustum::projectScreenToRay (const Vec2& p) const IMATH_NOEXCEPT { Vec2 point = screenToLocal (p); if (orthographic()) return Line3 (Vec3 (point.x, point.y, 0.0), Vec3 (point.x, point.y, -1.0)); else return Line3 (Vec3 (0, 0, 0), Vec3 (point.x, point.y, -_nearPlane)); } template IMATH_CONSTEXPR14 Vec2 Frustum::projectPointToScreenExc (const Vec3& point) const { if (orthographic() || point.z == T (0)) return localToScreenExc (Vec2 (point.x, point.y)); else return localToScreenExc ( Vec2 (point.x * _nearPlane / -point.z, point.y * _nearPlane / -point.z)); } template IMATH_CONSTEXPR14 Vec2 Frustum::projectPointToScreen (const Vec3& point) const IMATH_NOEXCEPT { if (orthographic() || point.z == T (0)) return localToScreen (Vec2 (point.x, point.y)); else return localToScreen ( Vec2 (point.x * _nearPlane / -point.z, point.y * _nearPlane / -point.z)); } template IMATH_CONSTEXPR14 T Frustum::ZToDepthExc (long zval, long zmin, long zmax) const { int zdiff = zmax - zmin; if (zdiff == 0) { throw std::domain_error ("Bad call to Frustum::ZToDepth: zmax == zmin"); } if (zval > zmax + 1) zval -= zdiff; T fzval = (T (zval) - T (zmin)) / T (zdiff); return normalizedZToDepthExc (fzval); } template IMATH_CONSTEXPR14 T Frustum::ZToDepth (long zval, long zmin, long zmax) const IMATH_NOEXCEPT { int zdiff = zmax - zmin; if (zval > zmax + 1) zval -= zdiff; T fzval = (T (zval) - T (zmin)) / T (zdiff); return normalizedZToDepth (fzval); } template IMATH_CONSTEXPR14 T Frustum::normalizedZToDepthExc (T zval) const { T Zp = zval * T (2) - T (1); if (_orthographic) { return -(Zp * (_farPlane - _nearPlane) + (_farPlane + _nearPlane)) / T (2); } else { T farTimesNear = 2 * _farPlane * _nearPlane; T farMinusNear = Zp * (_farPlane - _nearPlane) - _farPlane - _nearPlane; if (abs (farMinusNear) < 1 && abs (farTimesNear) > std::numeric_limits::max() * abs (farMinusNear)) { throw std::domain_error ("Frustum::normalizedZToDepth cannot be computed: " "near and far clipping planes of the viewing frustum " "may be too close to each other"); } return farTimesNear / farMinusNear; } } template IMATH_CONSTEXPR14 T Frustum::normalizedZToDepth (T zval) const IMATH_NOEXCEPT { T Zp = zval * T (2) - T (1); if (_orthographic) { return -(Zp * (_farPlane - _nearPlane) + (_farPlane + _nearPlane)) / T (2); } else { T farTimesNear = 2 * _farPlane * _nearPlane; T farMinusNear = Zp * (_farPlane - _nearPlane) - _farPlane - _nearPlane; return farTimesNear / farMinusNear; } } template IMATH_CONSTEXPR14 long Frustum::DepthToZExc (T depth, long zmin, long zmax) const { long zdiff = zmax - zmin; T farMinusNear = _farPlane - _nearPlane; if (_orthographic) { T farPlusNear = T (2) * depth + _farPlane + _nearPlane; if (abs (farMinusNear) < T (1) && abs (farPlusNear) > std::numeric_limits::max() * abs (farMinusNear)) { throw std::domain_error ("Bad viewing frustum: " "near and far clipping planes " "are too close to each other"); } T Zp = -farPlusNear / farMinusNear; return long (0.5 * (Zp + 1) * zdiff) + zmin; } else { // Perspective T farTimesNear = T (2) * _farPlane * _nearPlane; if (abs (depth) < T (1) && abs (farTimesNear) > std::numeric_limits::max() * abs (depth)) { throw std::domain_error ("Bad call to DepthToZ function: " "value of `depth' is too small"); } T farPlusNear = farTimesNear / depth + _farPlane + _nearPlane; if (abs (farMinusNear) < T (1) && abs (farPlusNear) > std::numeric_limits::max() * abs (farMinusNear)) { throw std::domain_error ("Bad viewing frustum: " "near and far clipping planes " "are too close to each other"); } T Zp = farPlusNear / farMinusNear; return long (0.5 * (Zp + 1) * zdiff) + zmin; } } template IMATH_CONSTEXPR14 long Frustum::DepthToZ (T depth, long zmin, long zmax) const IMATH_NOEXCEPT { long zdiff = zmax - zmin; T farMinusNear = _farPlane - _nearPlane; if (_orthographic) { T farPlusNear = T (2) * depth + _farPlane + _nearPlane; T Zp = -farPlusNear / farMinusNear; return long (0.5 * (Zp + 1) * zdiff) + zmin; } else { // Perspective T farTimesNear = T (2) * _farPlane * _nearPlane; T farPlusNear = farTimesNear / depth + _farPlane + _nearPlane; T Zp = farPlusNear / farMinusNear; return long (0.5 * (Zp + 1) * zdiff) + zmin; } } template IMATH_CONSTEXPR14 T Frustum::screenRadiusExc (const Vec3& p, T radius) const { // Derivation: // Consider X-Z plane. // X coord of projection of p = xp = p.x * (-_nearPlane / p.z) // Let q be p + (radius, 0, 0). // X coord of projection of q = xq = (p.x - radius) * (-_nearPlane / p.z) // X coord of projection of segment from p to q = r = xp - xq // = radius * (-_nearPlane / p.z) // A similar analysis holds in the Y-Z plane. // So r is the quantity we want to return. if (abs (p.z) > T (1) || abs (-_nearPlane) < std::numeric_limits::max() * abs (p.z)) { return radius * (-_nearPlane / p.z); } else { throw std::domain_error ("Bad call to Frustum::screenRadius: " "magnitude of `p' is too small"); } return radius * (-_nearPlane / p.z); } template IMATH_CONSTEXPR14 T Frustum::screenRadius (const Vec3& p, T radius) const IMATH_NOEXCEPT { // Derivation: // Consider X-Z plane. // X coord of projection of p = xp = p.x * (-_nearPlane / p.z) // Let q be p + (radius, 0, 0). // X coord of projection of q = xq = (p.x - radius) * (-_nearPlane / p.z) // X coord of projection of segment from p to q = r = xp - xq // = radius * (-_nearPlane / p.z) // A similar analysis holds in the Y-Z plane. // So r is the quantity we want to return. return radius * (-_nearPlane / p.z); } template IMATH_CONSTEXPR14 T Frustum::worldRadiusExc (const Vec3& p, T radius) const { if (abs (-_nearPlane) > T (1) || abs (p.z) < std::numeric_limits::max() * abs (-_nearPlane)) { return radius * (p.z / -_nearPlane); } else { throw std::domain_error ("Bad viewing frustum: " "near clipping plane is too close to zero"); } } template IMATH_CONSTEXPR14 T Frustum::worldRadius (const Vec3& p, T radius) const IMATH_NOEXCEPT { return radius * (p.z / -_nearPlane); } template void Frustum::planes (Plane3 p[6]) const IMATH_NOEXCEPT { // // Plane order: Top, Right, Bottom, Left, Near, Far. // Normals point outwards. // if (!_orthographic) { Vec3 a (_left, _bottom, -_nearPlane); Vec3 b (_left, _top, -_nearPlane); Vec3 c (_right, _top, -_nearPlane); Vec3 d (_right, _bottom, -_nearPlane); Vec3 o (0, 0, 0); p[0].set (o, c, b); p[1].set (o, d, c); p[2].set (o, a, d); p[3].set (o, b, a); } else { p[0].set (Vec3 (0, 1, 0), _top); p[1].set (Vec3 (1, 0, 0), _right); p[2].set (Vec3 (0, -1, 0), -_bottom); p[3].set (Vec3 (-1, 0, 0), -_left); } p[4].set (Vec3 (0, 0, 1), -_nearPlane); p[5].set (Vec3 (0, 0, -1), _farPlane); } template void Frustum::planes (Plane3 p[6], const Matrix44& M) const IMATH_NOEXCEPT { // // Plane order: Top, Right, Bottom, Left, Near, Far. // Normals point outwards. // Vec3 a = Vec3 (_left, _bottom, -_nearPlane) * M; Vec3 b = Vec3 (_left, _top, -_nearPlane) * M; Vec3 c = Vec3 (_right, _top, -_nearPlane) * M; Vec3 d = Vec3 (_right, _bottom, -_nearPlane) * M; if (!_orthographic) { double s = _farPlane / double (_nearPlane); T farLeft = (T) (s * _left); T farRight = (T) (s * _right); T farTop = (T) (s * _top); T farBottom = (T) (s * _bottom); Vec3 e = Vec3 (farLeft, farBottom, -_farPlane) * M; Vec3 f = Vec3 (farLeft, farTop, -_farPlane) * M; Vec3 g = Vec3 (farRight, farTop, -_farPlane) * M; Vec3 o = Vec3 (0, 0, 0) * M; p[0].set (o, c, b); p[1].set (o, d, c); p[2].set (o, a, d); p[3].set (o, b, a); p[4].set (a, d, c); p[5].set (e, f, g); } else { Vec3 e = Vec3 (_left, _bottom, -_farPlane) * M; Vec3 f = Vec3 (_left, _top, -_farPlane) * M; Vec3 g = Vec3 (_right, _top, -_farPlane) * M; Vec3 h = Vec3 (_right, _bottom, -_farPlane) * M; p[0].set (c, g, f); p[1].set (d, h, g); p[2].set (a, e, h); p[3].set (b, f, e); p[4].set (a, d, c); p[5].set (e, f, g); } } /// Frustum of type float typedef Frustum Frustumf; /// Frustum of type double typedef Frustum Frustumd; IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #if defined _WIN32 || defined _WIN64 # ifdef _redef_near # define near # endif # ifdef _redef_far # define far # endif #endif #endif // INCLUDED_IMATHFRUSTUM_H Imath-3.1.4/src/Imath/ImathFrustumTest.h000066400000000000000000000272631417213455000200670ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A viewing frustum class // // This file contains algorithms applied to or in conjunction with // Frustum visibility testing (Imath::Frustum). // // Methods for frustum-based rejection of primitives are contained here. // #ifndef INCLUDED_IMATHFRUSTUMTEST_H #define INCLUDED_IMATHFRUSTUMTEST_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathBox.h" #include "ImathFrustum.h" #include "ImathMatrix.h" #include "ImathSphere.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// template class FrustumTest /// /// This is a helper class, designed to accelerate the case /// where many tests are made against the same frustum. /// That's a really common case. /// /// The acceleration is achieved by pre-computing the planes of /// the frustum, along with the ablsolute values of the plane normals. /// /// How to use this /// /// Given that you already have: /// Imath::Frustum myFrustum /// Imath::Matrix44 myCameraWorldMatrix /// /// First, make a frustum test object: /// FrustumTest myFrustumTest(myFrustum, myCameraWorldMatrix) /// /// Whenever the camera or frustum changes, call: /// myFrustumTest.setFrustum(myFrustum, myCameraWorldMatrix) /// /// For each object you want to test for visibility, call: /// myFrustumTest.isVisible(myBox) /// myFrustumTest.isVisible(mySphere) /// myFrustumTest.isVisible(myVec3) /// myFrustumTest.completelyContains(myBox) /// myFrustumTest.completelyContains(mySphere) /// /// Explanation of how it works /// /// We store six world-space Frustum planes (nx, ny, nz, offset) /// /// Points: To test a Vec3 for visibility, test it against each plane /// using the normal (v dot n - offset) method. (the result is exact) /// /// BBoxes: To test an axis-aligned bbox, test the center against each plane /// using the normal (v dot n - offset) method, but offset by the /// box extents dot the abs of the plane normal. (the result is NOT /// exact, but will not return false-negatives.) /// /// Spheres: To test a sphere, test the center against each plane /// using the normal (v dot n - offset) method, but offset by the /// sphere's radius. (the result is NOT exact, but will not return /// false-negatives.) /// /// /// SPECIAL NOTE: "Where are the dot products?" /// Actual dot products are currently slow for most SIMD architectures. /// In order to keep this code optimization-ready, the dot products /// are all performed using vector adds and multipies. /// /// In order to do this, the plane equations are stored in "transpose" /// form, with the X components grouped into an X vector, etc. /// template class IMATH_EXPORT_TEMPLATE_TYPE FrustumTest { public: /// @{ /// @name Constructors /// Initialize camera matrix to identity FrustumTest() IMATH_NOEXCEPT { Frustum frust; Matrix44 cameraMat; cameraMat.makeIdentity(); setFrustum (frust, cameraMat); } /// Initialize to a given frustum and camera matrix. FrustumTest (const Frustum& frustum, const Matrix44& cameraMat) IMATH_NOEXCEPT { setFrustum (frustum, cameraMat); } /// @} /// @{ /// @name Set Value /// Update the frustum test with a new frustum and matrix. /// This should usually be called just once per frame, or however /// often the camera moves. void setFrustum (const Frustum& frustum, const Matrix44& cameraMat) IMATH_NOEXCEPT; /// @} /// @{ /// @name Query /// Return true if any part of the sphere is inside the frustum. /// The result MAY return close false-positives, but not false-negatives. bool isVisible (const Sphere3& sphere) const IMATH_NOEXCEPT; /// Return true if any part of the box is inside the frustum. /// The result MAY return close false-positives, but not false-negatives. bool isVisible (const Box>& box) const IMATH_NOEXCEPT; /// Return true if the point is inside the frustum. bool isVisible (const Vec3& vec) const IMATH_NOEXCEPT; /// Return true if every part of the sphere is inside the frustum. /// The result MAY return close false-negatives, but not false-positives. bool completelyContains (const Sphere3& sphere) const IMATH_NOEXCEPT; /// Return true if every part of the box is inside the frustum. /// The result MAY return close false-negatives, but not false-positives. bool completelyContains (const Box>& box) const IMATH_NOEXCEPT; /// Return the camera matrix (primarily for debugging) IMATH_INTERNAL_NAMESPACE::Matrix44 cameraMat() const IMATH_NOEXCEPT { return cameraMatrix; } /// Return the viewing frustum (primarily for debugging) IMATH_INTERNAL_NAMESPACE::Frustum currentFrustum() const IMATH_NOEXCEPT { return currFrustum; } /// @} protected: // To understand why the planes are stored this way, see // the SPECIAL NOTE above. /// @cond Doxygen_Suppress Vec3 planeNormX[2]; // The X components from 6 plane equations Vec3 planeNormY[2]; // The Y components from 6 plane equations Vec3 planeNormZ[2]; // The Z components from 6 plane equations Vec3 planeOffsetVec[2]; // The distance offsets from 6 plane equations // The absolute values are stored to assist with bounding box tests. Vec3 planeNormAbsX[2]; // The abs(X) components from 6 plane equations Vec3 planeNormAbsY[2]; // The abs(X) components from 6 plane equations Vec3 planeNormAbsZ[2]; // The abs(X) components from 6 plane equations // These are kept primarily for debugging tools. Frustum currFrustum; Matrix44 cameraMatrix; /// @endcond }; template void FrustumTest::setFrustum (const Frustum& frustum, const Matrix44& cameraMat) IMATH_NOEXCEPT { Plane3 frustumPlanes[6]; frustum.planes (frustumPlanes, cameraMat); // Here's where we effectively transpose the plane equations. // We stuff all six X's into the two planeNormX vectors, etc. for (int i = 0; i < 2; ++i) { int index = i * 3; planeNormX[i] = Vec3 (frustumPlanes[index + 0].normal.x, frustumPlanes[index + 1].normal.x, frustumPlanes[index + 2].normal.x); planeNormY[i] = Vec3 (frustumPlanes[index + 0].normal.y, frustumPlanes[index + 1].normal.y, frustumPlanes[index + 2].normal.y); planeNormZ[i] = Vec3 (frustumPlanes[index + 0].normal.z, frustumPlanes[index + 1].normal.z, frustumPlanes[index + 2].normal.z); planeNormAbsX[i] = Vec3 (std::abs (planeNormX[i].x), std::abs (planeNormX[i].y), std::abs (planeNormX[i].z)); planeNormAbsY[i] = Vec3 (std::abs (planeNormY[i].x), std::abs (planeNormY[i].y), std::abs (planeNormY[i].z)); planeNormAbsZ[i] = Vec3 (std::abs (planeNormZ[i].x), std::abs (planeNormZ[i].y), std::abs (planeNormZ[i].z)); planeOffsetVec[i] = Vec3 (frustumPlanes[index + 0].distance, frustumPlanes[index + 1].distance, frustumPlanes[index + 2].distance); } currFrustum = frustum; cameraMatrix = cameraMat; } template bool FrustumTest::isVisible (const Sphere3& sphere) const IMATH_NOEXCEPT { Vec3 center = sphere.center; Vec3 radiusVec = Vec3 (sphere.radius, sphere.radius, sphere.radius); // This is a vertical dot-product on three vectors at once. Vec3 d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z - radiusVec - planeOffsetVec[0]; if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0) return false; Vec3 d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z - radiusVec - planeOffsetVec[1]; if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0) return false; return true; } template bool FrustumTest::completelyContains (const Sphere3& sphere) const IMATH_NOEXCEPT { Vec3 center = sphere.center; Vec3 radiusVec = Vec3 (sphere.radius, sphere.radius, sphere.radius); // This is a vertical dot-product on three vectors at once. Vec3 d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z + radiusVec - planeOffsetVec[0]; if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0) return false; Vec3 d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z + radiusVec - planeOffsetVec[1]; if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0) return false; return true; } template bool FrustumTest::isVisible (const Box>& box) const IMATH_NOEXCEPT { if (box.isEmpty()) return false; Vec3 center = (box.min + box.max) / 2; Vec3 extent = (box.max - center); // This is a vertical dot-product on three vectors at once. Vec3 d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z - planeNormAbsX[0] * extent.x - planeNormAbsY[0] * extent.y - planeNormAbsZ[0] * extent.z - planeOffsetVec[0]; if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0) return false; Vec3 d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z - planeNormAbsX[1] * extent.x - planeNormAbsY[1] * extent.y - planeNormAbsZ[1] * extent.z - planeOffsetVec[1]; if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0) return false; return true; } template bool FrustumTest::completelyContains (const Box>& box) const IMATH_NOEXCEPT { if (box.isEmpty()) return false; Vec3 center = (box.min + box.max) / 2; Vec3 extent = (box.max - center); // This is a vertical dot-product on three vectors at once. Vec3 d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z + planeNormAbsX[0] * extent.x + planeNormAbsY[0] * extent.y + planeNormAbsZ[0] * extent.z - planeOffsetVec[0]; if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0) return false; Vec3 d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z + planeNormAbsX[1] * extent.x + planeNormAbsY[1] * extent.y + planeNormAbsZ[1] * extent.z - planeOffsetVec[1]; if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0) return false; return true; } template bool FrustumTest::isVisible (const Vec3& vec) const IMATH_NOEXCEPT { // This is a vertical dot-product on three vectors at once. Vec3 d0 = (planeNormX[0] * vec.x) + (planeNormY[0] * vec.y) + (planeNormZ[0] * vec.z) - planeOffsetVec[0]; if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0) return false; Vec3 d1 = (planeNormX[1] * vec.x) + (planeNormY[1] * vec.y) + (planeNormZ[1] * vec.z) - planeOffsetVec[1]; if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0) return false; return true; } /// FrustymTest of type float typedef FrustumTest FrustumTestf; /// FrustymTest of type double typedef FrustumTest FrustumTestd; IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHFRUSTUMTEST_H Imath-3.1.4/src/Imath/ImathFun.cpp000066400000000000000000000053701417213455000166400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #include "ImathFun.h" IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER float succf (float f) IMATH_NOEXCEPT { union { float f; uint32_t i; } u; u.f = f; if (isinf(f) || isnan (f)) { // Nan or infinity; don't change value. } else if (u.i == 0x00000000 || u.i == 0x80000000) { // Plus or minus zero. u.i = 0x00000001; } else if (u.f > 0) { // Positive float, normalized or denormalized. // Incrementing the largest positive float // produces +infinity. ++u.i; } else { // Negative normalized or denormalized float. --u.i; } return u.f; } float predf (float f) IMATH_NOEXCEPT { union { float f; uint32_t i; } u; u.f = f; if (isinf(f) || isnan (f)) { // Nan or infinity; don't change value. } else if (u.i == 0x00000000 || u.i == 0x80000000) { // Plus or minus zero. u.i = 0x80000001; } else if (u.f > 0) { // Positive float, normalized or denormalized. --u.i; } else { // Negative normalized or denormalized float. // Decrementing the largest negative float // produces -infinity. ++u.i; } return u.f; } double succd (double d) IMATH_NOEXCEPT { union { double d; uint64_t i; } u; u.d = d; if (isinf(d) || isnan (d)) { // Nan or infinity; don't change value. } else if (u.i == 0x0000000000000000LL || u.i == 0x8000000000000000LL) { // Plus or minus zero. u.i = 0x0000000000000001LL; } else if (u.d > 0) { // Positive double, normalized or denormalized. // Incrementing the largest positive double // produces +infinity. ++u.i; } else { // Negative normalized or denormalized double. --u.i; } return u.d; } double predd (double d) IMATH_NOEXCEPT { union { double d; uint64_t i; } u; u.d = d; if ((u.i & 0x7ff0000000000000LL) == 0x7ff0000000000000LL) { // Nan or infinity; don't change value. } else if (u.i == 0x0000000000000000LL || u.i == 0x8000000000000000LL) { // Plus or minus zero. u.i = 0x8000000000000001LL; } else if (u.d > 0) { // Positive double, normalized or denormalized. --u.i; } else { // Negative normalized or denormalized double. // Decrementing the largest negative double // produces -infinity. ++u.i; } return u.d; } IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT Imath-3.1.4/src/Imath/ImathFun.h000066400000000000000000000123651417213455000163070ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifndef INCLUDED_IMATHFUN_H #define INCLUDED_IMATHFUN_H //----------------------------------------------------------------------------- // // Miscellaneous utility functions // //----------------------------------------------------------------------------- #include #include #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathPlatform.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER template IMATH_HOSTDEVICE constexpr inline T abs (T a) IMATH_NOEXCEPT { return (a > T (0)) ? a : -a; } template IMATH_HOSTDEVICE constexpr inline int sign (T a) IMATH_NOEXCEPT { return (a > T (0)) ? 1 : ((a < T (0)) ? -1 : 0); } template IMATH_HOSTDEVICE constexpr inline T lerp (T a, T b, Q t) IMATH_NOEXCEPT { return (T) (a * (1 - t) + b * t); } template IMATH_HOSTDEVICE constexpr inline T ulerp (T a, T b, Q t) IMATH_NOEXCEPT { return (T) ((a > b) ? (a - (a - b) * t) : (a + (b - a) * t)); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T lerpfactor (T m, T a, T b) IMATH_NOEXCEPT { // // Return how far m is between a and b, that is return t such that // if: // t = lerpfactor(m, a, b); // then: // m = lerp(a, b, t); // // If a==b, return 0. // T d = b - a; T n = m - a; if (abs (d) > T (1) || abs (n) < std::numeric_limits::max() * abs (d)) return n / d; return T (0); } template IMATH_HOSTDEVICE constexpr inline T clamp (T a, T l, T h) IMATH_NOEXCEPT { return (a < l) ? l : ((a > h) ? h : a); } template IMATH_HOSTDEVICE constexpr inline int cmp (T a, T b) IMATH_NOEXCEPT { return IMATH_INTERNAL_NAMESPACE::sign (a - b); } template IMATH_HOSTDEVICE constexpr inline int cmpt (T a, T b, T t) IMATH_NOEXCEPT { return (IMATH_INTERNAL_NAMESPACE::abs (a - b) <= t) ? 0 : cmp (a, b); } template IMATH_HOSTDEVICE constexpr inline bool iszero (T a, T t) IMATH_NOEXCEPT { return (IMATH_INTERNAL_NAMESPACE::abs (a) <= t) ? 1 : 0; } template IMATH_HOSTDEVICE constexpr inline bool equal (T1 a, T2 b, T3 t) IMATH_NOEXCEPT { return IMATH_INTERNAL_NAMESPACE::abs (a - b) <= t; } template IMATH_HOSTDEVICE constexpr inline int floor (T x) IMATH_NOEXCEPT { return (x >= 0) ? int (x) : -(int (-x) + (-x > int (-x))); } template IMATH_HOSTDEVICE constexpr inline int ceil (T x) IMATH_NOEXCEPT { return -floor (-x); } template IMATH_HOSTDEVICE constexpr inline int trunc (T x) IMATH_NOEXCEPT { return (x >= 0) ? int (x) : -int (-x); } // // Integer division and remainder where the // remainder of x/y has the same sign as x: // // divs(x,y) == (abs(x) / abs(y)) * (sign(x) * sign(y)) // mods(x,y) == x - y * divs(x,y) // IMATH_HOSTDEVICE constexpr inline int divs (int x, int y) IMATH_NOEXCEPT { return (x >= 0) ? ((y >= 0) ? (x / y) : -(x / -y)) : ((y >= 0) ? -(-x / y) : (-x / -y)); } IMATH_HOSTDEVICE constexpr inline int mods (int x, int y) IMATH_NOEXCEPT { return (x >= 0) ? ((y >= 0) ? (x % y) : (x % -y)) : ((y >= 0) ? -(-x % y) : -(-x % -y)); } // // Integer division and remainder where the // remainder of x/y is always positive: // // divp(x,y) == floor (double(x) / double (y)) // modp(x,y) == x - y * divp(x,y) // IMATH_HOSTDEVICE constexpr inline int divp (int x, int y) IMATH_NOEXCEPT { return (x >= 0) ? ((y >= 0) ? (x / y) : -(x / -y)) : ((y >= 0) ? -((y - 1 - x) / y) : ((-y - 1 - x) / -y)); } IMATH_HOSTDEVICE constexpr inline int modp (int x, int y) IMATH_NOEXCEPT { return x - y * divp (x, y); } //---------------------------------------------------------- // Successor and predecessor for floating-point numbers: // // succf(f) returns float(f+e), where e is the smallest // positive number such that float(f+e) != f. // // predf(f) returns float(f-e), where e is the smallest // positive number such that float(f-e) != f. // // succd(d) returns double(d+e), where e is the smallest // positive number such that double(d+e) != d. // // predd(d) returns double(d-e), where e is the smallest // positive number such that double(d-e) != d. // // Exceptions: If the input value is an infinity or a nan, // succf(), predf(), succd(), and predd() all // return the input value without changing it. // //---------------------------------------------------------- IMATH_EXPORT float succf (float f) IMATH_NOEXCEPT; IMATH_EXPORT float predf (float f) IMATH_NOEXCEPT; IMATH_EXPORT double succd (double d) IMATH_NOEXCEPT; IMATH_EXPORT double predd (double d) IMATH_NOEXCEPT; // // Return true if the number is not a NaN or Infinity. // IMATH_HOSTDEVICE inline bool finitef (float f) IMATH_NOEXCEPT { union { float f; int i; } u; u.f = f; return (u.i & 0x7f800000) != 0x7f800000; } IMATH_HOSTDEVICE inline bool finited (double d) IMATH_NOEXCEPT { union { double d; uint64_t i; } u; u.d = d; return (u.i & 0x7ff0000000000000LL) != 0x7ff0000000000000LL; } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHFUN_H Imath-3.1.4/src/Imath/ImathGL.h000066400000000000000000000074111417213455000160550ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Convenience functions that call GL with Imath types // #ifndef INCLUDED_IMATHGL_H #define INCLUDED_IMATHGL_H #include #include "ImathFun.h" #include "ImathMatrix.h" #include "ImathNamespace.h" #include "ImathVec.h" /// Call glVertex3f inline void glVertex (const IMATH_INTERNAL_NAMESPACE::V3f& v) { glVertex3f (v.x, v.y, v.z); } /// Call glVertex2f inline void glVertex (const IMATH_INTERNAL_NAMESPACE::V2f& v) { glVertex2f (v.x, v.y); } /// Call glNormal3f inline void glNormal (const IMATH_INTERNAL_NAMESPACE::V3f& n) { glNormal3f (n.x, n.y, n.z); } /// Call glColor3f inline void glColor (const IMATH_INTERNAL_NAMESPACE::V3f& c) { glColor3f (c.x, c.y, c.z); } /// Call glTranslatef inline void glTranslate (const IMATH_INTERNAL_NAMESPACE::V3f& t) { glTranslatef (t.x, t.y, t.z); } /// Call glTexCoord2f inline void glTexCoord (const IMATH_INTERNAL_NAMESPACE::V2f& t) { glTexCoord2f (t.x, t.y); } /// Disable GL textures inline void glDisableTexture() { glActiveTexture (GL_TEXTURE1); glBindTexture (GL_TEXTURE_2D, 0); glDisable (GL_TEXTURE_2D); glActiveTexture (GL_TEXTURE0); } namespace { const float GL_FLOAT_MAX = 1.8e+19; // sqrt (FLT_MAX) inline bool badFloat (float f) { return !IMATH_INTERNAL_NAMESPACE::finitef (f) || f < -GL_FLOAT_MAX || f > GL_FLOAT_MAX; } } // namespace /// Throw an exception if m is not a valid matrix for GL inline void throwBadMatrix (const IMATH_INTERNAL_NAMESPACE::M44f& m) { if (badFloat (m[0][0]) || badFloat (m[0][1]) || badFloat (m[0][2]) || badFloat (m[0][3]) || badFloat (m[1][0]) || badFloat (m[1][1]) || badFloat (m[1][2]) || badFloat (m[1][3]) || badFloat (m[2][0]) || badFloat (m[2][1]) || badFloat (m[2][2]) || badFloat (m[2][3]) || badFloat (m[3][0]) || badFloat (m[3][1]) || badFloat (m[3][2]) || badFloat (m[3][3])) throw std::invalid_argument ("GL matrix overflow"); } /// Call glMultmatrixf. Throw an exception if m is not a valid matrix for GL. inline void glMultMatrix (const IMATH_INTERNAL_NAMESPACE::M44f& m) { throwBadMatrix (m); glMultMatrixf ((GLfloat*) m[0]); } /// Call glMultmatrixf. Throw an exception if m is not a valid matrix for GL. inline void glMultMatrix (const IMATH_INTERNAL_NAMESPACE::M44f* m) { throwBadMatrix (*m); glMultMatrixf ((GLfloat*) (*m)[0]); } /// Call glLoadmatrixf. Throw an exception if m is not a valid matrix for GL. inline void glLoadMatrix (const IMATH_INTERNAL_NAMESPACE::M44f& m) { throwBadMatrix (m); glLoadMatrixf ((GLfloat*) m[0]); } /// Call glLoadmatrixf. Throw an exception if m is not a valid matrix for GL. inline void glLoadMatrix (const IMATH_INTERNAL_NAMESPACE::M44f* m) { throwBadMatrix (*m); glLoadMatrixf ((GLfloat*) (*m)[0]); } IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// A class object that pushes/pops the GL matrix. This object assists with /// proper cleanup of the state when exceptions are thrown. /// class GLPushMatrix { public: GLPushMatrix() { glPushMatrix(); } ~GLPushMatrix() { glPopMatrix(); } }; /// /// A class object that pushes/pops the current GL attribute state. This object assists with /// proper cleanup of the state when exceptions are thrown. /// class GLPushAttrib { public: /// call glPushAttrib() GLPushAttrib (GLbitfield mask) { glPushAttrib (mask); } /// call glPopAttrib() ~GLPushAttrib() { glPopAttrib(); } }; /// /// A class object that wraps glBegin/glEnd. The constructor calls /// glBegin(). The destructor calls glEnd(). /// class GLBegin { public: /// Call glBegin() GLBegin (GLenum mode) { glBegin (mode); } /// Call glEnd() ~GLBegin() { glEnd(); } }; IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif Imath-3.1.4/src/Imath/ImathGLU.h000066400000000000000000000011641417213455000162010ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Convenience functions that call GLU with Imath types // #ifndef INCLUDED_IMATHGLU_H #define INCLUDED_IMATHGLU_H #include #include #include "ImathVec.h" /// Call gluLookAt with the given position, interest, and up-vector. inline void gluLookAt (const IMATH_INTERNAL_NAMESPACE::V3f& pos, const IMATH_INTERNAL_NAMESPACE::V3f& interest, const IMATH_INTERNAL_NAMESPACE::V3f& up) { gluLookAt (pos.x, pos.y, pos.z, interest.x, interest.y, interest.z, up.x, up.y, up.z); } #endif Imath-3.1.4/src/Imath/ImathInt64.h000066400000000000000000000021231417213455000164520ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // 64-bit integer types // // Deprecated, use int64_t/uint64_t instead. // #ifndef INCLUDED_IMATH_INT64_H #define INCLUDED_IMATH_INT64_H #include "ImathNamespace.h" #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER #if (defined _WIN32 || defined _WIN64) && _MSC_VER >= 1300 /// Int64 - unsigned 64-bit integer IMATH_DEPRECATED("use uint64_t") typedef unsigned __int64 Int64; /// SInt64 - signed 64-bit integer IMATH_DEPRECATED("use sint64_t") typedef __int64 SInt64; #elif ULONG_MAX == 18446744073709551615LU /// Int64 - unsigned 64-bit integer IMATH_DEPRECATED("use uint64_t") typedef long unsigned int Int64; /// SInt64 - signed 64-bit integer IMATH_DEPRECATED("use sint64_t") typedef long int SInt64; #else /// Int64 - unsigned 64-bit integer IMATH_DEPRECATED("use uint64_t") typedef long long unsigned int Int64; /// SInt64 - signed 64-bit integer IMATH_DEPRECATED("use sint64_t") typedef long long int SInt64; #endif IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATH_INT64_H Imath-3.1.4/src/Imath/ImathInterval.h000066400000000000000000000153031417213455000173360ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // An interval class // #ifndef INCLUDED_IMATHINTERVAL_H #define INCLUDED_IMATHINTERVAL_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// An Interval has a min and a max and some miscellaneous /// functions. It is basically a Box that allows T to be a scalar. /// template class IMATH_EXPORT_TEMPLATE_TYPE Interval { public: /// @{ /// @name Direct access to bounds /// The minimum value of the interval T min; /// The minimum value of the interval T max; /// @} /// @{ /// @name Constructors /// Initialize to the empty interval IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Interval() IMATH_NOEXCEPT; /// Intitialize to a single point IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Interval (const T& point) IMATH_NOEXCEPT; /// Intitialize to a given (min,max) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Interval (const T& minT, const T& maxT) IMATH_NOEXCEPT; /// @} /// @{ /// @name Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Interval& src) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Interval& src) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Manipulation /// Set the interval to be empty. An interval is empty if the /// minimum is greater than the maximum. IMATH_HOSTDEVICE void makeEmpty() IMATH_NOEXCEPT; /// Extend the interval to include the given point. IMATH_HOSTDEVICE void extendBy (const T& point) IMATH_NOEXCEPT; /// Extend the interval to include the given interval IMATH_HOSTDEVICE void extendBy (const Interval& interval) IMATH_NOEXCEPT; /// Make the interval include the entire range of the base type. IMATH_HOSTDEVICE void makeInfinite() IMATH_NOEXCEPT; /// @} /// @{ /// @name Query /// Return the size of the interval. The size is (max-min). An empty box has a size of 0. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T size() const IMATH_NOEXCEPT; /// Return the center of the interval. The center is defined as /// (max+min)/2. The center of an empty interval is undefined. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T center() const IMATH_NOEXCEPT; /// Return true if the given point is inside the interval, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const T& point) const IMATH_NOEXCEPT; /// Return true if the given interval is inside the interval, false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersects (const Interval& interval) const IMATH_NOEXCEPT; /// Return true if the interval is empty, false otherwise. An /// empty interval's minimum is greater than its maximum. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isEmpty() const IMATH_NOEXCEPT; /// Return true if the interval is larger than a single point, /// false otherwise. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool hasVolume() const IMATH_NOEXCEPT; /// Return true if the interval contains all points, false /// otherwise. An infinite box has a mimimum of std::numeric_limits::lowest() /// and a maximum of std::numeric_limits::max() IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool isInfinite() const IMATH_NOEXCEPT; /// @} }; /// Stream output, as "(min max)" template std::ostream& operator<< (std::ostream& s, const Interval& v); /// Interval of type float typedef Interval Intervalf; /// Interval of type double typedef Interval Intervald; /// Interval of type short typedef Interval Intervals; /// Interval of type integer typedef Interval Intervali; template IMATH_HOSTDEVICE inline IMATH_CONSTEXPR14 Interval::Interval() IMATH_NOEXCEPT { makeEmpty(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Interval::Interval (const T& point) IMATH_NOEXCEPT { min = point; max = point; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Interval::Interval (const T& minV, const T& maxV) IMATH_NOEXCEPT { min = minV; max = maxV; } template IMATH_HOSTDEVICE constexpr inline bool Interval::operator== (const Interval& src) const IMATH_NOEXCEPT { return (min == src.min && max == src.max); } template IMATH_HOSTDEVICE constexpr inline bool Interval::operator!= (const Interval& src) const IMATH_NOEXCEPT { return (min != src.min || max != src.max); } template IMATH_HOSTDEVICE inline void Interval::makeEmpty() IMATH_NOEXCEPT { min = std::numeric_limits::max(); max = std::numeric_limits::lowest(); } template IMATH_HOSTDEVICE inline void Interval::makeInfinite() IMATH_NOEXCEPT { min = std::numeric_limits::lowest(); max = std::numeric_limits::max(); } template IMATH_HOSTDEVICE inline void Interval::extendBy (const T& point) IMATH_NOEXCEPT { if (point < min) min = point; if (point > max) max = point; } template IMATH_HOSTDEVICE inline void Interval::extendBy (const Interval& interval) IMATH_NOEXCEPT { if (interval.min < min) min = interval.min; if (interval.max > max) max = interval.max; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Interval::intersects (const T& point) const IMATH_NOEXCEPT { return point >= min && point <= max; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Interval::intersects (const Interval& interval) const IMATH_NOEXCEPT { return interval.max >= min && interval.min <= max; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Interval::size() const IMATH_NOEXCEPT { if (isEmpty()) return T(0); return max - min; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Interval::center() const IMATH_NOEXCEPT { return (max + min) / 2; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Interval::isEmpty() const IMATH_NOEXCEPT { return max < min; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Interval::hasVolume() const IMATH_NOEXCEPT { return max > min; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Interval::isInfinite() const IMATH_NOEXCEPT { if (min != std::numeric_limits::lowest() || max != std::numeric_limits::max()) return false; return true; } /// Stream output template std::ostream& operator<< (std::ostream& s, const Interval& v) { return s << '(' << v.min << ' ' << v.max << ')'; } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHINTERVAL_H Imath-3.1.4/src/Imath/ImathLine.h000066400000000000000000000104451417213455000164430ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A 3D line class template // #ifndef INCLUDED_IMATHLINE_H #define INCLUDED_IMATHLINE_H #include "ImathMatrix.h" #include "ImathNamespace.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// The `Line3` class represents a 3D line, defined by a point and a /// direction vector. /// template class Line3 { public: /// @{ /// @name Direct access to member fields /// A point on the line Vec3 pos; /// The direction of the line Vec3 dir; /// @} /// @{ /// @name Constructors /// Uninitialized by default IMATH_HOSTDEVICE constexpr Line3() IMATH_NOEXCEPT {} /// Initialize with two points. The direction is the difference /// between the points. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Line3 (const Vec3& point1, const Vec3& point2) IMATH_NOEXCEPT; /// @} /// @{ /// @name Manipulation /// Set the line defined by two points. The direction is the difference /// between the points. IMATH_HOSTDEVICE void set (const Vec3& point1, const Vec3& point2) IMATH_NOEXCEPT; /// @} /// @{ /// @name Utility Methods /// Return the point on the line at the given parameter value, /// e.g. L(t) IMATH_HOSTDEVICE constexpr Vec3 operator() (T parameter) const IMATH_NOEXCEPT; /// Return the distance to the given point IMATH_HOSTDEVICE constexpr T distanceTo (const Vec3& point) const IMATH_NOEXCEPT; /// Return the distance to the given line IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T distanceTo (const Line3& line) const IMATH_NOEXCEPT; /// Return the point on the line closest to the given point IMATH_HOSTDEVICE constexpr Vec3 closestPointTo (const Vec3& point) const IMATH_NOEXCEPT; /// Return the point on the line closest to the given line IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 closestPointTo (const Line3& line) const IMATH_NOEXCEPT; /// @} }; /// Line of type float typedef Line3 Line3f; /// Line of type double typedef Line3 Line3d; template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Line3::Line3 (const Vec3& p0, const Vec3& p1) IMATH_NOEXCEPT { set (p0, p1); } template IMATH_HOSTDEVICE inline void Line3::set (const Vec3& p0, const Vec3& p1) IMATH_NOEXCEPT { pos = p0; dir = p1 - p0; dir.normalize(); } template IMATH_HOSTDEVICE constexpr inline Vec3 Line3::operator() (T parameter) const IMATH_NOEXCEPT { return pos + dir * parameter; } template IMATH_HOSTDEVICE constexpr inline T Line3::distanceTo (const Vec3& point) const IMATH_NOEXCEPT { return (closestPointTo (point) - point).length(); } template IMATH_HOSTDEVICE constexpr inline Vec3 Line3::closestPointTo (const Vec3& point) const IMATH_NOEXCEPT { return ((point - pos) ^ dir) * dir + pos; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Line3::distanceTo (const Line3& line) const IMATH_NOEXCEPT { T d = (dir % line.dir) ^ (line.pos - pos); return (d >= 0) ? d : -d; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3 Line3::closestPointTo (const Line3& line) const IMATH_NOEXCEPT { // Assumes the lines are normalized Vec3 posLpos = pos - line.pos; T c = dir ^ posLpos; T a = line.dir ^ dir; T f = line.dir ^ posLpos; T num = c - a * f; T denom = a * a - 1; T absDenom = ((denom >= 0) ? denom : -denom); if (absDenom < 1) { T absNum = ((num >= 0) ? num : -num); if (absNum >= absDenom * std::numeric_limits::max()) return pos; } return pos + dir * (num / denom); } /// Stream output, as "(pos dir)" template std::ostream& operator<< (std::ostream& o, const Line3& line) { return o << "(" << line.pos << ", " << line.dir << ")"; } /// Transform a line by a matrix template IMATH_HOSTDEVICE constexpr inline Line3 operator* (const Line3& line, const Matrix44& M) IMATH_NOEXCEPT { return Line3 (line.pos * M, (line.pos + line.dir) * M); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHLINE_H Imath-3.1.4/src/Imath/ImathLineAlgo.h000066400000000000000000000130351417213455000172440ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Algorithms applied to or in conjunction with Imath::Line class // #ifndef INCLUDED_IMATHLINEALGO_H #define INCLUDED_IMATHLINEALGO_H #include "ImathFun.h" #include "ImathLine.h" #include "ImathNamespace.h" #include "ImathVecAlgo.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// Compute point1 and point2 such that point1 is on line1, point2 /// is on line2 and the distance between point1 and point2 is minimal. /// /// This function returns true if point1 and point2 can be computed, /// or false if line1 and line2 are parallel or nearly parallel. /// This function assumes that line1.dir and line2.dir are normalized. /// template IMATH_CONSTEXPR14 bool closestPoints (const Line3& line1, const Line3& line2, Vec3& point1, Vec3& point2) IMATH_NOEXCEPT { Vec3 w = line1.pos - line2.pos; T d1w = line1.dir ^ w; T d2w = line2.dir ^ w; T d1d2 = line1.dir ^ line2.dir; T n1 = d1d2 * d2w - d1w; T n2 = d2w - d1d2 * d1w; T d = 1 - d1d2 * d1d2; T absD = abs (d); if ((absD > 1) || (abs (n1) < std::numeric_limits::max() * absD && abs (n2) < std::numeric_limits::max() * absD)) { point1 = line1 (n1 / d); point2 = line2 (n2 / d); return true; } else { return false; } } /// /// Given a line and a triangle (v0, v1, v2), the intersect() function /// finds the intersection of the line and the plane that contains the /// triangle. /// /// If the intersection point cannot be computed, either because the /// line and the triangle's plane are nearly parallel or because the /// triangle's area is very small, intersect() returns false. /// /// If the intersection point is outside the triangle, intersect /// returns false. /// /// If the intersection point, pt, is inside the triangle, intersect() /// computes a front-facing flag and the barycentric coordinates of /// the intersection point, and returns true. /// /// The front-facing flag is true if the dot product of the triangle's /// normal, (v2-v1)%(v1-v0), and the line's direction is negative. /// /// The barycentric coordinates have the following property: /// /// pt = v0 * barycentric.x + v1 * barycentric.y + v2 * barycentric.z /// template IMATH_CONSTEXPR14 bool intersect (const Line3& line, const Vec3& v0, const Vec3& v1, const Vec3& v2, Vec3& pt, Vec3& barycentric, bool& front) IMATH_NOEXCEPT { Vec3 edge0 = v1 - v0; Vec3 edge1 = v2 - v1; Vec3 normal = edge1 % edge0; T l = normal.length(); if (l != 0) normal /= l; else return false; // zero-area triangle // // d is the distance of line.pos from the plane that contains the triangle. // The intersection point is at line.pos + (d/nd) * line.dir. // T d = normal ^ (v0 - line.pos); T nd = normal ^ line.dir; if (abs (nd) > 1 || abs (d) < std::numeric_limits::max() * abs (nd)) pt = line (d / nd); else return false; // line and plane are nearly parallel // // Compute the barycentric coordinates of the intersection point. // The intersection is inside the triangle if all three barycentric // coordinates are between zero and one. // { Vec3 en = edge0.normalized(); Vec3 a = pt - v0; Vec3 b = v2 - v0; Vec3 c = (a - en * (en ^ a)); Vec3 d = (b - en * (en ^ b)); T e = c ^ d; T f = d ^ d; if (e >= 0 && e <= f) barycentric.z = e / f; else return false; // outside } { Vec3 en = edge1.normalized(); Vec3 a = pt - v1; Vec3 b = v0 - v1; Vec3 c = (a - en * (en ^ a)); Vec3 d = (b - en * (en ^ b)); T e = c ^ d; T f = d ^ d; if (e >= 0 && e <= f) barycentric.x = e / f; else return false; // outside } barycentric.y = 1 - barycentric.x - barycentric.z; if (barycentric.y < 0) return false; // outside front = ((line.dir ^ normal) < 0); return true; } /// /// Return the vertex that is closest to the given line. The returned /// point is either v0, v1, or v2. /// template IMATH_CONSTEXPR14 Vec3 closestVertex (const Vec3& v0, const Vec3& v1, const Vec3& v2, const Line3& l) IMATH_NOEXCEPT { Vec3 nearest = v0; T neardot = (v0 - l.closestPointTo (v0)).length2(); T tmp = (v1 - l.closestPointTo (v1)).length2(); if (tmp < neardot) { neardot = tmp; nearest = v1; } tmp = (v2 - l.closestPointTo (v2)).length2(); if (tmp < neardot) { neardot = tmp; nearest = v2; } return nearest; } /// /// Rotate the point p around the line l by the given angle. /// template IMATH_CONSTEXPR14 Vec3 rotatePoint (const Vec3 p, Line3 l, T angle) IMATH_NOEXCEPT { // // Form a coordinate frame with . The rotation is the in xy // plane. // Vec3 q = l.closestPointTo (p); Vec3 x = p - q; T radius = x.length(); x.normalize(); Vec3 y = (x % l.dir).normalize(); T cosangle = std::cos (angle); T sinangle = std::sin (angle); Vec3 r = q + x * radius * cosangle + y * radius * sinangle; return r; } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHLINEALGO_H Imath-3.1.4/src/Imath/ImathMath.h000066400000000000000000000114111417213455000164370ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Obsolete functions provided for compatibility, deprecated in favor // of std:: functions. // #ifndef INCLUDED_IMATHMATH_H #define INCLUDED_IMATHMATH_H #include "ImathNamespace.h" #include "ImathPlatform.h" #include #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER //---------------------------------------------------------------------------- // // The deprecated Math methods were intended to allow templated access to // math functions so that they would automatically choose either the double // (e.g. sin()) or float (e.g., sinf()) version. // // Beginning wth C++11, this is unnecessary, as std:: versions of all these // functions are available and are templated by type. // // We keep these old definitions for backward compatibility but encourage // users to prefer the std:: versions. Some day we may remove these // deprecated versions. // //---------------------------------------------------------------------------- /// @cond Doxygen_Suppress template struct Math { IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T acos (T x) { return std::acos (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T asin (T x) { return std::asin (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T atan (T x) { return std::atan (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T atan2 (T x, T y) { return std::atan2 (x, y); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T cos (T x) { return std::cos (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T sin (T x) { return std::sin (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T tan (T x) { return std::tan (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T cosh (T x) { return std::cosh (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T sinh (T x) { return std::sinh (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T tanh (T x) { return std::tanh (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T exp (T x) { return std::exp (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T log (T x) { return std::log (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T log10 (T x) { return std::log10 (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T modf (T x, T* iptr) { T ival; T rval (std::modf (T (x), &ival)); *iptr = ival; return rval; } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T pow (T x, T y) { return std::pow (x, y); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T sqrt (T x) { return std::sqrt (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T ceil (T x) { return std::ceil (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T fabs (T x) { return std::fabs (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T floor (T x) { return std::floor (x); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T fmod (T x, T y) { return std::fmod (x, y); } IMATH_DEPRECATED("use std::math functions") IMATH_HOSTDEVICE static T hypot (T x, T y) { return std::hypot (x, y); } }; /// @endcond /// Don Hatch's version of sin(x)/x, which is accurate for very small x. /// Returns 1 for x == 0. template IMATH_HOSTDEVICE inline T sinx_over_x (T x) { if (x * x < std::numeric_limits::epsilon()) return T (1); else return std::sin (x) / x; } /// Compare two numbers and test if they are "approximately equal": /// /// @return Ttrue if x1 is the same as x2 with an absolute error of /// no more than e: /// /// abs (x1 - x2) <= e template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool equalWithAbsError (T x1, T x2, T e) IMATH_NOEXCEPT { return ((x1 > x2) ? x1 - x2 : x2 - x1) <= e; } /// Compare two numbers and test if they are "approximately equal": /// /// @return True if x1 is the same as x2 with an relative error of /// no more than e, /// /// abs (x1 - x2) <= e * x1 template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool equalWithRelError (T x1, T x2, T e) IMATH_NOEXCEPT { return ((x1 > x2) ? x1 - x2 : x2 - x1) <= e * ((x1 > 0) ? x1 : -x1); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHMATH_H Imath-3.1.4/src/Imath/ImathMatrix.h000066400000000000000000004061501417213455000170220ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // 2x2, 3x3, and 4x4 transformation matrix templates // #ifndef INCLUDED_IMATHMATRIX_H #define INCLUDED_IMATHMATRIX_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathFun.h" #include "ImathPlatform.h" #include "ImathShear.h" #include "ImathVec.h" #include #include #include #include #include #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER // suppress exception specification warnings # pragma warning(disable : 4290) #endif IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// Enum used to indicate uninitialized construction of Matrix22, /// Matrix33, Matrix44 enum IMATH_EXPORT_ENUM Uninitialized { UNINITIALIZED }; /// /// 2x2 transformation matrix /// template class IMATH_EXPORT_TEMPLATE_TYPE Matrix22 { public: /// @{ /// @name Direct access to elements /// Matrix elements T x[2][2]; /// @} /// Row access IMATH_HOSTDEVICE T* operator[] (int i) IMATH_NOEXCEPT; /// Row access IMATH_HOSTDEVICE const T* operator[] (int i) const IMATH_NOEXCEPT; /// @{ /// @name Constructors and Assignment /// Uninitialized IMATH_HOSTDEVICE Matrix22 (Uninitialized) IMATH_NOEXCEPT {} /// Default constructor: initialize to identity /// /// 1 0 /// 0 1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22() IMATH_NOEXCEPT; /// Initialize to scalar constant: /// /// a a /// a a IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 (T a) IMATH_NOEXCEPT; /// Construct from 2x2 array: /// /// a[0][0] a[0][1] /// a[1][0] a[1][1] IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 (const T a[2][2]) IMATH_NOEXCEPT; /// Construct from given scalar values: /// /// a b /// c d IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 (T a, T b, T c, T d) IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 (const Matrix22& v) IMATH_NOEXCEPT; /// Construct from Matrix22 of another base type template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 explicit Matrix22 (const Matrix22& v) IMATH_NOEXCEPT; /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator= (const Matrix22& v) IMATH_NOEXCEPT; /// Assignment from scalar IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator= (T a) IMATH_NOEXCEPT; /// Destructor ~Matrix22() IMATH_NOEXCEPT = default; /// @} #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Interoperability with other matrix types /// /// Construction and assignment are allowed from other classes that /// appear to be equivalent matrix types, provided that they support /// double-subscript (i.e., `m[j][i]`) giving the same type as the /// elements of this matrix, and their total size appears to be the /// right number of matrix elements. /// /// This functionality is disabled for gcc 4.x, which seems to have a /// compiler bug that results in spurious errors. It can also be /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to /// including any Imath header files. /// template::value)> IMATH_HOSTDEVICE explicit Matrix22 (const M& m) : Matrix22(T(m[0][0]), T(m[0][1]), T(m[1][0]), T(m[1][1])) { } template::value)> IMATH_HOSTDEVICE const Matrix22& operator= (const M& m) { *this = Matrix22(T(m[0][0]), T(m[0][1]), T(m[1][0]), T(m[1][1])); return *this; } /// @} #endif /// @{ /// @name Compatibility with Sb /// Return a raw pointer to the array of values IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT; /// Return the value in `v` template IMATH_HOSTDEVICE void getValue (Matrix22& v) const IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22& setValue (const Matrix22& v) IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22& setTheMatrix (const Matrix22& v) IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Matrix22& v) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Matrix22& v) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and `m` are the same /// with an absolute error of no more than e, i.e., for all i, j: /// /// abs (this[i][j] - m[i][j]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Matrix22& v, T e) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and m are the same with /// a relative error of no more than e, i.e., for all i, j: /// /// abs (this[i] - v[i][j]) <= e * abs (this[i][j]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Matrix22& v, T e) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator+= (const Matrix22& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator+= (T a) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Matrix22 operator+ (const Matrix22& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator-= (const Matrix22& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator-= (T a) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Matrix22 operator- (const Matrix22& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Matrix22 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Matrix22 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Matrix22 operator/ (T a) const IMATH_NOEXCEPT; /// Matrix-matrix multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& operator*= (const Matrix22& v) IMATH_NOEXCEPT; /// Matrix-matrix multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 operator* (const Matrix22& v) const IMATH_NOEXCEPT; /// Vector * matrix multiplication /// @param[in] src Input vector /// @param[out] dst transformed vector template IMATH_HOSTDEVICE void multDirMatrix (const Vec2& src, Vec2& dst) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Maniplation /// Set to the identity IMATH_HOSTDEVICE void makeIdentity() IMATH_NOEXCEPT; /// Transpose IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& transpose() IMATH_NOEXCEPT; /// Return the transpose IMATH_HOSTDEVICE constexpr Matrix22 transposed() const IMATH_NOEXCEPT; /// Invert in place /// @param singExc If true, throw an exception if the matrix cannot be inverted. /// @return const reference to this IMATH_CONSTEXPR14 const Matrix22& invert (bool singExc); /// Invert in place /// @return const reference to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& invert() IMATH_NOEXCEPT; /// Return the inverse, leaving this unmodified. /// @param singExc If true, throw an exception if the matrix cannot be inverted. IMATH_CONSTEXPR14 Matrix22 inverse (bool singExc) const; /// Return the inverse, leaving this unmodified. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix22 inverse() const IMATH_NOEXCEPT; /// Determinant IMATH_HOSTDEVICE constexpr T determinant() const IMATH_NOEXCEPT; /// Set matrix to rotation by r (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE const Matrix22& setRotation (S r) IMATH_NOEXCEPT; /// Rotate the given matrix by r (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& rotate (S r) IMATH_NOEXCEPT; /// Set matrix to scale by given uniform factor /// @return const referenced to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& setScale (T s) IMATH_NOEXCEPT; /// Set matrix to scale by given vector /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& setScale (const Vec2& s) IMATH_NOEXCEPT; // Scale the matrix by s /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix22& scale (const Vec2& s) IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of the row and column dimensions, i.e. 2. IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 2; } /// The base type: In templates that accept a parameter `V`, you /// can refer to `T` as `V::BaseType` typedef T BaseType; /// The base vector type typedef Vec2 BaseVecType; }; /// /// 3x3 transformation matrix /// template class IMATH_EXPORT_TEMPLATE_TYPE Matrix33 { public: /// @{ /// @name Direct access to elements /// Matrix elements T x[3][3]; /// @} /// Row access IMATH_HOSTDEVICE T* operator[] (int i) IMATH_NOEXCEPT; /// Row access IMATH_HOSTDEVICE const T* operator[] (int i) const IMATH_NOEXCEPT; /// @{ /// @name Constructors and Assignment /// Uninitialized IMATH_HOSTDEVICE Matrix33 (Uninitialized) IMATH_NOEXCEPT {} /// Default constructor: initialize to identity /// 1 0 0 /// 0 1 0 /// 0 0 1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33() IMATH_NOEXCEPT; /// Initialize to scalar constant /// a a a /// a a a /// a a a IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 (T a) IMATH_NOEXCEPT; /// Construct from 3x3 array /// a[0][0] a[0][1] a[0][2] /// a[1][0] a[1][1] a[1][2] /// a[2][0] a[2][1] a[2][2] IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 (const T a[3][3]) IMATH_NOEXCEPT; /// Construct from given scalar values /// a b c /// d e f /// g h i IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 (T a, T b, T c, T d, T e, T f, T g, T h, T i) IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 (const Matrix33& v) IMATH_NOEXCEPT; /// Construct from Matrix33 of another base type template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 explicit Matrix33 (const Matrix33& v) IMATH_NOEXCEPT; /// Assignment operator IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator= (const Matrix33& v) IMATH_NOEXCEPT; /// Assignment from scalar IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator= (T a) IMATH_NOEXCEPT; /// Destructor ~Matrix33() IMATH_NOEXCEPT = default; /// @} #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Interoperability with other matrix types /// /// Construction and assignment are allowed from other classes that /// appear to be equivalent matrix types, provided that they support /// double-subscript (i.e., `m[j][i]`) giving the same type as the /// elements of this matrix, and their total size appears to be the /// right number of matrix elements. /// /// This functionality is disabled for gcc 4.x, which seems to have a /// compiler bug that results in spurious errors. It can also be /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to /// including any Imath header files. /// template::value)> IMATH_HOSTDEVICE explicit Matrix33 (const M& m) : Matrix33(T(m[0][0]), T(m[0][1]), T(m[0][2]), T(m[1][0]), T(m[1][1]), T(m[1][2]), T(m[2][0]), T(m[2][1]), T(m[2][2])) { } /// Interoperability assignment from another type that behaves as if it /// were an equivalent matrix. template::value)> IMATH_HOSTDEVICE const Matrix33& operator= (const M& m) { *this = Matrix33(T(m[0][0]), T(m[0][1]), T(m[0][2]), T(m[1][0]), T(m[1][1]), T(m[1][2]), T(m[2][0]), T(m[2][1]), T(m[2][2])); return *this; } /// @} #endif /// @{ /// @name Compatibility with Sb /// Return a raw pointer to the array of values IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT; /// Return the value in `v` template IMATH_HOSTDEVICE void getValue (Matrix33& v) const IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33& setValue (const Matrix33& v) IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33& setTheMatrix (const Matrix33& v) IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Matrix33& v) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Matrix33& v) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and `m` are the same /// with an absolute error of no more than e, i.e., for all i, j: /// /// abs (this[i][j] - m[i][j]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Matrix33& v, T e) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and m are the same with /// a relative error of no more than e, i.e., for all i, j: /// /// abs (this[i] - v[i][j]) <= e * abs (this[i][j]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Matrix33& v, T e) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator+= (const Matrix33& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator+= (T a) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Matrix33 operator+ (const Matrix33& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator-= (const Matrix33& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator-= (T a) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Matrix33 operator- (const Matrix33& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Matrix33 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Matrix33 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Matrix33 operator/ (T a) const IMATH_NOEXCEPT; /// Matrix-matrix multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& operator*= (const Matrix33& v) IMATH_NOEXCEPT; /// Matrix-matrix multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 operator* (const Matrix33& v) const IMATH_NOEXCEPT; /// Vector-matrix multiplication: a homogeneous transformation /// by computing Vec3 (src.x, src.y, 1) * m and dividing by the /// result's third element. /// @param[in] src The input vector /// @param[out] dst The output vector template IMATH_HOSTDEVICE void multVecMatrix (const Vec2& src, Vec2& dst) const IMATH_NOEXCEPT; /// Vector-matrix multiplication: multiply `src` by the upper left 2x2 /// submatrix, ignoring the rest of matrix. /// @param[in] src The input vector /// @param[out] dst The output vector template IMATH_HOSTDEVICE void multDirMatrix (const Vec2& src, Vec2& dst) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Maniplation /// Set to the identity matrix IMATH_HOSTDEVICE void makeIdentity() IMATH_NOEXCEPT; /// Transpose IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& transpose() IMATH_NOEXCEPT; /// Return the transpose IMATH_HOSTDEVICE constexpr Matrix33 transposed() const IMATH_NOEXCEPT; /// Invert in place using the determinant. /// @param singExc If true, throw an exception if the matrix cannot be inverted. /// @return const reference to this IMATH_CONSTEXPR14 const Matrix33& invert (bool singExc); /// Invert in place using the determinant. /// @return const reference to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& invert() IMATH_NOEXCEPT; /// Return the inverse using the determinant, leaving this unmodified. /// @param singExc If true, throw an exception if the matrix cannot be inverted. IMATH_CONSTEXPR14 Matrix33 inverse (bool singExc) const; /// Return the inverse using the determinant, leaving this unmodified. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix33 inverse() const IMATH_NOEXCEPT; /// Invert in place using the Gauss-Jordan method. Significantly slower /// but more accurate than invert(). /// @param singExc If true, throw an exception if the matrix cannot be inverted. /// @return const reference to this const Matrix33& gjInvert (bool singExc); /// Invert in place using the Gauss-Jordan method. Significantly slower /// but more accurate than invert(). /// @return const reference to this IMATH_HOSTDEVICE const Matrix33& gjInvert() IMATH_NOEXCEPT; /// Return the inverse using the Gauss-Jordan method, leaving this /// unmodified. Significantly slower but more accurate than inverse(). Matrix33 gjInverse (bool singExc) const; /// Return the inverse using the Gauss-Jordan method. Significantly slower, /// leaving this unmodified. Slower but more accurate than inverse(). IMATH_HOSTDEVICE Matrix33 gjInverse() const IMATH_NOEXCEPT; /// Calculate the matrix minor of the (r,c) element IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T minorOf (const int r, const int c) const IMATH_NOEXCEPT; /// Build a minor using the specified rows and columns IMATH_HOSTDEVICE constexpr T fastMinor (const int r0, const int r1, const int c0, const int c1) const IMATH_NOEXCEPT; /// Determinant IMATH_HOSTDEVICE constexpr T determinant() const IMATH_NOEXCEPT; /// Set matrix to rotation by r (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE const Matrix33& setRotation (S r) IMATH_NOEXCEPT; // Rotate the given matrix by r (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& rotate (S r) IMATH_NOEXCEPT; /// Set matrix to scale by given uniform factor /// @return const referenced to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& setScale (T s) IMATH_NOEXCEPT; /// Set matrix to scale by given vector /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& setScale (const Vec2& s) IMATH_NOEXCEPT; /// Scale the matrix by s /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& scale (const Vec2& s) IMATH_NOEXCEPT; /// Set matrix to translation by given vector /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& setTranslation (const Vec2& t) IMATH_NOEXCEPT; /// Return the translation component IMATH_HOSTDEVICE constexpr Vec2 translation() const IMATH_NOEXCEPT; /// Translate the matrix by t /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& translate (const Vec2& t) IMATH_NOEXCEPT; /// Set matrix to shear x for each y coord. by given factor xy /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& setShear (const S& h) IMATH_NOEXCEPT; /// Set matrix to shear x for each y coord. by given factor h.x /// and to shear y for each x coord. by given factor h.y /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& setShear (const Vec2& h) IMATH_NOEXCEPT; /// Shear the matrix in x for each y coord. by given factor xy /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& shear (const S& xy) IMATH_NOEXCEPT; /// Shear the matrix in x for each y coord. by given factor xy /// and shear y for each x coord. by given factor yx /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix33& shear (const Vec2& h) IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of the row and column dimensions, i.e. 3. IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 3; } /// The base type: In templates that accept a parameter `V` (could be a Color4), you can refer to `T` as `V::BaseType` typedef T BaseType; /// The base vector type typedef Vec3 BaseVecType; }; /// /// 4x4 transformation matrix /// template class IMATH_EXPORT_TEMPLATE_TYPE Matrix44 { public: /// @{ /// @name Direct access to elements /// Matrix elements T x[4][4]; /// @} /// Row access IMATH_HOSTDEVICE T* operator[] (int i) IMATH_NOEXCEPT; /// Row access IMATH_HOSTDEVICE const T* operator[] (int i) const IMATH_NOEXCEPT; /// @{ /// @name Constructors and Assignment /// Uninitialized IMATH_HOSTDEVICE constexpr Matrix44 (Uninitialized) IMATH_NOEXCEPT {} /// Default constructor: initialize to identity /// 1 0 0 0 /// 0 1 0 0 /// 0 0 1 0 /// 0 0 0 1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44() IMATH_NOEXCEPT; /// Initialize to scalar constant /// a a a a /// a a a a /// a a a a /// a a a a IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 (T a) IMATH_NOEXCEPT; /// Construct from 4x4 array /// a[0][0] a[0][1] a[0][2] a[0][3] /// a[1][0] a[1][1] a[1][2] a[1][3] /// a[2][0] a[2][1] a[2][2] a[2][3] /// a[3][0] a[3][1] a[3][2] a[3][3] IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 (const T a[4][4]) IMATH_NOEXCEPT; /// Construct from given scalar values /// a b c d /// e f g h /// i j k l /// m n o p IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 (T a, T b, T c, T d, T e, T f, T g, T h, T i, T j, T k, T l, T m, T n, T o, T p) IMATH_NOEXCEPT; /// Construct from a 3x3 rotation matrix and a translation vector /// r r r 0 /// r r r 0 /// r r r 0 /// t t t 1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 (Matrix33 r, Vec3 t) IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 (const Matrix44& v) IMATH_NOEXCEPT; /// Construct from Matrix44 of another base type template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 explicit Matrix44 (const Matrix44& v) IMATH_NOEXCEPT; /// Assignment operator IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator= (const Matrix44& v) IMATH_NOEXCEPT; /// Assignment from scalar IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator= (T a) IMATH_NOEXCEPT; /// Destructor ~Matrix44() IMATH_NOEXCEPT = default; /// @} #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Interoperability with other matrix types /// /// Construction and assignment are allowed from other classes that /// appear to be equivalent matrix types, provided that they support /// double-subscript (i.e., `m[j][i]`) giving the same type as the /// elements of this matrix, and their total size appears to be the /// right number of matrix elements. /// /// This functionality is disabled for gcc 4.x, which seems to have a /// compiler bug that results in spurious errors. It can also be /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to /// including any Imath header files. /// template::value)> IMATH_HOSTDEVICE explicit Matrix44 (const M& m) : Matrix44(T(m[0][0]), T(m[0][1]), T(m[0][2]), T(m[0][3]), T(m[1][0]), T(m[1][1]), T(m[1][2]), T(m[1][3]), T(m[2][0]), T(m[2][1]), T(m[2][2]), T(m[2][3]), T(m[3][0]), T(m[3][1]), T(m[3][2]), T(m[3][3])) { } /// Interoperability assignment from another type that behaves as if it /// were an equivalent matrix. template::value)> IMATH_HOSTDEVICE const Matrix44& operator= (const M& m) { *this = Matrix44(T(m[0][0]), T(m[0][1]), T(m[0][2]), T(m[0][3]), T(m[1][0]), T(m[1][1]), T(m[1][2]), T(m[1][3]), T(m[2][0]), T(m[2][1]), T(m[2][2]), T(m[2][3]), T(m[3][0]), T(m[3][1]), T(m[3][2]), T(m[3][3])); return *this; } /// @} #endif /// @{ /// @name Compatibility with Sb /// Return a raw pointer to the array of values IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT; /// Return the value in `v` template IMATH_HOSTDEVICE void getValue (Matrix44& v) const IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44& setValue (const Matrix44& v) IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44& setTheMatrix (const Matrix44& v) IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality IMATH_HOSTDEVICE constexpr bool operator== (const Matrix44& v) const IMATH_NOEXCEPT; /// Inequality IMATH_HOSTDEVICE constexpr bool operator!= (const Matrix44& v) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and `m` are the same /// with an absolute error of no more than e, i.e., for all i, j: /// /// abs (this[i][j] - m[i][j]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Matrix44& v, T e) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and m are the same with /// a relative error of no more than e, i.e., for all i, j: /// /// abs (this[i] - v[i][j]) <= e * abs (this[i][j]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Matrix44& v, T e) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator+= (const Matrix44& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator+= (T a) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Matrix44 operator+ (const Matrix44& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator-= (const Matrix44& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator-= (T a) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Matrix44 operator- (const Matrix44& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Matrix44 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Matrix44 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Matrix44 operator/ (T a) const IMATH_NOEXCEPT; /// Matrix-matrix multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& operator*= (const Matrix44& v) IMATH_NOEXCEPT; /// Matrix-matrix multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 operator* (const Matrix44& v) const IMATH_NOEXCEPT; /// Matrix-matrix multiplication: compute c = a * b IMATH_HOSTDEVICE static void multiply (const Matrix44& a, // assumes that const Matrix44& b, // &a != &c and Matrix44& c) IMATH_NOEXCEPT; // &b != &c. /// Matrix-matrix multiplication returning a result. IMATH_HOSTDEVICE static IMATH_CONSTEXPR14 Matrix44 multiply (const Matrix44& a, const Matrix44& b) IMATH_NOEXCEPT; /// Vector-matrix multiplication: a homogeneous transformation /// by computing Vec3 (src.x, src.y, src.z, 1) * m and dividing by the /// result's third element. /// @param[in] src The input vector /// @param[out] dst The output vector template IMATH_HOSTDEVICE void multVecMatrix (const Vec3& src, Vec3& dst) const IMATH_NOEXCEPT; /// Vector-matrix multiplication: multiply `src` by the upper left 2x2 /// submatrix, ignoring the rest of matrix. /// @param[in] src The input vector /// @param[out] dst The output vector template IMATH_HOSTDEVICE void multDirMatrix (const Vec3& src, Vec3& dst) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Maniplation /// Set to the identity matrix IMATH_HOSTDEVICE void makeIdentity() IMATH_NOEXCEPT; /// Transpose IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& transpose() IMATH_NOEXCEPT; /// Return the transpose IMATH_HOSTDEVICE constexpr Matrix44 transposed() const IMATH_NOEXCEPT; /// Invert in place using the determinant. /// @param singExc If true, throw an exception if the matrix cannot be inverted. /// @return const reference to this IMATH_CONSTEXPR14 const Matrix44& invert (bool singExc); /// Invert in place using the determinant. /// @return const reference to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& invert() IMATH_NOEXCEPT; /// Return the inverse using the determinant, leaving this unmodified. /// @param singExc If true, throw an exception if the matrix cannot be inverted. IMATH_CONSTEXPR14 Matrix44 inverse (bool singExc) const; /// Return the inverse using the determinant, leaving this unmodified. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Matrix44 inverse() const IMATH_NOEXCEPT; /// Invert in place using the Gauss-Jordan method. Significantly slower /// but more accurate than invert(). /// @param singExc If true, throw an exception if the matrix cannot be inverted. /// @return const reference to this IMATH_CONSTEXPR14 const Matrix44& gjInvert (bool singExc); /// Invert in place using the Gauss-Jordan method. Significantly slower /// but more accurate than invert(). /// @return const reference to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& gjInvert() IMATH_NOEXCEPT; /// Return the inverse using the Gauss-Jordan method, leaving this /// unmodified. Significantly slower but more accurate than inverse(). Matrix44 gjInverse (bool singExc) const; /// Return the inverse using the Gauss-Jordan method, leaving this /// unmodified Significantly slower but more accurate than inverse(). IMATH_HOSTDEVICE Matrix44 gjInverse() const IMATH_NOEXCEPT; /// Calculate the matrix minor of the (r,c) element IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T minorOf (const int r, const int c) const IMATH_NOEXCEPT; /// Build a minor using the specified rows and columns IMATH_HOSTDEVICE constexpr T fastMinor (const int r0, const int r1, const int r2, const int c0, const int c1, const int c2) const IMATH_NOEXCEPT; /// Determinant IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T determinant() const IMATH_NOEXCEPT; /// Set matrix to rotation by XYZ euler angles (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE const Matrix44& setEulerAngles (const Vec3& r) IMATH_NOEXCEPT; /// Set matrix to rotation around given axis by given angle (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& setAxisAngle (const Vec3& ax, S ang) IMATH_NOEXCEPT; /// Rotate the matrix by XYZ euler angles in r (in radians) /// @return const referenced to this template IMATH_HOSTDEVICE const Matrix44& rotate (const Vec3& r) IMATH_NOEXCEPT; /// Set matrix to scale by given uniform factor /// @return const referenced to this IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& setScale (T s) IMATH_NOEXCEPT; /// Set matrix to scale by given vector /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& setScale (const Vec3& s) IMATH_NOEXCEPT; /// Scale the matrix by s /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& scale (const Vec3& s) IMATH_NOEXCEPT; /// Set matrix to translation by given vector /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& setTranslation (const Vec3& t) IMATH_NOEXCEPT; /// Return translation component IMATH_HOSTDEVICE constexpr const Vec3 translation() const IMATH_NOEXCEPT; /// Translate the matrix by t /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& translate (const Vec3& t) IMATH_NOEXCEPT; /// Set matrix to shear by given vector h. The resulting matrix /// - will shear x for each y coord. by a factor of h[0] ; /// - will shear x for each z coord. by a factor of h[1] ; /// - will shear y for each z coord. by a factor of h[2] . /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& setShear (const Vec3& h) IMATH_NOEXCEPT; /// Set matrix to shear by given factors. The resulting matrix /// - will shear x for each y coord. by a factor of h.xy ; /// - will shear x for each z coord. by a factor of h.xz ; /// - will shear y for each z coord. by a factor of h.yz ; /// - will shear y for each x coord. by a factor of h.yx ; /// - will shear z for each x coord. by a factor of h.zx ; /// - will shear z for each y coord. by a factor of h.zy . /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& setShear (const Shear6& h) IMATH_NOEXCEPT; /// Shear the matrix by given vector. The composed matrix /// will be `shear` * `this`, where the shear matrix ... /// - will shear x for each y coord. by a factor of h[0] ; /// - will shear x for each z coord. by a factor of h[1] ; /// - will shear y for each z coord. by a factor of h[2] . /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& shear (const Vec3& h) IMATH_NOEXCEPT; /// Shear the matrix by the given factors. The composed matrix /// will be `shear` * `this`, where the shear matrix ... /// - will shear x for each y coord. by a factor of h.xy ; /// - will shear x for each z coord. by a factor of h.xz ; /// - will shear y for each z coord. by a factor of h.yz ; /// - will shear y for each x coord. by a factor of h.yx ; /// - will shear z for each x coord. by a factor of h.zx ; /// - will shear z for each y coord. by a factor of h.zy . /// @return const referenced to this template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Matrix44& shear (const Shear6& h) IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of the row and column dimensions, i.e. 4 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 4; } /// The base type: In templates that accept a parameter `V` (could be a Color4), you can refer to `T` as `V::BaseType` typedef T BaseType; /// The base vector type typedef Vec4 BaseVecType; }; /// Stream output, as: /// (m00 m01 /// m10 m11) template std::ostream& operator<< (std::ostream& s, const Matrix22& m); /// Stream output, as: /// (m00 m01 m02 /// m10 m11 m12 /// m20 m21 m22) template std::ostream& operator<< (std::ostream& s, const Matrix33& m); /// Stream output, as: /// /// (m00 m01 m02 m03 /// m10 m11 m12 m13 /// m20 m21 m22 m23 /// m30 m31 m32 m33) template std::ostream& operator<< (std::ostream& s, const Matrix44& m); //--------------------------------------------- // Vector-times-matrix multiplication operators //--------------------------------------------- /// Vector-matrix multiplication: v *= m template IMATH_HOSTDEVICE inline const Vec2& operator*= (Vec2& v, const Matrix22& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: r = v * m template IMATH_HOSTDEVICE inline Vec2 operator* (const Vec2& v, const Matrix22& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: v *= m template IMATH_HOSTDEVICE inline const Vec2& operator*= (Vec2& v, const Matrix33& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: r = v * m template IMATH_HOSTDEVICE inline Vec2 operator* (const Vec2& v, const Matrix33& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: v *= m template IMATH_HOSTDEVICE inline const Vec3& operator*= (Vec3& v, const Matrix33& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: r = v * m template IMATH_HOSTDEVICE inline Vec3 operator* (const Vec3& v, const Matrix33& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: v *= m template IMATH_HOSTDEVICE inline const Vec3& operator*= (Vec3& v, const Matrix44& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: r = v * m template IMATH_HOSTDEVICE inline Vec3 operator* (const Vec3& v, const Matrix44& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: v *= m template IMATH_HOSTDEVICE inline const Vec4& operator*= (Vec4& v, const Matrix44& m) IMATH_NOEXCEPT; /// Vector-matrix multiplication: r = v * m template IMATH_HOSTDEVICE inline Vec4 operator* (const Vec4& v, const Matrix44& m) IMATH_NOEXCEPT; //------------------------- // Typedefs for convenience //------------------------- /// 2x2 matrix of float typedef Matrix22 M22f; /// 2x2 matrix of double typedef Matrix22 M22d; /// 3x3 matrix of float typedef Matrix33 M33f; /// 3x3 matrix of double typedef Matrix33 M33d; /// 4x4 matrix of float typedef Matrix44 M44f; /// 4x4 matrix of double typedef Matrix44 M44d; //--------------------------- // Implementation of Matrix22 //--------------------------- template IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T* Matrix22::operator[] (int i) IMATH_NOEXCEPT { return x[i]; } template IMATH_HOSTDEVICE inline const T* Matrix22::operator[] (int i) const IMATH_NOEXCEPT { return x[i]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22::Matrix22() IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[1][0] = 0; x[1][1] = 1; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22::Matrix22 (T a) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = a; x[1][0] = a; x[1][1] = a; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22::Matrix22 (const T a[2][2]) IMATH_NOEXCEPT { // Function calls and aliasing issues can inhibit vectorization versus // straight assignment of data members, so instead of this: // memcpy (x, a, sizeof (x)); // we do this: x[0][0] = a[0][0]; x[0][1] = a[0][1]; x[1][0] = a[1][0]; x[1][1] = a[1][1]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22::Matrix22 (T a, T b, T c, T d) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = b; x[1][0] = c; x[1][1] = d; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22::Matrix22 (const Matrix22& v) IMATH_NOEXCEPT { // Function calls and aliasing issues can inhibit vectorization versus // straight assignment of data members, so we don't do this: // memcpy (x, v.x, sizeof (x)); // we do this: x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22::Matrix22 (const Matrix22& v) IMATH_NOEXCEPT { x[0][0] = T (v.x[0][0]); x[0][1] = T (v.x[0][1]); x[1][0] = T (v.x[1][0]); x[1][1] = T (v.x[1][1]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator= (const Matrix22& v) IMATH_NOEXCEPT { // Function calls and aliasing issues can inhibit vectorization versus // straight assignment of data members, so we don't do this: // memcpy (x, v.x, sizeof (x)); // we do this: x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator= (T a) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = a; x[1][0] = a; x[1][1] = a; return *this; } template IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T* Matrix22::getValue() IMATH_NOEXCEPT { return (T*) &x[0][0]; } template IMATH_HOSTDEVICE inline const T* Matrix22::getValue() const IMATH_NOEXCEPT { return (const T*) &x[0][0]; } template template IMATH_HOSTDEVICE inline void Matrix22::getValue (Matrix22& v) const IMATH_NOEXCEPT { v.x[0][0] = x[0][0]; v.x[0][1] = x[0][1]; v.x[1][0] = x[1][0]; v.x[1][1] = x[1][1]; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22& Matrix22::setValue (const Matrix22& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22& Matrix22::setTheMatrix (const Matrix22& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; return *this; } template IMATH_HOSTDEVICE inline void Matrix22::makeIdentity() IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[1][0] = 0; x[1][1] = 1; } template IMATH_HOSTDEVICE constexpr inline bool Matrix22::operator== (const Matrix22& v) const IMATH_NOEXCEPT { return x[0][0] == v.x[0][0] && x[0][1] == v.x[0][1] && x[1][0] == v.x[1][0] && x[1][1] == v.x[1][1]; } template IMATH_HOSTDEVICE constexpr inline bool Matrix22::operator!= (const Matrix22& v) const IMATH_NOEXCEPT { return x[0][0] != v.x[0][0] || x[0][1] != v.x[0][1] || x[1][0] != v.x[1][0] || x[1][1] != v.x[1][1]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Matrix22::equalWithAbsError (const Matrix22& m, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this).x[i][j], m.x[i][j], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Matrix22::equalWithRelError (const Matrix22& m, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this).x[i][j], m.x[i][j], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator+= (const Matrix22& v) IMATH_NOEXCEPT { x[0][0] += v.x[0][0]; x[0][1] += v.x[0][1]; x[1][0] += v.x[1][0]; x[1][1] += v.x[1][1]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator+= (T a) IMATH_NOEXCEPT { x[0][0] += a; x[0][1] += a; x[1][0] += a; x[1][1] += a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix22 Matrix22::operator+ (const Matrix22& v) const IMATH_NOEXCEPT { return Matrix22 (x[0][0] + v.x[0][0], x[0][1] + v.x[0][1], x[1][0] + v.x[1][0], x[1][1] + v.x[1][1]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator-= (const Matrix22& v) IMATH_NOEXCEPT { x[0][0] -= v.x[0][0]; x[0][1] -= v.x[0][1]; x[1][0] -= v.x[1][0]; x[1][1] -= v.x[1][1]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator-= (T a) IMATH_NOEXCEPT { x[0][0] -= a; x[0][1] -= a; x[1][0] -= a; x[1][1] -= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix22 Matrix22::operator- (const Matrix22& v) const IMATH_NOEXCEPT { return Matrix22 (x[0][0] - v.x[0][0], x[0][1] - v.x[0][1], x[1][0] - v.x[1][0], x[1][1] - v.x[1][1]); } template IMATH_HOSTDEVICE constexpr inline Matrix22 Matrix22::operator-() const IMATH_NOEXCEPT { return Matrix22 (-x[0][0], -x[0][1], -x[1][0], -x[1][1]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::negate() IMATH_NOEXCEPT { x[0][0] = -x[0][0]; x[0][1] = -x[0][1]; x[1][0] = -x[1][0]; x[1][1] = -x[1][1]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator*= (T a) IMATH_NOEXCEPT { x[0][0] *= a; x[0][1] *= a; x[1][0] *= a; x[1][1] *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix22 Matrix22::operator* (T a) const IMATH_NOEXCEPT { return Matrix22 (x[0][0] * a, x[0][1] * a, x[1][0] * a, x[1][1] * a); } /// Matrix-scalar multiplication template IMATH_HOSTDEVICE inline Matrix22 operator* (T a, const Matrix22& v) IMATH_NOEXCEPT { return v * a; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator*= (const Matrix22& v) IMATH_NOEXCEPT { Matrix22 tmp (T (0)); for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) for (int k = 0; k < 2; k++) tmp.x[i][j] += x[i][k] * v.x[k][j]; *this = tmp; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22 Matrix22::operator* (const Matrix22& v) const IMATH_NOEXCEPT { Matrix22 tmp (T (0)); for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) for (int k = 0; k < 2; k++) tmp.x[i][j] += x[i][k] * v.x[k][j]; return tmp; } template template IMATH_HOSTDEVICE inline void Matrix22::multDirMatrix (const Vec2& src, Vec2& dst) const IMATH_NOEXCEPT { S a, b; a = src.x * x[0][0] + src.y * x[1][0]; b = src.x * x[0][1] + src.y * x[1][1]; dst.x = a; dst.y = b; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::operator/= (T a) IMATH_NOEXCEPT { x[0][0] /= a; x[0][1] /= a; x[1][0] /= a; x[1][1] /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix22 Matrix22::operator/ (T a) const IMATH_NOEXCEPT { return Matrix22 (x[0][0] / a, x[0][1] / a, x[1][0] / a, x[1][1] / a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::transpose() IMATH_NOEXCEPT { Matrix22 tmp (x[0][0], x[1][0], x[0][1], x[1][1]); *this = tmp; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix22 Matrix22::transposed() const IMATH_NOEXCEPT { return Matrix22 (x[0][0], x[1][0], x[0][1], x[1][1]); } template IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::invert (bool singExc) { *this = inverse (singExc); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::invert() IMATH_NOEXCEPT { *this = inverse(); return *this; } template IMATH_CONSTEXPR14 inline Matrix22 Matrix22::inverse (bool singExc) const { Matrix22 s (x[1][1], -x[0][1], -x[1][0], x[0][0]); T r = x[0][0] * x[1][1] - x[1][0] * x[0][1]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { s[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s[i][j])) { s[i][j] /= r; } else { if (singExc) throw std::invalid_argument ("Cannot invert " "singular matrix."); return Matrix22(); } } } } return s; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix22 Matrix22::inverse() const IMATH_NOEXCEPT { Matrix22 s (x[1][1], -x[0][1], -x[1][0], x[0][0]); T r = x[0][0] * x[1][1] - x[1][0] * x[0][1]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { s[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s[i][j])) { s[i][j] /= r; } else { return Matrix22(); } } } } return s; } template IMATH_HOSTDEVICE constexpr inline T Matrix22::determinant() const IMATH_NOEXCEPT { return x[0][0] * x[1][1] - x[1][0] * x[0][1]; } template template IMATH_HOSTDEVICE inline const Matrix22& Matrix22::setRotation (S r) IMATH_NOEXCEPT { S cos_r, sin_r; cos_r = cos ((T) r); sin_r = sin ((T) r); x[0][0] = cos_r; x[0][1] = sin_r; x[1][0] = -sin_r; x[1][1] = cos_r; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::rotate (S r) IMATH_NOEXCEPT { *this *= Matrix22().setRotation (r); return *this; } template IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::setScale (T s) IMATH_NOEXCEPT { // // Set the matrix to: // | s 0 | // | 0 s | // x[0][0] = s; x[0][1] = static_cast (0); x[1][0] = static_cast (0); x[1][1] = s; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::setScale (const Vec2& s) IMATH_NOEXCEPT { // // Set the matrix to: // | s.x 0 | // | 0 s.y | // x[0][0] = s.x; x[0][1] = static_cast (0); x[1][0] = static_cast (0); x[1][1] = s.y; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix22& Matrix22::scale (const Vec2& s) IMATH_NOEXCEPT { x[0][0] *= s.x; x[0][1] *= s.x; x[1][0] *= s.y; x[1][1] *= s.y; return *this; } //--------------------------- // Implementation of Matrix33 //--------------------------- template IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T* Matrix33::operator[] (int i) IMATH_NOEXCEPT { return x[i]; } template IMATH_HOSTDEVICE inline const T* Matrix33::operator[] (int i) const IMATH_NOEXCEPT { return x[i]; } template IMATH_HOSTDEVICE inline IMATH_CONSTEXPR14 Matrix33::Matrix33() IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[1][0] = 0; x[1][1] = 1; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33::Matrix33 (T a) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = a; x[0][2] = a; x[1][0] = a; x[1][1] = a; x[1][2] = a; x[2][0] = a; x[2][1] = a; x[2][2] = a; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33::Matrix33 (const T a[3][3]) IMATH_NOEXCEPT { // Function calls and aliasing issues can inhibit vectorization versus // straight assignment of data members, so instead of this: // memcpy (x, a, sizeof (x)); // we do this: x[0][0] = a[0][0]; x[0][1] = a[0][1]; x[0][2] = a[0][2]; x[1][0] = a[1][0]; x[1][1] = a[1][1]; x[1][2] = a[1][2]; x[2][0] = a[2][0]; x[2][1] = a[2][1]; x[2][2] = a[2][2]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33::Matrix33 (T a, T b, T c, T d, T e, T f, T g, T h, T i) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = b; x[0][2] = c; x[1][0] = d; x[1][1] = e; x[1][2] = f; x[2][0] = g; x[2][1] = h; x[2][2] = i; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33::Matrix33 (const Matrix33& v) IMATH_NOEXCEPT { // Function calls and aliasing issues can inhibit vectorization versus // straight assignment of data members, so instead of this: // memcpy (x, v.x, sizeof (x)); // we do this: x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33::Matrix33 (const Matrix33& v) IMATH_NOEXCEPT { x[0][0] = T (v.x[0][0]); x[0][1] = T (v.x[0][1]); x[0][2] = T (v.x[0][2]); x[1][0] = T (v.x[1][0]); x[1][1] = T (v.x[1][1]); x[1][2] = T (v.x[1][2]); x[2][0] = T (v.x[2][0]); x[2][1] = T (v.x[2][1]); x[2][2] = T (v.x[2][2]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator= (const Matrix33& v) IMATH_NOEXCEPT { // Function calls and aliasing issues can inhibit vectorization versus // straight assignment of data members, so instead of this: // memcpy (x, v.x, sizeof (x)); // we do this: x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator= (T a) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = a; x[0][2] = a; x[1][0] = a; x[1][1] = a; x[1][2] = a; x[2][0] = a; x[2][1] = a; x[2][2] = a; return *this; } template IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T* Matrix33::getValue() IMATH_NOEXCEPT { return (T*) &x[0][0]; } template IMATH_HOSTDEVICE inline const T* Matrix33::getValue() const IMATH_NOEXCEPT { return (const T*) &x[0][0]; } template template IMATH_HOSTDEVICE inline void Matrix33::getValue (Matrix33& v) const IMATH_NOEXCEPT { v.x[0][0] = x[0][0]; v.x[0][1] = x[0][1]; v.x[0][2] = x[0][2]; v.x[1][0] = x[1][0]; v.x[1][1] = x[1][1]; v.x[1][2] = x[1][2]; v.x[2][0] = x[2][0]; v.x[2][1] = x[2][1]; v.x[2][2] = x[2][2]; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33& Matrix33::setValue (const Matrix33& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33& Matrix33::setTheMatrix (const Matrix33& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; return *this; } template IMATH_HOSTDEVICE inline void Matrix33::makeIdentity() IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[1][0] = 0; x[1][1] = 1; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; } template IMATH_HOSTDEVICE constexpr inline bool Matrix33::operator== (const Matrix33& v) const IMATH_NOEXCEPT { return x[0][0] == v.x[0][0] && x[0][1] == v.x[0][1] && x[0][2] == v.x[0][2] && x[1][0] == v.x[1][0] && x[1][1] == v.x[1][1] && x[1][2] == v.x[1][2] && x[2][0] == v.x[2][0] && x[2][1] == v.x[2][1] && x[2][2] == v.x[2][2]; } template IMATH_HOSTDEVICE constexpr inline bool Matrix33::operator!= (const Matrix33& v) const IMATH_NOEXCEPT { return x[0][0] != v.x[0][0] || x[0][1] != v.x[0][1] || x[0][2] != v.x[0][2] || x[1][0] != v.x[1][0] || x[1][1] != v.x[1][1] || x[1][2] != v.x[1][2] || x[2][0] != v.x[2][0] || x[2][1] != v.x[2][1] || x[2][2] != v.x[2][2]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Matrix33::equalWithAbsError (const Matrix33& m, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i][j], m[i][j], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Matrix33::equalWithRelError (const Matrix33& m, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i][j], m[i][j], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator+= (const Matrix33& v) IMATH_NOEXCEPT { x[0][0] += v.x[0][0]; x[0][1] += v.x[0][1]; x[0][2] += v.x[0][2]; x[1][0] += v.x[1][0]; x[1][1] += v.x[1][1]; x[1][2] += v.x[1][2]; x[2][0] += v.x[2][0]; x[2][1] += v.x[2][1]; x[2][2] += v.x[2][2]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator+= (T a) IMATH_NOEXCEPT { x[0][0] += a; x[0][1] += a; x[0][2] += a; x[1][0] += a; x[1][1] += a; x[1][2] += a; x[2][0] += a; x[2][1] += a; x[2][2] += a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix33 Matrix33::operator+ (const Matrix33& v) const IMATH_NOEXCEPT { return Matrix33 (x[0][0] + v.x[0][0], x[0][1] + v.x[0][1], x[0][2] + v.x[0][2], x[1][0] + v.x[1][0], x[1][1] + v.x[1][1], x[1][2] + v.x[1][2], x[2][0] + v.x[2][0], x[2][1] + v.x[2][1], x[2][2] + v.x[2][2]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator-= (const Matrix33& v) IMATH_NOEXCEPT { x[0][0] -= v.x[0][0]; x[0][1] -= v.x[0][1]; x[0][2] -= v.x[0][2]; x[1][0] -= v.x[1][0]; x[1][1] -= v.x[1][1]; x[1][2] -= v.x[1][2]; x[2][0] -= v.x[2][0]; x[2][1] -= v.x[2][1]; x[2][2] -= v.x[2][2]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator-= (T a) IMATH_NOEXCEPT { x[0][0] -= a; x[0][1] -= a; x[0][2] -= a; x[1][0] -= a; x[1][1] -= a; x[1][2] -= a; x[2][0] -= a; x[2][1] -= a; x[2][2] -= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix33 Matrix33::operator- (const Matrix33& v) const IMATH_NOEXCEPT { return Matrix33 (x[0][0] - v.x[0][0], x[0][1] - v.x[0][1], x[0][2] - v.x[0][2], x[1][0] - v.x[1][0], x[1][1] - v.x[1][1], x[1][2] - v.x[1][2], x[2][0] - v.x[2][0], x[2][1] - v.x[2][1], x[2][2] - v.x[2][2]); } template IMATH_HOSTDEVICE constexpr inline Matrix33 Matrix33::operator-() const IMATH_NOEXCEPT { return Matrix33 (-x[0][0], -x[0][1], -x[0][2], -x[1][0], -x[1][1], -x[1][2], -x[2][0], -x[2][1], -x[2][2]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::negate() IMATH_NOEXCEPT { x[0][0] = -x[0][0]; x[0][1] = -x[0][1]; x[0][2] = -x[0][2]; x[1][0] = -x[1][0]; x[1][1] = -x[1][1]; x[1][2] = -x[1][2]; x[2][0] = -x[2][0]; x[2][1] = -x[2][1]; x[2][2] = -x[2][2]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator*= (T a) IMATH_NOEXCEPT { x[0][0] *= a; x[0][1] *= a; x[0][2] *= a; x[1][0] *= a; x[1][1] *= a; x[1][2] *= a; x[2][0] *= a; x[2][1] *= a; x[2][2] *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix33 Matrix33::operator* (T a) const IMATH_NOEXCEPT { return Matrix33 (x[0][0] * a, x[0][1] * a, x[0][2] * a, x[1][0] * a, x[1][1] * a, x[1][2] * a, x[2][0] * a, x[2][1] * a, x[2][2] * a); } /// Matrix-scalar multiplication template IMATH_HOSTDEVICE inline Matrix33 constexpr operator* (T a, const Matrix33& v) IMATH_NOEXCEPT { return v * a; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator*= (const Matrix33& v) IMATH_NOEXCEPT { // Avoid initializing with 0 values before immediately overwriting them, // and unroll all loops for the best autovectorization. Matrix33 tmp(IMATH_INTERNAL_NAMESPACE::UNINITIALIZED); tmp.x[0][0] = x[0][0] * v.x[0][0] + x[0][1] * v.x[1][0] + x[0][2] * v.x[2][0]; tmp.x[0][1] = x[0][0] * v.x[0][1] + x[0][1] * v.x[1][1] + x[0][2] * v.x[2][1]; tmp.x[0][2] = x[0][0] * v.x[0][2] + x[0][1] * v.x[1][2] + x[0][2] * v.x[2][2]; tmp.x[1][0] = x[1][0] * v.x[0][0] + x[1][1] * v.x[1][0] + x[1][2] * v.x[2][0]; tmp.x[1][1] = x[1][0] * v.x[0][1] + x[1][1] * v.x[1][1] + x[1][2] * v.x[2][1]; tmp.x[1][2] = x[1][0] * v.x[0][2] + x[1][1] * v.x[1][2] + x[1][2] * v.x[2][2]; tmp.x[2][0] = x[2][0] * v.x[0][0] + x[2][1] * v.x[1][0] + x[2][2] * v.x[2][0]; tmp.x[2][1] = x[2][0] * v.x[0][1] + x[2][1] * v.x[1][1] + x[2][2] * v.x[2][1]; tmp.x[2][2] = x[2][0] * v.x[0][2] + x[2][1] * v.x[1][2] + x[2][2] * v.x[2][2]; *this = tmp; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33 Matrix33::operator* (const Matrix33& v) const IMATH_NOEXCEPT { // Avoid initializing with 0 values before immediately overwriting them, // and unroll all loops for the best autovectorization. Matrix33 tmp(IMATH_INTERNAL_NAMESPACE::UNINITIALIZED); tmp.x[0][0] = x[0][0] * v.x[0][0] + x[0][1] * v.x[1][0] + x[0][2] * v.x[2][0]; tmp.x[0][1] = x[0][0] * v.x[0][1] + x[0][1] * v.x[1][1] + x[0][2] * v.x[2][1]; tmp.x[0][2] = x[0][0] * v.x[0][2] + x[0][1] * v.x[1][2] + x[0][2] * v.x[2][2]; tmp.x[1][0] = x[1][0] * v.x[0][0] + x[1][1] * v.x[1][0] + x[1][2] * v.x[2][0]; tmp.x[1][1] = x[1][0] * v.x[0][1] + x[1][1] * v.x[1][1] + x[1][2] * v.x[2][1]; tmp.x[1][2] = x[1][0] * v.x[0][2] + x[1][1] * v.x[1][2] + x[1][2] * v.x[2][2]; tmp.x[2][0] = x[2][0] * v.x[0][0] + x[2][1] * v.x[1][0] + x[2][2] * v.x[2][0]; tmp.x[2][1] = x[2][0] * v.x[0][1] + x[2][1] * v.x[1][1] + x[2][2] * v.x[2][1]; tmp.x[2][2] = x[2][0] * v.x[0][2] + x[2][1] * v.x[1][2] + x[2][2] * v.x[2][2]; return tmp; } template template IMATH_HOSTDEVICE inline void Matrix33::multVecMatrix (const Vec2& src, Vec2& dst) const IMATH_NOEXCEPT { S a, b, w; a = src.x * x[0][0] + src.y * x[1][0] + x[2][0]; b = src.x * x[0][1] + src.y * x[1][1] + x[2][1]; w = src.x * x[0][2] + src.y * x[1][2] + x[2][2]; dst.x = a / w; dst.y = b / w; } template template IMATH_HOSTDEVICE inline void Matrix33::multDirMatrix (const Vec2& src, Vec2& dst) const IMATH_NOEXCEPT { S a, b; a = src.x * x[0][0] + src.y * x[1][0]; b = src.x * x[0][1] + src.y * x[1][1]; dst.x = a; dst.y = b; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::operator/= (T a) IMATH_NOEXCEPT { x[0][0] /= a; x[0][1] /= a; x[0][2] /= a; x[1][0] /= a; x[1][1] /= a; x[1][2] /= a; x[2][0] /= a; x[2][1] /= a; x[2][2] /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix33 Matrix33::operator/ (T a) const IMATH_NOEXCEPT { return Matrix33 (x[0][0] / a, x[0][1] / a, x[0][2] / a, x[1][0] / a, x[1][1] / a, x[1][2] / a, x[2][0] / a, x[2][1] / a, x[2][2] / a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::transpose() IMATH_NOEXCEPT { Matrix33 tmp (x[0][0], x[1][0], x[2][0], x[0][1], x[1][1], x[2][1], x[0][2], x[1][2], x[2][2]); *this = tmp; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix33 Matrix33::transposed() const IMATH_NOEXCEPT { return Matrix33 (x[0][0], x[1][0], x[2][0], x[0][1], x[1][1], x[2][1], x[0][2], x[1][2], x[2][2]); } template const inline Matrix33& Matrix33::gjInvert (bool singExc) { *this = gjInverse (singExc); return *this; } template IMATH_HOSTDEVICE const inline Matrix33& Matrix33::gjInvert() IMATH_NOEXCEPT { *this = gjInverse(); return *this; } template inline Matrix33 Matrix33::gjInverse (bool singExc) const { int i, j, k; Matrix33 s; Matrix33 t (*this); // Forward elimination for (i = 0; i < 2; i++) { int pivot = i; T pivotsize = t.x[i][i]; if (pivotsize < 0) pivotsize = -pivotsize; for (j = i + 1; j < 3; j++) { T tmp = t.x[j][i]; if (tmp < 0) tmp = -tmp; if (tmp > pivotsize) { pivot = j; pivotsize = tmp; } } if (pivotsize == 0) { if (singExc) throw std::invalid_argument ("Cannot invert singular matrix."); return Matrix33(); } if (pivot != i) { for (j = 0; j < 3; j++) { T tmp; tmp = t.x[i][j]; t.x[i][j] = t.x[pivot][j]; t.x[pivot][j] = tmp; tmp = s.x[i][j]; s.x[i][j] = s.x[pivot][j]; s.x[pivot][j] = tmp; } } for (j = i + 1; j < 3; j++) { T f = t.x[j][i] / t.x[i][i]; for (k = 0; k < 3; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } // Backward substitution for (i = 2; i >= 0; --i) { T f; if ((f = t[i][i]) == 0) { if (singExc) throw std::invalid_argument ("Cannot invert singular matrix."); return Matrix33(); } for (j = 0; j < 3; j++) { t.x[i][j] /= f; s.x[i][j] /= f; } for (j = 0; j < i; j++) { f = t.x[j][i]; for (k = 0; k < 3; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } return s; } template IMATH_HOSTDEVICE inline Matrix33 Matrix33::gjInverse() const IMATH_NOEXCEPT { int i, j, k; Matrix33 s; Matrix33 t (*this); // Forward elimination for (i = 0; i < 2; i++) { int pivot = i; T pivotsize = t.x[i][i]; if (pivotsize < 0) pivotsize = -pivotsize; for (j = i + 1; j < 3; j++) { T tmp = t.x[j][i]; if (tmp < 0) tmp = -tmp; if (tmp > pivotsize) { pivot = j; pivotsize = tmp; } } if (pivotsize == 0) { return Matrix33(); } if (pivot != i) { for (j = 0; j < 3; j++) { T tmp; tmp = t.x[i][j]; t.x[i][j] = t.x[pivot][j]; t.x[pivot][j] = tmp; tmp = s.x[i][j]; s.x[i][j] = s.x[pivot][j]; s.x[pivot][j] = tmp; } } for (j = i + 1; j < 3; j++) { T f = t.x[j][i] / t.x[i][i]; for (k = 0; k < 3; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } // Backward substitution for (i = 2; i >= 0; --i) { T f; if ((f = t.x[i][i]) == 0) { return Matrix33(); } for (j = 0; j < 3; j++) { t.x[i][j] /= f; s.x[i][j] /= f; } for (j = 0; j < i; j++) { f = t.x[j][i]; for (k = 0; k < 3; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } return s; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::invert (bool singExc) { *this = inverse (singExc); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::invert() IMATH_NOEXCEPT { *this = inverse(); return *this; } template IMATH_CONSTEXPR14 inline Matrix33 Matrix33::inverse (bool singExc) const { if (x[0][2] != 0 || x[1][2] != 0 || x[2][2] != 1) { Matrix33 s (x[1][1] * x[2][2] - x[2][1] * x[1][2], x[2][1] * x[0][2] - x[0][1] * x[2][2], x[0][1] * x[1][2] - x[1][1] * x[0][2], x[2][0] * x[1][2] - x[1][0] * x[2][2], x[0][0] * x[2][2] - x[2][0] * x[0][2], x[1][0] * x[0][2] - x[0][0] * x[1][2], x[1][0] * x[2][1] - x[2][0] * x[1][1], x[2][0] * x[0][1] - x[0][0] * x[2][1], x[0][0] * x[1][1] - x[1][0] * x[0][1]); T r = x[0][0] * s[0][0] + x[0][1] * s[1][0] + x[0][2] * s[2][0]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { s.x[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s.x[i][j])) { s.x[i][j] /= r; } else { if (singExc) throw std::invalid_argument ("Cannot invert " "singular matrix."); return Matrix33(); } } } } return s; } else { Matrix33 s (x[1][1], -x[0][1], 0, -x[1][0], x[0][0], 0, 0, 0, 1); T r = x[0][0] * x[1][1] - x[1][0] * x[0][1]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { s.x[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s.x[i][j])) { s.x[i][j] /= r; } else { if (singExc) throw std::invalid_argument ("Cannot invert " "singular matrix."); return Matrix33(); } } } } s.x[2][0] = -x[2][0] * s.x[0][0] - x[2][1] * s.x[1][0]; s.x[2][1] = -x[2][0] * s.x[0][1] - x[2][1] * s.x[1][1]; return s; } } template IMATH_HOSTDEVICE IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix33 Matrix33::inverse() const IMATH_NOEXCEPT { if (x[0][2] != 0 || x[1][2] != 0 || x[2][2] != 1) { Matrix33 s (x[1][1] * x[2][2] - x[2][1] * x[1][2], x[2][1] * x[0][2] - x[0][1] * x[2][2], x[0][1] * x[1][2] - x[1][1] * x[0][2], x[2][0] * x[1][2] - x[1][0] * x[2][2], x[0][0] * x[2][2] - x[2][0] * x[0][2], x[1][0] * x[0][2] - x[0][0] * x[1][2], x[1][0] * x[2][1] - x[2][0] * x[1][1], x[2][0] * x[0][1] - x[0][0] * x[2][1], x[0][0] * x[1][1] - x[1][0] * x[0][1]); T r = x[0][0] * s.x[0][0] + x[0][1] * s.x[1][0] + x[0][2] * s.x[2][0]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { s.x[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s.x[i][j])) { s.x[i][j] /= r; } else { return Matrix33(); } } } } return s; } else { Matrix33 s (x[1][1], -x[0][1], 0, -x[1][0], x[0][0], 0, 0, 0, 1); T r = x[0][0] * x[1][1] - x[1][0] * x[0][1]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { s.x[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 2; ++i) { for (int j = 0; j < 2; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s.x[i][j])) { s.x[i][j] /= r; } else { return Matrix33(); } } } } s.x[2][0] = -x[2][0] * s.x[0][0] - x[2][1] * s.x[1][0]; s.x[2][1] = -x[2][0] * s.x[0][1] - x[2][1] * s.x[1][1]; return s; } } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Matrix33::minorOf (const int r, const int c) const IMATH_NOEXCEPT { int r0 = 0 + (r < 1 ? 1 : 0); int r1 = 1 + (r < 2 ? 1 : 0); int c0 = 0 + (c < 1 ? 1 : 0); int c1 = 1 + (c < 2 ? 1 : 0); return x[r0][c0] * x[r1][c1] - x[r1][c0] * x[r0][c1]; } template IMATH_HOSTDEVICE constexpr inline T Matrix33::fastMinor (const int r0, const int r1, const int c0, const int c1) const IMATH_NOEXCEPT { return x[r0][c0] * x[r1][c1] - x[r0][c1] * x[r1][c0]; } template IMATH_HOSTDEVICE constexpr inline T Matrix33::determinant() const IMATH_NOEXCEPT { return x[0][0] * (x[1][1] * x[2][2] - x[1][2] * x[2][1]) + x[0][1] * (x[1][2] * x[2][0] - x[1][0] * x[2][2]) + x[0][2] * (x[1][0] * x[2][1] - x[1][1] * x[2][0]); } template template IMATH_HOSTDEVICE inline const Matrix33& Matrix33::setRotation (S r) IMATH_NOEXCEPT { S cos_r, sin_r; cos_r = cos ((T) r); sin_r = sin ((T) r); x[0][0] = cos_r; x[0][1] = sin_r; x[0][2] = 0; x[1][0] = -sin_r; x[1][1] = cos_r; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::rotate (S r) IMATH_NOEXCEPT { *this *= Matrix33().setRotation (r); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::setScale (T s) IMATH_NOEXCEPT { // // Set the matrix to a 2D homogeneous transform scale: // | s 0 0 | // | 0 s 0 | // | 0 0 1 | // x[0][0] = s; x[0][1] = 0; x[0][2] = 0; x[1][0] = 0; x[1][1] = s; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::setScale (const Vec2& s) IMATH_NOEXCEPT { // // Set the matrix to a 2D homogeneous transform scale: // | s.x 0 0 | // | 0 s.y 0 | // | 0 0 1 | // x[0][0] = s.x; x[0][1] = 0; x[0][2] = 0; x[1][0] = 0; x[1][1] = s.y; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::scale (const Vec2& s) IMATH_NOEXCEPT { x[0][0] *= s.x; x[0][1] *= s.x; x[0][2] *= s.x; x[1][0] *= s.y; x[1][1] *= s.y; x[1][2] *= s.y; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::setTranslation (const Vec2& t) IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[1][0] = 0; x[1][1] = 1; x[1][2] = 0; x[2][0] = t.x; x[2][1] = t.y; x[2][2] = 1; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec2 Matrix33::translation() const IMATH_NOEXCEPT { return Vec2 (x[2][0], x[2][1]); } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::translate (const Vec2& t) IMATH_NOEXCEPT { x[2][0] += t.x * x[0][0] + t.y * x[1][0]; x[2][1] += t.x * x[0][1] + t.y * x[1][1]; x[2][2] += t.x * x[0][2] + t.y * x[1][2]; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::setShear (const S& xy) IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[1][0] = xy; x[1][1] = 1; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::setShear (const Vec2& h) IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = h.y; x[0][2] = 0; x[1][0] = h.x; x[1][1] = 1; x[1][2] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::shear (const S& xy) IMATH_NOEXCEPT { // // In this case, we don't need a temp. copy of the matrix // because we never use a value on the RHS after we've // changed it on the LHS. // x[1][0] += xy * x[0][0]; x[1][1] += xy * x[0][1]; x[1][2] += xy * x[0][2]; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix33& Matrix33::shear (const Vec2& h) IMATH_NOEXCEPT { Matrix33 P (*this); x[0][0] = P.x[0][0] + h.y * P.x[1][0]; x[0][1] = P.x[0][1] + h.y * P.x[1][1]; x[0][2] = P.x[0][2] + h.y * P.x[1][2]; x[1][0] = P.x[1][0] + h.x * P.x[0][0]; x[1][1] = P.x[1][1] + h.x * P.x[0][1]; x[1][2] = P.x[1][2] + h.x * P.x[0][2]; return *this; } //--------------------------- // Implementation of Matrix44 //--------------------------- template IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T* Matrix44::operator[] (int i) IMATH_NOEXCEPT { return x[i]; } template IMATH_HOSTDEVICE inline const T* Matrix44::operator[] (int i) const IMATH_NOEXCEPT { return x[i]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44::Matrix44() IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[0][3] = 0; x[1][0] = 0; x[1][1] = 1; x[1][2] = 0; x[1][3] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44::Matrix44 (T a) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = a; x[0][2] = a; x[0][3] = a; x[1][0] = a; x[1][1] = a; x[1][2] = a; x[1][3] = a; x[2][0] = a; x[2][1] = a; x[2][2] = a; x[2][3] = a; x[3][0] = a; x[3][1] = a; x[3][2] = a; x[3][3] = a; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44::Matrix44 (const T a[4][4]) IMATH_NOEXCEPT { x[0][0] = a[0][0]; x[0][1] = a[0][1]; x[0][2] = a[0][2]; x[0][3] = a[0][3]; x[1][0] = a[1][0]; x[1][1] = a[1][1]; x[1][2] = a[1][2]; x[1][3] = a[1][3]; x[2][0] = a[2][0]; x[2][1] = a[2][1]; x[2][2] = a[2][2]; x[2][3] = a[2][3]; x[3][0] = a[3][0]; x[3][1] = a[3][1]; x[3][2] = a[3][2]; x[3][3] = a[3][3]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44< T>::Matrix44 (T a, T b, T c, T d, T e, T f, T g, T h, T i, T j, T k, T l, T m, T n, T o, T p) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = b; x[0][2] = c; x[0][3] = d; x[1][0] = e; x[1][1] = f; x[1][2] = g; x[1][3] = h; x[2][0] = i; x[2][1] = j; x[2][2] = k; x[2][3] = l; x[3][0] = m; x[3][1] = n; x[3][2] = o; x[3][3] = p; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44::Matrix44 (Matrix33 r, Vec3 t) IMATH_NOEXCEPT { x[0][0] = r.x[0][0]; x[0][1] = r.x[0][1]; x[0][2] = r.x[0][2]; x[0][3] = 0; x[1][0] = r.x[1][0]; x[1][1] = r.x[1][1]; x[1][2] = r.x[1][2]; x[1][3] = 0; x[2][0] = r.x[2][0]; x[2][1] = r.x[2][1]; x[2][2] = r.x[2][2]; x[2][3] = 0; x[3][0] = t.x; x[3][1] = t.y; x[3][2] = t.z; x[3][3] = 1; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44::Matrix44 (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[0][3] = v.x[0][3]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[1][3] = v.x[1][3]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; x[2][3] = v.x[2][3]; x[3][0] = v.x[3][0]; x[3][1] = v.x[3][1]; x[3][2] = v.x[3][2]; x[3][3] = v.x[3][3]; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44::Matrix44 (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] = T (v.x[0][0]); x[0][1] = T (v.x[0][1]); x[0][2] = T (v.x[0][2]); x[0][3] = T (v.x[0][3]); x[1][0] = T (v.x[1][0]); x[1][1] = T (v.x[1][1]); x[1][2] = T (v.x[1][2]); x[1][3] = T (v.x[1][3]); x[2][0] = T (v.x[2][0]); x[2][1] = T (v.x[2][1]); x[2][2] = T (v.x[2][2]); x[2][3] = T (v.x[2][3]); x[3][0] = T (v.x[3][0]); x[3][1] = T (v.x[3][1]); x[3][2] = T (v.x[3][2]); x[3][3] = T (v.x[3][3]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator= (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[0][3] = v.x[0][3]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[1][3] = v.x[1][3]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; x[2][3] = v.x[2][3]; x[3][0] = v.x[3][0]; x[3][1] = v.x[3][1]; x[3][2] = v.x[3][2]; x[3][3] = v.x[3][3]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator= (T a) IMATH_NOEXCEPT { x[0][0] = a; x[0][1] = a; x[0][2] = a; x[0][3] = a; x[1][0] = a; x[1][1] = a; x[1][2] = a; x[1][3] = a; x[2][0] = a; x[2][1] = a; x[2][2] = a; x[2][3] = a; x[3][0] = a; x[3][1] = a; x[3][2] = a; x[3][3] = a; return *this; } template IMATH_HOSTDEVICE IMATH_HOSTDEVICE inline T* Matrix44::getValue() IMATH_NOEXCEPT { return (T*) &x[0][0]; } template IMATH_HOSTDEVICE inline const T* Matrix44::getValue() const IMATH_NOEXCEPT { return (const T*) &x[0][0]; } template template IMATH_HOSTDEVICE inline void Matrix44::getValue (Matrix44& v) const IMATH_NOEXCEPT { v.x[0][0] = x[0][0]; v.x[0][1] = x[0][1]; v.x[0][2] = x[0][2]; v.x[0][3] = x[0][3]; v.x[1][0] = x[1][0]; v.x[1][1] = x[1][1]; v.x[1][2] = x[1][2]; v.x[1][3] = x[1][3]; v.x[2][0] = x[2][0]; v.x[2][1] = x[2][1]; v.x[2][2] = x[2][2]; v.x[2][3] = x[2][3]; v.x[3][0] = x[3][0]; v.x[3][1] = x[3][1]; v.x[3][2] = x[3][2]; v.x[3][3] = x[3][3]; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44& Matrix44::setValue (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[0][3] = v.x[0][3]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[1][3] = v.x[1][3]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; x[2][3] = v.x[2][3]; x[3][0] = v.x[3][0]; x[3][1] = v.x[3][1]; x[3][2] = v.x[3][2]; x[3][3] = v.x[3][3]; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44& Matrix44::setTheMatrix (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] = v.x[0][0]; x[0][1] = v.x[0][1]; x[0][2] = v.x[0][2]; x[0][3] = v.x[0][3]; x[1][0] = v.x[1][0]; x[1][1] = v.x[1][1]; x[1][2] = v.x[1][2]; x[1][3] = v.x[1][3]; x[2][0] = v.x[2][0]; x[2][1] = v.x[2][1]; x[2][2] = v.x[2][2]; x[2][3] = v.x[2][3]; x[3][0] = v.x[3][0]; x[3][1] = v.x[3][1]; x[3][2] = v.x[3][2]; x[3][3] = v.x[3][3]; return *this; } template IMATH_HOSTDEVICE inline void Matrix44::makeIdentity() IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[0][3] = 0; x[1][0] = 0; x[1][1] = 1; x[1][2] = 0; x[1][3] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; } template IMATH_HOSTDEVICE constexpr inline bool Matrix44::operator== (const Matrix44& v) const IMATH_NOEXCEPT { return x[0][0] == v.x[0][0] && x[0][1] == v.x[0][1] && x[0][2] == v.x[0][2] && x[0][3] == v.x[0][3] && x[1][0] == v.x[1][0] && x[1][1] == v.x[1][1] && x[1][2] == v.x[1][2] && x[1][3] == v.x[1][3] && x[2][0] == v.x[2][0] && x[2][1] == v.x[2][1] && x[2][2] == v.x[2][2] && x[2][3] == v.x[2][3] && x[3][0] == v.x[3][0] && x[3][1] == v.x[3][1] && x[3][2] == v.x[3][2] && x[3][3] == v.x[3][3]; } template IMATH_HOSTDEVICE constexpr inline bool Matrix44::operator!= (const Matrix44& v) const IMATH_NOEXCEPT { return x[0][0] != v.x[0][0] || x[0][1] != v.x[0][1] || x[0][2] != v.x[0][2] || x[0][3] != v.x[0][3] || x[1][0] != v.x[1][0] || x[1][1] != v.x[1][1] || x[1][2] != v.x[1][2] || x[1][3] != v.x[1][3] || x[2][0] != v.x[2][0] || x[2][1] != v.x[2][1] || x[2][2] != v.x[2][2] || x[2][3] != v.x[2][3] || x[3][0] != v.x[3][0] || x[3][1] != v.x[3][1] || x[3][2] != v.x[3][2] || x[3][3] != v.x[3][3]; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Matrix44::equalWithAbsError (const Matrix44& m, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this).x[i][j], m.x[i][j], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Matrix44::equalWithRelError (const Matrix44& m, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this).x[i][j], m.x[i][j], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator+= (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] += v.x[0][0]; x[0][1] += v.x[0][1]; x[0][2] += v.x[0][2]; x[0][3] += v.x[0][3]; x[1][0] += v.x[1][0]; x[1][1] += v.x[1][1]; x[1][2] += v.x[1][2]; x[1][3] += v.x[1][3]; x[2][0] += v.x[2][0]; x[2][1] += v.x[2][1]; x[2][2] += v.x[2][2]; x[2][3] += v.x[2][3]; x[3][0] += v.x[3][0]; x[3][1] += v.x[3][1]; x[3][2] += v.x[3][2]; x[3][3] += v.x[3][3]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator+= (T a) IMATH_NOEXCEPT { x[0][0] += a; x[0][1] += a; x[0][2] += a; x[0][3] += a; x[1][0] += a; x[1][1] += a; x[1][2] += a; x[1][3] += a; x[2][0] += a; x[2][1] += a; x[2][2] += a; x[2][3] += a; x[3][0] += a; x[3][1] += a; x[3][2] += a; x[3][3] += a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix44 Matrix44::operator+ (const Matrix44& v) const IMATH_NOEXCEPT { return Matrix44 (x[0][0] + v.x[0][0], x[0][1] + v.x[0][1], x[0][2] + v.x[0][2], x[0][3] + v.x[0][3], x[1][0] + v.x[1][0], x[1][1] + v.x[1][1], x[1][2] + v.x[1][2], x[1][3] + v.x[1][3], x[2][0] + v.x[2][0], x[2][1] + v.x[2][1], x[2][2] + v.x[2][2], x[2][3] + v.x[2][3], x[3][0] + v.x[3][0], x[3][1] + v.x[3][1], x[3][2] + v.x[3][2], x[3][3] + v.x[3][3]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator-= (const Matrix44& v) IMATH_NOEXCEPT { x[0][0] -= v.x[0][0]; x[0][1] -= v.x[0][1]; x[0][2] -= v.x[0][2]; x[0][3] -= v.x[0][3]; x[1][0] -= v.x[1][0]; x[1][1] -= v.x[1][1]; x[1][2] -= v.x[1][2]; x[1][3] -= v.x[1][3]; x[2][0] -= v.x[2][0]; x[2][1] -= v.x[2][1]; x[2][2] -= v.x[2][2]; x[2][3] -= v.x[2][3]; x[3][0] -= v.x[3][0]; x[3][1] -= v.x[3][1]; x[3][2] -= v.x[3][2]; x[3][3] -= v.x[3][3]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator-= (T a) IMATH_NOEXCEPT { x[0][0] -= a; x[0][1] -= a; x[0][2] -= a; x[0][3] -= a; x[1][0] -= a; x[1][1] -= a; x[1][2] -= a; x[1][3] -= a; x[2][0] -= a; x[2][1] -= a; x[2][2] -= a; x[2][3] -= a; x[3][0] -= a; x[3][1] -= a; x[3][2] -= a; x[3][3] -= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix44 Matrix44::operator- (const Matrix44& v) const IMATH_NOEXCEPT { return Matrix44 (x[0][0] - v.x[0][0], x[0][1] - v.x[0][1], x[0][2] - v.x[0][2], x[0][3] - v.x[0][3], x[1][0] - v.x[1][0], x[1][1] - v.x[1][1], x[1][2] - v.x[1][2], x[1][3] - v.x[1][3], x[2][0] - v.x[2][0], x[2][1] - v.x[2][1], x[2][2] - v.x[2][2], x[2][3] - v.x[2][3], x[3][0] - v.x[3][0], x[3][1] - v.x[3][1], x[3][2] - v.x[3][2], x[3][3] - v.x[3][3]); } template IMATH_HOSTDEVICE constexpr inline Matrix44 Matrix44::operator-() const IMATH_NOEXCEPT { return Matrix44 (-x[0][0], -x[0][1], -x[0][2], -x[0][3], -x[1][0], -x[1][1], -x[1][2], -x[1][3], -x[2][0], -x[2][1], -x[2][2], -x[2][3], -x[3][0], -x[3][1], -x[3][2], -x[3][3]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::negate() IMATH_NOEXCEPT { x[0][0] = -x[0][0]; x[0][1] = -x[0][1]; x[0][2] = -x[0][2]; x[0][3] = -x[0][3]; x[1][0] = -x[1][0]; x[1][1] = -x[1][1]; x[1][2] = -x[1][2]; x[1][3] = -x[1][3]; x[2][0] = -x[2][0]; x[2][1] = -x[2][1]; x[2][2] = -x[2][2]; x[2][3] = -x[2][3]; x[3][0] = -x[3][0]; x[3][1] = -x[3][1]; x[3][2] = -x[3][2]; x[3][3] = -x[3][3]; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator*= (T a) IMATH_NOEXCEPT { x[0][0] *= a; x[0][1] *= a; x[0][2] *= a; x[0][3] *= a; x[1][0] *= a; x[1][1] *= a; x[1][2] *= a; x[1][3] *= a; x[2][0] *= a; x[2][1] *= a; x[2][2] *= a; x[2][3] *= a; x[3][0] *= a; x[3][1] *= a; x[3][2] *= a; x[3][3] *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix44 Matrix44::operator* (T a) const IMATH_NOEXCEPT { return Matrix44 (x[0][0] * a, x[0][1] * a, x[0][2] * a, x[0][3] * a, x[1][0] * a, x[1][1] * a, x[1][2] * a, x[1][3] * a, x[2][0] * a, x[2][1] * a, x[2][2] * a, x[2][3] * a, x[3][0] * a, x[3][1] * a, x[3][2] * a, x[3][3] * a); } /// Matrix-scalar multiplication template IMATH_HOSTDEVICE inline Matrix44 operator* (T a, const Matrix44& v) IMATH_NOEXCEPT { return v * a; } template IMATH_HOSTDEVICE inline IMATH_CONSTEXPR14 Matrix44 Matrix44::multiply (const Matrix44 &a, const Matrix44 &b) IMATH_NOEXCEPT { const auto a00 = a.x[0][0]; const auto a01 = a.x[0][1]; const auto a02 = a.x[0][2]; const auto a03 = a.x[0][3]; const auto c00 = a00 * b.x[0][0] + a01 * b.x[1][0] + a02 * b.x[2][0] + a03 * b.x[3][0]; const auto c01 = a00 * b.x[0][1] + a01 * b.x[1][1] + a02 * b.x[2][1] + a03 * b.x[3][1]; const auto c02 = a00 * b.x[0][2] + a01 * b.x[1][2] + a02 * b.x[2][2] + a03 * b.x[3][2]; const auto c03 = a00 * b.x[0][3] + a01 * b.x[1][3] + a02 * b.x[2][3] + a03 * b.x[3][3]; const auto a10 = a.x[1][0]; const auto a11 = a.x[1][1]; const auto a12 = a.x[1][2]; const auto a13 = a.x[1][3]; const auto c10 = a10 * b.x[0][0] + a11 * b.x[1][0] + a12 * b.x[2][0] + a13 * b.x[3][0]; const auto c11 = a10 * b.x[0][1] + a11 * b.x[1][1] + a12 * b.x[2][1] + a13 * b.x[3][1]; const auto c12 = a10 * b.x[0][2] + a11 * b.x[1][2] + a12 * b.x[2][2] + a13 * b.x[3][2]; const auto c13 = a10 * b.x[0][3] + a11 * b.x[1][3] + a12 * b.x[2][3] + a13 * b.x[3][3]; const auto a20 = a.x[2][0]; const auto a21 = a.x[2][1]; const auto a22 = a.x[2][2]; const auto a23 = a.x[2][3]; const auto c20 = a20 * b.x[0][0] + a21 * b.x[1][0] + a22 * b.x[2][0] + a23 * b.x[3][0]; const auto c21 = a20 * b.x[0][1] + a21 * b.x[1][1] + a22 * b.x[2][1] + a23 * b.x[3][1]; const auto c22 = a20 * b.x[0][2] + a21 * b.x[1][2] + a22 * b.x[2][2] + a23 * b.x[3][2]; const auto c23 = a20 * b.x[0][3] + a21 * b.x[1][3] + a22 * b.x[2][3] + a23 * b.x[3][3]; const auto a30 = a.x[3][0]; const auto a31 = a.x[3][1]; const auto a32 = a.x[3][2]; const auto a33 = a.x[3][3]; const auto c30 = a30 * b.x[0][0] + a31 * b.x[1][0] + a32 * b.x[2][0] + a33 * b.x[3][0]; const auto c31 = a30 * b.x[0][1] + a31 * b.x[1][1] + a32 * b.x[2][1] + a33 * b.x[3][1]; const auto c32 = a30 * b.x[0][2] + a31 * b.x[1][2] + a32 * b.x[2][2] + a33 * b.x[3][2]; const auto c33 = a30 * b.x[0][3] + a31 * b.x[1][3] + a32 * b.x[2][3] + a33 * b.x[3][3]; return Matrix44(c00, c01, c02, c03, c10, c11, c12, c13, c20, c21, c22, c23, c30, c31, c32, c33); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator*= (const Matrix44& v) IMATH_NOEXCEPT { *this = multiply(*this, v); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44 Matrix44::operator* (const Matrix44& v) const IMATH_NOEXCEPT { return multiply(*this, v); } template IMATH_HOSTDEVICE inline void Matrix44::multiply (const Matrix44& a, const Matrix44& b, Matrix44& c) IMATH_NOEXCEPT { c = multiply(a, b); } template template IMATH_HOSTDEVICE inline void Matrix44::multVecMatrix (const Vec3& src, Vec3& dst) const IMATH_NOEXCEPT { S a, b, c, w; a = src.x * x[0][0] + src.y * x[1][0] + src.z * x[2][0] + x[3][0]; b = src.x * x[0][1] + src.y * x[1][1] + src.z * x[2][1] + x[3][1]; c = src.x * x[0][2] + src.y * x[1][2] + src.z * x[2][2] + x[3][2]; w = src.x * x[0][3] + src.y * x[1][3] + src.z * x[2][3] + x[3][3]; dst.x = a / w; dst.y = b / w; dst.z = c / w; } template template IMATH_HOSTDEVICE inline void Matrix44::multDirMatrix (const Vec3& src, Vec3& dst) const IMATH_NOEXCEPT { S a, b, c; a = src.x * x[0][0] + src.y * x[1][0] + src.z * x[2][0]; b = src.x * x[0][1] + src.y * x[1][1] + src.z * x[2][1]; c = src.x * x[0][2] + src.y * x[1][2] + src.z * x[2][2]; dst.x = a; dst.y = b; dst.z = c; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::operator/= (T a) IMATH_NOEXCEPT { x[0][0] /= a; x[0][1] /= a; x[0][2] /= a; x[0][3] /= a; x[1][0] /= a; x[1][1] /= a; x[1][2] /= a; x[1][3] /= a; x[2][0] /= a; x[2][1] /= a; x[2][2] /= a; x[2][3] /= a; x[3][0] /= a; x[3][1] /= a; x[3][2] /= a; x[3][3] /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix44 Matrix44::operator/ (T a) const IMATH_NOEXCEPT { return Matrix44 (x[0][0] / a, x[0][1] / a, x[0][2] / a, x[0][3] / a, x[1][0] / a, x[1][1] / a, x[1][2] / a, x[1][3] / a, x[2][0] / a, x[2][1] / a, x[2][2] / a, x[2][3] / a, x[3][0] / a, x[3][1] / a, x[3][2] / a, x[3][3] / a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::transpose() IMATH_NOEXCEPT { Matrix44 tmp (x[0][0], x[1][0], x[2][0], x[3][0], x[0][1], x[1][1], x[2][1], x[3][1], x[0][2], x[1][2], x[2][2], x[3][2], x[0][3], x[1][3], x[2][3], x[3][3]); *this = tmp; return *this; } template IMATH_HOSTDEVICE constexpr inline Matrix44 Matrix44::transposed() const IMATH_NOEXCEPT { return Matrix44 (x[0][0], x[1][0], x[2][0], x[3][0], x[0][1], x[1][1], x[2][1], x[3][1], x[0][2], x[1][2], x[2][2], x[3][2], x[0][3], x[1][3], x[2][3], x[3][3]); } template IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::gjInvert (bool singExc) { *this = gjInverse (singExc); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::gjInvert() IMATH_NOEXCEPT { *this = gjInverse(); return *this; } template inline Matrix44 Matrix44::gjInverse (bool singExc) const { int i, j, k; Matrix44 s; Matrix44 t (*this); // Forward elimination for (i = 0; i < 3; i++) { int pivot = i; T pivotsize = t.x[i][i]; if (pivotsize < 0) pivotsize = -pivotsize; for (j = i + 1; j < 4; j++) { T tmp = t.x[j][i]; if (tmp < 0) tmp = -tmp; if (tmp > pivotsize) { pivot = j; pivotsize = tmp; } } if (pivotsize == 0) { if (singExc) throw std::invalid_argument ("Cannot invert singular matrix."); return Matrix44(); } if (pivot != i) { for (j = 0; j < 4; j++) { T tmp; tmp = t.x[i][j]; t.x[i][j] = t.x[pivot][j]; t.x[pivot][j] = tmp; tmp = s.x[i][j]; s.x[i][j] = s.x[pivot][j]; s.x[pivot][j] = tmp; } } for (j = i + 1; j < 4; j++) { T f = t.x[j][i] / t.x[i][i]; for (k = 0; k < 4; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } // Backward substitution for (i = 3; i >= 0; --i) { T f; if ((f = t.x[i][i]) == 0) { if (singExc) throw std::invalid_argument ("Cannot invert singular matrix."); return Matrix44(); } for (j = 0; j < 4; j++) { t.x[i][j] /= f; s.x[i][j] /= f; } for (j = 0; j < i; j++) { f = t.x[j][i]; for (k = 0; k < 4; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } return s; } template IMATH_HOSTDEVICE inline Matrix44 Matrix44::gjInverse() const IMATH_NOEXCEPT { int i, j, k; Matrix44 s; Matrix44 t (*this); // Forward elimination for (i = 0; i < 3; i++) { int pivot = i; T pivotsize = t.x[i][i]; if (pivotsize < 0) pivotsize = -pivotsize; for (j = i + 1; j < 4; j++) { T tmp = t.x[j][i]; if (tmp < 0) tmp = -tmp; if (tmp > pivotsize) { pivot = j; pivotsize = tmp; } } if (pivotsize == 0) { return Matrix44(); } if (pivot != i) { for (j = 0; j < 4; j++) { T tmp; tmp = t.x[i][j]; t.x[i][j] = t.x[pivot][j]; t.x[pivot][j] = tmp; tmp = s.x[i][j]; s.x[i][j] = s.x[pivot][j]; s.x[pivot][j] = tmp; } } for (j = i + 1; j < 4; j++) { T f = t.x[j][i] / t.x[i][i]; for (k = 0; k < 4; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } // Backward substitution for (i = 3; i >= 0; --i) { T f; if ((f = t.x[i][i]) == 0) { return Matrix44(); } for (j = 0; j < 4; j++) { t.x[i][j] /= f; s.x[i][j] /= f; } for (j = 0; j < i; j++) { f = t.x[j][i]; for (k = 0; k < 4; k++) { t.x[j][k] -= f * t.x[i][k]; s.x[j][k] -= f * s.x[i][k]; } } } return s; } template IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::invert (bool singExc) { *this = inverse (singExc); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::invert() IMATH_NOEXCEPT { *this = inverse(); return *this; } template IMATH_CONSTEXPR14 inline Matrix44 Matrix44::inverse (bool singExc) const { if (x[0][3] != 0 || x[1][3] != 0 || x[2][3] != 0 || x[3][3] != 1) return gjInverse (singExc); Matrix44 s (x[1][1] * x[2][2] - x[2][1] * x[1][2], x[2][1] * x[0][2] - x[0][1] * x[2][2], x[0][1] * x[1][2] - x[1][1] * x[0][2], 0, x[2][0] * x[1][2] - x[1][0] * x[2][2], x[0][0] * x[2][2] - x[2][0] * x[0][2], x[1][0] * x[0][2] - x[0][0] * x[1][2], 0, x[1][0] * x[2][1] - x[2][0] * x[1][1], x[2][0] * x[0][1] - x[0][0] * x[2][1], x[0][0] * x[1][1] - x[1][0] * x[0][1], 0, 0, 0, 0, 1); T r = x[0][0] * s.x[0][0] + x[0][1] * s.x[1][0] + x[0][2] * s.x[2][0]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { s.x[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s.x[i][j])) { s.x[i][j] /= r; } else { if (singExc) throw std::invalid_argument ("Cannot invert singular matrix."); return Matrix44(); } } } } s.x[3][0] = -x[3][0] * s.x[0][0] - x[3][1] * s.x[1][0] - x[3][2] * s.x[2][0]; s.x[3][1] = -x[3][0] * s.x[0][1] - x[3][1] * s.x[1][1] - x[3][2] * s.x[2][1]; s.x[3][2] = -x[3][0] * s.x[0][2] - x[3][1] * s.x[1][2] - x[3][2] * s.x[2][2]; return s; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Matrix44 Matrix44::inverse() const IMATH_NOEXCEPT { if (x[0][3] != 0 || x[1][3] != 0 || x[2][3] != 0 || x[3][3] != 1) return gjInverse(); Matrix44 s (x[1][1] * x[2][2] - x[2][1] * x[1][2], x[2][1] * x[0][2] - x[0][1] * x[2][2], x[0][1] * x[1][2] - x[1][1] * x[0][2], 0, x[2][0] * x[1][2] - x[1][0] * x[2][2], x[0][0] * x[2][2] - x[2][0] * x[0][2], x[1][0] * x[0][2] - x[0][0] * x[1][2], 0, x[1][0] * x[2][1] - x[2][0] * x[1][1], x[2][0] * x[0][1] - x[0][0] * x[2][1], x[0][0] * x[1][1] - x[1][0] * x[0][1], 0, 0, 0, 0, 1); T r = x[0][0] * s.x[0][0] + x[0][1] * s.x[1][0] + x[0][2] * s.x[2][0]; if (IMATH_INTERNAL_NAMESPACE::abs (r) >= 1) { for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { s.x[i][j] /= r; } } } else { T mr = IMATH_INTERNAL_NAMESPACE::abs (r) / std::numeric_limits::min(); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { if (mr > IMATH_INTERNAL_NAMESPACE::abs (s.x[i][j])) { s.x[i][j] /= r; } else { return Matrix44(); } } } } s.x[3][0] = -x[3][0] * s.x[0][0] - x[3][1] * s.x[1][0] - x[3][2] * s.x[2][0]; s.x[3][1] = -x[3][0] * s.x[0][1] - x[3][1] * s.x[1][1] - x[3][2] * s.x[2][1]; s.x[3][2] = -x[3][0] * s.x[0][2] - x[3][1] * s.x[1][2] - x[3][2] * s.x[2][2]; return s; } template IMATH_HOSTDEVICE constexpr inline T Matrix44::fastMinor (const int r0, const int r1, const int r2, const int c0, const int c1, const int c2) const IMATH_NOEXCEPT { return x[r0][c0] * (x[r1][c1] * x[r2][c2] - x[r1][c2] * x[r2][c1]) + x[r0][c1] * (x[r1][c2] * x[r2][c0] - x[r1][c0] * x[r2][c2]) + x[r0][c2] * (x[r1][c0] * x[r2][c1] - x[r1][c1] * x[r2][c0]); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Matrix44::minorOf (const int r, const int c) const IMATH_NOEXCEPT { int r0 = 0 + (r < 1 ? 1 : 0); int r1 = 1 + (r < 2 ? 1 : 0); int r2 = 2 + (r < 3 ? 1 : 0); int c0 = 0 + (c < 1 ? 1 : 0); int c1 = 1 + (c < 2 ? 1 : 0); int c2 = 2 + (c < 3 ? 1 : 0); Matrix33 working (x[r0][c0], x[r1][c0], x[r2][c0], x[r0][c1], x[r1][c1], x[r2][c1], x[r0][c2], x[r1][c2], x[r2][c2]); return working.determinant(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Matrix44::determinant() const IMATH_NOEXCEPT { T sum = (T) 0; if (x[0][3] != 0.) sum -= x[0][3] * fastMinor (1, 2, 3, 0, 1, 2); if (x[1][3] != 0.) sum += x[1][3] * fastMinor (0, 2, 3, 0, 1, 2); if (x[2][3] != 0.) sum -= x[2][3] * fastMinor (0, 1, 3, 0, 1, 2); if (x[3][3] != 0.) sum += x[3][3] * fastMinor (0, 1, 2, 0, 1, 2); return sum; } template template IMATH_HOSTDEVICE inline const Matrix44& Matrix44::setEulerAngles (const Vec3& r) IMATH_NOEXCEPT { S cos_rz, sin_rz, cos_ry, sin_ry, cos_rx, sin_rx; cos_rz = cos ((T) r.z); cos_ry = cos ((T) r.y); cos_rx = cos ((T) r.x); sin_rz = sin ((T) r.z); sin_ry = sin ((T) r.y); sin_rx = sin ((T) r.x); x[0][0] = cos_rz * cos_ry; x[0][1] = sin_rz * cos_ry; x[0][2] = -sin_ry; x[0][3] = 0; x[1][0] = -sin_rz * cos_rx + cos_rz * sin_ry * sin_rx; x[1][1] = cos_rz * cos_rx + sin_rz * sin_ry * sin_rx; x[1][2] = cos_ry * sin_rx; x[1][3] = 0; x[2][0] = sin_rz * sin_rx + cos_rz * sin_ry * cos_rx; x[2][1] = -cos_rz * sin_rx + sin_rz * sin_ry * cos_rx; x[2][2] = cos_ry * cos_rx; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::setAxisAngle (const Vec3& axis, S angle) IMATH_NOEXCEPT { Vec3 unit (axis.normalized()); S sine = std::sin (angle); S cosine = std::cos (angle); x[0][0] = unit.x * unit.x * (1 - cosine) + cosine; x[0][1] = unit.x * unit.y * (1 - cosine) + unit.z * sine; x[0][2] = unit.x * unit.z * (1 - cosine) - unit.y * sine; x[0][3] = 0; x[1][0] = unit.x * unit.y * (1 - cosine) - unit.z * sine; x[1][1] = unit.y * unit.y * (1 - cosine) + cosine; x[1][2] = unit.y * unit.z * (1 - cosine) + unit.x * sine; x[1][3] = 0; x[2][0] = unit.x * unit.z * (1 - cosine) + unit.y * sine; x[2][1] = unit.y * unit.z * (1 - cosine) - unit.x * sine; x[2][2] = unit.z * unit.z * (1 - cosine) + cosine; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; return *this; } template template IMATH_HOSTDEVICE inline const Matrix44& Matrix44::rotate (const Vec3& r) IMATH_NOEXCEPT { S cos_rz, sin_rz, cos_ry, sin_ry, cos_rx, sin_rx; S m00, m01, m02; S m10, m11, m12; S m20, m21, m22; cos_rz = cos ((S) r.z); cos_ry = cos ((S) r.y); cos_rx = cos ((S) r.x); sin_rz = sin ((S) r.z); sin_ry = sin ((S) r.y); sin_rx = sin ((S) r.x); m00 = cos_rz * cos_ry; m01 = sin_rz * cos_ry; m02 = -sin_ry; m10 = -sin_rz * cos_rx + cos_rz * sin_ry * sin_rx; m11 = cos_rz * cos_rx + sin_rz * sin_ry * sin_rx; m12 = cos_ry * sin_rx; m20 = -sin_rz * -sin_rx + cos_rz * sin_ry * cos_rx; m21 = cos_rz * -sin_rx + sin_rz * sin_ry * cos_rx; m22 = cos_ry * cos_rx; Matrix44 P (*this); x[0][0] = P.x[0][0] * m00 + P.x[1][0] * m01 + P.x[2][0] * m02; x[0][1] = P.x[0][1] * m00 + P.x[1][1] * m01 + P.x[2][1] * m02; x[0][2] = P.x[0][2] * m00 + P.x[1][2] * m01 + P.x[2][2] * m02; x[0][3] = P.x[0][3] * m00 + P.x[1][3] * m01 + P.x[2][3] * m02; x[1][0] = P.x[0][0] * m10 + P.x[1][0] * m11 + P.x[2][0] * m12; x[1][1] = P.x[0][1] * m10 + P.x[1][1] * m11 + P.x[2][1] * m12; x[1][2] = P.x[0][2] * m10 + P.x[1][2] * m11 + P.x[2][2] * m12; x[1][3] = P.x[0][3] * m10 + P.x[1][3] * m11 + P.x[2][3] * m12; x[2][0] = P.x[0][0] * m20 + P.x[1][0] * m21 + P.x[2][0] * m22; x[2][1] = P.x[0][1] * m20 + P.x[1][1] * m21 + P.x[2][1] * m22; x[2][2] = P.x[0][2] * m20 + P.x[1][2] * m21 + P.x[2][2] * m22; x[2][3] = P.x[0][3] * m20 + P.x[1][3] * m21 + P.x[2][3] * m22; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::setScale (T s) IMATH_NOEXCEPT { // // Set the matrix to a 3D homogeneous transform scale: // | s 0 0 0 | // | 0 s 0 0 | // | 0 0 s 0 | // | 0 0 0 1 | // x[0][0] = s; x[0][1] = 0; x[0][2] = 0; x[0][3] = 0; x[1][0] = 0; x[1][1] = s; x[1][2] = 0; x[1][3] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = s; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::setScale (const Vec3& s) IMATH_NOEXCEPT { // // Set the matrix to a 3D homogeneous transform scale: // | s.x 0 0 0 | // | 0 s.y 0 0 | // | 0 0 s.z 0 | // | 0 0 0 1 | // x[0][0] = s.x; x[0][1] = 0; x[0][2] = 0; x[0][3] = 0; x[1][0] = 0; x[1][1] = s.y; x[1][2] = 0; x[1][3] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = s.z; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::scale (const Vec3& s) IMATH_NOEXCEPT { x[0][0] *= s.x; x[0][1] *= s.x; x[0][2] *= s.x; x[0][3] *= s.x; x[1][0] *= s.y; x[1][1] *= s.y; x[1][2] *= s.y; x[1][3] *= s.y; x[2][0] *= s.z; x[2][1] *= s.z; x[2][2] *= s.z; x[2][3] *= s.z; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::setTranslation (const Vec3& t) IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[0][3] = 0; x[1][0] = 0; x[1][1] = 1; x[1][2] = 0; x[1][3] = 0; x[2][0] = 0; x[2][1] = 0; x[2][2] = 1; x[2][3] = 0; x[3][0] = t.x; x[3][1] = t.y; x[3][2] = t.z; x[3][3] = 1; return *this; } template IMATH_HOSTDEVICE constexpr inline const Vec3 Matrix44::translation() const IMATH_NOEXCEPT { return Vec3 (x[3][0], x[3][1], x[3][2]); } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::translate (const Vec3& t) IMATH_NOEXCEPT { x[3][0] += t.x * x[0][0] + t.y * x[1][0] + t.z * x[2][0]; x[3][1] += t.x * x[0][1] + t.y * x[1][1] + t.z * x[2][1]; x[3][2] += t.x * x[0][2] + t.y * x[1][2] + t.z * x[2][2]; x[3][3] += t.x * x[0][3] + t.y * x[1][3] + t.z * x[2][3]; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::setShear (const Vec3& h) IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = 0; x[0][2] = 0; x[0][3] = 0; x[1][0] = h.x; x[1][1] = 1; x[1][2] = 0; x[1][3] = 0; x[2][0] = h.y; x[2][1] = h.z; x[2][2] = 1; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::setShear (const Shear6& h) IMATH_NOEXCEPT { x[0][0] = 1; x[0][1] = h.yx; x[0][2] = h.zx; x[0][3] = 0; x[1][0] = h.xy; x[1][1] = 1; x[1][2] = h.zy; x[1][3] = 0; x[2][0] = h.xz; x[2][1] = h.yz; x[2][2] = 1; x[2][3] = 0; x[3][0] = 0; x[3][1] = 0; x[3][2] = 0; x[3][3] = 1; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::shear (const Vec3& h) IMATH_NOEXCEPT { // // In this case, we don't need a temp. copy of the matrix // because we never use a value on the RHS after we've // changed it on the LHS. // for (int i = 0; i < 4; i++) { x[2][i] += h.y * x[0][i] + h.z * x[1][i]; x[1][i] += h.x * x[0][i]; } return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Matrix44& Matrix44::shear (const Shear6& h) IMATH_NOEXCEPT { Matrix44 P (*this); for (int i = 0; i < 4; i++) { x[0][i] = P.x[0][i] + h.yx * P.x[1][i] + h.zx * P.x[2][i]; x[1][i] = h.xy * P.x[0][i] + P.x[1][i] + h.zy * P.x[2][i]; x[2][i] = h.xz * P.x[0][i] + h.yz * P.x[1][i] + P.x[2][i]; } return *this; } //-------------------------------- // Implementation of stream output //-------------------------------- template std::ostream& operator<< (std::ostream& s, const Matrix22& m) { std::ios_base::fmtflags oldFlags = s.flags(); int width; if (s.flags() & std::ios_base::fixed) { s.setf (std::ios_base::showpoint); width = static_cast (s.precision()) + 5; } else { s.setf (std::ios_base::scientific); s.setf (std::ios_base::showpoint); width = static_cast (s.precision()) + 8; } s << "(" << std::setw (width) << m[0][0] << " " << std::setw (width) << m[0][1] << "\n" << " " << std::setw (width) << m[1][0] << " " << std::setw (width) << m[1][1] << ")\n"; s.flags (oldFlags); return s; } template std::ostream& operator<< (std::ostream& s, const Matrix33& m) { std::ios_base::fmtflags oldFlags = s.flags(); int width; if (s.flags() & std::ios_base::fixed) { s.setf (std::ios_base::showpoint); width = static_cast (s.precision()) + 5; } else { s.setf (std::ios_base::scientific); s.setf (std::ios_base::showpoint); width = static_cast (s.precision()) + 8; } s << "(" << std::setw (width) << m[0][0] << " " << std::setw (width) << m[0][1] << " " << std::setw (width) << m[0][2] << "\n" << " " << std::setw (width) << m[1][0] << " " << std::setw (width) << m[1][1] << " " << std::setw (width) << m[1][2] << "\n" << " " << std::setw (width) << m[2][0] << " " << std::setw (width) << m[2][1] << " " << std::setw (width) << m[2][2] << ")\n"; s.flags (oldFlags); return s; } template std::ostream& operator<< (std::ostream& s, const Matrix44& m) { std::ios_base::fmtflags oldFlags = s.flags(); int width; if (s.flags() & std::ios_base::fixed) { s.setf (std::ios_base::showpoint); width = static_cast (s.precision()) + 5; } else { s.setf (std::ios_base::scientific); s.setf (std::ios_base::showpoint); width = static_cast (s.precision()) + 8; } s << "(" << std::setw (width) << m[0][0] << " " << std::setw (width) << m[0][1] << " " << std::setw (width) << m[0][2] << " " << std::setw (width) << m[0][3] << "\n" << " " << std::setw (width) << m[1][0] << " " << std::setw (width) << m[1][1] << " " << std::setw (width) << m[1][2] << " " << std::setw (width) << m[1][3] << "\n" << " " << std::setw (width) << m[2][0] << " " << std::setw (width) << m[2][1] << " " << std::setw (width) << m[2][2] << " " << std::setw (width) << m[2][3] << "\n" << " " << std::setw (width) << m[3][0] << " " << std::setw (width) << m[3][1] << " " << std::setw (width) << m[3][2] << " " << std::setw (width) << m[3][3] << ")\n"; s.flags (oldFlags); return s; } //--------------------------------------------------------------- // Implementation of vector-times-matrix multiplication operators //--------------------------------------------------------------- template IMATH_HOSTDEVICE inline const Vec2& operator*= (Vec2& v, const Matrix22& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1]); v.x = x; v.y = y; return v; } template IMATH_HOSTDEVICE inline Vec2 operator* (const Vec2& v, const Matrix22& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1]); return Vec2 (x, y); } template IMATH_HOSTDEVICE inline const Vec2& operator*= (Vec2& v, const Matrix33& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + m.x[2][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + m.x[2][1]); S w = S (v.x * m.x[0][2] + v.y * m.x[1][2] + m.x[2][2]); v.x = x / w; v.y = y / w; return v; } template IMATH_HOSTDEVICE inline Vec2 operator* (const Vec2& v, const Matrix33& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + m.x[2][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + m.x[2][1]); S w = S (v.x * m.x[0][2] + v.y * m.x[1][2] + m.x[2][2]); return Vec2 (x / w, y / w); } template IMATH_HOSTDEVICE inline const Vec3& operator*= (Vec3& v, const Matrix33& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + v.z * m.x[2][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + v.z * m.x[2][1]); S z = S (v.x * m.x[0][2] + v.y * m.x[1][2] + v.z * m.x[2][2]); v.x = x; v.y = y; v.z = z; return v; } template IMATH_HOSTDEVICE inline Vec3 operator* (const Vec3& v, const Matrix33& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + v.z * m.x[2][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + v.z * m.x[2][1]); S z = S (v.x * m.x[0][2] + v.y * m.x[1][2] + v.z * m.x[2][2]); return Vec3 (x, y, z); } template IMATH_HOSTDEVICE inline const Vec3& operator*= (Vec3& v, const Matrix44& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + v.z * m.x[2][0] + m.x[3][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + v.z * m.x[2][1] + m.x[3][1]); S z = S (v.x * m.x[0][2] + v.y * m.x[1][2] + v.z * m.x[2][2] + m.x[3][2]); S w = S (v.x * m.x[0][3] + v.y * m.x[1][3] + v.z * m.x[2][3] + m.x[3][3]); v.x = x / w; v.y = y / w; v.z = z / w; return v; } template IMATH_HOSTDEVICE inline Vec3 IMATH_HOSTDEVICE operator* (const Vec3& v, const Matrix44& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + v.z * m.x[2][0] + m.x[3][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + v.z * m.x[2][1] + m.x[3][1]); S z = S (v.x * m.x[0][2] + v.y * m.x[1][2] + v.z * m.x[2][2] + m.x[3][2]); S w = S (v.x * m.x[0][3] + v.y * m.x[1][3] + v.z * m.x[2][3] + m.x[3][3]); return Vec3 (x / w, y / w, z / w); } template IMATH_HOSTDEVICE inline const Vec4& IMATH_HOSTDEVICE operator*= (Vec4& v, const Matrix44& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + v.z * m.x[2][0] + v.w * m.x[3][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + v.z * m.x[2][1] + v.w * m.x[3][1]); S z = S (v.x * m.x[0][2] + v.y * m.x[1][2] + v.z * m.x[2][2] + v.w * m.x[3][2]); S w = S (v.x * m.x[0][3] + v.y * m.x[1][3] + v.z * m.x[2][3] + v.w * m.x[3][3]); v.x = x; v.y = y; v.z = z; v.w = w; return v; } template IMATH_HOSTDEVICE inline Vec4 IMATH_HOSTDEVICE operator* (const Vec4& v, const Matrix44& m) IMATH_NOEXCEPT { S x = S (v.x * m.x[0][0] + v.y * m.x[1][0] + v.z * m.x[2][0] + v.w * m.x[3][0]); S y = S (v.x * m.x[0][1] + v.y * m.x[1][1] + v.z * m.x[2][1] + v.w * m.x[3][1]); S z = S (v.x * m.x[0][2] + v.y * m.x[1][2] + v.z * m.x[2][2] + v.w * m.x[3][2]); S w = S (v.x * m.x[0][3] + v.y * m.x[1][3] + v.z * m.x[2][3] + v.w * m.x[3][3]); return Vec4 (x, y, z, w); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHMATRIX_H Imath-3.1.4/src/Imath/ImathMatrixAlgo.cpp000066400000000000000000001223231417213455000201550ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // /// /// @file ImathMatrixAlgo.cpp /// /// @brief Functions operating on Matrix22, Matrix33, and Matrix44 types. /// // clang-format off /// @cond Doxygen_Suppress #include "ImathMatrixAlgo.h" #include #include #if defined(IMATH_DLL) # define EXPORT_CONST __declspec(dllexport) #else # define EXPORT_CONST const #endif IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER EXPORT_CONST M22f identity22f ( 1, 0, 0, 1); EXPORT_CONST M22d identity22d ( 1, 0, 0, 1); EXPORT_CONST M33f identity33f ( 1, 0, 0, 0, 1, 0, 0, 0, 1); EXPORT_CONST M33d identity33d ( 1, 0, 0, 0, 1, 0, 0, 0, 1); EXPORT_CONST M44f identity44f ( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); EXPORT_CONST M44d identity44d ( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); // clang-format on namespace { class KahanSum { public: KahanSum() : _total (0), _correction (0) {} void operator+= (const double val) { const double y = val - _correction; const double t = _total + y; _correction = (t - _total) - y; _total = t; } double get() const { return _total; } private: double _total; double _correction; }; } // namespace template M44d procrustesRotationAndTranslation (const Vec3* A, const Vec3* B, const T* weights, const size_t numPoints, const bool doScale) { if (numPoints == 0) return M44d(); // Always do the accumulation in double precision: V3d Acenter (0.0); V3d Bcenter (0.0); double weightsSum = 0.0; if (weights == 0) { for (size_t i = 0; i < numPoints; ++i) { Acenter += (V3d) A[i]; Bcenter += (V3d) B[i]; } weightsSum = (double) numPoints; } else { for (size_t i = 0; i < numPoints; ++i) { const double w = weights[i]; weightsSum += w; Acenter += w * (V3d) A[i]; Bcenter += w * (V3d) B[i]; } } if (weightsSum == 0) return M44d(); Acenter /= weightsSum; Bcenter /= weightsSum; // // Find Q such that |Q*A - B| (actually A-Acenter and B-Bcenter, weighted) // is minimized in the least squares sense. // From Golub/Van Loan, p.601 // // A,B are 3xn // Let C = B A^T (where A is 3xn and B^T is nx3, so C is 3x3) // Compute the SVD: C = U D V^T (U,V rotations, D diagonal). // Throw away the D part, and return Q = U V^T M33d C (0.0); if (weights == 0) { for (size_t i = 0; i < numPoints; ++i) C += outerProduct ((V3d) B[i] - Bcenter, (V3d) A[i] - Acenter); } else { for (size_t i = 0; i < numPoints; ++i) { const double w = weights[i]; C += outerProduct (w * ((V3d) B[i] - Bcenter), (V3d) A[i] - Acenter); } } M33d U, V; V3d S; jacobiSVD (C, U, S, V, std::numeric_limits::epsilon(), true); // We want Q.transposed() here since we are going to be using it in the // Imath style (multiplying vectors on the right, v' = v*A^T): const M33d Qt = V * U.transposed(); double s = 1.0; if (doScale && numPoints > 1) { // Finding a uniform scale: let us assume the Q is completely fixed // at this point (solving for both simultaneously seems much harder). // We are trying to compute (again, per Golub and van Loan) // min || s*A*Q - B ||_F // Notice that we've jammed a uniform scale in front of the Q. // Now, the Frobenius norm (the least squares norm over matrices) // has the neat property that it is equivalent to minimizing the trace // of M^T*M (see your friendly neighborhood linear algebra text for a // derivation). Thus, we can expand this out as // min tr (s*A*Q - B)^T*(s*A*Q - B) // = min tr(Q^T*A^T*s*s*A*Q) + tr(B^T*B) - 2*tr(Q^T*A^T*s*B) by linearity of the trace // = min s^2 tr(A^T*A) + tr(B^T*B) - 2*s*tr(Q^T*A^T*B) using the fact that the trace is invariant // under similarity transforms Q*M*Q^T // If we differentiate w.r.t. s and set this to 0, we get // 0 = 2*s*tr(A^T*A) - 2*tr(Q^T*A^T*B) // so // 2*s*tr(A^T*A) = 2*s*tr(Q^T*A^T*B) // s = tr(Q^T*A^T*B) / tr(A^T*A) KahanSum traceATA; if (weights == 0) { for (size_t i = 0; i < numPoints; ++i) traceATA += ((V3d) A[i] - Acenter).length2(); } else { for (size_t i = 0; i < numPoints; ++i) traceATA += ((double) weights[i]) * ((V3d) A[i] - Acenter).length2(); } KahanSum traceBATQ; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) traceBATQ += Qt[j][i] * C[i][j]; s = traceBATQ.get() / traceATA.get(); } // Q is the rotation part of what we want to return. // The entire transform is: // (translate origin to Bcenter) * Q * (translate Acenter to origin) // last first // The effect of this on a point is: // (translate origin to Bcenter) * Q * (translate Acenter to origin) * point // = (translate origin to Bcenter) * Q * (-Acenter + point) // = (translate origin to Bcenter) * (-Q*Acenter + Q*point) // = (translate origin to Bcenter) * (translate Q*Acenter to origin) * Q*point // = (translate Q*Acenter to Bcenter) * Q*point // So what we want to return is: // (translate Q*Acenter to Bcenter) * Q // // In block form, this is: // [ 1 0 0 | ] [ 0 ] [ 1 0 0 | ] [ 1 0 0 | ] [ | ] [ ] // [ 0 1 0 tb ] [ s*Q 0 ] [ 0 1 0 -ta ] = [ 0 1 0 tb ] [ s*Q -s*Q*ta ] = [ Q tb-s*Q*ta ] // [ 0 0 1 | ] [ 0 ] [ 0 0 1 | ] [ 0 0 1 | ] [ | ] [ ] // [ 0 0 0 1 ] [ 0 0 0 1 ] [ 0 0 0 1 ] [ 0 0 0 1 ] [ 0 0 0 1 ] [ 0 0 0 1 ] // (ofc the whole thing is transposed for Imath). const V3d translate = Bcenter - s * Acenter * Qt; return M44d (s * Qt.x[0][0], s * Qt.x[0][1], s * Qt.x[0][2], T (0), s * Qt.x[1][0], s * Qt.x[1][1], s * Qt.x[1][2], T (0), s * Qt.x[2][0], s * Qt.x[2][1], s * Qt.x[2][2], T (0), translate.x, translate.y, translate.z, T (1)); } // procrustesRotationAndTranslation /// /// Return the procrustes transformation of a set of points: the /// rotation, translation, and optionally the scale that comes closest /// in a least squares sense to transforming the `A` points into /// `B`. /// template M44d procrustesRotationAndTranslation (const Vec3* A, const Vec3* B, const size_t numPoints, const bool doScale) { return procrustesRotationAndTranslation (A, B, (const T*) 0, numPoints, doScale); } // procrustesRotationAndTranslation /// TODO template IMATH_EXPORT M44d procrustesRotationAndTranslation (const V3d* from, const V3d* to, const size_t numPoints, const bool doScale); /// TODO template IMATH_EXPORT M44d procrustesRotationAndTranslation (const V3f* from, const V3f* to, const size_t numPoints, const bool doScale); /// TODO template IMATH_EXPORT M44d procrustesRotationAndTranslation (const V3d* from, const V3d* to, const double* weights, const size_t numPoints, const bool doScale); /// TODO template IMATH_EXPORT M44d procrustesRotationAndTranslation (const V3f* from, const V3f* to, const float* weights, const size_t numPoints, const bool doScale); namespace { // Applies the 2x2 Jacobi rotation // [ c s 0 ] [ 1 0 0 ] [ c 0 s ] // [ -s c 0 ] or [ 0 c s ] or [ 0 1 0 ] // [ 0 0 1 ] [ 0 -s c ] [ -s 0 c ] // from the right; that is, computes // J * A // for the Jacobi rotation J and the matrix A. This is efficient because we // only need to touch exactly the 2 columns that are affected, so we never // need to explicitly construct the J matrix. template void jacobiRotateRight (IMATH_INTERNAL_NAMESPACE::Matrix33& A, const T c, const T s) { for (int i = 0; i < 3; ++i) { const T tau1 = A[i][j]; const T tau2 = A[i][k]; A[i][j] = c * tau1 - s * tau2; A[i][k] = s * tau1 + c * tau2; } } template void jacobiRotateRight (IMATH_INTERNAL_NAMESPACE::Matrix44& A, const int j, const int k, const T c, const T s) { for (int i = 0; i < 4; ++i) { const T tau1 = A[i][j]; const T tau2 = A[i][k]; A[i][j] = c * tau1 - s * tau2; A[i][k] = s * tau1 + c * tau2; } } // This routine solves the 2x2 SVD: // [ c1 s1 ] [ w x ] [ c2 s2 ] [ d1 0 ] // [ ] [ ] [ ] = [ ] // [ -s1 c1 ] [ y z ] [ -s2 c2 ] [ 0 d2 ] // where // [ w x ] // A = [ ] // [ y z ] // is the subset of A consisting of the [j,k] entries, A([j k], [j k]) in // Matlab parlance. The method is the 'USVD' algorithm described in the // following paper: // 'Computation of the Singular Value Decomposition using Mesh-Connected Processors' // by Richard P. Brent, Franklin T. Luk, and Charles Van Loan // It breaks the computation into two steps: the first symmetrizes the matrix, // and the second diagonalizes the symmetric matrix. template bool twoSidedJacobiRotation (IMATH_INTERNAL_NAMESPACE::Matrix33& A, IMATH_INTERNAL_NAMESPACE::Matrix33& U, IMATH_INTERNAL_NAMESPACE::Matrix33& V, const T tol) { // Load everything into local variables to make things easier on the // optimizer: const T w = A[j][j]; const T x = A[j][k]; const T y = A[k][j]; const T z = A[k][k]; // We will keep track of whether we're actually performing any rotations, // since if the matrix is already diagonal we'll end up with the identity // as our Jacobi rotation and we can short-circuit. bool changed = false; // The first step is to symmetrize the 2x2 matrix, // [ c s ]^T [ w x ] = [ p q ] // [ -s c ] [ y z ] [ q r ] T mu_1 = w + z; T mu_2 = x - y; T c, s; if (std::abs (mu_2) <= tol * std::abs (mu_1)) // Already symmetric (to tolerance) { // Note that the <= is important here c = T (1); // because we want to bypass the computation s = T (0); // of rho if mu_1 = mu_2 = 0. const T p = w; const T r = z; mu_1 = r - p; mu_2 = x + y; } else { // TODO is there a native inverse square root function? const T rho = mu_1 / mu_2; s = T (1) / std::sqrt (T (1) + rho * rho); if (rho < 0) s = -s; c = s * rho; mu_1 = s * (x + y) + c * (z - w); // = r - p mu_2 = T (2) * (c * x - s * z); // = 2*q changed = true; } // The second stage diagonalizes, // [ c2 s2 ]^T [ p q ] [ c2 s2 ] = [ d1 0 ] // [ -s2 c2 ] [ q r ] [ -s2 c2 ] [ 0 d2 ] T c_2, s_2; if (std::abs (mu_2) <= tol * std::abs (mu_1)) { c_2 = T (1); s_2 = T (0); } else { const T rho_2 = mu_1 / mu_2; T t_2 = T (1) / (std::abs (rho_2) + std::sqrt (1 + rho_2 * rho_2)); if (rho_2 < 0) t_2 = -t_2; c_2 = T (1) / std::sqrt (T (1) + t_2 * t_2); s_2 = c_2 * t_2; changed = true; } const T c_1 = c_2 * c - s_2 * s; const T s_1 = s_2 * c + c_2 * s; if (!changed) { // We've decided that the off-diagonal entries are already small // enough, so we'll set them to zero. This actually appears to result // in smaller errors than leaving them be, possibly because it prevents // us from trying to do extra rotations later that we don't need. A[k][j] = 0; A[j][k] = 0; return false; } const T d_1 = c_1 * (w * c_2 - x * s_2) - s_1 * (y * c_2 - z * s_2); const T d_2 = s_1 * (w * s_2 + x * c_2) + c_1 * (y * s_2 + z * c_2); // For the entries we just zeroed out, we'll just set them to 0, since // they should be 0 up to machine precision. A[j][j] = d_1; A[k][k] = d_2; A[k][j] = 0; A[j][k] = 0; // Rotate the entries that _weren't_ involved in the 2x2 SVD: { // Rotate on the left by // [ c1 s1 0 ]^T [ c1 0 s1 ]^T [ 1 0 0 ]^T // [ -s1 c1 0 ] or [ 0 1 0 ] or [ 0 c1 s1 ] // [ 0 0 1 ] [ -s1 0 c1 ] [ 0 -s1 c1 ] // This has the effect of adding the (weighted) ith and jth _rows_ to // each other. const T tau1 = A[j][l]; const T tau2 = A[k][l]; A[j][l] = c_1 * tau1 - s_1 * tau2; A[k][l] = s_1 * tau1 + c_1 * tau2; } { // Rotate on the right by // [ c2 s2 0 ] [ c2 0 s2 ] [ 1 0 0 ] // [ -s2 c2 0 ] or [ 0 1 0 ] or [ 0 c2 s2 ] // [ 0 0 1 ] [ -s2 0 c2 ] [ 0 -s2 c2 ] // This has the effect of adding the (weighted) ith and jth _columns_ to // each other. const T tau1 = A[l][j]; const T tau2 = A[l][k]; A[l][j] = c_2 * tau1 - s_2 * tau2; A[l][k] = s_2 * tau1 + c_2 * tau2; } // Now apply the rotations to U and V: // Remember that we have // R1^T * A * R2 = D // This is in the 2x2 case, but after doing a bunch of these // we will get something like this for the 3x3 case: // ... R1b^T * R1a^T * A * R2a * R2b * ... = D // ----------------- --------------- // = U^T = V // So, // U = R1a * R1b * ... // V = R2a * R2b * ... jacobiRotateRight (U, c_1, s_1); jacobiRotateRight (V, c_2, s_2); return true; } template bool twoSidedJacobiRotation (IMATH_INTERNAL_NAMESPACE::Matrix44& A, int j, int k, IMATH_INTERNAL_NAMESPACE::Matrix44& U, IMATH_INTERNAL_NAMESPACE::Matrix44& V, const T tol) { // Load everything into local variables to make things easier on the // optimizer: const T w = A[j][j]; const T x = A[j][k]; const T y = A[k][j]; const T z = A[k][k]; // We will keep track of whether we're actually performing any rotations, // since if the matrix is already diagonal we'll end up with the identity // as our Jacobi rotation and we can short-circuit. bool changed = false; // The first step is to symmetrize the 2x2 matrix, // [ c s ]^T [ w x ] = [ p q ] // [ -s c ] [ y z ] [ q r ] T mu_1 = w + z; T mu_2 = x - y; T c, s; if (std::abs (mu_2) <= tol * std::abs (mu_1)) // Already symmetric (to tolerance) { // Note that the <= is important here c = T (1); // because we want to bypass the computation s = T (0); // of rho if mu_1 = mu_2 = 0. const T p = w; const T r = z; mu_1 = r - p; mu_2 = x + y; } else { // TODO is there a native inverse square root function? const T rho = mu_1 / mu_2; s = T (1) / std::sqrt (T (1) + rho * rho); if (rho < 0) s = -s; c = s * rho; mu_1 = s * (x + y) + c * (z - w); // = r - p mu_2 = T (2) * (c * x - s * z); // = 2*q changed = true; } // The second stage diagonalizes, // [ c2 s2 ]^T [ p q ] [ c2 s2 ] = [ d1 0 ] // [ -s2 c2 ] [ q r ] [ -s2 c2 ] [ 0 d2 ] T c_2, s_2; if (std::abs (mu_2) <= tol * std::abs (mu_1)) { c_2 = T (1); s_2 = T (0); } else { const T rho_2 = mu_1 / mu_2; T t_2 = T (1) / (std::abs (rho_2) + std::sqrt (1 + rho_2 * rho_2)); if (rho_2 < 0) t_2 = -t_2; c_2 = T (1) / std::sqrt (T (1) + t_2 * t_2); s_2 = c_2 * t_2; changed = true; } const T c_1 = c_2 * c - s_2 * s; const T s_1 = s_2 * c + c_2 * s; if (!changed) { // We've decided that the off-diagonal entries are already small // enough, so we'll set them to zero. This actually appears to result // in smaller errors than leaving them be, possibly because it prevents // us from trying to do extra rotations later that we don't need. A[k][j] = 0; A[j][k] = 0; return false; } const T d_1 = c_1 * (w * c_2 - x * s_2) - s_1 * (y * c_2 - z * s_2); const T d_2 = s_1 * (w * s_2 + x * c_2) + c_1 * (y * s_2 + z * c_2); // For the entries we just zeroed out, we'll just set them to 0, since // they should be 0 up to machine precision. A[j][j] = d_1; A[k][k] = d_2; A[k][j] = 0; A[j][k] = 0; // Rotate the entries that _weren't_ involved in the 2x2 SVD: for (int l = 0; l < 4; ++l) { if (l == j || l == k) continue; // Rotate on the left by // [ 1 ] // [ . ] // [ c2 s2 ] j // [ 1 ] // [ -s2 c2 ] k // [ . ] // [ 1 ] // j k // // This has the effect of adding the (weighted) ith and jth _rows_ to // each other. const T tau1 = A[j][l]; const T tau2 = A[k][l]; A[j][l] = c_1 * tau1 - s_1 * tau2; A[k][l] = s_1 * tau1 + c_1 * tau2; } for (int l = 0; l < 4; ++l) { // We set the A[j/k][j/k] entries already if (l == j || l == k) continue; // Rotate on the right by // [ 1 ] // [ . ] // [ c2 s2 ] j // [ 1 ] // [ -s2 c2 ] k // [ . ] // [ 1 ] // j k // // This has the effect of adding the (weighted) ith and jth _columns_ to // each other. const T tau1 = A[l][j]; const T tau2 = A[l][k]; A[l][j] = c_2 * tau1 - s_2 * tau2; A[l][k] = s_2 * tau1 + c_2 * tau2; } // Now apply the rotations to U and V: // Remember that we have // R1^T * A * R2 = D // This is in the 2x2 case, but after doing a bunch of these // we will get something like this for the 3x3 case: // ... R1b^T * R1a^T * A * R2a * R2b * ... = D // ----------------- --------------- // = U^T = V // So, // U = R1a * R1b * ... // V = R2a * R2b * ... jacobiRotateRight (U, j, k, c_1, s_1); jacobiRotateRight (V, j, k, c_2, s_2); return true; } template void swapColumns (IMATH_INTERNAL_NAMESPACE::Matrix33& A, int j, int k) { for (int i = 0; i < 3; ++i) std::swap (A[i][j], A[i][k]); } template IMATH_CONSTEXPR14 T maxOffDiag (const IMATH_INTERNAL_NAMESPACE::Matrix33& A) { T result = 0; result = std::max (result, std::abs (A[0][1])); result = std::max (result, std::abs (A[0][2])); result = std::max (result, std::abs (A[1][0])); result = std::max (result, std::abs (A[1][2])); result = std::max (result, std::abs (A[2][0])); result = std::max (result, std::abs (A[2][1])); return result; } template IMATH_CONSTEXPR14 T maxOffDiag (const IMATH_INTERNAL_NAMESPACE::Matrix44& A) { T result = 0; for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) { if (i != j) result = std::max (result, std::abs (A[i][j])); } } return result; } template void twoSidedJacobiSVD (IMATH_INTERNAL_NAMESPACE::Matrix33 A, IMATH_INTERNAL_NAMESPACE::Matrix33& U, IMATH_INTERNAL_NAMESPACE::Vec3& S, IMATH_INTERNAL_NAMESPACE::Matrix33& V, const T tol, const bool forcePositiveDeterminant) { // The two-sided Jacobi SVD works by repeatedly zeroing out // off-diagonal entries of the matrix, 2 at a time. Basically, // we can take our 3x3 matrix, // [* * *] // [* * *] // [* * *] // and use a pair of orthogonal transforms to zero out, say, the // pair of entries (0, 1) and (1, 0): // [ c1 s1 ] [* * *] [ c2 s2 ] [* *] // [-s1 c1 ] [* * *] [-s2 c2 ] = [ * *] // [ 1] [* * *] [ 1] [* * *] // When we go to zero out the next pair of entries (say, (0, 2) and (2, 0)) // then we don't expect those entries to stay 0: // [ c1 s1 ] [* *] [ c2 s2 ] [* * ] // [-s1 c1 ] [ * *] [-s2 c2 ] = [* * *] // [ 1] [* * *] [ 1] [ * *] // However, if we keep doing this, we'll find that the off-diagonal entries // converge to 0 fairly quickly (convergence should be roughly cubic). The // result is a diagonal A matrix and a bunch of orthogonal transforms: // [* * *] [* ] // L1 L2 ... Ln [* * *] Rn ... R2 R1 = [ * ] // [* * *] [ *] // ------------ ------- ------------ ------- // U^T A V S // This turns out to be highly accurate because (1) orthogonal transforms // are extremely stable to compute and apply (this is why QR factorization // works so well, FWIW) and because (2) by applying everything to the original // matrix A instead of computing (A^T * A) we avoid any precision loss that // would result from that. U.makeIdentity(); V.makeIdentity(); const int maxIter = 20; // In case we get really unlucky, prevents infinite loops const T absTol = tol * maxOffDiag (A); // Tolerance is in terms of the maximum if (absTol != 0) // _off-diagonal_ entry. { int numIter = 0; do { ++numIter; bool changed = twoSidedJacobiRotation (A, U, V, tol); changed = twoSidedJacobiRotation (A, U, V, tol) || changed; changed = twoSidedJacobiRotation (A, U, V, tol) || changed; if (!changed) break; } while (maxOffDiag (A) > absTol && numIter < maxIter); } // The off-diagonal entries are (effectively) 0, so whatever's left on the // diagonal are the singular values: S.x = A[0][0]; S.y = A[1][1]; S.z = A[2][2]; // Nothing thus far has guaranteed that the singular values are positive, // so let's go back through and flip them if not (since by contract we are // supposed to return all positive SVs): for (int i = 0; i < 3; ++i) { if (S[i] < 0) { // If we flip S[i], we need to flip the corresponding column of U // (we could also pick V if we wanted; it doesn't really matter): S[i] = -S[i]; for (int j = 0; j < 3; ++j) U[j][i] = -U[j][i]; } } // Order the singular values from largest to smallest; this requires // exactly two passes through the data using bubble sort: for (int i = 0; i < 2; ++i) { for (int j = 0; j < (2 - i); ++j) { // No absolute values necessary since we already ensured that // they're positive: if (S[j] < S[j + 1]) { // If we swap singular values we also have to swap // corresponding columns in U and V: std::swap (S[j], S[j + 1]); swapColumns (U, j, j + 1); swapColumns (V, j, j + 1); } } } if (forcePositiveDeterminant) { // We want to guarantee that the returned matrices always have positive // determinant. We can do this by adding the appropriate number of // matrices of the form: // [ 1 ] // L = [ 1 ] // [ -1 ] // Note that L' = L and L*L = Identity. Thus we can add: // U*L*L*S*V = (U*L)*(L*S)*V // if U has a negative determinant, and // U*S*L*L*V = U*(S*L)*(L*V) // if V has a neg. determinant. if (U.determinant() < 0) { for (int i = 0; i < 3; ++i) U[i][2] = -U[i][2]; S.z = -S.z; } if (V.determinant() < 0) { for (int i = 0; i < 3; ++i) V[i][2] = -V[i][2]; S.z = -S.z; } } } template void twoSidedJacobiSVD (IMATH_INTERNAL_NAMESPACE::Matrix44 A, IMATH_INTERNAL_NAMESPACE::Matrix44& U, IMATH_INTERNAL_NAMESPACE::Vec4& S, IMATH_INTERNAL_NAMESPACE::Matrix44& V, const T tol, const bool forcePositiveDeterminant) { // Please see the Matrix33 version for a detailed description of the algorithm. U.makeIdentity(); V.makeIdentity(); const int maxIter = 20; // In case we get really unlucky, prevents infinite loops const T absTol = tol * maxOffDiag (A); // Tolerance is in terms of the maximum if (absTol != 0) // _off-diagonal_ entry. { int numIter = 0; do { ++numIter; bool changed = twoSidedJacobiRotation (A, 0, 1, U, V, tol); changed = twoSidedJacobiRotation (A, 0, 2, U, V, tol) || changed; changed = twoSidedJacobiRotation (A, 0, 3, U, V, tol) || changed; changed = twoSidedJacobiRotation (A, 1, 2, U, V, tol) || changed; changed = twoSidedJacobiRotation (A, 1, 3, U, V, tol) || changed; changed = twoSidedJacobiRotation (A, 2, 3, U, V, tol) || changed; if (!changed) break; } while (maxOffDiag (A) > absTol && numIter < maxIter); } // The off-diagonal entries are (effectively) 0, so whatever's left on the // diagonal are the singular values: S[0] = A[0][0]; S[1] = A[1][1]; S[2] = A[2][2]; S[3] = A[3][3]; // Nothing thus far has guaranteed that the singular values are positive, // so let's go back through and flip them if not (since by contract we are // supposed to return all positive SVs): for (int i = 0; i < 4; ++i) { if (S[i] < 0) { // If we flip S[i], we need to flip the corresponding column of U // (we could also pick V if we wanted; it doesn't really matter): S[i] = -S[i]; for (int j = 0; j < 4; ++j) U[j][i] = -U[j][i]; } } // Order the singular values from largest to smallest using insertion sort: for (int i = 1; i < 4; ++i) { const IMATH_INTERNAL_NAMESPACE::Vec4 uCol (U[0][i], U[1][i], U[2][i], U[3][i]); const IMATH_INTERNAL_NAMESPACE::Vec4 vCol (V[0][i], V[1][i], V[2][i], V[3][i]); const T sVal = S[i]; int j = i - 1; while (std::abs (S[j]) < std::abs (sVal)) { for (int k = 0; k < 4; ++k) U[k][j + 1] = U[k][j]; for (int k = 0; k < 4; ++k) V[k][j + 1] = V[k][j]; S[j + 1] = S[j]; --j; if (j < 0) break; } for (int k = 0; k < 4; ++k) U[k][j + 1] = uCol[k]; for (int k = 0; k < 4; ++k) V[k][j + 1] = vCol[k]; S[j + 1] = sVal; } if (forcePositiveDeterminant) { // We want to guarantee that the returned matrices always have positive // determinant. We can do this by adding the appropriate number of // matrices of the form: // [ 1 ] // L = [ 1 ] // [ 1 ] // [ -1 ] // Note that L' = L and L*L = Identity. Thus we can add: // U*L*L*S*V = (U*L)*(L*S)*V // if U has a negative determinant, and // U*S*L*L*V = U*(S*L)*(L*V) // if V has a neg. determinant. if (U.determinant() < 0) { for (int i = 0; i < 4; ++i) U[i][3] = -U[i][3]; S[3] = -S[3]; } if (V.determinant() < 0) { for (int i = 0; i < 4; ++i) V[i][3] = -V[i][3]; S[3] = -S[3]; } } } } // namespace /// TODO template void jacobiSVD (const IMATH_INTERNAL_NAMESPACE::Matrix33& A, IMATH_INTERNAL_NAMESPACE::Matrix33& U, IMATH_INTERNAL_NAMESPACE::Vec3& S, IMATH_INTERNAL_NAMESPACE::Matrix33& V, const T tol, const bool forcePositiveDeterminant) { twoSidedJacobiSVD (A, U, S, V, tol, forcePositiveDeterminant); } /// TODO template void jacobiSVD (const IMATH_INTERNAL_NAMESPACE::Matrix44& A, IMATH_INTERNAL_NAMESPACE::Matrix44& U, IMATH_INTERNAL_NAMESPACE::Vec4& S, IMATH_INTERNAL_NAMESPACE::Matrix44& V, const T tol, const bool forcePositiveDeterminant) { twoSidedJacobiSVD (A, U, S, V, tol, forcePositiveDeterminant); } /// TODO template IMATH_EXPORT void jacobiSVD (const IMATH_INTERNAL_NAMESPACE::Matrix33& A, IMATH_INTERNAL_NAMESPACE::Matrix33& U, IMATH_INTERNAL_NAMESPACE::Vec3& S, IMATH_INTERNAL_NAMESPACE::Matrix33& V, const float tol, const bool forcePositiveDeterminant); /// TODO template IMATH_EXPORT void jacobiSVD (const IMATH_INTERNAL_NAMESPACE::Matrix33& A, IMATH_INTERNAL_NAMESPACE::Matrix33& U, IMATH_INTERNAL_NAMESPACE::Vec3& S, IMATH_INTERNAL_NAMESPACE::Matrix33& V, const double tol, const bool forcePositiveDeterminant); /// TODO template IMATH_EXPORT void jacobiSVD (const IMATH_INTERNAL_NAMESPACE::Matrix44& A, IMATH_INTERNAL_NAMESPACE::Matrix44& U, IMATH_INTERNAL_NAMESPACE::Vec4& S, IMATH_INTERNAL_NAMESPACE::Matrix44& V, const float tol, const bool forcePositiveDeterminant); /// TODO template IMATH_EXPORT void jacobiSVD (const IMATH_INTERNAL_NAMESPACE::Matrix44& A, IMATH_INTERNAL_NAMESPACE::Matrix44& U, IMATH_INTERNAL_NAMESPACE::Vec4& S, IMATH_INTERNAL_NAMESPACE::Matrix44& V, const double tol, const bool forcePositiveDeterminant); namespace { template inline void jacobiRotateRight (TM& A, const typename TM::BaseType s, const typename TM::BaseType tau) { typedef typename TM::BaseType T; for (unsigned int i = 0; i < TM::dimensions(); ++i) { const T nu1 = A[i][j]; const T nu2 = A[i][k]; A[i][j] -= s * (nu2 + tau * nu1); A[i][k] += s * (nu1 - tau * nu2); } } template bool jacobiRotation (Matrix33& A, Matrix33& V, Vec3& Z, const T tol) { // Load everything into local variables to make things easier on the // optimizer: const T x = A[j][j]; const T y = A[j][k]; const T z = A[k][k]; // The first stage diagonalizes, // [ c s ]^T [ x y ] [ c -s ] = [ d1 0 ] // [ -s c ] [ y z ] [ s c ] [ 0 d2 ] const T mu1 = z - x; const T mu2 = 2 * y; if (std::abs (mu2) <= tol * std::abs (mu1)) { // We've decided that the off-diagonal entries are already small // enough, so we'll set them to zero. This actually appears to result // in smaller errors than leaving them be, possibly because it prevents // us from trying to do extra rotations later that we don't need. A[j][k] = 0; return false; } const T rho = mu1 / mu2; const T t = (rho < 0 ? T (-1) : T (1)) / (std::abs (rho) + std::sqrt (1 + rho * rho)); const T c = T (1) / std::sqrt (T (1) + t * t); const T s = t * c; const T tau = s / (T (1) + c); const T h = t * y; // Update diagonal elements. Z[j] -= h; Z[k] += h; A[j][j] -= h; A[k][k] += h; // For the entries we just zeroed out, we'll just set them to 0, since // they should be 0 up to machine precision. A[j][k] = 0; // We only update upper triagnular elements of A, since // A is supposed to be symmetric. T& offd1 = l < j ? A[l][j] : A[j][l]; T& offd2 = l < k ? A[l][k] : A[k][l]; const T nu1 = offd1; const T nu2 = offd2; offd1 = nu1 - s * (nu2 + tau * nu1); offd2 = nu2 + s * (nu1 - tau * nu2); // Apply rotation to V jacobiRotateRight (V, s, tau); return true; } template bool jacobiRotation (Matrix44& A, Matrix44& V, Vec4& Z, const T tol) { const T x = A[j][j]; const T y = A[j][k]; const T z = A[k][k]; const T mu1 = z - x; const T mu2 = T (2) * y; // Let's see if rho^(-1) = mu2 / mu1 is less than tol // This test also checks if rho^2 will overflow // when tol^(-1) < sqrt(std::numeric_limits::max()). if (std::abs (mu2) <= tol * std::abs (mu1)) { A[j][k] = 0; return true; } const T rho = mu1 / mu2; const T t = (rho < 0 ? T (-1) : T (1)) / (std::abs (rho) + std::sqrt (1 + rho * rho)); const T c = T (1) / std::sqrt (T (1) + t * t); const T s = c * t; const T tau = s / (T (1) + c); const T h = t * y; Z[j] -= h; Z[k] += h; A[j][j] -= h; A[k][k] += h; A[j][k] = 0; { T& offd1 = l1 < j ? A[l1][j] : A[j][l1]; T& offd2 = l1 < k ? A[l1][k] : A[k][l1]; const T nu1 = offd1; const T nu2 = offd2; offd1 -= s * (nu2 + tau * nu1); offd2 += s * (nu1 - tau * nu2); } { T& offd1 = l2 < j ? A[l2][j] : A[j][l2]; T& offd2 = l2 < k ? A[l2][k] : A[k][l2]; const T nu1 = offd1; const T nu2 = offd2; offd1 -= s * (nu2 + tau * nu1); offd2 += s * (nu1 - tau * nu2); } jacobiRotateRight (V, s, tau); return true; } template IMATH_CONSTEXPR14 inline typename TM::BaseType maxOffDiagSymm (const TM& A) { typedef typename TM::BaseType T; T result = 0; for (unsigned int i = 0; i < TM::dimensions(); ++i) for (unsigned int j = i + 1; j < TM::dimensions(); ++j) result = std::max (result, std::abs (A[i][j])); return result; } } // namespace template void jacobiEigenSolver (Matrix33& A, Vec3& S, Matrix33& V, const T tol) { V.makeIdentity(); for (int i = 0; i < 3; ++i) { S[i] = A[i][i]; } const int maxIter = 20; // In case we get really unlucky, prevents infinite loops const T absTol = tol * maxOffDiagSymm (A); // Tolerance is in terms of the maximum if (absTol != 0) // _off-diagonal_ entry. { int numIter = 0; do { // Z is for accumulating small changes (h) to diagonal entries // of A for one sweep. Adding h's directly to A might cause // a cancellation effect when h is relatively very small to // the corresponding diagonal entry of A and // this will increase numerical errors Vec3 Z (0, 0, 0); ++numIter; bool changed = jacobiRotation<0, 1, 2> (A, V, Z, tol); changed = jacobiRotation<0, 2, 1> (A, V, Z, tol) || changed; changed = jacobiRotation<1, 2, 0> (A, V, Z, tol) || changed; // One sweep passed. Add accumulated changes (Z) to singular values (S) // Update diagonal elements of A for better accuracy as well. for (int i = 0; i < 3; ++i) { A[i][i] = S[i] += Z[i]; } if (!changed) break; } while (maxOffDiagSymm (A) > absTol && numIter < maxIter); } } template void jacobiEigenSolver (Matrix44& A, Vec4& S, Matrix44& V, const T tol) { V.makeIdentity(); for (int i = 0; i < 4; ++i) { S[i] = A[i][i]; } const int maxIter = 20; // In case we get really unlucky, prevents infinite loops const T absTol = tol * maxOffDiagSymm (A); // Tolerance is in terms of the maximum if (absTol != 0) // _off-diagonal_ entry. { int numIter = 0; do { ++numIter; Vec4 Z (0, 0, 0, 0); bool changed = jacobiRotation<0, 1, 2, 3> (A, V, Z, tol); changed = jacobiRotation<0, 2, 1, 3> (A, V, Z, tol) || changed; changed = jacobiRotation<0, 3, 1, 2> (A, V, Z, tol) || changed; changed = jacobiRotation<1, 2, 0, 3> (A, V, Z, tol) || changed; changed = jacobiRotation<1, 3, 0, 2> (A, V, Z, tol) || changed; changed = jacobiRotation<2, 3, 0, 1> (A, V, Z, tol) || changed; for (int i = 0; i < 4; ++i) { A[i][i] = S[i] += Z[i]; } if (!changed) break; } while (maxOffDiagSymm (A) > absTol && numIter < maxIter); } } template void maxEigenVector (TM& A, TV& V) { TV S; TM MV; jacobiEigenSolver (A, S, MV); int maxIdx (0); for (unsigned int i = 1; i < TV::dimensions(); ++i) { if (std::abs (S[i]) > std::abs (S[maxIdx])) maxIdx = i; } for (unsigned int i = 0; i < TV::dimensions(); ++i) V[i] = MV[i][maxIdx]; } template void minEigenVector (TM& A, TV& V) { TV S; TM MV; jacobiEigenSolver (A, S, MV); int minIdx (0); for (unsigned int i = 1; i < TV::dimensions(); ++i) { if (std::abs (S[i]) < std::abs (S[minIdx])) minIdx = i; } for (unsigned int i = 0; i < TV::dimensions(); ++i) V[i] = MV[i][minIdx]; } template IMATH_EXPORT void jacobiEigenSolver (Matrix33& A, Vec3& S, Matrix33& V, const float tol); template IMATH_EXPORT void jacobiEigenSolver (Matrix33& A, Vec3& S, Matrix33& V, const double tol); template IMATH_EXPORT void jacobiEigenSolver (Matrix44& A, Vec4& S, Matrix44& V, const float tol); template IMATH_EXPORT void jacobiEigenSolver (Matrix44& A, Vec4& S, Matrix44& V, const double tol); template IMATH_EXPORT void maxEigenVector (Matrix33& A, Vec3& S); template IMATH_EXPORT void maxEigenVector (Matrix44& A, Vec4& S); template IMATH_EXPORT void maxEigenVector (Matrix33& A, Vec3& S); template IMATH_EXPORT void maxEigenVector (Matrix44& A, Vec4& S); template IMATH_EXPORT void minEigenVector (Matrix33& A, Vec3& S); template IMATH_EXPORT void minEigenVector (Matrix44& A, Vec4& S); template IMATH_EXPORT void minEigenVector (Matrix33& A, Vec3& S); template IMATH_EXPORT void minEigenVector (Matrix44& A, Vec4& S); IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT /// @endcond Imath-3.1.4/src/Imath/ImathMatrixAlgo.h000066400000000000000000001334031417213455000176230ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // // Functions operating on Matrix22, Matrix33, and Matrix44 types // // This file also defines a few predefined constant matrices. // #ifndef INCLUDED_IMATHMATRIXALGO_H #define INCLUDED_IMATHMATRIXALGO_H #include "ImathEuler.h" #include "ImathExport.h" #include "ImathMatrix.h" #include "ImathNamespace.h" #include "ImathQuat.h" #include "ImathVec.h" #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER //------------------ // Identity matrices //------------------ /// M22f identity matrix IMATH_EXPORT_CONST M22f identity22f; /// M33f identity matrix IMATH_EXPORT_CONST M33f identity33f; /// M44f identity matrix IMATH_EXPORT_CONST M44f identity44f; /// M22d identity matrix IMATH_EXPORT_CONST M22d identity22d; /// M33d identity matrix IMATH_EXPORT_CONST M33d identity33d; /// M44d identity matrix IMATH_EXPORT_CONST M44d identity44d; //---------------------------------------------------------------------- // Extract scale, shear, rotation, and translation values from a matrix: // // Notes: // // This implementation follows the technique described in the paper by // Spencer W. Thomas in the Graphics Gems II article: "Decomposing a // Matrix into Simple Transformations", p. 320. // // - Some of the functions below have an optional exc parameter // that determines the functions' behavior when the matrix' // scaling is very close to zero: // // If exc is true, the functions throw a std::domain_error exception. // // If exc is false: // // extractScaling (m, s) returns false, s is invalid // sansScaling (m) returns m // removeScaling (m) returns false, m is unchanged // sansScalingAndShear (m) returns m // removeScalingAndShear (m) returns false, m is unchanged // extractAndRemoveScalingAndShear (m, s, h) // returns false, m is unchanged, // (sh) are invalid // checkForZeroScaleInRow () returns false // extractSHRT (m, s, h, r, t) returns false, (shrt) are invalid // // - Functions extractEuler(), extractEulerXYZ() and extractEulerZYX() // assume that the matrix does not include shear or non-uniform scaling, // but they do not examine the matrix to verify this assumption. // Matrices with shear or non-uniform scaling are likely to produce // meaningless results. Therefore, you should use the // removeScalingAndShear() routine, if necessary, prior to calling // extractEuler...() . // // - All functions assume that the matrix does not include perspective // transformation(s), but they do not examine the matrix to verify // this assumption. Matrices with perspective transformations are // likely to produce meaningless results. // //---------------------------------------------------------------------- // // Declarations for 4x4 matrix. // /// Extract the scaling component of the given 4x4 matrix. /// /// @param[in] mat The input matrix /// @param[out] scl The extracted scale, i.e. the output value /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool extractScaling (const Matrix44& mat, Vec3& scl, bool exc = true); /// Return the given 4x4 matrix with scaling removed. /// /// @param[in] mat The input matrix /// @param[in] exc If true, throw an exception if the scaling in `mat` template Matrix44 sansScaling (const Matrix44& mat, bool exc = true); /// Remove scaling from the given 4x4 matrix in place. Return true if the /// scale could be successfully extracted, false if the matrix is /// degenerate. // /// @param[in] mat The matrix to operate on /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool removeScaling (Matrix44& mat, bool exc = true); /// Extract the scaling and shear components of the given 4x4 matrix. /// Return true if the scale could be successfully extracted, false if /// the matrix is degenerate. /// /// @param[in] mat The input matrix /// @param[out] scl The extracted scale /// @param[out] shr The extracted shear /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool extractScalingAndShear (const Matrix44& mat, Vec3& scl, Vec3& shr, bool exc = true); /// Return the given 4x4 matrix with scaling and shear removed. /// /// @param[in] mat The input matrix /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. template Matrix44 sansScalingAndShear (const Matrix44& mat, bool exc = true); /// Extract scaling and shear from the given 4x4 matrix in-place. /// /// @param[in,out] result The output matrix /// @param[in] mat The return value if `result` is degenerate /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. template void sansScalingAndShear (Matrix44& result, const Matrix44& mat, bool exc = true); /// Remove scaling and shear from the given 4x4 matrix in place. // /// @param[in,out] mat The matrix to operate on /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool removeScalingAndShear (Matrix44& mat, bool exc = true); /// Remove scaling and shear from the given 4x4 matrix in place, returning /// the extracted values. // /// @param[in,out] mat The matrix to operate on /// @param[out] scl The extracted scale /// @param[out] shr The extracted shear /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool extractAndRemoveScalingAndShear (Matrix44& mat, Vec3& scl, Vec3& shr, bool exc = true); /// Extract the rotation from the given 4x4 matrix in the form of XYZ /// euler angles. /// /// @param[in] mat The input matrix /// @param[out] rot The extracted XYZ euler angle vector template void extractEulerXYZ (const Matrix44& mat, Vec3& rot); /// Extract the rotation from the given 4x4 matrix in the form of ZYX /// euler angles. /// /// @param[in] mat The input matrix /// @param[out] rot The extracted ZYX euler angle vector template void extractEulerZYX (const Matrix44& mat, Vec3& rot); /// Extract the rotation from the given 4x4 matrix in the form of a quaternion. /// /// @param[in] mat The input matrix /// @return The extracted quaternion template Quat extractQuat (const Matrix44& mat); /// Extract the scaling, shear, rotation, and translation components /// of the given 4x4 matrix. The values are such that: /// /// M = S * H * R * T /// /// @param[in] mat The input matrix /// @param[out] s The extracted scale /// @param[out] h The extracted shear /// @param[out] r The extracted rotation /// @param[out] t The extracted translation /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @param[in] rOrder The order with which to extract the rotation /// @return True if the values could be extracted, false if the matrix is degenerate. template bool extractSHRT (const Matrix44& mat, Vec3& s, Vec3& h, Vec3& r, Vec3& t, bool exc /*= true*/, typename Euler::Order rOrder); /// Extract the scaling, shear, rotation, and translation components /// of the given 4x4 matrix. /// /// @param[in] mat The input matrix /// @param[out] s The extracted scale /// @param[out] h The extracted shear /// @param[out] r The extracted rotation, in XYZ euler angles /// @param[out] t The extracted translation /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the values could be extracted, false if the matrix is degenerate. template bool extractSHRT (const Matrix44& mat, Vec3& s, Vec3& h, Vec3& r, Vec3& t, bool exc = true); /// Extract the scaling, shear, rotation, and translation components /// of the given 4x4 matrix. /// /// @param[in] mat The input matrix /// @param[out] s The extracted scale /// @param[out] h The extracted shear /// @param[out] r The extracted rotation, in Euler angles /// @param[out] t The extracted translation /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the values could be extracted, false if the matrix is degenerate. template bool extractSHRT (const Matrix44& mat, Vec3& s, Vec3& h, Euler& r, Vec3& t, bool exc = true); /// Return true if the given scale can be removed from the given row /// matrix, false if `scl` is small enough that the operation would /// overflow. If `exc` is true, throw an exception on overflow. template bool checkForZeroScaleInRow (const T& scl, const Vec3& row, bool exc = true); /// Return the 4x4 outer product two 4-vectors template Matrix44 outerProduct (const Vec4& a, const Vec4& b); /// /// Return a 4x4 matrix that rotates the vector `fromDirection` to `toDirection` /// template Matrix44 rotationMatrix (const Vec3& fromDirection, const Vec3& toDirection); /// /// Return a 4x4 matrix that rotates the `fromDir` vector /// so that it points towards `toDir1. You may also /// specify that you want the up vector to be pointing /// in a certain direction 1upDir`. template Matrix44 rotationMatrixWithUpDir (const Vec3& fromDir, const Vec3& toDir, const Vec3& upDir); /// /// Construct a 4x4 matrix that rotates the z-axis so that it points /// towards `targetDir`. You must also specify that you want the up /// vector to be pointing in a certain direction `upDir`. /// /// Notes: The following degenerate cases are handled: /// (a) when the directions given by `toDir` and `upDir` /// are parallel or opposite (the direction vectors must have a non-zero cross product); /// (b) when any of the given direction vectors have zero length /// /// @param[out] result The output matrix /// @param[in] targetDir The target direction vector /// @param[in] upDir The up direction vector template void alignZAxisWithTargetDir (Matrix44& result, Vec3 targetDir, Vec3 upDir); /// Compute an orthonormal direct 4x4 frame from a position, an x axis /// direction and a normal to the y axis. If the x axis and normal are /// perpendicular, then the normal will have the same direction as the /// z axis. /// /// @param[in] p The position of the frame /// @param[in] xDir The x axis direction of the frame /// @param[in] normal A normal to the y axis of the frame /// @return The orthonormal frame template Matrix44 computeLocalFrame (const Vec3& p, const Vec3& xDir, const Vec3& normal); /// Add a translate/rotate/scale offset to a 4x4 input frame /// and put it in another frame of reference /// /// @param[in] inMat Input frame /// @param[in] tOffset Translation offset /// @param[in] rOffset Rotation offset in degrees /// @param[in] sOffset Scale offset /// @param[in] ref Frame of reference /// @return The offsetted frame template Matrix44 addOffset (const Matrix44& inMat, const Vec3& tOffset, const Vec3& rOffset, const Vec3& sOffset, const Vec3& ref); /// Compute 4x4 translate/rotate/scale matrix from `A` with the /// rotate/scale of `B`. /// /// @param[in] keepRotateA If true, keep rotate from matrix `A`, use `B` otherwise /// @param[in] keepScaleA If true, keep scale from matrix `A`, use `B` otherwise /// @param[in] A Matrix A /// @param[in] B Matrix B /// @return Matrix `A` with tweaked rotation/scale template Matrix44 computeRSMatrix (bool keepRotateA, bool keepScaleA, const Matrix44& A, const Matrix44& B); // // Declarations for 3x3 matrix. // /// Extract the scaling component of the given 3x3 matrix. /// /// @param[in] mat The input matrix /// @param[out] scl The extracted scale, i.e. the output value /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool extractScaling (const Matrix33& mat, Vec2& scl, bool exc = true); /// Return the given 3x3 matrix with scaling removed. /// /// @param[in] mat The input matrix /// @param[in] exc If true, throw an exception if the scaling in `mat` template Matrix33 sansScaling (const Matrix33& mat, bool exc = true); /// Remove scaling from the given 3x3 matrix in place. Return true if the /// scale could be successfully extracted, false if the matrix is /// degenerate. // /// @param[in] mat The matrix to operate on /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool removeScaling (Matrix33& mat, bool exc = true); /// Extract the scaling and shear components of the given 3x3 matrix. /// Return true if the scale could be successfully extracted, false if /// the matrix is degenerate. /// /// @param[in] mat The input matrix /// @param[out] scl The extracted scale /// @param[out] shr The extracted shear /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool extractScalingAndShear (const Matrix33& mat, Vec2& scl, T& shr, bool exc = true); /// Return the given 3x3 matrix with scaling and shear removed. /// /// @param[in] mat The input matrix /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. template Matrix33 sansScalingAndShear (const Matrix33& mat, bool exc = true); /// Remove scaling and shear from the given 3x3e matrix in place. // /// @param[in,out] mat The matrix to operate on /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool removeScalingAndShear (Matrix33& mat, bool exc = true); /// Remove scaling and shear from the given 3x3 matrix in place, returning /// the extracted values. // /// @param[in,out] mat The matrix to operate on /// @param[out] scl The extracted scale /// @param[out] shr The extracted shear /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the scale could be extracted, false if the matrix is degenerate. template bool extractAndRemoveScalingAndShear (Matrix33& mat, Vec2& scl, T& shr, bool exc = true); /// Extract the rotation from the given 2x2 matrix /// /// @param[in] mat The input matrix /// @param[out] rot The extracted rotation value template void extractEuler (const Matrix22& mat, T& rot); /// Extract the rotation from the given 3x3 matrix /// /// @param[in] mat The input matrix /// @param[out] rot The extracted rotation value template void extractEuler (const Matrix33& mat, T& rot); /// Extract the scaling, shear, rotation, and translation components /// of the given 3x3 matrix. The values are such that: /// /// M = S * H * R * T /// /// @param[in] mat The input matrix /// @param[out] s The extracted scale /// @param[out] h The extracted shear /// @param[out] r The extracted rotation /// @param[out] t The extracted translation /// @param[in] exc If true, throw an exception if the scaling in `mat` is very close to zero. /// @return True if the values could be extracted, false if the matrix is degenerate. template bool extractSHRT (const Matrix33& mat, Vec2& s, T& h, T& r, Vec2& t, bool exc = true); /// Return true if the given scale can be removed from the given row /// matrix, false if `scl` is small enough that the operation would /// overflow. If `exc` is true, throw an exception on overflow. template bool checkForZeroScaleInRow (const T& scl, const Vec2& row, bool exc = true); /// Return the 3xe outer product two 3-vectors template Matrix33 outerProduct (const Vec3& a, const Vec3& b); //------------------------------ // Implementation for 4x4 Matrix //------------------------------ template bool extractScaling (const Matrix44& mat, Vec3& scl, bool exc) { Vec3 shr; Matrix44 M (mat); if (!extractAndRemoveScalingAndShear (M, scl, shr, exc)) return false; return true; } template Matrix44 sansScaling (const Matrix44& mat, bool exc) { Vec3 scl; Vec3 shr; Vec3 rot; Vec3 tran; if (!extractSHRT (mat, scl, shr, rot, tran, exc)) return mat; Matrix44 M; M.translate (tran); M.rotate (rot); M.shear (shr); return M; } template bool removeScaling (Matrix44& mat, bool exc) { Vec3 scl; Vec3 shr; Vec3 rot; Vec3 tran; if (!extractSHRT (mat, scl, shr, rot, tran, exc)) return false; mat.makeIdentity(); mat.translate (tran); mat.rotate (rot); mat.shear (shr); return true; } template bool extractScalingAndShear (const Matrix44& mat, Vec3& scl, Vec3& shr, bool exc) { Matrix44 M (mat); if (!extractAndRemoveScalingAndShear (M, scl, shr, exc)) return false; return true; } template Matrix44 sansScalingAndShear (const Matrix44& mat, bool exc) { Vec3 scl; Vec3 shr; Matrix44 M (mat); if (!extractAndRemoveScalingAndShear (M, scl, shr, exc)) return mat; return M; } template void sansScalingAndShear (Matrix44& result, const Matrix44& mat, bool exc) { Vec3 scl; Vec3 shr; if (!extractAndRemoveScalingAndShear (result, scl, shr, exc)) result = mat; } template bool removeScalingAndShear (Matrix44& mat, bool exc) { Vec3 scl; Vec3 shr; if (!extractAndRemoveScalingAndShear (mat, scl, shr, exc)) return false; return true; } template bool extractAndRemoveScalingAndShear (Matrix44& mat, Vec3& scl, Vec3& shr, bool exc) { // // This implementation follows the technique described in the paper by // Spencer W. Thomas in the Graphics Gems II article: "Decomposing a // Matrix into Simple Transformations", p. 320. // Vec3 row[3]; row[0] = Vec3 (mat[0][0], mat[0][1], mat[0][2]); row[1] = Vec3 (mat[1][0], mat[1][1], mat[1][2]); row[2] = Vec3 (mat[2][0], mat[2][1], mat[2][2]); T maxVal = 0; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) if (IMATH_INTERNAL_NAMESPACE::abs (row[i][j]) > maxVal) maxVal = IMATH_INTERNAL_NAMESPACE::abs (row[i][j]); // // We normalize the 3x3 matrix here. // It was noticed that this can improve numerical stability significantly, // especially when many of the upper 3x3 matrix's coefficients are very // close to zero; we correct for this step at the end by multiplying the // scaling factors by maxVal at the end (shear and rotation are not // affected by the normalization). if (maxVal != 0) { for (int i = 0; i < 3; i++) if (!checkForZeroScaleInRow (maxVal, row[i], exc)) return false; else row[i] /= maxVal; } // Compute X scale factor. scl.x = row[0].length(); if (!checkForZeroScaleInRow (scl.x, row[0], exc)) return false; // Normalize first row. row[0] /= scl.x; // An XY shear factor will shear the X coord. as the Y coord. changes. // There are 6 combinations (XY, XZ, YZ, YX, ZX, ZY), although we only // extract the first 3 because we can effect the last 3 by shearing in // XY, XZ, YZ combined rotations and scales. // // shear matrix < 1, YX, ZX, 0, // XY, 1, ZY, 0, // XZ, YZ, 1, 0, // 0, 0, 0, 1 > // Compute XY shear factor and make 2nd row orthogonal to 1st. shr[0] = row[0].dot (row[1]); row[1] -= shr[0] * row[0]; // Now, compute Y scale. scl.y = row[1].length(); if (!checkForZeroScaleInRow (scl.y, row[1], exc)) return false; // Normalize 2nd row and correct the XY shear factor for Y scaling. row[1] /= scl.y; shr[0] /= scl.y; // Compute XZ and YZ shears, orthogonalize 3rd row. shr[1] = row[0].dot (row[2]); row[2] -= shr[1] * row[0]; shr[2] = row[1].dot (row[2]); row[2] -= shr[2] * row[1]; // Next, get Z scale. scl.z = row[2].length(); if (!checkForZeroScaleInRow (scl.z, row[2], exc)) return false; // Normalize 3rd row and correct the XZ and YZ shear factors for Z scaling. row[2] /= scl.z; shr[1] /= scl.z; shr[2] /= scl.z; // At this point, the upper 3x3 matrix in mat is orthonormal. // Check for a coordinate system flip. If the determinant // is less than zero, then negate the matrix and the scaling factors. if (row[0].dot (row[1].cross (row[2])) < 0) for (int i = 0; i < 3; i++) { scl[i] *= -1; row[i] *= -1; } // Copy over the orthonormal rows into the returned matrix. // The upper 3x3 matrix in mat is now a rotation matrix. for (int i = 0; i < 3; i++) { mat[i][0] = row[i][0]; mat[i][1] = row[i][1]; mat[i][2] = row[i][2]; } // Correct the scaling factors for the normalization step that we // performed above; shear and rotation are not affected by the // normalization. scl *= maxVal; return true; } template void extractEulerXYZ (const Matrix44& mat, Vec3& rot) { // // Normalize the local x, y and z axes to remove scaling. // Vec3 i (mat[0][0], mat[0][1], mat[0][2]); Vec3 j (mat[1][0], mat[1][1], mat[1][2]); Vec3 k (mat[2][0], mat[2][1], mat[2][2]); i.normalize(); j.normalize(); k.normalize(); Matrix44 M (i[0], i[1], i[2], 0, j[0], j[1], j[2], 0, k[0], k[1], k[2], 0, 0, 0, 0, 1); // // Extract the first angle, rot.x. // rot.x = std::atan2 (M[1][2], M[2][2]); // // Remove the rot.x rotation from M, so that the remaining // rotation, N, is only around two axes, and gimbal lock // cannot occur. // Matrix44 N; N.rotate (Vec3 (-rot.x, 0, 0)); N = N * M; // // Extract the other two angles, rot.y and rot.z, from N. // T cy = std::sqrt (N[0][0] * N[0][0] + N[0][1] * N[0][1]); rot.y = std::atan2 (-N[0][2], cy); rot.z = std::atan2 (-N[1][0], N[1][1]); } template void extractEulerZYX (const Matrix44& mat, Vec3& rot) { // // Normalize the local x, y and z axes to remove scaling. // Vec3 i (mat[0][0], mat[0][1], mat[0][2]); Vec3 j (mat[1][0], mat[1][1], mat[1][2]); Vec3 k (mat[2][0], mat[2][1], mat[2][2]); i.normalize(); j.normalize(); k.normalize(); Matrix44 M (i[0], i[1], i[2], 0, j[0], j[1], j[2], 0, k[0], k[1], k[2], 0, 0, 0, 0, 1); // // Extract the first angle, rot.x. // rot.x = -std::atan2 (M[1][0], M[0][0]); // // Remove the x rotation from M, so that the remaining // rotation, N, is only around two axes, and gimbal lock // cannot occur. // Matrix44 N; N.rotate (Vec3 (0, 0, -rot.x)); N = N * M; // // Extract the other two angles, rot.y and rot.z, from N. // T cy = std::sqrt (N[2][2] * N[2][2] + N[2][1] * N[2][1]); rot.y = -std::atan2 (-N[2][0], cy); rot.z = -std::atan2 (-N[1][2], N[1][1]); } template Quat extractQuat (const Matrix44& mat) { Matrix44 rot; T tr, s; T q[4]; int i, j, k; Quat quat; int nxt[3] = { 1, 2, 0 }; tr = mat[0][0] + mat[1][1] + mat[2][2]; // check the diagonal if (tr > 0.0) { s = std::sqrt (tr + T (1.0)); quat.r = s / T (2.0); s = T (0.5) / s; quat.v.x = (mat[1][2] - mat[2][1]) * s; quat.v.y = (mat[2][0] - mat[0][2]) * s; quat.v.z = (mat[0][1] - mat[1][0]) * s; } else { // diagonal is negative i = 0; if (mat[1][1] > mat[0][0]) i = 1; if (mat[2][2] > mat[i][i]) i = 2; j = nxt[i]; k = nxt[j]; s = std::sqrt ((mat[i][i] - (mat[j][j] + mat[k][k])) + T (1.0)); q[i] = s * T (0.5); if (s != T (0.0)) s = T (0.5) / s; q[3] = (mat[j][k] - mat[k][j]) * s; q[j] = (mat[i][j] + mat[j][i]) * s; q[k] = (mat[i][k] + mat[k][i]) * s; quat.v.x = q[0]; quat.v.y = q[1]; quat.v.z = q[2]; quat.r = q[3]; } return quat; } template bool extractSHRT (const Matrix44& mat, Vec3& s, Vec3& h, Vec3& r, Vec3& t, bool exc /* = true */, typename Euler::Order rOrder /* = Euler::XYZ */) { Matrix44 rot; rot = mat; if (!extractAndRemoveScalingAndShear (rot, s, h, exc)) return false; extractEulerXYZ (rot, r); t.x = mat[3][0]; t.y = mat[3][1]; t.z = mat[3][2]; if (rOrder != Euler::XYZ) { Euler eXYZ (r, Euler::XYZ); Euler e (eXYZ, rOrder); r = e.toXYZVector(); } return true; } template bool extractSHRT (const Matrix44& mat, Vec3& s, Vec3& h, Vec3& r, Vec3& t, bool exc) { return extractSHRT (mat, s, h, r, t, exc, Euler::XYZ); } template bool extractSHRT (const Matrix44& mat, Vec3& s, Vec3& h, Euler& r, Vec3& t, bool exc /* = true */) { return extractSHRT (mat, s, h, r, t, exc, r.order()); } template bool checkForZeroScaleInRow (const T& scl, const Vec3& row, bool exc /* = true */) { for (int i = 0; i < 3; i++) { if ((abs (scl) < 1 && abs (row[i]) >= std::numeric_limits::max() * abs (scl))) { if (exc) throw std::domain_error ("Cannot remove zero scaling " "from matrix."); else return false; } } return true; } template Matrix44 outerProduct (const Vec4& a, const Vec4& b) { return Matrix44 (a.x * b.x, a.x * b.y, a.x * b.z, a.x * b.w, a.y * b.x, a.y * b.y, a.y * b.z, a.x * b.w, a.z * b.x, a.z * b.y, a.z * b.z, a.x * b.w, a.w * b.x, a.w * b.y, a.w * b.z, a.w * b.w); } template Matrix44 rotationMatrix (const Vec3& from, const Vec3& to) { Quat q; q.setRotation (from, to); return q.toMatrix44(); } template Matrix44 rotationMatrixWithUpDir (const Vec3& fromDir, const Vec3& toDir, const Vec3& upDir) { // // The goal is to obtain a rotation matrix that takes // "fromDir" to "toDir". We do this in two steps and // compose the resulting rotation matrices; // (a) rotate "fromDir" into the z-axis // (b) rotate the z-axis into "toDir" // // The from direction must be non-zero; but we allow zero to and up dirs. if (fromDir.length() == 0) return Matrix44(); else { Matrix44 zAxis2FromDir (UNINITIALIZED); alignZAxisWithTargetDir (zAxis2FromDir, fromDir, Vec3 (0, 1, 0)); Matrix44 fromDir2zAxis = zAxis2FromDir.transposed(); Matrix44 zAxis2ToDir (UNINITIALIZED); alignZAxisWithTargetDir (zAxis2ToDir, toDir, upDir); return fromDir2zAxis * zAxis2ToDir; } } template void alignZAxisWithTargetDir (Matrix44& result, Vec3 targetDir, Vec3 upDir) { // // Ensure that the target direction is non-zero. // if (targetDir.length() == 0) targetDir = Vec3 (0, 0, 1); // // Ensure that the up direction is non-zero. // if (upDir.length() == 0) upDir = Vec3 (0, 1, 0); // // Check for degeneracies. If the upDir and targetDir are parallel // or opposite, then compute a new, arbitrary up direction that is // not parallel or opposite to the targetDir. // if (upDir.cross (targetDir).length() == 0) { upDir = targetDir.cross (Vec3 (1, 0, 0)); if (upDir.length() == 0) upDir = targetDir.cross (Vec3 (0, 0, 1)); } // // Compute the x-, y-, and z-axis vectors of the new coordinate system. // Vec3 targetPerpDir = upDir.cross (targetDir); Vec3 targetUpDir = targetDir.cross (targetPerpDir); // // Rotate the x-axis into targetPerpDir (row 0), // rotate the y-axis into targetUpDir (row 1), // rotate the z-axis into targetDir (row 2). // Vec3 row[3]; row[0] = targetPerpDir.normalized(); row[1] = targetUpDir.normalized(); row[2] = targetDir.normalized(); result.x[0][0] = row[0][0]; result.x[0][1] = row[0][1]; result.x[0][2] = row[0][2]; result.x[0][3] = (T) 0; result.x[1][0] = row[1][0]; result.x[1][1] = row[1][1]; result.x[1][2] = row[1][2]; result.x[1][3] = (T) 0; result.x[2][0] = row[2][0]; result.x[2][1] = row[2][1]; result.x[2][2] = row[2][2]; result.x[2][3] = (T) 0; result.x[3][0] = (T) 0; result.x[3][1] = (T) 0; result.x[3][2] = (T) 0; result.x[3][3] = (T) 1; } // Compute an orthonormal direct frame from : a position, an x axis direction and a normal to the y axis // If the x axis and normal are perpendicular, then the normal will have the same direction as the z axis. // Inputs are : // -the position of the frame // -the x axis direction of the frame // -a normal to the y axis of the frame // Return is the orthonormal frame template Matrix44 computeLocalFrame (const Vec3& p, const Vec3& xDir, const Vec3& normal) { Vec3 _xDir (xDir); Vec3 x = _xDir.normalize(); Vec3 y = (normal % x).normalize(); Vec3 z = (x % y).normalize(); Matrix44 L; L[0][0] = x[0]; L[0][1] = x[1]; L[0][2] = x[2]; L[0][3] = 0.0; L[1][0] = y[0]; L[1][1] = y[1]; L[1][2] = y[2]; L[1][3] = 0.0; L[2][0] = z[0]; L[2][1] = z[1]; L[2][2] = z[2]; L[2][3] = 0.0; L[3][0] = p[0]; L[3][1] = p[1]; L[3][2] = p[2]; L[3][3] = 1.0; return L; } /// Add a translate/rotate/scale offset to an input frame and put it /// in another frame of reference. /// /// @param inMat input frame /// @param tOffset translate offset /// @param rOffset rotate offset in degrees /// @param sOffset scale offset /// @param ref Frame of reference /// @return The offsetted frame template Matrix44 addOffset (const Matrix44& inMat, const Vec3& tOffset, const Vec3& rOffset, const Vec3& sOffset, const Matrix44& ref) { Matrix44 O; Vec3 _rOffset (rOffset); _rOffset *= M_PI / 180.0; O.rotate (_rOffset); O[3][0] = tOffset[0]; O[3][1] = tOffset[1]; O[3][2] = tOffset[2]; Matrix44 S; S.scale (sOffset); Matrix44 X = S * O * inMat * ref; return X; } // Compute Translate/Rotate/Scale matrix from matrix A with the Rotate/Scale of Matrix B // Inputs are : // -keepRotateA : if true keep rotate from matrix A, use B otherwise // -keepScaleA : if true keep scale from matrix A, use B otherwise // -Matrix A // -Matrix B // Return Matrix A with tweaked rotation/scale template Matrix44 computeRSMatrix (bool keepRotateA, bool keepScaleA, const Matrix44& A, const Matrix44& B) { Vec3 as, ah, ar, at; extractSHRT (A, as, ah, ar, at); Vec3 bs, bh, br, bt; extractSHRT (B, bs, bh, br, bt); if (!keepRotateA) ar = br; if (!keepScaleA) as = bs; Matrix44 mat; mat.makeIdentity(); mat.translate (at); mat.rotate (ar); mat.scale (as); return mat; } //----------------------------------------------------------------------------- // Implementation for 3x3 Matrix //------------------------------ template bool extractScaling (const Matrix33& mat, Vec2& scl, bool exc) { T shr; Matrix33 M (mat); if (!extractAndRemoveScalingAndShear (M, scl, shr, exc)) return false; return true; } template Matrix33 sansScaling (const Matrix33& mat, bool exc) { Vec2 scl; T shr; T rot; Vec2 tran; if (!extractSHRT (mat, scl, shr, rot, tran, exc)) return mat; Matrix33 M; M.translate (tran); M.rotate (rot); M.shear (shr); return M; } template bool removeScaling (Matrix33& mat, bool exc) { Vec2 scl; T shr; T rot; Vec2 tran; if (!extractSHRT (mat, scl, shr, rot, tran, exc)) return false; mat.makeIdentity(); mat.translate (tran); mat.rotate (rot); mat.shear (shr); return true; } template bool extractScalingAndShear (const Matrix33& mat, Vec2& scl, T& shr, bool exc) { Matrix33 M (mat); if (!extractAndRemoveScalingAndShear (M, scl, shr, exc)) return false; return true; } template Matrix33 sansScalingAndShear (const Matrix33& mat, bool exc) { Vec2 scl; T shr; Matrix33 M (mat); if (!extractAndRemoveScalingAndShear (M, scl, shr, exc)) return mat; return M; } template bool removeScalingAndShear (Matrix33& mat, bool exc) { Vec2 scl; T shr; if (!extractAndRemoveScalingAndShear (mat, scl, shr, exc)) return false; return true; } template bool extractAndRemoveScalingAndShear (Matrix33& mat, Vec2& scl, T& shr, bool exc) { Vec2 row[2]; row[0] = Vec2 (mat[0][0], mat[0][1]); row[1] = Vec2 (mat[1][0], mat[1][1]); T maxVal = 0; for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) if (IMATH_INTERNAL_NAMESPACE::abs (row[i][j]) > maxVal) maxVal = IMATH_INTERNAL_NAMESPACE::abs (row[i][j]); // // We normalize the 2x2 matrix here. // It was noticed that this can improve numerical stability significantly, // especially when many of the upper 2x2 matrix's coefficients are very // close to zero; we correct for this step at the end by multiplying the // scaling factors by maxVal at the end (shear and rotation are not // affected by the normalization). if (maxVal != 0) { for (int i = 0; i < 2; i++) if (!checkForZeroScaleInRow (maxVal, row[i], exc)) return false; else row[i] /= maxVal; } // Compute X scale factor. scl.x = row[0].length(); if (!checkForZeroScaleInRow (scl.x, row[0], exc)) return false; // Normalize first row. row[0] /= scl.x; // An XY shear factor will shear the X coord. as the Y coord. changes. // There are 2 combinations (XY, YX), although we only extract the XY // shear factor because we can effect the an YX shear factor by // shearing in XY combined with rotations and scales. // // shear matrix < 1, YX, 0, // XY, 1, 0, // 0, 0, 1 > // Compute XY shear factor and make 2nd row orthogonal to 1st. shr = row[0].dot (row[1]); row[1] -= shr * row[0]; // Now, compute Y scale. scl.y = row[1].length(); if (!checkForZeroScaleInRow (scl.y, row[1], exc)) return false; // Normalize 2nd row and correct the XY shear factor for Y scaling. row[1] /= scl.y; shr /= scl.y; // At this point, the upper 2x2 matrix in mat is orthonormal. // Check for a coordinate system flip. If the determinant // is -1, then flip the rotation matrix and adjust the scale(Y) // and shear(XY) factors to compensate. if (row[0][0] * row[1][1] - row[0][1] * row[1][0] < 0) { row[1][0] *= -1; row[1][1] *= -1; scl[1] *= -1; shr *= -1; } // Copy over the orthonormal rows into the returned matrix. // The upper 2x2 matrix in mat is now a rotation matrix. for (int i = 0; i < 2; i++) { mat[i][0] = row[i][0]; mat[i][1] = row[i][1]; } scl *= maxVal; return true; } template void extractEuler (const Matrix22& mat, T& rot) { // // Normalize the local x and y axes to remove scaling. // Vec2 i (mat[0][0], mat[0][1]); Vec2 j (mat[1][0], mat[1][1]); i.normalize(); j.normalize(); // // Extract the angle, rot. // rot = -std::atan2 (j[0], i[0]); } template void extractEuler (const Matrix33& mat, T& rot) { // // Normalize the local x and y axes to remove scaling. // Vec2 i (mat[0][0], mat[0][1]); Vec2 j (mat[1][0], mat[1][1]); i.normalize(); j.normalize(); // // Extract the angle, rot. // rot = -std::atan2 (j[0], i[0]); } template bool extractSHRT (const Matrix33& mat, Vec2& s, T& h, T& r, Vec2& t, bool exc) { Matrix33 rot; rot = mat; if (!extractAndRemoveScalingAndShear (rot, s, h, exc)) return false; extractEuler (rot, r); t.x = mat[2][0]; t.y = mat[2][1]; return true; } /// @cond Doxygen_Suppress template bool checkForZeroScaleInRow (const T& scl, const Vec2& row, bool exc /* = true */) { for (int i = 0; i < 2; i++) { if ((abs (scl) < 1 && abs (row[i]) >= std::numeric_limits::max() * abs (scl))) { if (exc) throw std::domain_error ("Cannot remove zero scaling from matrix."); else return false; } } return true; } /// @endcond template Matrix33 outerProduct (const Vec3& a, const Vec3& b) { return Matrix33 (a.x * b.x, a.x * b.y, a.x * b.z, a.y * b.x, a.y * b.y, a.y * b.z, a.z * b.x, a.z * b.y, a.z * b.z); } /// Computes the translation and rotation that brings the 'from' points /// as close as possible to the 'to' points under the Frobenius norm. /// To be more specific, let x be the matrix of 'from' points and y be /// the matrix of 'to' points, we want to find the matrix A of the form /// [ R t ] /// [ 0 1 ] /// that minimizes /// || (A*x - y)^T * W * (A*x - y) ||_F /// If doScaling is true, then a uniform scale is allowed also. /// @param A From points /// @param B To points /// @param weights Per-point weights /// @param numPoints The number of points in `A`, `B`, and `weights` (must be equal) /// @param doScaling If true, include a scaling transformation /// @return The procrustes transformation template M44d procrustesRotationAndTranslation (const Vec3* A, const Vec3* B, const T* weights, const size_t numPoints, const bool doScaling = false); /// Computes the translation and rotation that brings the 'from' points /// as close as possible to the 'to' points under the Frobenius norm. /// To be more specific, let x be the matrix of 'from' points and y be /// the matrix of 'to' points, we want to find the matrix A of the form /// [ R t ] /// [ 0 1 ] /// that minimizes /// || (A*x - y)^T * W * (A*x - y) ||_F /// If doScaling is true, then a uniform scale is allowed also. /// @param A From points /// @param B To points /// @param numPoints The number of points in `A` and `B` (must be equal) /// @param doScaling If true, include a scaling transformation /// @return The procrustes transformation template M44d procrustesRotationAndTranslation (const Vec3* A, const Vec3* B, const size_t numPoints, const bool doScaling = false); /// Compute the SVD of a 3x3 matrix using Jacobi transformations. This method /// should be quite accurate (competitive with LAPACK) even for poorly /// conditioned matrices, and because it has been written specifically for the /// 3x3/4x4 case it is much faster than calling out to LAPACK. /// /// The SVD of a 3x3/4x4 matrix A is defined as follows: /// A = U * S * V^T /// where S is the diagonal matrix of singular values and both U and V are /// orthonormal. By convention, the entries S are all positive and sorted from /// the largest to the smallest. However, some uses of this function may /// require that the matrix U*V^T have positive determinant; in this case, we /// may make the smallest singular value negative to ensure that this is /// satisfied. /// /// Currently only available for single- and double-precision matrices. template void jacobiSVD (const Matrix33& A, Matrix33& U, Vec3& S, Matrix33& V, const T tol = std::numeric_limits::epsilon(), const bool forcePositiveDeterminant = false); /// Compute the SVD of a 3x3 matrix using Jacobi transformations. This method /// should be quite accurate (competitive with LAPACK) even for poorly /// conditioned matrices, and because it has been written specifically for the /// 3x3/4x4 case it is much faster than calling out to LAPACK. /// /// The SVD of a 3x3/4x4 matrix A is defined as follows: /// A = U * S * V^T /// where S is the diagonal matrix of singular values and both U and V are /// orthonormal. By convention, the entries S are all positive and sorted from /// the largest to the smallest. However, some uses of this function may /// require that the matrix U*V^T have positive determinant; in this case, we /// may make the smallest singular value negative to ensure that this is /// satisfied. /// /// Currently only available for single- and double-precision matrices. template void jacobiSVD (const Matrix44& A, Matrix44& U, Vec4& S, Matrix44& V, const T tol = std::numeric_limits::epsilon(), const bool forcePositiveDeterminant = false); /// Compute the eigenvalues (S) and the eigenvectors (V) of a real /// symmetric matrix using Jacobi transformation, using a given /// tolerance `tol`. /// /// Jacobi transformation of a 3x3/4x4 matrix A outputs S and V: /// A = V * S * V^T /// where V is orthonormal and S is the diagonal matrix of eigenvalues. /// Input matrix A must be symmetric. A is also modified during /// the computation so that upper diagonal entries of A become zero. template void jacobiEigenSolver (Matrix33& A, Vec3& S, Matrix33& V, const T tol); /// Compute the eigenvalues (S) and the eigenvectors (V) of /// a real symmetric matrix using Jacobi transformation. /// /// Jacobi transformation of a 3x3/4x4 matrix A outputs S and V: /// A = V * S * V^T /// where V is orthonormal and S is the diagonal matrix of eigenvalues. /// Input matrix A must be symmetric. A is also modified during /// the computation so that upper diagonal entries of A become zero. template inline void jacobiEigenSolver (Matrix33& A, Vec3& S, Matrix33& V) { jacobiEigenSolver (A, S, V, std::numeric_limits::epsilon()); } /// Compute the eigenvalues (S) and the eigenvectors (V) of a real /// symmetric matrix using Jacobi transformation, using a given /// tolerance `tol`. /// /// Jacobi transformation of a 3x3/4x4 matrix A outputs S and V: /// A = V * S * V^T /// where V is orthonormal and S is the diagonal matrix of eigenvalues. /// Input matrix A must be symmetric. A is also modified during /// the computation so that upper diagonal entries of A become zero. template void jacobiEigenSolver (Matrix44& A, Vec4& S, Matrix44& V, const T tol); /// Compute the eigenvalues (S) and the eigenvectors (V) of /// a real symmetric matrix using Jacobi transformation. /// /// Jacobi transformation of a 3x3/4x4 matrix A outputs S and V: /// A = V * S * V^T /// where V is orthonormal and S is the diagonal matrix of eigenvalues. /// Input matrix A must be symmetric. A is also modified during /// the computation so that upper diagonal entries of A become zero. template inline void jacobiEigenSolver (Matrix44& A, Vec4& S, Matrix44& V) { jacobiEigenSolver (A, S, V, std::numeric_limits::epsilon()); } /// Compute a eigenvector corresponding to the abs max eigenvalue /// of a real symmetric matrix using Jacobi transformation. template void maxEigenVector (TM& A, TV& S); /// Compute a eigenvector corresponding to the abs min eigenvalue /// of a real symmetric matrix using Jacobi transformation. template void minEigenVector (TM& A, TV& S); IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHMATRIXALGO_H Imath-3.1.4/src/Imath/ImathNamespace.h000066400000000000000000000057501417213455000174530ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // The Imath library namespace // // The purpose of this file is to make it possible to specify an // IMATH_INTERNAL_NAMESPACE as a preprocessor definition and have all of the // Imath symbols defined within that namespace rather than the standard // Imath namespace. Those symbols are made available to client code through // the IMATH_NAMESPACE in addition to the IMATH_INTERNAL_NAMESPACE. // // To ensure source code compatibility, the IMATH_NAMESPACE defaults to Imath // and then "using namespace IMATH_INTERNAL_NAMESPACE;" brings all of the // declarations from the IMATH_INTERNAL_NAMESPACE into the IMATH_NAMESPACE. // This means that client code can continue to use syntax like Imath::V3f, // but at link time it will resolve to a mangled symbol based on the // IMATH_INTERNAL_NAMESPACE. // // As an example, if one needed to build against a newer version of Imath and // have it run alongside an older version in the same application, it is now // possible to use an internal namespace to prevent collisions between the // older versions of Imath symbols and the newer ones. To do this, the // following could be defined at build time: // // IMATH_INTERNAL_NAMESPACE = Imath_v2 // // This means that declarations inside Imath headers look like this (after // the preprocessor has done its work): // // namespace Imath_v2 { // ... // class declarations // ... // } // // namespace Imath { // using namespace Imath_v2; // } // #ifndef INCLUDED_IMATHNAMESPACE_H #define INCLUDED_IMATHNAMESPACE_H /// @cond Doxygen_Suppress #include "ImathConfig.h" #ifndef IMATH_NAMESPACE # define IMATH_NAMESPACE Imath #endif #ifndef IMATH_INTERNAL_NAMESPACE # define IMATH_INTERNAL_NAMESPACE IMATH_NAMESPACE #endif #ifdef __cplusplus // // We need to be sure that we import the internal namespace into the public one. // To do this, we use the small bit of code below which initially defines // IMATH_INTERNAL_NAMESPACE (so it can be referenced) and then defines // IMATH_NAMESPACE and pulls the internal symbols into the public // namespace. // namespace IMATH_INTERNAL_NAMESPACE {} namespace IMATH_NAMESPACE { using namespace IMATH_INTERNAL_NAMESPACE; } // // There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that // future extension to the namespace mechanism is possible without changing // project source code. // #define IMATH_INTERNAL_NAMESPACE_HEADER_ENTER \ namespace IMATH_INTERNAL_NAMESPACE \ { #define IMATH_INTERNAL_NAMESPACE_HEADER_EXIT } #define IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER \ namespace IMATH_INTERNAL_NAMESPACE \ { #define IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT } #endif // __cplusplus /// @endcond #endif /* INCLUDED_IMATHNAMESPACE_H */ Imath-3.1.4/src/Imath/ImathPlane.h000066400000000000000000000157231417213455000166170ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A 3D plane class template // #ifndef INCLUDED_IMATHPLANE_H #define INCLUDED_IMATHPLANE_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathLine.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// The `Plane3` class represents a half space in 3D, so the normal /// may point either towards or away from origin. The plane `P` can /// be represented by Plane3 as either `p` or `-p` corresponding to /// the two half-spaces on either side of the plane. Any function /// which computes a distance will return either negative or positive /// values for the distance indicating which half-space the point is /// in. Note that reflection, and intersection functions will operate /// as expected. template class IMATH_EXPORT_TEMPLATE_TYPE Plane3 { public: /// @{ /// @name Direct access to member fields /// The normal to the plane Vec3 normal; /// The distance from the origin to the plane T distance; /// @} /// @{ /// @name Constructors /// Uninitialized by default IMATH_HOSTDEVICE Plane3() IMATH_NOEXCEPT {} /// Initialize with a normal and distance IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Plane3 (const Vec3& normal, T distance) IMATH_NOEXCEPT; /// Initialize with a point and a normal IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Plane3 (const Vec3& point, const Vec3& normal) IMATH_NOEXCEPT; /// Initialize with three points IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Plane3 (const Vec3& point1, const Vec3& point2, const Vec3& point3) IMATH_NOEXCEPT; /// @} /// @{ /// @name Manipulation /// Set via a given normal and distance IMATH_HOSTDEVICE void set (const Vec3& normal, T distance) IMATH_NOEXCEPT; /// Set via a given point and normal IMATH_HOSTDEVICE void set (const Vec3& point, const Vec3& normal) IMATH_NOEXCEPT; /// Set via three points IMATH_HOSTDEVICE void set (const Vec3& point1, const Vec3& point2, const Vec3& point3) IMATH_NOEXCEPT; /// @} /// @{ /// @name Utility Methods /// Determine if a line intersects the plane. /// @param line The line /// @param[out] intersection The point of intersection /// @return True if the line intersects the plane. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersect (const Line3& line, Vec3& intersection) const IMATH_NOEXCEPT; /// Determine if a line intersects the plane. /// @param line The line /// @param[out] parameter The parametric value of the point of intersection /// @return True if the line intersects the plane. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersectT (const Line3& line, T& parameter) const IMATH_NOEXCEPT; /// Return the distance from a point to the plane. IMATH_HOSTDEVICE constexpr T distanceTo (const Vec3& point) const IMATH_NOEXCEPT; /// Reflect the given point around the plane. IMATH_HOSTDEVICE constexpr Vec3 reflectPoint (const Vec3& point) const IMATH_NOEXCEPT; /// Reflect the direction vector around the plane IMATH_HOSTDEVICE constexpr Vec3 reflectVector (const Vec3& vec) const IMATH_NOEXCEPT; /// @} }; /// Plane of type float typedef Plane3 Plane3f; /// Plane of type double typedef Plane3 Plane3d; //--------------- // Implementation //--------------- template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Plane3::Plane3 (const Vec3& p0, const Vec3& p1, const Vec3& p2) IMATH_NOEXCEPT { set (p0, p1, p2); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Plane3::Plane3 (const Vec3& n, T d) IMATH_NOEXCEPT { set (n, d); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Plane3::Plane3 (const Vec3& p, const Vec3& n) IMATH_NOEXCEPT { set (p, n); } template IMATH_HOSTDEVICE inline void Plane3::set (const Vec3& point1, const Vec3& point2, const Vec3& point3) IMATH_NOEXCEPT { normal = (point2 - point1) % (point3 - point1); normal.normalize(); distance = normal ^ point1; } template IMATH_HOSTDEVICE inline void Plane3::set (const Vec3& point, const Vec3& n) IMATH_NOEXCEPT { normal = n; normal.normalize(); distance = normal ^ point; } template IMATH_HOSTDEVICE inline void Plane3::set (const Vec3& n, T d) IMATH_NOEXCEPT { normal = n; normal.normalize(); distance = d; } template IMATH_HOSTDEVICE constexpr inline T Plane3::distanceTo (const Vec3& point) const IMATH_NOEXCEPT { return (point ^ normal) - distance; } template IMATH_HOSTDEVICE constexpr inline Vec3 Plane3::reflectPoint (const Vec3& point) const IMATH_NOEXCEPT { return normal * distanceTo (point) * -2.0 + point; } template IMATH_HOSTDEVICE constexpr inline Vec3 Plane3::reflectVector (const Vec3& v) const IMATH_NOEXCEPT { return normal * (normal ^ v) * 2.0 - v; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Plane3::intersect (const Line3& line, Vec3& point) const IMATH_NOEXCEPT { T d = normal ^ line.dir; if (d == 0.0) return false; T t = -((normal ^ line.pos) - distance) / d; point = line (t); return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Plane3::intersectT (const Line3& line, T& t) const IMATH_NOEXCEPT { T d = normal ^ line.dir; if (d == 0.0) return false; t = -((normal ^ line.pos) - distance) / d; return true; } /// Stream output, as "(normal distance)" template std::ostream& operator<< (std::ostream& o, const Plane3& plane) { return o << "(" << plane.normal << ", " << plane.distance << ")"; } /// Transform a plane by a matrix template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Plane3 operator* (const Plane3& plane, const Matrix44& M) IMATH_NOEXCEPT { // T // -1 // Could also compute M but that would suck. // Vec3 dir1 = Vec3 (1, 0, 0) % plane.normal; T dir1Len = dir1 ^ dir1; Vec3 tmp = Vec3 (0, 1, 0) % plane.normal; T tmpLen = tmp ^ tmp; if (tmpLen > dir1Len) { dir1 = tmp; dir1Len = tmpLen; } tmp = Vec3 (0, 0, 1) % plane.normal; tmpLen = tmp ^ tmp; if (tmpLen > dir1Len) { dir1 = tmp; } Vec3 dir2 = dir1 % plane.normal; Vec3 point = plane.distance * plane.normal; return Plane3 (point * M, (point + dir2) * M, (point + dir1) * M); } /// Reflect the pla template IMATH_HOSTDEVICE constexpr inline Plane3 operator- (const Plane3& plane) IMATH_NOEXCEPT { return Plane3 (-plane.normal, -plane.distance); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHPLANE_H Imath-3.1.4/src/Imath/ImathPlatform.h000066400000000000000000000036301417213455000173360ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // This file contains functions and constants which aren't // provided by the system libraries, compilers, or includes on // certain platforms. // #ifndef INCLUDED_IMATHPLATFORM_H #define INCLUDED_IMATHPLATFORM_H /// @cond Doxygen_Suppress #include #include "ImathNamespace.h" #ifdef __cplusplus IMATH_INTERNAL_NAMESPACE_HEADER_ENTER // // Helpful macros for checking which C++ standard we are compiling with. // #if (__cplusplus >= 202002L) # define IMATH_CPLUSPLUS_VERSION 20 #elif (__cplusplus >= 201703L) # define IMATH_CPLUSPLUS_VERSION 17 #elif (__cplusplus >= 201402L) || (defined(_MSC_VER) && _MSC_VER >= 1914) # define IMATH_CPLUSPLUS_VERSION 14 #elif (__cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1900) # define IMATH_CPLUSPLUS_VERSION 11 #else # error "This version of Imath is meant to work only with C++11 and above" #endif // // Constexpr C++14 conditional definition // #if (IMATH_CPLUSPLUS_VERSION >= 14) #define IMATH_CONSTEXPR14 constexpr #else #define IMATH_CONSTEXPR14 /* can not be constexpr before c++14 */ #endif #endif // __cplusplus #ifndef M_PI # define M_PI 3.14159265358979323846 #endif #ifndef M_PI_2 # define M_PI_2 1.57079632679489661923 // pi/2 #endif //----------------------------------------------------------------------------- // // Some, but not all, C++ compilers support the C99 restrict // keyword or some variant of it, for example, __restrict. // //----------------------------------------------------------------------------- #if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER) || defined(__INTEL_COMPILER) # define IMATH_RESTRICT __restrict #else # define IMATH_RESTRICT #endif #ifdef __cplusplus IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // __cplusplus /// @endcond #endif // INCLUDED_IMATHPLATFORM_H Imath-3.1.4/src/Imath/ImathQuat.h000066400000000000000000000641771417213455000165010ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A quaternion // // "Quaternions came from Hamilton ... and have been an unmixed // evil to those who have touched them in any way. Vector is a // useless survival ... and has never been of the slightest use // to any creature." // // - Lord Kelvin // #ifndef INCLUDED_IMATHQUAT_H #define INCLUDED_IMATHQUAT_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathMatrix.h" #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER // Disable MS VC++ warnings about conversion from double to float # pragma warning(push) # pragma warning(disable : 4244) #endif /// /// The Quat class implements the quaternion numerical type -- you /// will probably want to use this class to represent orientations /// in R3 and to convert between various euler angle reps. You /// should probably use Imath::Euler<> for that. /// template class IMATH_EXPORT_TEMPLATE_TYPE Quat { public: /// @{ /// @name Direct access to elements /// The real part T r; /// The imaginary vector Vec3 v; /// @} /// Element access: q[0] is the real part, (q[1],q[2],q[3]) is the /// imaginary part. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int index) IMATH_NOEXCEPT; // as 4D vector /// Element access: q[0] is the real part, (q[1],q[2],q[3]) is the /// imaginary part. IMATH_HOSTDEVICE constexpr T operator[] (int index) const IMATH_NOEXCEPT; /// @{ /// @name Constructors /// Default constructor is the identity quat IMATH_HOSTDEVICE constexpr Quat() IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE constexpr Quat (const Quat& q) IMATH_NOEXCEPT; /// Construct from a quaternion of a another base type template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat (const Quat& q) IMATH_NOEXCEPT; /// Initialize with real part `s` and imaginary vector 1(i,j,k)` IMATH_HOSTDEVICE constexpr Quat (T s, T i, T j, T k) IMATH_NOEXCEPT; /// Initialize with real part `s` and imaginary vector `d` IMATH_HOSTDEVICE constexpr Quat (T s, Vec3 d) IMATH_NOEXCEPT; /// The identity quaternion IMATH_HOSTDEVICE constexpr static Quat identity() IMATH_NOEXCEPT; /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator= (const Quat& q) IMATH_NOEXCEPT; /// Destructor IMATH_HOSTDEVICE ~Quat() IMATH_NOEXCEPT = default; /// @} /// @{ /// @name Basic Algebra /// /// Note that the operator return values are *NOT* normalized // /// Quaternion multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator*= (const Quat& q) IMATH_NOEXCEPT; /// Scalar multiplication: multiply both real and imaginary parts /// by the given scalar. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator*= (T t) IMATH_NOEXCEPT; /// Quaterion division, using the inverse() IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator/= (const Quat& q) IMATH_NOEXCEPT; /// Scalar division: multiply both real and imaginary parts /// by the given scalar. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator/= (T t) IMATH_NOEXCEPT; /// Quaternion addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator+= (const Quat& q) IMATH_NOEXCEPT; /// Quaternion subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Quat& operator-= (const Quat& q) IMATH_NOEXCEPT; /// Equality template IMATH_HOSTDEVICE constexpr bool operator== (const Quat& q) const IMATH_NOEXCEPT; /// Inequality template IMATH_HOSTDEVICE constexpr bool operator!= (const Quat& q) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Query /// Return the R4 length IMATH_HOSTDEVICE constexpr T length() const IMATH_NOEXCEPT; // in R4 /// Return the angle of the axis/angle representation IMATH_HOSTDEVICE constexpr T angle() const IMATH_NOEXCEPT; /// Return the axis of the axis/angle representation IMATH_HOSTDEVICE constexpr Vec3 axis() const IMATH_NOEXCEPT; /// Return a 3x3 rotation matrix IMATH_HOSTDEVICE constexpr Matrix33 toMatrix33() const IMATH_NOEXCEPT; /// Return a 4x4 rotation matrix IMATH_HOSTDEVICE constexpr Matrix44 toMatrix44() const IMATH_NOEXCEPT; /// Return the logarithm of the quaterion IMATH_HOSTDEVICE Quat log() const IMATH_NOEXCEPT; /// Return the exponent of the quaterion IMATH_HOSTDEVICE Quat exp() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Utility Methods /// Invert in place: this = 1 / this. /// @return const reference to this. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat& invert() IMATH_NOEXCEPT; /// Return 1/this, leaving this unchanged. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat inverse() const IMATH_NOEXCEPT; /// Normalize in place /// @return const reference to this. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat& normalize() IMATH_NOEXCEPT; /// Return a normalized quaternion, leaving this unmodified. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat normalized() const IMATH_NOEXCEPT; /// Rotate the given point by the quaterion. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 rotateVector (const Vec3& original) const IMATH_NOEXCEPT; /// Return the Euclidean inner product. IMATH_HOSTDEVICE constexpr T euclideanInnerProduct (const Quat& q) const IMATH_NOEXCEPT; /// Set the quaterion to be a rotation around the given axis by the /// given angle. /// @return const reference to this. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat& setAxisAngle (const Vec3& axis, T radians) IMATH_NOEXCEPT; /// Set the quaternion to be a rotation that transforms the /// direction vector `fromDirection` to `toDirection` /// @return const reference to this. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat& setRotation (const Vec3& fromDirection, const Vec3& toDirection) IMATH_NOEXCEPT; /// @} /// The base type: In templates that accept a parameter `V`, you /// can refer to `T` as `V::BaseType` typedef T BaseType; private: IMATH_HOSTDEVICE void setRotationInternal (const Vec3& f0, const Vec3& t0, Quat& q) IMATH_NOEXCEPT; }; template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat slerp (const Quat& q1, const Quat& q2, T t) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat slerpShortestArc (const Quat& q1, const Quat& q2, T t) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat squad (const Quat& q1, const Quat& q2, const Quat& qa, const Quat& qb, T t) IMATH_NOEXCEPT; /// /// From advanced Animation and Rendering Techniques by Watt and Watt, /// Page 366: /// /// computing the inner quadrangle points (qa and qb) to guarantee /// tangent continuity. template IMATH_HOSTDEVICE void intermediate (const Quat& q0, const Quat& q1, const Quat& q2, const Quat& q3, Quat& qa, Quat& qb) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Matrix33 operator* (const Matrix33& M, const Quat& q) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Matrix33 operator* (const Quat& q, const Matrix33& M) IMATH_NOEXCEPT; template std::ostream& operator<< (std::ostream& o, const Quat& q); template IMATH_HOSTDEVICE constexpr Quat operator* (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator/ (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator/ (const Quat& q, T t) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator* (const Quat& q, T t) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator* (T t, const Quat& q) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator+ (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator- (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator~ (const Quat& q) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE constexpr Quat operator- (const Quat& q) IMATH_NOEXCEPT; template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 operator* (const Vec3& v, const Quat& q) IMATH_NOEXCEPT; /// Quaternion of type float typedef Quat Quatf; /// Quaternion of type double typedef Quat Quatd; //--------------- // Implementation //--------------- template IMATH_HOSTDEVICE constexpr inline Quat::Quat() IMATH_NOEXCEPT : r (1), v (0, 0, 0) { // empty } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat::Quat (const Quat& q) IMATH_NOEXCEPT : r (q.r), v (q.v) { // empty } template IMATH_HOSTDEVICE constexpr inline Quat::Quat (T s, T i, T j, T k) IMATH_NOEXCEPT : r (s), v (i, j, k) { // empty } template IMATH_HOSTDEVICE constexpr inline Quat::Quat (T s, Vec3 d) IMATH_NOEXCEPT : r (s), v (d) { // empty } template IMATH_HOSTDEVICE constexpr inline Quat::Quat (const Quat& q) IMATH_NOEXCEPT : r (q.r), v (q.v) { // empty } template IMATH_HOSTDEVICE constexpr inline Quat Quat::identity() IMATH_NOEXCEPT { return Quat(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator= (const Quat& q) IMATH_NOEXCEPT { r = q.r; v = q.v; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator*= (const Quat& q) IMATH_NOEXCEPT { T rtmp = r * q.r - (v ^ q.v); v = r * q.v + v * q.r + v % q.v; r = rtmp; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator*= (T t) IMATH_NOEXCEPT { r *= t; v *= t; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator/= (const Quat& q) IMATH_NOEXCEPT { *this = *this * q.inverse(); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator/= (T t) IMATH_NOEXCEPT { r /= t; v /= t; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator+= (const Quat& q) IMATH_NOEXCEPT { r += q.r; v += q.v; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Quat& Quat::operator-= (const Quat& q) IMATH_NOEXCEPT { r -= q.r; v -= q.v; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T& Quat::operator[] (int index) IMATH_NOEXCEPT { return index ? v[index - 1] : r; } template IMATH_HOSTDEVICE constexpr inline T Quat::operator[] (int index) const IMATH_NOEXCEPT { return index ? v[index - 1] : r; } template template IMATH_HOSTDEVICE constexpr inline bool Quat::operator== (const Quat& q) const IMATH_NOEXCEPT { return r == q.r && v == q.v; } template template IMATH_HOSTDEVICE constexpr inline bool Quat::operator!= (const Quat& q) const IMATH_NOEXCEPT { return r != q.r || v != q.v; } /// 4D dot product template IMATH_HOSTDEVICE constexpr inline T operator^ (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { return q1.r * q2.r + (q1.v ^ q2.v); } template IMATH_HOSTDEVICE constexpr inline T Quat::length() const IMATH_NOEXCEPT { return std::sqrt (r * r + (v ^ v)); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat& Quat::normalize() IMATH_NOEXCEPT { if (T l = length()) { r /= l; v /= l; } else { r = 1; v = Vec3 (0); } return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat Quat::normalized() const IMATH_NOEXCEPT { if (T l = length()) return Quat (r / l, v / l); return Quat(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat Quat::inverse() const IMATH_NOEXCEPT { // // 1 Q* // - = ---- where Q* is conjugate (operator~) // Q Q* Q and (Q* Q) == Q ^ Q (4D dot) // T qdot = *this ^ *this; return Quat (r / qdot, -v / qdot); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat& Quat::invert() IMATH_NOEXCEPT { T qdot = (*this) ^ (*this); r /= qdot; v = -v / qdot; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3 Quat::rotateVector (const Vec3& original) const IMATH_NOEXCEPT { // // Given a vector p and a quaternion q (aka this), // calculate p' = qpq* // // Assumes unit quaternions (because non-unit // quaternions cannot be used to rotate vectors // anyway). // Quat vec (0, original); // temporarily promote grade of original Quat inv (*this); inv.v *= -1; // unit multiplicative inverse Quat result = *this * vec * inv; return result.v; } template IMATH_HOSTDEVICE constexpr inline T Quat::euclideanInnerProduct (const Quat& q) const IMATH_NOEXCEPT { return r * q.r + v.x * q.v.x + v.y * q.v.y + v.z * q.v.z; } /// /// Compute the angle between two quaternions, /// interpreting the quaternions as 4D vectors. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T angle4D (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { Quat d = q1 - q2; T lengthD = std::sqrt (d ^ d); Quat s = q1 + q2; T lengthS = std::sqrt (s ^ s); return 2 * std::atan2 (lengthD, lengthS); } /// /// Spherical linear interpolation. /// Assumes q1 and q2 are normalized and that q1 != -q2. /// /// This method does *not* interpolate along the shortest /// arc between q1 and q2. If you desire interpolation /// along the shortest arc, and q1^q2 is negative, then /// consider calling slerpShortestArc(), below, or flipping /// the second quaternion explicitly. /// /// The implementation of squad() depends on a slerp() /// that interpolates as is, without the automatic /// flipping. /// /// Don Hatch explains the method we use here on his /// web page, The Right Way to Calculate Stuff, at /// http://www.plunk.org/~hatch/rightway.php template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat slerp (const Quat& q1, const Quat& q2, T t) IMATH_NOEXCEPT { T a = angle4D (q1, q2); T s = 1 - t; Quat q = sinx_over_x (s * a) / sinx_over_x (a) * s * q1 + sinx_over_x (t * a) / sinx_over_x (a) * t * q2; return q.normalized(); } /// /// Spherical linear interpolation along the shortest /// arc from q1 to either q2 or -q2, whichever is closer. /// Assumes q1 and q2 are unit quaternions. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat slerpShortestArc (const Quat& q1, const Quat& q2, T t) IMATH_NOEXCEPT { if ((q1 ^ q2) >= 0) return slerp (q1, q2, t); else return slerp (q1, -q2, t); } /// /// Spherical Cubic Spline Interpolation - from Advanced Animation and /// Rendering Techniques by Watt and Watt, Page 366: /// /// A spherical curve is constructed using three spherical linear /// interpolations of a quadrangle of unit quaternions: q1, qa, qb, /// q2. Given a set of quaternion keys: q0, q1, q2, q3, this routine /// does the interpolation between q1 and q2 by constructing two /// intermediate quaternions: qa and qb. The qa and qb are computed by /// the intermediate function to guarantee the continuity of tangents /// across adjacent cubic segments. The qa represents in-tangent for /// q1 and the qb represents the out-tangent for q2. /// /// The q1 q2 is the cubic segment being interpolated. /// /// The q0 is from the previous adjacent segment and q3 is from the /// next adjacent segment. The q0 and q3 are used in computing qa and /// qb. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat spline (const Quat& q0, const Quat& q1, const Quat& q2, const Quat& q3, T t) IMATH_NOEXCEPT { Quat qa = intermediate (q0, q1, q2); Quat qb = intermediate (q1, q2, q3); Quat result = squad (q1, qa, qb, q2, t); return result; } /// /// Spherical Quadrangle Interpolation - from Advanced Animation and /// Rendering Techniques by Watt and Watt, Page 366: /// /// It constructs a spherical cubic interpolation as a series of three /// spherical linear interpolations of a quadrangle of unit /// quaternions. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat squad (const Quat& q1, const Quat& qa, const Quat& qb, const Quat& q2, T t) IMATH_NOEXCEPT { Quat r1 = slerp (q1, q2, t); Quat r2 = slerp (qa, qb, t); Quat result = slerp (r1, r2, 2 * t * (1 - t)); return result; } /// Compute the intermediate point between three quaternions `q0`, `q1`, /// and `q2`. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat intermediate (const Quat& q0, const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { Quat q1inv = q1.inverse(); Quat c1 = q1inv * q2; Quat c2 = q1inv * q0; Quat c3 = (T) (-0.25) * (c2.log() + c1.log()); Quat qa = q1 * c3.exp(); qa.normalize(); return qa; } template IMATH_HOSTDEVICE inline Quat Quat::log() const IMATH_NOEXCEPT { // // For unit quaternion, from Advanced Animation and // Rendering Techniques by Watt and Watt, Page 366: // T theta = std::acos (std::min (r, (T) 1.0)); if (theta == 0) return Quat (0, v); T sintheta = std::sin (theta); T k; if (std::abs(sintheta) < 1 && std::abs(theta) >= std::numeric_limits::max() * std::abs(sintheta)) k = 1; else k = theta / sintheta; return Quat ((T) 0, v.x * k, v.y * k, v.z * k); } template IMATH_HOSTDEVICE inline Quat Quat::exp() const IMATH_NOEXCEPT { // // For pure quaternion (zero scalar part): // from Advanced Animation and Rendering // Techniques by Watt and Watt, Page 366: // T theta = v.length(); T sintheta = std::sin (theta); T k; if (abs (theta) < 1 && abs (sintheta) >= std::numeric_limits::max() * abs (theta)) k = 1; else k = sintheta / theta; T costheta = std::cos (theta); return Quat (costheta, v.x * k, v.y * k, v.z * k); } template IMATH_HOSTDEVICE constexpr inline T Quat::angle() const IMATH_NOEXCEPT { return 2 * std::atan2 (v.length(), r); } template IMATH_HOSTDEVICE constexpr inline Vec3 Quat::axis() const IMATH_NOEXCEPT { return v.normalized(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat& Quat::setAxisAngle (const Vec3& axis, T radians) IMATH_NOEXCEPT { r = std::cos (radians / 2); v = axis.normalized() * std::sin (radians / 2); return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Quat& Quat::setRotation (const Vec3& from, const Vec3& to) IMATH_NOEXCEPT { // // Create a quaternion that rotates vector from into vector to, // such that the rotation is around an axis that is the cross // product of from and to. // // This function calls function setRotationInternal(), which is // numerically accurate only for rotation angles that are not much // greater than pi/2. In order to achieve good accuracy for angles // greater than pi/2, we split large angles in half, and rotate in // two steps. // // // Normalize from and to, yielding f0 and t0. // Vec3 f0 = from.normalized(); Vec3 t0 = to.normalized(); if ((f0 ^ t0) >= 0) { // // The rotation angle is less than or equal to pi/2. // setRotationInternal (f0, t0, *this); } else { // // The angle is greater than pi/2. After computing h0, // which is halfway between f0 and t0, we rotate first // from f0 to h0, then from h0 to t0. // Vec3 h0 = (f0 + t0).normalized(); if ((h0 ^ h0) != 0) { setRotationInternal (f0, h0, *this); Quat q; setRotationInternal (h0, t0, q); *this *= q; } else { // // f0 and t0 point in exactly opposite directions. // Pick an arbitrary axis that is orthogonal to f0, // and rotate by pi. // r = T (0); Vec3 f02 = f0 * f0; if (f02.x <= f02.y && f02.x <= f02.z) v = (f0 % Vec3 (1, 0, 0)).normalized(); else if (f02.y <= f02.z) v = (f0 % Vec3 (0, 1, 0)).normalized(); else v = (f0 % Vec3 (0, 0, 1)).normalized(); } } return *this; } template IMATH_HOSTDEVICE inline void Quat::setRotationInternal (const Vec3& f0, const Vec3& t0, Quat& q) IMATH_NOEXCEPT { // // The following is equivalent to setAxisAngle(n,2*phi), // where the rotation axis, n, is orthogonal to the f0 and // t0 vectors, and 2*phi is the angle between f0 and t0. // // This function is called by setRotation(), above; it assumes // that f0 and t0 are normalized and that the angle between // them is not much greater than pi/2. This function becomes // numerically inaccurate if f0 and t0 point into nearly // opposite directions. // // // Find a normalized vector, h0, that is halfway between f0 and t0. // The angle between f0 and h0 is phi. // Vec3 h0 = (f0 + t0).normalized(); // // Store the rotation axis and rotation angle. // q.r = f0 ^ h0; // f0 ^ h0 == cos (phi) q.v = f0 % h0; // (f0 % h0).length() == sin (phi) } template IMATH_HOSTDEVICE constexpr inline Matrix33 Quat::toMatrix33() const IMATH_NOEXCEPT { return Matrix33 (1 - 2 * (v.y * v.y + v.z * v.z), 2 * (v.x * v.y + v.z * r), 2 * (v.z * v.x - v.y * r), 2 * (v.x * v.y - v.z * r), 1 - 2 * (v.z * v.z + v.x * v.x), 2 * (v.y * v.z + v.x * r), 2 * (v.z * v.x + v.y * r), 2 * (v.y * v.z - v.x * r), 1 - 2 * (v.y * v.y + v.x * v.x)); } template IMATH_HOSTDEVICE constexpr inline Matrix44 Quat::toMatrix44() const IMATH_NOEXCEPT { return Matrix44 (1 - 2 * (v.y * v.y + v.z * v.z), 2 * (v.x * v.y + v.z * r), 2 * (v.z * v.x - v.y * r), 0, 2 * (v.x * v.y - v.z * r), 1 - 2 * (v.z * v.z + v.x * v.x), 2 * (v.y * v.z + v.x * r), 0, 2 * (v.z * v.x + v.y * r), 2 * (v.y * v.z - v.x * r), 1 - 2 * (v.y * v.y + v.x * v.x), 0, 0, 0, 0, 1); } /// Transform the quaternion by the matrix /// @return M * q template IMATH_HOSTDEVICE constexpr inline Matrix33 operator* (const Matrix33& M, const Quat& q) IMATH_NOEXCEPT { return M * q.toMatrix33(); } /// Transform the matrix by the quaterion: /// @return q * M template IMATH_HOSTDEVICE constexpr inline Matrix33 operator* (const Quat& q, const Matrix33& M) IMATH_NOEXCEPT { return q.toMatrix33() * M; } /// Stream output as "(r x y z)" template std::ostream& operator<< (std::ostream& o, const Quat& q) { return o << "(" << q.r << " " << q.v.x << " " << q.v.y << " " << q.v.z << ")"; } /// Quaterion multiplication template IMATH_HOSTDEVICE constexpr inline Quat operator* (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { return Quat (q1.r * q2.r - (q1.v ^ q2.v), q1.r * q2.v + q1.v * q2.r + q1.v % q2.v); } /// Quaterion division template IMATH_HOSTDEVICE constexpr inline Quat operator/ (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { return q1 * q2.inverse(); } /// Quaterion division template IMATH_HOSTDEVICE constexpr inline Quat operator/ (const Quat& q, T t) IMATH_NOEXCEPT { return Quat (q.r / t, q.v / t); } /// Quaterion*scalar multiplication /// @return q * t template IMATH_HOSTDEVICE constexpr inline Quat operator* (const Quat& q, T t) IMATH_NOEXCEPT { return Quat (q.r * t, q.v * t); } /// Quaterion*scalar multiplication /// @return q * t template IMATH_HOSTDEVICE constexpr inline Quat operator* (T t, const Quat& q) IMATH_NOEXCEPT { return Quat (q.r * t, q.v * t); } /// Quaterion addition template IMATH_HOSTDEVICE constexpr inline Quat operator+ (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { return Quat (q1.r + q2.r, q1.v + q2.v); } /// Quaterion subtraction template IMATH_HOSTDEVICE constexpr inline Quat operator- (const Quat& q1, const Quat& q2) IMATH_NOEXCEPT { return Quat (q1.r - q2.r, q1.v - q2.v); } /// Compute the conjugate template IMATH_HOSTDEVICE constexpr inline Quat operator~ (const Quat& q) IMATH_NOEXCEPT { return Quat (q.r, -q.v); } /// Negate the quaterion template IMATH_HOSTDEVICE constexpr inline Quat operator- (const Quat& q) IMATH_NOEXCEPT { return Quat (-q.r, -q.v); } /// Quaterion*vector multiplcation /// @return v * q template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3 operator* (const Vec3& v, const Quat& q) IMATH_NOEXCEPT { Vec3 a = q.v % v; Vec3 b = q.v % a; return v + T (2) * (q.r * a + b); } #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER # pragma warning(pop) #endif IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHQUAT_H Imath-3.1.4/src/Imath/ImathRandom.cpp000066400000000000000000000104311417213455000173220ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // //----------------------------------------------------------------------------- // // Routines that generate pseudo-random numbers compatible // with the standard erand48(), nrand48(), etc. functions. // //----------------------------------------------------------------------------- #include "ImathRandom.h" #include IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER namespace { // // Static state used by Imath::drand48(), Imath::lrand48() and Imath::srand48() // unsigned short staticState[3] = { 0, 0, 0 }; void rand48Next (unsigned short state[3]) { // // drand48() and friends are all based on a linear congruential // sequence, // // x[n+1] = (a * x[n] + c) % m, // // where a and c are as specified below, and m == (1 << 48) // static const uint64_t a = uint64_t (0x5deece66dLL); static const uint64_t c = uint64_t (0xbLL); // // Assemble the 48-bit value x[n] from the // three 16-bit values stored in state. // // clang-format off uint64_t x = (uint64_t (state[2]) << 32) | (uint64_t (state[1]) << 16) | uint64_t (state[0]); // clang-format on // // Compute x[n+1], except for the "modulo m" part. // x = a * x + c; // // Disassemble the 48 least significant bits of x[n+1] into // three 16-bit values. Discard the 16 most significant bits; // this takes care of the "modulo m" operation. // // We assume that sizeof (unsigned short) == 2. // state[2] = (unsigned short) (x >> 32); state[1] = (unsigned short) (x >> 16); state[0] = (unsigned short) (x); } } // namespace /// /// Generate double-precision floating-point values between 0.0 and 1.0: /// /// The exponent is set to 0x3ff, which indicates a value greater /// than or equal to 1.0, and less than 2.0. The 48 most significant /// bits of the significand (mantissa) are filled with pseudo-random /// bits generated by rand48Next(). The remaining 4 bits are a copy /// of the 4 most significant bits of the significand. This results /// in bit patterns between 0x3ff0000000000000 and 0x3fffffffffffffff, /// which correspond to uniformly distributed floating-point values /// between 1.0 and 1.99999999999999978. Subtracting 1.0 from those /// values produces numbers between 0.0 and 0.99999999999999978, that /// is, between 0.0 and 1.0-DBL_EPSILON. double erand48 (unsigned short state[3]) { rand48Next (state); union { double d; uint64_t i; } u; // clang-format off u.i = (uint64_t (0x3ff) << 52) | // sign and exponent (uint64_t (state[2]) << 36) | // significand (uint64_t (state[1]) << 20) | (uint64_t (state[0]) << 4) | (uint64_t (state[2]) >> 12); // clang-format on return u.d - 1; } /// Return erand48() double drand48() { return IMATH_INTERNAL_NAMESPACE::erand48 (staticState); } /// Generate uniformly distributed integers between 0 and 0x7fffffff. long int nrand48 (unsigned short state[3]) { rand48Next (state); // clang-format off return ((long int) (state[2]) << 15) | ((long int) (state[1]) >> 1); // clang-format on } /// Return nrand48() long int lrand48() { return IMATH_INTERNAL_NAMESPACE::nrand48 (staticState); } void srand48 (long int seed) { staticState[2] = (unsigned short) (seed >> 16); staticState[1] = (unsigned short) (seed); staticState[0] = 0x330e; } float Rand32::nextf() { // // Generate single-precision floating-point values between 0.0 and 1.0: // // The exponent is set to 0x7f, which indicates a value greater than // or equal to 1.0, and less than 2.0. The 23 bits of the significand // (mantissa) are filled with pseudo-random bits generated by // Rand32::next(). This results in in bit patterns between 0x3f800000 // and 0x3fffffff, which correspond to uniformly distributed floating- // point values between 1.0 and 1.99999988. Subtracting 1.0 from // those values produces numbers between 0.0 and 0.99999988, that is, // between 0.0 and 1.0-FLT_EPSILON. // next(); union { float f; unsigned int i; } u; u.i = 0x3f800000 | (_state & 0x7fffff); return u.f - 1; } IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT Imath-3.1.4/src/Imath/ImathRandom.h000066400000000000000000000152151417213455000167740ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Generators for uniformly distributed pseudo-random numbers and // functions that use those generators to generate numbers with // non-uniform distributions // // Note: class Rand48() calls erand48() and nrand48(), which are not // available on all operating systems. For compatibility we include // our own versions of erand48() and nrand48(). Our functions // have been reverse-engineered from the corresponding Unix/Linux // man page. // #ifndef INCLUDED_IMATHRANDOM_H #define INCLUDED_IMATHRANDOM_H #include "ImathExport.h" #include "ImathNamespace.h" #include #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// Fast random-number generator that generates /// a uniformly distributed sequence with a period /// length of 2^32. class IMATH_EXPORT Rand32 { public: /// Constructor, given a seed IMATH_HOSTDEVICE Rand32 (unsigned long int seed = 0); /// Re-initialize with a given seed IMATH_HOSTDEVICE void init (unsigned long int seed); /// Get the next value in the sequence (range: [false, true]) IMATH_HOSTDEVICE bool nextb(); /// Get the next value in the sequence (range: [0 ... 0xffffffff]) IMATH_HOSTDEVICE unsigned long int nexti(); /// Get the next value in the sequence (range: [0 ... 1[) IMATH_HOSTDEVICE float nextf(); /// Get the next value in the sequence (range [rangeMin ... rangeMax[) IMATH_HOSTDEVICE float nextf (float rangeMin, float rangeMax); private: IMATH_HOSTDEVICE void next(); unsigned long int _state; }; /// Random-number generator based on the C Standard Library /// functions erand48(), nrand48() & company; generates a /// uniformly distributed sequence. class Rand48 { public: /// Constructor IMATH_HOSTDEVICE Rand48 (unsigned long int seed = 0); /// Re-initialize with a given seed IMATH_HOSTDEVICE void init (unsigned long int seed); /// Get the next value in the sequence (range: [false, true]) IMATH_HOSTDEVICE bool nextb(); /// Get the next value in the sequence (range: [0 ... 0x7fffffff]) IMATH_HOSTDEVICE long int nexti(); /// Get the next value in the sequence (range: [0 ... 1[) IMATH_HOSTDEVICE double nextf(); /// Get the next value in the sequence (range [rangeMin ... rangeMax[) IMATH_HOSTDEVICE double nextf (double rangeMin, double rangeMax); private: unsigned short int _state[3]; }; /// Return random points uniformly distributed in a sphere with /// radius 1 around the origin (distance from origin <= 1). template IMATH_HOSTDEVICE Vec solidSphereRand (Rand& rand); /// Return random points uniformly distributed on the surface of /// a sphere with radius 1 around the origin. template IMATH_HOSTDEVICE Vec hollowSphereRand (Rand& rand); /// Return random numbers with a normal (Gaussian) /// distribution with zero mean and unit variance. template IMATH_HOSTDEVICE float gaussRand (Rand& rand); /// Return random points whose distance from the origin /// has a normal (Gaussian) distribution with zero mean /// and unit variance. template IMATH_HOSTDEVICE Vec gaussSphereRand (Rand& rand); //--------------------------------- // erand48(), nrand48() and friends //--------------------------------- /// @cond Doxygen_Suppress IMATH_HOSTDEVICE IMATH_EXPORT double erand48 (unsigned short state[3]); IMATH_HOSTDEVICE IMATH_EXPORT double drand48(); IMATH_HOSTDEVICE IMATH_EXPORT long int nrand48 (unsigned short state[3]); IMATH_HOSTDEVICE IMATH_EXPORT long int lrand48(); IMATH_HOSTDEVICE IMATH_EXPORT void srand48 (long int seed); /// @endcond //--------------- // Implementation //--------------- IMATH_HOSTDEVICE inline void Rand32::init (unsigned long int seed) { _state = (seed * 0xa5a573a5L) ^ 0x5a5a5a5aL; } IMATH_HOSTDEVICE inline Rand32::Rand32 (unsigned long int seed) { init (seed); } IMATH_HOSTDEVICE inline void Rand32::next() { _state = 1664525L * _state + 1013904223L; } IMATH_HOSTDEVICE inline bool Rand32::nextb() { next(); // Return the 31st (most significant) bit, by and-ing with 2 ^ 31. return !!(_state & 2147483648UL); } IMATH_HOSTDEVICE inline unsigned long int Rand32::nexti() { next(); return _state & 0xffffffff; } IMATH_HOSTDEVICE inline float Rand32::nextf (float rangeMin, float rangeMax) { float f = nextf(); return rangeMin * (1 - f) + rangeMax * f; } IMATH_HOSTDEVICE inline void Rand48::init (unsigned long int seed) { seed = (seed * 0xa5a573a5L) ^ 0x5a5a5a5aL; _state[0] = (unsigned short int) (seed & 0xFFFF); _state[1] = (unsigned short int) ((seed >> 16) & 0xFFFF); _state[2] = (unsigned short int) (seed & 0xFFFF); } IMATH_HOSTDEVICE inline Rand48::Rand48 (unsigned long int seed) { init (seed); } IMATH_HOSTDEVICE inline bool Rand48::nextb() { return nrand48 (_state) & 1; } IMATH_HOSTDEVICE inline long int Rand48::nexti() { return nrand48 (_state); } IMATH_HOSTDEVICE inline double Rand48::nextf() { return erand48 (_state); } IMATH_HOSTDEVICE inline double Rand48::nextf (double rangeMin, double rangeMax) { double f = nextf(); return rangeMin * (1 - f) + rangeMax * f; } template IMATH_HOSTDEVICE Vec solidSphereRand (Rand& rand) { Vec v; do { for (unsigned int i = 0; i < Vec::dimensions(); i++) v[i] = (typename Vec::BaseType) rand.nextf (-1, 1); } while (v.length2() > 1); return v; } template IMATH_HOSTDEVICE Vec hollowSphereRand (Rand& rand) { Vec v; typename Vec::BaseType length; do { for (unsigned int i = 0; i < Vec::dimensions(); i++) v[i] = (typename Vec::BaseType) rand.nextf (-1, 1); length = v.length(); } while (length > 1 || length == 0); return v / length; } template IMATH_HOSTDEVICE float gaussRand (Rand& rand) { float x; // Note: to avoid numerical problems with very small float y; // numbers, we make these variables singe-precision float length2; // floats, but later we call the double-precision log() // and sqrt() functions instead of logf() and sqrtf(). do { x = float (rand.nextf (-1, 1)); y = float (rand.nextf (-1, 1)); length2 = x * x + y * y; } while (length2 >= 1 || length2 == 0); return x * sqrt (-2 * log (double (length2)) / length2); } template IMATH_HOSTDEVICE Vec gaussSphereRand (Rand& rand) { return hollowSphereRand (rand) * gaussRand (rand); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHRANDOM_H Imath-3.1.4/src/Imath/ImathRoots.h000066400000000000000000000117461417213455000166670ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Functions to solve linear, quadratic or cubic equations // // Note: It is possible that an equation has real solutions, but that // the solutions (or some intermediate result) are not representable. // In this case, either some of the solutions returned are invalid // (nan or infinity), or, if floating-point exceptions have been // enabled, an exception is thrown. // #ifndef INCLUDED_IMATHROOTS_H #define INCLUDED_IMATHROOTS_H #include "ImathMath.h" #include "ImathNamespace.h" #include /// @cond Doxygen_Suppress #ifdef __CUDACC__ # include # define COMPLEX_NAMESPACE thrust #else # define COMPLEX_NAMESPACE std #endif /// @endcond IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// Solve for x in the linear equation: /// /// a * x + b == 0 /// /// @return 1 if the equation has a solution, 0 if there is no /// solution, and -1 if all real numbers are solutions. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 int solveLinear (T a, T b, T& x); /// /// Solve for x in the quadratic equation: /// /// a * x*x + b * x + c == 0 /// /// @return 2 if the equation has two solutions, 1 if the equation has /// a single solution, 0 if there is no solution, and -1 if all real /// numbers are solutions. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 int solveQuadratic (T a, T b, T c, T x[2]); template /// /// Solve for x in the normalized cubic equation: /// /// x*x*x + r * x*x + s * x + t == 0 /// /// The equation is solved using Cardano's Formula; even though only /// real solutions are produced, some intermediate results are complex /// (std::complex). /// /// @return 0 if there is no solution, and -1 if all real /// numbers are solutions, otherwise return the number of solutions. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 int solveNormalizedCubic (T r, T s, T t, T x[3]); /// /// Solve for x in the cubic equation: /// /// a * x*x*x + b * x*x + c * x + d == 0 /// /// The equation is solved using Cardano's Formula; even though only /// real solutions are produced, some intermediate results are complex /// (std::complex). /// /// @return 0 if there is no solution, and -1 if all real /// numbers are solutions, otherwise return the number of solutions. template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 int solveCubic (T a, T b, T c, T d, T x[3]); //--------------- // Implementation //--------------- template IMATH_CONSTEXPR14 int solveLinear (T a, T b, T& x) { if (a != 0) { x = -b / a; return 1; } else if (b != 0) { return 0; } else { return -1; } } template IMATH_CONSTEXPR14 int solveQuadratic (T a, T b, T c, T x[2]) { if (a == 0) { return solveLinear (b, c, x[0]); } else { T D = b * b - 4 * a * c; if (D > 0) { T s = std::sqrt (D); T q = -(b + (b > 0 ? 1 : -1) * s) / T (2); x[0] = q / a; x[1] = c / q; return 2; } if (D == 0) { x[0] = -b / (2 * a); return 1; } else { return 0; } } } template IMATH_CONSTEXPR14 int solveNormalizedCubic (T r, T s, T t, T x[3]) { T p = (3 * s - r * r) / 3; T q = 2 * r * r * r / 27 - r * s / 3 + t; T p3 = p / 3; T q2 = q / 2; T D = p3 * p3 * p3 + q2 * q2; if (D == 0 && p3 == 0) { x[0] = -r / 3; x[1] = -r / 3; x[2] = -r / 3; return 1; } if (D > 0) { auto real_root = [] (T a, T x) -> T { T sign = std::copysign(T(1), a); return sign * std::pow (sign * a, T (1) / x); }; T u = real_root (-q / 2 + std::sqrt (D), 3); T v = -p / (T (3) * u); x[0] = u + v - r / 3; return 1; } namespace CN = COMPLEX_NAMESPACE; CN::complex u = CN::pow (-q / 2 + CN::sqrt (CN::complex (D)), T (1) / T (3)); CN::complex v = -p / (T (3) * u); const T sqrt3 = T (1.73205080756887729352744634150587); // enough digits // for long double CN::complex y0 (u + v); CN::complex y1 (-(u + v) / T (2) + (u - v) / T (2) * CN::complex (0, sqrt3)); CN::complex y2 (-(u + v) / T (2) - (u - v) / T (2) * CN::complex (0, sqrt3)); if (D == 0) { x[0] = y0.real() - r / 3; x[1] = y1.real() - r / 3; return 2; } else { x[0] = y0.real() - r / 3; x[1] = y1.real() - r / 3; x[2] = y2.real() - r / 3; return 3; } } template IMATH_CONSTEXPR14 int solveCubic (T a, T b, T c, T d, T x[3]) { if (a == 0) { return solveQuadratic (b, c, d, x); } else { return solveNormalizedCubic (b / a, c / a, d / a, x); } } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHROOTS_H Imath-3.1.4/src/Imath/ImathShear.h000066400000000000000000000440641417213455000166220ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A representation of a shear transformation // #ifndef INCLUDED_IMATHSHEAR_H #define INCLUDED_IMATHSHEAR_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathMath.h" #include "ImathVec.h" #include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// Shear6 class template. /// /// A shear matrix is technically defined as having a single nonzero /// off-diagonal element; more generally, a shear transformation is /// defined by those off-diagonal elements, so in 3D, that means there /// are 6 possible elements/coefficients: /// /// | X' | | 1 YX ZX 0 | | X | /// | Y' | | XY 1 ZY 0 | | Y | /// | Z' | = | XZ YZ 1 0 | = | Z | /// | 1 | | 0 0 0 1 | | 1 | /// /// X' = X + YX * Y + ZX * Z /// Y' = YX * X + Y + ZY * Z /// Z` = XZ * X + YZ * Y + Z /// /// See /// https://www.cs.drexel.edu/~david/Classes/CS430/Lectures/L-04_3DTransformations.6.pdf /// /// Those variable elements correspond to the 6 values in a Shear6. /// So, looking at those equations, "Shear YX", for example, means /// that for any point transformed by that matrix, its X values will /// have some of their Y values added. If you're talking /// about "Axis A has values from Axis B added to it", there are 6 /// permutations for A and B (XY, XZ, YX, YZ, ZX, ZY). /// /// Not that Maya has only three values, which represent the /// lower/upper (depending on column/row major) triangle of the /// matrix. Houdini is the same as Maya (see /// https://www.sidefx.com/docs/houdini/props/obj.html) in this /// respect. /// /// There's another way to look at it. A general affine transformation /// in 3D has 12 degrees of freedom - 12 "available" elements in the /// 4x4 matrix since a single row/column must be (0,0,0,1). If you /// add up the degrees of freedom from Maya: /// /// - 3 translation /// - 3 rotation /// - 3 scale /// - 3 shear /// /// You obviously get the full 12. So technically, the Shear6 option /// of having all 6 shear options is overkill; Imath/Shear6 has 15 /// values for a 12-degree-of-freedom transformation. This means that /// any nonzero values in those last 3 shear coefficients can be /// represented in those standard 12 degrees of freedom. Here's a /// python example of how to do that: /// /// /// >>> import imath /// >>> M = imath.M44f() /// >>> s = imath.V3f() /// >>> h = imath.V3f() /// >>> r = imath.V3f() /// >>> t = imath.V3f() /// # Use Shear.YX (index 3), which is an "extra" shear value /// >>> M.setShear((0,0,0,1,0,0)) /// M44f((1, 1, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)) /// >>> M.extractSHRT(s, h, r, t) /// 1 /// >>> s /// V3f(1.41421354, 0.707106769, 1) /// >>> h /// V3f(1, 0, 0) /// >>> r /// V3f(0, -0, 0.785398185) /// >>> t /// V3f(0, 0, 0) /// /// That shows how to decompose a transform matrix with one of those /// "extra" shear coefficients into those standard 12 degrees of /// freedom. But it's not necessarily intuitive; in this case, a /// single non-zero shear coefficient resulted in a transform that has /// non-uniform scale, a single "standard" shear value, and some /// rotation. /// /// So, it would seem that any transform with those extra shear /// values set could be translated into Maya to produce the exact same /// transformation matrix; but doing this is probably pretty /// undesirable, since the result would have some surprising values on /// the other transformation attributes, despite being technically /// correct. /// /// This usage of "degrees of freedom" is a bit hand-wavey here; /// having a total of 12 inputs into the construction of a standard /// transformation matrix doesn't necessarily mean that the matrix has /// 12 true degrees of freedom, but the standard /// translation/rotation/scale/shear matrices have the right /// construction to ensure that. /// template class IMATH_EXPORT_TEMPLATE_TYPE Shear6 { public: /// @{ /// @name Direct access to members T xy, xz, yz, yx, zx, zy; /// @} /// Element access IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i); /// Element access IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const; /// @{ /// @name Constructors and Assignment /// Initialize to 0 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6(); /// Initialize to the given XY, XZ, YZ values IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6 (T XY, T XZ, T YZ); /// Initialize to the given XY, XZ, YZ values held in (v.x, v.y, v.z) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6 (const Vec3& v); /// Initialize to the given XY, XZ, YZ values held in (v.x, v.y, v.z) template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6 (const Vec3& v); /// Initialize to the given (XY XZ YZ YX ZX ZY) values IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY); /// Copy constructor IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6 (const Shear6& h); /// Construct from a Shear6 object of another base type template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Shear6 (const Shear6& h); /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator= (const Shear6& h); /// Assignment from vector template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator= (const Vec3& v); /// Destructor IMATH_HOSTDEVICE ~Shear6() = default; /// @} /// @{ /// @name Compatibility with Sb /// Set the value template IMATH_HOSTDEVICE void setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY); /// Set the value template IMATH_HOSTDEVICE void setValue (const Shear6& h); /// Return the values template IMATH_HOSTDEVICE void getValue (S& XY, S& XZ, S& YZ, S& YX, S& ZX, S& ZY) const; /// Return the value in `h` template IMATH_HOSTDEVICE void getValue (Shear6& h) const; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE T* getValue(); /// Return a raw pointer to the array of values IMATH_HOSTDEVICE const T* getValue() const; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality template IMATH_HOSTDEVICE constexpr bool operator== (const Shear6& h) const; /// Inequality template IMATH_HOSTDEVICE constexpr bool operator!= (const Shear6& h) const; /// Compare two shears and test if they are "approximately equal": /// @return True if the coefficients of this and h are the same with /// an absolute error of no more than e, i.e., for all i /// abs (this[i] - h[i]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Shear6& h, T e) const; /// Compare two shears and test if they are "approximately equal": /// @return True if the coefficients of this and h are the same with /// a relative error of no more than e, i.e., for all i /// abs (this[i] - h[i]) <= e * abs (this[i]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Shear6& h, T e) const; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator+= (const Shear6& h); /// Component-wise addition IMATH_HOSTDEVICE constexpr Shear6 operator+ (const Shear6& h) const; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator-= (const Shear6& h); /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Shear6 operator- (const Shear6& h) const; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Shear6 operator-() const; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& negate(); /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator*= (const Shear6& h); /// Scalar multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator*= (T a); /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Shear6 operator* (const Shear6& h) const; /// Scalar multiplication IMATH_HOSTDEVICE constexpr Shear6 operator* (T a) const; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator/= (const Shear6& h); /// Scalar division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Shear6& operator/= (T a); /// Component-wise division IMATH_HOSTDEVICE constexpr Shear6 operator/ (const Shear6& h) const; /// Scalar division IMATH_HOSTDEVICE constexpr Shear6 operator/ (T a) const; /// @} /// @{ /// @name Numerical Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of dimensions, i.e. 6 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() { return 6; } /// The base type: In templates that accept a parameter `V` (could /// be a Color4), you can refer to `T` as `V::BaseType` typedef T BaseType; }; /// Stream output, as "(xy xz yz yx zx zy)" template std::ostream& operator<< (std::ostream& s, const Shear6& h); /// Reverse multiplication: scalar * Shear6 template IMATH_HOSTDEVICE constexpr Shear6 operator* (S a, const Shear6& h); /// 3D shear of type float typedef Vec3 Shear3f; /// 3D shear of type double typedef Vec3 Shear3d; /// Shear6 of type float typedef Shear6 Shear6f; /// Shear6 of type double typedef Shear6 Shear6d; //----------------------- // Implementation of Shear6 //----------------------- template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T& Shear6::operator[] (int i) { return (&xy)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE constexpr inline const T& Shear6::operator[] (int i) const { return (&xy)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6() { xy = xz = yz = yx = zx = zy = 0; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6 (T XY, T XZ, T YZ) { xy = XY; xz = XZ; yz = YZ; yx = 0; zx = 0; zy = 0; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6 (const Vec3& v) { xy = v.x; xz = v.y; yz = v.z; yx = 0; zx = 0; zy = 0; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6 (const Vec3& v) { xy = T (v.x); xz = T (v.y); yz = T (v.z); yx = 0; zx = 0; zy = 0; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY) { xy = XY; xz = XZ; yz = YZ; yx = YX; zx = ZX; zy = ZY; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6 (const Shear6& h) { xy = h.xy; xz = h.xz; yz = h.yz; yx = h.yx; zx = h.zx; zy = h.zy; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Shear6::Shear6 (const Shear6& h) { xy = T (h.xy); xz = T (h.xz); yz = T (h.yz); yx = T (h.yx); zx = T (h.zx); zy = T (h.zy); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator= (const Shear6& h) { xy = h.xy; xz = h.xz; yz = h.yz; yx = h.yx; zx = h.zx; zy = h.zy; return *this; } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator= (const Vec3& v) { xy = T (v.x); xz = T (v.y); yz = T (v.z); yx = 0; zx = 0; zy = 0; return *this; } template template IMATH_HOSTDEVICE inline void Shear6::setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY) { xy = T (XY); xz = T (XZ); yz = T (YZ); yx = T (YX); zx = T (ZX); zy = T (ZY); } template template IMATH_HOSTDEVICE inline void Shear6::setValue (const Shear6& h) { xy = T (h.xy); xz = T (h.xz); yz = T (h.yz); yx = T (h.yx); zx = T (h.zx); zy = T (h.zy); } template template IMATH_HOSTDEVICE inline void Shear6::getValue (S& XY, S& XZ, S& YZ, S& YX, S& ZX, S& ZY) const { XY = S (xy); XZ = S (xz); YZ = S (yz); YX = S (yx); ZX = S (zx); ZY = S (zy); } template template IMATH_HOSTDEVICE inline void Shear6::getValue (Shear6& h) const { h.xy = S (xy); h.xz = S (xz); h.yz = S (yz); h.yx = S (yx); h.zx = S (zx); h.zy = S (zy); } template IMATH_HOSTDEVICE inline T* Shear6::getValue() { return (T*) &xy; } template IMATH_HOSTDEVICE inline const T* Shear6::getValue() const { return (const T*) &xy; } template template IMATH_HOSTDEVICE constexpr inline bool Shear6::operator== (const Shear6& h) const { return xy == h.xy && xz == h.xz && yz == h.yz && yx == h.yx && zx == h.zx && zy == h.zy; } template template IMATH_HOSTDEVICE constexpr inline bool Shear6::operator!= (const Shear6& h) const { return xy != h.xy || xz != h.xz || yz != h.yz || yx != h.yx || zx != h.zx || zy != h.zy; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Shear6::equalWithAbsError (const Shear6& h, T e) const { for (int i = 0; i < 6; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], h[i], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Shear6::equalWithRelError (const Shear6& h, T e) const { for (int i = 0; i < 6; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], h[i], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator+= (const Shear6& h) { xy += h.xy; xz += h.xz; yz += h.yz; yx += h.yx; zx += h.zx; zy += h.zy; return *this; } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator+ (const Shear6& h) const { return Shear6 (xy + h.xy, xz + h.xz, yz + h.yz, yx + h.yx, zx + h.zx, zy + h.zy); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator-= (const Shear6& h) { xy -= h.xy; xz -= h.xz; yz -= h.yz; yx -= h.yx; zx -= h.zx; zy -= h.zy; return *this; } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator- (const Shear6& h) const { return Shear6 (xy - h.xy, xz - h.xz, yz - h.yz, yx - h.yx, zx - h.zx, zy - h.zy); } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator-() const { return Shear6 (-xy, -xz, -yz, -yx, -zx, -zy); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::negate() { xy = -xy; xz = -xz; yz = -yz; yx = -yx; zx = -zx; zy = -zy; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator*= (const Shear6& h) { xy *= h.xy; xz *= h.xz; yz *= h.yz; yx *= h.yx; zx *= h.zx; zy *= h.zy; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator*= (T a) { xy *= a; xz *= a; yz *= a; yx *= a; zx *= a; zy *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator* (const Shear6& h) const { return Shear6 (xy * h.xy, xz * h.xz, yz * h.yz, yx * h.yx, zx * h.zx, zy * h.zy); } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator* (T a) const { return Shear6 (xy * a, xz * a, yz * a, yx * a, zx * a, zy * a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator/= (const Shear6& h) { xy /= h.xy; xz /= h.xz; yz /= h.yz; yx /= h.yx; zx /= h.zx; zy /= h.zy; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Shear6& Shear6::operator/= (T a) { xy /= a; xz /= a; yz /= a; yx /= a; zx /= a; zy /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator/ (const Shear6& h) const { return Shear6 (xy / h.xy, xz / h.xz, yz / h.yz, yx / h.yx, zx / h.zx, zy / h.zy); } template IMATH_HOSTDEVICE constexpr inline Shear6 Shear6::operator/ (T a) const { return Shear6 (xy / a, xz / a, yz / a, yx / a, zx / a, zy / a); } //----------------------------- // Stream output implementation //----------------------------- template std::ostream& operator<< (std::ostream& s, const Shear6& h) { return s << '(' << h.xy << ' ' << h.xz << ' ' << h.yz << h.yx << ' ' << h.zx << ' ' << h.zy << ')'; } //----------------------------------------- // Implementation of reverse multiplication //----------------------------------------- template IMATH_HOSTDEVICE constexpr inline Shear6 operator* (S a, const Shear6& h) { return Shear6 (a * h.xy, a * h.xz, a * h.yz, a * h.yx, a * h.zx, a * h.zy); } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHSHEAR_H Imath-3.1.4/src/Imath/ImathSphere.h000066400000000000000000000071121417213455000167770ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // A 3D sphere class template // #ifndef INCLUDED_IMATHSPHERE_H #define INCLUDED_IMATHSPHERE_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathBox.h" #include "ImathLine.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// A 3D sphere /// template class IMATH_EXPORT_TEMPLATE_TYPE Sphere3 { public: /// @{ /// @name Direct access to member fields /// Center Vec3 center; /// Radius T radius; /// @} /// @{ /// @name Constructors /// Default is center at (0,0,0) and radius of 0. IMATH_HOSTDEVICE constexpr Sphere3() : center (0, 0, 0), radius (0) {} /// Initialize to a given center and radius IMATH_HOSTDEVICE constexpr Sphere3 (const Vec3& c, T r) : center (c), radius (r) {} /// @} /// @{ /// @name Manipulation /// Set the center and radius of the sphere so that it tightly /// encloses Box b. IMATH_HOSTDEVICE void circumscribe (const Box>& box); /// @} /// @{ /// @name Utility Methods /// If the sphere and line `l` intersect, then compute the /// smallest `t` with `t>=0` so that `l(t)` is a point on the sphere. /// /// @param[in] l The line /// @param[out] intersection The point of intersection /// @return True if the sphere and line intersect, false if they /// do not. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersect (const Line3& l, Vec3& intersection) const; /// If the sphere and line `l` intersect, then compute the /// smallest `t` with `t>=0` so that `l(t)` is a point on the sphere. /// /// @param[in] l The line /// @param[out] t The parameter of the line at the intersection point /// @return True if the sphere and line intersect, false if they /// do not. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool intersectT (const Line3& l, T& t) const; /// @} }; /// Sphere of type float typedef Sphere3 Sphere3f; /// Sphere of type double typedef Sphere3 Sphere3d; //--------------- // Implementation //--------------- template IMATH_HOSTDEVICE inline void Sphere3::circumscribe (const Box>& box) { center = T (0.5) * (box.min + box.max); radius = (box.max - center).length(); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool Sphere3::intersectT (const Line3& line, T& t) const { bool doesIntersect = true; Vec3 v = line.pos - center; T B = T (2.0) * (line.dir ^ v); T C = (v ^ v) - (radius * radius); // compute discriminant // if negative, there is no intersection T discr = B * B - T (4.0) * C; if (discr < 0.0) { // line and Sphere3 do not intersect doesIntersect = false; } else { // t0: (-B - sqrt(B^2 - 4AC)) / 2A (A = 1) T sqroot = std::sqrt (discr); t = (-B - sqroot) * T (0.5); if (t < 0.0) { // no intersection, try t1: (-B + sqrt(B^2 - 4AC)) / 2A (A = 1) t = (-B + sqroot) * T (0.5); } if (t < 0.0) doesIntersect = false; } return doesIntersect; } template IMATH_CONSTEXPR14 bool Sphere3::intersect (const Line3& line, Vec3& intersection) const { T t (0); if (intersectT (line, t)) { intersection = line (t); return true; } else { return false; } } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHSPHERE_H Imath-3.1.4/src/Imath/ImathTypeTraits.h000066400000000000000000000167171417213455000176740ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // This file contains type traits related to or used by the Imath library. // #ifndef INCLUDED_IMATHTYPETRAITS_H #define INCLUDED_IMATHTYPETRAITS_H #include #include "ImathPlatform.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// Define Imath::enable_if_t to be std for C++14, equivalent for C++11. #if (IMATH_CPLUSPLUS_VERSION >= 14) using std::enable_if_t; // Use C++14 std::enable_if_t #else // Define enable_if_t for C++11 template using enable_if_t = typename std::enable_if::type; #endif /// An enable_if helper to be used in template parameters which results in /// much shorter symbols. #define IMATH_ENABLE_IF(...) IMATH_INTERNAL_NAMESPACE::enable_if_t<(__VA_ARGS__), int> = 0 #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Detecting interoperable types. /// /// In order to construct or assign from external "compatible" types without /// prior knowledge of their definitions, we have a few helper type traits. /// The intent of these is to allow custom linear algebra types in an /// application that have seamless conversion to and from Imath types. /// /// `has_xy`, `has_xyz`, `has_xyzw` detect if class /// `T` has elements `.x`, `.y`, and `.z` all of type `Base` and seems to be /// the right size to hold exactly those members and nothing more. /// /// `has_subscript` detects if class `T` can perform `T[int]` /// to yield a `Base`, and that it seems to be exactly the right size to /// hold `N` of those elements. /// /// This is not exact. It's possible that for a particular user-defined /// type, this may yield a false negative or false positive. For example: /// * A class for a 3-vector that contains an extra element of padding /// so that it will have the right size and alignment to use 4-wide /// SIMD math ops will appear to be the wrong size. /// * A `std::vector` is subscriptable and might have N elements at /// runtime, but the size is dynamic and so would fail this test. /// * A foreign type may have .x, .y, .z that are not matching our base /// type but we still want it to work (with appropriate conversions). /// /// In these cases, user code may declare an exception -- for example, /// stating that `mytype` should be considered implicitly convertible to /// an Imath::V3f by subscripting: /// /// template<> /// struct Imath::has_subscript : public std::true_type { }; /// /// And similarly, user code may correct a potential false positive (that /// is, a `mytype` looks like it should be convertible to a V3f, but you /// don't want it to ever happen): /// /// template /// struct Imath::has_subscript : public std::false_type { }; /// /// `has_xy::value` will be true if type `T` has member variables /// `.x` and `.y`, all of type `Base`, and the size of a `T` is exactly big /// enough to hold 2 Base values. template struct has_xy { private: typedef char Yes[1]; typedef char No[2]; // Valid only if .x, .y exist and are the right type: return a Yes. template::value), IMATH_ENABLE_IF(std::is_same::value)> static Yes& test(int); // Fallback, default to returning a No. template static No& test(...); public: enum { value = (sizeof(test(0)) == sizeof(Yes) && sizeof(T) == 2*sizeof(Base)) }; }; /// `has_xyz::value` will be true if type `T` has member variables /// `.x`, `.y`, and `.z`, all of type `Base`, and the size of a `T` is /// exactly big enough to hold 3 Base values. template struct has_xyz { private: typedef char Yes[1]; typedef char No[2]; // Valid only if .x, .y, .z exist and are the right type: return a Yes. template::value), IMATH_ENABLE_IF(std::is_same::value), IMATH_ENABLE_IF(std::is_same::value)> static Yes& test(int); // Fallback, default to returning a No. template static No& test(...); public: enum { value = (sizeof(test(0)) == sizeof(Yes) && sizeof(T) == 3*sizeof(Base)) }; }; /// `has_xyzw::value` will be true if type `T` has member variables /// `.x`, `.y`, `.z`, and `.w`, all of type `Base`, and the size of a `T` is /// exactly big enough to hold 4 Base values. template struct has_xyzw { private: typedef char Yes[1]; typedef char No[2]; // Valid only if .x, .y, .z, .w exist and are the right type: return a Yes. template::value), IMATH_ENABLE_IF(std::is_same::value), IMATH_ENABLE_IF(std::is_same::value), IMATH_ENABLE_IF(std::is_same::value)> static Yes& test(int); // Fallback, default to returning a No. template static No& test(...); public: enum { value = (sizeof(test(0)) == sizeof(Yes) && sizeof(T) == 4*sizeof(Base)) }; }; /// `has_subscript::value` will be true if type `T` has /// subscripting syntax, a `T[int]` returns a `Base`, and the size of a `T` /// is exactly big enough to hold `Nelem` `Base` values. template struct has_subscript { private: typedef char Yes[1]; typedef char No[2]; // Valid only if T[] is possible and is the right type: return a Yes. template::type, Base>::value)> static Yes& test(int); // Fallback, default to returning a No. template static No& test(...); public: enum { value = (sizeof(test(0)) == sizeof(Yes) && sizeof(T) == Nelem*sizeof(Base)) }; }; /// C arrays of just the right length also are qualified for has_subscript. template struct has_subscript : public std::true_type { }; /// `has_double_subscript::value` will be true if type `T` /// has 2-level subscripting syntax, a `T[int][int]` returns a `Base`, and /// the size of a `T` is exactly big enough to hold `R*C` `Base` values. template struct has_double_subscript { private: typedef char Yes[1]; typedef char No[2]; // Valid only if T[][] is possible and is the right type: return a Yes. template::type, Base>::value)> static Yes& test(int); // Fallback, default to returning a No. template static No& test(...); public: enum { value = (sizeof(test(0)) == sizeof(Yes) && sizeof(T) == (Rows*Cols)*sizeof(Base)) }; }; /// C arrays of just the right length also are qualified for has_double_subscript. template struct has_double_subscript : public std::true_type { }; /// @} #endif IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHTYPETRAITS_H Imath-3.1.4/src/Imath/ImathVec.h000066400000000000000000001747331417213455000163040ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // 2D, 3D and 4D point/vector class templates // #ifndef INCLUDED_IMATHVEC_H #define INCLUDED_IMATHVEC_H #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathTypeTraits.h" #include "ImathMath.h" #include #include #include #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER // suppress exception specification warnings # pragma warning(push) # pragma warning(disable : 4290) #endif IMATH_INTERNAL_NAMESPACE_HEADER_ENTER template class Vec2; template class Vec3; template class Vec4; /// Enum for the Vec4 to Vec3 conversion constructor enum IMATH_EXPORT_ENUM InfException { INF_EXCEPTION }; /// /// 2-element vector /// template class IMATH_EXPORT_TEMPLATE_TYPE Vec2 { public: /// @{ /// @name Direct access to elements T x, y; /// @} /// Element access by index. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT; /// Element access by index. IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT; /// @{ /// @name Constructors and Assignment /// Uninitialized by default IMATH_HOSTDEVICE Vec2() IMATH_NOEXCEPT; /// Initialize to a scalar `(a,a)` IMATH_HOSTDEVICE constexpr explicit Vec2 (T a) IMATH_NOEXCEPT; /// Initialize to given elements `(a,b)` IMATH_HOSTDEVICE constexpr Vec2 (T a, T b) IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE constexpr Vec2 (const Vec2& v) IMATH_NOEXCEPT; /// Construct from Vec2 of another base type template IMATH_HOSTDEVICE constexpr Vec2 (const Vec2& v) IMATH_NOEXCEPT; /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator= (const Vec2& v) IMATH_NOEXCEPT; /// Destructor ~Vec2() IMATH_NOEXCEPT = default; /// @} #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Interoperability with other vector types /// /// Construction and assignment are allowed from other classes that /// appear to be equivalent vector types, provided that they have either /// a subscripting operator, or data members .x and .y, that are of the /// same type as the elements of this vector, and their size appears to /// be the right number of elements. /// /// This functionality is disabled for gcc 4.x, which seems to have a /// compiler bug that results in spurious errors. It can also be /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to /// including any Imath header files. /// template::value)> IMATH_HOSTDEVICE explicit constexpr Vec2 (const V& v) IMATH_NOEXCEPT : Vec2(T(v.x), T(v.y)) { } template::value && !has_xy::value)> IMATH_HOSTDEVICE explicit Vec2 (const V& v) : Vec2(T(v[0]), T(v[1])) { } template::value)> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator= (const V& v) IMATH_NOEXCEPT { x = T(v.x); y = T(v.y); return *this; } template::value && !has_xy::value)> IMATH_HOSTDEVICE const Vec2& operator= (const V& v) { x = T(v[0]); y = T(v[1]); return *this; } #endif /// @{ /// @name Compatibility with Sb /// Set the value template IMATH_HOSTDEVICE void setValue (S a, S b) IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE void setValue (const Vec2& v) IMATH_NOEXCEPT; /// Return the value in `a` and `b` template IMATH_HOSTDEVICE void getValue (S& a, S& b) const IMATH_NOEXCEPT; /// Return the value in `v` template IMATH_HOSTDEVICE void getValue (Vec2& v) const IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality template IMATH_HOSTDEVICE constexpr bool operator== (const Vec2& v) const IMATH_NOEXCEPT; /// Inequality template IMATH_HOSTDEVICE constexpr bool operator!= (const Vec2& v) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and `m` are the same /// with an absolute error of no more than e, i.e., for all i, j: /// /// abs (this[i][j] - m[i][j]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Vec2& v, T e) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and m are the same with /// a relative error of no more than e, i.e., for all i, j: /// /// abs (this[i] - v[i][j]) <= e * abs (this[i][j]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Vec2& v, T e) const IMATH_NOEXCEPT; /// Dot product IMATH_HOSTDEVICE constexpr T dot (const Vec2& v) const IMATH_NOEXCEPT; /// Dot product IMATH_HOSTDEVICE constexpr T operator^ (const Vec2& v) const IMATH_NOEXCEPT; /// Right-handed cross product, i.e. z component of /// Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0) IMATH_HOSTDEVICE constexpr T cross (const Vec2& v) const IMATH_NOEXCEPT; /// Right-handed cross product, i.e. z component of /// Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0) IMATH_HOSTDEVICE constexpr T operator% (const Vec2& v) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator+= (const Vec2& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Vec2 operator+ (const Vec2& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator-= (const Vec2& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Vec2 operator- (const Vec2& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Vec2 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator*= (const Vec2& v) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Vec2 operator* (const Vec2& v) const IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Vec2 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator/= (const Vec2& v) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Vec2 operator/ (const Vec2& v) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Vec2 operator/ (T a) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Query and Manipulation /// Return the Euclidean norm IMATH_HOSTDEVICE T length() const IMATH_NOEXCEPT; /// Return the square of the Euclidean norm, i.e. the dot product /// with itself. IMATH_HOSTDEVICE constexpr T length2() const IMATH_NOEXCEPT; /// Normalize in place. If length()==0, return a null vector. IMATH_HOSTDEVICE const Vec2& normalize() IMATH_NOEXCEPT; /// Normalize in place. If length()==0, throw an exception. const Vec2& normalizeExc(); /// Normalize without any checks for length()==0. Slightly faster /// than the other normalization routines, but if v.length() is /// 0.0, the result is undefined. IMATH_HOSTDEVICE const Vec2& normalizeNonNull() IMATH_NOEXCEPT; /// Return a normalized vector. Does not modify *this. IMATH_HOSTDEVICE Vec2 normalized() const IMATH_NOEXCEPT; /// Return a normalized vector. Does not modify *this. Throw an /// exception if length()==0. Vec2 normalizedExc() const; /// Return a normalized vector. Does not modify *this, and does /// not check for length()==0. Slightly faster than the other /// normalization routines, but if v.length() is 0.0, the result /// is undefined. IMATH_HOSTDEVICE Vec2 normalizedNonNull() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of dimensions, i.e. 2 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 2; } /// The base type: In templates that accept a parameter `V`, you /// can refer to `T` as `V::BaseType` typedef T BaseType; private: IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny() const IMATH_NOEXCEPT; }; /// /// 3-element vector /// template class IMATH_EXPORT_TEMPLATE_TYPE Vec3 { public: /// @{ /// @name Direct access to elements T x, y, z; /// @} /// Element access by index. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT; /// Element access by index. IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT; /// @{ /// @name Constructors and Assignment /// Uninitialized by default IMATH_HOSTDEVICE Vec3() IMATH_NOEXCEPT; /// Initialize to a scalar `(a,a,a)` IMATH_HOSTDEVICE constexpr explicit Vec3 (T a) IMATH_NOEXCEPT; /// Initialize to given elements `(a,b,c)` IMATH_HOSTDEVICE constexpr Vec3 (T a, T b, T c) IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE constexpr Vec3 (const Vec3& v) IMATH_NOEXCEPT; /// Construct from Vec3 of another base type template IMATH_HOSTDEVICE constexpr Vec3 (const Vec3& v) IMATH_NOEXCEPT; /// Vec4 to Vec3 conversion: divide x, y and z by w, even if w is /// 0. The result depends on how the environment handles /// floating-point exceptions. template IMATH_HOSTDEVICE explicit constexpr Vec3 (const Vec4& v) IMATH_NOEXCEPT; /// Vec4 to Vec3 conversion: divide x, y and z by w. Throws an /// exception if w is zero or if division by w would overflow. template explicit IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 (const Vec4& v, InfException); /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator= (const Vec3& v) IMATH_NOEXCEPT; /// Destructor ~Vec3() IMATH_NOEXCEPT = default; /// @} #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Interoperability with other vector types /// /// Construction and assignment are allowed from other classes that /// appear to be equivalent vector types, provided that they have either /// a subscripting operator, or data members .x, .y, .z, that are of the /// same type as the elements of this vector, and their size appears to /// be the right number of elements. /// /// This functionality is disabled for gcc 4.x, which seems to have a /// compiler bug that results in spurious errors. It can also be /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to /// including any Imath header files. /// template::value)> IMATH_HOSTDEVICE explicit constexpr Vec3 (const V& v) IMATH_NOEXCEPT : Vec3(T(v.x), T(v.y), T(v.z)) { } template::value && !has_xyz::value)> IMATH_HOSTDEVICE explicit Vec3 (const V& v) : Vec3(T(v[0]), T(v[1]), T(v[2])) { } /// Interoperability assignment from another type that behaves as if it /// were an equivalent vector. template::value)> IMATH_HOSTDEVICE const Vec3& operator= (const V& v) IMATH_NOEXCEPT { x = T(v.x); y = T(v.y); z = T(v.z); return *this; } template::value && !has_xyz::value)> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator= (const V& v) { x = T(v[0]); y = T(v[1]); z = T(v[2]); return *this; } /// @} #endif /// @{ /// @name Compatibility with Sb /// Set the value template IMATH_HOSTDEVICE void setValue (S a, S b, S c) IMATH_NOEXCEPT; /// Set the value template IMATH_HOSTDEVICE void setValue (const Vec3& v) IMATH_NOEXCEPT; /// Return the value in `a`, `b`, and `c` template IMATH_HOSTDEVICE void getValue (S& a, S& b, S& c) const IMATH_NOEXCEPT; /// Return the value in `v` template IMATH_HOSTDEVICE void getValue (Vec3& v) const IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT; /// Return a raw pointer to the array of values IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Arithmetic and Comparison /// Equality template IMATH_HOSTDEVICE constexpr bool operator== (const Vec3& v) const IMATH_NOEXCEPT; /// Inequality template IMATH_HOSTDEVICE constexpr bool operator!= (const Vec3& v) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and `m` are the same /// with an absolute error of no more than e, i.e., for all i, j: /// /// abs (this[i][j] - m[i][j]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Vec3& v, T e) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and m are the same with /// a relative error of no more than e, i.e., for all i, j: /// /// abs (this[i] - v[i][j]) <= e * abs (this[i][j]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Vec3& v, T e) const IMATH_NOEXCEPT; /// Dot product IMATH_HOSTDEVICE constexpr T dot (const Vec3& v) const IMATH_NOEXCEPT; /// Dot product IMATH_HOSTDEVICE constexpr T operator^ (const Vec3& v) const IMATH_NOEXCEPT; /// Right-handed cross product IMATH_HOSTDEVICE constexpr Vec3 cross (const Vec3& v) const IMATH_NOEXCEPT; /// Right-handed cross product IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator%= (const Vec3& v) IMATH_NOEXCEPT; /// Right-handed cross product IMATH_HOSTDEVICE constexpr Vec3 operator% (const Vec3& v) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator+= (const Vec3& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Vec3 operator+ (const Vec3& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator-= (const Vec3& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Vec3 operator- (const Vec3& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Vec3 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator*= (const Vec3& v) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Vec3 operator* (const Vec3& v) const IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Vec3 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator/= (const Vec3& v) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Vec3 operator/ (const Vec3& v) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Vec3 operator/ (T a) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Query and Manipulation /// Return the Euclidean norm IMATH_HOSTDEVICE T length() const IMATH_NOEXCEPT; /// Return the square of the Euclidean norm, i.e. the dot product /// with itself. IMATH_HOSTDEVICE constexpr T length2() const IMATH_NOEXCEPT; /// Normalize in place. If length()==0, return a null vector. IMATH_HOSTDEVICE const Vec3& normalize() IMATH_NOEXCEPT; /// Normalize in place. If length()==0, throw an exception. const Vec3& normalizeExc(); /// Normalize without any checks for length()==0. Slightly faster /// than the other normalization routines, but if v.length() is /// 0.0, the result is undefined. IMATH_HOSTDEVICE const Vec3& normalizeNonNull() IMATH_NOEXCEPT; /// Return a normalized vector. Does not modify *this. IMATH_HOSTDEVICE Vec3 normalized() const IMATH_NOEXCEPT; // does not modify *this /// Return a normalized vector. Does not modify *this. Throw an /// exception if length()==0. Vec3 normalizedExc() const; /// Return a normalized vector. Does not modify *this, and does /// not check for length()==0. Slightly faster than the other /// normalization routines, but if v.length() is 0.0, the result /// is undefined. IMATH_HOSTDEVICE Vec3 normalizedNonNull() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of dimensions, i.e. 3 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 3; } /// The base type: In templates that accept a parameter `V`, you /// can refer to `T` as `V::BaseType` typedef T BaseType; private: IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny() const IMATH_NOEXCEPT; }; /// /// 4-element vector /// template class IMATH_EXPORT_TEMPLATE_TYPE Vec4 { public: /// @{ /// @name Direct access to elements T x, y, z, w; /// @} /// Element access by index. IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT; /// Element access by index. IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT; /// @{ /// @name Constructors and Assignment /// Uninitialized by default IMATH_HOSTDEVICE Vec4() IMATH_NOEXCEPT; // no initialization /// Initialize to a scalar `(a,a,a,a)` IMATH_HOSTDEVICE constexpr explicit Vec4 (T a) IMATH_NOEXCEPT; /// Initialize to given elements `(a,b,c,d)` IMATH_HOSTDEVICE constexpr Vec4 (T a, T b, T c, T d) IMATH_NOEXCEPT; /// Copy constructor IMATH_HOSTDEVICE constexpr Vec4 (const Vec4& v) IMATH_NOEXCEPT; /// Construct from Vec4 of another base type template IMATH_HOSTDEVICE constexpr Vec4 (const Vec4& v) IMATH_NOEXCEPT; /// Vec3 to Vec4 conversion, sets w to 1. template IMATH_HOSTDEVICE explicit constexpr Vec4 (const Vec3& v) IMATH_NOEXCEPT; /// Assignment IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator= (const Vec4& v) IMATH_NOEXCEPT; /// Destructor ~Vec4() IMATH_NOEXCEPT = default; /// @} #if IMATH_FOREIGN_VECTOR_INTEROP /// @{ /// @name Interoperability with other vector types /// /// Construction and assignment are allowed from other classes that /// appear to be equivalent vector types, provided that they have either /// a subscripting operator, or data members .x, .y, .z, .w that are of /// the same type as the elements of this vector, and their size appears /// to be the right number of elements. /// /// This functionality is disabled for gcc 4.x, which seems to have a /// compiler bug that results in spurious errors. It can also be /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to /// including any Imath header files. /// template::value)> IMATH_HOSTDEVICE explicit constexpr Vec4 (const V& v) IMATH_NOEXCEPT : Vec4(T(v.x), T(v.y), T(v.z), T(v.w)) { } template::value && !has_xyzw::value)> IMATH_HOSTDEVICE explicit Vec4 (const V& v) : Vec4(T(v[0]), T(v[1]), T(v[2]), T(v[3])) { } template::value)> IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator= (const V& v) IMATH_NOEXCEPT { x = T(v.x); y = T(v.y); z = T(v.z); w = T(v.w); return *this; } template::value && !has_xyzw::value)> IMATH_HOSTDEVICE const Vec4& operator= (const V& v) { x = T(v[0]); y = T(v[1]); z = T(v[2]); w = T(v[3]); return *this; } /// @} #endif /// @{ /// @name Arithmetic and Comparison /// Equality template IMATH_HOSTDEVICE constexpr bool operator== (const Vec4& v) const IMATH_NOEXCEPT; /// Inequality template IMATH_HOSTDEVICE constexpr bool operator!= (const Vec4& v) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and `m` are the same /// with an absolute error of no more than e, i.e., for all i, j: /// /// abs (this[i][j] - m[i][j]) <= e IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Vec4& v, T e) const IMATH_NOEXCEPT; /// Compare two matrices and test if they are "approximately equal": /// @return True if the coefficients of this and m are the same with /// a relative error of no more than e, i.e., for all i, j: /// /// abs (this[i] - v[i][j]) <= e * abs (this[i][j]) IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Vec4& v, T e) const IMATH_NOEXCEPT; /// Dot product IMATH_HOSTDEVICE constexpr T dot (const Vec4& v) const IMATH_NOEXCEPT; /// Dot product IMATH_HOSTDEVICE constexpr T operator^ (const Vec4& v) const IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator+= (const Vec4& v) IMATH_NOEXCEPT; /// Component-wise addition IMATH_HOSTDEVICE constexpr Vec4 operator+ (const Vec4& v) const IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator-= (const Vec4& v) IMATH_NOEXCEPT; /// Component-wise subtraction IMATH_HOSTDEVICE constexpr Vec4 operator- (const Vec4& v) const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE constexpr Vec4 operator-() const IMATH_NOEXCEPT; /// Component-wise multiplication by -1 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& negate() IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator*= (const Vec4& v) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator*= (T a) IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Vec4 operator* (const Vec4& v) const IMATH_NOEXCEPT; /// Component-wise multiplication IMATH_HOSTDEVICE constexpr Vec4 operator* (T a) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator/= (const Vec4& v) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator/= (T a) IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Vec4 operator/ (const Vec4& v) const IMATH_NOEXCEPT; /// Component-wise division IMATH_HOSTDEVICE constexpr Vec4 operator/ (T a) const IMATH_NOEXCEPT; /// @} /// @{ /// @name Query and Manipulation /// Return the Euclidean norm IMATH_HOSTDEVICE T length() const IMATH_NOEXCEPT; /// Return the square of the Euclidean norm, i.e. the dot product /// with itself. IMATH_HOSTDEVICE constexpr T length2() const IMATH_NOEXCEPT; /// Normalize in place. If length()==0, return a null vector. IMATH_HOSTDEVICE const Vec4& normalize() IMATH_NOEXCEPT; // modifies *this /// Normalize in place. If length()==0, throw an exception. const Vec4& normalizeExc(); /// Normalize without any checks for length()==0. Slightly faster /// than the other normalization routines, but if v.length() is /// 0.0, the result is undefined. IMATH_HOSTDEVICE const Vec4& normalizeNonNull() IMATH_NOEXCEPT; /// Return a normalized vector. Does not modify *this. IMATH_HOSTDEVICE Vec4 normalized() const IMATH_NOEXCEPT; // does not modify *this /// Return a normalized vector. Does not modify *this. Throw an /// exception if length()==0. Vec4 normalizedExc() const; /// Return a normalized vector. Does not modify *this, and does /// not check for length()==0. Slightly faster than the other /// normalization routines, but if v.length() is 0.0, the result /// is undefined. IMATH_HOSTDEVICE Vec4 normalizedNonNull() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Numeric Limits /// Largest possible negative value IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits::lowest(); } /// Largest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits::max(); } /// Smallest possible positive value IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits::min(); } /// Smallest possible e for which 1+e != 1 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits::epsilon(); } /// @} /// Return the number of dimensions, i.e. 4 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 4; } /// The base type: In templates that accept a parameter `V`, you /// can refer to `T` as `V::BaseType` typedef T BaseType; private: IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny() const IMATH_NOEXCEPT; }; /// Stream output, as "(x y)" template std::ostream& operator<< (std::ostream& s, const Vec2& v); /// Stream output, as "(x y z)" template std::ostream& operator<< (std::ostream& s, const Vec3& v); /// Stream output, as "(x y z w)" template std::ostream& operator<< (std::ostream& s, const Vec4& v); /// Reverse multiplication: S * Vec2 template IMATH_HOSTDEVICE constexpr Vec2 operator* (T a, const Vec2& v) IMATH_NOEXCEPT; /// Reverse multiplication: S * Vec3 template IMATH_HOSTDEVICE constexpr Vec3 operator* (T a, const Vec3& v) IMATH_NOEXCEPT; /// Reverse multiplication: S * Vec4 template IMATH_HOSTDEVICE constexpr Vec4 operator* (T a, const Vec4& v) IMATH_NOEXCEPT; //------------------------- // Typedefs for convenience //------------------------- /// Vec2 of short typedef Vec2 V2s; /// Vec2 of integer typedef Vec2 V2i; /// Vec2 of int64_t typedef Vec2 V2i64; /// Vec2 of float typedef Vec2 V2f; /// Vec2 of double typedef Vec2 V2d; /// Vec3 of short typedef Vec3 V3s; /// Vec3 of integer typedef Vec3 V3i; /// Vec3 of int64_t typedef Vec3 V3i64; /// Vec3 of float typedef Vec3 V3f; /// Vec3 of double typedef Vec3 V3d; /// Vec4 of short typedef Vec4 V4s; /// Vec4 of integer typedef Vec4 V4i; /// Vec4 of int64_t typedef Vec4 V4i64; /// Vec4 of float typedef Vec4 V4f; /// Vec4 of double typedef Vec4 V4d; //---------------------------------------------------------------------------- // Specializations for VecN, VecN // // Normalize and length don't make sense for integer vectors, so disable them. //---------------------------------------------------------------------------- /// @cond Doxygen_Suppress // Vec2 template <> IMATH_HOSTDEVICE short Vec2::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec2& Vec2::normalize() IMATH_NOEXCEPT = delete; template <> const Vec2& Vec2::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec2& Vec2::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec2 Vec2::normalized() const IMATH_NOEXCEPT = delete; template <> Vec2 Vec2::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec2 Vec2::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec2 template <> IMATH_HOSTDEVICE int Vec2::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec2& Vec2::normalize() IMATH_NOEXCEPT = delete; template <> const Vec2& Vec2::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec2& Vec2::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec2 Vec2::normalized() const IMATH_NOEXCEPT = delete; template <> Vec2 Vec2::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec2 Vec2::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec2 template <> IMATH_HOSTDEVICE int64_t Vec2::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec2& Vec2::normalize() IMATH_NOEXCEPT = delete; template <> const Vec2& Vec2::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec2& Vec2::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec2 Vec2::normalized() const IMATH_NOEXCEPT = delete; template <> Vec2 Vec2::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec2 Vec2::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec3 template <> IMATH_HOSTDEVICE short Vec3::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec3& Vec3::normalize() IMATH_NOEXCEPT = delete; template <> const Vec3& Vec3::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec3& Vec3::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec3 Vec3::normalized() const IMATH_NOEXCEPT = delete; template <> Vec3 Vec3::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec3 Vec3::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec3 template <> IMATH_HOSTDEVICE int Vec3::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec3& Vec3::normalize() IMATH_NOEXCEPT = delete; template <> const Vec3& Vec3::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec3& Vec3::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec3 Vec3::normalized() const IMATH_NOEXCEPT = delete; template <> Vec3 Vec3::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec3 Vec3::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec3 template <> IMATH_HOSTDEVICE int64_t Vec3::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec3& Vec3::normalize() IMATH_NOEXCEPT = delete; template <> const Vec3& Vec3::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec3& Vec3::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec3 Vec3::normalized() const IMATH_NOEXCEPT = delete; template <> Vec3 Vec3::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec3 Vec3::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec4 template <> IMATH_HOSTDEVICE short Vec4::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec4& Vec4::normalize() IMATH_NOEXCEPT = delete; template <> const Vec4& Vec4::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec4& Vec4::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec4 Vec4::normalized() const IMATH_NOEXCEPT = delete; template <> Vec4 Vec4::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec4 Vec4::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec4 template <> IMATH_HOSTDEVICE int Vec4::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec4& Vec4::normalize() IMATH_NOEXCEPT = delete; template <> const Vec4& Vec4::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec4& Vec4::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec4 Vec4::normalized() const IMATH_NOEXCEPT = delete; template <> Vec4 Vec4::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec4 Vec4::normalizedNonNull() const IMATH_NOEXCEPT = delete; // Vec4 template <> IMATH_HOSTDEVICE int64_t Vec4::length() const IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE const Vec4& Vec4::normalize() IMATH_NOEXCEPT = delete; template <> const Vec4& Vec4::normalizeExc() = delete; template <> IMATH_HOSTDEVICE const Vec4& Vec4::normalizeNonNull() IMATH_NOEXCEPT = delete; template <> IMATH_HOSTDEVICE Vec4 Vec4::normalized() const IMATH_NOEXCEPT = delete; template <> Vec4 Vec4::normalizedExc() const = delete; template <> IMATH_HOSTDEVICE Vec4 Vec4::normalizedNonNull() const IMATH_NOEXCEPT = delete; /// @endcond Doxygen_Suppress //------------------------ // Implementation of Vec2: //------------------------ template IMATH_CONSTEXPR14 IMATH_HOSTDEVICE inline T& Vec2::operator[] (int i) IMATH_NOEXCEPT { return (&x)[i]; // NOSONAR - suppress SonarCloud bug report. } template constexpr IMATH_HOSTDEVICE inline const T& Vec2::operator[] (int i) const IMATH_NOEXCEPT { return (&x)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE inline Vec2::Vec2() IMATH_NOEXCEPT { // empty, and not constexpr because data is uninitialized. } template IMATH_HOSTDEVICE constexpr inline Vec2::Vec2 (T a) IMATH_NOEXCEPT : x(a), y(a) { } template IMATH_HOSTDEVICE constexpr inline Vec2::Vec2 (T a, T b) IMATH_NOEXCEPT : x(a), y(b) { } template IMATH_HOSTDEVICE constexpr inline Vec2::Vec2 (const Vec2& v) IMATH_NOEXCEPT : x(v.x), y(v.y) { } template template IMATH_HOSTDEVICE constexpr inline Vec2::Vec2 (const Vec2& v) IMATH_NOEXCEPT : x(T(v.x)), y(T(v.y)) { } template IMATH_CONSTEXPR14 IMATH_HOSTDEVICE inline const Vec2& Vec2::operator= (const Vec2& v) IMATH_NOEXCEPT { x = v.x; y = v.y; return *this; } template template IMATH_HOSTDEVICE inline void Vec2::setValue (S a, S b) IMATH_NOEXCEPT { x = T (a); y = T (b); } template template IMATH_HOSTDEVICE inline void Vec2::setValue (const Vec2& v) IMATH_NOEXCEPT { x = T (v.x); y = T (v.y); } template template IMATH_HOSTDEVICE inline void Vec2::getValue (S& a, S& b) const IMATH_NOEXCEPT { a = S (x); b = S (y); } template template IMATH_HOSTDEVICE inline void Vec2::getValue (Vec2& v) const IMATH_NOEXCEPT { v.x = S (x); v.y = S (y); } template IMATH_HOSTDEVICE inline T* Vec2::getValue() IMATH_NOEXCEPT { return (T*) &x; } template IMATH_HOSTDEVICE inline const T* Vec2::getValue() const IMATH_NOEXCEPT { return (const T*) &x; } template template IMATH_HOSTDEVICE constexpr inline bool Vec2::operator== (const Vec2& v) const IMATH_NOEXCEPT { return x == v.x && y == v.y; } template template IMATH_HOSTDEVICE constexpr inline bool Vec2::operator!= (const Vec2& v) const IMATH_NOEXCEPT { return x != v.x || y != v.y; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Vec2::equalWithAbsError (const Vec2& v, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 2; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Vec2::equalWithRelError (const Vec2& v, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 2; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e)) return false; return true; } template IMATH_HOSTDEVICE constexpr inline T Vec2::dot (const Vec2& v) const IMATH_NOEXCEPT { return x * v.x + y * v.y; } template IMATH_HOSTDEVICE constexpr inline T Vec2::operator^ (const Vec2& v) const IMATH_NOEXCEPT { return dot (v); } template IMATH_HOSTDEVICE constexpr inline T Vec2::cross (const Vec2& v) const IMATH_NOEXCEPT { return x * v.y - y * v.x; } template IMATH_HOSTDEVICE constexpr inline T Vec2::operator% (const Vec2& v) const IMATH_NOEXCEPT { return x * v.y - y * v.x; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::operator+= (const Vec2& v) IMATH_NOEXCEPT { x += v.x; y += v.y; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator+ (const Vec2& v) const IMATH_NOEXCEPT { return Vec2 (x + v.x, y + v.y); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::operator-= (const Vec2& v) IMATH_NOEXCEPT { x -= v.x; y -= v.y; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator- (const Vec2& v) const IMATH_NOEXCEPT { return Vec2 (x - v.x, y - v.y); } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator-() const IMATH_NOEXCEPT { return Vec2 (-x, -y); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::negate() IMATH_NOEXCEPT { x = -x; y = -y; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::operator*= (const Vec2& v) IMATH_NOEXCEPT { x *= v.x; y *= v.y; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::operator*= (T a) IMATH_NOEXCEPT { x *= a; y *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator* (const Vec2& v) const IMATH_NOEXCEPT { return Vec2 (x * v.x, y * v.y); } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator* (T a) const IMATH_NOEXCEPT { return Vec2 (x * a, y * a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::operator/= (const Vec2& v) IMATH_NOEXCEPT { x /= v.x; y /= v.y; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2& Vec2::operator/= (T a) IMATH_NOEXCEPT { x /= a; y /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator/ (const Vec2& v) const IMATH_NOEXCEPT { return Vec2 (x / v.x, y / v.y); } template IMATH_HOSTDEVICE constexpr inline Vec2 Vec2::operator/ (T a) const IMATH_NOEXCEPT { return Vec2 (x / a, y / a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Vec2::lengthTiny() const IMATH_NOEXCEPT { T absX = std::abs(x); T absY = std::abs(y); T max = absX; if (max < absY) max = absY; if (IMATH_UNLIKELY(max == T (0))) return T (0); // // Do not replace the divisions by max with multiplications by 1/max. // Computing 1/max can overflow but the divisions below will always // produce results less than or equal to 1. // absX /= max; absY /= max; return max * std::sqrt (absX * absX + absY * absY); } template IMATH_HOSTDEVICE inline T Vec2::length() const IMATH_NOEXCEPT { T length2 = dot (*this); if (IMATH_UNLIKELY(length2 < T (2) * std::numeric_limits::min())) return lengthTiny(); return std::sqrt (length2); } template IMATH_HOSTDEVICE constexpr inline T Vec2::length2() const IMATH_NOEXCEPT { return dot (*this); } template IMATH_HOSTDEVICE inline const Vec2& Vec2::normalize() IMATH_NOEXCEPT { T l = length(); if (IMATH_LIKELY(l != T (0))) { // // Do not replace the divisions by l with multiplications by 1/l. // Computing 1/l can overflow but the divisions below will always // produce results less than or equal to 1. // x /= l; y /= l; } return *this; } template inline const Vec2& Vec2::normalizeExc() { T l = length(); if (IMATH_UNLIKELY(l == T (0))) throw std::domain_error ("Cannot normalize null vector."); x /= l; y /= l; return *this; } template IMATH_HOSTDEVICE inline const Vec2& Vec2::normalizeNonNull() IMATH_NOEXCEPT { T l = length(); x /= l; y /= l; return *this; } template IMATH_HOSTDEVICE inline Vec2 Vec2::normalized() const IMATH_NOEXCEPT { T l = length(); if (IMATH_UNLIKELY(l == T (0))) return Vec2 (T (0)); return Vec2 (x / l, y / l); } template inline Vec2 Vec2::normalizedExc() const { T l = length(); if (IMATH_UNLIKELY(l == T (0))) throw std::domain_error ("Cannot normalize null vector."); return Vec2 (x / l, y / l); } template IMATH_HOSTDEVICE inline Vec2 Vec2::normalizedNonNull() const IMATH_NOEXCEPT { T l = length(); return Vec2 (x / l, y / l); } //----------------------- // Implementation of Vec3 //----------------------- template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T& Vec3::operator[] (int i) IMATH_NOEXCEPT { return (&x)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE constexpr inline const T& Vec3::operator[] (int i) const IMATH_NOEXCEPT { return (&x)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE inline Vec3::Vec3() IMATH_NOEXCEPT { // empty, and not constexpr because data is uninitialized. } template IMATH_HOSTDEVICE constexpr inline Vec3::Vec3 (T a) IMATH_NOEXCEPT : x(a), y(a), z(a) { } template IMATH_HOSTDEVICE constexpr inline Vec3::Vec3 (T a, T b, T c) IMATH_NOEXCEPT : x(a), y(b), z(c) { } template IMATH_HOSTDEVICE constexpr inline Vec3::Vec3 (const Vec3& v) IMATH_NOEXCEPT : x(v.x), y(v.y), z(v.z) { } template template IMATH_HOSTDEVICE constexpr inline Vec3::Vec3 (const Vec3& v) IMATH_NOEXCEPT : x(T(v.x)), y(T(v.y)), z(T(v.z)) { } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator= (const Vec3& v) IMATH_NOEXCEPT { x = v.x; y = v.y; z = v.z; return *this; } template template IMATH_HOSTDEVICE constexpr inline Vec3::Vec3 (const Vec4& v) IMATH_NOEXCEPT : x(T(v.x/v.w)), y(T(v.y/v.w)), z(T(v.z/v.w)) { } template template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3::Vec3 (const Vec4& v, InfException) { T vx = T (v.x); T vy = T (v.y); T vz = T (v.z); T vw = T (v.w); T absW = (vw >= T (0)) ? vw : -vw; if (absW < 1) { T m = baseTypeMax() * absW; if (vx <= -m || vx >= m || vy <= -m || vy >= m || vz <= -m || vz >= m) throw std::domain_error ("Cannot normalize point at infinity."); } x = vx / vw; y = vy / vw; z = vz / vw; } template template IMATH_HOSTDEVICE inline void Vec3::setValue (S a, S b, S c) IMATH_NOEXCEPT { x = T (a); y = T (b); z = T (c); } template template IMATH_HOSTDEVICE inline void Vec3::setValue (const Vec3& v) IMATH_NOEXCEPT { x = T (v.x); y = T (v.y); z = T (v.z); } template template IMATH_HOSTDEVICE inline void Vec3::getValue (S& a, S& b, S& c) const IMATH_NOEXCEPT { a = S (x); b = S (y); c = S (z); } template template IMATH_HOSTDEVICE inline void Vec3::getValue (Vec3& v) const IMATH_NOEXCEPT { v.x = S (x); v.y = S (y); v.z = S (z); } template IMATH_HOSTDEVICE inline T* Vec3::getValue() IMATH_NOEXCEPT { return (T*) &x; } template IMATH_HOSTDEVICE inline const T* Vec3::getValue() const IMATH_NOEXCEPT { return (const T*) &x; } template template IMATH_HOSTDEVICE constexpr inline bool Vec3::operator== (const Vec3& v) const IMATH_NOEXCEPT { return x == v.x && y == v.y && z == v.z; } template template IMATH_HOSTDEVICE constexpr inline bool Vec3::operator!= (const Vec3& v) const IMATH_NOEXCEPT { return x != v.x || y != v.y || z != v.z; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Vec3::equalWithAbsError (const Vec3& v, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 3; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Vec3::equalWithRelError (const Vec3& v, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 3; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e)) return false; return true; } template IMATH_HOSTDEVICE constexpr inline T Vec3::dot (const Vec3& v) const IMATH_NOEXCEPT { return x * v.x + y * v.y + z * v.z; } template IMATH_HOSTDEVICE constexpr inline T Vec3::operator^ (const Vec3& v) const IMATH_NOEXCEPT { return dot (v); } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::cross (const Vec3& v) const IMATH_NOEXCEPT { return Vec3 (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator%= (const Vec3& v) IMATH_NOEXCEPT { T a = y * v.z - z * v.y; T b = z * v.x - x * v.z; T c = x * v.y - y * v.x; x = a; y = b; z = c; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator% (const Vec3& v) const IMATH_NOEXCEPT { return Vec3 (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator+= (const Vec3& v) IMATH_NOEXCEPT { x += v.x; y += v.y; z += v.z; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator+ (const Vec3& v) const IMATH_NOEXCEPT { return Vec3 (x + v.x, y + v.y, z + v.z); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator-= (const Vec3& v) IMATH_NOEXCEPT { x -= v.x; y -= v.y; z -= v.z; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator- (const Vec3& v) const IMATH_NOEXCEPT { return Vec3 (x - v.x, y - v.y, z - v.z); } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator-() const IMATH_NOEXCEPT { return Vec3 (-x, -y, -z); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::negate() IMATH_NOEXCEPT { x = -x; y = -y; z = -z; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator*= (const Vec3& v) IMATH_NOEXCEPT { x *= v.x; y *= v.y; z *= v.z; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator*= (T a) IMATH_NOEXCEPT { x *= a; y *= a; z *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator* (const Vec3& v) const IMATH_NOEXCEPT { return Vec3 (x * v.x, y * v.y, z * v.z); } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator* (T a) const IMATH_NOEXCEPT { return Vec3 (x * a, y * a, z * a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator/= (const Vec3& v) IMATH_NOEXCEPT { x /= v.x; y /= v.y; z /= v.z; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3& Vec3::operator/= (T a) IMATH_NOEXCEPT { x /= a; y /= a; z /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator/ (const Vec3& v) const IMATH_NOEXCEPT { return Vec3 (x / v.x, y / v.y, z / v.z); } template IMATH_HOSTDEVICE constexpr inline Vec3 Vec3::operator/ (T a) const IMATH_NOEXCEPT { return Vec3 (x / a, y / a, z / a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Vec3::lengthTiny() const IMATH_NOEXCEPT { T absX = (x >= T (0)) ? x : -x; T absY = (y >= T (0)) ? y : -y; T absZ = (z >= T (0)) ? z : -z; T max = absX; if (max < absY) max = absY; if (max < absZ) max = absZ; if (IMATH_UNLIKELY(max == T (0))) return T (0); // // Do not replace the divisions by max with multiplications by 1/max. // Computing 1/max can overflow but the divisions below will always // produce results less than or equal to 1. // absX /= max; absY /= max; absZ /= max; return max * std::sqrt (absX * absX + absY * absY + absZ * absZ); } template IMATH_HOSTDEVICE inline T Vec3::length() const IMATH_NOEXCEPT { T length2 = dot (*this); if (IMATH_UNLIKELY(length2 < T (2) * std::numeric_limits::min())) return lengthTiny(); return std::sqrt (length2); } template IMATH_HOSTDEVICE constexpr inline T Vec3::length2() const IMATH_NOEXCEPT { return dot (*this); } template IMATH_HOSTDEVICE inline const Vec3& Vec3::normalize() IMATH_NOEXCEPT { T l = length(); if (IMATH_LIKELY(l != T (0))) { // // Do not replace the divisions by l with multiplications by 1/l. // Computing 1/l can overflow but the divisions below will always // produce results less than or equal to 1. // x /= l; y /= l; z /= l; } return *this; } template inline const Vec3& Vec3::normalizeExc() { T l = length(); if (IMATH_UNLIKELY(l == T (0))) throw std::domain_error ("Cannot normalize null vector."); x /= l; y /= l; z /= l; return *this; } template IMATH_HOSTDEVICE inline const Vec3& Vec3::normalizeNonNull() IMATH_NOEXCEPT { T l = length(); x /= l; y /= l; z /= l; return *this; } template IMATH_HOSTDEVICE inline Vec3 Vec3::normalized() const IMATH_NOEXCEPT { T l = length(); if (IMATH_UNLIKELY((l == T (0)))) return Vec3 (T (0)); return Vec3 (x / l, y / l, z / l); } template inline Vec3 Vec3::normalizedExc() const { T l = length(); if (IMATH_UNLIKELY(l == T (0))) throw std::domain_error ("Cannot normalize null vector."); return Vec3 (x / l, y / l, z / l); } template IMATH_HOSTDEVICE inline Vec3 Vec3::normalizedNonNull() const IMATH_NOEXCEPT { T l = length(); return Vec3 (x / l, y / l, z / l); } //----------------------- // Implementation of Vec4 //----------------------- template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T& Vec4::operator[] (int i) IMATH_NOEXCEPT { return (&x)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE constexpr inline const T& Vec4::operator[] (int i) const IMATH_NOEXCEPT { return (&x)[i]; // NOSONAR - suppress SonarCloud bug report. } template IMATH_HOSTDEVICE inline Vec4::Vec4() IMATH_NOEXCEPT { // empty, and not constexpr because data is uninitialized. } template IMATH_HOSTDEVICE constexpr inline Vec4::Vec4 (T a) IMATH_NOEXCEPT : x(a), y(a), z(a), w(a) { } template IMATH_HOSTDEVICE constexpr inline Vec4::Vec4 (T a, T b, T c, T d) IMATH_NOEXCEPT : x(a), y(b), z(c), w(d) { } template IMATH_HOSTDEVICE constexpr inline Vec4::Vec4 (const Vec4& v) IMATH_NOEXCEPT : x(v.x), y(v.y), z(v.z), w(v.w) { } template template IMATH_HOSTDEVICE constexpr inline Vec4::Vec4 (const Vec4& v) IMATH_NOEXCEPT : x(T(v.x)), y(T(v.y)), z(T(v.z)), w(T(v.w)) { } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator= (const Vec4& v) IMATH_NOEXCEPT { x = v.x; y = v.y; z = v.z; w = v.w; return *this; } template template IMATH_HOSTDEVICE constexpr inline Vec4::Vec4 (const Vec3& v) IMATH_NOEXCEPT : x(T(v.x)), y(T(v.y)), z(T(v.z)), w(T(1)) { } template template IMATH_HOSTDEVICE constexpr inline bool Vec4::operator== (const Vec4& v) const IMATH_NOEXCEPT { return x == v.x && y == v.y && z == v.z && w == v.w; } template template IMATH_HOSTDEVICE constexpr inline bool Vec4::operator!= (const Vec4& v) const IMATH_NOEXCEPT { return x != v.x || y != v.y || z != v.z || w != v.w; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Vec4::equalWithAbsError (const Vec4& v, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 4; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e)) return false; return true; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool Vec4::equalWithRelError (const Vec4& v, T e) const IMATH_NOEXCEPT { for (int i = 0; i < 4; i++) if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e)) return false; return true; } template IMATH_HOSTDEVICE constexpr inline T Vec4::dot (const Vec4& v) const IMATH_NOEXCEPT { return x * v.x + y * v.y + z * v.z + w * v.w; } template IMATH_HOSTDEVICE constexpr inline T Vec4::operator^ (const Vec4& v) const IMATH_NOEXCEPT { return dot (v); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator+= (const Vec4& v) IMATH_NOEXCEPT { x += v.x; y += v.y; z += v.z; w += v.w; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator+ (const Vec4& v) const IMATH_NOEXCEPT { return Vec4 (x + v.x, y + v.y, z + v.z, w + v.w); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator-= (const Vec4& v) IMATH_NOEXCEPT { x -= v.x; y -= v.y; z -= v.z; w -= v.w; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator- (const Vec4& v) const IMATH_NOEXCEPT { return Vec4 (x - v.x, y - v.y, z - v.z, w - v.w); } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator-() const IMATH_NOEXCEPT { return Vec4 (-x, -y, -z, -w); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::negate() IMATH_NOEXCEPT { x = -x; y = -y; z = -z; w = -w; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator*= (const Vec4& v) IMATH_NOEXCEPT { x *= v.x; y *= v.y; z *= v.z; w *= v.w; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator*= (T a) IMATH_NOEXCEPT { x *= a; y *= a; z *= a; w *= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator* (const Vec4& v) const IMATH_NOEXCEPT { return Vec4 (x * v.x, y * v.y, z * v.z, w * v.w); } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator* (T a) const IMATH_NOEXCEPT { return Vec4 (x * a, y * a, z * a, w * a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator/= (const Vec4& v) IMATH_NOEXCEPT { x /= v.x; y /= v.y; z /= v.z; w /= v.w; return *this; } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4& Vec4::operator/= (T a) IMATH_NOEXCEPT { x /= a; y /= a; z /= a; w /= a; return *this; } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator/ (const Vec4& v) const IMATH_NOEXCEPT { return Vec4 (x / v.x, y / v.y, z / v.z, w / v.w); } template IMATH_HOSTDEVICE constexpr inline Vec4 Vec4::operator/ (T a) const IMATH_NOEXCEPT { return Vec4 (x / a, y / a, z / a, w / a); } template IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T Vec4::lengthTiny() const IMATH_NOEXCEPT { T absX = (x >= T (0)) ? x : -x; T absY = (y >= T (0)) ? y : -y; T absZ = (z >= T (0)) ? z : -z; T absW = (w >= T (0)) ? w : -w; T max = absX; if (max < absY) max = absY; if (max < absZ) max = absZ; if (max < absW) max = absW; if (IMATH_UNLIKELY(max == T (0))) return T (0); // // Do not replace the divisions by max with multiplications by 1/max. // Computing 1/max can overflow but the divisions below will always // produce results less than or equal to 1. // absX /= max; absY /= max; absZ /= max; absW /= max; return max * std::sqrt (absX * absX + absY * absY + absZ * absZ + absW * absW); } template IMATH_HOSTDEVICE inline T Vec4::length() const IMATH_NOEXCEPT { T length2 = dot (*this); if (IMATH_UNLIKELY(length2 < T (2) * std::numeric_limits::min())) return lengthTiny(); return std::sqrt (length2); } template IMATH_HOSTDEVICE constexpr inline T Vec4::length2() const IMATH_NOEXCEPT { return dot (*this); } template IMATH_HOSTDEVICE const inline Vec4& Vec4::normalize() IMATH_NOEXCEPT { T l = length(); if (IMATH_LIKELY(l != T (0))) { // // Do not replace the divisions by l with multiplications by 1/l. // Computing 1/l can overflow but the divisions below will always // produce results less than or equal to 1. // x /= l; y /= l; z /= l; w /= l; } return *this; } template const inline Vec4& Vec4::normalizeExc() { T l = length(); if (IMATH_UNLIKELY(l == T (0))) throw std::domain_error ("Cannot normalize null vector."); x /= l; y /= l; z /= l; w /= l; return *this; } template IMATH_HOSTDEVICE inline const Vec4& Vec4::normalizeNonNull() IMATH_NOEXCEPT { T l = length(); x /= l; y /= l; z /= l; w /= l; return *this; } template IMATH_HOSTDEVICE inline Vec4 Vec4::normalized() const IMATH_NOEXCEPT { T l = length(); if (IMATH_UNLIKELY(l == T (0))) return Vec4 (T (0)); return Vec4 (x / l, y / l, z / l, w / l); } template inline Vec4 Vec4::normalizedExc() const { T l = length(); if (IMATH_UNLIKELY(l == T (0))) throw std::domain_error ("Cannot normalize null vector."); return Vec4 (x / l, y / l, z / l, w / l); } template IMATH_HOSTDEVICE inline Vec4 Vec4::normalizedNonNull() const IMATH_NOEXCEPT { T l = length(); return Vec4 (x / l, y / l, z / l, w / l); } //----------------------------- // Stream output implementation //----------------------------- template std::ostream& operator<< (std::ostream& s, const Vec2& v) { return s << '(' << v.x << ' ' << v.y << ')'; } template std::ostream& operator<< (std::ostream& s, const Vec3& v) { return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ')'; } template std::ostream& operator<< (std::ostream& s, const Vec4& v) { return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ' ' << v.w << ')'; } //----------------------------------------- // Implementation of reverse multiplication //----------------------------------------- template IMATH_HOSTDEVICE constexpr inline Vec2 operator* (T a, const Vec2& v) IMATH_NOEXCEPT { return Vec2 (a * v.x, a * v.y); } template IMATH_HOSTDEVICE constexpr inline Vec3 operator* (T a, const Vec3& v) IMATH_NOEXCEPT { return Vec3 (a * v.x, a * v.y, a * v.z); } template IMATH_HOSTDEVICE constexpr inline Vec4 operator* (T a, const Vec4& v) IMATH_NOEXCEPT { return Vec4 (a * v.x, a * v.y, a * v.z, a * v.w); } #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER # pragma warning(pop) #endif IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHVEC_H Imath-3.1.4/src/Imath/ImathVecAlgo.h000066400000000000000000000050151417213455000170710ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Algorithms applied to or in conjunction with points (Imath::Vec2 // and Imath::Vec3). // // The assumption made is that these functions are called much // less often than the basic point functions or these functions // require more support classes. // #ifndef INCLUDED_IMATHVECALGO_H #define INCLUDED_IMATHVECALGO_H #include "ImathNamespace.h" #include "ImathVec.h" IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// @cond Doxygen_Suppress // // Note: doxygen doesn't understand these templates, so omit these // functions from the docs. // /// Find the projection of vector `t` onto vector `s` (`Vec2`, `Vec3`, `Vec4`) /// /// Only defined for floating-point types, e.g. `V2f`, `V3d`, etc. template ::value)> IMATH_CONSTEXPR14 inline Vec project (const Vec& s, const Vec& t) IMATH_NOEXCEPT { Vec sNormalized = s.normalized(); return sNormalized * (sNormalized ^ t); } /// Find a vector that is perpendicular to `s` and /// in the same plane as `s` and `t` (`Vec2`, `Vec3`, `Vec4`) /// /// Only defined for floating-point types, e.g. `V2f`, `V3d`, etc. template ::value)> constexpr inline Vec orthogonal (const Vec& s, const Vec& t) IMATH_NOEXCEPT { return t - project (s, t); } /// Find the direction of a ray `s` after reflection /// off a plane with normal `t` (`Vec2`, `Vec3`, `Vec4`) /// /// Only defined for floating-point types, e.g. `V2f`, `V3d`, etc. template ::value)> constexpr inline Vec reflect (const Vec& s, const Vec& t) IMATH_NOEXCEPT { return s - typename Vec::BaseType (2) * (s - project (t, s)); } /// @endcond /// Find the vertex of triangle `(v0, v1, v2)` that is closest to point `p` /// (`Vec2`, `Vec3`, `Vec4`) template IMATH_CONSTEXPR14 Vec closestVertex (const Vec& v0, const Vec& v1, const Vec& v2, const Vec& p) IMATH_NOEXCEPT { Vec nearest = v0; typename Vec::BaseType neardot = (v0 - p).length2(); typename Vec::BaseType tmp = (v1 - p).length2(); if (tmp < neardot) { neardot = tmp; nearest = v1; } tmp = (v2 - p).length2(); if (tmp < neardot) { neardot = tmp; nearest = v2; } return nearest; } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT #endif // INCLUDED_IMATHVECALGO_H Imath-3.1.4/src/Imath/half.cpp000066400000000000000000000052441417213455000160370ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Primary original authors: // Florian Kainz // Rod Bogart // //--------------------------------------------------------------------------- // // class half -- // implementation of non-inline members // //--------------------------------------------------------------------------- #include "half.h" #include using namespace std; #if defined(IMATH_DLL) # define EXPORT_CONST __declspec(dllexport) #else # define EXPORT_CONST #endif //------------------------------------------------------------- // Lookup tables for half-to-float and float-to-half conversion //------------------------------------------------------------- // clang-format off #if !defined(IMATH_HALF_NO_LOOKUP_TABLE) // Omit the table entirely if IMATH_HALF_NO_LOOKUP_TABLE is // defined. Half-to-float conversion must be accomplished either by // F16C instructions or the bit-shift algorithm. const imath_half_uif_t imath_half_to_float_table_data[1 << 16] = #include "toFloat.h" extern "C" { EXPORT_CONST const imath_half_uif_t *imath_half_to_float_table = imath_half_to_float_table_data; } // extern "C" #endif // clang-format on //--------------------- // Stream I/O operators //--------------------- IMATH_EXPORT ostream& operator<< (ostream& os, half h) { os << float (h); return os; } IMATH_EXPORT istream& operator>> (istream& is, half& h) { float f; is >> f; h = half (f); return is; } //--------------------------------------- // Functions to print the bit-layout of // floats and halfs, mostly for debugging //--------------------------------------- IMATH_EXPORT void printBits (ostream& os, half h) { unsigned short b = h.bits(); for (int i = 15; i >= 0; i--) { os << (((b >> i) & 1) ? '1' : '0'); if (i == 15 || i == 10) os << ' '; } } IMATH_EXPORT void printBits (ostream& os, float f) { half::uif x; x.f = f; for (int i = 31; i >= 0; i--) { os << (((x.i >> i) & 1) ? '1' : '0'); if (i == 31 || i == 23) os << ' '; } } IMATH_EXPORT void printBits (char c[19], half h) { unsigned short b = h.bits(); for (int i = 15, j = 0; i >= 0; i--, j++) { c[j] = (((b >> i) & 1) ? '1' : '0'); if (i == 15 || i == 10) c[++j] = ' '; } c[18] = 0; } IMATH_EXPORT void printBits (char c[35], float f) { half::uif x; x.f = f; for (int i = 31, j = 0; i >= 0; i--, j++) { c[j] = (((x.i >> i) & 1) ? '1' : '0'); if (i == 31 || i == 23) c[++j] = ' '; } c[34] = 0; } Imath-3.1.4/src/Imath/half.h000066400000000000000000000567171417213455000155170ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Primary original authors: // Florian Kainz // Rod Bogart // #ifndef IMATH_HALF_H_ #define IMATH_HALF_H_ #include "ImathExport.h" #include "ImathNamespace.h" #include "ImathPlatform.h" /// @file half.h /// The half type is a 16-bit floating number, compatible with the /// IEEE 754-2008 binary16 type. /// /// **Representation of a 32-bit float:** /// /// We assume that a float, f, is an IEEE 754 single-precision /// floating point number, whose bits are arranged as follows: /// /// 31 (msb) /// | /// | 30 23 /// | | | /// | | | 22 0 (lsb) /// | | | | | /// X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX /// /// s e m /// /// S is the sign-bit, e is the exponent and m is the significand. /// /// If e is between 1 and 254, f is a normalized number: /// /// s e-127 /// f = (-1) * 2 * 1.m /// /// If e is 0, and m is not zero, f is a denormalized number: /// /// s -126 /// f = (-1) * 2 * 0.m /// /// If e and m are both zero, f is zero: /// /// f = 0.0 /// /// If e is 255, f is an "infinity" or "not a number" (NAN), /// depending on whether m is zero or not. /// /// Examples: /// /// 0 00000000 00000000000000000000000 = 0.0 /// 0 01111110 00000000000000000000000 = 0.5 /// 0 01111111 00000000000000000000000 = 1.0 /// 0 10000000 00000000000000000000000 = 2.0 /// 0 10000000 10000000000000000000000 = 3.0 /// 1 10000101 11110000010000000000000 = -124.0625 /// 0 11111111 00000000000000000000000 = +infinity /// 1 11111111 00000000000000000000000 = -infinity /// 0 11111111 10000000000000000000000 = NAN /// 1 11111111 11111111111111111111111 = NAN /// /// **Representation of a 16-bit half:** /// /// Here is the bit-layout for a half number, h: /// /// 15 (msb) /// | /// | 14 10 /// | | | /// | | | 9 0 (lsb) /// | | | | | /// X XXXXX XXXXXXXXXX /// /// s e m /// /// S is the sign-bit, e is the exponent and m is the significand. /// /// If e is between 1 and 30, h is a normalized number: /// /// s e-15 /// h = (-1) * 2 * 1.m /// /// If e is 0, and m is not zero, h is a denormalized number: /// /// S -14 /// h = (-1) * 2 * 0.m /// /// If e and m are both zero, h is zero: /// /// h = 0.0 /// /// If e is 31, h is an "infinity" or "not a number" (NAN), /// depending on whether m is zero or not. /// /// Examples: /// /// 0 00000 0000000000 = 0.0 /// 0 01110 0000000000 = 0.5 /// 0 01111 0000000000 = 1.0 /// 0 10000 0000000000 = 2.0 /// 0 10000 1000000000 = 3.0 /// 1 10101 1111000001 = -124.0625 /// 0 11111 0000000000 = +infinity /// 1 11111 0000000000 = -infinity /// 0 11111 1000000000 = NAN /// 1 11111 1111111111 = NAN /// /// **Conversion via Lookup Table:** /// /// Converting from half to float is performed by default using a /// lookup table. There are only 65,536 different half numbers; each /// of these numbers has been converted and stored in a table pointed /// to by the ``imath_half_to_float_table`` pointer. /// /// Prior to Imath v3.1, conversion from float to half was /// accomplished with the help of an exponent look table, but this is /// now replaced with explicit bit shifting. /// /// **Conversion via Hardware:** /// /// For Imath v3.1, the conversion routines have been extended to use /// F16C SSE instructions whenever present and enabled by compiler /// flags. /// /// **Conversion via Bit-Shifting** /// /// If F16C SSE instructions are not available, conversion can be /// accomplished by a bit-shifting algorithm. For half-to-float /// conversion, this is generally slower than the lookup table, but it /// may be preferable when memory limits preclude storing of the /// 65,536-entry lookup table. /// /// The lookup table symbol is included in the compilation even if /// ``IMATH_HALF_USE_LOOKUP_TABLE`` is false, because application code /// using the exported ``half.h`` may choose to enable the use of the table. /// /// An implementation can eliminate the table from compilation by /// defining the ``IMATH_HALF_NO_LOOKUP_TABLE`` preprocessor symbol. /// Simply add: /// /// #define IMATH_HALF_NO_LOOKUP_TABLE /// /// before including ``half.h``, or define the symbol on the compile /// command line. /// /// Furthermore, an implementation wishing to receive ``FE_OVERFLOW`` /// and ``FE_UNDERFLOW`` floating point exceptions when converting /// float to half by the bit-shift algorithm can define the /// preprocessor symbol ``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to /// including ``half.h``: /// /// #define IMATH_HALF_ENABLE_FP_EXCEPTIONS /// /// **Conversion Performance Comparison:** /// /// Testing on a Core i9, the timings are approximately: /// /// half to float /// - table: 0.71 ns / call /// - no table: 1.06 ns / call /// - f16c: 0.45 ns / call /// /// float-to-half: /// - original: 5.2 ns / call /// - no exp table + opt: 1.27 ns / call /// - f16c: 0.45 ns / call /// /// **Note:** the timing above depends on the distribution of the /// floats in question. /// #ifdef _WIN32 # include #elif defined(__x86_64__) # include #endif #include #include #ifdef IMATH_HALF_ENABLE_FP_EXCEPTIONS # include #endif //------------------------------------------------------------------------- // Limits // // Visual C++ will complain if HALF_DENORM_MIN, HALF_NRM_MIN etc. are not float // constants, but at least one other compiler (gcc 2.96) produces incorrect // results if they are. //------------------------------------------------------------------------- #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER /// Smallest positive denormalized half # define HALF_DENORM_MIN 5.96046448e-08f /// Smallest positive normalized half # define HALF_NRM_MIN 6.10351562e-05f /// Smallest positive normalized half # define HALF_MIN 6.10351562e-05f /// Largest positive half # define HALF_MAX 65504.0f /// Smallest positive e for which ``half(1.0 + e) != half(1.0)`` # define HALF_EPSILON 0.00097656f #else /// Smallest positive denormalized half # define HALF_DENORM_MIN 5.96046448e-08 /// Smallest positive normalized half # define HALF_NRM_MIN 6.10351562e-05 /// Smallest positive normalized half # define HALF_MIN 6.10351562e-05f /// Largest positive half # define HALF_MAX 65504.0 /// Smallest positive e for which ``half(1.0 + e) != half(1.0)`` # define HALF_EPSILON 0.00097656 #endif /// Number of digits in mantissa (significand + hidden leading 1) #define HALF_MANT_DIG 11 /// Number of base 10 digits that can be represented without change: /// /// ``floor( (HALF_MANT_DIG - 1) * log10(2) ) => 3.01... -> 3`` #define HALF_DIG 3 /// Number of base-10 digits that are necessary to uniquely represent /// all distinct values: /// /// ``ceil(HALF_MANT_DIG * log10(2) + 1) => 4.31... -> 5`` #define HALF_DECIMAL_DIG 5 /// Base of the exponent #define HALF_RADIX 2 /// Minimum negative integer such that ``HALF_RADIX`` raised to the power /// of one less than that integer is a normalized half #define HALF_DENORM_MIN_EXP -13 /// Maximum positive integer such that ``HALF_RADIX`` raised to the power /// of one less than that integer is a normalized half #define HALF_MAX_EXP 16 /// Minimum positive integer such that 10 raised to that power is a /// normalized half #define HALF_DENORM_MIN_10_EXP -4 /// Maximum positive integer such that 10 raised to that power is a /// normalized half #define HALF_MAX_10_EXP 4 /// a type for both C-only programs and C++ to use the same utilities typedef union imath_half_uif { uint32_t i; float f; } imath_half_uif_t; /// a type for both C-only programs and C++ to use the same utilities typedef uint16_t imath_half_bits_t; #if !defined(__cplusplus) && !defined(__CUDACC__) /// if we're in a C-only context, alias the half bits type to half typedef imath_half_bits_t half; #endif #if !defined(IMATH_HALF_NO_LOOKUP_TABLE) # if defined(__cplusplus) extern "C" # else extern # endif IMATH_EXPORT const imath_half_uif_t* imath_half_to_float_table; #endif /// /// Convert half to float /// static inline float imath_half_to_float (imath_half_bits_t h) { #if defined(__F16C__) // NB: The intel implementation does seem to treat NaN slightly // different than the original toFloat table does (i.e. where the // 1 bits are, meaning the signalling or not bits). This seems // benign, given that the original library didn't really deal with // signalling vs non-signalling NaNs # ifdef _MSC_VER /* msvc does not seem to have cvtsh_ss :( */ return _mm_cvtss_f32 (_mm_cvtph_ps (_mm_set1_epi16 (h))); # else return _cvtsh_ss (h); # endif #elif defined(IMATH_HALF_USE_LOOKUP_TABLE) && !defined(IMATH_HALF_NO_LOOKUP_TABLE) return imath_half_to_float_table[h].f; #else imath_half_uif_t v; // this code would be clearer, although it does appear to be faster // (1.06 vs 1.08 ns/call) to avoid the constants and just do 4 // shifts. // uint32_t hexpmant = ( (uint32_t)(h) << 17 ) >> 4; v.i = ((uint32_t)(h >> 15)) << 31; // the likely really does help if most of your numbers are "normal" half numbers if (IMATH_LIKELY ((hexpmant >= 0x00800000))) { v.i |= hexpmant; // either we are a normal number, in which case add in the bias difference // otherwise make sure all exponent bits are set if (IMATH_LIKELY ((hexpmant < 0x0f800000))) v.i += 0x38000000; else v.i |= 0x7f800000; } else if (hexpmant != 0) { // exponent is 0 because we're denormal, don't have to extract // the mantissa, can just use as is // // // other compilers may provide count-leading-zeros primitives, // but we need the community to inform us of the variants uint32_t lc; # if defined(_MSC_VER) && (_M_IX86 || _M_X64) lc = __lzcnt (hexpmant); # elif defined(__GNUC__) || defined(__clang__) lc = (uint32_t) __builtin_clz (hexpmant); # else lc = 0; while (0 == ((hexpmant << lc) & 0x80000000)) ++lc; # endif lc -= 8; // so nominally we want to remove that extra bit we shifted // up, but we are going to add that bit back in, then subtract // from it with the 0x38800000 - (lc << 23).... // // by combining, this allows us to skip the & operation (and // remove a constant) // // hexpmant &= ~0x00800000; v.i |= 0x38800000; // lc is now x, where the desired exponent is then // -14 - lc // + 127 -> new exponent v.i |= (hexpmant << lc); v.i -= (lc << 23); } return v.f; #endif } /// /// Convert half to float /// /// Note: This only supports the "round to even" rounding mode, which /// was the only mode supported by the original OpenEXR library /// static inline imath_half_bits_t imath_float_to_half (float f) { #if defined(__F16C__) # ifdef _MSC_VER // msvc does not seem to have cvtsh_ss :( return _mm_extract_epi16 ( _mm_cvtps_ph (_mm_set_ss (f), (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)), 0); # else // preserve the fixed rounding mode to nearest return _cvtss_sh (f, (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)); # endif #else imath_half_uif_t v; imath_half_bits_t ret; uint32_t e, m, ui, r, shift; v.f = f; ui = (v.i & ~0x80000000); ret = ((v.i >> 16) & 0x8000); // exponent large enough to result in a normal number, round and return if (ui >= 0x38800000) { // inf or nan if (IMATH_UNLIKELY (ui >= 0x7f800000)) { ret |= 0x7c00; if (ui == 0x7f800000) return ret; m = (ui & 0x7fffff) >> 13; // make sure we have at least one bit after shift to preserve nan-ness return ret | (uint16_t)m | (uint16_t)(m == 0); } // too large, round to infinity if (IMATH_UNLIKELY (ui > 0x477fefff)) { # ifdef IMATH_HALF_ENABLE_FP_EXCEPTIONS feraiseexcept (FE_OVERFLOW); # endif return ret | 0x7c00; } ui -= 0x38000000; ui = ((ui + 0x00000fff + ((ui >> 13) & 1)) >> 13); return ret | (uint16_t)ui; } // zero or flush to 0 if (ui < 0x33000001) { # ifdef IMATH_HALF_ENABLE_FP_EXCEPTIONS if (ui == 0) return ret; feraiseexcept (FE_UNDERFLOW); # endif return ret; } // produce a denormalized half e = (ui >> 23); shift = 0x7e - e; m = 0x800000 | (ui & 0x7fffff); r = m << (32 - shift); ret |= (m >> shift); if (r > 0x80000000 || (r == 0x80000000 && (ret & 0x1) != 0)) ++ret; return ret; #endif } //////////////////////////////////////// #ifdef __cplusplus # include IMATH_INTERNAL_NAMESPACE_HEADER_ENTER /// /// /// class half -- 16-bit floating point number /// /// Type half can represent positive and negative numbers whose /// magnitude is between roughly 6.1e-5 and 6.5e+4 with a relative /// error of 9.8e-4; numbers smaller than 6.1e-5 can be represented /// with an absolute error of 6.0e-8. All integers from -2048 to /// +2048 can be represented exactly. /// /// Type half behaves (almost) like the built-in C++ floating point /// types. In arithmetic expressions, half, float and double can be /// mixed freely. Here are a few examples: /// /// half a (3.5); /// float b (a + sqrt (a)); /// a += b; /// b += a; /// b = a + 7; /// /// Conversions from half to float are lossless; all half numbers /// are exactly representable as floats. /// /// Conversions from float to half may not preserve a float's value /// exactly. If a float is not representable as a half, then the /// float value is rounded to the nearest representable half. If a /// float value is exactly in the middle between the two closest /// representable half values, then the float value is rounded to /// the closest half whose least significant bit is zero. /// /// Overflows during float-to-half conversions cause arithmetic /// exceptions. An overflow occurs when the float value to be /// converted is too large to be represented as a half, or if the /// float value is an infinity or a NAN. /// /// The implementation of type half makes the following assumptions /// about the implementation of the built-in C++ types: /// /// * float is an IEEE 754 single-precision number /// * sizeof (float) == 4 /// * sizeof (unsigned int) == sizeof (float) /// * alignof (unsigned int) == alignof (float) /// * sizeof (uint16_t) == 2 /// class IMATH_EXPORT_TYPE half { public: /// A special tag that lets us initialize a half from the raw bits. enum IMATH_EXPORT_ENUM FromBitsTag { FromBits }; /// @{ /// @name Constructors /// Default construction provides no initialization (hence it is /// not constexpr). half() IMATH_NOEXCEPT = default; /// Construct from float half (float f) IMATH_NOEXCEPT; /// Construct from bit-vector constexpr half (FromBitsTag, uint16_t bits) IMATH_NOEXCEPT; /// Copy constructor constexpr half (const half&) IMATH_NOEXCEPT = default; /// Move constructor constexpr half (half&&) IMATH_NOEXCEPT = default; /// Destructor ~half() IMATH_NOEXCEPT = default; /// @} /// Conversion to float operator float() const IMATH_NOEXCEPT; /// @{ /// @name Basic Algebra /// Unary minus constexpr half operator-() const IMATH_NOEXCEPT; /// Assignment half& operator= (const half& h) IMATH_NOEXCEPT = default; /// Move assignment half& operator= (half&& h) IMATH_NOEXCEPT = default; /// Assignment from float half& operator= (float f) IMATH_NOEXCEPT; /// Addition assignment half& operator+= (half h) IMATH_NOEXCEPT; /// Addition assignment from float half& operator+= (float f) IMATH_NOEXCEPT; /// Subtraction assignment half& operator-= (half h) IMATH_NOEXCEPT; /// Subtraction assignment from float half& operator-= (float f) IMATH_NOEXCEPT; /// Multiplication assignment half& operator*= (half h) IMATH_NOEXCEPT; /// Multiplication assignment from float half& operator*= (float f) IMATH_NOEXCEPT; /// Division assignment half& operator/= (half h) IMATH_NOEXCEPT; /// Division assignment from float half& operator/= (float f) IMATH_NOEXCEPT; /// @} /// Round to n-bit precision (n should be between 0 and 10). /// After rounding, the significand's 10-n least significant /// bits will be zero. IMATH_CONSTEXPR14 half round (unsigned int n) const IMATH_NOEXCEPT; /// @{ /// @name Classification /// Return true if a normalized number, a denormalized number, or /// zero. constexpr bool isFinite() const IMATH_NOEXCEPT; /// Return true if a normalized number. constexpr bool isNormalized() const IMATH_NOEXCEPT; /// Return true if a denormalized number. constexpr bool isDenormalized() const IMATH_NOEXCEPT; /// Return true if zero. constexpr bool isZero() const IMATH_NOEXCEPT; /// Return true if NAN. constexpr bool isNan() const IMATH_NOEXCEPT; /// Return true if a positive or a negative infinity constexpr bool isInfinity() const IMATH_NOEXCEPT; /// Return true if the sign bit is set (negative) constexpr bool isNegative() const IMATH_NOEXCEPT; /// @} /// @{ /// @name Special values /// Return +infinity static constexpr half posInf() IMATH_NOEXCEPT; /// Return -infinity static constexpr half negInf() IMATH_NOEXCEPT; /// Returns a NAN with the bit pattern 0111111111111111 static constexpr half qNan() IMATH_NOEXCEPT; /// Return a NAN with the bit pattern 0111110111111111 static constexpr half sNan() IMATH_NOEXCEPT; /// @} /// @{ /// @name Access to the internal representation /// Return the bit pattern IMATH_EXPORT constexpr uint16_t bits() const IMATH_NOEXCEPT; /// Set the bit pattern IMATH_EXPORT IMATH_CONSTEXPR14 void setBits (uint16_t bits) IMATH_NOEXCEPT; /// @} public: static_assert (sizeof (float) == sizeof (uint32_t), "Assumption about the size of floats correct"); using uif = imath_half_uif; private: constexpr uint16_t mantissa() const IMATH_NOEXCEPT; constexpr uint16_t exponent() const IMATH_NOEXCEPT; uint16_t _h; }; //---------------------------- // Half-from-float constructor //---------------------------- inline half::half (float f) IMATH_NOEXCEPT : _h (imath_float_to_half (f)) { } //------------------------------------------ // Half from raw bits constructor //------------------------------------------ inline constexpr half::half (FromBitsTag, uint16_t bits) IMATH_NOEXCEPT : _h (bits) {} //------------------------- // Half-to-float conversion //------------------------- inline half::operator float() const IMATH_NOEXCEPT { return imath_half_to_float (_h); } //------------------------- // Round to n-bit precision //------------------------- inline IMATH_CONSTEXPR14 half half::round (unsigned int n) const IMATH_NOEXCEPT { // // Parameter check. // if (n >= 10) return *this; // // Disassemble h into the sign, s, // and the combined exponent and significand, e. // uint16_t s = _h & 0x8000; uint16_t e = _h & 0x7fff; // // Round the exponent and significand to the nearest value // where ones occur only in the (10-n) most significant bits. // Note that the exponent adjusts automatically if rounding // up causes the significand to overflow. // e >>= 9 - n; e += e & 1; e <<= 9 - n; // // Check for exponent overflow. // if (e >= 0x7c00) { // // Overflow occurred -- truncate instead of rounding. // e = _h; e >>= 10 - n; e <<= 10 - n; } // // Put the original sign bit back. // half h (FromBits, s | e); return h; } //----------------------- // Other inline functions //----------------------- inline constexpr half half::operator-() const IMATH_NOEXCEPT { return half (FromBits, bits() ^ 0x8000); } inline half& half::operator= (float f) IMATH_NOEXCEPT { *this = half (f); return *this; } inline half& half::operator+= (half h) IMATH_NOEXCEPT { *this = half (float (*this) + float (h)); return *this; } inline half& half::operator+= (float f) IMATH_NOEXCEPT { *this = half (float (*this) + f); return *this; } inline half& half::operator-= (half h) IMATH_NOEXCEPT { *this = half (float (*this) - float (h)); return *this; } inline half& half::operator-= (float f) IMATH_NOEXCEPT { *this = half (float (*this) - f); return *this; } inline half& half::operator*= (half h) IMATH_NOEXCEPT { *this = half (float (*this) * float (h)); return *this; } inline half& half::operator*= (float f) IMATH_NOEXCEPT { *this = half (float (*this) * f); return *this; } inline half& half::operator/= (half h) IMATH_NOEXCEPT { *this = half (float (*this) / float (h)); return *this; } inline half& half::operator/= (float f) IMATH_NOEXCEPT { *this = half (float (*this) / f); return *this; } inline constexpr uint16_t half::mantissa() const IMATH_NOEXCEPT { return _h & 0x3ff; } inline constexpr uint16_t half::exponent() const IMATH_NOEXCEPT { return (_h >> 10) & 0x001f; } inline constexpr bool half::isFinite() const IMATH_NOEXCEPT { return exponent() < 31; } inline constexpr bool half::isNormalized() const IMATH_NOEXCEPT { return exponent() > 0 && exponent() < 31; } inline constexpr bool half::isDenormalized() const IMATH_NOEXCEPT { return exponent() == 0 && mantissa() != 0; } inline constexpr bool half::isZero() const IMATH_NOEXCEPT { return (_h & 0x7fff) == 0; } inline constexpr bool half::isNan() const IMATH_NOEXCEPT { return exponent() == 31 && mantissa() != 0; } inline constexpr bool half::isInfinity() const IMATH_NOEXCEPT { return exponent() == 31 && mantissa() == 0; } inline constexpr bool half::isNegative() const IMATH_NOEXCEPT { return (_h & 0x8000) != 0; } inline constexpr half half::posInf() IMATH_NOEXCEPT { return half (FromBits, 0x7c00); } inline constexpr half half::negInf() IMATH_NOEXCEPT { return half (FromBits, 0xfc00); } inline constexpr half half::qNan() IMATH_NOEXCEPT { return half (FromBits, 0x7fff); } inline constexpr half half::sNan() IMATH_NOEXCEPT { return half (FromBits, 0x7dff); } inline constexpr uint16_t half::bits() const IMATH_NOEXCEPT { return _h; } inline IMATH_CONSTEXPR14 void half::setBits (uint16_t bits) IMATH_NOEXCEPT { _h = bits; } IMATH_INTERNAL_NAMESPACE_HEADER_EXIT /// Output h to os, formatted as a float IMATH_EXPORT std::ostream& operator<< (std::ostream& os, IMATH_INTERNAL_NAMESPACE::half h); /// Input h from is IMATH_EXPORT std::istream& operator>> (std::istream& is, IMATH_INTERNAL_NAMESPACE::half& h); //---------- // Debugging //---------- IMATH_EXPORT void printBits (std::ostream& os, IMATH_INTERNAL_NAMESPACE::half h); IMATH_EXPORT void printBits (std::ostream& os, float f); IMATH_EXPORT void printBits (char c[19], IMATH_INTERNAL_NAMESPACE::half h); IMATH_EXPORT void printBits (char c[35], float f); # ifndef __CUDACC__ using half = IMATH_INTERNAL_NAMESPACE::half; # else # include # endif #endif // __cplusplus #endif // IMATH_HALF_H_ Imath-3.1.4/src/Imath/halfFunction.h000066400000000000000000000070401417213455000172060ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // //--------------------------------------------------------------------------- // // halfFunction -- a class for fast evaluation // of half --> T functions // // The constructor for a halfFunction object, // // halfFunction (function, // domainMin, domainMax, // defaultValue, // posInfValue, negInfValue, // nanValue); // // evaluates the function for all finite half values in the interval // [domainMin, domainMax], and stores the results in a lookup table. // For finite half values that are not in [domainMin, domainMax], the // constructor stores defaultValue in the table. For positive infinity, // negative infinity and NANs, posInfValue, negInfValue and nanValue // are stored in the table. // // The tabulated function can then be evaluated quickly for arbitrary // half values by calling the the halfFunction object's operator() // method. // // Example: // // #include // #include // // halfFunction hsin (sin); // // halfFunction hsqrt (sqrt, // function // 0, HALF_MAX, // domain // half::qNan(), // sqrt(x) for x < 0 // half::posInf(), // sqrt(+inf) // half::qNan(), // sqrt(-inf) // half::qNan()); // sqrt(nan) // // half x = hsin (1); // half y = hsqrt (3.5); // //--------------------------------------------------------------------------- #ifndef _HALF_FUNCTION_H_ #define _HALF_FUNCTION_H_ /// @cond Doxygen_Suppress #include "half.h" #include "ImathConfig.h" #ifndef IMATH_HAVE_LARGE_STACK # include // need this for memset #else #endif #include template class halfFunction { public: //------------ // Constructor //------------ template halfFunction (Function f, half domainMin = -HALF_MAX, half domainMax = HALF_MAX, T defaultValue = 0, T posInfValue = 0, T negInfValue = 0, T nanValue = 0); #ifndef IMATH_HAVE_LARGE_STACK ~halfFunction() { delete[] _lut; } halfFunction (const halfFunction&) = delete; halfFunction& operator= (const halfFunction&) = delete; halfFunction (halfFunction&&) = delete; halfFunction& operator= (halfFunction&&) = delete; #endif //----------- // Evaluation //----------- T operator() (half x) const; private: #ifdef IMATH_HAVE_LARGE_STACK T _lut[1 << 16]; #else T* _lut; #endif }; //--------------- // Implementation //--------------- template template halfFunction::halfFunction (Function f, half domainMin, half domainMax, T defaultValue, T posInfValue, T negInfValue, T nanValue) { #ifndef IMATH_HAVE_LARGE_STACK _lut = new T[1 << 16]; #endif for (int i = 0; i < (1 << 16); i++) { half x; x.setBits (i); if (x.isNan()) _lut[i] = nanValue; else if (x.isInfinity()) _lut[i] = x.isNegative() ? negInfValue : posInfValue; else if (x < domainMin || x > domainMax) _lut[i] = defaultValue; else _lut[i] = f (x); } } template inline T halfFunction::operator() (half x) const { return _lut[x.bits()]; } /// @endcond #endif Imath-3.1.4/src/Imath/halfLimits.h000066400000000000000000000055271417213455000166720ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // Primary origin authors: // Florian Kainz // Rod Bogart // #ifndef INCLUDED_HALF_LIMITS_H #define INCLUDED_HALF_LIMITS_H //------------------------------------------------------------------------ // // C++ standard library-style numeric_limits for class half // //------------------------------------------------------------------------ #include "half.h" #include /// @cond Doxygen_Suppress namespace std { template <> class numeric_limits { public: static const bool is_specialized = true; static constexpr half min() IMATH_NOEXCEPT { return half(half::FromBits, 0x0400); /*HALF_MIN*/ } static constexpr half max() IMATH_NOEXCEPT { return half(half::FromBits, 0x7bff); /*HALF_MAX*/ } static constexpr half lowest() { return half(half::FromBits, 0xfbff); /* -HALF_MAX */ } static constexpr int digits = HALF_MANT_DIG; static constexpr int digits10 = HALF_DIG; static constexpr int max_digits10 = HALF_DECIMAL_DIG; static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = HALF_RADIX; static constexpr half epsilon() IMATH_NOEXCEPT { return half(half::FromBits, 0x1400); /*HALF_EPSILON*/ } static constexpr half round_error() IMATH_NOEXCEPT { return half(half::FromBits, 0x3800); /*0.5*/ } static constexpr int min_exponent = HALF_DENORM_MIN_EXP; static constexpr int min_exponent10 = HALF_DENORM_MIN_10_EXP; static constexpr int max_exponent = HALF_MAX_EXP; static constexpr int max_exponent10 = HALF_MAX_10_EXP; static constexpr bool has_infinity = true; static constexpr bool has_quiet_NaN = true; static constexpr bool has_signaling_NaN = true; static constexpr float_denorm_style has_denorm = denorm_present; static constexpr bool has_denorm_loss = false; static constexpr half infinity() IMATH_NOEXCEPT { return half(half::FromBits, 0x7c00); /*half::posInf()*/ } static constexpr half quiet_NaN() IMATH_NOEXCEPT { return half(half::FromBits, 0x7fff); /*half::qNan()*/ } static constexpr half signaling_NaN() IMATH_NOEXCEPT { return half(half::FromBits, 0x7dff); /*half::sNan()*/ } static constexpr half denorm_min() IMATH_NOEXCEPT { return half(half::FromBits, 0x0001); /*HALF_DENORM_MIN*/ } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; /// @endcond } // namespace std #endif Imath-3.1.4/src/Imath/toFloat.cpp000066400000000000000000000051151417213455000165320ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // //--------------------------------------------------------------------------- // // toFloat // // A program to generate the lookup table for half-to-float // conversion needed by class half. // The program loops over all 65536 possible half numbers, // converts each of them to a float, and prints the result. // //--------------------------------------------------------------------------- #include #include using namespace std; //--------------------------------------------------- // Interpret an unsigned short bit pattern as a half, // and convert that half to the corresponding float's // bit pattern. //--------------------------------------------------- unsigned int halfToFloat (unsigned short y) { int s = (y >> 15) & 0x00000001; int e = (y >> 10) & 0x0000001f; int m = y & 0x000003ff; if (e == 0) { if (m == 0) { // // Plus or minus zero // return s << 31; } else { // // Denormalized number -- renormalize it // while (!(m & 0x00000400)) { m <<= 1; e -= 1; } e += 1; m &= ~0x00000400; } } else if (e == 31) { if (m == 0) { // // Positive or negative infinity // return (s << 31) | 0x7f800000; } else { // // Nan -- preserve sign and significand bits // return (s << 31) | 0x7f800000 | (m << 13); } } // // Normalized number // e = e + (127 - 15); m = m << 13; // // Assemble s, e and m. // return (s << 31) | (e << 23) | m; } //--------------------------------------------- // Main - prints the half-to-float lookup table //--------------------------------------------- int main() { cout.precision (9); cout.setf (ios_base::hex, ios_base::basefield); cout << "//\n" "// This is an automatically generated file.\n" "// Do not edit.\n" "//\n\n"; cout << "{\n "; const int iMax = (1 << 16); for (int i = 0; i < iMax; i++) { cout << "{0x" << setfill ('0') << setw (8) << halfToFloat (i) << "}, "; if (i % 4 == 3) { cout << "\n"; if (i < iMax - 1) cout << " "; } } cout << "};\n"; return 0; } Imath-3.1.4/src/Imath/toFloat.h000066400000000000000000036403211417213455000162060ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // This is an automatically generated file. // Do not edit. // // clang-format off { {0x00000000}, {0x33800000}, {0x34000000}, {0x34400000}, {0x34800000}, {0x34a00000}, {0x34c00000}, {0x34e00000}, {0x35000000}, {0x35100000}, {0x35200000}, {0x35300000}, {0x35400000}, {0x35500000}, {0x35600000}, {0x35700000}, {0x35800000}, {0x35880000}, {0x35900000}, {0x35980000}, {0x35a00000}, {0x35a80000}, {0x35b00000}, {0x35b80000}, {0x35c00000}, {0x35c80000}, {0x35d00000}, {0x35d80000}, {0x35e00000}, {0x35e80000}, {0x35f00000}, {0x35f80000}, {0x36000000}, {0x36040000}, {0x36080000}, {0x360c0000}, {0x36100000}, {0x36140000}, {0x36180000}, {0x361c0000}, {0x36200000}, {0x36240000}, {0x36280000}, {0x362c0000}, {0x36300000}, {0x36340000}, {0x36380000}, {0x363c0000}, {0x36400000}, {0x36440000}, {0x36480000}, {0x364c0000}, {0x36500000}, {0x36540000}, {0x36580000}, {0x365c0000}, {0x36600000}, {0x36640000}, {0x36680000}, {0x366c0000}, {0x36700000}, {0x36740000}, {0x36780000}, {0x367c0000}, {0x36800000}, {0x36820000}, {0x36840000}, {0x36860000}, {0x36880000}, {0x368a0000}, {0x368c0000}, {0x368e0000}, {0x36900000}, {0x36920000}, {0x36940000}, {0x36960000}, {0x36980000}, {0x369a0000}, {0x369c0000}, {0x369e0000}, {0x36a00000}, {0x36a20000}, {0x36a40000}, {0x36a60000}, {0x36a80000}, {0x36aa0000}, {0x36ac0000}, {0x36ae0000}, {0x36b00000}, {0x36b20000}, {0x36b40000}, {0x36b60000}, {0x36b80000}, {0x36ba0000}, {0x36bc0000}, {0x36be0000}, {0x36c00000}, {0x36c20000}, {0x36c40000}, {0x36c60000}, {0x36c80000}, {0x36ca0000}, {0x36cc0000}, {0x36ce0000}, {0x36d00000}, {0x36d20000}, {0x36d40000}, {0x36d60000}, {0x36d80000}, {0x36da0000}, {0x36dc0000}, {0x36de0000}, {0x36e00000}, {0x36e20000}, {0x36e40000}, {0x36e60000}, {0x36e80000}, {0x36ea0000}, {0x36ec0000}, {0x36ee0000}, {0x36f00000}, {0x36f20000}, {0x36f40000}, {0x36f60000}, {0x36f80000}, {0x36fa0000}, {0x36fc0000}, {0x36fe0000}, {0x37000000}, {0x37010000}, {0x37020000}, {0x37030000}, {0x37040000}, {0x37050000}, {0x37060000}, {0x37070000}, {0x37080000}, {0x37090000}, {0x370a0000}, {0x370b0000}, {0x370c0000}, {0x370d0000}, {0x370e0000}, {0x370f0000}, {0x37100000}, {0x37110000}, {0x37120000}, {0x37130000}, {0x37140000}, {0x37150000}, {0x37160000}, {0x37170000}, {0x37180000}, {0x37190000}, {0x371a0000}, {0x371b0000}, {0x371c0000}, {0x371d0000}, {0x371e0000}, {0x371f0000}, {0x37200000}, {0x37210000}, {0x37220000}, {0x37230000}, {0x37240000}, {0x37250000}, {0x37260000}, {0x37270000}, {0x37280000}, {0x37290000}, {0x372a0000}, {0x372b0000}, {0x372c0000}, {0x372d0000}, {0x372e0000}, {0x372f0000}, {0x37300000}, {0x37310000}, {0x37320000}, {0x37330000}, {0x37340000}, {0x37350000}, {0x37360000}, {0x37370000}, {0x37380000}, {0x37390000}, {0x373a0000}, {0x373b0000}, {0x373c0000}, {0x373d0000}, {0x373e0000}, {0x373f0000}, {0x37400000}, {0x37410000}, {0x37420000}, {0x37430000}, {0x37440000}, {0x37450000}, {0x37460000}, {0x37470000}, {0x37480000}, {0x37490000}, {0x374a0000}, {0x374b0000}, {0x374c0000}, {0x374d0000}, {0x374e0000}, {0x374f0000}, {0x37500000}, {0x37510000}, {0x37520000}, {0x37530000}, {0x37540000}, {0x37550000}, {0x37560000}, {0x37570000}, {0x37580000}, {0x37590000}, {0x375a0000}, {0x375b0000}, {0x375c0000}, {0x375d0000}, {0x375e0000}, {0x375f0000}, {0x37600000}, {0x37610000}, {0x37620000}, {0x37630000}, {0x37640000}, {0x37650000}, {0x37660000}, {0x37670000}, {0x37680000}, {0x37690000}, {0x376a0000}, {0x376b0000}, {0x376c0000}, {0x376d0000}, {0x376e0000}, {0x376f0000}, {0x37700000}, {0x37710000}, {0x37720000}, {0x37730000}, {0x37740000}, {0x37750000}, {0x37760000}, {0x37770000}, {0x37780000}, {0x37790000}, {0x377a0000}, {0x377b0000}, {0x377c0000}, {0x377d0000}, {0x377e0000}, {0x377f0000}, {0x37800000}, {0x37808000}, {0x37810000}, {0x37818000}, {0x37820000}, {0x37828000}, {0x37830000}, {0x37838000}, {0x37840000}, {0x37848000}, {0x37850000}, {0x37858000}, {0x37860000}, {0x37868000}, {0x37870000}, {0x37878000}, {0x37880000}, {0x37888000}, {0x37890000}, {0x37898000}, {0x378a0000}, {0x378a8000}, {0x378b0000}, {0x378b8000}, {0x378c0000}, {0x378c8000}, {0x378d0000}, {0x378d8000}, {0x378e0000}, {0x378e8000}, {0x378f0000}, {0x378f8000}, {0x37900000}, {0x37908000}, {0x37910000}, {0x37918000}, {0x37920000}, {0x37928000}, {0x37930000}, {0x37938000}, {0x37940000}, {0x37948000}, {0x37950000}, {0x37958000}, {0x37960000}, {0x37968000}, {0x37970000}, {0x37978000}, {0x37980000}, {0x37988000}, {0x37990000}, {0x37998000}, {0x379a0000}, {0x379a8000}, {0x379b0000}, {0x379b8000}, {0x379c0000}, {0x379c8000}, {0x379d0000}, {0x379d8000}, {0x379e0000}, {0x379e8000}, {0x379f0000}, {0x379f8000}, {0x37a00000}, {0x37a08000}, {0x37a10000}, {0x37a18000}, {0x37a20000}, {0x37a28000}, {0x37a30000}, {0x37a38000}, {0x37a40000}, {0x37a48000}, {0x37a50000}, {0x37a58000}, {0x37a60000}, {0x37a68000}, {0x37a70000}, {0x37a78000}, {0x37a80000}, {0x37a88000}, {0x37a90000}, {0x37a98000}, {0x37aa0000}, {0x37aa8000}, {0x37ab0000}, {0x37ab8000}, {0x37ac0000}, {0x37ac8000}, {0x37ad0000}, {0x37ad8000}, {0x37ae0000}, {0x37ae8000}, {0x37af0000}, {0x37af8000}, {0x37b00000}, {0x37b08000}, {0x37b10000}, {0x37b18000}, {0x37b20000}, {0x37b28000}, {0x37b30000}, {0x37b38000}, {0x37b40000}, {0x37b48000}, {0x37b50000}, {0x37b58000}, {0x37b60000}, {0x37b68000}, {0x37b70000}, {0x37b78000}, {0x37b80000}, {0x37b88000}, {0x37b90000}, {0x37b98000}, {0x37ba0000}, {0x37ba8000}, {0x37bb0000}, {0x37bb8000}, {0x37bc0000}, {0x37bc8000}, {0x37bd0000}, {0x37bd8000}, {0x37be0000}, {0x37be8000}, {0x37bf0000}, {0x37bf8000}, {0x37c00000}, {0x37c08000}, {0x37c10000}, {0x37c18000}, {0x37c20000}, {0x37c28000}, {0x37c30000}, {0x37c38000}, {0x37c40000}, {0x37c48000}, {0x37c50000}, {0x37c58000}, {0x37c60000}, {0x37c68000}, {0x37c70000}, {0x37c78000}, {0x37c80000}, {0x37c88000}, {0x37c90000}, {0x37c98000}, {0x37ca0000}, {0x37ca8000}, {0x37cb0000}, {0x37cb8000}, {0x37cc0000}, {0x37cc8000}, {0x37cd0000}, {0x37cd8000}, {0x37ce0000}, {0x37ce8000}, {0x37cf0000}, {0x37cf8000}, {0x37d00000}, {0x37d08000}, {0x37d10000}, {0x37d18000}, {0x37d20000}, {0x37d28000}, {0x37d30000}, {0x37d38000}, {0x37d40000}, {0x37d48000}, {0x37d50000}, {0x37d58000}, {0x37d60000}, {0x37d68000}, {0x37d70000}, {0x37d78000}, {0x37d80000}, {0x37d88000}, {0x37d90000}, {0x37d98000}, {0x37da0000}, {0x37da8000}, {0x37db0000}, {0x37db8000}, {0x37dc0000}, {0x37dc8000}, {0x37dd0000}, {0x37dd8000}, {0x37de0000}, {0x37de8000}, {0x37df0000}, {0x37df8000}, {0x37e00000}, {0x37e08000}, {0x37e10000}, {0x37e18000}, {0x37e20000}, {0x37e28000}, {0x37e30000}, {0x37e38000}, {0x37e40000}, {0x37e48000}, {0x37e50000}, {0x37e58000}, {0x37e60000}, {0x37e68000}, {0x37e70000}, {0x37e78000}, {0x37e80000}, {0x37e88000}, {0x37e90000}, {0x37e98000}, {0x37ea0000}, {0x37ea8000}, {0x37eb0000}, {0x37eb8000}, {0x37ec0000}, {0x37ec8000}, {0x37ed0000}, {0x37ed8000}, {0x37ee0000}, {0x37ee8000}, {0x37ef0000}, {0x37ef8000}, {0x37f00000}, {0x37f08000}, {0x37f10000}, {0x37f18000}, {0x37f20000}, {0x37f28000}, {0x37f30000}, {0x37f38000}, {0x37f40000}, {0x37f48000}, {0x37f50000}, {0x37f58000}, {0x37f60000}, {0x37f68000}, {0x37f70000}, {0x37f78000}, {0x37f80000}, {0x37f88000}, {0x37f90000}, {0x37f98000}, {0x37fa0000}, {0x37fa8000}, {0x37fb0000}, {0x37fb8000}, {0x37fc0000}, {0x37fc8000}, {0x37fd0000}, {0x37fd8000}, {0x37fe0000}, {0x37fe8000}, {0x37ff0000}, {0x37ff8000}, {0x38000000}, {0x38004000}, {0x38008000}, {0x3800c000}, {0x38010000}, {0x38014000}, {0x38018000}, {0x3801c000}, {0x38020000}, {0x38024000}, {0x38028000}, {0x3802c000}, {0x38030000}, {0x38034000}, {0x38038000}, {0x3803c000}, {0x38040000}, {0x38044000}, {0x38048000}, {0x3804c000}, {0x38050000}, {0x38054000}, {0x38058000}, {0x3805c000}, {0x38060000}, {0x38064000}, {0x38068000}, {0x3806c000}, {0x38070000}, {0x38074000}, {0x38078000}, {0x3807c000}, {0x38080000}, {0x38084000}, {0x38088000}, {0x3808c000}, {0x38090000}, {0x38094000}, {0x38098000}, {0x3809c000}, {0x380a0000}, {0x380a4000}, {0x380a8000}, {0x380ac000}, {0x380b0000}, {0x380b4000}, {0x380b8000}, {0x380bc000}, {0x380c0000}, {0x380c4000}, {0x380c8000}, {0x380cc000}, {0x380d0000}, {0x380d4000}, {0x380d8000}, {0x380dc000}, {0x380e0000}, {0x380e4000}, {0x380e8000}, {0x380ec000}, {0x380f0000}, {0x380f4000}, {0x380f8000}, {0x380fc000}, {0x38100000}, {0x38104000}, {0x38108000}, {0x3810c000}, {0x38110000}, {0x38114000}, {0x38118000}, {0x3811c000}, {0x38120000}, {0x38124000}, {0x38128000}, {0x3812c000}, {0x38130000}, {0x38134000}, {0x38138000}, {0x3813c000}, {0x38140000}, {0x38144000}, {0x38148000}, {0x3814c000}, {0x38150000}, {0x38154000}, {0x38158000}, {0x3815c000}, {0x38160000}, {0x38164000}, {0x38168000}, {0x3816c000}, {0x38170000}, {0x38174000}, {0x38178000}, {0x3817c000}, {0x38180000}, {0x38184000}, {0x38188000}, {0x3818c000}, {0x38190000}, {0x38194000}, {0x38198000}, {0x3819c000}, {0x381a0000}, {0x381a4000}, {0x381a8000}, {0x381ac000}, {0x381b0000}, {0x381b4000}, {0x381b8000}, {0x381bc000}, {0x381c0000}, {0x381c4000}, {0x381c8000}, {0x381cc000}, {0x381d0000}, {0x381d4000}, {0x381d8000}, {0x381dc000}, {0x381e0000}, {0x381e4000}, {0x381e8000}, {0x381ec000}, {0x381f0000}, {0x381f4000}, {0x381f8000}, {0x381fc000}, {0x38200000}, {0x38204000}, {0x38208000}, {0x3820c000}, {0x38210000}, {0x38214000}, {0x38218000}, {0x3821c000}, {0x38220000}, {0x38224000}, {0x38228000}, {0x3822c000}, {0x38230000}, {0x38234000}, {0x38238000}, {0x3823c000}, {0x38240000}, {0x38244000}, {0x38248000}, {0x3824c000}, {0x38250000}, {0x38254000}, {0x38258000}, {0x3825c000}, {0x38260000}, {0x38264000}, {0x38268000}, {0x3826c000}, {0x38270000}, {0x38274000}, {0x38278000}, {0x3827c000}, {0x38280000}, {0x38284000}, {0x38288000}, {0x3828c000}, {0x38290000}, {0x38294000}, {0x38298000}, {0x3829c000}, {0x382a0000}, {0x382a4000}, {0x382a8000}, {0x382ac000}, {0x382b0000}, {0x382b4000}, {0x382b8000}, {0x382bc000}, {0x382c0000}, {0x382c4000}, {0x382c8000}, {0x382cc000}, {0x382d0000}, {0x382d4000}, {0x382d8000}, {0x382dc000}, {0x382e0000}, {0x382e4000}, {0x382e8000}, {0x382ec000}, {0x382f0000}, {0x382f4000}, {0x382f8000}, {0x382fc000}, {0x38300000}, {0x38304000}, {0x38308000}, {0x3830c000}, {0x38310000}, {0x38314000}, {0x38318000}, {0x3831c000}, {0x38320000}, {0x38324000}, {0x38328000}, {0x3832c000}, {0x38330000}, {0x38334000}, {0x38338000}, {0x3833c000}, {0x38340000}, {0x38344000}, {0x38348000}, {0x3834c000}, {0x38350000}, {0x38354000}, {0x38358000}, {0x3835c000}, {0x38360000}, {0x38364000}, {0x38368000}, {0x3836c000}, {0x38370000}, {0x38374000}, {0x38378000}, {0x3837c000}, {0x38380000}, {0x38384000}, {0x38388000}, {0x3838c000}, {0x38390000}, {0x38394000}, {0x38398000}, {0x3839c000}, {0x383a0000}, {0x383a4000}, {0x383a8000}, {0x383ac000}, {0x383b0000}, {0x383b4000}, {0x383b8000}, {0x383bc000}, {0x383c0000}, {0x383c4000}, {0x383c8000}, {0x383cc000}, {0x383d0000}, {0x383d4000}, {0x383d8000}, {0x383dc000}, {0x383e0000}, {0x383e4000}, {0x383e8000}, {0x383ec000}, {0x383f0000}, {0x383f4000}, {0x383f8000}, {0x383fc000}, {0x38400000}, {0x38404000}, {0x38408000}, {0x3840c000}, {0x38410000}, {0x38414000}, {0x38418000}, {0x3841c000}, {0x38420000}, {0x38424000}, {0x38428000}, {0x3842c000}, {0x38430000}, {0x38434000}, {0x38438000}, {0x3843c000}, {0x38440000}, {0x38444000}, {0x38448000}, {0x3844c000}, {0x38450000}, {0x38454000}, {0x38458000}, {0x3845c000}, {0x38460000}, {0x38464000}, {0x38468000}, {0x3846c000}, {0x38470000}, {0x38474000}, {0x38478000}, {0x3847c000}, {0x38480000}, {0x38484000}, {0x38488000}, {0x3848c000}, {0x38490000}, {0x38494000}, {0x38498000}, {0x3849c000}, {0x384a0000}, {0x384a4000}, {0x384a8000}, {0x384ac000}, {0x384b0000}, {0x384b4000}, {0x384b8000}, {0x384bc000}, {0x384c0000}, {0x384c4000}, {0x384c8000}, {0x384cc000}, {0x384d0000}, {0x384d4000}, {0x384d8000}, {0x384dc000}, {0x384e0000}, {0x384e4000}, {0x384e8000}, {0x384ec000}, {0x384f0000}, {0x384f4000}, {0x384f8000}, {0x384fc000}, {0x38500000}, {0x38504000}, {0x38508000}, {0x3850c000}, {0x38510000}, {0x38514000}, {0x38518000}, {0x3851c000}, {0x38520000}, {0x38524000}, {0x38528000}, {0x3852c000}, {0x38530000}, {0x38534000}, {0x38538000}, {0x3853c000}, {0x38540000}, {0x38544000}, {0x38548000}, {0x3854c000}, {0x38550000}, {0x38554000}, {0x38558000}, {0x3855c000}, {0x38560000}, {0x38564000}, {0x38568000}, {0x3856c000}, {0x38570000}, {0x38574000}, {0x38578000}, {0x3857c000}, {0x38580000}, {0x38584000}, {0x38588000}, {0x3858c000}, {0x38590000}, {0x38594000}, {0x38598000}, {0x3859c000}, {0x385a0000}, {0x385a4000}, {0x385a8000}, {0x385ac000}, {0x385b0000}, {0x385b4000}, {0x385b8000}, {0x385bc000}, {0x385c0000}, {0x385c4000}, {0x385c8000}, {0x385cc000}, {0x385d0000}, {0x385d4000}, {0x385d8000}, {0x385dc000}, {0x385e0000}, {0x385e4000}, {0x385e8000}, {0x385ec000}, {0x385f0000}, {0x385f4000}, {0x385f8000}, {0x385fc000}, {0x38600000}, {0x38604000}, {0x38608000}, {0x3860c000}, {0x38610000}, {0x38614000}, {0x38618000}, {0x3861c000}, {0x38620000}, {0x38624000}, {0x38628000}, {0x3862c000}, {0x38630000}, {0x38634000}, {0x38638000}, {0x3863c000}, {0x38640000}, {0x38644000}, {0x38648000}, {0x3864c000}, {0x38650000}, {0x38654000}, {0x38658000}, {0x3865c000}, {0x38660000}, {0x38664000}, {0x38668000}, {0x3866c000}, {0x38670000}, {0x38674000}, {0x38678000}, {0x3867c000}, {0x38680000}, {0x38684000}, {0x38688000}, {0x3868c000}, {0x38690000}, {0x38694000}, {0x38698000}, {0x3869c000}, {0x386a0000}, {0x386a4000}, {0x386a8000}, {0x386ac000}, {0x386b0000}, {0x386b4000}, {0x386b8000}, {0x386bc000}, {0x386c0000}, {0x386c4000}, {0x386c8000}, {0x386cc000}, {0x386d0000}, {0x386d4000}, {0x386d8000}, {0x386dc000}, {0x386e0000}, {0x386e4000}, {0x386e8000}, {0x386ec000}, {0x386f0000}, {0x386f4000}, {0x386f8000}, {0x386fc000}, {0x38700000}, {0x38704000}, {0x38708000}, {0x3870c000}, {0x38710000}, {0x38714000}, {0x38718000}, {0x3871c000}, {0x38720000}, {0x38724000}, {0x38728000}, {0x3872c000}, {0x38730000}, {0x38734000}, {0x38738000}, {0x3873c000}, {0x38740000}, {0x38744000}, {0x38748000}, {0x3874c000}, {0x38750000}, {0x38754000}, {0x38758000}, {0x3875c000}, {0x38760000}, {0x38764000}, {0x38768000}, {0x3876c000}, {0x38770000}, {0x38774000}, {0x38778000}, {0x3877c000}, {0x38780000}, {0x38784000}, {0x38788000}, {0x3878c000}, {0x38790000}, {0x38794000}, {0x38798000}, {0x3879c000}, {0x387a0000}, {0x387a4000}, {0x387a8000}, {0x387ac000}, {0x387b0000}, {0x387b4000}, {0x387b8000}, {0x387bc000}, {0x387c0000}, {0x387c4000}, {0x387c8000}, {0x387cc000}, {0x387d0000}, {0x387d4000}, {0x387d8000}, {0x387dc000}, {0x387e0000}, {0x387e4000}, {0x387e8000}, {0x387ec000}, {0x387f0000}, {0x387f4000}, {0x387f8000}, {0x387fc000}, {0x38800000}, {0x38802000}, {0x38804000}, {0x38806000}, {0x38808000}, {0x3880a000}, {0x3880c000}, {0x3880e000}, {0x38810000}, {0x38812000}, {0x38814000}, {0x38816000}, {0x38818000}, {0x3881a000}, {0x3881c000}, {0x3881e000}, {0x38820000}, {0x38822000}, {0x38824000}, {0x38826000}, {0x38828000}, {0x3882a000}, {0x3882c000}, {0x3882e000}, {0x38830000}, {0x38832000}, {0x38834000}, {0x38836000}, {0x38838000}, {0x3883a000}, {0x3883c000}, {0x3883e000}, {0x38840000}, {0x38842000}, {0x38844000}, {0x38846000}, {0x38848000}, {0x3884a000}, {0x3884c000}, {0x3884e000}, {0x38850000}, {0x38852000}, {0x38854000}, {0x38856000}, {0x38858000}, {0x3885a000}, {0x3885c000}, {0x3885e000}, {0x38860000}, {0x38862000}, {0x38864000}, {0x38866000}, {0x38868000}, {0x3886a000}, {0x3886c000}, {0x3886e000}, {0x38870000}, {0x38872000}, {0x38874000}, {0x38876000}, {0x38878000}, {0x3887a000}, {0x3887c000}, {0x3887e000}, {0x38880000}, {0x38882000}, {0x38884000}, {0x38886000}, {0x38888000}, {0x3888a000}, {0x3888c000}, {0x3888e000}, {0x38890000}, {0x38892000}, {0x38894000}, {0x38896000}, {0x38898000}, {0x3889a000}, {0x3889c000}, {0x3889e000}, {0x388a0000}, {0x388a2000}, {0x388a4000}, {0x388a6000}, {0x388a8000}, {0x388aa000}, {0x388ac000}, {0x388ae000}, {0x388b0000}, {0x388b2000}, {0x388b4000}, {0x388b6000}, {0x388b8000}, {0x388ba000}, {0x388bc000}, {0x388be000}, {0x388c0000}, {0x388c2000}, {0x388c4000}, {0x388c6000}, {0x388c8000}, {0x388ca000}, {0x388cc000}, {0x388ce000}, {0x388d0000}, {0x388d2000}, {0x388d4000}, {0x388d6000}, {0x388d8000}, {0x388da000}, {0x388dc000}, {0x388de000}, {0x388e0000}, {0x388e2000}, {0x388e4000}, {0x388e6000}, {0x388e8000}, {0x388ea000}, {0x388ec000}, {0x388ee000}, {0x388f0000}, {0x388f2000}, {0x388f4000}, {0x388f6000}, {0x388f8000}, {0x388fa000}, {0x388fc000}, {0x388fe000}, {0x38900000}, {0x38902000}, {0x38904000}, {0x38906000}, {0x38908000}, {0x3890a000}, {0x3890c000}, {0x3890e000}, {0x38910000}, {0x38912000}, {0x38914000}, {0x38916000}, {0x38918000}, {0x3891a000}, {0x3891c000}, {0x3891e000}, {0x38920000}, {0x38922000}, {0x38924000}, {0x38926000}, {0x38928000}, {0x3892a000}, {0x3892c000}, {0x3892e000}, {0x38930000}, {0x38932000}, {0x38934000}, {0x38936000}, {0x38938000}, {0x3893a000}, {0x3893c000}, {0x3893e000}, {0x38940000}, {0x38942000}, {0x38944000}, {0x38946000}, {0x38948000}, {0x3894a000}, {0x3894c000}, {0x3894e000}, {0x38950000}, {0x38952000}, {0x38954000}, {0x38956000}, {0x38958000}, {0x3895a000}, {0x3895c000}, {0x3895e000}, {0x38960000}, {0x38962000}, {0x38964000}, {0x38966000}, {0x38968000}, {0x3896a000}, {0x3896c000}, {0x3896e000}, {0x38970000}, {0x38972000}, {0x38974000}, {0x38976000}, {0x38978000}, {0x3897a000}, {0x3897c000}, {0x3897e000}, {0x38980000}, {0x38982000}, {0x38984000}, {0x38986000}, {0x38988000}, {0x3898a000}, {0x3898c000}, {0x3898e000}, {0x38990000}, {0x38992000}, {0x38994000}, {0x38996000}, {0x38998000}, {0x3899a000}, {0x3899c000}, {0x3899e000}, {0x389a0000}, {0x389a2000}, {0x389a4000}, {0x389a6000}, {0x389a8000}, {0x389aa000}, {0x389ac000}, {0x389ae000}, {0x389b0000}, {0x389b2000}, {0x389b4000}, {0x389b6000}, {0x389b8000}, {0x389ba000}, {0x389bc000}, {0x389be000}, {0x389c0000}, {0x389c2000}, {0x389c4000}, {0x389c6000}, {0x389c8000}, {0x389ca000}, {0x389cc000}, {0x389ce000}, {0x389d0000}, {0x389d2000}, {0x389d4000}, {0x389d6000}, {0x389d8000}, {0x389da000}, {0x389dc000}, {0x389de000}, {0x389e0000}, {0x389e2000}, {0x389e4000}, {0x389e6000}, {0x389e8000}, {0x389ea000}, {0x389ec000}, {0x389ee000}, {0x389f0000}, {0x389f2000}, {0x389f4000}, {0x389f6000}, {0x389f8000}, {0x389fa000}, {0x389fc000}, {0x389fe000}, {0x38a00000}, {0x38a02000}, {0x38a04000}, {0x38a06000}, {0x38a08000}, {0x38a0a000}, {0x38a0c000}, {0x38a0e000}, {0x38a10000}, {0x38a12000}, {0x38a14000}, {0x38a16000}, {0x38a18000}, {0x38a1a000}, {0x38a1c000}, {0x38a1e000}, {0x38a20000}, {0x38a22000}, {0x38a24000}, {0x38a26000}, {0x38a28000}, {0x38a2a000}, {0x38a2c000}, {0x38a2e000}, {0x38a30000}, {0x38a32000}, {0x38a34000}, {0x38a36000}, {0x38a38000}, {0x38a3a000}, {0x38a3c000}, {0x38a3e000}, {0x38a40000}, {0x38a42000}, {0x38a44000}, {0x38a46000}, {0x38a48000}, {0x38a4a000}, {0x38a4c000}, {0x38a4e000}, {0x38a50000}, {0x38a52000}, {0x38a54000}, {0x38a56000}, {0x38a58000}, {0x38a5a000}, {0x38a5c000}, {0x38a5e000}, {0x38a60000}, {0x38a62000}, {0x38a64000}, {0x38a66000}, {0x38a68000}, {0x38a6a000}, {0x38a6c000}, {0x38a6e000}, {0x38a70000}, {0x38a72000}, {0x38a74000}, {0x38a76000}, {0x38a78000}, {0x38a7a000}, {0x38a7c000}, {0x38a7e000}, {0x38a80000}, {0x38a82000}, {0x38a84000}, {0x38a86000}, {0x38a88000}, {0x38a8a000}, {0x38a8c000}, {0x38a8e000}, {0x38a90000}, {0x38a92000}, {0x38a94000}, {0x38a96000}, {0x38a98000}, {0x38a9a000}, {0x38a9c000}, {0x38a9e000}, {0x38aa0000}, {0x38aa2000}, {0x38aa4000}, {0x38aa6000}, {0x38aa8000}, {0x38aaa000}, {0x38aac000}, {0x38aae000}, {0x38ab0000}, {0x38ab2000}, {0x38ab4000}, {0x38ab6000}, {0x38ab8000}, {0x38aba000}, {0x38abc000}, {0x38abe000}, {0x38ac0000}, {0x38ac2000}, {0x38ac4000}, {0x38ac6000}, {0x38ac8000}, {0x38aca000}, {0x38acc000}, {0x38ace000}, {0x38ad0000}, {0x38ad2000}, {0x38ad4000}, {0x38ad6000}, {0x38ad8000}, {0x38ada000}, {0x38adc000}, {0x38ade000}, {0x38ae0000}, {0x38ae2000}, {0x38ae4000}, {0x38ae6000}, {0x38ae8000}, {0x38aea000}, {0x38aec000}, {0x38aee000}, {0x38af0000}, {0x38af2000}, {0x38af4000}, {0x38af6000}, {0x38af8000}, {0x38afa000}, {0x38afc000}, {0x38afe000}, {0x38b00000}, {0x38b02000}, {0x38b04000}, {0x38b06000}, {0x38b08000}, {0x38b0a000}, {0x38b0c000}, {0x38b0e000}, {0x38b10000}, {0x38b12000}, {0x38b14000}, {0x38b16000}, {0x38b18000}, {0x38b1a000}, {0x38b1c000}, {0x38b1e000}, {0x38b20000}, {0x38b22000}, {0x38b24000}, {0x38b26000}, {0x38b28000}, {0x38b2a000}, {0x38b2c000}, {0x38b2e000}, {0x38b30000}, {0x38b32000}, {0x38b34000}, {0x38b36000}, {0x38b38000}, {0x38b3a000}, {0x38b3c000}, {0x38b3e000}, {0x38b40000}, {0x38b42000}, {0x38b44000}, {0x38b46000}, {0x38b48000}, {0x38b4a000}, {0x38b4c000}, {0x38b4e000}, {0x38b50000}, {0x38b52000}, {0x38b54000}, {0x38b56000}, {0x38b58000}, {0x38b5a000}, {0x38b5c000}, {0x38b5e000}, {0x38b60000}, {0x38b62000}, {0x38b64000}, {0x38b66000}, {0x38b68000}, {0x38b6a000}, {0x38b6c000}, {0x38b6e000}, {0x38b70000}, {0x38b72000}, {0x38b74000}, {0x38b76000}, {0x38b78000}, {0x38b7a000}, {0x38b7c000}, {0x38b7e000}, {0x38b80000}, {0x38b82000}, {0x38b84000}, {0x38b86000}, {0x38b88000}, {0x38b8a000}, {0x38b8c000}, {0x38b8e000}, {0x38b90000}, {0x38b92000}, {0x38b94000}, {0x38b96000}, {0x38b98000}, {0x38b9a000}, {0x38b9c000}, {0x38b9e000}, {0x38ba0000}, {0x38ba2000}, {0x38ba4000}, {0x38ba6000}, {0x38ba8000}, {0x38baa000}, {0x38bac000}, {0x38bae000}, {0x38bb0000}, {0x38bb2000}, {0x38bb4000}, {0x38bb6000}, {0x38bb8000}, {0x38bba000}, {0x38bbc000}, {0x38bbe000}, {0x38bc0000}, {0x38bc2000}, {0x38bc4000}, {0x38bc6000}, {0x38bc8000}, {0x38bca000}, {0x38bcc000}, {0x38bce000}, {0x38bd0000}, {0x38bd2000}, {0x38bd4000}, {0x38bd6000}, {0x38bd8000}, {0x38bda000}, {0x38bdc000}, {0x38bde000}, {0x38be0000}, {0x38be2000}, {0x38be4000}, {0x38be6000}, {0x38be8000}, {0x38bea000}, {0x38bec000}, {0x38bee000}, {0x38bf0000}, {0x38bf2000}, {0x38bf4000}, {0x38bf6000}, {0x38bf8000}, {0x38bfa000}, {0x38bfc000}, {0x38bfe000}, {0x38c00000}, {0x38c02000}, {0x38c04000}, {0x38c06000}, {0x38c08000}, {0x38c0a000}, {0x38c0c000}, {0x38c0e000}, {0x38c10000}, {0x38c12000}, {0x38c14000}, {0x38c16000}, {0x38c18000}, {0x38c1a000}, {0x38c1c000}, {0x38c1e000}, {0x38c20000}, {0x38c22000}, {0x38c24000}, {0x38c26000}, {0x38c28000}, {0x38c2a000}, {0x38c2c000}, {0x38c2e000}, {0x38c30000}, {0x38c32000}, {0x38c34000}, {0x38c36000}, {0x38c38000}, {0x38c3a000}, {0x38c3c000}, {0x38c3e000}, {0x38c40000}, {0x38c42000}, {0x38c44000}, {0x38c46000}, {0x38c48000}, {0x38c4a000}, {0x38c4c000}, {0x38c4e000}, {0x38c50000}, {0x38c52000}, {0x38c54000}, {0x38c56000}, {0x38c58000}, {0x38c5a000}, {0x38c5c000}, {0x38c5e000}, {0x38c60000}, {0x38c62000}, {0x38c64000}, {0x38c66000}, {0x38c68000}, {0x38c6a000}, {0x38c6c000}, {0x38c6e000}, {0x38c70000}, {0x38c72000}, {0x38c74000}, {0x38c76000}, {0x38c78000}, {0x38c7a000}, {0x38c7c000}, {0x38c7e000}, {0x38c80000}, {0x38c82000}, {0x38c84000}, {0x38c86000}, {0x38c88000}, {0x38c8a000}, {0x38c8c000}, {0x38c8e000}, {0x38c90000}, {0x38c92000}, {0x38c94000}, {0x38c96000}, {0x38c98000}, {0x38c9a000}, {0x38c9c000}, {0x38c9e000}, {0x38ca0000}, {0x38ca2000}, {0x38ca4000}, {0x38ca6000}, {0x38ca8000}, {0x38caa000}, {0x38cac000}, {0x38cae000}, {0x38cb0000}, {0x38cb2000}, {0x38cb4000}, {0x38cb6000}, {0x38cb8000}, {0x38cba000}, {0x38cbc000}, {0x38cbe000}, {0x38cc0000}, {0x38cc2000}, {0x38cc4000}, {0x38cc6000}, {0x38cc8000}, {0x38cca000}, {0x38ccc000}, {0x38cce000}, {0x38cd0000}, {0x38cd2000}, {0x38cd4000}, {0x38cd6000}, {0x38cd8000}, {0x38cda000}, {0x38cdc000}, {0x38cde000}, {0x38ce0000}, {0x38ce2000}, {0x38ce4000}, {0x38ce6000}, {0x38ce8000}, {0x38cea000}, {0x38cec000}, {0x38cee000}, {0x38cf0000}, {0x38cf2000}, {0x38cf4000}, {0x38cf6000}, {0x38cf8000}, {0x38cfa000}, {0x38cfc000}, {0x38cfe000}, {0x38d00000}, {0x38d02000}, {0x38d04000}, {0x38d06000}, {0x38d08000}, {0x38d0a000}, {0x38d0c000}, {0x38d0e000}, {0x38d10000}, {0x38d12000}, {0x38d14000}, {0x38d16000}, {0x38d18000}, {0x38d1a000}, {0x38d1c000}, {0x38d1e000}, {0x38d20000}, {0x38d22000}, {0x38d24000}, {0x38d26000}, {0x38d28000}, {0x38d2a000}, {0x38d2c000}, {0x38d2e000}, {0x38d30000}, {0x38d32000}, {0x38d34000}, {0x38d36000}, {0x38d38000}, {0x38d3a000}, {0x38d3c000}, {0x38d3e000}, {0x38d40000}, {0x38d42000}, {0x38d44000}, {0x38d46000}, {0x38d48000}, {0x38d4a000}, {0x38d4c000}, {0x38d4e000}, {0x38d50000}, {0x38d52000}, {0x38d54000}, {0x38d56000}, {0x38d58000}, {0x38d5a000}, {0x38d5c000}, {0x38d5e000}, {0x38d60000}, {0x38d62000}, {0x38d64000}, {0x38d66000}, {0x38d68000}, {0x38d6a000}, {0x38d6c000}, {0x38d6e000}, {0x38d70000}, {0x38d72000}, {0x38d74000}, {0x38d76000}, {0x38d78000}, {0x38d7a000}, {0x38d7c000}, {0x38d7e000}, {0x38d80000}, {0x38d82000}, {0x38d84000}, {0x38d86000}, {0x38d88000}, {0x38d8a000}, {0x38d8c000}, {0x38d8e000}, {0x38d90000}, {0x38d92000}, {0x38d94000}, {0x38d96000}, {0x38d98000}, {0x38d9a000}, {0x38d9c000}, {0x38d9e000}, {0x38da0000}, {0x38da2000}, {0x38da4000}, {0x38da6000}, {0x38da8000}, {0x38daa000}, {0x38dac000}, {0x38dae000}, {0x38db0000}, {0x38db2000}, {0x38db4000}, {0x38db6000}, {0x38db8000}, {0x38dba000}, {0x38dbc000}, {0x38dbe000}, {0x38dc0000}, {0x38dc2000}, {0x38dc4000}, {0x38dc6000}, {0x38dc8000}, {0x38dca000}, {0x38dcc000}, {0x38dce000}, {0x38dd0000}, {0x38dd2000}, {0x38dd4000}, {0x38dd6000}, {0x38dd8000}, {0x38dda000}, {0x38ddc000}, {0x38dde000}, {0x38de0000}, {0x38de2000}, {0x38de4000}, {0x38de6000}, {0x38de8000}, {0x38dea000}, {0x38dec000}, {0x38dee000}, {0x38df0000}, {0x38df2000}, {0x38df4000}, {0x38df6000}, {0x38df8000}, {0x38dfa000}, {0x38dfc000}, {0x38dfe000}, {0x38e00000}, {0x38e02000}, {0x38e04000}, {0x38e06000}, {0x38e08000}, {0x38e0a000}, {0x38e0c000}, {0x38e0e000}, {0x38e10000}, {0x38e12000}, {0x38e14000}, {0x38e16000}, {0x38e18000}, {0x38e1a000}, {0x38e1c000}, {0x38e1e000}, {0x38e20000}, {0x38e22000}, {0x38e24000}, {0x38e26000}, {0x38e28000}, {0x38e2a000}, {0x38e2c000}, {0x38e2e000}, {0x38e30000}, {0x38e32000}, {0x38e34000}, {0x38e36000}, {0x38e38000}, {0x38e3a000}, {0x38e3c000}, {0x38e3e000}, {0x38e40000}, {0x38e42000}, {0x38e44000}, {0x38e46000}, {0x38e48000}, {0x38e4a000}, {0x38e4c000}, {0x38e4e000}, {0x38e50000}, {0x38e52000}, {0x38e54000}, {0x38e56000}, {0x38e58000}, {0x38e5a000}, {0x38e5c000}, {0x38e5e000}, {0x38e60000}, {0x38e62000}, {0x38e64000}, {0x38e66000}, {0x38e68000}, {0x38e6a000}, {0x38e6c000}, {0x38e6e000}, {0x38e70000}, {0x38e72000}, {0x38e74000}, {0x38e76000}, {0x38e78000}, {0x38e7a000}, {0x38e7c000}, {0x38e7e000}, {0x38e80000}, {0x38e82000}, {0x38e84000}, {0x38e86000}, {0x38e88000}, {0x38e8a000}, {0x38e8c000}, {0x38e8e000}, {0x38e90000}, {0x38e92000}, {0x38e94000}, {0x38e96000}, {0x38e98000}, {0x38e9a000}, {0x38e9c000}, {0x38e9e000}, {0x38ea0000}, {0x38ea2000}, {0x38ea4000}, {0x38ea6000}, {0x38ea8000}, {0x38eaa000}, {0x38eac000}, {0x38eae000}, {0x38eb0000}, {0x38eb2000}, {0x38eb4000}, {0x38eb6000}, {0x38eb8000}, {0x38eba000}, {0x38ebc000}, {0x38ebe000}, {0x38ec0000}, {0x38ec2000}, {0x38ec4000}, {0x38ec6000}, {0x38ec8000}, {0x38eca000}, {0x38ecc000}, {0x38ece000}, {0x38ed0000}, {0x38ed2000}, {0x38ed4000}, {0x38ed6000}, {0x38ed8000}, {0x38eda000}, {0x38edc000}, {0x38ede000}, {0x38ee0000}, {0x38ee2000}, {0x38ee4000}, {0x38ee6000}, {0x38ee8000}, {0x38eea000}, {0x38eec000}, {0x38eee000}, {0x38ef0000}, {0x38ef2000}, {0x38ef4000}, {0x38ef6000}, {0x38ef8000}, {0x38efa000}, {0x38efc000}, {0x38efe000}, {0x38f00000}, {0x38f02000}, {0x38f04000}, {0x38f06000}, {0x38f08000}, {0x38f0a000}, {0x38f0c000}, {0x38f0e000}, {0x38f10000}, {0x38f12000}, {0x38f14000}, {0x38f16000}, {0x38f18000}, {0x38f1a000}, {0x38f1c000}, {0x38f1e000}, {0x38f20000}, {0x38f22000}, {0x38f24000}, {0x38f26000}, {0x38f28000}, {0x38f2a000}, {0x38f2c000}, {0x38f2e000}, {0x38f30000}, {0x38f32000}, {0x38f34000}, {0x38f36000}, {0x38f38000}, {0x38f3a000}, {0x38f3c000}, {0x38f3e000}, {0x38f40000}, {0x38f42000}, {0x38f44000}, {0x38f46000}, {0x38f48000}, {0x38f4a000}, {0x38f4c000}, {0x38f4e000}, {0x38f50000}, {0x38f52000}, {0x38f54000}, {0x38f56000}, {0x38f58000}, {0x38f5a000}, {0x38f5c000}, {0x38f5e000}, {0x38f60000}, {0x38f62000}, {0x38f64000}, {0x38f66000}, {0x38f68000}, {0x38f6a000}, {0x38f6c000}, {0x38f6e000}, {0x38f70000}, {0x38f72000}, {0x38f74000}, {0x38f76000}, {0x38f78000}, {0x38f7a000}, {0x38f7c000}, {0x38f7e000}, {0x38f80000}, {0x38f82000}, {0x38f84000}, {0x38f86000}, {0x38f88000}, {0x38f8a000}, {0x38f8c000}, {0x38f8e000}, {0x38f90000}, {0x38f92000}, {0x38f94000}, {0x38f96000}, {0x38f98000}, {0x38f9a000}, {0x38f9c000}, {0x38f9e000}, {0x38fa0000}, {0x38fa2000}, {0x38fa4000}, {0x38fa6000}, {0x38fa8000}, {0x38faa000}, {0x38fac000}, {0x38fae000}, {0x38fb0000}, {0x38fb2000}, {0x38fb4000}, {0x38fb6000}, {0x38fb8000}, {0x38fba000}, {0x38fbc000}, {0x38fbe000}, {0x38fc0000}, {0x38fc2000}, {0x38fc4000}, {0x38fc6000}, {0x38fc8000}, {0x38fca000}, {0x38fcc000}, {0x38fce000}, {0x38fd0000}, {0x38fd2000}, {0x38fd4000}, {0x38fd6000}, {0x38fd8000}, {0x38fda000}, {0x38fdc000}, {0x38fde000}, {0x38fe0000}, {0x38fe2000}, {0x38fe4000}, {0x38fe6000}, {0x38fe8000}, {0x38fea000}, {0x38fec000}, {0x38fee000}, {0x38ff0000}, {0x38ff2000}, {0x38ff4000}, {0x38ff6000}, {0x38ff8000}, {0x38ffa000}, {0x38ffc000}, {0x38ffe000}, {0x39000000}, {0x39002000}, {0x39004000}, {0x39006000}, {0x39008000}, {0x3900a000}, {0x3900c000}, {0x3900e000}, {0x39010000}, {0x39012000}, {0x39014000}, {0x39016000}, {0x39018000}, {0x3901a000}, {0x3901c000}, {0x3901e000}, {0x39020000}, {0x39022000}, {0x39024000}, {0x39026000}, {0x39028000}, {0x3902a000}, {0x3902c000}, {0x3902e000}, {0x39030000}, {0x39032000}, {0x39034000}, {0x39036000}, {0x39038000}, {0x3903a000}, {0x3903c000}, {0x3903e000}, {0x39040000}, {0x39042000}, {0x39044000}, {0x39046000}, {0x39048000}, {0x3904a000}, {0x3904c000}, {0x3904e000}, {0x39050000}, {0x39052000}, {0x39054000}, {0x39056000}, {0x39058000}, {0x3905a000}, {0x3905c000}, {0x3905e000}, {0x39060000}, {0x39062000}, {0x39064000}, {0x39066000}, {0x39068000}, {0x3906a000}, {0x3906c000}, {0x3906e000}, {0x39070000}, {0x39072000}, {0x39074000}, {0x39076000}, {0x39078000}, {0x3907a000}, {0x3907c000}, {0x3907e000}, {0x39080000}, {0x39082000}, {0x39084000}, {0x39086000}, {0x39088000}, {0x3908a000}, {0x3908c000}, {0x3908e000}, {0x39090000}, {0x39092000}, {0x39094000}, {0x39096000}, {0x39098000}, {0x3909a000}, {0x3909c000}, {0x3909e000}, {0x390a0000}, {0x390a2000}, {0x390a4000}, {0x390a6000}, {0x390a8000}, {0x390aa000}, {0x390ac000}, {0x390ae000}, {0x390b0000}, {0x390b2000}, {0x390b4000}, {0x390b6000}, {0x390b8000}, {0x390ba000}, {0x390bc000}, {0x390be000}, {0x390c0000}, {0x390c2000}, {0x390c4000}, {0x390c6000}, {0x390c8000}, {0x390ca000}, {0x390cc000}, {0x390ce000}, {0x390d0000}, {0x390d2000}, {0x390d4000}, {0x390d6000}, {0x390d8000}, {0x390da000}, {0x390dc000}, {0x390de000}, {0x390e0000}, {0x390e2000}, {0x390e4000}, {0x390e6000}, {0x390e8000}, {0x390ea000}, {0x390ec000}, {0x390ee000}, {0x390f0000}, {0x390f2000}, {0x390f4000}, {0x390f6000}, {0x390f8000}, {0x390fa000}, {0x390fc000}, {0x390fe000}, {0x39100000}, {0x39102000}, {0x39104000}, {0x39106000}, {0x39108000}, {0x3910a000}, {0x3910c000}, {0x3910e000}, {0x39110000}, {0x39112000}, {0x39114000}, {0x39116000}, {0x39118000}, {0x3911a000}, {0x3911c000}, {0x3911e000}, {0x39120000}, {0x39122000}, {0x39124000}, {0x39126000}, {0x39128000}, {0x3912a000}, {0x3912c000}, {0x3912e000}, {0x39130000}, {0x39132000}, {0x39134000}, {0x39136000}, {0x39138000}, {0x3913a000}, {0x3913c000}, {0x3913e000}, {0x39140000}, {0x39142000}, {0x39144000}, {0x39146000}, {0x39148000}, {0x3914a000}, {0x3914c000}, {0x3914e000}, {0x39150000}, {0x39152000}, {0x39154000}, {0x39156000}, {0x39158000}, {0x3915a000}, {0x3915c000}, {0x3915e000}, {0x39160000}, {0x39162000}, {0x39164000}, {0x39166000}, {0x39168000}, {0x3916a000}, {0x3916c000}, {0x3916e000}, {0x39170000}, {0x39172000}, {0x39174000}, {0x39176000}, {0x39178000}, {0x3917a000}, {0x3917c000}, {0x3917e000}, {0x39180000}, {0x39182000}, {0x39184000}, {0x39186000}, {0x39188000}, {0x3918a000}, {0x3918c000}, {0x3918e000}, {0x39190000}, {0x39192000}, {0x39194000}, {0x39196000}, {0x39198000}, {0x3919a000}, {0x3919c000}, {0x3919e000}, {0x391a0000}, {0x391a2000}, {0x391a4000}, {0x391a6000}, {0x391a8000}, {0x391aa000}, {0x391ac000}, {0x391ae000}, {0x391b0000}, {0x391b2000}, {0x391b4000}, {0x391b6000}, {0x391b8000}, {0x391ba000}, {0x391bc000}, {0x391be000}, {0x391c0000}, {0x391c2000}, {0x391c4000}, {0x391c6000}, {0x391c8000}, {0x391ca000}, {0x391cc000}, {0x391ce000}, {0x391d0000}, {0x391d2000}, {0x391d4000}, {0x391d6000}, {0x391d8000}, {0x391da000}, {0x391dc000}, {0x391de000}, {0x391e0000}, {0x391e2000}, {0x391e4000}, {0x391e6000}, {0x391e8000}, {0x391ea000}, {0x391ec000}, {0x391ee000}, {0x391f0000}, {0x391f2000}, {0x391f4000}, {0x391f6000}, {0x391f8000}, {0x391fa000}, {0x391fc000}, {0x391fe000}, {0x39200000}, {0x39202000}, {0x39204000}, {0x39206000}, {0x39208000}, {0x3920a000}, {0x3920c000}, {0x3920e000}, {0x39210000}, {0x39212000}, {0x39214000}, {0x39216000}, {0x39218000}, {0x3921a000}, {0x3921c000}, {0x3921e000}, {0x39220000}, {0x39222000}, {0x39224000}, {0x39226000}, {0x39228000}, {0x3922a000}, {0x3922c000}, {0x3922e000}, {0x39230000}, {0x39232000}, {0x39234000}, {0x39236000}, {0x39238000}, {0x3923a000}, {0x3923c000}, {0x3923e000}, {0x39240000}, {0x39242000}, {0x39244000}, {0x39246000}, {0x39248000}, {0x3924a000}, {0x3924c000}, {0x3924e000}, {0x39250000}, {0x39252000}, {0x39254000}, {0x39256000}, {0x39258000}, {0x3925a000}, {0x3925c000}, {0x3925e000}, {0x39260000}, {0x39262000}, {0x39264000}, {0x39266000}, {0x39268000}, {0x3926a000}, {0x3926c000}, {0x3926e000}, {0x39270000}, {0x39272000}, {0x39274000}, {0x39276000}, {0x39278000}, {0x3927a000}, {0x3927c000}, {0x3927e000}, {0x39280000}, {0x39282000}, {0x39284000}, {0x39286000}, {0x39288000}, {0x3928a000}, {0x3928c000}, {0x3928e000}, {0x39290000}, {0x39292000}, {0x39294000}, {0x39296000}, {0x39298000}, {0x3929a000}, {0x3929c000}, {0x3929e000}, {0x392a0000}, {0x392a2000}, {0x392a4000}, {0x392a6000}, {0x392a8000}, {0x392aa000}, {0x392ac000}, {0x392ae000}, {0x392b0000}, {0x392b2000}, {0x392b4000}, {0x392b6000}, {0x392b8000}, {0x392ba000}, {0x392bc000}, {0x392be000}, {0x392c0000}, {0x392c2000}, {0x392c4000}, {0x392c6000}, {0x392c8000}, {0x392ca000}, {0x392cc000}, {0x392ce000}, {0x392d0000}, {0x392d2000}, {0x392d4000}, {0x392d6000}, {0x392d8000}, {0x392da000}, {0x392dc000}, {0x392de000}, {0x392e0000}, {0x392e2000}, {0x392e4000}, {0x392e6000}, {0x392e8000}, {0x392ea000}, {0x392ec000}, {0x392ee000}, {0x392f0000}, {0x392f2000}, {0x392f4000}, {0x392f6000}, {0x392f8000}, {0x392fa000}, {0x392fc000}, {0x392fe000}, {0x39300000}, {0x39302000}, {0x39304000}, {0x39306000}, {0x39308000}, {0x3930a000}, {0x3930c000}, {0x3930e000}, {0x39310000}, {0x39312000}, {0x39314000}, {0x39316000}, {0x39318000}, {0x3931a000}, {0x3931c000}, {0x3931e000}, {0x39320000}, {0x39322000}, {0x39324000}, {0x39326000}, {0x39328000}, {0x3932a000}, {0x3932c000}, {0x3932e000}, {0x39330000}, {0x39332000}, {0x39334000}, {0x39336000}, {0x39338000}, {0x3933a000}, {0x3933c000}, {0x3933e000}, {0x39340000}, {0x39342000}, {0x39344000}, {0x39346000}, {0x39348000}, {0x3934a000}, {0x3934c000}, {0x3934e000}, {0x39350000}, {0x39352000}, {0x39354000}, {0x39356000}, {0x39358000}, {0x3935a000}, {0x3935c000}, {0x3935e000}, {0x39360000}, {0x39362000}, {0x39364000}, {0x39366000}, {0x39368000}, {0x3936a000}, {0x3936c000}, {0x3936e000}, {0x39370000}, {0x39372000}, {0x39374000}, {0x39376000}, {0x39378000}, {0x3937a000}, {0x3937c000}, {0x3937e000}, {0x39380000}, {0x39382000}, {0x39384000}, {0x39386000}, {0x39388000}, {0x3938a000}, {0x3938c000}, {0x3938e000}, {0x39390000}, {0x39392000}, {0x39394000}, {0x39396000}, {0x39398000}, {0x3939a000}, {0x3939c000}, {0x3939e000}, {0x393a0000}, {0x393a2000}, {0x393a4000}, {0x393a6000}, {0x393a8000}, {0x393aa000}, {0x393ac000}, {0x393ae000}, {0x393b0000}, {0x393b2000}, {0x393b4000}, {0x393b6000}, {0x393b8000}, {0x393ba000}, {0x393bc000}, {0x393be000}, {0x393c0000}, {0x393c2000}, {0x393c4000}, {0x393c6000}, {0x393c8000}, {0x393ca000}, {0x393cc000}, {0x393ce000}, {0x393d0000}, {0x393d2000}, {0x393d4000}, {0x393d6000}, {0x393d8000}, {0x393da000}, {0x393dc000}, {0x393de000}, {0x393e0000}, {0x393e2000}, {0x393e4000}, {0x393e6000}, {0x393e8000}, {0x393ea000}, {0x393ec000}, {0x393ee000}, {0x393f0000}, {0x393f2000}, {0x393f4000}, {0x393f6000}, {0x393f8000}, {0x393fa000}, {0x393fc000}, {0x393fe000}, {0x39400000}, {0x39402000}, {0x39404000}, {0x39406000}, {0x39408000}, {0x3940a000}, {0x3940c000}, {0x3940e000}, {0x39410000}, {0x39412000}, {0x39414000}, {0x39416000}, {0x39418000}, {0x3941a000}, {0x3941c000}, {0x3941e000}, {0x39420000}, {0x39422000}, {0x39424000}, {0x39426000}, {0x39428000}, {0x3942a000}, {0x3942c000}, {0x3942e000}, {0x39430000}, {0x39432000}, {0x39434000}, {0x39436000}, {0x39438000}, {0x3943a000}, {0x3943c000}, {0x3943e000}, {0x39440000}, {0x39442000}, {0x39444000}, {0x39446000}, {0x39448000}, {0x3944a000}, {0x3944c000}, {0x3944e000}, {0x39450000}, {0x39452000}, {0x39454000}, {0x39456000}, {0x39458000}, {0x3945a000}, {0x3945c000}, {0x3945e000}, {0x39460000}, {0x39462000}, {0x39464000}, {0x39466000}, {0x39468000}, {0x3946a000}, {0x3946c000}, {0x3946e000}, {0x39470000}, {0x39472000}, {0x39474000}, {0x39476000}, {0x39478000}, {0x3947a000}, {0x3947c000}, {0x3947e000}, {0x39480000}, {0x39482000}, {0x39484000}, {0x39486000}, {0x39488000}, {0x3948a000}, {0x3948c000}, {0x3948e000}, {0x39490000}, {0x39492000}, {0x39494000}, {0x39496000}, {0x39498000}, {0x3949a000}, {0x3949c000}, {0x3949e000}, {0x394a0000}, {0x394a2000}, {0x394a4000}, {0x394a6000}, {0x394a8000}, {0x394aa000}, {0x394ac000}, {0x394ae000}, {0x394b0000}, {0x394b2000}, {0x394b4000}, {0x394b6000}, {0x394b8000}, {0x394ba000}, {0x394bc000}, {0x394be000}, {0x394c0000}, {0x394c2000}, {0x394c4000}, {0x394c6000}, {0x394c8000}, {0x394ca000}, {0x394cc000}, {0x394ce000}, {0x394d0000}, {0x394d2000}, {0x394d4000}, {0x394d6000}, {0x394d8000}, {0x394da000}, {0x394dc000}, {0x394de000}, {0x394e0000}, {0x394e2000}, {0x394e4000}, {0x394e6000}, {0x394e8000}, {0x394ea000}, {0x394ec000}, {0x394ee000}, {0x394f0000}, {0x394f2000}, {0x394f4000}, {0x394f6000}, {0x394f8000}, {0x394fa000}, {0x394fc000}, {0x394fe000}, {0x39500000}, {0x39502000}, {0x39504000}, {0x39506000}, {0x39508000}, {0x3950a000}, {0x3950c000}, {0x3950e000}, {0x39510000}, {0x39512000}, {0x39514000}, {0x39516000}, {0x39518000}, {0x3951a000}, {0x3951c000}, {0x3951e000}, {0x39520000}, {0x39522000}, {0x39524000}, {0x39526000}, {0x39528000}, {0x3952a000}, {0x3952c000}, {0x3952e000}, {0x39530000}, {0x39532000}, {0x39534000}, {0x39536000}, {0x39538000}, {0x3953a000}, {0x3953c000}, {0x3953e000}, {0x39540000}, {0x39542000}, {0x39544000}, {0x39546000}, {0x39548000}, {0x3954a000}, {0x3954c000}, {0x3954e000}, {0x39550000}, {0x39552000}, {0x39554000}, {0x39556000}, {0x39558000}, {0x3955a000}, {0x3955c000}, {0x3955e000}, {0x39560000}, {0x39562000}, {0x39564000}, {0x39566000}, {0x39568000}, {0x3956a000}, {0x3956c000}, {0x3956e000}, {0x39570000}, {0x39572000}, {0x39574000}, {0x39576000}, {0x39578000}, {0x3957a000}, {0x3957c000}, {0x3957e000}, {0x39580000}, {0x39582000}, {0x39584000}, {0x39586000}, {0x39588000}, {0x3958a000}, {0x3958c000}, {0x3958e000}, {0x39590000}, {0x39592000}, {0x39594000}, {0x39596000}, {0x39598000}, {0x3959a000}, {0x3959c000}, {0x3959e000}, {0x395a0000}, {0x395a2000}, {0x395a4000}, {0x395a6000}, {0x395a8000}, {0x395aa000}, {0x395ac000}, {0x395ae000}, {0x395b0000}, {0x395b2000}, {0x395b4000}, {0x395b6000}, {0x395b8000}, {0x395ba000}, {0x395bc000}, {0x395be000}, {0x395c0000}, {0x395c2000}, {0x395c4000}, {0x395c6000}, {0x395c8000}, {0x395ca000}, {0x395cc000}, {0x395ce000}, {0x395d0000}, {0x395d2000}, {0x395d4000}, {0x395d6000}, {0x395d8000}, {0x395da000}, {0x395dc000}, {0x395de000}, {0x395e0000}, {0x395e2000}, {0x395e4000}, {0x395e6000}, {0x395e8000}, {0x395ea000}, {0x395ec000}, {0x395ee000}, {0x395f0000}, {0x395f2000}, {0x395f4000}, {0x395f6000}, {0x395f8000}, {0x395fa000}, {0x395fc000}, {0x395fe000}, {0x39600000}, {0x39602000}, {0x39604000}, {0x39606000}, {0x39608000}, {0x3960a000}, {0x3960c000}, {0x3960e000}, {0x39610000}, {0x39612000}, {0x39614000}, {0x39616000}, {0x39618000}, {0x3961a000}, {0x3961c000}, {0x3961e000}, {0x39620000}, {0x39622000}, {0x39624000}, {0x39626000}, {0x39628000}, {0x3962a000}, {0x3962c000}, {0x3962e000}, {0x39630000}, {0x39632000}, {0x39634000}, {0x39636000}, {0x39638000}, {0x3963a000}, {0x3963c000}, {0x3963e000}, {0x39640000}, {0x39642000}, {0x39644000}, {0x39646000}, {0x39648000}, {0x3964a000}, {0x3964c000}, {0x3964e000}, {0x39650000}, {0x39652000}, {0x39654000}, {0x39656000}, {0x39658000}, {0x3965a000}, {0x3965c000}, {0x3965e000}, {0x39660000}, {0x39662000}, {0x39664000}, {0x39666000}, {0x39668000}, {0x3966a000}, {0x3966c000}, {0x3966e000}, {0x39670000}, {0x39672000}, {0x39674000}, {0x39676000}, {0x39678000}, {0x3967a000}, {0x3967c000}, {0x3967e000}, {0x39680000}, {0x39682000}, {0x39684000}, {0x39686000}, {0x39688000}, {0x3968a000}, {0x3968c000}, {0x3968e000}, {0x39690000}, {0x39692000}, {0x39694000}, {0x39696000}, {0x39698000}, {0x3969a000}, {0x3969c000}, {0x3969e000}, {0x396a0000}, {0x396a2000}, {0x396a4000}, {0x396a6000}, {0x396a8000}, {0x396aa000}, {0x396ac000}, {0x396ae000}, {0x396b0000}, {0x396b2000}, {0x396b4000}, {0x396b6000}, {0x396b8000}, {0x396ba000}, {0x396bc000}, {0x396be000}, {0x396c0000}, {0x396c2000}, {0x396c4000}, {0x396c6000}, {0x396c8000}, {0x396ca000}, {0x396cc000}, {0x396ce000}, {0x396d0000}, {0x396d2000}, {0x396d4000}, {0x396d6000}, {0x396d8000}, {0x396da000}, {0x396dc000}, {0x396de000}, {0x396e0000}, {0x396e2000}, {0x396e4000}, {0x396e6000}, {0x396e8000}, {0x396ea000}, {0x396ec000}, {0x396ee000}, {0x396f0000}, {0x396f2000}, {0x396f4000}, {0x396f6000}, {0x396f8000}, {0x396fa000}, {0x396fc000}, {0x396fe000}, {0x39700000}, {0x39702000}, {0x39704000}, {0x39706000}, {0x39708000}, {0x3970a000}, {0x3970c000}, {0x3970e000}, {0x39710000}, {0x39712000}, {0x39714000}, {0x39716000}, {0x39718000}, {0x3971a000}, {0x3971c000}, {0x3971e000}, {0x39720000}, {0x39722000}, {0x39724000}, {0x39726000}, {0x39728000}, {0x3972a000}, {0x3972c000}, {0x3972e000}, {0x39730000}, {0x39732000}, {0x39734000}, {0x39736000}, {0x39738000}, {0x3973a000}, {0x3973c000}, {0x3973e000}, {0x39740000}, {0x39742000}, {0x39744000}, {0x39746000}, {0x39748000}, {0x3974a000}, {0x3974c000}, {0x3974e000}, {0x39750000}, {0x39752000}, {0x39754000}, {0x39756000}, {0x39758000}, {0x3975a000}, {0x3975c000}, {0x3975e000}, {0x39760000}, {0x39762000}, {0x39764000}, {0x39766000}, {0x39768000}, {0x3976a000}, {0x3976c000}, {0x3976e000}, {0x39770000}, {0x39772000}, {0x39774000}, {0x39776000}, {0x39778000}, {0x3977a000}, {0x3977c000}, {0x3977e000}, {0x39780000}, {0x39782000}, {0x39784000}, {0x39786000}, {0x39788000}, {0x3978a000}, {0x3978c000}, {0x3978e000}, {0x39790000}, {0x39792000}, {0x39794000}, {0x39796000}, {0x39798000}, {0x3979a000}, {0x3979c000}, {0x3979e000}, {0x397a0000}, {0x397a2000}, {0x397a4000}, {0x397a6000}, {0x397a8000}, {0x397aa000}, {0x397ac000}, {0x397ae000}, {0x397b0000}, {0x397b2000}, {0x397b4000}, {0x397b6000}, {0x397b8000}, {0x397ba000}, {0x397bc000}, {0x397be000}, {0x397c0000}, {0x397c2000}, {0x397c4000}, {0x397c6000}, {0x397c8000}, {0x397ca000}, {0x397cc000}, {0x397ce000}, {0x397d0000}, {0x397d2000}, {0x397d4000}, {0x397d6000}, {0x397d8000}, {0x397da000}, {0x397dc000}, {0x397de000}, {0x397e0000}, {0x397e2000}, {0x397e4000}, {0x397e6000}, {0x397e8000}, {0x397ea000}, {0x397ec000}, {0x397ee000}, {0x397f0000}, {0x397f2000}, {0x397f4000}, {0x397f6000}, {0x397f8000}, {0x397fa000}, {0x397fc000}, {0x397fe000}, {0x39800000}, {0x39802000}, {0x39804000}, {0x39806000}, {0x39808000}, {0x3980a000}, {0x3980c000}, {0x3980e000}, {0x39810000}, {0x39812000}, {0x39814000}, {0x39816000}, {0x39818000}, {0x3981a000}, {0x3981c000}, {0x3981e000}, {0x39820000}, {0x39822000}, {0x39824000}, {0x39826000}, {0x39828000}, {0x3982a000}, {0x3982c000}, {0x3982e000}, {0x39830000}, {0x39832000}, {0x39834000}, {0x39836000}, {0x39838000}, {0x3983a000}, {0x3983c000}, {0x3983e000}, {0x39840000}, {0x39842000}, {0x39844000}, {0x39846000}, {0x39848000}, {0x3984a000}, {0x3984c000}, {0x3984e000}, {0x39850000}, {0x39852000}, {0x39854000}, {0x39856000}, {0x39858000}, {0x3985a000}, {0x3985c000}, {0x3985e000}, {0x39860000}, {0x39862000}, {0x39864000}, {0x39866000}, {0x39868000}, {0x3986a000}, {0x3986c000}, {0x3986e000}, {0x39870000}, {0x39872000}, {0x39874000}, {0x39876000}, {0x39878000}, {0x3987a000}, {0x3987c000}, {0x3987e000}, {0x39880000}, {0x39882000}, {0x39884000}, {0x39886000}, {0x39888000}, {0x3988a000}, {0x3988c000}, {0x3988e000}, {0x39890000}, {0x39892000}, {0x39894000}, {0x39896000}, {0x39898000}, {0x3989a000}, {0x3989c000}, {0x3989e000}, {0x398a0000}, {0x398a2000}, {0x398a4000}, {0x398a6000}, {0x398a8000}, {0x398aa000}, {0x398ac000}, {0x398ae000}, {0x398b0000}, {0x398b2000}, {0x398b4000}, {0x398b6000}, {0x398b8000}, {0x398ba000}, {0x398bc000}, {0x398be000}, {0x398c0000}, {0x398c2000}, {0x398c4000}, {0x398c6000}, {0x398c8000}, {0x398ca000}, {0x398cc000}, {0x398ce000}, {0x398d0000}, {0x398d2000}, {0x398d4000}, {0x398d6000}, {0x398d8000}, {0x398da000}, {0x398dc000}, {0x398de000}, {0x398e0000}, {0x398e2000}, {0x398e4000}, {0x398e6000}, {0x398e8000}, {0x398ea000}, {0x398ec000}, {0x398ee000}, {0x398f0000}, {0x398f2000}, {0x398f4000}, {0x398f6000}, {0x398f8000}, {0x398fa000}, {0x398fc000}, {0x398fe000}, {0x39900000}, {0x39902000}, {0x39904000}, {0x39906000}, {0x39908000}, {0x3990a000}, {0x3990c000}, {0x3990e000}, {0x39910000}, {0x39912000}, {0x39914000}, {0x39916000}, {0x39918000}, {0x3991a000}, {0x3991c000}, {0x3991e000}, {0x39920000}, {0x39922000}, {0x39924000}, {0x39926000}, {0x39928000}, {0x3992a000}, {0x3992c000}, {0x3992e000}, {0x39930000}, {0x39932000}, {0x39934000}, {0x39936000}, {0x39938000}, {0x3993a000}, {0x3993c000}, {0x3993e000}, {0x39940000}, {0x39942000}, {0x39944000}, {0x39946000}, {0x39948000}, {0x3994a000}, {0x3994c000}, {0x3994e000}, {0x39950000}, {0x39952000}, {0x39954000}, {0x39956000}, {0x39958000}, {0x3995a000}, {0x3995c000}, {0x3995e000}, {0x39960000}, {0x39962000}, {0x39964000}, {0x39966000}, {0x39968000}, {0x3996a000}, {0x3996c000}, {0x3996e000}, {0x39970000}, {0x39972000}, {0x39974000}, {0x39976000}, {0x39978000}, {0x3997a000}, {0x3997c000}, {0x3997e000}, {0x39980000}, {0x39982000}, {0x39984000}, {0x39986000}, {0x39988000}, {0x3998a000}, {0x3998c000}, {0x3998e000}, {0x39990000}, {0x39992000}, {0x39994000}, {0x39996000}, {0x39998000}, {0x3999a000}, {0x3999c000}, {0x3999e000}, {0x399a0000}, {0x399a2000}, {0x399a4000}, {0x399a6000}, {0x399a8000}, {0x399aa000}, {0x399ac000}, {0x399ae000}, {0x399b0000}, {0x399b2000}, {0x399b4000}, {0x399b6000}, {0x399b8000}, {0x399ba000}, {0x399bc000}, {0x399be000}, {0x399c0000}, {0x399c2000}, {0x399c4000}, {0x399c6000}, {0x399c8000}, {0x399ca000}, {0x399cc000}, {0x399ce000}, {0x399d0000}, {0x399d2000}, {0x399d4000}, {0x399d6000}, {0x399d8000}, {0x399da000}, {0x399dc000}, {0x399de000}, {0x399e0000}, {0x399e2000}, {0x399e4000}, {0x399e6000}, {0x399e8000}, {0x399ea000}, {0x399ec000}, {0x399ee000}, {0x399f0000}, {0x399f2000}, {0x399f4000}, {0x399f6000}, {0x399f8000}, {0x399fa000}, {0x399fc000}, {0x399fe000}, {0x39a00000}, {0x39a02000}, {0x39a04000}, {0x39a06000}, {0x39a08000}, {0x39a0a000}, {0x39a0c000}, {0x39a0e000}, {0x39a10000}, {0x39a12000}, {0x39a14000}, {0x39a16000}, {0x39a18000}, {0x39a1a000}, {0x39a1c000}, {0x39a1e000}, {0x39a20000}, {0x39a22000}, {0x39a24000}, {0x39a26000}, {0x39a28000}, {0x39a2a000}, {0x39a2c000}, {0x39a2e000}, {0x39a30000}, {0x39a32000}, {0x39a34000}, {0x39a36000}, {0x39a38000}, {0x39a3a000}, {0x39a3c000}, {0x39a3e000}, {0x39a40000}, {0x39a42000}, {0x39a44000}, {0x39a46000}, {0x39a48000}, {0x39a4a000}, {0x39a4c000}, {0x39a4e000}, {0x39a50000}, {0x39a52000}, {0x39a54000}, {0x39a56000}, {0x39a58000}, {0x39a5a000}, {0x39a5c000}, {0x39a5e000}, {0x39a60000}, {0x39a62000}, {0x39a64000}, {0x39a66000}, {0x39a68000}, {0x39a6a000}, {0x39a6c000}, {0x39a6e000}, {0x39a70000}, {0x39a72000}, {0x39a74000}, {0x39a76000}, {0x39a78000}, {0x39a7a000}, {0x39a7c000}, {0x39a7e000}, {0x39a80000}, {0x39a82000}, {0x39a84000}, {0x39a86000}, {0x39a88000}, {0x39a8a000}, {0x39a8c000}, {0x39a8e000}, {0x39a90000}, {0x39a92000}, {0x39a94000}, {0x39a96000}, {0x39a98000}, {0x39a9a000}, {0x39a9c000}, {0x39a9e000}, {0x39aa0000}, {0x39aa2000}, {0x39aa4000}, {0x39aa6000}, {0x39aa8000}, {0x39aaa000}, {0x39aac000}, {0x39aae000}, {0x39ab0000}, {0x39ab2000}, {0x39ab4000}, {0x39ab6000}, {0x39ab8000}, {0x39aba000}, {0x39abc000}, {0x39abe000}, {0x39ac0000}, {0x39ac2000}, {0x39ac4000}, {0x39ac6000}, {0x39ac8000}, {0x39aca000}, {0x39acc000}, {0x39ace000}, {0x39ad0000}, {0x39ad2000}, {0x39ad4000}, {0x39ad6000}, {0x39ad8000}, {0x39ada000}, {0x39adc000}, {0x39ade000}, {0x39ae0000}, {0x39ae2000}, {0x39ae4000}, {0x39ae6000}, {0x39ae8000}, {0x39aea000}, {0x39aec000}, {0x39aee000}, {0x39af0000}, {0x39af2000}, {0x39af4000}, {0x39af6000}, {0x39af8000}, {0x39afa000}, {0x39afc000}, {0x39afe000}, {0x39b00000}, {0x39b02000}, {0x39b04000}, {0x39b06000}, {0x39b08000}, {0x39b0a000}, {0x39b0c000}, {0x39b0e000}, {0x39b10000}, {0x39b12000}, {0x39b14000}, {0x39b16000}, {0x39b18000}, {0x39b1a000}, {0x39b1c000}, {0x39b1e000}, {0x39b20000}, {0x39b22000}, {0x39b24000}, {0x39b26000}, {0x39b28000}, {0x39b2a000}, {0x39b2c000}, {0x39b2e000}, {0x39b30000}, {0x39b32000}, {0x39b34000}, {0x39b36000}, {0x39b38000}, {0x39b3a000}, {0x39b3c000}, {0x39b3e000}, {0x39b40000}, {0x39b42000}, {0x39b44000}, {0x39b46000}, {0x39b48000}, {0x39b4a000}, {0x39b4c000}, {0x39b4e000}, {0x39b50000}, {0x39b52000}, {0x39b54000}, {0x39b56000}, {0x39b58000}, {0x39b5a000}, {0x39b5c000}, {0x39b5e000}, {0x39b60000}, {0x39b62000}, {0x39b64000}, {0x39b66000}, {0x39b68000}, {0x39b6a000}, {0x39b6c000}, {0x39b6e000}, {0x39b70000}, {0x39b72000}, {0x39b74000}, {0x39b76000}, {0x39b78000}, {0x39b7a000}, {0x39b7c000}, {0x39b7e000}, {0x39b80000}, {0x39b82000}, {0x39b84000}, {0x39b86000}, {0x39b88000}, {0x39b8a000}, {0x39b8c000}, {0x39b8e000}, {0x39b90000}, {0x39b92000}, {0x39b94000}, {0x39b96000}, {0x39b98000}, {0x39b9a000}, {0x39b9c000}, {0x39b9e000}, {0x39ba0000}, {0x39ba2000}, {0x39ba4000}, {0x39ba6000}, {0x39ba8000}, {0x39baa000}, {0x39bac000}, {0x39bae000}, {0x39bb0000}, {0x39bb2000}, {0x39bb4000}, {0x39bb6000}, {0x39bb8000}, {0x39bba000}, {0x39bbc000}, {0x39bbe000}, {0x39bc0000}, {0x39bc2000}, {0x39bc4000}, {0x39bc6000}, {0x39bc8000}, {0x39bca000}, {0x39bcc000}, {0x39bce000}, {0x39bd0000}, {0x39bd2000}, {0x39bd4000}, {0x39bd6000}, {0x39bd8000}, {0x39bda000}, {0x39bdc000}, {0x39bde000}, {0x39be0000}, {0x39be2000}, {0x39be4000}, {0x39be6000}, {0x39be8000}, {0x39bea000}, {0x39bec000}, {0x39bee000}, {0x39bf0000}, {0x39bf2000}, {0x39bf4000}, {0x39bf6000}, {0x39bf8000}, {0x39bfa000}, {0x39bfc000}, {0x39bfe000}, {0x39c00000}, {0x39c02000}, {0x39c04000}, {0x39c06000}, {0x39c08000}, {0x39c0a000}, {0x39c0c000}, {0x39c0e000}, {0x39c10000}, {0x39c12000}, {0x39c14000}, {0x39c16000}, {0x39c18000}, {0x39c1a000}, {0x39c1c000}, {0x39c1e000}, {0x39c20000}, {0x39c22000}, {0x39c24000}, {0x39c26000}, {0x39c28000}, {0x39c2a000}, {0x39c2c000}, {0x39c2e000}, {0x39c30000}, {0x39c32000}, {0x39c34000}, {0x39c36000}, {0x39c38000}, {0x39c3a000}, {0x39c3c000}, {0x39c3e000}, {0x39c40000}, {0x39c42000}, {0x39c44000}, {0x39c46000}, {0x39c48000}, {0x39c4a000}, {0x39c4c000}, {0x39c4e000}, {0x39c50000}, {0x39c52000}, {0x39c54000}, {0x39c56000}, {0x39c58000}, {0x39c5a000}, {0x39c5c000}, {0x39c5e000}, {0x39c60000}, {0x39c62000}, {0x39c64000}, {0x39c66000}, {0x39c68000}, {0x39c6a000}, {0x39c6c000}, {0x39c6e000}, {0x39c70000}, {0x39c72000}, {0x39c74000}, {0x39c76000}, {0x39c78000}, {0x39c7a000}, {0x39c7c000}, {0x39c7e000}, {0x39c80000}, {0x39c82000}, {0x39c84000}, {0x39c86000}, {0x39c88000}, {0x39c8a000}, {0x39c8c000}, {0x39c8e000}, {0x39c90000}, {0x39c92000}, {0x39c94000}, {0x39c96000}, {0x39c98000}, {0x39c9a000}, {0x39c9c000}, {0x39c9e000}, {0x39ca0000}, {0x39ca2000}, {0x39ca4000}, {0x39ca6000}, {0x39ca8000}, {0x39caa000}, {0x39cac000}, {0x39cae000}, {0x39cb0000}, {0x39cb2000}, {0x39cb4000}, {0x39cb6000}, {0x39cb8000}, {0x39cba000}, {0x39cbc000}, {0x39cbe000}, {0x39cc0000}, {0x39cc2000}, {0x39cc4000}, {0x39cc6000}, {0x39cc8000}, {0x39cca000}, {0x39ccc000}, {0x39cce000}, {0x39cd0000}, {0x39cd2000}, {0x39cd4000}, {0x39cd6000}, {0x39cd8000}, {0x39cda000}, {0x39cdc000}, {0x39cde000}, {0x39ce0000}, {0x39ce2000}, {0x39ce4000}, {0x39ce6000}, {0x39ce8000}, {0x39cea000}, {0x39cec000}, {0x39cee000}, {0x39cf0000}, {0x39cf2000}, {0x39cf4000}, {0x39cf6000}, {0x39cf8000}, {0x39cfa000}, {0x39cfc000}, {0x39cfe000}, {0x39d00000}, {0x39d02000}, {0x39d04000}, {0x39d06000}, {0x39d08000}, {0x39d0a000}, {0x39d0c000}, {0x39d0e000}, {0x39d10000}, {0x39d12000}, {0x39d14000}, {0x39d16000}, {0x39d18000}, {0x39d1a000}, {0x39d1c000}, {0x39d1e000}, {0x39d20000}, {0x39d22000}, {0x39d24000}, {0x39d26000}, {0x39d28000}, {0x39d2a000}, {0x39d2c000}, {0x39d2e000}, {0x39d30000}, {0x39d32000}, {0x39d34000}, {0x39d36000}, {0x39d38000}, {0x39d3a000}, {0x39d3c000}, {0x39d3e000}, {0x39d40000}, {0x39d42000}, {0x39d44000}, {0x39d46000}, {0x39d48000}, {0x39d4a000}, {0x39d4c000}, {0x39d4e000}, {0x39d50000}, {0x39d52000}, {0x39d54000}, {0x39d56000}, {0x39d58000}, {0x39d5a000}, {0x39d5c000}, {0x39d5e000}, {0x39d60000}, {0x39d62000}, {0x39d64000}, {0x39d66000}, {0x39d68000}, {0x39d6a000}, {0x39d6c000}, {0x39d6e000}, {0x39d70000}, {0x39d72000}, {0x39d74000}, {0x39d76000}, {0x39d78000}, {0x39d7a000}, {0x39d7c000}, {0x39d7e000}, {0x39d80000}, {0x39d82000}, {0x39d84000}, {0x39d86000}, {0x39d88000}, {0x39d8a000}, {0x39d8c000}, {0x39d8e000}, {0x39d90000}, {0x39d92000}, {0x39d94000}, {0x39d96000}, {0x39d98000}, {0x39d9a000}, {0x39d9c000}, {0x39d9e000}, {0x39da0000}, {0x39da2000}, {0x39da4000}, {0x39da6000}, {0x39da8000}, {0x39daa000}, {0x39dac000}, {0x39dae000}, {0x39db0000}, {0x39db2000}, {0x39db4000}, {0x39db6000}, {0x39db8000}, {0x39dba000}, {0x39dbc000}, {0x39dbe000}, {0x39dc0000}, {0x39dc2000}, {0x39dc4000}, {0x39dc6000}, {0x39dc8000}, {0x39dca000}, {0x39dcc000}, {0x39dce000}, {0x39dd0000}, {0x39dd2000}, {0x39dd4000}, {0x39dd6000}, {0x39dd8000}, {0x39dda000}, {0x39ddc000}, {0x39dde000}, {0x39de0000}, {0x39de2000}, {0x39de4000}, {0x39de6000}, {0x39de8000}, {0x39dea000}, {0x39dec000}, {0x39dee000}, {0x39df0000}, {0x39df2000}, {0x39df4000}, {0x39df6000}, {0x39df8000}, {0x39dfa000}, {0x39dfc000}, {0x39dfe000}, {0x39e00000}, {0x39e02000}, {0x39e04000}, {0x39e06000}, {0x39e08000}, {0x39e0a000}, {0x39e0c000}, {0x39e0e000}, {0x39e10000}, {0x39e12000}, {0x39e14000}, {0x39e16000}, {0x39e18000}, {0x39e1a000}, {0x39e1c000}, {0x39e1e000}, {0x39e20000}, {0x39e22000}, {0x39e24000}, {0x39e26000}, {0x39e28000}, {0x39e2a000}, {0x39e2c000}, {0x39e2e000}, {0x39e30000}, {0x39e32000}, {0x39e34000}, {0x39e36000}, {0x39e38000}, {0x39e3a000}, {0x39e3c000}, {0x39e3e000}, {0x39e40000}, {0x39e42000}, {0x39e44000}, {0x39e46000}, {0x39e48000}, {0x39e4a000}, {0x39e4c000}, {0x39e4e000}, {0x39e50000}, {0x39e52000}, {0x39e54000}, {0x39e56000}, {0x39e58000}, {0x39e5a000}, {0x39e5c000}, {0x39e5e000}, {0x39e60000}, {0x39e62000}, {0x39e64000}, {0x39e66000}, {0x39e68000}, {0x39e6a000}, {0x39e6c000}, {0x39e6e000}, {0x39e70000}, {0x39e72000}, {0x39e74000}, {0x39e76000}, {0x39e78000}, {0x39e7a000}, {0x39e7c000}, {0x39e7e000}, {0x39e80000}, {0x39e82000}, {0x39e84000}, {0x39e86000}, {0x39e88000}, {0x39e8a000}, {0x39e8c000}, {0x39e8e000}, {0x39e90000}, {0x39e92000}, {0x39e94000}, {0x39e96000}, {0x39e98000}, {0x39e9a000}, {0x39e9c000}, {0x39e9e000}, {0x39ea0000}, {0x39ea2000}, {0x39ea4000}, {0x39ea6000}, {0x39ea8000}, {0x39eaa000}, {0x39eac000}, {0x39eae000}, {0x39eb0000}, {0x39eb2000}, {0x39eb4000}, {0x39eb6000}, {0x39eb8000}, {0x39eba000}, {0x39ebc000}, {0x39ebe000}, {0x39ec0000}, {0x39ec2000}, {0x39ec4000}, {0x39ec6000}, {0x39ec8000}, {0x39eca000}, {0x39ecc000}, {0x39ece000}, {0x39ed0000}, {0x39ed2000}, {0x39ed4000}, {0x39ed6000}, {0x39ed8000}, {0x39eda000}, {0x39edc000}, {0x39ede000}, {0x39ee0000}, {0x39ee2000}, {0x39ee4000}, {0x39ee6000}, {0x39ee8000}, {0x39eea000}, {0x39eec000}, {0x39eee000}, {0x39ef0000}, {0x39ef2000}, {0x39ef4000}, {0x39ef6000}, {0x39ef8000}, {0x39efa000}, {0x39efc000}, {0x39efe000}, {0x39f00000}, {0x39f02000}, {0x39f04000}, {0x39f06000}, {0x39f08000}, {0x39f0a000}, {0x39f0c000}, {0x39f0e000}, {0x39f10000}, {0x39f12000}, {0x39f14000}, {0x39f16000}, {0x39f18000}, {0x39f1a000}, {0x39f1c000}, {0x39f1e000}, {0x39f20000}, {0x39f22000}, {0x39f24000}, {0x39f26000}, {0x39f28000}, {0x39f2a000}, {0x39f2c000}, {0x39f2e000}, {0x39f30000}, {0x39f32000}, {0x39f34000}, {0x39f36000}, {0x39f38000}, {0x39f3a000}, {0x39f3c000}, {0x39f3e000}, {0x39f40000}, {0x39f42000}, {0x39f44000}, {0x39f46000}, {0x39f48000}, {0x39f4a000}, {0x39f4c000}, {0x39f4e000}, {0x39f50000}, {0x39f52000}, {0x39f54000}, {0x39f56000}, {0x39f58000}, {0x39f5a000}, {0x39f5c000}, {0x39f5e000}, {0x39f60000}, {0x39f62000}, {0x39f64000}, {0x39f66000}, {0x39f68000}, {0x39f6a000}, {0x39f6c000}, {0x39f6e000}, {0x39f70000}, {0x39f72000}, {0x39f74000}, {0x39f76000}, {0x39f78000}, {0x39f7a000}, {0x39f7c000}, {0x39f7e000}, {0x39f80000}, {0x39f82000}, {0x39f84000}, {0x39f86000}, {0x39f88000}, {0x39f8a000}, {0x39f8c000}, {0x39f8e000}, {0x39f90000}, {0x39f92000}, {0x39f94000}, {0x39f96000}, {0x39f98000}, {0x39f9a000}, {0x39f9c000}, {0x39f9e000}, {0x39fa0000}, {0x39fa2000}, {0x39fa4000}, {0x39fa6000}, {0x39fa8000}, {0x39faa000}, {0x39fac000}, {0x39fae000}, {0x39fb0000}, {0x39fb2000}, {0x39fb4000}, {0x39fb6000}, {0x39fb8000}, {0x39fba000}, {0x39fbc000}, {0x39fbe000}, {0x39fc0000}, {0x39fc2000}, {0x39fc4000}, {0x39fc6000}, {0x39fc8000}, {0x39fca000}, {0x39fcc000}, {0x39fce000}, {0x39fd0000}, {0x39fd2000}, {0x39fd4000}, {0x39fd6000}, {0x39fd8000}, {0x39fda000}, {0x39fdc000}, {0x39fde000}, {0x39fe0000}, {0x39fe2000}, {0x39fe4000}, {0x39fe6000}, {0x39fe8000}, {0x39fea000}, {0x39fec000}, {0x39fee000}, {0x39ff0000}, {0x39ff2000}, {0x39ff4000}, {0x39ff6000}, {0x39ff8000}, {0x39ffa000}, {0x39ffc000}, {0x39ffe000}, {0x3a000000}, {0x3a002000}, {0x3a004000}, {0x3a006000}, {0x3a008000}, {0x3a00a000}, {0x3a00c000}, {0x3a00e000}, {0x3a010000}, {0x3a012000}, {0x3a014000}, {0x3a016000}, {0x3a018000}, {0x3a01a000}, {0x3a01c000}, {0x3a01e000}, {0x3a020000}, {0x3a022000}, {0x3a024000}, {0x3a026000}, {0x3a028000}, {0x3a02a000}, {0x3a02c000}, {0x3a02e000}, {0x3a030000}, {0x3a032000}, {0x3a034000}, {0x3a036000}, {0x3a038000}, {0x3a03a000}, {0x3a03c000}, {0x3a03e000}, {0x3a040000}, {0x3a042000}, {0x3a044000}, {0x3a046000}, {0x3a048000}, {0x3a04a000}, {0x3a04c000}, {0x3a04e000}, {0x3a050000}, {0x3a052000}, {0x3a054000}, {0x3a056000}, {0x3a058000}, {0x3a05a000}, {0x3a05c000}, {0x3a05e000}, {0x3a060000}, {0x3a062000}, {0x3a064000}, {0x3a066000}, {0x3a068000}, {0x3a06a000}, {0x3a06c000}, {0x3a06e000}, {0x3a070000}, {0x3a072000}, {0x3a074000}, {0x3a076000}, {0x3a078000}, {0x3a07a000}, {0x3a07c000}, {0x3a07e000}, {0x3a080000}, {0x3a082000}, {0x3a084000}, {0x3a086000}, {0x3a088000}, {0x3a08a000}, {0x3a08c000}, {0x3a08e000}, {0x3a090000}, {0x3a092000}, {0x3a094000}, {0x3a096000}, {0x3a098000}, {0x3a09a000}, {0x3a09c000}, {0x3a09e000}, {0x3a0a0000}, {0x3a0a2000}, {0x3a0a4000}, {0x3a0a6000}, {0x3a0a8000}, {0x3a0aa000}, {0x3a0ac000}, {0x3a0ae000}, {0x3a0b0000}, {0x3a0b2000}, {0x3a0b4000}, {0x3a0b6000}, {0x3a0b8000}, {0x3a0ba000}, {0x3a0bc000}, {0x3a0be000}, {0x3a0c0000}, {0x3a0c2000}, {0x3a0c4000}, {0x3a0c6000}, {0x3a0c8000}, {0x3a0ca000}, {0x3a0cc000}, {0x3a0ce000}, {0x3a0d0000}, {0x3a0d2000}, {0x3a0d4000}, {0x3a0d6000}, {0x3a0d8000}, {0x3a0da000}, {0x3a0dc000}, {0x3a0de000}, {0x3a0e0000}, {0x3a0e2000}, {0x3a0e4000}, {0x3a0e6000}, {0x3a0e8000}, {0x3a0ea000}, {0x3a0ec000}, {0x3a0ee000}, {0x3a0f0000}, {0x3a0f2000}, {0x3a0f4000}, {0x3a0f6000}, {0x3a0f8000}, {0x3a0fa000}, {0x3a0fc000}, {0x3a0fe000}, {0x3a100000}, {0x3a102000}, {0x3a104000}, {0x3a106000}, {0x3a108000}, {0x3a10a000}, {0x3a10c000}, {0x3a10e000}, {0x3a110000}, {0x3a112000}, {0x3a114000}, {0x3a116000}, {0x3a118000}, {0x3a11a000}, {0x3a11c000}, {0x3a11e000}, {0x3a120000}, {0x3a122000}, {0x3a124000}, {0x3a126000}, {0x3a128000}, {0x3a12a000}, {0x3a12c000}, {0x3a12e000}, {0x3a130000}, {0x3a132000}, {0x3a134000}, {0x3a136000}, {0x3a138000}, {0x3a13a000}, {0x3a13c000}, {0x3a13e000}, {0x3a140000}, {0x3a142000}, {0x3a144000}, {0x3a146000}, {0x3a148000}, {0x3a14a000}, {0x3a14c000}, {0x3a14e000}, {0x3a150000}, {0x3a152000}, {0x3a154000}, {0x3a156000}, {0x3a158000}, {0x3a15a000}, {0x3a15c000}, {0x3a15e000}, {0x3a160000}, {0x3a162000}, {0x3a164000}, {0x3a166000}, {0x3a168000}, {0x3a16a000}, {0x3a16c000}, {0x3a16e000}, {0x3a170000}, {0x3a172000}, {0x3a174000}, {0x3a176000}, {0x3a178000}, {0x3a17a000}, {0x3a17c000}, {0x3a17e000}, {0x3a180000}, {0x3a182000}, {0x3a184000}, {0x3a186000}, {0x3a188000}, {0x3a18a000}, {0x3a18c000}, {0x3a18e000}, {0x3a190000}, {0x3a192000}, {0x3a194000}, {0x3a196000}, {0x3a198000}, {0x3a19a000}, {0x3a19c000}, {0x3a19e000}, {0x3a1a0000}, {0x3a1a2000}, {0x3a1a4000}, {0x3a1a6000}, {0x3a1a8000}, {0x3a1aa000}, {0x3a1ac000}, {0x3a1ae000}, {0x3a1b0000}, {0x3a1b2000}, {0x3a1b4000}, {0x3a1b6000}, {0x3a1b8000}, {0x3a1ba000}, {0x3a1bc000}, {0x3a1be000}, {0x3a1c0000}, {0x3a1c2000}, {0x3a1c4000}, {0x3a1c6000}, {0x3a1c8000}, {0x3a1ca000}, {0x3a1cc000}, {0x3a1ce000}, {0x3a1d0000}, {0x3a1d2000}, {0x3a1d4000}, {0x3a1d6000}, {0x3a1d8000}, {0x3a1da000}, {0x3a1dc000}, {0x3a1de000}, {0x3a1e0000}, {0x3a1e2000}, {0x3a1e4000}, {0x3a1e6000}, {0x3a1e8000}, {0x3a1ea000}, {0x3a1ec000}, {0x3a1ee000}, {0x3a1f0000}, {0x3a1f2000}, {0x3a1f4000}, {0x3a1f6000}, {0x3a1f8000}, {0x3a1fa000}, {0x3a1fc000}, {0x3a1fe000}, {0x3a200000}, {0x3a202000}, {0x3a204000}, {0x3a206000}, {0x3a208000}, {0x3a20a000}, {0x3a20c000}, {0x3a20e000}, {0x3a210000}, {0x3a212000}, {0x3a214000}, {0x3a216000}, {0x3a218000}, {0x3a21a000}, {0x3a21c000}, {0x3a21e000}, {0x3a220000}, {0x3a222000}, {0x3a224000}, {0x3a226000}, {0x3a228000}, {0x3a22a000}, {0x3a22c000}, {0x3a22e000}, {0x3a230000}, {0x3a232000}, {0x3a234000}, {0x3a236000}, {0x3a238000}, {0x3a23a000}, {0x3a23c000}, {0x3a23e000}, {0x3a240000}, {0x3a242000}, {0x3a244000}, {0x3a246000}, {0x3a248000}, {0x3a24a000}, {0x3a24c000}, {0x3a24e000}, {0x3a250000}, {0x3a252000}, {0x3a254000}, {0x3a256000}, {0x3a258000}, {0x3a25a000}, {0x3a25c000}, {0x3a25e000}, {0x3a260000}, {0x3a262000}, {0x3a264000}, {0x3a266000}, {0x3a268000}, {0x3a26a000}, {0x3a26c000}, {0x3a26e000}, {0x3a270000}, {0x3a272000}, {0x3a274000}, {0x3a276000}, {0x3a278000}, {0x3a27a000}, {0x3a27c000}, {0x3a27e000}, {0x3a280000}, {0x3a282000}, {0x3a284000}, {0x3a286000}, {0x3a288000}, {0x3a28a000}, {0x3a28c000}, {0x3a28e000}, {0x3a290000}, {0x3a292000}, {0x3a294000}, {0x3a296000}, {0x3a298000}, {0x3a29a000}, {0x3a29c000}, {0x3a29e000}, {0x3a2a0000}, {0x3a2a2000}, {0x3a2a4000}, {0x3a2a6000}, {0x3a2a8000}, {0x3a2aa000}, {0x3a2ac000}, {0x3a2ae000}, {0x3a2b0000}, {0x3a2b2000}, {0x3a2b4000}, {0x3a2b6000}, {0x3a2b8000}, {0x3a2ba000}, {0x3a2bc000}, {0x3a2be000}, {0x3a2c0000}, {0x3a2c2000}, {0x3a2c4000}, {0x3a2c6000}, {0x3a2c8000}, {0x3a2ca000}, {0x3a2cc000}, {0x3a2ce000}, {0x3a2d0000}, {0x3a2d2000}, {0x3a2d4000}, {0x3a2d6000}, {0x3a2d8000}, {0x3a2da000}, {0x3a2dc000}, {0x3a2de000}, {0x3a2e0000}, {0x3a2e2000}, {0x3a2e4000}, {0x3a2e6000}, {0x3a2e8000}, {0x3a2ea000}, {0x3a2ec000}, {0x3a2ee000}, {0x3a2f0000}, {0x3a2f2000}, {0x3a2f4000}, {0x3a2f6000}, {0x3a2f8000}, {0x3a2fa000}, {0x3a2fc000}, {0x3a2fe000}, {0x3a300000}, {0x3a302000}, {0x3a304000}, {0x3a306000}, {0x3a308000}, {0x3a30a000}, {0x3a30c000}, {0x3a30e000}, {0x3a310000}, {0x3a312000}, {0x3a314000}, {0x3a316000}, {0x3a318000}, {0x3a31a000}, {0x3a31c000}, {0x3a31e000}, {0x3a320000}, {0x3a322000}, {0x3a324000}, {0x3a326000}, {0x3a328000}, {0x3a32a000}, {0x3a32c000}, {0x3a32e000}, {0x3a330000}, {0x3a332000}, {0x3a334000}, {0x3a336000}, {0x3a338000}, {0x3a33a000}, {0x3a33c000}, {0x3a33e000}, {0x3a340000}, {0x3a342000}, {0x3a344000}, {0x3a346000}, {0x3a348000}, {0x3a34a000}, {0x3a34c000}, {0x3a34e000}, {0x3a350000}, {0x3a352000}, {0x3a354000}, {0x3a356000}, {0x3a358000}, {0x3a35a000}, {0x3a35c000}, {0x3a35e000}, {0x3a360000}, {0x3a362000}, {0x3a364000}, {0x3a366000}, {0x3a368000}, {0x3a36a000}, {0x3a36c000}, {0x3a36e000}, {0x3a370000}, {0x3a372000}, {0x3a374000}, {0x3a376000}, {0x3a378000}, {0x3a37a000}, {0x3a37c000}, {0x3a37e000}, {0x3a380000}, {0x3a382000}, {0x3a384000}, {0x3a386000}, {0x3a388000}, {0x3a38a000}, {0x3a38c000}, {0x3a38e000}, {0x3a390000}, {0x3a392000}, {0x3a394000}, {0x3a396000}, {0x3a398000}, {0x3a39a000}, {0x3a39c000}, {0x3a39e000}, {0x3a3a0000}, {0x3a3a2000}, {0x3a3a4000}, {0x3a3a6000}, {0x3a3a8000}, {0x3a3aa000}, {0x3a3ac000}, {0x3a3ae000}, {0x3a3b0000}, {0x3a3b2000}, {0x3a3b4000}, {0x3a3b6000}, {0x3a3b8000}, {0x3a3ba000}, {0x3a3bc000}, {0x3a3be000}, {0x3a3c0000}, {0x3a3c2000}, {0x3a3c4000}, {0x3a3c6000}, {0x3a3c8000}, {0x3a3ca000}, {0x3a3cc000}, {0x3a3ce000}, {0x3a3d0000}, {0x3a3d2000}, {0x3a3d4000}, {0x3a3d6000}, {0x3a3d8000}, {0x3a3da000}, {0x3a3dc000}, {0x3a3de000}, {0x3a3e0000}, {0x3a3e2000}, {0x3a3e4000}, {0x3a3e6000}, {0x3a3e8000}, {0x3a3ea000}, {0x3a3ec000}, {0x3a3ee000}, {0x3a3f0000}, {0x3a3f2000}, {0x3a3f4000}, {0x3a3f6000}, {0x3a3f8000}, {0x3a3fa000}, {0x3a3fc000}, {0x3a3fe000}, {0x3a400000}, {0x3a402000}, {0x3a404000}, {0x3a406000}, {0x3a408000}, {0x3a40a000}, {0x3a40c000}, {0x3a40e000}, {0x3a410000}, {0x3a412000}, {0x3a414000}, {0x3a416000}, {0x3a418000}, {0x3a41a000}, {0x3a41c000}, {0x3a41e000}, {0x3a420000}, {0x3a422000}, {0x3a424000}, {0x3a426000}, {0x3a428000}, {0x3a42a000}, {0x3a42c000}, {0x3a42e000}, {0x3a430000}, {0x3a432000}, {0x3a434000}, {0x3a436000}, {0x3a438000}, {0x3a43a000}, {0x3a43c000}, {0x3a43e000}, {0x3a440000}, {0x3a442000}, {0x3a444000}, {0x3a446000}, {0x3a448000}, {0x3a44a000}, {0x3a44c000}, {0x3a44e000}, {0x3a450000}, {0x3a452000}, {0x3a454000}, {0x3a456000}, {0x3a458000}, {0x3a45a000}, {0x3a45c000}, {0x3a45e000}, {0x3a460000}, {0x3a462000}, {0x3a464000}, {0x3a466000}, {0x3a468000}, {0x3a46a000}, {0x3a46c000}, {0x3a46e000}, {0x3a470000}, {0x3a472000}, {0x3a474000}, {0x3a476000}, {0x3a478000}, {0x3a47a000}, {0x3a47c000}, {0x3a47e000}, {0x3a480000}, {0x3a482000}, {0x3a484000}, {0x3a486000}, {0x3a488000}, {0x3a48a000}, {0x3a48c000}, {0x3a48e000}, {0x3a490000}, {0x3a492000}, {0x3a494000}, {0x3a496000}, {0x3a498000}, {0x3a49a000}, {0x3a49c000}, {0x3a49e000}, {0x3a4a0000}, {0x3a4a2000}, {0x3a4a4000}, {0x3a4a6000}, {0x3a4a8000}, {0x3a4aa000}, {0x3a4ac000}, {0x3a4ae000}, {0x3a4b0000}, {0x3a4b2000}, {0x3a4b4000}, {0x3a4b6000}, {0x3a4b8000}, {0x3a4ba000}, {0x3a4bc000}, {0x3a4be000}, {0x3a4c0000}, {0x3a4c2000}, {0x3a4c4000}, {0x3a4c6000}, {0x3a4c8000}, {0x3a4ca000}, {0x3a4cc000}, {0x3a4ce000}, {0x3a4d0000}, {0x3a4d2000}, {0x3a4d4000}, {0x3a4d6000}, {0x3a4d8000}, {0x3a4da000}, {0x3a4dc000}, {0x3a4de000}, {0x3a4e0000}, {0x3a4e2000}, {0x3a4e4000}, {0x3a4e6000}, {0x3a4e8000}, {0x3a4ea000}, {0x3a4ec000}, {0x3a4ee000}, {0x3a4f0000}, {0x3a4f2000}, {0x3a4f4000}, {0x3a4f6000}, {0x3a4f8000}, {0x3a4fa000}, {0x3a4fc000}, {0x3a4fe000}, {0x3a500000}, {0x3a502000}, {0x3a504000}, {0x3a506000}, {0x3a508000}, {0x3a50a000}, {0x3a50c000}, {0x3a50e000}, {0x3a510000}, {0x3a512000}, {0x3a514000}, {0x3a516000}, {0x3a518000}, {0x3a51a000}, {0x3a51c000}, {0x3a51e000}, {0x3a520000}, {0x3a522000}, {0x3a524000}, {0x3a526000}, {0x3a528000}, {0x3a52a000}, {0x3a52c000}, {0x3a52e000}, {0x3a530000}, {0x3a532000}, {0x3a534000}, {0x3a536000}, {0x3a538000}, {0x3a53a000}, {0x3a53c000}, {0x3a53e000}, {0x3a540000}, {0x3a542000}, {0x3a544000}, {0x3a546000}, {0x3a548000}, {0x3a54a000}, {0x3a54c000}, {0x3a54e000}, {0x3a550000}, {0x3a552000}, {0x3a554000}, {0x3a556000}, {0x3a558000}, {0x3a55a000}, {0x3a55c000}, {0x3a55e000}, {0x3a560000}, {0x3a562000}, {0x3a564000}, {0x3a566000}, {0x3a568000}, {0x3a56a000}, {0x3a56c000}, {0x3a56e000}, {0x3a570000}, {0x3a572000}, {0x3a574000}, {0x3a576000}, {0x3a578000}, {0x3a57a000}, {0x3a57c000}, {0x3a57e000}, {0x3a580000}, {0x3a582000}, {0x3a584000}, {0x3a586000}, {0x3a588000}, {0x3a58a000}, {0x3a58c000}, {0x3a58e000}, {0x3a590000}, {0x3a592000}, {0x3a594000}, {0x3a596000}, {0x3a598000}, {0x3a59a000}, {0x3a59c000}, {0x3a59e000}, {0x3a5a0000}, {0x3a5a2000}, {0x3a5a4000}, {0x3a5a6000}, {0x3a5a8000}, {0x3a5aa000}, {0x3a5ac000}, {0x3a5ae000}, {0x3a5b0000}, {0x3a5b2000}, {0x3a5b4000}, {0x3a5b6000}, {0x3a5b8000}, {0x3a5ba000}, {0x3a5bc000}, {0x3a5be000}, {0x3a5c0000}, {0x3a5c2000}, {0x3a5c4000}, {0x3a5c6000}, {0x3a5c8000}, {0x3a5ca000}, {0x3a5cc000}, {0x3a5ce000}, {0x3a5d0000}, {0x3a5d2000}, {0x3a5d4000}, {0x3a5d6000}, {0x3a5d8000}, {0x3a5da000}, {0x3a5dc000}, {0x3a5de000}, {0x3a5e0000}, {0x3a5e2000}, {0x3a5e4000}, {0x3a5e6000}, {0x3a5e8000}, {0x3a5ea000}, {0x3a5ec000}, {0x3a5ee000}, {0x3a5f0000}, {0x3a5f2000}, {0x3a5f4000}, {0x3a5f6000}, {0x3a5f8000}, {0x3a5fa000}, {0x3a5fc000}, {0x3a5fe000}, {0x3a600000}, {0x3a602000}, {0x3a604000}, {0x3a606000}, {0x3a608000}, {0x3a60a000}, {0x3a60c000}, {0x3a60e000}, {0x3a610000}, {0x3a612000}, {0x3a614000}, {0x3a616000}, {0x3a618000}, {0x3a61a000}, {0x3a61c000}, {0x3a61e000}, {0x3a620000}, {0x3a622000}, {0x3a624000}, {0x3a626000}, {0x3a628000}, {0x3a62a000}, {0x3a62c000}, {0x3a62e000}, {0x3a630000}, {0x3a632000}, {0x3a634000}, {0x3a636000}, {0x3a638000}, {0x3a63a000}, {0x3a63c000}, {0x3a63e000}, {0x3a640000}, {0x3a642000}, {0x3a644000}, {0x3a646000}, {0x3a648000}, {0x3a64a000}, {0x3a64c000}, {0x3a64e000}, {0x3a650000}, {0x3a652000}, {0x3a654000}, {0x3a656000}, {0x3a658000}, {0x3a65a000}, {0x3a65c000}, {0x3a65e000}, {0x3a660000}, {0x3a662000}, {0x3a664000}, {0x3a666000}, {0x3a668000}, {0x3a66a000}, {0x3a66c000}, {0x3a66e000}, {0x3a670000}, {0x3a672000}, {0x3a674000}, {0x3a676000}, {0x3a678000}, {0x3a67a000}, {0x3a67c000}, {0x3a67e000}, {0x3a680000}, {0x3a682000}, {0x3a684000}, {0x3a686000}, {0x3a688000}, {0x3a68a000}, {0x3a68c000}, {0x3a68e000}, {0x3a690000}, {0x3a692000}, {0x3a694000}, {0x3a696000}, {0x3a698000}, {0x3a69a000}, {0x3a69c000}, {0x3a69e000}, {0x3a6a0000}, {0x3a6a2000}, {0x3a6a4000}, {0x3a6a6000}, {0x3a6a8000}, {0x3a6aa000}, {0x3a6ac000}, {0x3a6ae000}, {0x3a6b0000}, {0x3a6b2000}, {0x3a6b4000}, {0x3a6b6000}, {0x3a6b8000}, {0x3a6ba000}, {0x3a6bc000}, {0x3a6be000}, {0x3a6c0000}, {0x3a6c2000}, {0x3a6c4000}, {0x3a6c6000}, {0x3a6c8000}, {0x3a6ca000}, {0x3a6cc000}, {0x3a6ce000}, {0x3a6d0000}, {0x3a6d2000}, {0x3a6d4000}, {0x3a6d6000}, {0x3a6d8000}, {0x3a6da000}, {0x3a6dc000}, {0x3a6de000}, {0x3a6e0000}, {0x3a6e2000}, {0x3a6e4000}, {0x3a6e6000}, {0x3a6e8000}, {0x3a6ea000}, {0x3a6ec000}, {0x3a6ee000}, {0x3a6f0000}, {0x3a6f2000}, {0x3a6f4000}, {0x3a6f6000}, {0x3a6f8000}, {0x3a6fa000}, {0x3a6fc000}, {0x3a6fe000}, {0x3a700000}, {0x3a702000}, {0x3a704000}, {0x3a706000}, {0x3a708000}, {0x3a70a000}, {0x3a70c000}, {0x3a70e000}, {0x3a710000}, {0x3a712000}, {0x3a714000}, {0x3a716000}, {0x3a718000}, {0x3a71a000}, {0x3a71c000}, {0x3a71e000}, {0x3a720000}, {0x3a722000}, {0x3a724000}, {0x3a726000}, {0x3a728000}, {0x3a72a000}, {0x3a72c000}, {0x3a72e000}, {0x3a730000}, {0x3a732000}, {0x3a734000}, {0x3a736000}, {0x3a738000}, {0x3a73a000}, {0x3a73c000}, {0x3a73e000}, {0x3a740000}, {0x3a742000}, {0x3a744000}, {0x3a746000}, {0x3a748000}, {0x3a74a000}, {0x3a74c000}, {0x3a74e000}, {0x3a750000}, {0x3a752000}, {0x3a754000}, {0x3a756000}, {0x3a758000}, {0x3a75a000}, {0x3a75c000}, {0x3a75e000}, {0x3a760000}, {0x3a762000}, {0x3a764000}, {0x3a766000}, {0x3a768000}, {0x3a76a000}, {0x3a76c000}, {0x3a76e000}, {0x3a770000}, {0x3a772000}, {0x3a774000}, {0x3a776000}, {0x3a778000}, {0x3a77a000}, {0x3a77c000}, {0x3a77e000}, {0x3a780000}, {0x3a782000}, {0x3a784000}, {0x3a786000}, {0x3a788000}, {0x3a78a000}, {0x3a78c000}, {0x3a78e000}, {0x3a790000}, {0x3a792000}, {0x3a794000}, {0x3a796000}, {0x3a798000}, {0x3a79a000}, {0x3a79c000}, {0x3a79e000}, {0x3a7a0000}, {0x3a7a2000}, {0x3a7a4000}, {0x3a7a6000}, {0x3a7a8000}, {0x3a7aa000}, {0x3a7ac000}, {0x3a7ae000}, {0x3a7b0000}, {0x3a7b2000}, {0x3a7b4000}, {0x3a7b6000}, {0x3a7b8000}, {0x3a7ba000}, {0x3a7bc000}, {0x3a7be000}, {0x3a7c0000}, {0x3a7c2000}, {0x3a7c4000}, {0x3a7c6000}, {0x3a7c8000}, {0x3a7ca000}, {0x3a7cc000}, {0x3a7ce000}, {0x3a7d0000}, {0x3a7d2000}, {0x3a7d4000}, {0x3a7d6000}, {0x3a7d8000}, {0x3a7da000}, {0x3a7dc000}, {0x3a7de000}, {0x3a7e0000}, {0x3a7e2000}, {0x3a7e4000}, {0x3a7e6000}, {0x3a7e8000}, {0x3a7ea000}, {0x3a7ec000}, {0x3a7ee000}, {0x3a7f0000}, {0x3a7f2000}, {0x3a7f4000}, {0x3a7f6000}, {0x3a7f8000}, {0x3a7fa000}, {0x3a7fc000}, {0x3a7fe000}, {0x3a800000}, {0x3a802000}, {0x3a804000}, {0x3a806000}, {0x3a808000}, {0x3a80a000}, {0x3a80c000}, {0x3a80e000}, {0x3a810000}, {0x3a812000}, {0x3a814000}, {0x3a816000}, {0x3a818000}, {0x3a81a000}, {0x3a81c000}, {0x3a81e000}, {0x3a820000}, {0x3a822000}, {0x3a824000}, {0x3a826000}, {0x3a828000}, {0x3a82a000}, {0x3a82c000}, {0x3a82e000}, {0x3a830000}, {0x3a832000}, {0x3a834000}, {0x3a836000}, {0x3a838000}, {0x3a83a000}, {0x3a83c000}, {0x3a83e000}, {0x3a840000}, {0x3a842000}, {0x3a844000}, {0x3a846000}, {0x3a848000}, {0x3a84a000}, {0x3a84c000}, {0x3a84e000}, {0x3a850000}, {0x3a852000}, {0x3a854000}, {0x3a856000}, {0x3a858000}, {0x3a85a000}, {0x3a85c000}, {0x3a85e000}, {0x3a860000}, {0x3a862000}, {0x3a864000}, {0x3a866000}, {0x3a868000}, {0x3a86a000}, {0x3a86c000}, {0x3a86e000}, {0x3a870000}, {0x3a872000}, {0x3a874000}, {0x3a876000}, {0x3a878000}, {0x3a87a000}, {0x3a87c000}, {0x3a87e000}, {0x3a880000}, {0x3a882000}, {0x3a884000}, {0x3a886000}, {0x3a888000}, {0x3a88a000}, {0x3a88c000}, {0x3a88e000}, {0x3a890000}, {0x3a892000}, {0x3a894000}, {0x3a896000}, {0x3a898000}, {0x3a89a000}, {0x3a89c000}, {0x3a89e000}, {0x3a8a0000}, {0x3a8a2000}, {0x3a8a4000}, {0x3a8a6000}, {0x3a8a8000}, {0x3a8aa000}, {0x3a8ac000}, {0x3a8ae000}, {0x3a8b0000}, {0x3a8b2000}, {0x3a8b4000}, {0x3a8b6000}, {0x3a8b8000}, {0x3a8ba000}, {0x3a8bc000}, {0x3a8be000}, {0x3a8c0000}, {0x3a8c2000}, {0x3a8c4000}, {0x3a8c6000}, {0x3a8c8000}, {0x3a8ca000}, {0x3a8cc000}, {0x3a8ce000}, {0x3a8d0000}, {0x3a8d2000}, {0x3a8d4000}, {0x3a8d6000}, {0x3a8d8000}, {0x3a8da000}, {0x3a8dc000}, {0x3a8de000}, {0x3a8e0000}, {0x3a8e2000}, {0x3a8e4000}, {0x3a8e6000}, {0x3a8e8000}, {0x3a8ea000}, {0x3a8ec000}, {0x3a8ee000}, {0x3a8f0000}, {0x3a8f2000}, {0x3a8f4000}, {0x3a8f6000}, {0x3a8f8000}, {0x3a8fa000}, {0x3a8fc000}, {0x3a8fe000}, {0x3a900000}, {0x3a902000}, {0x3a904000}, {0x3a906000}, {0x3a908000}, {0x3a90a000}, {0x3a90c000}, {0x3a90e000}, {0x3a910000}, {0x3a912000}, {0x3a914000}, {0x3a916000}, {0x3a918000}, {0x3a91a000}, {0x3a91c000}, {0x3a91e000}, {0x3a920000}, {0x3a922000}, {0x3a924000}, {0x3a926000}, {0x3a928000}, {0x3a92a000}, {0x3a92c000}, {0x3a92e000}, {0x3a930000}, {0x3a932000}, {0x3a934000}, {0x3a936000}, {0x3a938000}, {0x3a93a000}, {0x3a93c000}, {0x3a93e000}, {0x3a940000}, {0x3a942000}, {0x3a944000}, {0x3a946000}, {0x3a948000}, {0x3a94a000}, {0x3a94c000}, {0x3a94e000}, {0x3a950000}, {0x3a952000}, {0x3a954000}, {0x3a956000}, {0x3a958000}, {0x3a95a000}, {0x3a95c000}, {0x3a95e000}, {0x3a960000}, {0x3a962000}, {0x3a964000}, {0x3a966000}, {0x3a968000}, {0x3a96a000}, {0x3a96c000}, {0x3a96e000}, {0x3a970000}, {0x3a972000}, {0x3a974000}, {0x3a976000}, {0x3a978000}, {0x3a97a000}, {0x3a97c000}, {0x3a97e000}, {0x3a980000}, {0x3a982000}, {0x3a984000}, {0x3a986000}, {0x3a988000}, {0x3a98a000}, {0x3a98c000}, {0x3a98e000}, {0x3a990000}, {0x3a992000}, {0x3a994000}, {0x3a996000}, {0x3a998000}, {0x3a99a000}, {0x3a99c000}, {0x3a99e000}, {0x3a9a0000}, {0x3a9a2000}, {0x3a9a4000}, {0x3a9a6000}, {0x3a9a8000}, {0x3a9aa000}, {0x3a9ac000}, {0x3a9ae000}, {0x3a9b0000}, {0x3a9b2000}, {0x3a9b4000}, {0x3a9b6000}, {0x3a9b8000}, {0x3a9ba000}, {0x3a9bc000}, {0x3a9be000}, {0x3a9c0000}, {0x3a9c2000}, {0x3a9c4000}, {0x3a9c6000}, {0x3a9c8000}, {0x3a9ca000}, {0x3a9cc000}, {0x3a9ce000}, {0x3a9d0000}, {0x3a9d2000}, {0x3a9d4000}, {0x3a9d6000}, {0x3a9d8000}, {0x3a9da000}, {0x3a9dc000}, {0x3a9de000}, {0x3a9e0000}, {0x3a9e2000}, {0x3a9e4000}, {0x3a9e6000}, {0x3a9e8000}, {0x3a9ea000}, {0x3a9ec000}, {0x3a9ee000}, {0x3a9f0000}, {0x3a9f2000}, {0x3a9f4000}, {0x3a9f6000}, {0x3a9f8000}, {0x3a9fa000}, {0x3a9fc000}, {0x3a9fe000}, {0x3aa00000}, {0x3aa02000}, {0x3aa04000}, {0x3aa06000}, {0x3aa08000}, {0x3aa0a000}, {0x3aa0c000}, {0x3aa0e000}, {0x3aa10000}, {0x3aa12000}, {0x3aa14000}, {0x3aa16000}, {0x3aa18000}, {0x3aa1a000}, {0x3aa1c000}, {0x3aa1e000}, {0x3aa20000}, {0x3aa22000}, {0x3aa24000}, {0x3aa26000}, {0x3aa28000}, {0x3aa2a000}, {0x3aa2c000}, {0x3aa2e000}, {0x3aa30000}, {0x3aa32000}, {0x3aa34000}, {0x3aa36000}, {0x3aa38000}, {0x3aa3a000}, {0x3aa3c000}, {0x3aa3e000}, {0x3aa40000}, {0x3aa42000}, {0x3aa44000}, {0x3aa46000}, {0x3aa48000}, {0x3aa4a000}, {0x3aa4c000}, {0x3aa4e000}, {0x3aa50000}, {0x3aa52000}, {0x3aa54000}, {0x3aa56000}, {0x3aa58000}, {0x3aa5a000}, {0x3aa5c000}, {0x3aa5e000}, {0x3aa60000}, {0x3aa62000}, {0x3aa64000}, {0x3aa66000}, {0x3aa68000}, {0x3aa6a000}, {0x3aa6c000}, {0x3aa6e000}, {0x3aa70000}, {0x3aa72000}, {0x3aa74000}, {0x3aa76000}, {0x3aa78000}, {0x3aa7a000}, {0x3aa7c000}, {0x3aa7e000}, {0x3aa80000}, {0x3aa82000}, {0x3aa84000}, {0x3aa86000}, {0x3aa88000}, {0x3aa8a000}, {0x3aa8c000}, {0x3aa8e000}, {0x3aa90000}, {0x3aa92000}, {0x3aa94000}, {0x3aa96000}, {0x3aa98000}, {0x3aa9a000}, {0x3aa9c000}, {0x3aa9e000}, {0x3aaa0000}, {0x3aaa2000}, {0x3aaa4000}, {0x3aaa6000}, {0x3aaa8000}, {0x3aaaa000}, {0x3aaac000}, {0x3aaae000}, {0x3aab0000}, {0x3aab2000}, {0x3aab4000}, {0x3aab6000}, {0x3aab8000}, {0x3aaba000}, {0x3aabc000}, {0x3aabe000}, {0x3aac0000}, {0x3aac2000}, {0x3aac4000}, {0x3aac6000}, {0x3aac8000}, {0x3aaca000}, {0x3aacc000}, {0x3aace000}, {0x3aad0000}, {0x3aad2000}, {0x3aad4000}, {0x3aad6000}, {0x3aad8000}, {0x3aada000}, {0x3aadc000}, {0x3aade000}, {0x3aae0000}, {0x3aae2000}, {0x3aae4000}, {0x3aae6000}, {0x3aae8000}, {0x3aaea000}, {0x3aaec000}, {0x3aaee000}, {0x3aaf0000}, {0x3aaf2000}, {0x3aaf4000}, {0x3aaf6000}, {0x3aaf8000}, {0x3aafa000}, {0x3aafc000}, {0x3aafe000}, {0x3ab00000}, {0x3ab02000}, {0x3ab04000}, {0x3ab06000}, {0x3ab08000}, {0x3ab0a000}, {0x3ab0c000}, {0x3ab0e000}, {0x3ab10000}, {0x3ab12000}, {0x3ab14000}, {0x3ab16000}, {0x3ab18000}, {0x3ab1a000}, {0x3ab1c000}, {0x3ab1e000}, {0x3ab20000}, {0x3ab22000}, {0x3ab24000}, {0x3ab26000}, {0x3ab28000}, {0x3ab2a000}, {0x3ab2c000}, {0x3ab2e000}, {0x3ab30000}, {0x3ab32000}, {0x3ab34000}, {0x3ab36000}, {0x3ab38000}, {0x3ab3a000}, {0x3ab3c000}, {0x3ab3e000}, {0x3ab40000}, {0x3ab42000}, {0x3ab44000}, {0x3ab46000}, {0x3ab48000}, {0x3ab4a000}, {0x3ab4c000}, {0x3ab4e000}, {0x3ab50000}, {0x3ab52000}, {0x3ab54000}, {0x3ab56000}, {0x3ab58000}, {0x3ab5a000}, {0x3ab5c000}, {0x3ab5e000}, {0x3ab60000}, {0x3ab62000}, {0x3ab64000}, {0x3ab66000}, {0x3ab68000}, {0x3ab6a000}, {0x3ab6c000}, {0x3ab6e000}, {0x3ab70000}, {0x3ab72000}, {0x3ab74000}, {0x3ab76000}, {0x3ab78000}, {0x3ab7a000}, {0x3ab7c000}, {0x3ab7e000}, {0x3ab80000}, {0x3ab82000}, {0x3ab84000}, {0x3ab86000}, {0x3ab88000}, {0x3ab8a000}, {0x3ab8c000}, {0x3ab8e000}, {0x3ab90000}, {0x3ab92000}, {0x3ab94000}, {0x3ab96000}, {0x3ab98000}, {0x3ab9a000}, {0x3ab9c000}, {0x3ab9e000}, {0x3aba0000}, {0x3aba2000}, {0x3aba4000}, {0x3aba6000}, {0x3aba8000}, {0x3abaa000}, {0x3abac000}, {0x3abae000}, {0x3abb0000}, {0x3abb2000}, {0x3abb4000}, {0x3abb6000}, {0x3abb8000}, {0x3abba000}, {0x3abbc000}, {0x3abbe000}, {0x3abc0000}, {0x3abc2000}, {0x3abc4000}, {0x3abc6000}, {0x3abc8000}, {0x3abca000}, {0x3abcc000}, {0x3abce000}, {0x3abd0000}, {0x3abd2000}, {0x3abd4000}, {0x3abd6000}, {0x3abd8000}, {0x3abda000}, {0x3abdc000}, {0x3abde000}, {0x3abe0000}, {0x3abe2000}, {0x3abe4000}, {0x3abe6000}, {0x3abe8000}, {0x3abea000}, {0x3abec000}, {0x3abee000}, {0x3abf0000}, {0x3abf2000}, {0x3abf4000}, {0x3abf6000}, {0x3abf8000}, {0x3abfa000}, {0x3abfc000}, {0x3abfe000}, {0x3ac00000}, {0x3ac02000}, {0x3ac04000}, {0x3ac06000}, {0x3ac08000}, {0x3ac0a000}, {0x3ac0c000}, {0x3ac0e000}, {0x3ac10000}, {0x3ac12000}, {0x3ac14000}, {0x3ac16000}, {0x3ac18000}, {0x3ac1a000}, {0x3ac1c000}, {0x3ac1e000}, {0x3ac20000}, {0x3ac22000}, {0x3ac24000}, {0x3ac26000}, {0x3ac28000}, {0x3ac2a000}, {0x3ac2c000}, {0x3ac2e000}, {0x3ac30000}, {0x3ac32000}, {0x3ac34000}, {0x3ac36000}, {0x3ac38000}, {0x3ac3a000}, {0x3ac3c000}, {0x3ac3e000}, {0x3ac40000}, {0x3ac42000}, {0x3ac44000}, {0x3ac46000}, {0x3ac48000}, {0x3ac4a000}, {0x3ac4c000}, {0x3ac4e000}, {0x3ac50000}, {0x3ac52000}, {0x3ac54000}, {0x3ac56000}, {0x3ac58000}, {0x3ac5a000}, {0x3ac5c000}, {0x3ac5e000}, {0x3ac60000}, {0x3ac62000}, {0x3ac64000}, {0x3ac66000}, {0x3ac68000}, {0x3ac6a000}, {0x3ac6c000}, {0x3ac6e000}, {0x3ac70000}, {0x3ac72000}, {0x3ac74000}, {0x3ac76000}, {0x3ac78000}, {0x3ac7a000}, {0x3ac7c000}, {0x3ac7e000}, {0x3ac80000}, {0x3ac82000}, {0x3ac84000}, {0x3ac86000}, {0x3ac88000}, {0x3ac8a000}, {0x3ac8c000}, {0x3ac8e000}, {0x3ac90000}, {0x3ac92000}, {0x3ac94000}, {0x3ac96000}, {0x3ac98000}, {0x3ac9a000}, {0x3ac9c000}, {0x3ac9e000}, {0x3aca0000}, {0x3aca2000}, {0x3aca4000}, {0x3aca6000}, {0x3aca8000}, {0x3acaa000}, {0x3acac000}, {0x3acae000}, {0x3acb0000}, {0x3acb2000}, {0x3acb4000}, {0x3acb6000}, {0x3acb8000}, {0x3acba000}, {0x3acbc000}, {0x3acbe000}, {0x3acc0000}, {0x3acc2000}, {0x3acc4000}, {0x3acc6000}, {0x3acc8000}, {0x3acca000}, {0x3accc000}, {0x3acce000}, {0x3acd0000}, {0x3acd2000}, {0x3acd4000}, {0x3acd6000}, {0x3acd8000}, {0x3acda000}, {0x3acdc000}, {0x3acde000}, {0x3ace0000}, {0x3ace2000}, {0x3ace4000}, {0x3ace6000}, {0x3ace8000}, {0x3acea000}, {0x3acec000}, {0x3acee000}, {0x3acf0000}, {0x3acf2000}, {0x3acf4000}, {0x3acf6000}, {0x3acf8000}, {0x3acfa000}, {0x3acfc000}, {0x3acfe000}, {0x3ad00000}, {0x3ad02000}, {0x3ad04000}, {0x3ad06000}, {0x3ad08000}, {0x3ad0a000}, {0x3ad0c000}, {0x3ad0e000}, {0x3ad10000}, {0x3ad12000}, {0x3ad14000}, {0x3ad16000}, {0x3ad18000}, {0x3ad1a000}, {0x3ad1c000}, {0x3ad1e000}, {0x3ad20000}, {0x3ad22000}, {0x3ad24000}, {0x3ad26000}, {0x3ad28000}, {0x3ad2a000}, {0x3ad2c000}, {0x3ad2e000}, {0x3ad30000}, {0x3ad32000}, {0x3ad34000}, {0x3ad36000}, {0x3ad38000}, {0x3ad3a000}, {0x3ad3c000}, {0x3ad3e000}, {0x3ad40000}, {0x3ad42000}, {0x3ad44000}, {0x3ad46000}, {0x3ad48000}, {0x3ad4a000}, {0x3ad4c000}, {0x3ad4e000}, {0x3ad50000}, {0x3ad52000}, {0x3ad54000}, {0x3ad56000}, {0x3ad58000}, {0x3ad5a000}, {0x3ad5c000}, {0x3ad5e000}, {0x3ad60000}, {0x3ad62000}, {0x3ad64000}, {0x3ad66000}, {0x3ad68000}, {0x3ad6a000}, {0x3ad6c000}, {0x3ad6e000}, {0x3ad70000}, {0x3ad72000}, {0x3ad74000}, {0x3ad76000}, {0x3ad78000}, {0x3ad7a000}, {0x3ad7c000}, {0x3ad7e000}, {0x3ad80000}, {0x3ad82000}, {0x3ad84000}, {0x3ad86000}, {0x3ad88000}, {0x3ad8a000}, {0x3ad8c000}, {0x3ad8e000}, {0x3ad90000}, {0x3ad92000}, {0x3ad94000}, {0x3ad96000}, {0x3ad98000}, {0x3ad9a000}, {0x3ad9c000}, {0x3ad9e000}, {0x3ada0000}, {0x3ada2000}, {0x3ada4000}, {0x3ada6000}, {0x3ada8000}, {0x3adaa000}, {0x3adac000}, {0x3adae000}, {0x3adb0000}, {0x3adb2000}, {0x3adb4000}, {0x3adb6000}, {0x3adb8000}, {0x3adba000}, {0x3adbc000}, {0x3adbe000}, {0x3adc0000}, {0x3adc2000}, {0x3adc4000}, {0x3adc6000}, {0x3adc8000}, {0x3adca000}, {0x3adcc000}, {0x3adce000}, {0x3add0000}, {0x3add2000}, {0x3add4000}, {0x3add6000}, {0x3add8000}, {0x3adda000}, {0x3addc000}, {0x3adde000}, {0x3ade0000}, {0x3ade2000}, {0x3ade4000}, {0x3ade6000}, {0x3ade8000}, {0x3adea000}, {0x3adec000}, {0x3adee000}, {0x3adf0000}, {0x3adf2000}, {0x3adf4000}, {0x3adf6000}, {0x3adf8000}, {0x3adfa000}, {0x3adfc000}, {0x3adfe000}, {0x3ae00000}, {0x3ae02000}, {0x3ae04000}, {0x3ae06000}, {0x3ae08000}, {0x3ae0a000}, {0x3ae0c000}, {0x3ae0e000}, {0x3ae10000}, {0x3ae12000}, {0x3ae14000}, {0x3ae16000}, {0x3ae18000}, {0x3ae1a000}, {0x3ae1c000}, {0x3ae1e000}, {0x3ae20000}, {0x3ae22000}, {0x3ae24000}, {0x3ae26000}, {0x3ae28000}, {0x3ae2a000}, {0x3ae2c000}, {0x3ae2e000}, {0x3ae30000}, {0x3ae32000}, {0x3ae34000}, {0x3ae36000}, {0x3ae38000}, {0x3ae3a000}, {0x3ae3c000}, {0x3ae3e000}, {0x3ae40000}, {0x3ae42000}, {0x3ae44000}, {0x3ae46000}, {0x3ae48000}, {0x3ae4a000}, {0x3ae4c000}, {0x3ae4e000}, {0x3ae50000}, {0x3ae52000}, {0x3ae54000}, {0x3ae56000}, {0x3ae58000}, {0x3ae5a000}, {0x3ae5c000}, {0x3ae5e000}, {0x3ae60000}, {0x3ae62000}, {0x3ae64000}, {0x3ae66000}, {0x3ae68000}, {0x3ae6a000}, {0x3ae6c000}, {0x3ae6e000}, {0x3ae70000}, {0x3ae72000}, {0x3ae74000}, {0x3ae76000}, {0x3ae78000}, {0x3ae7a000}, {0x3ae7c000}, {0x3ae7e000}, {0x3ae80000}, {0x3ae82000}, {0x3ae84000}, {0x3ae86000}, {0x3ae88000}, {0x3ae8a000}, {0x3ae8c000}, {0x3ae8e000}, {0x3ae90000}, {0x3ae92000}, {0x3ae94000}, {0x3ae96000}, {0x3ae98000}, {0x3ae9a000}, {0x3ae9c000}, {0x3ae9e000}, {0x3aea0000}, {0x3aea2000}, {0x3aea4000}, {0x3aea6000}, {0x3aea8000}, {0x3aeaa000}, {0x3aeac000}, {0x3aeae000}, {0x3aeb0000}, {0x3aeb2000}, {0x3aeb4000}, {0x3aeb6000}, {0x3aeb8000}, {0x3aeba000}, {0x3aebc000}, {0x3aebe000}, {0x3aec0000}, {0x3aec2000}, {0x3aec4000}, {0x3aec6000}, {0x3aec8000}, {0x3aeca000}, {0x3aecc000}, {0x3aece000}, {0x3aed0000}, {0x3aed2000}, {0x3aed4000}, {0x3aed6000}, {0x3aed8000}, {0x3aeda000}, {0x3aedc000}, {0x3aede000}, {0x3aee0000}, {0x3aee2000}, {0x3aee4000}, {0x3aee6000}, {0x3aee8000}, {0x3aeea000}, {0x3aeec000}, {0x3aeee000}, {0x3aef0000}, {0x3aef2000}, {0x3aef4000}, {0x3aef6000}, {0x3aef8000}, {0x3aefa000}, {0x3aefc000}, {0x3aefe000}, {0x3af00000}, {0x3af02000}, {0x3af04000}, {0x3af06000}, {0x3af08000}, {0x3af0a000}, {0x3af0c000}, {0x3af0e000}, {0x3af10000}, {0x3af12000}, {0x3af14000}, {0x3af16000}, {0x3af18000}, {0x3af1a000}, {0x3af1c000}, {0x3af1e000}, {0x3af20000}, {0x3af22000}, {0x3af24000}, {0x3af26000}, {0x3af28000}, {0x3af2a000}, {0x3af2c000}, {0x3af2e000}, {0x3af30000}, {0x3af32000}, {0x3af34000}, {0x3af36000}, {0x3af38000}, {0x3af3a000}, {0x3af3c000}, {0x3af3e000}, {0x3af40000}, {0x3af42000}, {0x3af44000}, {0x3af46000}, {0x3af48000}, {0x3af4a000}, {0x3af4c000}, {0x3af4e000}, {0x3af50000}, {0x3af52000}, {0x3af54000}, {0x3af56000}, {0x3af58000}, {0x3af5a000}, {0x3af5c000}, {0x3af5e000}, {0x3af60000}, {0x3af62000}, {0x3af64000}, {0x3af66000}, {0x3af68000}, {0x3af6a000}, {0x3af6c000}, {0x3af6e000}, {0x3af70000}, {0x3af72000}, {0x3af74000}, {0x3af76000}, {0x3af78000}, {0x3af7a000}, {0x3af7c000}, {0x3af7e000}, {0x3af80000}, {0x3af82000}, {0x3af84000}, {0x3af86000}, {0x3af88000}, {0x3af8a000}, {0x3af8c000}, {0x3af8e000}, {0x3af90000}, {0x3af92000}, {0x3af94000}, {0x3af96000}, {0x3af98000}, {0x3af9a000}, {0x3af9c000}, {0x3af9e000}, {0x3afa0000}, {0x3afa2000}, {0x3afa4000}, {0x3afa6000}, {0x3afa8000}, {0x3afaa000}, {0x3afac000}, {0x3afae000}, {0x3afb0000}, {0x3afb2000}, {0x3afb4000}, {0x3afb6000}, {0x3afb8000}, {0x3afba000}, {0x3afbc000}, {0x3afbe000}, {0x3afc0000}, {0x3afc2000}, {0x3afc4000}, {0x3afc6000}, {0x3afc8000}, {0x3afca000}, {0x3afcc000}, {0x3afce000}, {0x3afd0000}, {0x3afd2000}, {0x3afd4000}, {0x3afd6000}, {0x3afd8000}, {0x3afda000}, {0x3afdc000}, {0x3afde000}, {0x3afe0000}, {0x3afe2000}, {0x3afe4000}, {0x3afe6000}, {0x3afe8000}, {0x3afea000}, {0x3afec000}, {0x3afee000}, {0x3aff0000}, {0x3aff2000}, {0x3aff4000}, {0x3aff6000}, {0x3aff8000}, {0x3affa000}, {0x3affc000}, {0x3affe000}, {0x3b000000}, {0x3b002000}, {0x3b004000}, {0x3b006000}, {0x3b008000}, {0x3b00a000}, {0x3b00c000}, {0x3b00e000}, {0x3b010000}, {0x3b012000}, {0x3b014000}, {0x3b016000}, {0x3b018000}, {0x3b01a000}, {0x3b01c000}, {0x3b01e000}, {0x3b020000}, {0x3b022000}, {0x3b024000}, {0x3b026000}, {0x3b028000}, {0x3b02a000}, {0x3b02c000}, {0x3b02e000}, {0x3b030000}, {0x3b032000}, {0x3b034000}, {0x3b036000}, {0x3b038000}, {0x3b03a000}, {0x3b03c000}, {0x3b03e000}, {0x3b040000}, {0x3b042000}, {0x3b044000}, {0x3b046000}, {0x3b048000}, {0x3b04a000}, {0x3b04c000}, {0x3b04e000}, {0x3b050000}, {0x3b052000}, {0x3b054000}, {0x3b056000}, {0x3b058000}, {0x3b05a000}, {0x3b05c000}, {0x3b05e000}, {0x3b060000}, {0x3b062000}, {0x3b064000}, {0x3b066000}, {0x3b068000}, {0x3b06a000}, {0x3b06c000}, {0x3b06e000}, {0x3b070000}, {0x3b072000}, {0x3b074000}, {0x3b076000}, {0x3b078000}, {0x3b07a000}, {0x3b07c000}, {0x3b07e000}, {0x3b080000}, {0x3b082000}, {0x3b084000}, {0x3b086000}, {0x3b088000}, {0x3b08a000}, {0x3b08c000}, {0x3b08e000}, {0x3b090000}, {0x3b092000}, {0x3b094000}, {0x3b096000}, {0x3b098000}, {0x3b09a000}, {0x3b09c000}, {0x3b09e000}, {0x3b0a0000}, {0x3b0a2000}, {0x3b0a4000}, {0x3b0a6000}, {0x3b0a8000}, {0x3b0aa000}, {0x3b0ac000}, {0x3b0ae000}, {0x3b0b0000}, {0x3b0b2000}, {0x3b0b4000}, {0x3b0b6000}, {0x3b0b8000}, {0x3b0ba000}, {0x3b0bc000}, {0x3b0be000}, {0x3b0c0000}, {0x3b0c2000}, {0x3b0c4000}, {0x3b0c6000}, {0x3b0c8000}, {0x3b0ca000}, {0x3b0cc000}, {0x3b0ce000}, {0x3b0d0000}, {0x3b0d2000}, {0x3b0d4000}, {0x3b0d6000}, {0x3b0d8000}, {0x3b0da000}, {0x3b0dc000}, {0x3b0de000}, {0x3b0e0000}, {0x3b0e2000}, {0x3b0e4000}, {0x3b0e6000}, {0x3b0e8000}, {0x3b0ea000}, {0x3b0ec000}, {0x3b0ee000}, {0x3b0f0000}, {0x3b0f2000}, {0x3b0f4000}, {0x3b0f6000}, {0x3b0f8000}, {0x3b0fa000}, {0x3b0fc000}, {0x3b0fe000}, {0x3b100000}, {0x3b102000}, {0x3b104000}, {0x3b106000}, {0x3b108000}, {0x3b10a000}, {0x3b10c000}, {0x3b10e000}, {0x3b110000}, {0x3b112000}, {0x3b114000}, {0x3b116000}, {0x3b118000}, {0x3b11a000}, {0x3b11c000}, {0x3b11e000}, {0x3b120000}, {0x3b122000}, {0x3b124000}, {0x3b126000}, {0x3b128000}, {0x3b12a000}, {0x3b12c000}, {0x3b12e000}, {0x3b130000}, {0x3b132000}, {0x3b134000}, {0x3b136000}, {0x3b138000}, {0x3b13a000}, {0x3b13c000}, {0x3b13e000}, {0x3b140000}, {0x3b142000}, {0x3b144000}, {0x3b146000}, {0x3b148000}, {0x3b14a000}, {0x3b14c000}, {0x3b14e000}, {0x3b150000}, {0x3b152000}, {0x3b154000}, {0x3b156000}, {0x3b158000}, {0x3b15a000}, {0x3b15c000}, {0x3b15e000}, {0x3b160000}, {0x3b162000}, {0x3b164000}, {0x3b166000}, {0x3b168000}, {0x3b16a000}, {0x3b16c000}, {0x3b16e000}, {0x3b170000}, {0x3b172000}, {0x3b174000}, {0x3b176000}, {0x3b178000}, {0x3b17a000}, {0x3b17c000}, {0x3b17e000}, {0x3b180000}, {0x3b182000}, {0x3b184000}, {0x3b186000}, {0x3b188000}, {0x3b18a000}, {0x3b18c000}, {0x3b18e000}, {0x3b190000}, {0x3b192000}, {0x3b194000}, {0x3b196000}, {0x3b198000}, {0x3b19a000}, {0x3b19c000}, {0x3b19e000}, {0x3b1a0000}, {0x3b1a2000}, {0x3b1a4000}, {0x3b1a6000}, {0x3b1a8000}, {0x3b1aa000}, {0x3b1ac000}, {0x3b1ae000}, {0x3b1b0000}, {0x3b1b2000}, {0x3b1b4000}, {0x3b1b6000}, {0x3b1b8000}, {0x3b1ba000}, {0x3b1bc000}, {0x3b1be000}, {0x3b1c0000}, {0x3b1c2000}, {0x3b1c4000}, {0x3b1c6000}, {0x3b1c8000}, {0x3b1ca000}, {0x3b1cc000}, {0x3b1ce000}, {0x3b1d0000}, {0x3b1d2000}, {0x3b1d4000}, {0x3b1d6000}, {0x3b1d8000}, {0x3b1da000}, {0x3b1dc000}, {0x3b1de000}, {0x3b1e0000}, {0x3b1e2000}, {0x3b1e4000}, {0x3b1e6000}, {0x3b1e8000}, {0x3b1ea000}, {0x3b1ec000}, {0x3b1ee000}, {0x3b1f0000}, {0x3b1f2000}, {0x3b1f4000}, {0x3b1f6000}, {0x3b1f8000}, {0x3b1fa000}, {0x3b1fc000}, {0x3b1fe000}, {0x3b200000}, {0x3b202000}, {0x3b204000}, {0x3b206000}, {0x3b208000}, {0x3b20a000}, {0x3b20c000}, {0x3b20e000}, {0x3b210000}, {0x3b212000}, {0x3b214000}, {0x3b216000}, {0x3b218000}, {0x3b21a000}, {0x3b21c000}, {0x3b21e000}, {0x3b220000}, {0x3b222000}, {0x3b224000}, {0x3b226000}, {0x3b228000}, {0x3b22a000}, {0x3b22c000}, {0x3b22e000}, {0x3b230000}, {0x3b232000}, {0x3b234000}, {0x3b236000}, {0x3b238000}, {0x3b23a000}, {0x3b23c000}, {0x3b23e000}, {0x3b240000}, {0x3b242000}, {0x3b244000}, {0x3b246000}, {0x3b248000}, {0x3b24a000}, {0x3b24c000}, {0x3b24e000}, {0x3b250000}, {0x3b252000}, {0x3b254000}, {0x3b256000}, {0x3b258000}, {0x3b25a000}, {0x3b25c000}, {0x3b25e000}, {0x3b260000}, {0x3b262000}, {0x3b264000}, {0x3b266000}, {0x3b268000}, {0x3b26a000}, {0x3b26c000}, {0x3b26e000}, {0x3b270000}, {0x3b272000}, {0x3b274000}, {0x3b276000}, {0x3b278000}, {0x3b27a000}, {0x3b27c000}, {0x3b27e000}, {0x3b280000}, {0x3b282000}, {0x3b284000}, {0x3b286000}, {0x3b288000}, {0x3b28a000}, {0x3b28c000}, {0x3b28e000}, {0x3b290000}, {0x3b292000}, {0x3b294000}, {0x3b296000}, {0x3b298000}, {0x3b29a000}, {0x3b29c000}, {0x3b29e000}, {0x3b2a0000}, {0x3b2a2000}, {0x3b2a4000}, {0x3b2a6000}, {0x3b2a8000}, {0x3b2aa000}, {0x3b2ac000}, {0x3b2ae000}, {0x3b2b0000}, {0x3b2b2000}, {0x3b2b4000}, {0x3b2b6000}, {0x3b2b8000}, {0x3b2ba000}, {0x3b2bc000}, {0x3b2be000}, {0x3b2c0000}, {0x3b2c2000}, {0x3b2c4000}, {0x3b2c6000}, {0x3b2c8000}, {0x3b2ca000}, {0x3b2cc000}, {0x3b2ce000}, {0x3b2d0000}, {0x3b2d2000}, {0x3b2d4000}, {0x3b2d6000}, {0x3b2d8000}, {0x3b2da000}, {0x3b2dc000}, {0x3b2de000}, {0x3b2e0000}, {0x3b2e2000}, {0x3b2e4000}, {0x3b2e6000}, {0x3b2e8000}, {0x3b2ea000}, {0x3b2ec000}, {0x3b2ee000}, {0x3b2f0000}, {0x3b2f2000}, {0x3b2f4000}, {0x3b2f6000}, {0x3b2f8000}, {0x3b2fa000}, {0x3b2fc000}, {0x3b2fe000}, {0x3b300000}, {0x3b302000}, {0x3b304000}, {0x3b306000}, {0x3b308000}, {0x3b30a000}, {0x3b30c000}, {0x3b30e000}, {0x3b310000}, {0x3b312000}, {0x3b314000}, {0x3b316000}, {0x3b318000}, {0x3b31a000}, {0x3b31c000}, {0x3b31e000}, {0x3b320000}, {0x3b322000}, {0x3b324000}, {0x3b326000}, {0x3b328000}, {0x3b32a000}, {0x3b32c000}, {0x3b32e000}, {0x3b330000}, {0x3b332000}, {0x3b334000}, {0x3b336000}, {0x3b338000}, {0x3b33a000}, {0x3b33c000}, {0x3b33e000}, {0x3b340000}, {0x3b342000}, {0x3b344000}, {0x3b346000}, {0x3b348000}, {0x3b34a000}, {0x3b34c000}, {0x3b34e000}, {0x3b350000}, {0x3b352000}, {0x3b354000}, {0x3b356000}, {0x3b358000}, {0x3b35a000}, {0x3b35c000}, {0x3b35e000}, {0x3b360000}, {0x3b362000}, {0x3b364000}, {0x3b366000}, {0x3b368000}, {0x3b36a000}, {0x3b36c000}, {0x3b36e000}, {0x3b370000}, {0x3b372000}, {0x3b374000}, {0x3b376000}, {0x3b378000}, {0x3b37a000}, {0x3b37c000}, {0x3b37e000}, {0x3b380000}, {0x3b382000}, {0x3b384000}, {0x3b386000}, {0x3b388000}, {0x3b38a000}, {0x3b38c000}, {0x3b38e000}, {0x3b390000}, {0x3b392000}, {0x3b394000}, {0x3b396000}, {0x3b398000}, {0x3b39a000}, {0x3b39c000}, {0x3b39e000}, {0x3b3a0000}, {0x3b3a2000}, {0x3b3a4000}, {0x3b3a6000}, {0x3b3a8000}, {0x3b3aa000}, {0x3b3ac000}, {0x3b3ae000}, {0x3b3b0000}, {0x3b3b2000}, {0x3b3b4000}, {0x3b3b6000}, {0x3b3b8000}, {0x3b3ba000}, {0x3b3bc000}, {0x3b3be000}, {0x3b3c0000}, {0x3b3c2000}, {0x3b3c4000}, {0x3b3c6000}, {0x3b3c8000}, {0x3b3ca000}, {0x3b3cc000}, {0x3b3ce000}, {0x3b3d0000}, {0x3b3d2000}, {0x3b3d4000}, {0x3b3d6000}, {0x3b3d8000}, {0x3b3da000}, {0x3b3dc000}, {0x3b3de000}, {0x3b3e0000}, {0x3b3e2000}, {0x3b3e4000}, {0x3b3e6000}, {0x3b3e8000}, {0x3b3ea000}, {0x3b3ec000}, {0x3b3ee000}, {0x3b3f0000}, {0x3b3f2000}, {0x3b3f4000}, {0x3b3f6000}, {0x3b3f8000}, {0x3b3fa000}, {0x3b3fc000}, {0x3b3fe000}, {0x3b400000}, {0x3b402000}, {0x3b404000}, {0x3b406000}, {0x3b408000}, {0x3b40a000}, {0x3b40c000}, {0x3b40e000}, {0x3b410000}, {0x3b412000}, {0x3b414000}, {0x3b416000}, {0x3b418000}, {0x3b41a000}, {0x3b41c000}, {0x3b41e000}, {0x3b420000}, {0x3b422000}, {0x3b424000}, {0x3b426000}, {0x3b428000}, {0x3b42a000}, {0x3b42c000}, {0x3b42e000}, {0x3b430000}, {0x3b432000}, {0x3b434000}, {0x3b436000}, {0x3b438000}, {0x3b43a000}, {0x3b43c000}, {0x3b43e000}, {0x3b440000}, {0x3b442000}, {0x3b444000}, {0x3b446000}, {0x3b448000}, {0x3b44a000}, {0x3b44c000}, {0x3b44e000}, {0x3b450000}, {0x3b452000}, {0x3b454000}, {0x3b456000}, {0x3b458000}, {0x3b45a000}, {0x3b45c000}, {0x3b45e000}, {0x3b460000}, {0x3b462000}, {0x3b464000}, {0x3b466000}, {0x3b468000}, {0x3b46a000}, {0x3b46c000}, {0x3b46e000}, {0x3b470000}, {0x3b472000}, {0x3b474000}, {0x3b476000}, {0x3b478000}, {0x3b47a000}, {0x3b47c000}, {0x3b47e000}, {0x3b480000}, {0x3b482000}, {0x3b484000}, {0x3b486000}, {0x3b488000}, {0x3b48a000}, {0x3b48c000}, {0x3b48e000}, {0x3b490000}, {0x3b492000}, {0x3b494000}, {0x3b496000}, {0x3b498000}, {0x3b49a000}, {0x3b49c000}, {0x3b49e000}, {0x3b4a0000}, {0x3b4a2000}, {0x3b4a4000}, {0x3b4a6000}, {0x3b4a8000}, {0x3b4aa000}, {0x3b4ac000}, {0x3b4ae000}, {0x3b4b0000}, {0x3b4b2000}, {0x3b4b4000}, {0x3b4b6000}, {0x3b4b8000}, {0x3b4ba000}, {0x3b4bc000}, {0x3b4be000}, {0x3b4c0000}, {0x3b4c2000}, {0x3b4c4000}, {0x3b4c6000}, {0x3b4c8000}, {0x3b4ca000}, {0x3b4cc000}, {0x3b4ce000}, {0x3b4d0000}, {0x3b4d2000}, {0x3b4d4000}, {0x3b4d6000}, {0x3b4d8000}, {0x3b4da000}, {0x3b4dc000}, {0x3b4de000}, {0x3b4e0000}, {0x3b4e2000}, {0x3b4e4000}, {0x3b4e6000}, {0x3b4e8000}, {0x3b4ea000}, {0x3b4ec000}, {0x3b4ee000}, {0x3b4f0000}, {0x3b4f2000}, {0x3b4f4000}, {0x3b4f6000}, {0x3b4f8000}, {0x3b4fa000}, {0x3b4fc000}, {0x3b4fe000}, {0x3b500000}, {0x3b502000}, {0x3b504000}, {0x3b506000}, {0x3b508000}, {0x3b50a000}, {0x3b50c000}, {0x3b50e000}, {0x3b510000}, {0x3b512000}, {0x3b514000}, {0x3b516000}, {0x3b518000}, {0x3b51a000}, {0x3b51c000}, {0x3b51e000}, {0x3b520000}, {0x3b522000}, {0x3b524000}, {0x3b526000}, {0x3b528000}, {0x3b52a000}, {0x3b52c000}, {0x3b52e000}, {0x3b530000}, {0x3b532000}, {0x3b534000}, {0x3b536000}, {0x3b538000}, {0x3b53a000}, {0x3b53c000}, {0x3b53e000}, {0x3b540000}, {0x3b542000}, {0x3b544000}, {0x3b546000}, {0x3b548000}, {0x3b54a000}, {0x3b54c000}, {0x3b54e000}, {0x3b550000}, {0x3b552000}, {0x3b554000}, {0x3b556000}, {0x3b558000}, {0x3b55a000}, {0x3b55c000}, {0x3b55e000}, {0x3b560000}, {0x3b562000}, {0x3b564000}, {0x3b566000}, {0x3b568000}, {0x3b56a000}, {0x3b56c000}, {0x3b56e000}, {0x3b570000}, {0x3b572000}, {0x3b574000}, {0x3b576000}, {0x3b578000}, {0x3b57a000}, {0x3b57c000}, {0x3b57e000}, {0x3b580000}, {0x3b582000}, {0x3b584000}, {0x3b586000}, {0x3b588000}, {0x3b58a000}, {0x3b58c000}, {0x3b58e000}, {0x3b590000}, {0x3b592000}, {0x3b594000}, {0x3b596000}, {0x3b598000}, {0x3b59a000}, {0x3b59c000}, {0x3b59e000}, {0x3b5a0000}, {0x3b5a2000}, {0x3b5a4000}, {0x3b5a6000}, {0x3b5a8000}, {0x3b5aa000}, {0x3b5ac000}, {0x3b5ae000}, {0x3b5b0000}, {0x3b5b2000}, {0x3b5b4000}, {0x3b5b6000}, {0x3b5b8000}, {0x3b5ba000}, {0x3b5bc000}, {0x3b5be000}, {0x3b5c0000}, {0x3b5c2000}, {0x3b5c4000}, {0x3b5c6000}, {0x3b5c8000}, {0x3b5ca000}, {0x3b5cc000}, {0x3b5ce000}, {0x3b5d0000}, {0x3b5d2000}, {0x3b5d4000}, {0x3b5d6000}, {0x3b5d8000}, {0x3b5da000}, {0x3b5dc000}, {0x3b5de000}, {0x3b5e0000}, {0x3b5e2000}, {0x3b5e4000}, {0x3b5e6000}, {0x3b5e8000}, {0x3b5ea000}, {0x3b5ec000}, {0x3b5ee000}, {0x3b5f0000}, {0x3b5f2000}, {0x3b5f4000}, {0x3b5f6000}, {0x3b5f8000}, {0x3b5fa000}, {0x3b5fc000}, {0x3b5fe000}, {0x3b600000}, {0x3b602000}, {0x3b604000}, {0x3b606000}, {0x3b608000}, {0x3b60a000}, {0x3b60c000}, {0x3b60e000}, {0x3b610000}, {0x3b612000}, {0x3b614000}, {0x3b616000}, {0x3b618000}, {0x3b61a000}, {0x3b61c000}, {0x3b61e000}, {0x3b620000}, {0x3b622000}, {0x3b624000}, {0x3b626000}, {0x3b628000}, {0x3b62a000}, {0x3b62c000}, {0x3b62e000}, {0x3b630000}, {0x3b632000}, {0x3b634000}, {0x3b636000}, {0x3b638000}, {0x3b63a000}, {0x3b63c000}, {0x3b63e000}, {0x3b640000}, {0x3b642000}, {0x3b644000}, {0x3b646000}, {0x3b648000}, {0x3b64a000}, {0x3b64c000}, {0x3b64e000}, {0x3b650000}, {0x3b652000}, {0x3b654000}, {0x3b656000}, {0x3b658000}, {0x3b65a000}, {0x3b65c000}, {0x3b65e000}, {0x3b660000}, {0x3b662000}, {0x3b664000}, {0x3b666000}, {0x3b668000}, {0x3b66a000}, {0x3b66c000}, {0x3b66e000}, {0x3b670000}, {0x3b672000}, {0x3b674000}, {0x3b676000}, {0x3b678000}, {0x3b67a000}, {0x3b67c000}, {0x3b67e000}, {0x3b680000}, {0x3b682000}, {0x3b684000}, {0x3b686000}, {0x3b688000}, {0x3b68a000}, {0x3b68c000}, {0x3b68e000}, {0x3b690000}, {0x3b692000}, {0x3b694000}, {0x3b696000}, {0x3b698000}, {0x3b69a000}, {0x3b69c000}, {0x3b69e000}, {0x3b6a0000}, {0x3b6a2000}, {0x3b6a4000}, {0x3b6a6000}, {0x3b6a8000}, {0x3b6aa000}, {0x3b6ac000}, {0x3b6ae000}, {0x3b6b0000}, {0x3b6b2000}, {0x3b6b4000}, {0x3b6b6000}, {0x3b6b8000}, {0x3b6ba000}, {0x3b6bc000}, {0x3b6be000}, {0x3b6c0000}, {0x3b6c2000}, {0x3b6c4000}, {0x3b6c6000}, {0x3b6c8000}, {0x3b6ca000}, {0x3b6cc000}, {0x3b6ce000}, {0x3b6d0000}, {0x3b6d2000}, {0x3b6d4000}, {0x3b6d6000}, {0x3b6d8000}, {0x3b6da000}, {0x3b6dc000}, {0x3b6de000}, {0x3b6e0000}, {0x3b6e2000}, {0x3b6e4000}, {0x3b6e6000}, {0x3b6e8000}, {0x3b6ea000}, {0x3b6ec000}, {0x3b6ee000}, {0x3b6f0000}, {0x3b6f2000}, {0x3b6f4000}, {0x3b6f6000}, {0x3b6f8000}, {0x3b6fa000}, {0x3b6fc000}, {0x3b6fe000}, {0x3b700000}, {0x3b702000}, {0x3b704000}, {0x3b706000}, {0x3b708000}, {0x3b70a000}, {0x3b70c000}, {0x3b70e000}, {0x3b710000}, {0x3b712000}, {0x3b714000}, {0x3b716000}, {0x3b718000}, {0x3b71a000}, {0x3b71c000}, {0x3b71e000}, {0x3b720000}, {0x3b722000}, {0x3b724000}, {0x3b726000}, {0x3b728000}, {0x3b72a000}, {0x3b72c000}, {0x3b72e000}, {0x3b730000}, {0x3b732000}, {0x3b734000}, {0x3b736000}, {0x3b738000}, {0x3b73a000}, {0x3b73c000}, {0x3b73e000}, {0x3b740000}, {0x3b742000}, {0x3b744000}, {0x3b746000}, {0x3b748000}, {0x3b74a000}, {0x3b74c000}, {0x3b74e000}, {0x3b750000}, {0x3b752000}, {0x3b754000}, {0x3b756000}, {0x3b758000}, {0x3b75a000}, {0x3b75c000}, {0x3b75e000}, {0x3b760000}, {0x3b762000}, {0x3b764000}, {0x3b766000}, {0x3b768000}, {0x3b76a000}, {0x3b76c000}, {0x3b76e000}, {0x3b770000}, {0x3b772000}, {0x3b774000}, {0x3b776000}, {0x3b778000}, {0x3b77a000}, {0x3b77c000}, {0x3b77e000}, {0x3b780000}, {0x3b782000}, {0x3b784000}, {0x3b786000}, {0x3b788000}, {0x3b78a000}, {0x3b78c000}, {0x3b78e000}, {0x3b790000}, {0x3b792000}, {0x3b794000}, {0x3b796000}, {0x3b798000}, {0x3b79a000}, {0x3b79c000}, {0x3b79e000}, {0x3b7a0000}, {0x3b7a2000}, {0x3b7a4000}, {0x3b7a6000}, {0x3b7a8000}, {0x3b7aa000}, {0x3b7ac000}, {0x3b7ae000}, {0x3b7b0000}, {0x3b7b2000}, {0x3b7b4000}, {0x3b7b6000}, {0x3b7b8000}, {0x3b7ba000}, {0x3b7bc000}, {0x3b7be000}, {0x3b7c0000}, {0x3b7c2000}, {0x3b7c4000}, {0x3b7c6000}, {0x3b7c8000}, {0x3b7ca000}, {0x3b7cc000}, {0x3b7ce000}, {0x3b7d0000}, {0x3b7d2000}, {0x3b7d4000}, {0x3b7d6000}, {0x3b7d8000}, {0x3b7da000}, {0x3b7dc000}, {0x3b7de000}, {0x3b7e0000}, {0x3b7e2000}, {0x3b7e4000}, {0x3b7e6000}, {0x3b7e8000}, {0x3b7ea000}, {0x3b7ec000}, {0x3b7ee000}, {0x3b7f0000}, {0x3b7f2000}, {0x3b7f4000}, {0x3b7f6000}, {0x3b7f8000}, {0x3b7fa000}, {0x3b7fc000}, {0x3b7fe000}, {0x3b800000}, {0x3b802000}, {0x3b804000}, {0x3b806000}, {0x3b808000}, {0x3b80a000}, {0x3b80c000}, {0x3b80e000}, {0x3b810000}, {0x3b812000}, {0x3b814000}, {0x3b816000}, {0x3b818000}, {0x3b81a000}, {0x3b81c000}, {0x3b81e000}, {0x3b820000}, {0x3b822000}, {0x3b824000}, {0x3b826000}, {0x3b828000}, {0x3b82a000}, {0x3b82c000}, {0x3b82e000}, {0x3b830000}, {0x3b832000}, {0x3b834000}, {0x3b836000}, {0x3b838000}, {0x3b83a000}, {0x3b83c000}, {0x3b83e000}, {0x3b840000}, {0x3b842000}, {0x3b844000}, {0x3b846000}, {0x3b848000}, {0x3b84a000}, {0x3b84c000}, {0x3b84e000}, {0x3b850000}, {0x3b852000}, {0x3b854000}, {0x3b856000}, {0x3b858000}, {0x3b85a000}, {0x3b85c000}, {0x3b85e000}, {0x3b860000}, {0x3b862000}, {0x3b864000}, {0x3b866000}, {0x3b868000}, {0x3b86a000}, {0x3b86c000}, {0x3b86e000}, {0x3b870000}, {0x3b872000}, {0x3b874000}, {0x3b876000}, {0x3b878000}, {0x3b87a000}, {0x3b87c000}, {0x3b87e000}, {0x3b880000}, {0x3b882000}, {0x3b884000}, {0x3b886000}, {0x3b888000}, {0x3b88a000}, {0x3b88c000}, {0x3b88e000}, {0x3b890000}, {0x3b892000}, {0x3b894000}, {0x3b896000}, {0x3b898000}, {0x3b89a000}, {0x3b89c000}, {0x3b89e000}, {0x3b8a0000}, {0x3b8a2000}, {0x3b8a4000}, {0x3b8a6000}, {0x3b8a8000}, {0x3b8aa000}, {0x3b8ac000}, {0x3b8ae000}, {0x3b8b0000}, {0x3b8b2000}, {0x3b8b4000}, {0x3b8b6000}, {0x3b8b8000}, {0x3b8ba000}, {0x3b8bc000}, {0x3b8be000}, {0x3b8c0000}, {0x3b8c2000}, {0x3b8c4000}, {0x3b8c6000}, {0x3b8c8000}, {0x3b8ca000}, {0x3b8cc000}, {0x3b8ce000}, {0x3b8d0000}, {0x3b8d2000}, {0x3b8d4000}, {0x3b8d6000}, {0x3b8d8000}, {0x3b8da000}, {0x3b8dc000}, {0x3b8de000}, {0x3b8e0000}, {0x3b8e2000}, {0x3b8e4000}, {0x3b8e6000}, {0x3b8e8000}, {0x3b8ea000}, {0x3b8ec000}, {0x3b8ee000}, {0x3b8f0000}, {0x3b8f2000}, {0x3b8f4000}, {0x3b8f6000}, {0x3b8f8000}, {0x3b8fa000}, {0x3b8fc000}, {0x3b8fe000}, {0x3b900000}, {0x3b902000}, {0x3b904000}, {0x3b906000}, {0x3b908000}, {0x3b90a000}, {0x3b90c000}, {0x3b90e000}, {0x3b910000}, {0x3b912000}, {0x3b914000}, {0x3b916000}, {0x3b918000}, {0x3b91a000}, {0x3b91c000}, {0x3b91e000}, {0x3b920000}, {0x3b922000}, {0x3b924000}, {0x3b926000}, {0x3b928000}, {0x3b92a000}, {0x3b92c000}, {0x3b92e000}, {0x3b930000}, {0x3b932000}, {0x3b934000}, {0x3b936000}, {0x3b938000}, {0x3b93a000}, {0x3b93c000}, {0x3b93e000}, {0x3b940000}, {0x3b942000}, {0x3b944000}, {0x3b946000}, {0x3b948000}, {0x3b94a000}, {0x3b94c000}, {0x3b94e000}, {0x3b950000}, {0x3b952000}, {0x3b954000}, {0x3b956000}, {0x3b958000}, {0x3b95a000}, {0x3b95c000}, {0x3b95e000}, {0x3b960000}, {0x3b962000}, {0x3b964000}, {0x3b966000}, {0x3b968000}, {0x3b96a000}, {0x3b96c000}, {0x3b96e000}, {0x3b970000}, {0x3b972000}, {0x3b974000}, {0x3b976000}, {0x3b978000}, {0x3b97a000}, {0x3b97c000}, {0x3b97e000}, {0x3b980000}, {0x3b982000}, {0x3b984000}, {0x3b986000}, {0x3b988000}, {0x3b98a000}, {0x3b98c000}, {0x3b98e000}, {0x3b990000}, {0x3b992000}, {0x3b994000}, {0x3b996000}, {0x3b998000}, {0x3b99a000}, {0x3b99c000}, {0x3b99e000}, {0x3b9a0000}, {0x3b9a2000}, {0x3b9a4000}, {0x3b9a6000}, {0x3b9a8000}, {0x3b9aa000}, {0x3b9ac000}, {0x3b9ae000}, {0x3b9b0000}, {0x3b9b2000}, {0x3b9b4000}, {0x3b9b6000}, {0x3b9b8000}, {0x3b9ba000}, {0x3b9bc000}, {0x3b9be000}, {0x3b9c0000}, {0x3b9c2000}, {0x3b9c4000}, {0x3b9c6000}, {0x3b9c8000}, {0x3b9ca000}, {0x3b9cc000}, {0x3b9ce000}, {0x3b9d0000}, {0x3b9d2000}, {0x3b9d4000}, {0x3b9d6000}, {0x3b9d8000}, {0x3b9da000}, {0x3b9dc000}, {0x3b9de000}, {0x3b9e0000}, {0x3b9e2000}, {0x3b9e4000}, {0x3b9e6000}, {0x3b9e8000}, {0x3b9ea000}, {0x3b9ec000}, {0x3b9ee000}, {0x3b9f0000}, {0x3b9f2000}, {0x3b9f4000}, {0x3b9f6000}, {0x3b9f8000}, {0x3b9fa000}, {0x3b9fc000}, {0x3b9fe000}, {0x3ba00000}, {0x3ba02000}, {0x3ba04000}, {0x3ba06000}, {0x3ba08000}, {0x3ba0a000}, {0x3ba0c000}, {0x3ba0e000}, {0x3ba10000}, {0x3ba12000}, {0x3ba14000}, {0x3ba16000}, {0x3ba18000}, {0x3ba1a000}, {0x3ba1c000}, {0x3ba1e000}, {0x3ba20000}, {0x3ba22000}, {0x3ba24000}, {0x3ba26000}, {0x3ba28000}, {0x3ba2a000}, {0x3ba2c000}, {0x3ba2e000}, {0x3ba30000}, {0x3ba32000}, {0x3ba34000}, {0x3ba36000}, {0x3ba38000}, {0x3ba3a000}, {0x3ba3c000}, {0x3ba3e000}, {0x3ba40000}, {0x3ba42000}, {0x3ba44000}, {0x3ba46000}, {0x3ba48000}, {0x3ba4a000}, {0x3ba4c000}, {0x3ba4e000}, {0x3ba50000}, {0x3ba52000}, {0x3ba54000}, {0x3ba56000}, {0x3ba58000}, {0x3ba5a000}, {0x3ba5c000}, {0x3ba5e000}, {0x3ba60000}, {0x3ba62000}, {0x3ba64000}, {0x3ba66000}, {0x3ba68000}, {0x3ba6a000}, {0x3ba6c000}, {0x3ba6e000}, {0x3ba70000}, {0x3ba72000}, {0x3ba74000}, {0x3ba76000}, {0x3ba78000}, {0x3ba7a000}, {0x3ba7c000}, {0x3ba7e000}, {0x3ba80000}, {0x3ba82000}, {0x3ba84000}, {0x3ba86000}, {0x3ba88000}, {0x3ba8a000}, {0x3ba8c000}, {0x3ba8e000}, {0x3ba90000}, {0x3ba92000}, {0x3ba94000}, {0x3ba96000}, {0x3ba98000}, {0x3ba9a000}, {0x3ba9c000}, {0x3ba9e000}, {0x3baa0000}, {0x3baa2000}, {0x3baa4000}, {0x3baa6000}, {0x3baa8000}, {0x3baaa000}, {0x3baac000}, {0x3baae000}, {0x3bab0000}, {0x3bab2000}, {0x3bab4000}, {0x3bab6000}, {0x3bab8000}, {0x3baba000}, {0x3babc000}, {0x3babe000}, {0x3bac0000}, {0x3bac2000}, {0x3bac4000}, {0x3bac6000}, {0x3bac8000}, {0x3baca000}, {0x3bacc000}, {0x3bace000}, {0x3bad0000}, {0x3bad2000}, {0x3bad4000}, {0x3bad6000}, {0x3bad8000}, {0x3bada000}, {0x3badc000}, {0x3bade000}, {0x3bae0000}, {0x3bae2000}, {0x3bae4000}, {0x3bae6000}, {0x3bae8000}, {0x3baea000}, {0x3baec000}, {0x3baee000}, {0x3baf0000}, {0x3baf2000}, {0x3baf4000}, {0x3baf6000}, {0x3baf8000}, {0x3bafa000}, {0x3bafc000}, {0x3bafe000}, {0x3bb00000}, {0x3bb02000}, {0x3bb04000}, {0x3bb06000}, {0x3bb08000}, {0x3bb0a000}, {0x3bb0c000}, {0x3bb0e000}, {0x3bb10000}, {0x3bb12000}, {0x3bb14000}, {0x3bb16000}, {0x3bb18000}, {0x3bb1a000}, {0x3bb1c000}, {0x3bb1e000}, {0x3bb20000}, {0x3bb22000}, {0x3bb24000}, {0x3bb26000}, {0x3bb28000}, {0x3bb2a000}, {0x3bb2c000}, {0x3bb2e000}, {0x3bb30000}, {0x3bb32000}, {0x3bb34000}, {0x3bb36000}, {0x3bb38000}, {0x3bb3a000}, {0x3bb3c000}, {0x3bb3e000}, {0x3bb40000}, {0x3bb42000}, {0x3bb44000}, {0x3bb46000}, {0x3bb48000}, {0x3bb4a000}, {0x3bb4c000}, {0x3bb4e000}, {0x3bb50000}, {0x3bb52000}, {0x3bb54000}, {0x3bb56000}, {0x3bb58000}, {0x3bb5a000}, {0x3bb5c000}, {0x3bb5e000}, {0x3bb60000}, {0x3bb62000}, {0x3bb64000}, {0x3bb66000}, {0x3bb68000}, {0x3bb6a000}, {0x3bb6c000}, {0x3bb6e000}, {0x3bb70000}, {0x3bb72000}, {0x3bb74000}, {0x3bb76000}, {0x3bb78000}, {0x3bb7a000}, {0x3bb7c000}, {0x3bb7e000}, {0x3bb80000}, {0x3bb82000}, {0x3bb84000}, {0x3bb86000}, {0x3bb88000}, {0x3bb8a000}, {0x3bb8c000}, {0x3bb8e000}, {0x3bb90000}, {0x3bb92000}, {0x3bb94000}, {0x3bb96000}, {0x3bb98000}, {0x3bb9a000}, {0x3bb9c000}, {0x3bb9e000}, {0x3bba0000}, {0x3bba2000}, {0x3bba4000}, {0x3bba6000}, {0x3bba8000}, {0x3bbaa000}, {0x3bbac000}, {0x3bbae000}, {0x3bbb0000}, {0x3bbb2000}, {0x3bbb4000}, {0x3bbb6000}, {0x3bbb8000}, {0x3bbba000}, {0x3bbbc000}, {0x3bbbe000}, {0x3bbc0000}, {0x3bbc2000}, {0x3bbc4000}, {0x3bbc6000}, {0x3bbc8000}, {0x3bbca000}, {0x3bbcc000}, {0x3bbce000}, {0x3bbd0000}, {0x3bbd2000}, {0x3bbd4000}, {0x3bbd6000}, {0x3bbd8000}, {0x3bbda000}, {0x3bbdc000}, {0x3bbde000}, {0x3bbe0000}, {0x3bbe2000}, {0x3bbe4000}, {0x3bbe6000}, {0x3bbe8000}, {0x3bbea000}, {0x3bbec000}, {0x3bbee000}, {0x3bbf0000}, {0x3bbf2000}, {0x3bbf4000}, {0x3bbf6000}, {0x3bbf8000}, {0x3bbfa000}, {0x3bbfc000}, {0x3bbfe000}, {0x3bc00000}, {0x3bc02000}, {0x3bc04000}, {0x3bc06000}, {0x3bc08000}, {0x3bc0a000}, {0x3bc0c000}, {0x3bc0e000}, {0x3bc10000}, {0x3bc12000}, {0x3bc14000}, {0x3bc16000}, {0x3bc18000}, {0x3bc1a000}, {0x3bc1c000}, {0x3bc1e000}, {0x3bc20000}, {0x3bc22000}, {0x3bc24000}, {0x3bc26000}, {0x3bc28000}, {0x3bc2a000}, {0x3bc2c000}, {0x3bc2e000}, {0x3bc30000}, {0x3bc32000}, {0x3bc34000}, {0x3bc36000}, {0x3bc38000}, {0x3bc3a000}, {0x3bc3c000}, {0x3bc3e000}, {0x3bc40000}, {0x3bc42000}, {0x3bc44000}, {0x3bc46000}, {0x3bc48000}, {0x3bc4a000}, {0x3bc4c000}, {0x3bc4e000}, {0x3bc50000}, {0x3bc52000}, {0x3bc54000}, {0x3bc56000}, {0x3bc58000}, {0x3bc5a000}, {0x3bc5c000}, {0x3bc5e000}, {0x3bc60000}, {0x3bc62000}, {0x3bc64000}, {0x3bc66000}, {0x3bc68000}, {0x3bc6a000}, {0x3bc6c000}, {0x3bc6e000}, {0x3bc70000}, {0x3bc72000}, {0x3bc74000}, {0x3bc76000}, {0x3bc78000}, {0x3bc7a000}, {0x3bc7c000}, {0x3bc7e000}, {0x3bc80000}, {0x3bc82000}, {0x3bc84000}, {0x3bc86000}, {0x3bc88000}, {0x3bc8a000}, {0x3bc8c000}, {0x3bc8e000}, {0x3bc90000}, {0x3bc92000}, {0x3bc94000}, {0x3bc96000}, {0x3bc98000}, {0x3bc9a000}, {0x3bc9c000}, {0x3bc9e000}, {0x3bca0000}, {0x3bca2000}, {0x3bca4000}, {0x3bca6000}, {0x3bca8000}, {0x3bcaa000}, {0x3bcac000}, {0x3bcae000}, {0x3bcb0000}, {0x3bcb2000}, {0x3bcb4000}, {0x3bcb6000}, {0x3bcb8000}, {0x3bcba000}, {0x3bcbc000}, {0x3bcbe000}, {0x3bcc0000}, {0x3bcc2000}, {0x3bcc4000}, {0x3bcc6000}, {0x3bcc8000}, {0x3bcca000}, {0x3bccc000}, {0x3bcce000}, {0x3bcd0000}, {0x3bcd2000}, {0x3bcd4000}, {0x3bcd6000}, {0x3bcd8000}, {0x3bcda000}, {0x3bcdc000}, {0x3bcde000}, {0x3bce0000}, {0x3bce2000}, {0x3bce4000}, {0x3bce6000}, {0x3bce8000}, {0x3bcea000}, {0x3bcec000}, {0x3bcee000}, {0x3bcf0000}, {0x3bcf2000}, {0x3bcf4000}, {0x3bcf6000}, {0x3bcf8000}, {0x3bcfa000}, {0x3bcfc000}, {0x3bcfe000}, {0x3bd00000}, {0x3bd02000}, {0x3bd04000}, {0x3bd06000}, {0x3bd08000}, {0x3bd0a000}, {0x3bd0c000}, {0x3bd0e000}, {0x3bd10000}, {0x3bd12000}, {0x3bd14000}, {0x3bd16000}, {0x3bd18000}, {0x3bd1a000}, {0x3bd1c000}, {0x3bd1e000}, {0x3bd20000}, {0x3bd22000}, {0x3bd24000}, {0x3bd26000}, {0x3bd28000}, {0x3bd2a000}, {0x3bd2c000}, {0x3bd2e000}, {0x3bd30000}, {0x3bd32000}, {0x3bd34000}, {0x3bd36000}, {0x3bd38000}, {0x3bd3a000}, {0x3bd3c000}, {0x3bd3e000}, {0x3bd40000}, {0x3bd42000}, {0x3bd44000}, {0x3bd46000}, {0x3bd48000}, {0x3bd4a000}, {0x3bd4c000}, {0x3bd4e000}, {0x3bd50000}, {0x3bd52000}, {0x3bd54000}, {0x3bd56000}, {0x3bd58000}, {0x3bd5a000}, {0x3bd5c000}, {0x3bd5e000}, {0x3bd60000}, {0x3bd62000}, {0x3bd64000}, {0x3bd66000}, {0x3bd68000}, {0x3bd6a000}, {0x3bd6c000}, {0x3bd6e000}, {0x3bd70000}, {0x3bd72000}, {0x3bd74000}, {0x3bd76000}, {0x3bd78000}, {0x3bd7a000}, {0x3bd7c000}, {0x3bd7e000}, {0x3bd80000}, {0x3bd82000}, {0x3bd84000}, {0x3bd86000}, {0x3bd88000}, {0x3bd8a000}, {0x3bd8c000}, {0x3bd8e000}, {0x3bd90000}, {0x3bd92000}, {0x3bd94000}, {0x3bd96000}, {0x3bd98000}, {0x3bd9a000}, {0x3bd9c000}, {0x3bd9e000}, {0x3bda0000}, {0x3bda2000}, {0x3bda4000}, {0x3bda6000}, {0x3bda8000}, {0x3bdaa000}, {0x3bdac000}, {0x3bdae000}, {0x3bdb0000}, {0x3bdb2000}, {0x3bdb4000}, {0x3bdb6000}, {0x3bdb8000}, {0x3bdba000}, {0x3bdbc000}, {0x3bdbe000}, {0x3bdc0000}, {0x3bdc2000}, {0x3bdc4000}, {0x3bdc6000}, {0x3bdc8000}, {0x3bdca000}, {0x3bdcc000}, {0x3bdce000}, {0x3bdd0000}, {0x3bdd2000}, {0x3bdd4000}, {0x3bdd6000}, {0x3bdd8000}, {0x3bdda000}, {0x3bddc000}, {0x3bdde000}, {0x3bde0000}, {0x3bde2000}, {0x3bde4000}, {0x3bde6000}, {0x3bde8000}, {0x3bdea000}, {0x3bdec000}, {0x3bdee000}, {0x3bdf0000}, {0x3bdf2000}, {0x3bdf4000}, {0x3bdf6000}, {0x3bdf8000}, {0x3bdfa000}, {0x3bdfc000}, {0x3bdfe000}, {0x3be00000}, {0x3be02000}, {0x3be04000}, {0x3be06000}, {0x3be08000}, {0x3be0a000}, {0x3be0c000}, {0x3be0e000}, {0x3be10000}, {0x3be12000}, {0x3be14000}, {0x3be16000}, {0x3be18000}, {0x3be1a000}, {0x3be1c000}, {0x3be1e000}, {0x3be20000}, {0x3be22000}, {0x3be24000}, {0x3be26000}, {0x3be28000}, {0x3be2a000}, {0x3be2c000}, {0x3be2e000}, {0x3be30000}, {0x3be32000}, {0x3be34000}, {0x3be36000}, {0x3be38000}, {0x3be3a000}, {0x3be3c000}, {0x3be3e000}, {0x3be40000}, {0x3be42000}, {0x3be44000}, {0x3be46000}, {0x3be48000}, {0x3be4a000}, {0x3be4c000}, {0x3be4e000}, {0x3be50000}, {0x3be52000}, {0x3be54000}, {0x3be56000}, {0x3be58000}, {0x3be5a000}, {0x3be5c000}, {0x3be5e000}, {0x3be60000}, {0x3be62000}, {0x3be64000}, {0x3be66000}, {0x3be68000}, {0x3be6a000}, {0x3be6c000}, {0x3be6e000}, {0x3be70000}, {0x3be72000}, {0x3be74000}, {0x3be76000}, {0x3be78000}, {0x3be7a000}, {0x3be7c000}, {0x3be7e000}, {0x3be80000}, {0x3be82000}, {0x3be84000}, {0x3be86000}, {0x3be88000}, {0x3be8a000}, {0x3be8c000}, {0x3be8e000}, {0x3be90000}, {0x3be92000}, {0x3be94000}, {0x3be96000}, {0x3be98000}, {0x3be9a000}, {0x3be9c000}, {0x3be9e000}, {0x3bea0000}, {0x3bea2000}, {0x3bea4000}, {0x3bea6000}, {0x3bea8000}, {0x3beaa000}, {0x3beac000}, {0x3beae000}, {0x3beb0000}, {0x3beb2000}, {0x3beb4000}, {0x3beb6000}, {0x3beb8000}, {0x3beba000}, {0x3bebc000}, {0x3bebe000}, {0x3bec0000}, {0x3bec2000}, {0x3bec4000}, {0x3bec6000}, {0x3bec8000}, {0x3beca000}, {0x3becc000}, {0x3bece000}, {0x3bed0000}, {0x3bed2000}, {0x3bed4000}, {0x3bed6000}, {0x3bed8000}, {0x3beda000}, {0x3bedc000}, {0x3bede000}, {0x3bee0000}, {0x3bee2000}, {0x3bee4000}, {0x3bee6000}, {0x3bee8000}, {0x3beea000}, {0x3beec000}, {0x3beee000}, {0x3bef0000}, {0x3bef2000}, {0x3bef4000}, {0x3bef6000}, {0x3bef8000}, {0x3befa000}, {0x3befc000}, {0x3befe000}, {0x3bf00000}, {0x3bf02000}, {0x3bf04000}, {0x3bf06000}, {0x3bf08000}, {0x3bf0a000}, {0x3bf0c000}, {0x3bf0e000}, {0x3bf10000}, {0x3bf12000}, {0x3bf14000}, {0x3bf16000}, {0x3bf18000}, {0x3bf1a000}, {0x3bf1c000}, {0x3bf1e000}, {0x3bf20000}, {0x3bf22000}, {0x3bf24000}, {0x3bf26000}, {0x3bf28000}, {0x3bf2a000}, {0x3bf2c000}, {0x3bf2e000}, {0x3bf30000}, {0x3bf32000}, {0x3bf34000}, {0x3bf36000}, {0x3bf38000}, {0x3bf3a000}, {0x3bf3c000}, {0x3bf3e000}, {0x3bf40000}, {0x3bf42000}, {0x3bf44000}, {0x3bf46000}, {0x3bf48000}, {0x3bf4a000}, {0x3bf4c000}, {0x3bf4e000}, {0x3bf50000}, {0x3bf52000}, {0x3bf54000}, {0x3bf56000}, {0x3bf58000}, {0x3bf5a000}, {0x3bf5c000}, {0x3bf5e000}, {0x3bf60000}, {0x3bf62000}, {0x3bf64000}, {0x3bf66000}, {0x3bf68000}, {0x3bf6a000}, {0x3bf6c000}, {0x3bf6e000}, {0x3bf70000}, {0x3bf72000}, {0x3bf74000}, {0x3bf76000}, {0x3bf78000}, {0x3bf7a000}, {0x3bf7c000}, {0x3bf7e000}, {0x3bf80000}, {0x3bf82000}, {0x3bf84000}, {0x3bf86000}, {0x3bf88000}, {0x3bf8a000}, {0x3bf8c000}, {0x3bf8e000}, {0x3bf90000}, {0x3bf92000}, {0x3bf94000}, {0x3bf96000}, {0x3bf98000}, {0x3bf9a000}, {0x3bf9c000}, {0x3bf9e000}, {0x3bfa0000}, {0x3bfa2000}, {0x3bfa4000}, {0x3bfa6000}, {0x3bfa8000}, {0x3bfaa000}, {0x3bfac000}, {0x3bfae000}, {0x3bfb0000}, {0x3bfb2000}, {0x3bfb4000}, {0x3bfb6000}, {0x3bfb8000}, {0x3bfba000}, {0x3bfbc000}, {0x3bfbe000}, {0x3bfc0000}, {0x3bfc2000}, {0x3bfc4000}, {0x3bfc6000}, {0x3bfc8000}, {0x3bfca000}, {0x3bfcc000}, {0x3bfce000}, {0x3bfd0000}, {0x3bfd2000}, {0x3bfd4000}, {0x3bfd6000}, {0x3bfd8000}, {0x3bfda000}, {0x3bfdc000}, {0x3bfde000}, {0x3bfe0000}, {0x3bfe2000}, {0x3bfe4000}, {0x3bfe6000}, {0x3bfe8000}, {0x3bfea000}, {0x3bfec000}, {0x3bfee000}, {0x3bff0000}, {0x3bff2000}, {0x3bff4000}, {0x3bff6000}, {0x3bff8000}, {0x3bffa000}, {0x3bffc000}, {0x3bffe000}, {0x3c000000}, {0x3c002000}, {0x3c004000}, {0x3c006000}, {0x3c008000}, {0x3c00a000}, {0x3c00c000}, {0x3c00e000}, {0x3c010000}, {0x3c012000}, {0x3c014000}, {0x3c016000}, {0x3c018000}, {0x3c01a000}, {0x3c01c000}, {0x3c01e000}, {0x3c020000}, {0x3c022000}, {0x3c024000}, {0x3c026000}, {0x3c028000}, {0x3c02a000}, {0x3c02c000}, {0x3c02e000}, {0x3c030000}, {0x3c032000}, {0x3c034000}, {0x3c036000}, {0x3c038000}, {0x3c03a000}, {0x3c03c000}, {0x3c03e000}, {0x3c040000}, {0x3c042000}, {0x3c044000}, {0x3c046000}, {0x3c048000}, {0x3c04a000}, {0x3c04c000}, {0x3c04e000}, {0x3c050000}, {0x3c052000}, {0x3c054000}, {0x3c056000}, {0x3c058000}, {0x3c05a000}, {0x3c05c000}, {0x3c05e000}, {0x3c060000}, {0x3c062000}, {0x3c064000}, {0x3c066000}, {0x3c068000}, {0x3c06a000}, {0x3c06c000}, {0x3c06e000}, {0x3c070000}, {0x3c072000}, {0x3c074000}, {0x3c076000}, {0x3c078000}, {0x3c07a000}, {0x3c07c000}, {0x3c07e000}, {0x3c080000}, {0x3c082000}, {0x3c084000}, {0x3c086000}, {0x3c088000}, {0x3c08a000}, {0x3c08c000}, {0x3c08e000}, {0x3c090000}, {0x3c092000}, {0x3c094000}, {0x3c096000}, {0x3c098000}, {0x3c09a000}, {0x3c09c000}, {0x3c09e000}, {0x3c0a0000}, {0x3c0a2000}, {0x3c0a4000}, {0x3c0a6000}, {0x3c0a8000}, {0x3c0aa000}, {0x3c0ac000}, {0x3c0ae000}, {0x3c0b0000}, {0x3c0b2000}, {0x3c0b4000}, {0x3c0b6000}, {0x3c0b8000}, {0x3c0ba000}, {0x3c0bc000}, {0x3c0be000}, {0x3c0c0000}, {0x3c0c2000}, {0x3c0c4000}, {0x3c0c6000}, {0x3c0c8000}, {0x3c0ca000}, {0x3c0cc000}, {0x3c0ce000}, {0x3c0d0000}, {0x3c0d2000}, {0x3c0d4000}, {0x3c0d6000}, {0x3c0d8000}, {0x3c0da000}, {0x3c0dc000}, {0x3c0de000}, {0x3c0e0000}, {0x3c0e2000}, {0x3c0e4000}, {0x3c0e6000}, {0x3c0e8000}, {0x3c0ea000}, {0x3c0ec000}, {0x3c0ee000}, {0x3c0f0000}, {0x3c0f2000}, {0x3c0f4000}, {0x3c0f6000}, {0x3c0f8000}, {0x3c0fa000}, {0x3c0fc000}, {0x3c0fe000}, {0x3c100000}, {0x3c102000}, {0x3c104000}, {0x3c106000}, {0x3c108000}, {0x3c10a000}, {0x3c10c000}, {0x3c10e000}, {0x3c110000}, {0x3c112000}, {0x3c114000}, {0x3c116000}, {0x3c118000}, {0x3c11a000}, {0x3c11c000}, {0x3c11e000}, {0x3c120000}, {0x3c122000}, {0x3c124000}, {0x3c126000}, {0x3c128000}, {0x3c12a000}, {0x3c12c000}, {0x3c12e000}, {0x3c130000}, {0x3c132000}, {0x3c134000}, {0x3c136000}, {0x3c138000}, {0x3c13a000}, {0x3c13c000}, {0x3c13e000}, {0x3c140000}, {0x3c142000}, {0x3c144000}, {0x3c146000}, {0x3c148000}, {0x3c14a000}, {0x3c14c000}, {0x3c14e000}, {0x3c150000}, {0x3c152000}, {0x3c154000}, {0x3c156000}, {0x3c158000}, {0x3c15a000}, {0x3c15c000}, {0x3c15e000}, {0x3c160000}, {0x3c162000}, {0x3c164000}, {0x3c166000}, {0x3c168000}, {0x3c16a000}, {0x3c16c000}, {0x3c16e000}, {0x3c170000}, {0x3c172000}, {0x3c174000}, {0x3c176000}, {0x3c178000}, {0x3c17a000}, {0x3c17c000}, {0x3c17e000}, {0x3c180000}, {0x3c182000}, {0x3c184000}, {0x3c186000}, {0x3c188000}, {0x3c18a000}, {0x3c18c000}, {0x3c18e000}, {0x3c190000}, {0x3c192000}, {0x3c194000}, {0x3c196000}, {0x3c198000}, {0x3c19a000}, {0x3c19c000}, {0x3c19e000}, {0x3c1a0000}, {0x3c1a2000}, {0x3c1a4000}, {0x3c1a6000}, {0x3c1a8000}, {0x3c1aa000}, {0x3c1ac000}, {0x3c1ae000}, {0x3c1b0000}, {0x3c1b2000}, {0x3c1b4000}, {0x3c1b6000}, {0x3c1b8000}, {0x3c1ba000}, {0x3c1bc000}, {0x3c1be000}, {0x3c1c0000}, {0x3c1c2000}, {0x3c1c4000}, {0x3c1c6000}, {0x3c1c8000}, {0x3c1ca000}, {0x3c1cc000}, {0x3c1ce000}, {0x3c1d0000}, {0x3c1d2000}, {0x3c1d4000}, {0x3c1d6000}, {0x3c1d8000}, {0x3c1da000}, {0x3c1dc000}, {0x3c1de000}, {0x3c1e0000}, {0x3c1e2000}, {0x3c1e4000}, {0x3c1e6000}, {0x3c1e8000}, {0x3c1ea000}, {0x3c1ec000}, {0x3c1ee000}, {0x3c1f0000}, {0x3c1f2000}, {0x3c1f4000}, {0x3c1f6000}, {0x3c1f8000}, {0x3c1fa000}, {0x3c1fc000}, {0x3c1fe000}, {0x3c200000}, {0x3c202000}, {0x3c204000}, {0x3c206000}, {0x3c208000}, {0x3c20a000}, {0x3c20c000}, {0x3c20e000}, {0x3c210000}, {0x3c212000}, {0x3c214000}, {0x3c216000}, {0x3c218000}, {0x3c21a000}, {0x3c21c000}, {0x3c21e000}, {0x3c220000}, {0x3c222000}, {0x3c224000}, {0x3c226000}, {0x3c228000}, {0x3c22a000}, {0x3c22c000}, {0x3c22e000}, {0x3c230000}, {0x3c232000}, {0x3c234000}, {0x3c236000}, {0x3c238000}, {0x3c23a000}, {0x3c23c000}, {0x3c23e000}, {0x3c240000}, {0x3c242000}, {0x3c244000}, {0x3c246000}, {0x3c248000}, {0x3c24a000}, {0x3c24c000}, {0x3c24e000}, {0x3c250000}, {0x3c252000}, {0x3c254000}, {0x3c256000}, {0x3c258000}, {0x3c25a000}, {0x3c25c000}, {0x3c25e000}, {0x3c260000}, {0x3c262000}, {0x3c264000}, {0x3c266000}, {0x3c268000}, {0x3c26a000}, {0x3c26c000}, {0x3c26e000}, {0x3c270000}, {0x3c272000}, {0x3c274000}, {0x3c276000}, {0x3c278000}, {0x3c27a000}, {0x3c27c000}, {0x3c27e000}, {0x3c280000}, {0x3c282000}, {0x3c284000}, {0x3c286000}, {0x3c288000}, {0x3c28a000}, {0x3c28c000}, {0x3c28e000}, {0x3c290000}, {0x3c292000}, {0x3c294000}, {0x3c296000}, {0x3c298000}, {0x3c29a000}, {0x3c29c000}, {0x3c29e000}, {0x3c2a0000}, {0x3c2a2000}, {0x3c2a4000}, {0x3c2a6000}, {0x3c2a8000}, {0x3c2aa000}, {0x3c2ac000}, {0x3c2ae000}, {0x3c2b0000}, {0x3c2b2000}, {0x3c2b4000}, {0x3c2b6000}, {0x3c2b8000}, {0x3c2ba000}, {0x3c2bc000}, {0x3c2be000}, {0x3c2c0000}, {0x3c2c2000}, {0x3c2c4000}, {0x3c2c6000}, {0x3c2c8000}, {0x3c2ca000}, {0x3c2cc000}, {0x3c2ce000}, {0x3c2d0000}, {0x3c2d2000}, {0x3c2d4000}, {0x3c2d6000}, {0x3c2d8000}, {0x3c2da000}, {0x3c2dc000}, {0x3c2de000}, {0x3c2e0000}, {0x3c2e2000}, {0x3c2e4000}, {0x3c2e6000}, {0x3c2e8000}, {0x3c2ea000}, {0x3c2ec000}, {0x3c2ee000}, {0x3c2f0000}, {0x3c2f2000}, {0x3c2f4000}, {0x3c2f6000}, {0x3c2f8000}, {0x3c2fa000}, {0x3c2fc000}, {0x3c2fe000}, {0x3c300000}, {0x3c302000}, {0x3c304000}, {0x3c306000}, {0x3c308000}, {0x3c30a000}, {0x3c30c000}, {0x3c30e000}, {0x3c310000}, {0x3c312000}, {0x3c314000}, {0x3c316000}, {0x3c318000}, {0x3c31a000}, {0x3c31c000}, {0x3c31e000}, {0x3c320000}, {0x3c322000}, {0x3c324000}, {0x3c326000}, {0x3c328000}, {0x3c32a000}, {0x3c32c000}, {0x3c32e000}, {0x3c330000}, {0x3c332000}, {0x3c334000}, {0x3c336000}, {0x3c338000}, {0x3c33a000}, {0x3c33c000}, {0x3c33e000}, {0x3c340000}, {0x3c342000}, {0x3c344000}, {0x3c346000}, {0x3c348000}, {0x3c34a000}, {0x3c34c000}, {0x3c34e000}, {0x3c350000}, {0x3c352000}, {0x3c354000}, {0x3c356000}, {0x3c358000}, {0x3c35a000}, {0x3c35c000}, {0x3c35e000}, {0x3c360000}, {0x3c362000}, {0x3c364000}, {0x3c366000}, {0x3c368000}, {0x3c36a000}, {0x3c36c000}, {0x3c36e000}, {0x3c370000}, {0x3c372000}, {0x3c374000}, {0x3c376000}, {0x3c378000}, {0x3c37a000}, {0x3c37c000}, {0x3c37e000}, {0x3c380000}, {0x3c382000}, {0x3c384000}, {0x3c386000}, {0x3c388000}, {0x3c38a000}, {0x3c38c000}, {0x3c38e000}, {0x3c390000}, {0x3c392000}, {0x3c394000}, {0x3c396000}, {0x3c398000}, {0x3c39a000}, {0x3c39c000}, {0x3c39e000}, {0x3c3a0000}, {0x3c3a2000}, {0x3c3a4000}, {0x3c3a6000}, {0x3c3a8000}, {0x3c3aa000}, {0x3c3ac000}, {0x3c3ae000}, {0x3c3b0000}, {0x3c3b2000}, {0x3c3b4000}, {0x3c3b6000}, {0x3c3b8000}, {0x3c3ba000}, {0x3c3bc000}, {0x3c3be000}, {0x3c3c0000}, {0x3c3c2000}, {0x3c3c4000}, {0x3c3c6000}, {0x3c3c8000}, {0x3c3ca000}, {0x3c3cc000}, {0x3c3ce000}, {0x3c3d0000}, {0x3c3d2000}, {0x3c3d4000}, {0x3c3d6000}, {0x3c3d8000}, {0x3c3da000}, {0x3c3dc000}, {0x3c3de000}, {0x3c3e0000}, {0x3c3e2000}, {0x3c3e4000}, {0x3c3e6000}, {0x3c3e8000}, {0x3c3ea000}, {0x3c3ec000}, {0x3c3ee000}, {0x3c3f0000}, {0x3c3f2000}, {0x3c3f4000}, {0x3c3f6000}, {0x3c3f8000}, {0x3c3fa000}, {0x3c3fc000}, {0x3c3fe000}, {0x3c400000}, {0x3c402000}, {0x3c404000}, {0x3c406000}, {0x3c408000}, {0x3c40a000}, {0x3c40c000}, {0x3c40e000}, {0x3c410000}, {0x3c412000}, {0x3c414000}, {0x3c416000}, {0x3c418000}, {0x3c41a000}, {0x3c41c000}, {0x3c41e000}, {0x3c420000}, {0x3c422000}, {0x3c424000}, {0x3c426000}, {0x3c428000}, {0x3c42a000}, {0x3c42c000}, {0x3c42e000}, {0x3c430000}, {0x3c432000}, {0x3c434000}, {0x3c436000}, {0x3c438000}, {0x3c43a000}, {0x3c43c000}, {0x3c43e000}, {0x3c440000}, {0x3c442000}, {0x3c444000}, {0x3c446000}, {0x3c448000}, {0x3c44a000}, {0x3c44c000}, {0x3c44e000}, {0x3c450000}, {0x3c452000}, {0x3c454000}, {0x3c456000}, {0x3c458000}, {0x3c45a000}, {0x3c45c000}, {0x3c45e000}, {0x3c460000}, {0x3c462000}, {0x3c464000}, {0x3c466000}, {0x3c468000}, {0x3c46a000}, {0x3c46c000}, {0x3c46e000}, {0x3c470000}, {0x3c472000}, {0x3c474000}, {0x3c476000}, {0x3c478000}, {0x3c47a000}, {0x3c47c000}, {0x3c47e000}, {0x3c480000}, {0x3c482000}, {0x3c484000}, {0x3c486000}, {0x3c488000}, {0x3c48a000}, {0x3c48c000}, {0x3c48e000}, {0x3c490000}, {0x3c492000}, {0x3c494000}, {0x3c496000}, {0x3c498000}, {0x3c49a000}, {0x3c49c000}, {0x3c49e000}, {0x3c4a0000}, {0x3c4a2000}, {0x3c4a4000}, {0x3c4a6000}, {0x3c4a8000}, {0x3c4aa000}, {0x3c4ac000}, {0x3c4ae000}, {0x3c4b0000}, {0x3c4b2000}, {0x3c4b4000}, {0x3c4b6000}, {0x3c4b8000}, {0x3c4ba000}, {0x3c4bc000}, {0x3c4be000}, {0x3c4c0000}, {0x3c4c2000}, {0x3c4c4000}, {0x3c4c6000}, {0x3c4c8000}, {0x3c4ca000}, {0x3c4cc000}, {0x3c4ce000}, {0x3c4d0000}, {0x3c4d2000}, {0x3c4d4000}, {0x3c4d6000}, {0x3c4d8000}, {0x3c4da000}, {0x3c4dc000}, {0x3c4de000}, {0x3c4e0000}, {0x3c4e2000}, {0x3c4e4000}, {0x3c4e6000}, {0x3c4e8000}, {0x3c4ea000}, {0x3c4ec000}, {0x3c4ee000}, {0x3c4f0000}, {0x3c4f2000}, {0x3c4f4000}, {0x3c4f6000}, {0x3c4f8000}, {0x3c4fa000}, {0x3c4fc000}, {0x3c4fe000}, {0x3c500000}, {0x3c502000}, {0x3c504000}, {0x3c506000}, {0x3c508000}, {0x3c50a000}, {0x3c50c000}, {0x3c50e000}, {0x3c510000}, {0x3c512000}, {0x3c514000}, {0x3c516000}, {0x3c518000}, {0x3c51a000}, {0x3c51c000}, {0x3c51e000}, {0x3c520000}, {0x3c522000}, {0x3c524000}, {0x3c526000}, {0x3c528000}, {0x3c52a000}, {0x3c52c000}, {0x3c52e000}, {0x3c530000}, {0x3c532000}, {0x3c534000}, {0x3c536000}, {0x3c538000}, {0x3c53a000}, {0x3c53c000}, {0x3c53e000}, {0x3c540000}, {0x3c542000}, {0x3c544000}, {0x3c546000}, {0x3c548000}, {0x3c54a000}, {0x3c54c000}, {0x3c54e000}, {0x3c550000}, {0x3c552000}, {0x3c554000}, {0x3c556000}, {0x3c558000}, {0x3c55a000}, {0x3c55c000}, {0x3c55e000}, {0x3c560000}, {0x3c562000}, {0x3c564000}, {0x3c566000}, {0x3c568000}, {0x3c56a000}, {0x3c56c000}, {0x3c56e000}, {0x3c570000}, {0x3c572000}, {0x3c574000}, {0x3c576000}, {0x3c578000}, {0x3c57a000}, {0x3c57c000}, {0x3c57e000}, {0x3c580000}, {0x3c582000}, {0x3c584000}, {0x3c586000}, {0x3c588000}, {0x3c58a000}, {0x3c58c000}, {0x3c58e000}, {0x3c590000}, {0x3c592000}, {0x3c594000}, {0x3c596000}, {0x3c598000}, {0x3c59a000}, {0x3c59c000}, {0x3c59e000}, {0x3c5a0000}, {0x3c5a2000}, {0x3c5a4000}, {0x3c5a6000}, {0x3c5a8000}, {0x3c5aa000}, {0x3c5ac000}, {0x3c5ae000}, {0x3c5b0000}, {0x3c5b2000}, {0x3c5b4000}, {0x3c5b6000}, {0x3c5b8000}, {0x3c5ba000}, {0x3c5bc000}, {0x3c5be000}, {0x3c5c0000}, {0x3c5c2000}, {0x3c5c4000}, {0x3c5c6000}, {0x3c5c8000}, {0x3c5ca000}, {0x3c5cc000}, {0x3c5ce000}, {0x3c5d0000}, {0x3c5d2000}, {0x3c5d4000}, {0x3c5d6000}, {0x3c5d8000}, {0x3c5da000}, {0x3c5dc000}, {0x3c5de000}, {0x3c5e0000}, {0x3c5e2000}, {0x3c5e4000}, {0x3c5e6000}, {0x3c5e8000}, {0x3c5ea000}, {0x3c5ec000}, {0x3c5ee000}, {0x3c5f0000}, {0x3c5f2000}, {0x3c5f4000}, {0x3c5f6000}, {0x3c5f8000}, {0x3c5fa000}, {0x3c5fc000}, {0x3c5fe000}, {0x3c600000}, {0x3c602000}, {0x3c604000}, {0x3c606000}, {0x3c608000}, {0x3c60a000}, {0x3c60c000}, {0x3c60e000}, {0x3c610000}, {0x3c612000}, {0x3c614000}, {0x3c616000}, {0x3c618000}, {0x3c61a000}, {0x3c61c000}, {0x3c61e000}, {0x3c620000}, {0x3c622000}, {0x3c624000}, {0x3c626000}, {0x3c628000}, {0x3c62a000}, {0x3c62c000}, {0x3c62e000}, {0x3c630000}, {0x3c632000}, {0x3c634000}, {0x3c636000}, {0x3c638000}, {0x3c63a000}, {0x3c63c000}, {0x3c63e000}, {0x3c640000}, {0x3c642000}, {0x3c644000}, {0x3c646000}, {0x3c648000}, {0x3c64a000}, {0x3c64c000}, {0x3c64e000}, {0x3c650000}, {0x3c652000}, {0x3c654000}, {0x3c656000}, {0x3c658000}, {0x3c65a000}, {0x3c65c000}, {0x3c65e000}, {0x3c660000}, {0x3c662000}, {0x3c664000}, {0x3c666000}, {0x3c668000}, {0x3c66a000}, {0x3c66c000}, {0x3c66e000}, {0x3c670000}, {0x3c672000}, {0x3c674000}, {0x3c676000}, {0x3c678000}, {0x3c67a000}, {0x3c67c000}, {0x3c67e000}, {0x3c680000}, {0x3c682000}, {0x3c684000}, {0x3c686000}, {0x3c688000}, {0x3c68a000}, {0x3c68c000}, {0x3c68e000}, {0x3c690000}, {0x3c692000}, {0x3c694000}, {0x3c696000}, {0x3c698000}, {0x3c69a000}, {0x3c69c000}, {0x3c69e000}, {0x3c6a0000}, {0x3c6a2000}, {0x3c6a4000}, {0x3c6a6000}, {0x3c6a8000}, {0x3c6aa000}, {0x3c6ac000}, {0x3c6ae000}, {0x3c6b0000}, {0x3c6b2000}, {0x3c6b4000}, {0x3c6b6000}, {0x3c6b8000}, {0x3c6ba000}, {0x3c6bc000}, {0x3c6be000}, {0x3c6c0000}, {0x3c6c2000}, {0x3c6c4000}, {0x3c6c6000}, {0x3c6c8000}, {0x3c6ca000}, {0x3c6cc000}, {0x3c6ce000}, {0x3c6d0000}, {0x3c6d2000}, {0x3c6d4000}, {0x3c6d6000}, {0x3c6d8000}, {0x3c6da000}, {0x3c6dc000}, {0x3c6de000}, {0x3c6e0000}, {0x3c6e2000}, {0x3c6e4000}, {0x3c6e6000}, {0x3c6e8000}, {0x3c6ea000}, {0x3c6ec000}, {0x3c6ee000}, {0x3c6f0000}, {0x3c6f2000}, {0x3c6f4000}, {0x3c6f6000}, {0x3c6f8000}, {0x3c6fa000}, {0x3c6fc000}, {0x3c6fe000}, {0x3c700000}, {0x3c702000}, {0x3c704000}, {0x3c706000}, {0x3c708000}, {0x3c70a000}, {0x3c70c000}, {0x3c70e000}, {0x3c710000}, {0x3c712000}, {0x3c714000}, {0x3c716000}, {0x3c718000}, {0x3c71a000}, {0x3c71c000}, {0x3c71e000}, {0x3c720000}, {0x3c722000}, {0x3c724000}, {0x3c726000}, {0x3c728000}, {0x3c72a000}, {0x3c72c000}, {0x3c72e000}, {0x3c730000}, {0x3c732000}, {0x3c734000}, {0x3c736000}, {0x3c738000}, {0x3c73a000}, {0x3c73c000}, {0x3c73e000}, {0x3c740000}, {0x3c742000}, {0x3c744000}, {0x3c746000}, {0x3c748000}, {0x3c74a000}, {0x3c74c000}, {0x3c74e000}, {0x3c750000}, {0x3c752000}, {0x3c754000}, {0x3c756000}, {0x3c758000}, {0x3c75a000}, {0x3c75c000}, {0x3c75e000}, {0x3c760000}, {0x3c762000}, {0x3c764000}, {0x3c766000}, {0x3c768000}, {0x3c76a000}, {0x3c76c000}, {0x3c76e000}, {0x3c770000}, {0x3c772000}, {0x3c774000}, {0x3c776000}, {0x3c778000}, {0x3c77a000}, {0x3c77c000}, {0x3c77e000}, {0x3c780000}, {0x3c782000}, {0x3c784000}, {0x3c786000}, {0x3c788000}, {0x3c78a000}, {0x3c78c000}, {0x3c78e000}, {0x3c790000}, {0x3c792000}, {0x3c794000}, {0x3c796000}, {0x3c798000}, {0x3c79a000}, {0x3c79c000}, {0x3c79e000}, {0x3c7a0000}, {0x3c7a2000}, {0x3c7a4000}, {0x3c7a6000}, {0x3c7a8000}, {0x3c7aa000}, {0x3c7ac000}, {0x3c7ae000}, {0x3c7b0000}, {0x3c7b2000}, {0x3c7b4000}, {0x3c7b6000}, {0x3c7b8000}, {0x3c7ba000}, {0x3c7bc000}, {0x3c7be000}, {0x3c7c0000}, {0x3c7c2000}, {0x3c7c4000}, {0x3c7c6000}, {0x3c7c8000}, {0x3c7ca000}, {0x3c7cc000}, {0x3c7ce000}, {0x3c7d0000}, {0x3c7d2000}, {0x3c7d4000}, {0x3c7d6000}, {0x3c7d8000}, {0x3c7da000}, {0x3c7dc000}, {0x3c7de000}, {0x3c7e0000}, {0x3c7e2000}, {0x3c7e4000}, {0x3c7e6000}, {0x3c7e8000}, {0x3c7ea000}, {0x3c7ec000}, {0x3c7ee000}, {0x3c7f0000}, {0x3c7f2000}, {0x3c7f4000}, {0x3c7f6000}, {0x3c7f8000}, {0x3c7fa000}, {0x3c7fc000}, {0x3c7fe000}, {0x3c800000}, {0x3c802000}, {0x3c804000}, {0x3c806000}, {0x3c808000}, {0x3c80a000}, {0x3c80c000}, {0x3c80e000}, {0x3c810000}, {0x3c812000}, {0x3c814000}, {0x3c816000}, {0x3c818000}, {0x3c81a000}, {0x3c81c000}, {0x3c81e000}, {0x3c820000}, {0x3c822000}, {0x3c824000}, {0x3c826000}, {0x3c828000}, {0x3c82a000}, {0x3c82c000}, {0x3c82e000}, {0x3c830000}, {0x3c832000}, {0x3c834000}, {0x3c836000}, {0x3c838000}, {0x3c83a000}, {0x3c83c000}, {0x3c83e000}, {0x3c840000}, {0x3c842000}, {0x3c844000}, {0x3c846000}, {0x3c848000}, {0x3c84a000}, {0x3c84c000}, {0x3c84e000}, {0x3c850000}, {0x3c852000}, {0x3c854000}, {0x3c856000}, {0x3c858000}, {0x3c85a000}, {0x3c85c000}, {0x3c85e000}, {0x3c860000}, {0x3c862000}, {0x3c864000}, {0x3c866000}, {0x3c868000}, {0x3c86a000}, {0x3c86c000}, {0x3c86e000}, {0x3c870000}, {0x3c872000}, {0x3c874000}, {0x3c876000}, {0x3c878000}, {0x3c87a000}, {0x3c87c000}, {0x3c87e000}, {0x3c880000}, {0x3c882000}, {0x3c884000}, {0x3c886000}, {0x3c888000}, {0x3c88a000}, {0x3c88c000}, {0x3c88e000}, {0x3c890000}, {0x3c892000}, {0x3c894000}, {0x3c896000}, {0x3c898000}, {0x3c89a000}, {0x3c89c000}, {0x3c89e000}, {0x3c8a0000}, {0x3c8a2000}, {0x3c8a4000}, {0x3c8a6000}, {0x3c8a8000}, {0x3c8aa000}, {0x3c8ac000}, {0x3c8ae000}, {0x3c8b0000}, {0x3c8b2000}, {0x3c8b4000}, {0x3c8b6000}, {0x3c8b8000}, {0x3c8ba000}, {0x3c8bc000}, {0x3c8be000}, {0x3c8c0000}, {0x3c8c2000}, {0x3c8c4000}, {0x3c8c6000}, {0x3c8c8000}, {0x3c8ca000}, {0x3c8cc000}, {0x3c8ce000}, {0x3c8d0000}, {0x3c8d2000}, {0x3c8d4000}, {0x3c8d6000}, {0x3c8d8000}, {0x3c8da000}, {0x3c8dc000}, {0x3c8de000}, {0x3c8e0000}, {0x3c8e2000}, {0x3c8e4000}, {0x3c8e6000}, {0x3c8e8000}, {0x3c8ea000}, {0x3c8ec000}, {0x3c8ee000}, {0x3c8f0000}, {0x3c8f2000}, {0x3c8f4000}, {0x3c8f6000}, {0x3c8f8000}, {0x3c8fa000}, {0x3c8fc000}, {0x3c8fe000}, {0x3c900000}, {0x3c902000}, {0x3c904000}, {0x3c906000}, {0x3c908000}, {0x3c90a000}, {0x3c90c000}, {0x3c90e000}, {0x3c910000}, {0x3c912000}, {0x3c914000}, {0x3c916000}, {0x3c918000}, {0x3c91a000}, {0x3c91c000}, {0x3c91e000}, {0x3c920000}, {0x3c922000}, {0x3c924000}, {0x3c926000}, {0x3c928000}, {0x3c92a000}, {0x3c92c000}, {0x3c92e000}, {0x3c930000}, {0x3c932000}, {0x3c934000}, {0x3c936000}, {0x3c938000}, {0x3c93a000}, {0x3c93c000}, {0x3c93e000}, {0x3c940000}, {0x3c942000}, {0x3c944000}, {0x3c946000}, {0x3c948000}, {0x3c94a000}, {0x3c94c000}, {0x3c94e000}, {0x3c950000}, {0x3c952000}, {0x3c954000}, {0x3c956000}, {0x3c958000}, {0x3c95a000}, {0x3c95c000}, {0x3c95e000}, {0x3c960000}, {0x3c962000}, {0x3c964000}, {0x3c966000}, {0x3c968000}, {0x3c96a000}, {0x3c96c000}, {0x3c96e000}, {0x3c970000}, {0x3c972000}, {0x3c974000}, {0x3c976000}, {0x3c978000}, {0x3c97a000}, {0x3c97c000}, {0x3c97e000}, {0x3c980000}, {0x3c982000}, {0x3c984000}, {0x3c986000}, {0x3c988000}, {0x3c98a000}, {0x3c98c000}, {0x3c98e000}, {0x3c990000}, {0x3c992000}, {0x3c994000}, {0x3c996000}, {0x3c998000}, {0x3c99a000}, {0x3c99c000}, {0x3c99e000}, {0x3c9a0000}, {0x3c9a2000}, {0x3c9a4000}, {0x3c9a6000}, {0x3c9a8000}, {0x3c9aa000}, {0x3c9ac000}, {0x3c9ae000}, {0x3c9b0000}, {0x3c9b2000}, {0x3c9b4000}, {0x3c9b6000}, {0x3c9b8000}, {0x3c9ba000}, {0x3c9bc000}, {0x3c9be000}, {0x3c9c0000}, {0x3c9c2000}, {0x3c9c4000}, {0x3c9c6000}, {0x3c9c8000}, {0x3c9ca000}, {0x3c9cc000}, {0x3c9ce000}, {0x3c9d0000}, {0x3c9d2000}, {0x3c9d4000}, {0x3c9d6000}, {0x3c9d8000}, {0x3c9da000}, {0x3c9dc000}, {0x3c9de000}, {0x3c9e0000}, {0x3c9e2000}, {0x3c9e4000}, {0x3c9e6000}, {0x3c9e8000}, {0x3c9ea000}, {0x3c9ec000}, {0x3c9ee000}, {0x3c9f0000}, {0x3c9f2000}, {0x3c9f4000}, {0x3c9f6000}, {0x3c9f8000}, {0x3c9fa000}, {0x3c9fc000}, {0x3c9fe000}, {0x3ca00000}, {0x3ca02000}, {0x3ca04000}, {0x3ca06000}, {0x3ca08000}, {0x3ca0a000}, {0x3ca0c000}, {0x3ca0e000}, {0x3ca10000}, {0x3ca12000}, {0x3ca14000}, {0x3ca16000}, {0x3ca18000}, {0x3ca1a000}, {0x3ca1c000}, {0x3ca1e000}, {0x3ca20000}, {0x3ca22000}, {0x3ca24000}, {0x3ca26000}, {0x3ca28000}, {0x3ca2a000}, {0x3ca2c000}, {0x3ca2e000}, {0x3ca30000}, {0x3ca32000}, {0x3ca34000}, {0x3ca36000}, {0x3ca38000}, {0x3ca3a000}, {0x3ca3c000}, {0x3ca3e000}, {0x3ca40000}, {0x3ca42000}, {0x3ca44000}, {0x3ca46000}, {0x3ca48000}, {0x3ca4a000}, {0x3ca4c000}, {0x3ca4e000}, {0x3ca50000}, {0x3ca52000}, {0x3ca54000}, {0x3ca56000}, {0x3ca58000}, {0x3ca5a000}, {0x3ca5c000}, {0x3ca5e000}, {0x3ca60000}, {0x3ca62000}, {0x3ca64000}, {0x3ca66000}, {0x3ca68000}, {0x3ca6a000}, {0x3ca6c000}, {0x3ca6e000}, {0x3ca70000}, {0x3ca72000}, {0x3ca74000}, {0x3ca76000}, {0x3ca78000}, {0x3ca7a000}, {0x3ca7c000}, {0x3ca7e000}, {0x3ca80000}, {0x3ca82000}, {0x3ca84000}, {0x3ca86000}, {0x3ca88000}, {0x3ca8a000}, {0x3ca8c000}, {0x3ca8e000}, {0x3ca90000}, {0x3ca92000}, {0x3ca94000}, {0x3ca96000}, {0x3ca98000}, {0x3ca9a000}, {0x3ca9c000}, {0x3ca9e000}, {0x3caa0000}, {0x3caa2000}, {0x3caa4000}, {0x3caa6000}, {0x3caa8000}, {0x3caaa000}, {0x3caac000}, {0x3caae000}, {0x3cab0000}, {0x3cab2000}, {0x3cab4000}, {0x3cab6000}, {0x3cab8000}, {0x3caba000}, {0x3cabc000}, {0x3cabe000}, {0x3cac0000}, {0x3cac2000}, {0x3cac4000}, {0x3cac6000}, {0x3cac8000}, {0x3caca000}, {0x3cacc000}, {0x3cace000}, {0x3cad0000}, {0x3cad2000}, {0x3cad4000}, {0x3cad6000}, {0x3cad8000}, {0x3cada000}, {0x3cadc000}, {0x3cade000}, {0x3cae0000}, {0x3cae2000}, {0x3cae4000}, {0x3cae6000}, {0x3cae8000}, {0x3caea000}, {0x3caec000}, {0x3caee000}, {0x3caf0000}, {0x3caf2000}, {0x3caf4000}, {0x3caf6000}, {0x3caf8000}, {0x3cafa000}, {0x3cafc000}, {0x3cafe000}, {0x3cb00000}, {0x3cb02000}, {0x3cb04000}, {0x3cb06000}, {0x3cb08000}, {0x3cb0a000}, {0x3cb0c000}, {0x3cb0e000}, {0x3cb10000}, {0x3cb12000}, {0x3cb14000}, {0x3cb16000}, {0x3cb18000}, {0x3cb1a000}, {0x3cb1c000}, {0x3cb1e000}, {0x3cb20000}, {0x3cb22000}, {0x3cb24000}, {0x3cb26000}, {0x3cb28000}, {0x3cb2a000}, {0x3cb2c000}, {0x3cb2e000}, {0x3cb30000}, {0x3cb32000}, {0x3cb34000}, {0x3cb36000}, {0x3cb38000}, {0x3cb3a000}, {0x3cb3c000}, {0x3cb3e000}, {0x3cb40000}, {0x3cb42000}, {0x3cb44000}, {0x3cb46000}, {0x3cb48000}, {0x3cb4a000}, {0x3cb4c000}, {0x3cb4e000}, {0x3cb50000}, {0x3cb52000}, {0x3cb54000}, {0x3cb56000}, {0x3cb58000}, {0x3cb5a000}, {0x3cb5c000}, {0x3cb5e000}, {0x3cb60000}, {0x3cb62000}, {0x3cb64000}, {0x3cb66000}, {0x3cb68000}, {0x3cb6a000}, {0x3cb6c000}, {0x3cb6e000}, {0x3cb70000}, {0x3cb72000}, {0x3cb74000}, {0x3cb76000}, {0x3cb78000}, {0x3cb7a000}, {0x3cb7c000}, {0x3cb7e000}, {0x3cb80000}, {0x3cb82000}, {0x3cb84000}, {0x3cb86000}, {0x3cb88000}, {0x3cb8a000}, {0x3cb8c000}, {0x3cb8e000}, {0x3cb90000}, {0x3cb92000}, {0x3cb94000}, {0x3cb96000}, {0x3cb98000}, {0x3cb9a000}, {0x3cb9c000}, {0x3cb9e000}, {0x3cba0000}, {0x3cba2000}, {0x3cba4000}, {0x3cba6000}, {0x3cba8000}, {0x3cbaa000}, {0x3cbac000}, {0x3cbae000}, {0x3cbb0000}, {0x3cbb2000}, {0x3cbb4000}, {0x3cbb6000}, {0x3cbb8000}, {0x3cbba000}, {0x3cbbc000}, {0x3cbbe000}, {0x3cbc0000}, {0x3cbc2000}, {0x3cbc4000}, {0x3cbc6000}, {0x3cbc8000}, {0x3cbca000}, {0x3cbcc000}, {0x3cbce000}, {0x3cbd0000}, {0x3cbd2000}, {0x3cbd4000}, {0x3cbd6000}, {0x3cbd8000}, {0x3cbda000}, {0x3cbdc000}, {0x3cbde000}, {0x3cbe0000}, {0x3cbe2000}, {0x3cbe4000}, {0x3cbe6000}, {0x3cbe8000}, {0x3cbea000}, {0x3cbec000}, {0x3cbee000}, {0x3cbf0000}, {0x3cbf2000}, {0x3cbf4000}, {0x3cbf6000}, {0x3cbf8000}, {0x3cbfa000}, {0x3cbfc000}, {0x3cbfe000}, {0x3cc00000}, {0x3cc02000}, {0x3cc04000}, {0x3cc06000}, {0x3cc08000}, {0x3cc0a000}, {0x3cc0c000}, {0x3cc0e000}, {0x3cc10000}, {0x3cc12000}, {0x3cc14000}, {0x3cc16000}, {0x3cc18000}, {0x3cc1a000}, {0x3cc1c000}, {0x3cc1e000}, {0x3cc20000}, {0x3cc22000}, {0x3cc24000}, {0x3cc26000}, {0x3cc28000}, {0x3cc2a000}, {0x3cc2c000}, {0x3cc2e000}, {0x3cc30000}, {0x3cc32000}, {0x3cc34000}, {0x3cc36000}, {0x3cc38000}, {0x3cc3a000}, {0x3cc3c000}, {0x3cc3e000}, {0x3cc40000}, {0x3cc42000}, {0x3cc44000}, {0x3cc46000}, {0x3cc48000}, {0x3cc4a000}, {0x3cc4c000}, {0x3cc4e000}, {0x3cc50000}, {0x3cc52000}, {0x3cc54000}, {0x3cc56000}, {0x3cc58000}, {0x3cc5a000}, {0x3cc5c000}, {0x3cc5e000}, {0x3cc60000}, {0x3cc62000}, {0x3cc64000}, {0x3cc66000}, {0x3cc68000}, {0x3cc6a000}, {0x3cc6c000}, {0x3cc6e000}, {0x3cc70000}, {0x3cc72000}, {0x3cc74000}, {0x3cc76000}, {0x3cc78000}, {0x3cc7a000}, {0x3cc7c000}, {0x3cc7e000}, {0x3cc80000}, {0x3cc82000}, {0x3cc84000}, {0x3cc86000}, {0x3cc88000}, {0x3cc8a000}, {0x3cc8c000}, {0x3cc8e000}, {0x3cc90000}, {0x3cc92000}, {0x3cc94000}, {0x3cc96000}, {0x3cc98000}, {0x3cc9a000}, {0x3cc9c000}, {0x3cc9e000}, {0x3cca0000}, {0x3cca2000}, {0x3cca4000}, {0x3cca6000}, {0x3cca8000}, {0x3ccaa000}, {0x3ccac000}, {0x3ccae000}, {0x3ccb0000}, {0x3ccb2000}, {0x3ccb4000}, {0x3ccb6000}, {0x3ccb8000}, {0x3ccba000}, {0x3ccbc000}, {0x3ccbe000}, {0x3ccc0000}, {0x3ccc2000}, {0x3ccc4000}, {0x3ccc6000}, {0x3ccc8000}, {0x3ccca000}, {0x3cccc000}, {0x3ccce000}, {0x3ccd0000}, {0x3ccd2000}, {0x3ccd4000}, {0x3ccd6000}, {0x3ccd8000}, {0x3ccda000}, {0x3ccdc000}, {0x3ccde000}, {0x3cce0000}, {0x3cce2000}, {0x3cce4000}, {0x3cce6000}, {0x3cce8000}, {0x3ccea000}, {0x3ccec000}, {0x3ccee000}, {0x3ccf0000}, {0x3ccf2000}, {0x3ccf4000}, {0x3ccf6000}, {0x3ccf8000}, {0x3ccfa000}, {0x3ccfc000}, {0x3ccfe000}, {0x3cd00000}, {0x3cd02000}, {0x3cd04000}, {0x3cd06000}, {0x3cd08000}, {0x3cd0a000}, {0x3cd0c000}, {0x3cd0e000}, {0x3cd10000}, {0x3cd12000}, {0x3cd14000}, {0x3cd16000}, {0x3cd18000}, {0x3cd1a000}, {0x3cd1c000}, {0x3cd1e000}, {0x3cd20000}, {0x3cd22000}, {0x3cd24000}, {0x3cd26000}, {0x3cd28000}, {0x3cd2a000}, {0x3cd2c000}, {0x3cd2e000}, {0x3cd30000}, {0x3cd32000}, {0x3cd34000}, {0x3cd36000}, {0x3cd38000}, {0x3cd3a000}, {0x3cd3c000}, {0x3cd3e000}, {0x3cd40000}, {0x3cd42000}, {0x3cd44000}, {0x3cd46000}, {0x3cd48000}, {0x3cd4a000}, {0x3cd4c000}, {0x3cd4e000}, {0x3cd50000}, {0x3cd52000}, {0x3cd54000}, {0x3cd56000}, {0x3cd58000}, {0x3cd5a000}, {0x3cd5c000}, {0x3cd5e000}, {0x3cd60000}, {0x3cd62000}, {0x3cd64000}, {0x3cd66000}, {0x3cd68000}, {0x3cd6a000}, {0x3cd6c000}, {0x3cd6e000}, {0x3cd70000}, {0x3cd72000}, {0x3cd74000}, {0x3cd76000}, {0x3cd78000}, {0x3cd7a000}, {0x3cd7c000}, {0x3cd7e000}, {0x3cd80000}, {0x3cd82000}, {0x3cd84000}, {0x3cd86000}, {0x3cd88000}, {0x3cd8a000}, {0x3cd8c000}, {0x3cd8e000}, {0x3cd90000}, {0x3cd92000}, {0x3cd94000}, {0x3cd96000}, {0x3cd98000}, {0x3cd9a000}, {0x3cd9c000}, {0x3cd9e000}, {0x3cda0000}, {0x3cda2000}, {0x3cda4000}, {0x3cda6000}, {0x3cda8000}, {0x3cdaa000}, {0x3cdac000}, {0x3cdae000}, {0x3cdb0000}, {0x3cdb2000}, {0x3cdb4000}, {0x3cdb6000}, {0x3cdb8000}, {0x3cdba000}, {0x3cdbc000}, {0x3cdbe000}, {0x3cdc0000}, {0x3cdc2000}, {0x3cdc4000}, {0x3cdc6000}, {0x3cdc8000}, {0x3cdca000}, {0x3cdcc000}, {0x3cdce000}, {0x3cdd0000}, {0x3cdd2000}, {0x3cdd4000}, {0x3cdd6000}, {0x3cdd8000}, {0x3cdda000}, {0x3cddc000}, {0x3cdde000}, {0x3cde0000}, {0x3cde2000}, {0x3cde4000}, {0x3cde6000}, {0x3cde8000}, {0x3cdea000}, {0x3cdec000}, {0x3cdee000}, {0x3cdf0000}, {0x3cdf2000}, {0x3cdf4000}, {0x3cdf6000}, {0x3cdf8000}, {0x3cdfa000}, {0x3cdfc000}, {0x3cdfe000}, {0x3ce00000}, {0x3ce02000}, {0x3ce04000}, {0x3ce06000}, {0x3ce08000}, {0x3ce0a000}, {0x3ce0c000}, {0x3ce0e000}, {0x3ce10000}, {0x3ce12000}, {0x3ce14000}, {0x3ce16000}, {0x3ce18000}, {0x3ce1a000}, {0x3ce1c000}, {0x3ce1e000}, {0x3ce20000}, {0x3ce22000}, {0x3ce24000}, {0x3ce26000}, {0x3ce28000}, {0x3ce2a000}, {0x3ce2c000}, {0x3ce2e000}, {0x3ce30000}, {0x3ce32000}, {0x3ce34000}, {0x3ce36000}, {0x3ce38000}, {0x3ce3a000}, {0x3ce3c000}, {0x3ce3e000}, {0x3ce40000}, {0x3ce42000}, {0x3ce44000}, {0x3ce46000}, {0x3ce48000}, {0x3ce4a000}, {0x3ce4c000}, {0x3ce4e000}, {0x3ce50000}, {0x3ce52000}, {0x3ce54000}, {0x3ce56000}, {0x3ce58000}, {0x3ce5a000}, {0x3ce5c000}, {0x3ce5e000}, {0x3ce60000}, {0x3ce62000}, {0x3ce64000}, {0x3ce66000}, {0x3ce68000}, {0x3ce6a000}, {0x3ce6c000}, {0x3ce6e000}, {0x3ce70000}, {0x3ce72000}, {0x3ce74000}, {0x3ce76000}, {0x3ce78000}, {0x3ce7a000}, {0x3ce7c000}, {0x3ce7e000}, {0x3ce80000}, {0x3ce82000}, {0x3ce84000}, {0x3ce86000}, {0x3ce88000}, {0x3ce8a000}, {0x3ce8c000}, {0x3ce8e000}, {0x3ce90000}, {0x3ce92000}, {0x3ce94000}, {0x3ce96000}, {0x3ce98000}, {0x3ce9a000}, {0x3ce9c000}, {0x3ce9e000}, {0x3cea0000}, {0x3cea2000}, {0x3cea4000}, {0x3cea6000}, {0x3cea8000}, {0x3ceaa000}, {0x3ceac000}, {0x3ceae000}, {0x3ceb0000}, {0x3ceb2000}, {0x3ceb4000}, {0x3ceb6000}, {0x3ceb8000}, {0x3ceba000}, {0x3cebc000}, {0x3cebe000}, {0x3cec0000}, {0x3cec2000}, {0x3cec4000}, {0x3cec6000}, {0x3cec8000}, {0x3ceca000}, {0x3cecc000}, {0x3cece000}, {0x3ced0000}, {0x3ced2000}, {0x3ced4000}, {0x3ced6000}, {0x3ced8000}, {0x3ceda000}, {0x3cedc000}, {0x3cede000}, {0x3cee0000}, {0x3cee2000}, {0x3cee4000}, {0x3cee6000}, {0x3cee8000}, {0x3ceea000}, {0x3ceec000}, {0x3ceee000}, {0x3cef0000}, {0x3cef2000}, {0x3cef4000}, {0x3cef6000}, {0x3cef8000}, {0x3cefa000}, {0x3cefc000}, {0x3cefe000}, {0x3cf00000}, {0x3cf02000}, {0x3cf04000}, {0x3cf06000}, {0x3cf08000}, {0x3cf0a000}, {0x3cf0c000}, {0x3cf0e000}, {0x3cf10000}, {0x3cf12000}, {0x3cf14000}, {0x3cf16000}, {0x3cf18000}, {0x3cf1a000}, {0x3cf1c000}, {0x3cf1e000}, {0x3cf20000}, {0x3cf22000}, {0x3cf24000}, {0x3cf26000}, {0x3cf28000}, {0x3cf2a000}, {0x3cf2c000}, {0x3cf2e000}, {0x3cf30000}, {0x3cf32000}, {0x3cf34000}, {0x3cf36000}, {0x3cf38000}, {0x3cf3a000}, {0x3cf3c000}, {0x3cf3e000}, {0x3cf40000}, {0x3cf42000}, {0x3cf44000}, {0x3cf46000}, {0x3cf48000}, {0x3cf4a000}, {0x3cf4c000}, {0x3cf4e000}, {0x3cf50000}, {0x3cf52000}, {0x3cf54000}, {0x3cf56000}, {0x3cf58000}, {0x3cf5a000}, {0x3cf5c000}, {0x3cf5e000}, {0x3cf60000}, {0x3cf62000}, {0x3cf64000}, {0x3cf66000}, {0x3cf68000}, {0x3cf6a000}, {0x3cf6c000}, {0x3cf6e000}, {0x3cf70000}, {0x3cf72000}, {0x3cf74000}, {0x3cf76000}, {0x3cf78000}, {0x3cf7a000}, {0x3cf7c000}, {0x3cf7e000}, {0x3cf80000}, {0x3cf82000}, {0x3cf84000}, {0x3cf86000}, {0x3cf88000}, {0x3cf8a000}, {0x3cf8c000}, {0x3cf8e000}, {0x3cf90000}, {0x3cf92000}, {0x3cf94000}, {0x3cf96000}, {0x3cf98000}, {0x3cf9a000}, {0x3cf9c000}, {0x3cf9e000}, {0x3cfa0000}, {0x3cfa2000}, {0x3cfa4000}, {0x3cfa6000}, {0x3cfa8000}, {0x3cfaa000}, {0x3cfac000}, {0x3cfae000}, {0x3cfb0000}, {0x3cfb2000}, {0x3cfb4000}, {0x3cfb6000}, {0x3cfb8000}, {0x3cfba000}, {0x3cfbc000}, {0x3cfbe000}, {0x3cfc0000}, {0x3cfc2000}, {0x3cfc4000}, {0x3cfc6000}, {0x3cfc8000}, {0x3cfca000}, {0x3cfcc000}, {0x3cfce000}, {0x3cfd0000}, {0x3cfd2000}, {0x3cfd4000}, {0x3cfd6000}, {0x3cfd8000}, {0x3cfda000}, {0x3cfdc000}, {0x3cfde000}, {0x3cfe0000}, {0x3cfe2000}, {0x3cfe4000}, {0x3cfe6000}, {0x3cfe8000}, {0x3cfea000}, {0x3cfec000}, {0x3cfee000}, {0x3cff0000}, {0x3cff2000}, {0x3cff4000}, {0x3cff6000}, {0x3cff8000}, {0x3cffa000}, {0x3cffc000}, {0x3cffe000}, {0x3d000000}, {0x3d002000}, {0x3d004000}, {0x3d006000}, {0x3d008000}, {0x3d00a000}, {0x3d00c000}, {0x3d00e000}, {0x3d010000}, {0x3d012000}, {0x3d014000}, {0x3d016000}, {0x3d018000}, {0x3d01a000}, {0x3d01c000}, {0x3d01e000}, {0x3d020000}, {0x3d022000}, {0x3d024000}, {0x3d026000}, {0x3d028000}, {0x3d02a000}, {0x3d02c000}, {0x3d02e000}, {0x3d030000}, {0x3d032000}, {0x3d034000}, {0x3d036000}, {0x3d038000}, {0x3d03a000}, {0x3d03c000}, {0x3d03e000}, {0x3d040000}, {0x3d042000}, {0x3d044000}, {0x3d046000}, {0x3d048000}, {0x3d04a000}, {0x3d04c000}, {0x3d04e000}, {0x3d050000}, {0x3d052000}, {0x3d054000}, {0x3d056000}, {0x3d058000}, {0x3d05a000}, {0x3d05c000}, {0x3d05e000}, {0x3d060000}, {0x3d062000}, {0x3d064000}, {0x3d066000}, {0x3d068000}, {0x3d06a000}, {0x3d06c000}, {0x3d06e000}, {0x3d070000}, {0x3d072000}, {0x3d074000}, {0x3d076000}, {0x3d078000}, {0x3d07a000}, {0x3d07c000}, {0x3d07e000}, {0x3d080000}, {0x3d082000}, {0x3d084000}, {0x3d086000}, {0x3d088000}, {0x3d08a000}, {0x3d08c000}, {0x3d08e000}, {0x3d090000}, {0x3d092000}, {0x3d094000}, {0x3d096000}, {0x3d098000}, {0x3d09a000}, {0x3d09c000}, {0x3d09e000}, {0x3d0a0000}, {0x3d0a2000}, {0x3d0a4000}, {0x3d0a6000}, {0x3d0a8000}, {0x3d0aa000}, {0x3d0ac000}, {0x3d0ae000}, {0x3d0b0000}, {0x3d0b2000}, {0x3d0b4000}, {0x3d0b6000}, {0x3d0b8000}, {0x3d0ba000}, {0x3d0bc000}, {0x3d0be000}, {0x3d0c0000}, {0x3d0c2000}, {0x3d0c4000}, {0x3d0c6000}, {0x3d0c8000}, {0x3d0ca000}, {0x3d0cc000}, {0x3d0ce000}, {0x3d0d0000}, {0x3d0d2000}, {0x3d0d4000}, {0x3d0d6000}, {0x3d0d8000}, {0x3d0da000}, {0x3d0dc000}, {0x3d0de000}, {0x3d0e0000}, {0x3d0e2000}, {0x3d0e4000}, {0x3d0e6000}, {0x3d0e8000}, {0x3d0ea000}, {0x3d0ec000}, {0x3d0ee000}, {0x3d0f0000}, {0x3d0f2000}, {0x3d0f4000}, {0x3d0f6000}, {0x3d0f8000}, {0x3d0fa000}, {0x3d0fc000}, {0x3d0fe000}, {0x3d100000}, {0x3d102000}, {0x3d104000}, {0x3d106000}, {0x3d108000}, {0x3d10a000}, {0x3d10c000}, {0x3d10e000}, {0x3d110000}, {0x3d112000}, {0x3d114000}, {0x3d116000}, {0x3d118000}, {0x3d11a000}, {0x3d11c000}, {0x3d11e000}, {0x3d120000}, {0x3d122000}, {0x3d124000}, {0x3d126000}, {0x3d128000}, {0x3d12a000}, {0x3d12c000}, {0x3d12e000}, {0x3d130000}, {0x3d132000}, {0x3d134000}, {0x3d136000}, {0x3d138000}, {0x3d13a000}, {0x3d13c000}, {0x3d13e000}, {0x3d140000}, {0x3d142000}, {0x3d144000}, {0x3d146000}, {0x3d148000}, {0x3d14a000}, {0x3d14c000}, {0x3d14e000}, {0x3d150000}, {0x3d152000}, {0x3d154000}, {0x3d156000}, {0x3d158000}, {0x3d15a000}, {0x3d15c000}, {0x3d15e000}, {0x3d160000}, {0x3d162000}, {0x3d164000}, {0x3d166000}, {0x3d168000}, {0x3d16a000}, {0x3d16c000}, {0x3d16e000}, {0x3d170000}, {0x3d172000}, {0x3d174000}, {0x3d176000}, {0x3d178000}, {0x3d17a000}, {0x3d17c000}, {0x3d17e000}, {0x3d180000}, {0x3d182000}, {0x3d184000}, {0x3d186000}, {0x3d188000}, {0x3d18a000}, {0x3d18c000}, {0x3d18e000}, {0x3d190000}, {0x3d192000}, {0x3d194000}, {0x3d196000}, {0x3d198000}, {0x3d19a000}, {0x3d19c000}, {0x3d19e000}, {0x3d1a0000}, {0x3d1a2000}, {0x3d1a4000}, {0x3d1a6000}, {0x3d1a8000}, {0x3d1aa000}, {0x3d1ac000}, {0x3d1ae000}, {0x3d1b0000}, {0x3d1b2000}, {0x3d1b4000}, {0x3d1b6000}, {0x3d1b8000}, {0x3d1ba000}, {0x3d1bc000}, {0x3d1be000}, {0x3d1c0000}, {0x3d1c2000}, {0x3d1c4000}, {0x3d1c6000}, {0x3d1c8000}, {0x3d1ca000}, {0x3d1cc000}, {0x3d1ce000}, {0x3d1d0000}, {0x3d1d2000}, {0x3d1d4000}, {0x3d1d6000}, {0x3d1d8000}, {0x3d1da000}, {0x3d1dc000}, {0x3d1de000}, {0x3d1e0000}, {0x3d1e2000}, {0x3d1e4000}, {0x3d1e6000}, {0x3d1e8000}, {0x3d1ea000}, {0x3d1ec000}, {0x3d1ee000}, {0x3d1f0000}, {0x3d1f2000}, {0x3d1f4000}, {0x3d1f6000}, {0x3d1f8000}, {0x3d1fa000}, {0x3d1fc000}, {0x3d1fe000}, {0x3d200000}, {0x3d202000}, {0x3d204000}, {0x3d206000}, {0x3d208000}, {0x3d20a000}, {0x3d20c000}, {0x3d20e000}, {0x3d210000}, {0x3d212000}, {0x3d214000}, {0x3d216000}, {0x3d218000}, {0x3d21a000}, {0x3d21c000}, {0x3d21e000}, {0x3d220000}, {0x3d222000}, {0x3d224000}, {0x3d226000}, {0x3d228000}, {0x3d22a000}, {0x3d22c000}, {0x3d22e000}, {0x3d230000}, {0x3d232000}, {0x3d234000}, {0x3d236000}, {0x3d238000}, {0x3d23a000}, {0x3d23c000}, {0x3d23e000}, {0x3d240000}, {0x3d242000}, {0x3d244000}, {0x3d246000}, {0x3d248000}, {0x3d24a000}, {0x3d24c000}, {0x3d24e000}, {0x3d250000}, {0x3d252000}, {0x3d254000}, {0x3d256000}, {0x3d258000}, {0x3d25a000}, {0x3d25c000}, {0x3d25e000}, {0x3d260000}, {0x3d262000}, {0x3d264000}, {0x3d266000}, {0x3d268000}, {0x3d26a000}, {0x3d26c000}, {0x3d26e000}, {0x3d270000}, {0x3d272000}, {0x3d274000}, {0x3d276000}, {0x3d278000}, {0x3d27a000}, {0x3d27c000}, {0x3d27e000}, {0x3d280000}, {0x3d282000}, {0x3d284000}, {0x3d286000}, {0x3d288000}, {0x3d28a000}, {0x3d28c000}, {0x3d28e000}, {0x3d290000}, {0x3d292000}, {0x3d294000}, {0x3d296000}, {0x3d298000}, {0x3d29a000}, {0x3d29c000}, {0x3d29e000}, {0x3d2a0000}, {0x3d2a2000}, {0x3d2a4000}, {0x3d2a6000}, {0x3d2a8000}, {0x3d2aa000}, {0x3d2ac000}, {0x3d2ae000}, {0x3d2b0000}, {0x3d2b2000}, {0x3d2b4000}, {0x3d2b6000}, {0x3d2b8000}, {0x3d2ba000}, {0x3d2bc000}, {0x3d2be000}, {0x3d2c0000}, {0x3d2c2000}, {0x3d2c4000}, {0x3d2c6000}, {0x3d2c8000}, {0x3d2ca000}, {0x3d2cc000}, {0x3d2ce000}, {0x3d2d0000}, {0x3d2d2000}, {0x3d2d4000}, {0x3d2d6000}, {0x3d2d8000}, {0x3d2da000}, {0x3d2dc000}, {0x3d2de000}, {0x3d2e0000}, {0x3d2e2000}, {0x3d2e4000}, {0x3d2e6000}, {0x3d2e8000}, {0x3d2ea000}, {0x3d2ec000}, {0x3d2ee000}, {0x3d2f0000}, {0x3d2f2000}, {0x3d2f4000}, {0x3d2f6000}, {0x3d2f8000}, {0x3d2fa000}, {0x3d2fc000}, {0x3d2fe000}, {0x3d300000}, {0x3d302000}, {0x3d304000}, {0x3d306000}, {0x3d308000}, {0x3d30a000}, {0x3d30c000}, {0x3d30e000}, {0x3d310000}, {0x3d312000}, {0x3d314000}, {0x3d316000}, {0x3d318000}, {0x3d31a000}, {0x3d31c000}, {0x3d31e000}, {0x3d320000}, {0x3d322000}, {0x3d324000}, {0x3d326000}, {0x3d328000}, {0x3d32a000}, {0x3d32c000}, {0x3d32e000}, {0x3d330000}, {0x3d332000}, {0x3d334000}, {0x3d336000}, {0x3d338000}, {0x3d33a000}, {0x3d33c000}, {0x3d33e000}, {0x3d340000}, {0x3d342000}, {0x3d344000}, {0x3d346000}, {0x3d348000}, {0x3d34a000}, {0x3d34c000}, {0x3d34e000}, {0x3d350000}, {0x3d352000}, {0x3d354000}, {0x3d356000}, {0x3d358000}, {0x3d35a000}, {0x3d35c000}, {0x3d35e000}, {0x3d360000}, {0x3d362000}, {0x3d364000}, {0x3d366000}, {0x3d368000}, {0x3d36a000}, {0x3d36c000}, {0x3d36e000}, {0x3d370000}, {0x3d372000}, {0x3d374000}, {0x3d376000}, {0x3d378000}, {0x3d37a000}, {0x3d37c000}, {0x3d37e000}, {0x3d380000}, {0x3d382000}, {0x3d384000}, {0x3d386000}, {0x3d388000}, {0x3d38a000}, {0x3d38c000}, {0x3d38e000}, {0x3d390000}, {0x3d392000}, {0x3d394000}, {0x3d396000}, {0x3d398000}, {0x3d39a000}, {0x3d39c000}, {0x3d39e000}, {0x3d3a0000}, {0x3d3a2000}, {0x3d3a4000}, {0x3d3a6000}, {0x3d3a8000}, {0x3d3aa000}, {0x3d3ac000}, {0x3d3ae000}, {0x3d3b0000}, {0x3d3b2000}, {0x3d3b4000}, {0x3d3b6000}, {0x3d3b8000}, {0x3d3ba000}, {0x3d3bc000}, {0x3d3be000}, {0x3d3c0000}, {0x3d3c2000}, {0x3d3c4000}, {0x3d3c6000}, {0x3d3c8000}, {0x3d3ca000}, {0x3d3cc000}, {0x3d3ce000}, {0x3d3d0000}, {0x3d3d2000}, {0x3d3d4000}, {0x3d3d6000}, {0x3d3d8000}, {0x3d3da000}, {0x3d3dc000}, {0x3d3de000}, {0x3d3e0000}, {0x3d3e2000}, {0x3d3e4000}, {0x3d3e6000}, {0x3d3e8000}, {0x3d3ea000}, {0x3d3ec000}, {0x3d3ee000}, {0x3d3f0000}, {0x3d3f2000}, {0x3d3f4000}, {0x3d3f6000}, {0x3d3f8000}, {0x3d3fa000}, {0x3d3fc000}, {0x3d3fe000}, {0x3d400000}, {0x3d402000}, {0x3d404000}, {0x3d406000}, {0x3d408000}, {0x3d40a000}, {0x3d40c000}, {0x3d40e000}, {0x3d410000}, {0x3d412000}, {0x3d414000}, {0x3d416000}, {0x3d418000}, {0x3d41a000}, {0x3d41c000}, {0x3d41e000}, {0x3d420000}, {0x3d422000}, {0x3d424000}, {0x3d426000}, {0x3d428000}, {0x3d42a000}, {0x3d42c000}, {0x3d42e000}, {0x3d430000}, {0x3d432000}, {0x3d434000}, {0x3d436000}, {0x3d438000}, {0x3d43a000}, {0x3d43c000}, {0x3d43e000}, {0x3d440000}, {0x3d442000}, {0x3d444000}, {0x3d446000}, {0x3d448000}, {0x3d44a000}, {0x3d44c000}, {0x3d44e000}, {0x3d450000}, {0x3d452000}, {0x3d454000}, {0x3d456000}, {0x3d458000}, {0x3d45a000}, {0x3d45c000}, {0x3d45e000}, {0x3d460000}, {0x3d462000}, {0x3d464000}, {0x3d466000}, {0x3d468000}, {0x3d46a000}, {0x3d46c000}, {0x3d46e000}, {0x3d470000}, {0x3d472000}, {0x3d474000}, {0x3d476000}, {0x3d478000}, {0x3d47a000}, {0x3d47c000}, {0x3d47e000}, {0x3d480000}, {0x3d482000}, {0x3d484000}, {0x3d486000}, {0x3d488000}, {0x3d48a000}, {0x3d48c000}, {0x3d48e000}, {0x3d490000}, {0x3d492000}, {0x3d494000}, {0x3d496000}, {0x3d498000}, {0x3d49a000}, {0x3d49c000}, {0x3d49e000}, {0x3d4a0000}, {0x3d4a2000}, {0x3d4a4000}, {0x3d4a6000}, {0x3d4a8000}, {0x3d4aa000}, {0x3d4ac000}, {0x3d4ae000}, {0x3d4b0000}, {0x3d4b2000}, {0x3d4b4000}, {0x3d4b6000}, {0x3d4b8000}, {0x3d4ba000}, {0x3d4bc000}, {0x3d4be000}, {0x3d4c0000}, {0x3d4c2000}, {0x3d4c4000}, {0x3d4c6000}, {0x3d4c8000}, {0x3d4ca000}, {0x3d4cc000}, {0x3d4ce000}, {0x3d4d0000}, {0x3d4d2000}, {0x3d4d4000}, {0x3d4d6000}, {0x3d4d8000}, {0x3d4da000}, {0x3d4dc000}, {0x3d4de000}, {0x3d4e0000}, {0x3d4e2000}, {0x3d4e4000}, {0x3d4e6000}, {0x3d4e8000}, {0x3d4ea000}, {0x3d4ec000}, {0x3d4ee000}, {0x3d4f0000}, {0x3d4f2000}, {0x3d4f4000}, {0x3d4f6000}, {0x3d4f8000}, {0x3d4fa000}, {0x3d4fc000}, {0x3d4fe000}, {0x3d500000}, {0x3d502000}, {0x3d504000}, {0x3d506000}, {0x3d508000}, {0x3d50a000}, {0x3d50c000}, {0x3d50e000}, {0x3d510000}, {0x3d512000}, {0x3d514000}, {0x3d516000}, {0x3d518000}, {0x3d51a000}, {0x3d51c000}, {0x3d51e000}, {0x3d520000}, {0x3d522000}, {0x3d524000}, {0x3d526000}, {0x3d528000}, {0x3d52a000}, {0x3d52c000}, {0x3d52e000}, {0x3d530000}, {0x3d532000}, {0x3d534000}, {0x3d536000}, {0x3d538000}, {0x3d53a000}, {0x3d53c000}, {0x3d53e000}, {0x3d540000}, {0x3d542000}, {0x3d544000}, {0x3d546000}, {0x3d548000}, {0x3d54a000}, {0x3d54c000}, {0x3d54e000}, {0x3d550000}, {0x3d552000}, {0x3d554000}, {0x3d556000}, {0x3d558000}, {0x3d55a000}, {0x3d55c000}, {0x3d55e000}, {0x3d560000}, {0x3d562000}, {0x3d564000}, {0x3d566000}, {0x3d568000}, {0x3d56a000}, {0x3d56c000}, {0x3d56e000}, {0x3d570000}, {0x3d572000}, {0x3d574000}, {0x3d576000}, {0x3d578000}, {0x3d57a000}, {0x3d57c000}, {0x3d57e000}, {0x3d580000}, {0x3d582000}, {0x3d584000}, {0x3d586000}, {0x3d588000}, {0x3d58a000}, {0x3d58c000}, {0x3d58e000}, {0x3d590000}, {0x3d592000}, {0x3d594000}, {0x3d596000}, {0x3d598000}, {0x3d59a000}, {0x3d59c000}, {0x3d59e000}, {0x3d5a0000}, {0x3d5a2000}, {0x3d5a4000}, {0x3d5a6000}, {0x3d5a8000}, {0x3d5aa000}, {0x3d5ac000}, {0x3d5ae000}, {0x3d5b0000}, {0x3d5b2000}, {0x3d5b4000}, {0x3d5b6000}, {0x3d5b8000}, {0x3d5ba000}, {0x3d5bc000}, {0x3d5be000}, {0x3d5c0000}, {0x3d5c2000}, {0x3d5c4000}, {0x3d5c6000}, {0x3d5c8000}, {0x3d5ca000}, {0x3d5cc000}, {0x3d5ce000}, {0x3d5d0000}, {0x3d5d2000}, {0x3d5d4000}, {0x3d5d6000}, {0x3d5d8000}, {0x3d5da000}, {0x3d5dc000}, {0x3d5de000}, {0x3d5e0000}, {0x3d5e2000}, {0x3d5e4000}, {0x3d5e6000}, {0x3d5e8000}, {0x3d5ea000}, {0x3d5ec000}, {0x3d5ee000}, {0x3d5f0000}, {0x3d5f2000}, {0x3d5f4000}, {0x3d5f6000}, {0x3d5f8000}, {0x3d5fa000}, {0x3d5fc000}, {0x3d5fe000}, {0x3d600000}, {0x3d602000}, {0x3d604000}, {0x3d606000}, {0x3d608000}, {0x3d60a000}, {0x3d60c000}, {0x3d60e000}, {0x3d610000}, {0x3d612000}, {0x3d614000}, {0x3d616000}, {0x3d618000}, {0x3d61a000}, {0x3d61c000}, {0x3d61e000}, {0x3d620000}, {0x3d622000}, {0x3d624000}, {0x3d626000}, {0x3d628000}, {0x3d62a000}, {0x3d62c000}, {0x3d62e000}, {0x3d630000}, {0x3d632000}, {0x3d634000}, {0x3d636000}, {0x3d638000}, {0x3d63a000}, {0x3d63c000}, {0x3d63e000}, {0x3d640000}, {0x3d642000}, {0x3d644000}, {0x3d646000}, {0x3d648000}, {0x3d64a000}, {0x3d64c000}, {0x3d64e000}, {0x3d650000}, {0x3d652000}, {0x3d654000}, {0x3d656000}, {0x3d658000}, {0x3d65a000}, {0x3d65c000}, {0x3d65e000}, {0x3d660000}, {0x3d662000}, {0x3d664000}, {0x3d666000}, {0x3d668000}, {0x3d66a000}, {0x3d66c000}, {0x3d66e000}, {0x3d670000}, {0x3d672000}, {0x3d674000}, {0x3d676000}, {0x3d678000}, {0x3d67a000}, {0x3d67c000}, {0x3d67e000}, {0x3d680000}, {0x3d682000}, {0x3d684000}, {0x3d686000}, {0x3d688000}, {0x3d68a000}, {0x3d68c000}, {0x3d68e000}, {0x3d690000}, {0x3d692000}, {0x3d694000}, {0x3d696000}, {0x3d698000}, {0x3d69a000}, {0x3d69c000}, {0x3d69e000}, {0x3d6a0000}, {0x3d6a2000}, {0x3d6a4000}, {0x3d6a6000}, {0x3d6a8000}, {0x3d6aa000}, {0x3d6ac000}, {0x3d6ae000}, {0x3d6b0000}, {0x3d6b2000}, {0x3d6b4000}, {0x3d6b6000}, {0x3d6b8000}, {0x3d6ba000}, {0x3d6bc000}, {0x3d6be000}, {0x3d6c0000}, {0x3d6c2000}, {0x3d6c4000}, {0x3d6c6000}, {0x3d6c8000}, {0x3d6ca000}, {0x3d6cc000}, {0x3d6ce000}, {0x3d6d0000}, {0x3d6d2000}, {0x3d6d4000}, {0x3d6d6000}, {0x3d6d8000}, {0x3d6da000}, {0x3d6dc000}, {0x3d6de000}, {0x3d6e0000}, {0x3d6e2000}, {0x3d6e4000}, {0x3d6e6000}, {0x3d6e8000}, {0x3d6ea000}, {0x3d6ec000}, {0x3d6ee000}, {0x3d6f0000}, {0x3d6f2000}, {0x3d6f4000}, {0x3d6f6000}, {0x3d6f8000}, {0x3d6fa000}, {0x3d6fc000}, {0x3d6fe000}, {0x3d700000}, {0x3d702000}, {0x3d704000}, {0x3d706000}, {0x3d708000}, {0x3d70a000}, {0x3d70c000}, {0x3d70e000}, {0x3d710000}, {0x3d712000}, {0x3d714000}, {0x3d716000}, {0x3d718000}, {0x3d71a000}, {0x3d71c000}, {0x3d71e000}, {0x3d720000}, {0x3d722000}, {0x3d724000}, {0x3d726000}, {0x3d728000}, {0x3d72a000}, {0x3d72c000}, {0x3d72e000}, {0x3d730000}, {0x3d732000}, {0x3d734000}, {0x3d736000}, {0x3d738000}, {0x3d73a000}, {0x3d73c000}, {0x3d73e000}, {0x3d740000}, {0x3d742000}, {0x3d744000}, {0x3d746000}, {0x3d748000}, {0x3d74a000}, {0x3d74c000}, {0x3d74e000}, {0x3d750000}, {0x3d752000}, {0x3d754000}, {0x3d756000}, {0x3d758000}, {0x3d75a000}, {0x3d75c000}, {0x3d75e000}, {0x3d760000}, {0x3d762000}, {0x3d764000}, {0x3d766000}, {0x3d768000}, {0x3d76a000}, {0x3d76c000}, {0x3d76e000}, {0x3d770000}, {0x3d772000}, {0x3d774000}, {0x3d776000}, {0x3d778000}, {0x3d77a000}, {0x3d77c000}, {0x3d77e000}, {0x3d780000}, {0x3d782000}, {0x3d784000}, {0x3d786000}, {0x3d788000}, {0x3d78a000}, {0x3d78c000}, {0x3d78e000}, {0x3d790000}, {0x3d792000}, {0x3d794000}, {0x3d796000}, {0x3d798000}, {0x3d79a000}, {0x3d79c000}, {0x3d79e000}, {0x3d7a0000}, {0x3d7a2000}, {0x3d7a4000}, {0x3d7a6000}, {0x3d7a8000}, {0x3d7aa000}, {0x3d7ac000}, {0x3d7ae000}, {0x3d7b0000}, {0x3d7b2000}, {0x3d7b4000}, {0x3d7b6000}, {0x3d7b8000}, {0x3d7ba000}, {0x3d7bc000}, {0x3d7be000}, {0x3d7c0000}, {0x3d7c2000}, {0x3d7c4000}, {0x3d7c6000}, {0x3d7c8000}, {0x3d7ca000}, {0x3d7cc000}, {0x3d7ce000}, {0x3d7d0000}, {0x3d7d2000}, {0x3d7d4000}, {0x3d7d6000}, {0x3d7d8000}, {0x3d7da000}, {0x3d7dc000}, {0x3d7de000}, {0x3d7e0000}, {0x3d7e2000}, {0x3d7e4000}, {0x3d7e6000}, {0x3d7e8000}, {0x3d7ea000}, {0x3d7ec000}, {0x3d7ee000}, {0x3d7f0000}, {0x3d7f2000}, {0x3d7f4000}, {0x3d7f6000}, {0x3d7f8000}, {0x3d7fa000}, {0x3d7fc000}, {0x3d7fe000}, {0x3d800000}, {0x3d802000}, {0x3d804000}, {0x3d806000}, {0x3d808000}, {0x3d80a000}, {0x3d80c000}, {0x3d80e000}, {0x3d810000}, {0x3d812000}, {0x3d814000}, {0x3d816000}, {0x3d818000}, {0x3d81a000}, {0x3d81c000}, {0x3d81e000}, {0x3d820000}, {0x3d822000}, {0x3d824000}, {0x3d826000}, {0x3d828000}, {0x3d82a000}, {0x3d82c000}, {0x3d82e000}, {0x3d830000}, {0x3d832000}, {0x3d834000}, {0x3d836000}, {0x3d838000}, {0x3d83a000}, {0x3d83c000}, {0x3d83e000}, {0x3d840000}, {0x3d842000}, {0x3d844000}, {0x3d846000}, {0x3d848000}, {0x3d84a000}, {0x3d84c000}, {0x3d84e000}, {0x3d850000}, {0x3d852000}, {0x3d854000}, {0x3d856000}, {0x3d858000}, {0x3d85a000}, {0x3d85c000}, {0x3d85e000}, {0x3d860000}, {0x3d862000}, {0x3d864000}, {0x3d866000}, {0x3d868000}, {0x3d86a000}, {0x3d86c000}, {0x3d86e000}, {0x3d870000}, {0x3d872000}, {0x3d874000}, {0x3d876000}, {0x3d878000}, {0x3d87a000}, {0x3d87c000}, {0x3d87e000}, {0x3d880000}, {0x3d882000}, {0x3d884000}, {0x3d886000}, {0x3d888000}, {0x3d88a000}, {0x3d88c000}, {0x3d88e000}, {0x3d890000}, {0x3d892000}, {0x3d894000}, {0x3d896000}, {0x3d898000}, {0x3d89a000}, {0x3d89c000}, {0x3d89e000}, {0x3d8a0000}, {0x3d8a2000}, {0x3d8a4000}, {0x3d8a6000}, {0x3d8a8000}, {0x3d8aa000}, {0x3d8ac000}, {0x3d8ae000}, {0x3d8b0000}, {0x3d8b2000}, {0x3d8b4000}, {0x3d8b6000}, {0x3d8b8000}, {0x3d8ba000}, {0x3d8bc000}, {0x3d8be000}, {0x3d8c0000}, {0x3d8c2000}, {0x3d8c4000}, {0x3d8c6000}, {0x3d8c8000}, {0x3d8ca000}, {0x3d8cc000}, {0x3d8ce000}, {0x3d8d0000}, {0x3d8d2000}, {0x3d8d4000}, {0x3d8d6000}, {0x3d8d8000}, {0x3d8da000}, {0x3d8dc000}, {0x3d8de000}, {0x3d8e0000}, {0x3d8e2000}, {0x3d8e4000}, {0x3d8e6000}, {0x3d8e8000}, {0x3d8ea000}, {0x3d8ec000}, {0x3d8ee000}, {0x3d8f0000}, {0x3d8f2000}, {0x3d8f4000}, {0x3d8f6000}, {0x3d8f8000}, {0x3d8fa000}, {0x3d8fc000}, {0x3d8fe000}, {0x3d900000}, {0x3d902000}, {0x3d904000}, {0x3d906000}, {0x3d908000}, {0x3d90a000}, {0x3d90c000}, {0x3d90e000}, {0x3d910000}, {0x3d912000}, {0x3d914000}, {0x3d916000}, {0x3d918000}, {0x3d91a000}, {0x3d91c000}, {0x3d91e000}, {0x3d920000}, {0x3d922000}, {0x3d924000}, {0x3d926000}, {0x3d928000}, {0x3d92a000}, {0x3d92c000}, {0x3d92e000}, {0x3d930000}, {0x3d932000}, {0x3d934000}, {0x3d936000}, {0x3d938000}, {0x3d93a000}, {0x3d93c000}, {0x3d93e000}, {0x3d940000}, {0x3d942000}, {0x3d944000}, {0x3d946000}, {0x3d948000}, {0x3d94a000}, {0x3d94c000}, {0x3d94e000}, {0x3d950000}, {0x3d952000}, {0x3d954000}, {0x3d956000}, {0x3d958000}, {0x3d95a000}, {0x3d95c000}, {0x3d95e000}, {0x3d960000}, {0x3d962000}, {0x3d964000}, {0x3d966000}, {0x3d968000}, {0x3d96a000}, {0x3d96c000}, {0x3d96e000}, {0x3d970000}, {0x3d972000}, {0x3d974000}, {0x3d976000}, {0x3d978000}, {0x3d97a000}, {0x3d97c000}, {0x3d97e000}, {0x3d980000}, {0x3d982000}, {0x3d984000}, {0x3d986000}, {0x3d988000}, {0x3d98a000}, {0x3d98c000}, {0x3d98e000}, {0x3d990000}, {0x3d992000}, {0x3d994000}, {0x3d996000}, {0x3d998000}, {0x3d99a000}, {0x3d99c000}, {0x3d99e000}, {0x3d9a0000}, {0x3d9a2000}, {0x3d9a4000}, {0x3d9a6000}, {0x3d9a8000}, {0x3d9aa000}, {0x3d9ac000}, {0x3d9ae000}, {0x3d9b0000}, {0x3d9b2000}, {0x3d9b4000}, {0x3d9b6000}, {0x3d9b8000}, {0x3d9ba000}, {0x3d9bc000}, {0x3d9be000}, {0x3d9c0000}, {0x3d9c2000}, {0x3d9c4000}, {0x3d9c6000}, {0x3d9c8000}, {0x3d9ca000}, {0x3d9cc000}, {0x3d9ce000}, {0x3d9d0000}, {0x3d9d2000}, {0x3d9d4000}, {0x3d9d6000}, {0x3d9d8000}, {0x3d9da000}, {0x3d9dc000}, {0x3d9de000}, {0x3d9e0000}, {0x3d9e2000}, {0x3d9e4000}, {0x3d9e6000}, {0x3d9e8000}, {0x3d9ea000}, {0x3d9ec000}, {0x3d9ee000}, {0x3d9f0000}, {0x3d9f2000}, {0x3d9f4000}, {0x3d9f6000}, {0x3d9f8000}, {0x3d9fa000}, {0x3d9fc000}, {0x3d9fe000}, {0x3da00000}, {0x3da02000}, {0x3da04000}, {0x3da06000}, {0x3da08000}, {0x3da0a000}, {0x3da0c000}, {0x3da0e000}, {0x3da10000}, {0x3da12000}, {0x3da14000}, {0x3da16000}, {0x3da18000}, {0x3da1a000}, {0x3da1c000}, {0x3da1e000}, {0x3da20000}, {0x3da22000}, {0x3da24000}, {0x3da26000}, {0x3da28000}, {0x3da2a000}, {0x3da2c000}, {0x3da2e000}, {0x3da30000}, {0x3da32000}, {0x3da34000}, {0x3da36000}, {0x3da38000}, {0x3da3a000}, {0x3da3c000}, {0x3da3e000}, {0x3da40000}, {0x3da42000}, {0x3da44000}, {0x3da46000}, {0x3da48000}, {0x3da4a000}, {0x3da4c000}, {0x3da4e000}, {0x3da50000}, {0x3da52000}, {0x3da54000}, {0x3da56000}, {0x3da58000}, {0x3da5a000}, {0x3da5c000}, {0x3da5e000}, {0x3da60000}, {0x3da62000}, {0x3da64000}, {0x3da66000}, {0x3da68000}, {0x3da6a000}, {0x3da6c000}, {0x3da6e000}, {0x3da70000}, {0x3da72000}, {0x3da74000}, {0x3da76000}, {0x3da78000}, {0x3da7a000}, {0x3da7c000}, {0x3da7e000}, {0x3da80000}, {0x3da82000}, {0x3da84000}, {0x3da86000}, {0x3da88000}, {0x3da8a000}, {0x3da8c000}, {0x3da8e000}, {0x3da90000}, {0x3da92000}, {0x3da94000}, {0x3da96000}, {0x3da98000}, {0x3da9a000}, {0x3da9c000}, {0x3da9e000}, {0x3daa0000}, {0x3daa2000}, {0x3daa4000}, {0x3daa6000}, {0x3daa8000}, {0x3daaa000}, {0x3daac000}, {0x3daae000}, {0x3dab0000}, {0x3dab2000}, {0x3dab4000}, {0x3dab6000}, {0x3dab8000}, {0x3daba000}, {0x3dabc000}, {0x3dabe000}, {0x3dac0000}, {0x3dac2000}, {0x3dac4000}, {0x3dac6000}, {0x3dac8000}, {0x3daca000}, {0x3dacc000}, {0x3dace000}, {0x3dad0000}, {0x3dad2000}, {0x3dad4000}, {0x3dad6000}, {0x3dad8000}, {0x3dada000}, {0x3dadc000}, {0x3dade000}, {0x3dae0000}, {0x3dae2000}, {0x3dae4000}, {0x3dae6000}, {0x3dae8000}, {0x3daea000}, {0x3daec000}, {0x3daee000}, {0x3daf0000}, {0x3daf2000}, {0x3daf4000}, {0x3daf6000}, {0x3daf8000}, {0x3dafa000}, {0x3dafc000}, {0x3dafe000}, {0x3db00000}, {0x3db02000}, {0x3db04000}, {0x3db06000}, {0x3db08000}, {0x3db0a000}, {0x3db0c000}, {0x3db0e000}, {0x3db10000}, {0x3db12000}, {0x3db14000}, {0x3db16000}, {0x3db18000}, {0x3db1a000}, {0x3db1c000}, {0x3db1e000}, {0x3db20000}, {0x3db22000}, {0x3db24000}, {0x3db26000}, {0x3db28000}, {0x3db2a000}, {0x3db2c000}, {0x3db2e000}, {0x3db30000}, {0x3db32000}, {0x3db34000}, {0x3db36000}, {0x3db38000}, {0x3db3a000}, {0x3db3c000}, {0x3db3e000}, {0x3db40000}, {0x3db42000}, {0x3db44000}, {0x3db46000}, {0x3db48000}, {0x3db4a000}, {0x3db4c000}, {0x3db4e000}, {0x3db50000}, {0x3db52000}, {0x3db54000}, {0x3db56000}, {0x3db58000}, {0x3db5a000}, {0x3db5c000}, {0x3db5e000}, {0x3db60000}, {0x3db62000}, {0x3db64000}, {0x3db66000}, {0x3db68000}, {0x3db6a000}, {0x3db6c000}, {0x3db6e000}, {0x3db70000}, {0x3db72000}, {0x3db74000}, {0x3db76000}, {0x3db78000}, {0x3db7a000}, {0x3db7c000}, {0x3db7e000}, {0x3db80000}, {0x3db82000}, {0x3db84000}, {0x3db86000}, {0x3db88000}, {0x3db8a000}, {0x3db8c000}, {0x3db8e000}, {0x3db90000}, {0x3db92000}, {0x3db94000}, {0x3db96000}, {0x3db98000}, {0x3db9a000}, {0x3db9c000}, {0x3db9e000}, {0x3dba0000}, {0x3dba2000}, {0x3dba4000}, {0x3dba6000}, {0x3dba8000}, {0x3dbaa000}, {0x3dbac000}, {0x3dbae000}, {0x3dbb0000}, {0x3dbb2000}, {0x3dbb4000}, {0x3dbb6000}, {0x3dbb8000}, {0x3dbba000}, {0x3dbbc000}, {0x3dbbe000}, {0x3dbc0000}, {0x3dbc2000}, {0x3dbc4000}, {0x3dbc6000}, {0x3dbc8000}, {0x3dbca000}, {0x3dbcc000}, {0x3dbce000}, {0x3dbd0000}, {0x3dbd2000}, {0x3dbd4000}, {0x3dbd6000}, {0x3dbd8000}, {0x3dbda000}, {0x3dbdc000}, {0x3dbde000}, {0x3dbe0000}, {0x3dbe2000}, {0x3dbe4000}, {0x3dbe6000}, {0x3dbe8000}, {0x3dbea000}, {0x3dbec000}, {0x3dbee000}, {0x3dbf0000}, {0x3dbf2000}, {0x3dbf4000}, {0x3dbf6000}, {0x3dbf8000}, {0x3dbfa000}, {0x3dbfc000}, {0x3dbfe000}, {0x3dc00000}, {0x3dc02000}, {0x3dc04000}, {0x3dc06000}, {0x3dc08000}, {0x3dc0a000}, {0x3dc0c000}, {0x3dc0e000}, {0x3dc10000}, {0x3dc12000}, {0x3dc14000}, {0x3dc16000}, {0x3dc18000}, {0x3dc1a000}, {0x3dc1c000}, {0x3dc1e000}, {0x3dc20000}, {0x3dc22000}, {0x3dc24000}, {0x3dc26000}, {0x3dc28000}, {0x3dc2a000}, {0x3dc2c000}, {0x3dc2e000}, {0x3dc30000}, {0x3dc32000}, {0x3dc34000}, {0x3dc36000}, {0x3dc38000}, {0x3dc3a000}, {0x3dc3c000}, {0x3dc3e000}, {0x3dc40000}, {0x3dc42000}, {0x3dc44000}, {0x3dc46000}, {0x3dc48000}, {0x3dc4a000}, {0x3dc4c000}, {0x3dc4e000}, {0x3dc50000}, {0x3dc52000}, {0x3dc54000}, {0x3dc56000}, {0x3dc58000}, {0x3dc5a000}, {0x3dc5c000}, {0x3dc5e000}, {0x3dc60000}, {0x3dc62000}, {0x3dc64000}, {0x3dc66000}, {0x3dc68000}, {0x3dc6a000}, {0x3dc6c000}, {0x3dc6e000}, {0x3dc70000}, {0x3dc72000}, {0x3dc74000}, {0x3dc76000}, {0x3dc78000}, {0x3dc7a000}, {0x3dc7c000}, {0x3dc7e000}, {0x3dc80000}, {0x3dc82000}, {0x3dc84000}, {0x3dc86000}, {0x3dc88000}, {0x3dc8a000}, {0x3dc8c000}, {0x3dc8e000}, {0x3dc90000}, {0x3dc92000}, {0x3dc94000}, {0x3dc96000}, {0x3dc98000}, {0x3dc9a000}, {0x3dc9c000}, {0x3dc9e000}, {0x3dca0000}, {0x3dca2000}, {0x3dca4000}, {0x3dca6000}, {0x3dca8000}, {0x3dcaa000}, {0x3dcac000}, {0x3dcae000}, {0x3dcb0000}, {0x3dcb2000}, {0x3dcb4000}, {0x3dcb6000}, {0x3dcb8000}, {0x3dcba000}, {0x3dcbc000}, {0x3dcbe000}, {0x3dcc0000}, {0x3dcc2000}, {0x3dcc4000}, {0x3dcc6000}, {0x3dcc8000}, {0x3dcca000}, {0x3dccc000}, {0x3dcce000}, {0x3dcd0000}, {0x3dcd2000}, {0x3dcd4000}, {0x3dcd6000}, {0x3dcd8000}, {0x3dcda000}, {0x3dcdc000}, {0x3dcde000}, {0x3dce0000}, {0x3dce2000}, {0x3dce4000}, {0x3dce6000}, {0x3dce8000}, {0x3dcea000}, {0x3dcec000}, {0x3dcee000}, {0x3dcf0000}, {0x3dcf2000}, {0x3dcf4000}, {0x3dcf6000}, {0x3dcf8000}, {0x3dcfa000}, {0x3dcfc000}, {0x3dcfe000}, {0x3dd00000}, {0x3dd02000}, {0x3dd04000}, {0x3dd06000}, {0x3dd08000}, {0x3dd0a000}, {0x3dd0c000}, {0x3dd0e000}, {0x3dd10000}, {0x3dd12000}, {0x3dd14000}, {0x3dd16000}, {0x3dd18000}, {0x3dd1a000}, {0x3dd1c000}, {0x3dd1e000}, {0x3dd20000}, {0x3dd22000}, {0x3dd24000}, {0x3dd26000}, {0x3dd28000}, {0x3dd2a000}, {0x3dd2c000}, {0x3dd2e000}, {0x3dd30000}, {0x3dd32000}, {0x3dd34000}, {0x3dd36000}, {0x3dd38000}, {0x3dd3a000}, {0x3dd3c000}, {0x3dd3e000}, {0x3dd40000}, {0x3dd42000}, {0x3dd44000}, {0x3dd46000}, {0x3dd48000}, {0x3dd4a000}, {0x3dd4c000}, {0x3dd4e000}, {0x3dd50000}, {0x3dd52000}, {0x3dd54000}, {0x3dd56000}, {0x3dd58000}, {0x3dd5a000}, {0x3dd5c000}, {0x3dd5e000}, {0x3dd60000}, {0x3dd62000}, {0x3dd64000}, {0x3dd66000}, {0x3dd68000}, {0x3dd6a000}, {0x3dd6c000}, {0x3dd6e000}, {0x3dd70000}, {0x3dd72000}, {0x3dd74000}, {0x3dd76000}, {0x3dd78000}, {0x3dd7a000}, {0x3dd7c000}, {0x3dd7e000}, {0x3dd80000}, {0x3dd82000}, {0x3dd84000}, {0x3dd86000}, {0x3dd88000}, {0x3dd8a000}, {0x3dd8c000}, {0x3dd8e000}, {0x3dd90000}, {0x3dd92000}, {0x3dd94000}, {0x3dd96000}, {0x3dd98000}, {0x3dd9a000}, {0x3dd9c000}, {0x3dd9e000}, {0x3dda0000}, {0x3dda2000}, {0x3dda4000}, {0x3dda6000}, {0x3dda8000}, {0x3ddaa000}, {0x3ddac000}, {0x3ddae000}, {0x3ddb0000}, {0x3ddb2000}, {0x3ddb4000}, {0x3ddb6000}, {0x3ddb8000}, {0x3ddba000}, {0x3ddbc000}, {0x3ddbe000}, {0x3ddc0000}, {0x3ddc2000}, {0x3ddc4000}, {0x3ddc6000}, {0x3ddc8000}, {0x3ddca000}, {0x3ddcc000}, {0x3ddce000}, {0x3ddd0000}, {0x3ddd2000}, {0x3ddd4000}, {0x3ddd6000}, {0x3ddd8000}, {0x3ddda000}, {0x3dddc000}, {0x3ddde000}, {0x3dde0000}, {0x3dde2000}, {0x3dde4000}, {0x3dde6000}, {0x3dde8000}, {0x3ddea000}, {0x3ddec000}, {0x3ddee000}, {0x3ddf0000}, {0x3ddf2000}, {0x3ddf4000}, {0x3ddf6000}, {0x3ddf8000}, {0x3ddfa000}, {0x3ddfc000}, {0x3ddfe000}, {0x3de00000}, {0x3de02000}, {0x3de04000}, {0x3de06000}, {0x3de08000}, {0x3de0a000}, {0x3de0c000}, {0x3de0e000}, {0x3de10000}, {0x3de12000}, {0x3de14000}, {0x3de16000}, {0x3de18000}, {0x3de1a000}, {0x3de1c000}, {0x3de1e000}, {0x3de20000}, {0x3de22000}, {0x3de24000}, {0x3de26000}, {0x3de28000}, {0x3de2a000}, {0x3de2c000}, {0x3de2e000}, {0x3de30000}, {0x3de32000}, {0x3de34000}, {0x3de36000}, {0x3de38000}, {0x3de3a000}, {0x3de3c000}, {0x3de3e000}, {0x3de40000}, {0x3de42000}, {0x3de44000}, {0x3de46000}, {0x3de48000}, {0x3de4a000}, {0x3de4c000}, {0x3de4e000}, {0x3de50000}, {0x3de52000}, {0x3de54000}, {0x3de56000}, {0x3de58000}, {0x3de5a000}, {0x3de5c000}, {0x3de5e000}, {0x3de60000}, {0x3de62000}, {0x3de64000}, {0x3de66000}, {0x3de68000}, {0x3de6a000}, {0x3de6c000}, {0x3de6e000}, {0x3de70000}, {0x3de72000}, {0x3de74000}, {0x3de76000}, {0x3de78000}, {0x3de7a000}, {0x3de7c000}, {0x3de7e000}, {0x3de80000}, {0x3de82000}, {0x3de84000}, {0x3de86000}, {0x3de88000}, {0x3de8a000}, {0x3de8c000}, {0x3de8e000}, {0x3de90000}, {0x3de92000}, {0x3de94000}, {0x3de96000}, {0x3de98000}, {0x3de9a000}, {0x3de9c000}, {0x3de9e000}, {0x3dea0000}, {0x3dea2000}, {0x3dea4000}, {0x3dea6000}, {0x3dea8000}, {0x3deaa000}, {0x3deac000}, {0x3deae000}, {0x3deb0000}, {0x3deb2000}, {0x3deb4000}, {0x3deb6000}, {0x3deb8000}, {0x3deba000}, {0x3debc000}, {0x3debe000}, {0x3dec0000}, {0x3dec2000}, {0x3dec4000}, {0x3dec6000}, {0x3dec8000}, {0x3deca000}, {0x3decc000}, {0x3dece000}, {0x3ded0000}, {0x3ded2000}, {0x3ded4000}, {0x3ded6000}, {0x3ded8000}, {0x3deda000}, {0x3dedc000}, {0x3dede000}, {0x3dee0000}, {0x3dee2000}, {0x3dee4000}, {0x3dee6000}, {0x3dee8000}, {0x3deea000}, {0x3deec000}, {0x3deee000}, {0x3def0000}, {0x3def2000}, {0x3def4000}, {0x3def6000}, {0x3def8000}, {0x3defa000}, {0x3defc000}, {0x3defe000}, {0x3df00000}, {0x3df02000}, {0x3df04000}, {0x3df06000}, {0x3df08000}, {0x3df0a000}, {0x3df0c000}, {0x3df0e000}, {0x3df10000}, {0x3df12000}, {0x3df14000}, {0x3df16000}, {0x3df18000}, {0x3df1a000}, {0x3df1c000}, {0x3df1e000}, {0x3df20000}, {0x3df22000}, {0x3df24000}, {0x3df26000}, {0x3df28000}, {0x3df2a000}, {0x3df2c000}, {0x3df2e000}, {0x3df30000}, {0x3df32000}, {0x3df34000}, {0x3df36000}, {0x3df38000}, {0x3df3a000}, {0x3df3c000}, {0x3df3e000}, {0x3df40000}, {0x3df42000}, {0x3df44000}, {0x3df46000}, {0x3df48000}, {0x3df4a000}, {0x3df4c000}, {0x3df4e000}, {0x3df50000}, {0x3df52000}, {0x3df54000}, {0x3df56000}, {0x3df58000}, {0x3df5a000}, {0x3df5c000}, {0x3df5e000}, {0x3df60000}, {0x3df62000}, {0x3df64000}, {0x3df66000}, {0x3df68000}, {0x3df6a000}, {0x3df6c000}, {0x3df6e000}, {0x3df70000}, {0x3df72000}, {0x3df74000}, {0x3df76000}, {0x3df78000}, {0x3df7a000}, {0x3df7c000}, {0x3df7e000}, {0x3df80000}, {0x3df82000}, {0x3df84000}, {0x3df86000}, {0x3df88000}, {0x3df8a000}, {0x3df8c000}, {0x3df8e000}, {0x3df90000}, {0x3df92000}, {0x3df94000}, {0x3df96000}, {0x3df98000}, {0x3df9a000}, {0x3df9c000}, {0x3df9e000}, {0x3dfa0000}, {0x3dfa2000}, {0x3dfa4000}, {0x3dfa6000}, {0x3dfa8000}, {0x3dfaa000}, {0x3dfac000}, {0x3dfae000}, {0x3dfb0000}, {0x3dfb2000}, {0x3dfb4000}, {0x3dfb6000}, {0x3dfb8000}, {0x3dfba000}, {0x3dfbc000}, {0x3dfbe000}, {0x3dfc0000}, {0x3dfc2000}, {0x3dfc4000}, {0x3dfc6000}, {0x3dfc8000}, {0x3dfca000}, {0x3dfcc000}, {0x3dfce000}, {0x3dfd0000}, {0x3dfd2000}, {0x3dfd4000}, {0x3dfd6000}, {0x3dfd8000}, {0x3dfda000}, {0x3dfdc000}, {0x3dfde000}, {0x3dfe0000}, {0x3dfe2000}, {0x3dfe4000}, {0x3dfe6000}, {0x3dfe8000}, {0x3dfea000}, {0x3dfec000}, {0x3dfee000}, {0x3dff0000}, {0x3dff2000}, {0x3dff4000}, {0x3dff6000}, {0x3dff8000}, {0x3dffa000}, {0x3dffc000}, {0x3dffe000}, {0x3e000000}, {0x3e002000}, {0x3e004000}, {0x3e006000}, {0x3e008000}, {0x3e00a000}, {0x3e00c000}, {0x3e00e000}, {0x3e010000}, {0x3e012000}, {0x3e014000}, {0x3e016000}, {0x3e018000}, {0x3e01a000}, {0x3e01c000}, {0x3e01e000}, {0x3e020000}, {0x3e022000}, {0x3e024000}, {0x3e026000}, {0x3e028000}, {0x3e02a000}, {0x3e02c000}, {0x3e02e000}, {0x3e030000}, {0x3e032000}, {0x3e034000}, {0x3e036000}, {0x3e038000}, {0x3e03a000}, {0x3e03c000}, {0x3e03e000}, {0x3e040000}, {0x3e042000}, {0x3e044000}, {0x3e046000}, {0x3e048000}, {0x3e04a000}, {0x3e04c000}, {0x3e04e000}, {0x3e050000}, {0x3e052000}, {0x3e054000}, {0x3e056000}, {0x3e058000}, {0x3e05a000}, {0x3e05c000}, {0x3e05e000}, {0x3e060000}, {0x3e062000}, {0x3e064000}, {0x3e066000}, {0x3e068000}, {0x3e06a000}, {0x3e06c000}, {0x3e06e000}, {0x3e070000}, {0x3e072000}, {0x3e074000}, {0x3e076000}, {0x3e078000}, {0x3e07a000}, {0x3e07c000}, {0x3e07e000}, {0x3e080000}, {0x3e082000}, {0x3e084000}, {0x3e086000}, {0x3e088000}, {0x3e08a000}, {0x3e08c000}, {0x3e08e000}, {0x3e090000}, {0x3e092000}, {0x3e094000}, {0x3e096000}, {0x3e098000}, {0x3e09a000}, {0x3e09c000}, {0x3e09e000}, {0x3e0a0000}, {0x3e0a2000}, {0x3e0a4000}, {0x3e0a6000}, {0x3e0a8000}, {0x3e0aa000}, {0x3e0ac000}, {0x3e0ae000}, {0x3e0b0000}, {0x3e0b2000}, {0x3e0b4000}, {0x3e0b6000}, {0x3e0b8000}, {0x3e0ba000}, {0x3e0bc000}, {0x3e0be000}, {0x3e0c0000}, {0x3e0c2000}, {0x3e0c4000}, {0x3e0c6000}, {0x3e0c8000}, {0x3e0ca000}, {0x3e0cc000}, {0x3e0ce000}, {0x3e0d0000}, {0x3e0d2000}, {0x3e0d4000}, {0x3e0d6000}, {0x3e0d8000}, {0x3e0da000}, {0x3e0dc000}, {0x3e0de000}, {0x3e0e0000}, {0x3e0e2000}, {0x3e0e4000}, {0x3e0e6000}, {0x3e0e8000}, {0x3e0ea000}, {0x3e0ec000}, {0x3e0ee000}, {0x3e0f0000}, {0x3e0f2000}, {0x3e0f4000}, {0x3e0f6000}, {0x3e0f8000}, {0x3e0fa000}, {0x3e0fc000}, {0x3e0fe000}, {0x3e100000}, {0x3e102000}, {0x3e104000}, {0x3e106000}, {0x3e108000}, {0x3e10a000}, {0x3e10c000}, {0x3e10e000}, {0x3e110000}, {0x3e112000}, {0x3e114000}, {0x3e116000}, {0x3e118000}, {0x3e11a000}, {0x3e11c000}, {0x3e11e000}, {0x3e120000}, {0x3e122000}, {0x3e124000}, {0x3e126000}, {0x3e128000}, {0x3e12a000}, {0x3e12c000}, {0x3e12e000}, {0x3e130000}, {0x3e132000}, {0x3e134000}, {0x3e136000}, {0x3e138000}, {0x3e13a000}, {0x3e13c000}, {0x3e13e000}, {0x3e140000}, {0x3e142000}, {0x3e144000}, {0x3e146000}, {0x3e148000}, {0x3e14a000}, {0x3e14c000}, {0x3e14e000}, {0x3e150000}, {0x3e152000}, {0x3e154000}, {0x3e156000}, {0x3e158000}, {0x3e15a000}, {0x3e15c000}, {0x3e15e000}, {0x3e160000}, {0x3e162000}, {0x3e164000}, {0x3e166000}, {0x3e168000}, {0x3e16a000}, {0x3e16c000}, {0x3e16e000}, {0x3e170000}, {0x3e172000}, {0x3e174000}, {0x3e176000}, {0x3e178000}, {0x3e17a000}, {0x3e17c000}, {0x3e17e000}, {0x3e180000}, {0x3e182000}, {0x3e184000}, {0x3e186000}, {0x3e188000}, {0x3e18a000}, {0x3e18c000}, {0x3e18e000}, {0x3e190000}, {0x3e192000}, {0x3e194000}, {0x3e196000}, {0x3e198000}, {0x3e19a000}, {0x3e19c000}, {0x3e19e000}, {0x3e1a0000}, {0x3e1a2000}, {0x3e1a4000}, {0x3e1a6000}, {0x3e1a8000}, {0x3e1aa000}, {0x3e1ac000}, {0x3e1ae000}, {0x3e1b0000}, {0x3e1b2000}, {0x3e1b4000}, {0x3e1b6000}, {0x3e1b8000}, {0x3e1ba000}, {0x3e1bc000}, {0x3e1be000}, {0x3e1c0000}, {0x3e1c2000}, {0x3e1c4000}, {0x3e1c6000}, {0x3e1c8000}, {0x3e1ca000}, {0x3e1cc000}, {0x3e1ce000}, {0x3e1d0000}, {0x3e1d2000}, {0x3e1d4000}, {0x3e1d6000}, {0x3e1d8000}, {0x3e1da000}, {0x3e1dc000}, {0x3e1de000}, {0x3e1e0000}, {0x3e1e2000}, {0x3e1e4000}, {0x3e1e6000}, {0x3e1e8000}, {0x3e1ea000}, {0x3e1ec000}, {0x3e1ee000}, {0x3e1f0000}, {0x3e1f2000}, {0x3e1f4000}, {0x3e1f6000}, {0x3e1f8000}, {0x3e1fa000}, {0x3e1fc000}, {0x3e1fe000}, {0x3e200000}, {0x3e202000}, {0x3e204000}, {0x3e206000}, {0x3e208000}, {0x3e20a000}, {0x3e20c000}, {0x3e20e000}, {0x3e210000}, {0x3e212000}, {0x3e214000}, {0x3e216000}, {0x3e218000}, {0x3e21a000}, {0x3e21c000}, {0x3e21e000}, {0x3e220000}, {0x3e222000}, {0x3e224000}, {0x3e226000}, {0x3e228000}, {0x3e22a000}, {0x3e22c000}, {0x3e22e000}, {0x3e230000}, {0x3e232000}, {0x3e234000}, {0x3e236000}, {0x3e238000}, {0x3e23a000}, {0x3e23c000}, {0x3e23e000}, {0x3e240000}, {0x3e242000}, {0x3e244000}, {0x3e246000}, {0x3e248000}, {0x3e24a000}, {0x3e24c000}, {0x3e24e000}, {0x3e250000}, {0x3e252000}, {0x3e254000}, {0x3e256000}, {0x3e258000}, {0x3e25a000}, {0x3e25c000}, {0x3e25e000}, {0x3e260000}, {0x3e262000}, {0x3e264000}, {0x3e266000}, {0x3e268000}, {0x3e26a000}, {0x3e26c000}, {0x3e26e000}, {0x3e270000}, {0x3e272000}, {0x3e274000}, {0x3e276000}, {0x3e278000}, {0x3e27a000}, {0x3e27c000}, {0x3e27e000}, {0x3e280000}, {0x3e282000}, {0x3e284000}, {0x3e286000}, {0x3e288000}, {0x3e28a000}, {0x3e28c000}, {0x3e28e000}, {0x3e290000}, {0x3e292000}, {0x3e294000}, {0x3e296000}, {0x3e298000}, {0x3e29a000}, {0x3e29c000}, {0x3e29e000}, {0x3e2a0000}, {0x3e2a2000}, {0x3e2a4000}, {0x3e2a6000}, {0x3e2a8000}, {0x3e2aa000}, {0x3e2ac000}, {0x3e2ae000}, {0x3e2b0000}, {0x3e2b2000}, {0x3e2b4000}, {0x3e2b6000}, {0x3e2b8000}, {0x3e2ba000}, {0x3e2bc000}, {0x3e2be000}, {0x3e2c0000}, {0x3e2c2000}, {0x3e2c4000}, {0x3e2c6000}, {0x3e2c8000}, {0x3e2ca000}, {0x3e2cc000}, {0x3e2ce000}, {0x3e2d0000}, {0x3e2d2000}, {0x3e2d4000}, {0x3e2d6000}, {0x3e2d8000}, {0x3e2da000}, {0x3e2dc000}, {0x3e2de000}, {0x3e2e0000}, {0x3e2e2000}, {0x3e2e4000}, {0x3e2e6000}, {0x3e2e8000}, {0x3e2ea000}, {0x3e2ec000}, {0x3e2ee000}, {0x3e2f0000}, {0x3e2f2000}, {0x3e2f4000}, {0x3e2f6000}, {0x3e2f8000}, {0x3e2fa000}, {0x3e2fc000}, {0x3e2fe000}, {0x3e300000}, {0x3e302000}, {0x3e304000}, {0x3e306000}, {0x3e308000}, {0x3e30a000}, {0x3e30c000}, {0x3e30e000}, {0x3e310000}, {0x3e312000}, {0x3e314000}, {0x3e316000}, {0x3e318000}, {0x3e31a000}, {0x3e31c000}, {0x3e31e000}, {0x3e320000}, {0x3e322000}, {0x3e324000}, {0x3e326000}, {0x3e328000}, {0x3e32a000}, {0x3e32c000}, {0x3e32e000}, {0x3e330000}, {0x3e332000}, {0x3e334000}, {0x3e336000}, {0x3e338000}, {0x3e33a000}, {0x3e33c000}, {0x3e33e000}, {0x3e340000}, {0x3e342000}, {0x3e344000}, {0x3e346000}, {0x3e348000}, {0x3e34a000}, {0x3e34c000}, {0x3e34e000}, {0x3e350000}, {0x3e352000}, {0x3e354000}, {0x3e356000}, {0x3e358000}, {0x3e35a000}, {0x3e35c000}, {0x3e35e000}, {0x3e360000}, {0x3e362000}, {0x3e364000}, {0x3e366000}, {0x3e368000}, {0x3e36a000}, {0x3e36c000}, {0x3e36e000}, {0x3e370000}, {0x3e372000}, {0x3e374000}, {0x3e376000}, {0x3e378000}, {0x3e37a000}, {0x3e37c000}, {0x3e37e000}, {0x3e380000}, {0x3e382000}, {0x3e384000}, {0x3e386000}, {0x3e388000}, {0x3e38a000}, {0x3e38c000}, {0x3e38e000}, {0x3e390000}, {0x3e392000}, {0x3e394000}, {0x3e396000}, {0x3e398000}, {0x3e39a000}, {0x3e39c000}, {0x3e39e000}, {0x3e3a0000}, {0x3e3a2000}, {0x3e3a4000}, {0x3e3a6000}, {0x3e3a8000}, {0x3e3aa000}, {0x3e3ac000}, {0x3e3ae000}, {0x3e3b0000}, {0x3e3b2000}, {0x3e3b4000}, {0x3e3b6000}, {0x3e3b8000}, {0x3e3ba000}, {0x3e3bc000}, {0x3e3be000}, {0x3e3c0000}, {0x3e3c2000}, {0x3e3c4000}, {0x3e3c6000}, {0x3e3c8000}, {0x3e3ca000}, {0x3e3cc000}, {0x3e3ce000}, {0x3e3d0000}, {0x3e3d2000}, {0x3e3d4000}, {0x3e3d6000}, {0x3e3d8000}, {0x3e3da000}, {0x3e3dc000}, {0x3e3de000}, {0x3e3e0000}, {0x3e3e2000}, {0x3e3e4000}, {0x3e3e6000}, {0x3e3e8000}, {0x3e3ea000}, {0x3e3ec000}, {0x3e3ee000}, {0x3e3f0000}, {0x3e3f2000}, {0x3e3f4000}, {0x3e3f6000}, {0x3e3f8000}, {0x3e3fa000}, {0x3e3fc000}, {0x3e3fe000}, {0x3e400000}, {0x3e402000}, {0x3e404000}, {0x3e406000}, {0x3e408000}, {0x3e40a000}, {0x3e40c000}, {0x3e40e000}, {0x3e410000}, {0x3e412000}, {0x3e414000}, {0x3e416000}, {0x3e418000}, {0x3e41a000}, {0x3e41c000}, {0x3e41e000}, {0x3e420000}, {0x3e422000}, {0x3e424000}, {0x3e426000}, {0x3e428000}, {0x3e42a000}, {0x3e42c000}, {0x3e42e000}, {0x3e430000}, {0x3e432000}, {0x3e434000}, {0x3e436000}, {0x3e438000}, {0x3e43a000}, {0x3e43c000}, {0x3e43e000}, {0x3e440000}, {0x3e442000}, {0x3e444000}, {0x3e446000}, {0x3e448000}, {0x3e44a000}, {0x3e44c000}, {0x3e44e000}, {0x3e450000}, {0x3e452000}, {0x3e454000}, {0x3e456000}, {0x3e458000}, {0x3e45a000}, {0x3e45c000}, {0x3e45e000}, {0x3e460000}, {0x3e462000}, {0x3e464000}, {0x3e466000}, {0x3e468000}, {0x3e46a000}, {0x3e46c000}, {0x3e46e000}, {0x3e470000}, {0x3e472000}, {0x3e474000}, {0x3e476000}, {0x3e478000}, {0x3e47a000}, {0x3e47c000}, {0x3e47e000}, {0x3e480000}, {0x3e482000}, {0x3e484000}, {0x3e486000}, {0x3e488000}, {0x3e48a000}, {0x3e48c000}, {0x3e48e000}, {0x3e490000}, {0x3e492000}, {0x3e494000}, {0x3e496000}, {0x3e498000}, {0x3e49a000}, {0x3e49c000}, {0x3e49e000}, {0x3e4a0000}, {0x3e4a2000}, {0x3e4a4000}, {0x3e4a6000}, {0x3e4a8000}, {0x3e4aa000}, {0x3e4ac000}, {0x3e4ae000}, {0x3e4b0000}, {0x3e4b2000}, {0x3e4b4000}, {0x3e4b6000}, {0x3e4b8000}, {0x3e4ba000}, {0x3e4bc000}, {0x3e4be000}, {0x3e4c0000}, {0x3e4c2000}, {0x3e4c4000}, {0x3e4c6000}, {0x3e4c8000}, {0x3e4ca000}, {0x3e4cc000}, {0x3e4ce000}, {0x3e4d0000}, {0x3e4d2000}, {0x3e4d4000}, {0x3e4d6000}, {0x3e4d8000}, {0x3e4da000}, {0x3e4dc000}, {0x3e4de000}, {0x3e4e0000}, {0x3e4e2000}, {0x3e4e4000}, {0x3e4e6000}, {0x3e4e8000}, {0x3e4ea000}, {0x3e4ec000}, {0x3e4ee000}, {0x3e4f0000}, {0x3e4f2000}, {0x3e4f4000}, {0x3e4f6000}, {0x3e4f8000}, {0x3e4fa000}, {0x3e4fc000}, {0x3e4fe000}, {0x3e500000}, {0x3e502000}, {0x3e504000}, {0x3e506000}, {0x3e508000}, {0x3e50a000}, {0x3e50c000}, {0x3e50e000}, {0x3e510000}, {0x3e512000}, {0x3e514000}, {0x3e516000}, {0x3e518000}, {0x3e51a000}, {0x3e51c000}, {0x3e51e000}, {0x3e520000}, {0x3e522000}, {0x3e524000}, {0x3e526000}, {0x3e528000}, {0x3e52a000}, {0x3e52c000}, {0x3e52e000}, {0x3e530000}, {0x3e532000}, {0x3e534000}, {0x3e536000}, {0x3e538000}, {0x3e53a000}, {0x3e53c000}, {0x3e53e000}, {0x3e540000}, {0x3e542000}, {0x3e544000}, {0x3e546000}, {0x3e548000}, {0x3e54a000}, {0x3e54c000}, {0x3e54e000}, {0x3e550000}, {0x3e552000}, {0x3e554000}, {0x3e556000}, {0x3e558000}, {0x3e55a000}, {0x3e55c000}, {0x3e55e000}, {0x3e560000}, {0x3e562000}, {0x3e564000}, {0x3e566000}, {0x3e568000}, {0x3e56a000}, {0x3e56c000}, {0x3e56e000}, {0x3e570000}, {0x3e572000}, {0x3e574000}, {0x3e576000}, {0x3e578000}, {0x3e57a000}, {0x3e57c000}, {0x3e57e000}, {0x3e580000}, {0x3e582000}, {0x3e584000}, {0x3e586000}, {0x3e588000}, {0x3e58a000}, {0x3e58c000}, {0x3e58e000}, {0x3e590000}, {0x3e592000}, {0x3e594000}, {0x3e596000}, {0x3e598000}, {0x3e59a000}, {0x3e59c000}, {0x3e59e000}, {0x3e5a0000}, {0x3e5a2000}, {0x3e5a4000}, {0x3e5a6000}, {0x3e5a8000}, {0x3e5aa000}, {0x3e5ac000}, {0x3e5ae000}, {0x3e5b0000}, {0x3e5b2000}, {0x3e5b4000}, {0x3e5b6000}, {0x3e5b8000}, {0x3e5ba000}, {0x3e5bc000}, {0x3e5be000}, {0x3e5c0000}, {0x3e5c2000}, {0x3e5c4000}, {0x3e5c6000}, {0x3e5c8000}, {0x3e5ca000}, {0x3e5cc000}, {0x3e5ce000}, {0x3e5d0000}, {0x3e5d2000}, {0x3e5d4000}, {0x3e5d6000}, {0x3e5d8000}, {0x3e5da000}, {0x3e5dc000}, {0x3e5de000}, {0x3e5e0000}, {0x3e5e2000}, {0x3e5e4000}, {0x3e5e6000}, {0x3e5e8000}, {0x3e5ea000}, {0x3e5ec000}, {0x3e5ee000}, {0x3e5f0000}, {0x3e5f2000}, {0x3e5f4000}, {0x3e5f6000}, {0x3e5f8000}, {0x3e5fa000}, {0x3e5fc000}, {0x3e5fe000}, {0x3e600000}, {0x3e602000}, {0x3e604000}, {0x3e606000}, {0x3e608000}, {0x3e60a000}, {0x3e60c000}, {0x3e60e000}, {0x3e610000}, {0x3e612000}, {0x3e614000}, {0x3e616000}, {0x3e618000}, {0x3e61a000}, {0x3e61c000}, {0x3e61e000}, {0x3e620000}, {0x3e622000}, {0x3e624000}, {0x3e626000}, {0x3e628000}, {0x3e62a000}, {0x3e62c000}, {0x3e62e000}, {0x3e630000}, {0x3e632000}, {0x3e634000}, {0x3e636000}, {0x3e638000}, {0x3e63a000}, {0x3e63c000}, {0x3e63e000}, {0x3e640000}, {0x3e642000}, {0x3e644000}, {0x3e646000}, {0x3e648000}, {0x3e64a000}, {0x3e64c000}, {0x3e64e000}, {0x3e650000}, {0x3e652000}, {0x3e654000}, {0x3e656000}, {0x3e658000}, {0x3e65a000}, {0x3e65c000}, {0x3e65e000}, {0x3e660000}, {0x3e662000}, {0x3e664000}, {0x3e666000}, {0x3e668000}, {0x3e66a000}, {0x3e66c000}, {0x3e66e000}, {0x3e670000}, {0x3e672000}, {0x3e674000}, {0x3e676000}, {0x3e678000}, {0x3e67a000}, {0x3e67c000}, {0x3e67e000}, {0x3e680000}, {0x3e682000}, {0x3e684000}, {0x3e686000}, {0x3e688000}, {0x3e68a000}, {0x3e68c000}, {0x3e68e000}, {0x3e690000}, {0x3e692000}, {0x3e694000}, {0x3e696000}, {0x3e698000}, {0x3e69a000}, {0x3e69c000}, {0x3e69e000}, {0x3e6a0000}, {0x3e6a2000}, {0x3e6a4000}, {0x3e6a6000}, {0x3e6a8000}, {0x3e6aa000}, {0x3e6ac000}, {0x3e6ae000}, {0x3e6b0000}, {0x3e6b2000}, {0x3e6b4000}, {0x3e6b6000}, {0x3e6b8000}, {0x3e6ba000}, {0x3e6bc000}, {0x3e6be000}, {0x3e6c0000}, {0x3e6c2000}, {0x3e6c4000}, {0x3e6c6000}, {0x3e6c8000}, {0x3e6ca000}, {0x3e6cc000}, {0x3e6ce000}, {0x3e6d0000}, {0x3e6d2000}, {0x3e6d4000}, {0x3e6d6000}, {0x3e6d8000}, {0x3e6da000}, {0x3e6dc000}, {0x3e6de000}, {0x3e6e0000}, {0x3e6e2000}, {0x3e6e4000}, {0x3e6e6000}, {0x3e6e8000}, {0x3e6ea000}, {0x3e6ec000}, {0x3e6ee000}, {0x3e6f0000}, {0x3e6f2000}, {0x3e6f4000}, {0x3e6f6000}, {0x3e6f8000}, {0x3e6fa000}, {0x3e6fc000}, {0x3e6fe000}, {0x3e700000}, {0x3e702000}, {0x3e704000}, {0x3e706000}, {0x3e708000}, {0x3e70a000}, {0x3e70c000}, {0x3e70e000}, {0x3e710000}, {0x3e712000}, {0x3e714000}, {0x3e716000}, {0x3e718000}, {0x3e71a000}, {0x3e71c000}, {0x3e71e000}, {0x3e720000}, {0x3e722000}, {0x3e724000}, {0x3e726000}, {0x3e728000}, {0x3e72a000}, {0x3e72c000}, {0x3e72e000}, {0x3e730000}, {0x3e732000}, {0x3e734000}, {0x3e736000}, {0x3e738000}, {0x3e73a000}, {0x3e73c000}, {0x3e73e000}, {0x3e740000}, {0x3e742000}, {0x3e744000}, {0x3e746000}, {0x3e748000}, {0x3e74a000}, {0x3e74c000}, {0x3e74e000}, {0x3e750000}, {0x3e752000}, {0x3e754000}, {0x3e756000}, {0x3e758000}, {0x3e75a000}, {0x3e75c000}, {0x3e75e000}, {0x3e760000}, {0x3e762000}, {0x3e764000}, {0x3e766000}, {0x3e768000}, {0x3e76a000}, {0x3e76c000}, {0x3e76e000}, {0x3e770000}, {0x3e772000}, {0x3e774000}, {0x3e776000}, {0x3e778000}, {0x3e77a000}, {0x3e77c000}, {0x3e77e000}, {0x3e780000}, {0x3e782000}, {0x3e784000}, {0x3e786000}, {0x3e788000}, {0x3e78a000}, {0x3e78c000}, {0x3e78e000}, {0x3e790000}, {0x3e792000}, {0x3e794000}, {0x3e796000}, {0x3e798000}, {0x3e79a000}, {0x3e79c000}, {0x3e79e000}, {0x3e7a0000}, {0x3e7a2000}, {0x3e7a4000}, {0x3e7a6000}, {0x3e7a8000}, {0x3e7aa000}, {0x3e7ac000}, {0x3e7ae000}, {0x3e7b0000}, {0x3e7b2000}, {0x3e7b4000}, {0x3e7b6000}, {0x3e7b8000}, {0x3e7ba000}, {0x3e7bc000}, {0x3e7be000}, {0x3e7c0000}, {0x3e7c2000}, {0x3e7c4000}, {0x3e7c6000}, {0x3e7c8000}, {0x3e7ca000}, {0x3e7cc000}, {0x3e7ce000}, {0x3e7d0000}, {0x3e7d2000}, {0x3e7d4000}, {0x3e7d6000}, {0x3e7d8000}, {0x3e7da000}, {0x3e7dc000}, {0x3e7de000}, {0x3e7e0000}, {0x3e7e2000}, {0x3e7e4000}, {0x3e7e6000}, {0x3e7e8000}, {0x3e7ea000}, {0x3e7ec000}, {0x3e7ee000}, {0x3e7f0000}, {0x3e7f2000}, {0x3e7f4000}, {0x3e7f6000}, {0x3e7f8000}, {0x3e7fa000}, {0x3e7fc000}, {0x3e7fe000}, {0x3e800000}, {0x3e802000}, {0x3e804000}, {0x3e806000}, {0x3e808000}, {0x3e80a000}, {0x3e80c000}, {0x3e80e000}, {0x3e810000}, {0x3e812000}, {0x3e814000}, {0x3e816000}, {0x3e818000}, {0x3e81a000}, {0x3e81c000}, {0x3e81e000}, {0x3e820000}, {0x3e822000}, {0x3e824000}, {0x3e826000}, {0x3e828000}, {0x3e82a000}, {0x3e82c000}, {0x3e82e000}, {0x3e830000}, {0x3e832000}, {0x3e834000}, {0x3e836000}, {0x3e838000}, {0x3e83a000}, {0x3e83c000}, {0x3e83e000}, {0x3e840000}, {0x3e842000}, {0x3e844000}, {0x3e846000}, {0x3e848000}, {0x3e84a000}, {0x3e84c000}, {0x3e84e000}, {0x3e850000}, {0x3e852000}, {0x3e854000}, {0x3e856000}, {0x3e858000}, {0x3e85a000}, {0x3e85c000}, {0x3e85e000}, {0x3e860000}, {0x3e862000}, {0x3e864000}, {0x3e866000}, {0x3e868000}, {0x3e86a000}, {0x3e86c000}, {0x3e86e000}, {0x3e870000}, {0x3e872000}, {0x3e874000}, {0x3e876000}, {0x3e878000}, {0x3e87a000}, {0x3e87c000}, {0x3e87e000}, {0x3e880000}, {0x3e882000}, {0x3e884000}, {0x3e886000}, {0x3e888000}, {0x3e88a000}, {0x3e88c000}, {0x3e88e000}, {0x3e890000}, {0x3e892000}, {0x3e894000}, {0x3e896000}, {0x3e898000}, {0x3e89a000}, {0x3e89c000}, {0x3e89e000}, {0x3e8a0000}, {0x3e8a2000}, {0x3e8a4000}, {0x3e8a6000}, {0x3e8a8000}, {0x3e8aa000}, {0x3e8ac000}, {0x3e8ae000}, {0x3e8b0000}, {0x3e8b2000}, {0x3e8b4000}, {0x3e8b6000}, {0x3e8b8000}, {0x3e8ba000}, {0x3e8bc000}, {0x3e8be000}, {0x3e8c0000}, {0x3e8c2000}, {0x3e8c4000}, {0x3e8c6000}, {0x3e8c8000}, {0x3e8ca000}, {0x3e8cc000}, {0x3e8ce000}, {0x3e8d0000}, {0x3e8d2000}, {0x3e8d4000}, {0x3e8d6000}, {0x3e8d8000}, {0x3e8da000}, {0x3e8dc000}, {0x3e8de000}, {0x3e8e0000}, {0x3e8e2000}, {0x3e8e4000}, {0x3e8e6000}, {0x3e8e8000}, {0x3e8ea000}, {0x3e8ec000}, {0x3e8ee000}, {0x3e8f0000}, {0x3e8f2000}, {0x3e8f4000}, {0x3e8f6000}, {0x3e8f8000}, {0x3e8fa000}, {0x3e8fc000}, {0x3e8fe000}, {0x3e900000}, {0x3e902000}, {0x3e904000}, {0x3e906000}, {0x3e908000}, {0x3e90a000}, {0x3e90c000}, {0x3e90e000}, {0x3e910000}, {0x3e912000}, {0x3e914000}, {0x3e916000}, {0x3e918000}, {0x3e91a000}, {0x3e91c000}, {0x3e91e000}, {0x3e920000}, {0x3e922000}, {0x3e924000}, {0x3e926000}, {0x3e928000}, {0x3e92a000}, {0x3e92c000}, {0x3e92e000}, {0x3e930000}, {0x3e932000}, {0x3e934000}, {0x3e936000}, {0x3e938000}, {0x3e93a000}, {0x3e93c000}, {0x3e93e000}, {0x3e940000}, {0x3e942000}, {0x3e944000}, {0x3e946000}, {0x3e948000}, {0x3e94a000}, {0x3e94c000}, {0x3e94e000}, {0x3e950000}, {0x3e952000}, {0x3e954000}, {0x3e956000}, {0x3e958000}, {0x3e95a000}, {0x3e95c000}, {0x3e95e000}, {0x3e960000}, {0x3e962000}, {0x3e964000}, {0x3e966000}, {0x3e968000}, {0x3e96a000}, {0x3e96c000}, {0x3e96e000}, {0x3e970000}, {0x3e972000}, {0x3e974000}, {0x3e976000}, {0x3e978000}, {0x3e97a000}, {0x3e97c000}, {0x3e97e000}, {0x3e980000}, {0x3e982000}, {0x3e984000}, {0x3e986000}, {0x3e988000}, {0x3e98a000}, {0x3e98c000}, {0x3e98e000}, {0x3e990000}, {0x3e992000}, {0x3e994000}, {0x3e996000}, {0x3e998000}, {0x3e99a000}, {0x3e99c000}, {0x3e99e000}, {0x3e9a0000}, {0x3e9a2000}, {0x3e9a4000}, {0x3e9a6000}, {0x3e9a8000}, {0x3e9aa000}, {0x3e9ac000}, {0x3e9ae000}, {0x3e9b0000}, {0x3e9b2000}, {0x3e9b4000}, {0x3e9b6000}, {0x3e9b8000}, {0x3e9ba000}, {0x3e9bc000}, {0x3e9be000}, {0x3e9c0000}, {0x3e9c2000}, {0x3e9c4000}, {0x3e9c6000}, {0x3e9c8000}, {0x3e9ca000}, {0x3e9cc000}, {0x3e9ce000}, {0x3e9d0000}, {0x3e9d2000}, {0x3e9d4000}, {0x3e9d6000}, {0x3e9d8000}, {0x3e9da000}, {0x3e9dc000}, {0x3e9de000}, {0x3e9e0000}, {0x3e9e2000}, {0x3e9e4000}, {0x3e9e6000}, {0x3e9e8000}, {0x3e9ea000}, {0x3e9ec000}, {0x3e9ee000}, {0x3e9f0000}, {0x3e9f2000}, {0x3e9f4000}, {0x3e9f6000}, {0x3e9f8000}, {0x3e9fa000}, {0x3e9fc000}, {0x3e9fe000}, {0x3ea00000}, {0x3ea02000}, {0x3ea04000}, {0x3ea06000}, {0x3ea08000}, {0x3ea0a000}, {0x3ea0c000}, {0x3ea0e000}, {0x3ea10000}, {0x3ea12000}, {0x3ea14000}, {0x3ea16000}, {0x3ea18000}, {0x3ea1a000}, {0x3ea1c000}, {0x3ea1e000}, {0x3ea20000}, {0x3ea22000}, {0x3ea24000}, {0x3ea26000}, {0x3ea28000}, {0x3ea2a000}, {0x3ea2c000}, {0x3ea2e000}, {0x3ea30000}, {0x3ea32000}, {0x3ea34000}, {0x3ea36000}, {0x3ea38000}, {0x3ea3a000}, {0x3ea3c000}, {0x3ea3e000}, {0x3ea40000}, {0x3ea42000}, {0x3ea44000}, {0x3ea46000}, {0x3ea48000}, {0x3ea4a000}, {0x3ea4c000}, {0x3ea4e000}, {0x3ea50000}, {0x3ea52000}, {0x3ea54000}, {0x3ea56000}, {0x3ea58000}, {0x3ea5a000}, {0x3ea5c000}, {0x3ea5e000}, {0x3ea60000}, {0x3ea62000}, {0x3ea64000}, {0x3ea66000}, {0x3ea68000}, {0x3ea6a000}, {0x3ea6c000}, {0x3ea6e000}, {0x3ea70000}, {0x3ea72000}, {0x3ea74000}, {0x3ea76000}, {0x3ea78000}, {0x3ea7a000}, {0x3ea7c000}, {0x3ea7e000}, {0x3ea80000}, {0x3ea82000}, {0x3ea84000}, {0x3ea86000}, {0x3ea88000}, {0x3ea8a000}, {0x3ea8c000}, {0x3ea8e000}, {0x3ea90000}, {0x3ea92000}, {0x3ea94000}, {0x3ea96000}, {0x3ea98000}, {0x3ea9a000}, {0x3ea9c000}, {0x3ea9e000}, {0x3eaa0000}, {0x3eaa2000}, {0x3eaa4000}, {0x3eaa6000}, {0x3eaa8000}, {0x3eaaa000}, {0x3eaac000}, {0x3eaae000}, {0x3eab0000}, {0x3eab2000}, {0x3eab4000}, {0x3eab6000}, {0x3eab8000}, {0x3eaba000}, {0x3eabc000}, {0x3eabe000}, {0x3eac0000}, {0x3eac2000}, {0x3eac4000}, {0x3eac6000}, {0x3eac8000}, {0x3eaca000}, {0x3eacc000}, {0x3eace000}, {0x3ead0000}, {0x3ead2000}, {0x3ead4000}, {0x3ead6000}, {0x3ead8000}, {0x3eada000}, {0x3eadc000}, {0x3eade000}, {0x3eae0000}, {0x3eae2000}, {0x3eae4000}, {0x3eae6000}, {0x3eae8000}, {0x3eaea000}, {0x3eaec000}, {0x3eaee000}, {0x3eaf0000}, {0x3eaf2000}, {0x3eaf4000}, {0x3eaf6000}, {0x3eaf8000}, {0x3eafa000}, {0x3eafc000}, {0x3eafe000}, {0x3eb00000}, {0x3eb02000}, {0x3eb04000}, {0x3eb06000}, {0x3eb08000}, {0x3eb0a000}, {0x3eb0c000}, {0x3eb0e000}, {0x3eb10000}, {0x3eb12000}, {0x3eb14000}, {0x3eb16000}, {0x3eb18000}, {0x3eb1a000}, {0x3eb1c000}, {0x3eb1e000}, {0x3eb20000}, {0x3eb22000}, {0x3eb24000}, {0x3eb26000}, {0x3eb28000}, {0x3eb2a000}, {0x3eb2c000}, {0x3eb2e000}, {0x3eb30000}, {0x3eb32000}, {0x3eb34000}, {0x3eb36000}, {0x3eb38000}, {0x3eb3a000}, {0x3eb3c000}, {0x3eb3e000}, {0x3eb40000}, {0x3eb42000}, {0x3eb44000}, {0x3eb46000}, {0x3eb48000}, {0x3eb4a000}, {0x3eb4c000}, {0x3eb4e000}, {0x3eb50000}, {0x3eb52000}, {0x3eb54000}, {0x3eb56000}, {0x3eb58000}, {0x3eb5a000}, {0x3eb5c000}, {0x3eb5e000}, {0x3eb60000}, {0x3eb62000}, {0x3eb64000}, {0x3eb66000}, {0x3eb68000}, {0x3eb6a000}, {0x3eb6c000}, {0x3eb6e000}, {0x3eb70000}, {0x3eb72000}, {0x3eb74000}, {0x3eb76000}, {0x3eb78000}, {0x3eb7a000}, {0x3eb7c000}, {0x3eb7e000}, {0x3eb80000}, {0x3eb82000}, {0x3eb84000}, {0x3eb86000}, {0x3eb88000}, {0x3eb8a000}, {0x3eb8c000}, {0x3eb8e000}, {0x3eb90000}, {0x3eb92000}, {0x3eb94000}, {0x3eb96000}, {0x3eb98000}, {0x3eb9a000}, {0x3eb9c000}, {0x3eb9e000}, {0x3eba0000}, {0x3eba2000}, {0x3eba4000}, {0x3eba6000}, {0x3eba8000}, {0x3ebaa000}, {0x3ebac000}, {0x3ebae000}, {0x3ebb0000}, {0x3ebb2000}, {0x3ebb4000}, {0x3ebb6000}, {0x3ebb8000}, {0x3ebba000}, {0x3ebbc000}, {0x3ebbe000}, {0x3ebc0000}, {0x3ebc2000}, {0x3ebc4000}, {0x3ebc6000}, {0x3ebc8000}, {0x3ebca000}, {0x3ebcc000}, {0x3ebce000}, {0x3ebd0000}, {0x3ebd2000}, {0x3ebd4000}, {0x3ebd6000}, {0x3ebd8000}, {0x3ebda000}, {0x3ebdc000}, {0x3ebde000}, {0x3ebe0000}, {0x3ebe2000}, {0x3ebe4000}, {0x3ebe6000}, {0x3ebe8000}, {0x3ebea000}, {0x3ebec000}, {0x3ebee000}, {0x3ebf0000}, {0x3ebf2000}, {0x3ebf4000}, {0x3ebf6000}, {0x3ebf8000}, {0x3ebfa000}, {0x3ebfc000}, {0x3ebfe000}, {0x3ec00000}, {0x3ec02000}, {0x3ec04000}, {0x3ec06000}, {0x3ec08000}, {0x3ec0a000}, {0x3ec0c000}, {0x3ec0e000}, {0x3ec10000}, {0x3ec12000}, {0x3ec14000}, {0x3ec16000}, {0x3ec18000}, {0x3ec1a000}, {0x3ec1c000}, {0x3ec1e000}, {0x3ec20000}, {0x3ec22000}, {0x3ec24000}, {0x3ec26000}, {0x3ec28000}, {0x3ec2a000}, {0x3ec2c000}, {0x3ec2e000}, {0x3ec30000}, {0x3ec32000}, {0x3ec34000}, {0x3ec36000}, {0x3ec38000}, {0x3ec3a000}, {0x3ec3c000}, {0x3ec3e000}, {0x3ec40000}, {0x3ec42000}, {0x3ec44000}, {0x3ec46000}, {0x3ec48000}, {0x3ec4a000}, {0x3ec4c000}, {0x3ec4e000}, {0x3ec50000}, {0x3ec52000}, {0x3ec54000}, {0x3ec56000}, {0x3ec58000}, {0x3ec5a000}, {0x3ec5c000}, {0x3ec5e000}, {0x3ec60000}, {0x3ec62000}, {0x3ec64000}, {0x3ec66000}, {0x3ec68000}, {0x3ec6a000}, {0x3ec6c000}, {0x3ec6e000}, {0x3ec70000}, {0x3ec72000}, {0x3ec74000}, {0x3ec76000}, {0x3ec78000}, {0x3ec7a000}, {0x3ec7c000}, {0x3ec7e000}, {0x3ec80000}, {0x3ec82000}, {0x3ec84000}, {0x3ec86000}, {0x3ec88000}, {0x3ec8a000}, {0x3ec8c000}, {0x3ec8e000}, {0x3ec90000}, {0x3ec92000}, {0x3ec94000}, {0x3ec96000}, {0x3ec98000}, {0x3ec9a000}, {0x3ec9c000}, {0x3ec9e000}, {0x3eca0000}, {0x3eca2000}, {0x3eca4000}, {0x3eca6000}, {0x3eca8000}, {0x3ecaa000}, {0x3ecac000}, {0x3ecae000}, {0x3ecb0000}, {0x3ecb2000}, {0x3ecb4000}, {0x3ecb6000}, {0x3ecb8000}, {0x3ecba000}, {0x3ecbc000}, {0x3ecbe000}, {0x3ecc0000}, {0x3ecc2000}, {0x3ecc4000}, {0x3ecc6000}, {0x3ecc8000}, {0x3ecca000}, {0x3eccc000}, {0x3ecce000}, {0x3ecd0000}, {0x3ecd2000}, {0x3ecd4000}, {0x3ecd6000}, {0x3ecd8000}, {0x3ecda000}, {0x3ecdc000}, {0x3ecde000}, {0x3ece0000}, {0x3ece2000}, {0x3ece4000}, {0x3ece6000}, {0x3ece8000}, {0x3ecea000}, {0x3ecec000}, {0x3ecee000}, {0x3ecf0000}, {0x3ecf2000}, {0x3ecf4000}, {0x3ecf6000}, {0x3ecf8000}, {0x3ecfa000}, {0x3ecfc000}, {0x3ecfe000}, {0x3ed00000}, {0x3ed02000}, {0x3ed04000}, {0x3ed06000}, {0x3ed08000}, {0x3ed0a000}, {0x3ed0c000}, {0x3ed0e000}, {0x3ed10000}, {0x3ed12000}, {0x3ed14000}, {0x3ed16000}, {0x3ed18000}, {0x3ed1a000}, {0x3ed1c000}, {0x3ed1e000}, {0x3ed20000}, {0x3ed22000}, {0x3ed24000}, {0x3ed26000}, {0x3ed28000}, {0x3ed2a000}, {0x3ed2c000}, {0x3ed2e000}, {0x3ed30000}, {0x3ed32000}, {0x3ed34000}, {0x3ed36000}, {0x3ed38000}, {0x3ed3a000}, {0x3ed3c000}, {0x3ed3e000}, {0x3ed40000}, {0x3ed42000}, {0x3ed44000}, {0x3ed46000}, {0x3ed48000}, {0x3ed4a000}, {0x3ed4c000}, {0x3ed4e000}, {0x3ed50000}, {0x3ed52000}, {0x3ed54000}, {0x3ed56000}, {0x3ed58000}, {0x3ed5a000}, {0x3ed5c000}, {0x3ed5e000}, {0x3ed60000}, {0x3ed62000}, {0x3ed64000}, {0x3ed66000}, {0x3ed68000}, {0x3ed6a000}, {0x3ed6c000}, {0x3ed6e000}, {0x3ed70000}, {0x3ed72000}, {0x3ed74000}, {0x3ed76000}, {0x3ed78000}, {0x3ed7a000}, {0x3ed7c000}, {0x3ed7e000}, {0x3ed80000}, {0x3ed82000}, {0x3ed84000}, {0x3ed86000}, {0x3ed88000}, {0x3ed8a000}, {0x3ed8c000}, {0x3ed8e000}, {0x3ed90000}, {0x3ed92000}, {0x3ed94000}, {0x3ed96000}, {0x3ed98000}, {0x3ed9a000}, {0x3ed9c000}, {0x3ed9e000}, {0x3eda0000}, {0x3eda2000}, {0x3eda4000}, {0x3eda6000}, {0x3eda8000}, {0x3edaa000}, {0x3edac000}, {0x3edae000}, {0x3edb0000}, {0x3edb2000}, {0x3edb4000}, {0x3edb6000}, {0x3edb8000}, {0x3edba000}, {0x3edbc000}, {0x3edbe000}, {0x3edc0000}, {0x3edc2000}, {0x3edc4000}, {0x3edc6000}, {0x3edc8000}, {0x3edca000}, {0x3edcc000}, {0x3edce000}, {0x3edd0000}, {0x3edd2000}, {0x3edd4000}, {0x3edd6000}, {0x3edd8000}, {0x3edda000}, {0x3eddc000}, {0x3edde000}, {0x3ede0000}, {0x3ede2000}, {0x3ede4000}, {0x3ede6000}, {0x3ede8000}, {0x3edea000}, {0x3edec000}, {0x3edee000}, {0x3edf0000}, {0x3edf2000}, {0x3edf4000}, {0x3edf6000}, {0x3edf8000}, {0x3edfa000}, {0x3edfc000}, {0x3edfe000}, {0x3ee00000}, {0x3ee02000}, {0x3ee04000}, {0x3ee06000}, {0x3ee08000}, {0x3ee0a000}, {0x3ee0c000}, {0x3ee0e000}, {0x3ee10000}, {0x3ee12000}, {0x3ee14000}, {0x3ee16000}, {0x3ee18000}, {0x3ee1a000}, {0x3ee1c000}, {0x3ee1e000}, {0x3ee20000}, {0x3ee22000}, {0x3ee24000}, {0x3ee26000}, {0x3ee28000}, {0x3ee2a000}, {0x3ee2c000}, {0x3ee2e000}, {0x3ee30000}, {0x3ee32000}, {0x3ee34000}, {0x3ee36000}, {0x3ee38000}, {0x3ee3a000}, {0x3ee3c000}, {0x3ee3e000}, {0x3ee40000}, {0x3ee42000}, {0x3ee44000}, {0x3ee46000}, {0x3ee48000}, {0x3ee4a000}, {0x3ee4c000}, {0x3ee4e000}, {0x3ee50000}, {0x3ee52000}, {0x3ee54000}, {0x3ee56000}, {0x3ee58000}, {0x3ee5a000}, {0x3ee5c000}, {0x3ee5e000}, {0x3ee60000}, {0x3ee62000}, {0x3ee64000}, {0x3ee66000}, {0x3ee68000}, {0x3ee6a000}, {0x3ee6c000}, {0x3ee6e000}, {0x3ee70000}, {0x3ee72000}, {0x3ee74000}, {0x3ee76000}, {0x3ee78000}, {0x3ee7a000}, {0x3ee7c000}, {0x3ee7e000}, {0x3ee80000}, {0x3ee82000}, {0x3ee84000}, {0x3ee86000}, {0x3ee88000}, {0x3ee8a000}, {0x3ee8c000}, {0x3ee8e000}, {0x3ee90000}, {0x3ee92000}, {0x3ee94000}, {0x3ee96000}, {0x3ee98000}, {0x3ee9a000}, {0x3ee9c000}, {0x3ee9e000}, {0x3eea0000}, {0x3eea2000}, {0x3eea4000}, {0x3eea6000}, {0x3eea8000}, {0x3eeaa000}, {0x3eeac000}, {0x3eeae000}, {0x3eeb0000}, {0x3eeb2000}, {0x3eeb4000}, {0x3eeb6000}, {0x3eeb8000}, {0x3eeba000}, {0x3eebc000}, {0x3eebe000}, {0x3eec0000}, {0x3eec2000}, {0x3eec4000}, {0x3eec6000}, {0x3eec8000}, {0x3eeca000}, {0x3eecc000}, {0x3eece000}, {0x3eed0000}, {0x3eed2000}, {0x3eed4000}, {0x3eed6000}, {0x3eed8000}, {0x3eeda000}, {0x3eedc000}, {0x3eede000}, {0x3eee0000}, {0x3eee2000}, {0x3eee4000}, {0x3eee6000}, {0x3eee8000}, {0x3eeea000}, {0x3eeec000}, {0x3eeee000}, {0x3eef0000}, {0x3eef2000}, {0x3eef4000}, {0x3eef6000}, {0x3eef8000}, {0x3eefa000}, {0x3eefc000}, {0x3eefe000}, {0x3ef00000}, {0x3ef02000}, {0x3ef04000}, {0x3ef06000}, {0x3ef08000}, {0x3ef0a000}, {0x3ef0c000}, {0x3ef0e000}, {0x3ef10000}, {0x3ef12000}, {0x3ef14000}, {0x3ef16000}, {0x3ef18000}, {0x3ef1a000}, {0x3ef1c000}, {0x3ef1e000}, {0x3ef20000}, {0x3ef22000}, {0x3ef24000}, {0x3ef26000}, {0x3ef28000}, {0x3ef2a000}, {0x3ef2c000}, {0x3ef2e000}, {0x3ef30000}, {0x3ef32000}, {0x3ef34000}, {0x3ef36000}, {0x3ef38000}, {0x3ef3a000}, {0x3ef3c000}, {0x3ef3e000}, {0x3ef40000}, {0x3ef42000}, {0x3ef44000}, {0x3ef46000}, {0x3ef48000}, {0x3ef4a000}, {0x3ef4c000}, {0x3ef4e000}, {0x3ef50000}, {0x3ef52000}, {0x3ef54000}, {0x3ef56000}, {0x3ef58000}, {0x3ef5a000}, {0x3ef5c000}, {0x3ef5e000}, {0x3ef60000}, {0x3ef62000}, {0x3ef64000}, {0x3ef66000}, {0x3ef68000}, {0x3ef6a000}, {0x3ef6c000}, {0x3ef6e000}, {0x3ef70000}, {0x3ef72000}, {0x3ef74000}, {0x3ef76000}, {0x3ef78000}, {0x3ef7a000}, {0x3ef7c000}, {0x3ef7e000}, {0x3ef80000}, {0x3ef82000}, {0x3ef84000}, {0x3ef86000}, {0x3ef88000}, {0x3ef8a000}, {0x3ef8c000}, {0x3ef8e000}, {0x3ef90000}, {0x3ef92000}, {0x3ef94000}, {0x3ef96000}, {0x3ef98000}, {0x3ef9a000}, {0x3ef9c000}, {0x3ef9e000}, {0x3efa0000}, {0x3efa2000}, {0x3efa4000}, {0x3efa6000}, {0x3efa8000}, {0x3efaa000}, {0x3efac000}, {0x3efae000}, {0x3efb0000}, {0x3efb2000}, {0x3efb4000}, {0x3efb6000}, {0x3efb8000}, {0x3efba000}, {0x3efbc000}, {0x3efbe000}, {0x3efc0000}, {0x3efc2000}, {0x3efc4000}, {0x3efc6000}, {0x3efc8000}, {0x3efca000}, {0x3efcc000}, {0x3efce000}, {0x3efd0000}, {0x3efd2000}, {0x3efd4000}, {0x3efd6000}, {0x3efd8000}, {0x3efda000}, {0x3efdc000}, {0x3efde000}, {0x3efe0000}, {0x3efe2000}, {0x3efe4000}, {0x3efe6000}, {0x3efe8000}, {0x3efea000}, {0x3efec000}, {0x3efee000}, {0x3eff0000}, {0x3eff2000}, {0x3eff4000}, {0x3eff6000}, {0x3eff8000}, {0x3effa000}, {0x3effc000}, {0x3effe000}, {0x3f000000}, {0x3f002000}, {0x3f004000}, {0x3f006000}, {0x3f008000}, {0x3f00a000}, {0x3f00c000}, {0x3f00e000}, {0x3f010000}, {0x3f012000}, {0x3f014000}, {0x3f016000}, {0x3f018000}, {0x3f01a000}, {0x3f01c000}, {0x3f01e000}, {0x3f020000}, {0x3f022000}, {0x3f024000}, {0x3f026000}, {0x3f028000}, {0x3f02a000}, {0x3f02c000}, {0x3f02e000}, {0x3f030000}, {0x3f032000}, {0x3f034000}, {0x3f036000}, {0x3f038000}, {0x3f03a000}, {0x3f03c000}, {0x3f03e000}, {0x3f040000}, {0x3f042000}, {0x3f044000}, {0x3f046000}, {0x3f048000}, {0x3f04a000}, {0x3f04c000}, {0x3f04e000}, {0x3f050000}, {0x3f052000}, {0x3f054000}, {0x3f056000}, {0x3f058000}, {0x3f05a000}, {0x3f05c000}, {0x3f05e000}, {0x3f060000}, {0x3f062000}, {0x3f064000}, {0x3f066000}, {0x3f068000}, {0x3f06a000}, {0x3f06c000}, {0x3f06e000}, {0x3f070000}, {0x3f072000}, {0x3f074000}, {0x3f076000}, {0x3f078000}, {0x3f07a000}, {0x3f07c000}, {0x3f07e000}, {0x3f080000}, {0x3f082000}, {0x3f084000}, {0x3f086000}, {0x3f088000}, {0x3f08a000}, {0x3f08c000}, {0x3f08e000}, {0x3f090000}, {0x3f092000}, {0x3f094000}, {0x3f096000}, {0x3f098000}, {0x3f09a000}, {0x3f09c000}, {0x3f09e000}, {0x3f0a0000}, {0x3f0a2000}, {0x3f0a4000}, {0x3f0a6000}, {0x3f0a8000}, {0x3f0aa000}, {0x3f0ac000}, {0x3f0ae000}, {0x3f0b0000}, {0x3f0b2000}, {0x3f0b4000}, {0x3f0b6000}, {0x3f0b8000}, {0x3f0ba000}, {0x3f0bc000}, {0x3f0be000}, {0x3f0c0000}, {0x3f0c2000}, {0x3f0c4000}, {0x3f0c6000}, {0x3f0c8000}, {0x3f0ca000}, {0x3f0cc000}, {0x3f0ce000}, {0x3f0d0000}, {0x3f0d2000}, {0x3f0d4000}, {0x3f0d6000}, {0x3f0d8000}, {0x3f0da000}, {0x3f0dc000}, {0x3f0de000}, {0x3f0e0000}, {0x3f0e2000}, {0x3f0e4000}, {0x3f0e6000}, {0x3f0e8000}, {0x3f0ea000}, {0x3f0ec000}, {0x3f0ee000}, {0x3f0f0000}, {0x3f0f2000}, {0x3f0f4000}, {0x3f0f6000}, {0x3f0f8000}, {0x3f0fa000}, {0x3f0fc000}, {0x3f0fe000}, {0x3f100000}, {0x3f102000}, {0x3f104000}, {0x3f106000}, {0x3f108000}, {0x3f10a000}, {0x3f10c000}, {0x3f10e000}, {0x3f110000}, {0x3f112000}, {0x3f114000}, {0x3f116000}, {0x3f118000}, {0x3f11a000}, {0x3f11c000}, {0x3f11e000}, {0x3f120000}, {0x3f122000}, {0x3f124000}, {0x3f126000}, {0x3f128000}, {0x3f12a000}, {0x3f12c000}, {0x3f12e000}, {0x3f130000}, {0x3f132000}, {0x3f134000}, {0x3f136000}, {0x3f138000}, {0x3f13a000}, {0x3f13c000}, {0x3f13e000}, {0x3f140000}, {0x3f142000}, {0x3f144000}, {0x3f146000}, {0x3f148000}, {0x3f14a000}, {0x3f14c000}, {0x3f14e000}, {0x3f150000}, {0x3f152000}, {0x3f154000}, {0x3f156000}, {0x3f158000}, {0x3f15a000}, {0x3f15c000}, {0x3f15e000}, {0x3f160000}, {0x3f162000}, {0x3f164000}, {0x3f166000}, {0x3f168000}, {0x3f16a000}, {0x3f16c000}, {0x3f16e000}, {0x3f170000}, {0x3f172000}, {0x3f174000}, {0x3f176000}, {0x3f178000}, {0x3f17a000}, {0x3f17c000}, {0x3f17e000}, {0x3f180000}, {0x3f182000}, {0x3f184000}, {0x3f186000}, {0x3f188000}, {0x3f18a000}, {0x3f18c000}, {0x3f18e000}, {0x3f190000}, {0x3f192000}, {0x3f194000}, {0x3f196000}, {0x3f198000}, {0x3f19a000}, {0x3f19c000}, {0x3f19e000}, {0x3f1a0000}, {0x3f1a2000}, {0x3f1a4000}, {0x3f1a6000}, {0x3f1a8000}, {0x3f1aa000}, {0x3f1ac000}, {0x3f1ae000}, {0x3f1b0000}, {0x3f1b2000}, {0x3f1b4000}, {0x3f1b6000}, {0x3f1b8000}, {0x3f1ba000}, {0x3f1bc000}, {0x3f1be000}, {0x3f1c0000}, {0x3f1c2000}, {0x3f1c4000}, {0x3f1c6000}, {0x3f1c8000}, {0x3f1ca000}, {0x3f1cc000}, {0x3f1ce000}, {0x3f1d0000}, {0x3f1d2000}, {0x3f1d4000}, {0x3f1d6000}, {0x3f1d8000}, {0x3f1da000}, {0x3f1dc000}, {0x3f1de000}, {0x3f1e0000}, {0x3f1e2000}, {0x3f1e4000}, {0x3f1e6000}, {0x3f1e8000}, {0x3f1ea000}, {0x3f1ec000}, {0x3f1ee000}, {0x3f1f0000}, {0x3f1f2000}, {0x3f1f4000}, {0x3f1f6000}, {0x3f1f8000}, {0x3f1fa000}, {0x3f1fc000}, {0x3f1fe000}, {0x3f200000}, {0x3f202000}, {0x3f204000}, {0x3f206000}, {0x3f208000}, {0x3f20a000}, {0x3f20c000}, {0x3f20e000}, {0x3f210000}, {0x3f212000}, {0x3f214000}, {0x3f216000}, {0x3f218000}, {0x3f21a000}, {0x3f21c000}, {0x3f21e000}, {0x3f220000}, {0x3f222000}, {0x3f224000}, {0x3f226000}, {0x3f228000}, {0x3f22a000}, {0x3f22c000}, {0x3f22e000}, {0x3f230000}, {0x3f232000}, {0x3f234000}, {0x3f236000}, {0x3f238000}, {0x3f23a000}, {0x3f23c000}, {0x3f23e000}, {0x3f240000}, {0x3f242000}, {0x3f244000}, {0x3f246000}, {0x3f248000}, {0x3f24a000}, {0x3f24c000}, {0x3f24e000}, {0x3f250000}, {0x3f252000}, {0x3f254000}, {0x3f256000}, {0x3f258000}, {0x3f25a000}, {0x3f25c000}, {0x3f25e000}, {0x3f260000}, {0x3f262000}, {0x3f264000}, {0x3f266000}, {0x3f268000}, {0x3f26a000}, {0x3f26c000}, {0x3f26e000}, {0x3f270000}, {0x3f272000}, {0x3f274000}, {0x3f276000}, {0x3f278000}, {0x3f27a000}, {0x3f27c000}, {0x3f27e000}, {0x3f280000}, {0x3f282000}, {0x3f284000}, {0x3f286000}, {0x3f288000}, {0x3f28a000}, {0x3f28c000}, {0x3f28e000}, {0x3f290000}, {0x3f292000}, {0x3f294000}, {0x3f296000}, {0x3f298000}, {0x3f29a000}, {0x3f29c000}, {0x3f29e000}, {0x3f2a0000}, {0x3f2a2000}, {0x3f2a4000}, {0x3f2a6000}, {0x3f2a8000}, {0x3f2aa000}, {0x3f2ac000}, {0x3f2ae000}, {0x3f2b0000}, {0x3f2b2000}, {0x3f2b4000}, {0x3f2b6000}, {0x3f2b8000}, {0x3f2ba000}, {0x3f2bc000}, {0x3f2be000}, {0x3f2c0000}, {0x3f2c2000}, {0x3f2c4000}, {0x3f2c6000}, {0x3f2c8000}, {0x3f2ca000}, {0x3f2cc000}, {0x3f2ce000}, {0x3f2d0000}, {0x3f2d2000}, {0x3f2d4000}, {0x3f2d6000}, {0x3f2d8000}, {0x3f2da000}, {0x3f2dc000}, {0x3f2de000}, {0x3f2e0000}, {0x3f2e2000}, {0x3f2e4000}, {0x3f2e6000}, {0x3f2e8000}, {0x3f2ea000}, {0x3f2ec000}, {0x3f2ee000}, {0x3f2f0000}, {0x3f2f2000}, {0x3f2f4000}, {0x3f2f6000}, {0x3f2f8000}, {0x3f2fa000}, {0x3f2fc000}, {0x3f2fe000}, {0x3f300000}, {0x3f302000}, {0x3f304000}, {0x3f306000}, {0x3f308000}, {0x3f30a000}, {0x3f30c000}, {0x3f30e000}, {0x3f310000}, {0x3f312000}, {0x3f314000}, {0x3f316000}, {0x3f318000}, {0x3f31a000}, {0x3f31c000}, {0x3f31e000}, {0x3f320000}, {0x3f322000}, {0x3f324000}, {0x3f326000}, {0x3f328000}, {0x3f32a000}, {0x3f32c000}, {0x3f32e000}, {0x3f330000}, {0x3f332000}, {0x3f334000}, {0x3f336000}, {0x3f338000}, {0x3f33a000}, {0x3f33c000}, {0x3f33e000}, {0x3f340000}, {0x3f342000}, {0x3f344000}, {0x3f346000}, {0x3f348000}, {0x3f34a000}, {0x3f34c000}, {0x3f34e000}, {0x3f350000}, {0x3f352000}, {0x3f354000}, {0x3f356000}, {0x3f358000}, {0x3f35a000}, {0x3f35c000}, {0x3f35e000}, {0x3f360000}, {0x3f362000}, {0x3f364000}, {0x3f366000}, {0x3f368000}, {0x3f36a000}, {0x3f36c000}, {0x3f36e000}, {0x3f370000}, {0x3f372000}, {0x3f374000}, {0x3f376000}, {0x3f378000}, {0x3f37a000}, {0x3f37c000}, {0x3f37e000}, {0x3f380000}, {0x3f382000}, {0x3f384000}, {0x3f386000}, {0x3f388000}, {0x3f38a000}, {0x3f38c000}, {0x3f38e000}, {0x3f390000}, {0x3f392000}, {0x3f394000}, {0x3f396000}, {0x3f398000}, {0x3f39a000}, {0x3f39c000}, {0x3f39e000}, {0x3f3a0000}, {0x3f3a2000}, {0x3f3a4000}, {0x3f3a6000}, {0x3f3a8000}, {0x3f3aa000}, {0x3f3ac000}, {0x3f3ae000}, {0x3f3b0000}, {0x3f3b2000}, {0x3f3b4000}, {0x3f3b6000}, {0x3f3b8000}, {0x3f3ba000}, {0x3f3bc000}, {0x3f3be000}, {0x3f3c0000}, {0x3f3c2000}, {0x3f3c4000}, {0x3f3c6000}, {0x3f3c8000}, {0x3f3ca000}, {0x3f3cc000}, {0x3f3ce000}, {0x3f3d0000}, {0x3f3d2000}, {0x3f3d4000}, {0x3f3d6000}, {0x3f3d8000}, {0x3f3da000}, {0x3f3dc000}, {0x3f3de000}, {0x3f3e0000}, {0x3f3e2000}, {0x3f3e4000}, {0x3f3e6000}, {0x3f3e8000}, {0x3f3ea000}, {0x3f3ec000}, {0x3f3ee000}, {0x3f3f0000}, {0x3f3f2000}, {0x3f3f4000}, {0x3f3f6000}, {0x3f3f8000}, {0x3f3fa000}, {0x3f3fc000}, {0x3f3fe000}, {0x3f400000}, {0x3f402000}, {0x3f404000}, {0x3f406000}, {0x3f408000}, {0x3f40a000}, {0x3f40c000}, {0x3f40e000}, {0x3f410000}, {0x3f412000}, {0x3f414000}, {0x3f416000}, {0x3f418000}, {0x3f41a000}, {0x3f41c000}, {0x3f41e000}, {0x3f420000}, {0x3f422000}, {0x3f424000}, {0x3f426000}, {0x3f428000}, {0x3f42a000}, {0x3f42c000}, {0x3f42e000}, {0x3f430000}, {0x3f432000}, {0x3f434000}, {0x3f436000}, {0x3f438000}, {0x3f43a000}, {0x3f43c000}, {0x3f43e000}, {0x3f440000}, {0x3f442000}, {0x3f444000}, {0x3f446000}, {0x3f448000}, {0x3f44a000}, {0x3f44c000}, {0x3f44e000}, {0x3f450000}, {0x3f452000}, {0x3f454000}, {0x3f456000}, {0x3f458000}, {0x3f45a000}, {0x3f45c000}, {0x3f45e000}, {0x3f460000}, {0x3f462000}, {0x3f464000}, {0x3f466000}, {0x3f468000}, {0x3f46a000}, {0x3f46c000}, {0x3f46e000}, {0x3f470000}, {0x3f472000}, {0x3f474000}, {0x3f476000}, {0x3f478000}, {0x3f47a000}, {0x3f47c000}, {0x3f47e000}, {0x3f480000}, {0x3f482000}, {0x3f484000}, {0x3f486000}, {0x3f488000}, {0x3f48a000}, {0x3f48c000}, {0x3f48e000}, {0x3f490000}, {0x3f492000}, {0x3f494000}, {0x3f496000}, {0x3f498000}, {0x3f49a000}, {0x3f49c000}, {0x3f49e000}, {0x3f4a0000}, {0x3f4a2000}, {0x3f4a4000}, {0x3f4a6000}, {0x3f4a8000}, {0x3f4aa000}, {0x3f4ac000}, {0x3f4ae000}, {0x3f4b0000}, {0x3f4b2000}, {0x3f4b4000}, {0x3f4b6000}, {0x3f4b8000}, {0x3f4ba000}, {0x3f4bc000}, {0x3f4be000}, {0x3f4c0000}, {0x3f4c2000}, {0x3f4c4000}, {0x3f4c6000}, {0x3f4c8000}, {0x3f4ca000}, {0x3f4cc000}, {0x3f4ce000}, {0x3f4d0000}, {0x3f4d2000}, {0x3f4d4000}, {0x3f4d6000}, {0x3f4d8000}, {0x3f4da000}, {0x3f4dc000}, {0x3f4de000}, {0x3f4e0000}, {0x3f4e2000}, {0x3f4e4000}, {0x3f4e6000}, {0x3f4e8000}, {0x3f4ea000}, {0x3f4ec000}, {0x3f4ee000}, {0x3f4f0000}, {0x3f4f2000}, {0x3f4f4000}, {0x3f4f6000}, {0x3f4f8000}, {0x3f4fa000}, {0x3f4fc000}, {0x3f4fe000}, {0x3f500000}, {0x3f502000}, {0x3f504000}, {0x3f506000}, {0x3f508000}, {0x3f50a000}, {0x3f50c000}, {0x3f50e000}, {0x3f510000}, {0x3f512000}, {0x3f514000}, {0x3f516000}, {0x3f518000}, {0x3f51a000}, {0x3f51c000}, {0x3f51e000}, {0x3f520000}, {0x3f522000}, {0x3f524000}, {0x3f526000}, {0x3f528000}, {0x3f52a000}, {0x3f52c000}, {0x3f52e000}, {0x3f530000}, {0x3f532000}, {0x3f534000}, {0x3f536000}, {0x3f538000}, {0x3f53a000}, {0x3f53c000}, {0x3f53e000}, {0x3f540000}, {0x3f542000}, {0x3f544000}, {0x3f546000}, {0x3f548000}, {0x3f54a000}, {0x3f54c000}, {0x3f54e000}, {0x3f550000}, {0x3f552000}, {0x3f554000}, {0x3f556000}, {0x3f558000}, {0x3f55a000}, {0x3f55c000}, {0x3f55e000}, {0x3f560000}, {0x3f562000}, {0x3f564000}, {0x3f566000}, {0x3f568000}, {0x3f56a000}, {0x3f56c000}, {0x3f56e000}, {0x3f570000}, {0x3f572000}, {0x3f574000}, {0x3f576000}, {0x3f578000}, {0x3f57a000}, {0x3f57c000}, {0x3f57e000}, {0x3f580000}, {0x3f582000}, {0x3f584000}, {0x3f586000}, {0x3f588000}, {0x3f58a000}, {0x3f58c000}, {0x3f58e000}, {0x3f590000}, {0x3f592000}, {0x3f594000}, {0x3f596000}, {0x3f598000}, {0x3f59a000}, {0x3f59c000}, {0x3f59e000}, {0x3f5a0000}, {0x3f5a2000}, {0x3f5a4000}, {0x3f5a6000}, {0x3f5a8000}, {0x3f5aa000}, {0x3f5ac000}, {0x3f5ae000}, {0x3f5b0000}, {0x3f5b2000}, {0x3f5b4000}, {0x3f5b6000}, {0x3f5b8000}, {0x3f5ba000}, {0x3f5bc000}, {0x3f5be000}, {0x3f5c0000}, {0x3f5c2000}, {0x3f5c4000}, {0x3f5c6000}, {0x3f5c8000}, {0x3f5ca000}, {0x3f5cc000}, {0x3f5ce000}, {0x3f5d0000}, {0x3f5d2000}, {0x3f5d4000}, {0x3f5d6000}, {0x3f5d8000}, {0x3f5da000}, {0x3f5dc000}, {0x3f5de000}, {0x3f5e0000}, {0x3f5e2000}, {0x3f5e4000}, {0x3f5e6000}, {0x3f5e8000}, {0x3f5ea000}, {0x3f5ec000}, {0x3f5ee000}, {0x3f5f0000}, {0x3f5f2000}, {0x3f5f4000}, {0x3f5f6000}, {0x3f5f8000}, {0x3f5fa000}, {0x3f5fc000}, {0x3f5fe000}, {0x3f600000}, {0x3f602000}, {0x3f604000}, {0x3f606000}, {0x3f608000}, {0x3f60a000}, {0x3f60c000}, {0x3f60e000}, {0x3f610000}, {0x3f612000}, {0x3f614000}, {0x3f616000}, {0x3f618000}, {0x3f61a000}, {0x3f61c000}, {0x3f61e000}, {0x3f620000}, {0x3f622000}, {0x3f624000}, {0x3f626000}, {0x3f628000}, {0x3f62a000}, {0x3f62c000}, {0x3f62e000}, {0x3f630000}, {0x3f632000}, {0x3f634000}, {0x3f636000}, {0x3f638000}, {0x3f63a000}, {0x3f63c000}, {0x3f63e000}, {0x3f640000}, {0x3f642000}, {0x3f644000}, {0x3f646000}, {0x3f648000}, {0x3f64a000}, {0x3f64c000}, {0x3f64e000}, {0x3f650000}, {0x3f652000}, {0x3f654000}, {0x3f656000}, {0x3f658000}, {0x3f65a000}, {0x3f65c000}, {0x3f65e000}, {0x3f660000}, {0x3f662000}, {0x3f664000}, {0x3f666000}, {0x3f668000}, {0x3f66a000}, {0x3f66c000}, {0x3f66e000}, {0x3f670000}, {0x3f672000}, {0x3f674000}, {0x3f676000}, {0x3f678000}, {0x3f67a000}, {0x3f67c000}, {0x3f67e000}, {0x3f680000}, {0x3f682000}, {0x3f684000}, {0x3f686000}, {0x3f688000}, {0x3f68a000}, {0x3f68c000}, {0x3f68e000}, {0x3f690000}, {0x3f692000}, {0x3f694000}, {0x3f696000}, {0x3f698000}, {0x3f69a000}, {0x3f69c000}, {0x3f69e000}, {0x3f6a0000}, {0x3f6a2000}, {0x3f6a4000}, {0x3f6a6000}, {0x3f6a8000}, {0x3f6aa000}, {0x3f6ac000}, {0x3f6ae000}, {0x3f6b0000}, {0x3f6b2000}, {0x3f6b4000}, {0x3f6b6000}, {0x3f6b8000}, {0x3f6ba000}, {0x3f6bc000}, {0x3f6be000}, {0x3f6c0000}, {0x3f6c2000}, {0x3f6c4000}, {0x3f6c6000}, {0x3f6c8000}, {0x3f6ca000}, {0x3f6cc000}, {0x3f6ce000}, {0x3f6d0000}, {0x3f6d2000}, {0x3f6d4000}, {0x3f6d6000}, {0x3f6d8000}, {0x3f6da000}, {0x3f6dc000}, {0x3f6de000}, {0x3f6e0000}, {0x3f6e2000}, {0x3f6e4000}, {0x3f6e6000}, {0x3f6e8000}, {0x3f6ea000}, {0x3f6ec000}, {0x3f6ee000}, {0x3f6f0000}, {0x3f6f2000}, {0x3f6f4000}, {0x3f6f6000}, {0x3f6f8000}, {0x3f6fa000}, {0x3f6fc000}, {0x3f6fe000}, {0x3f700000}, {0x3f702000}, {0x3f704000}, {0x3f706000}, {0x3f708000}, {0x3f70a000}, {0x3f70c000}, {0x3f70e000}, {0x3f710000}, {0x3f712000}, {0x3f714000}, {0x3f716000}, {0x3f718000}, {0x3f71a000}, {0x3f71c000}, {0x3f71e000}, {0x3f720000}, {0x3f722000}, {0x3f724000}, {0x3f726000}, {0x3f728000}, {0x3f72a000}, {0x3f72c000}, {0x3f72e000}, {0x3f730000}, {0x3f732000}, {0x3f734000}, {0x3f736000}, {0x3f738000}, {0x3f73a000}, {0x3f73c000}, {0x3f73e000}, {0x3f740000}, {0x3f742000}, {0x3f744000}, {0x3f746000}, {0x3f748000}, {0x3f74a000}, {0x3f74c000}, {0x3f74e000}, {0x3f750000}, {0x3f752000}, {0x3f754000}, {0x3f756000}, {0x3f758000}, {0x3f75a000}, {0x3f75c000}, {0x3f75e000}, {0x3f760000}, {0x3f762000}, {0x3f764000}, {0x3f766000}, {0x3f768000}, {0x3f76a000}, {0x3f76c000}, {0x3f76e000}, {0x3f770000}, {0x3f772000}, {0x3f774000}, {0x3f776000}, {0x3f778000}, {0x3f77a000}, {0x3f77c000}, {0x3f77e000}, {0x3f780000}, {0x3f782000}, {0x3f784000}, {0x3f786000}, {0x3f788000}, {0x3f78a000}, {0x3f78c000}, {0x3f78e000}, {0x3f790000}, {0x3f792000}, {0x3f794000}, {0x3f796000}, {0x3f798000}, {0x3f79a000}, {0x3f79c000}, {0x3f79e000}, {0x3f7a0000}, {0x3f7a2000}, {0x3f7a4000}, {0x3f7a6000}, {0x3f7a8000}, {0x3f7aa000}, {0x3f7ac000}, {0x3f7ae000}, {0x3f7b0000}, {0x3f7b2000}, {0x3f7b4000}, {0x3f7b6000}, {0x3f7b8000}, {0x3f7ba000}, {0x3f7bc000}, {0x3f7be000}, {0x3f7c0000}, {0x3f7c2000}, {0x3f7c4000}, {0x3f7c6000}, {0x3f7c8000}, {0x3f7ca000}, {0x3f7cc000}, {0x3f7ce000}, {0x3f7d0000}, {0x3f7d2000}, {0x3f7d4000}, {0x3f7d6000}, {0x3f7d8000}, {0x3f7da000}, {0x3f7dc000}, {0x3f7de000}, {0x3f7e0000}, {0x3f7e2000}, {0x3f7e4000}, {0x3f7e6000}, {0x3f7e8000}, {0x3f7ea000}, {0x3f7ec000}, {0x3f7ee000}, {0x3f7f0000}, {0x3f7f2000}, {0x3f7f4000}, {0x3f7f6000}, {0x3f7f8000}, {0x3f7fa000}, {0x3f7fc000}, {0x3f7fe000}, {0x3f800000}, {0x3f802000}, {0x3f804000}, {0x3f806000}, {0x3f808000}, {0x3f80a000}, {0x3f80c000}, {0x3f80e000}, {0x3f810000}, {0x3f812000}, {0x3f814000}, {0x3f816000}, {0x3f818000}, {0x3f81a000}, {0x3f81c000}, {0x3f81e000}, {0x3f820000}, {0x3f822000}, {0x3f824000}, {0x3f826000}, {0x3f828000}, {0x3f82a000}, {0x3f82c000}, {0x3f82e000}, {0x3f830000}, {0x3f832000}, {0x3f834000}, {0x3f836000}, {0x3f838000}, {0x3f83a000}, {0x3f83c000}, {0x3f83e000}, {0x3f840000}, {0x3f842000}, {0x3f844000}, {0x3f846000}, {0x3f848000}, {0x3f84a000}, {0x3f84c000}, {0x3f84e000}, {0x3f850000}, {0x3f852000}, {0x3f854000}, {0x3f856000}, {0x3f858000}, {0x3f85a000}, {0x3f85c000}, {0x3f85e000}, {0x3f860000}, {0x3f862000}, {0x3f864000}, {0x3f866000}, {0x3f868000}, {0x3f86a000}, {0x3f86c000}, {0x3f86e000}, {0x3f870000}, {0x3f872000}, {0x3f874000}, {0x3f876000}, {0x3f878000}, {0x3f87a000}, {0x3f87c000}, {0x3f87e000}, {0x3f880000}, {0x3f882000}, {0x3f884000}, {0x3f886000}, {0x3f888000}, {0x3f88a000}, {0x3f88c000}, {0x3f88e000}, {0x3f890000}, {0x3f892000}, {0x3f894000}, {0x3f896000}, {0x3f898000}, {0x3f89a000}, {0x3f89c000}, {0x3f89e000}, {0x3f8a0000}, {0x3f8a2000}, {0x3f8a4000}, {0x3f8a6000}, {0x3f8a8000}, {0x3f8aa000}, {0x3f8ac000}, {0x3f8ae000}, {0x3f8b0000}, {0x3f8b2000}, {0x3f8b4000}, {0x3f8b6000}, {0x3f8b8000}, {0x3f8ba000}, {0x3f8bc000}, {0x3f8be000}, {0x3f8c0000}, {0x3f8c2000}, {0x3f8c4000}, {0x3f8c6000}, {0x3f8c8000}, {0x3f8ca000}, {0x3f8cc000}, {0x3f8ce000}, {0x3f8d0000}, {0x3f8d2000}, {0x3f8d4000}, {0x3f8d6000}, {0x3f8d8000}, {0x3f8da000}, {0x3f8dc000}, {0x3f8de000}, {0x3f8e0000}, {0x3f8e2000}, {0x3f8e4000}, {0x3f8e6000}, {0x3f8e8000}, {0x3f8ea000}, {0x3f8ec000}, {0x3f8ee000}, {0x3f8f0000}, {0x3f8f2000}, {0x3f8f4000}, {0x3f8f6000}, {0x3f8f8000}, {0x3f8fa000}, {0x3f8fc000}, {0x3f8fe000}, {0x3f900000}, {0x3f902000}, {0x3f904000}, {0x3f906000}, {0x3f908000}, {0x3f90a000}, {0x3f90c000}, {0x3f90e000}, {0x3f910000}, {0x3f912000}, {0x3f914000}, {0x3f916000}, {0x3f918000}, {0x3f91a000}, {0x3f91c000}, {0x3f91e000}, {0x3f920000}, {0x3f922000}, {0x3f924000}, {0x3f926000}, {0x3f928000}, {0x3f92a000}, {0x3f92c000}, {0x3f92e000}, {0x3f930000}, {0x3f932000}, {0x3f934000}, {0x3f936000}, {0x3f938000}, {0x3f93a000}, {0x3f93c000}, {0x3f93e000}, {0x3f940000}, {0x3f942000}, {0x3f944000}, {0x3f946000}, {0x3f948000}, {0x3f94a000}, {0x3f94c000}, {0x3f94e000}, {0x3f950000}, {0x3f952000}, {0x3f954000}, {0x3f956000}, {0x3f958000}, {0x3f95a000}, {0x3f95c000}, {0x3f95e000}, {0x3f960000}, {0x3f962000}, {0x3f964000}, {0x3f966000}, {0x3f968000}, {0x3f96a000}, {0x3f96c000}, {0x3f96e000}, {0x3f970000}, {0x3f972000}, {0x3f974000}, {0x3f976000}, {0x3f978000}, {0x3f97a000}, {0x3f97c000}, {0x3f97e000}, {0x3f980000}, {0x3f982000}, {0x3f984000}, {0x3f986000}, {0x3f988000}, {0x3f98a000}, {0x3f98c000}, {0x3f98e000}, {0x3f990000}, {0x3f992000}, {0x3f994000}, {0x3f996000}, {0x3f998000}, {0x3f99a000}, {0x3f99c000}, {0x3f99e000}, {0x3f9a0000}, {0x3f9a2000}, {0x3f9a4000}, {0x3f9a6000}, {0x3f9a8000}, {0x3f9aa000}, {0x3f9ac000}, {0x3f9ae000}, {0x3f9b0000}, {0x3f9b2000}, {0x3f9b4000}, {0x3f9b6000}, {0x3f9b8000}, {0x3f9ba000}, {0x3f9bc000}, {0x3f9be000}, {0x3f9c0000}, {0x3f9c2000}, {0x3f9c4000}, {0x3f9c6000}, {0x3f9c8000}, {0x3f9ca000}, {0x3f9cc000}, {0x3f9ce000}, {0x3f9d0000}, {0x3f9d2000}, {0x3f9d4000}, {0x3f9d6000}, {0x3f9d8000}, {0x3f9da000}, {0x3f9dc000}, {0x3f9de000}, {0x3f9e0000}, {0x3f9e2000}, {0x3f9e4000}, {0x3f9e6000}, {0x3f9e8000}, {0x3f9ea000}, {0x3f9ec000}, {0x3f9ee000}, {0x3f9f0000}, {0x3f9f2000}, {0x3f9f4000}, {0x3f9f6000}, {0x3f9f8000}, {0x3f9fa000}, {0x3f9fc000}, {0x3f9fe000}, {0x3fa00000}, {0x3fa02000}, {0x3fa04000}, {0x3fa06000}, {0x3fa08000}, {0x3fa0a000}, {0x3fa0c000}, {0x3fa0e000}, {0x3fa10000}, {0x3fa12000}, {0x3fa14000}, {0x3fa16000}, {0x3fa18000}, {0x3fa1a000}, {0x3fa1c000}, {0x3fa1e000}, {0x3fa20000}, {0x3fa22000}, {0x3fa24000}, {0x3fa26000}, {0x3fa28000}, {0x3fa2a000}, {0x3fa2c000}, {0x3fa2e000}, {0x3fa30000}, {0x3fa32000}, {0x3fa34000}, {0x3fa36000}, {0x3fa38000}, {0x3fa3a000}, {0x3fa3c000}, {0x3fa3e000}, {0x3fa40000}, {0x3fa42000}, {0x3fa44000}, {0x3fa46000}, {0x3fa48000}, {0x3fa4a000}, {0x3fa4c000}, {0x3fa4e000}, {0x3fa50000}, {0x3fa52000}, {0x3fa54000}, {0x3fa56000}, {0x3fa58000}, {0x3fa5a000}, {0x3fa5c000}, {0x3fa5e000}, {0x3fa60000}, {0x3fa62000}, {0x3fa64000}, {0x3fa66000}, {0x3fa68000}, {0x3fa6a000}, {0x3fa6c000}, {0x3fa6e000}, {0x3fa70000}, {0x3fa72000}, {0x3fa74000}, {0x3fa76000}, {0x3fa78000}, {0x3fa7a000}, {0x3fa7c000}, {0x3fa7e000}, {0x3fa80000}, {0x3fa82000}, {0x3fa84000}, {0x3fa86000}, {0x3fa88000}, {0x3fa8a000}, {0x3fa8c000}, {0x3fa8e000}, {0x3fa90000}, {0x3fa92000}, {0x3fa94000}, {0x3fa96000}, {0x3fa98000}, {0x3fa9a000}, {0x3fa9c000}, {0x3fa9e000}, {0x3faa0000}, {0x3faa2000}, {0x3faa4000}, {0x3faa6000}, {0x3faa8000}, {0x3faaa000}, {0x3faac000}, {0x3faae000}, {0x3fab0000}, {0x3fab2000}, {0x3fab4000}, {0x3fab6000}, {0x3fab8000}, {0x3faba000}, {0x3fabc000}, {0x3fabe000}, {0x3fac0000}, {0x3fac2000}, {0x3fac4000}, {0x3fac6000}, {0x3fac8000}, {0x3faca000}, {0x3facc000}, {0x3face000}, {0x3fad0000}, {0x3fad2000}, {0x3fad4000}, {0x3fad6000}, {0x3fad8000}, {0x3fada000}, {0x3fadc000}, {0x3fade000}, {0x3fae0000}, {0x3fae2000}, {0x3fae4000}, {0x3fae6000}, {0x3fae8000}, {0x3faea000}, {0x3faec000}, {0x3faee000}, {0x3faf0000}, {0x3faf2000}, {0x3faf4000}, {0x3faf6000}, {0x3faf8000}, {0x3fafa000}, {0x3fafc000}, {0x3fafe000}, {0x3fb00000}, {0x3fb02000}, {0x3fb04000}, {0x3fb06000}, {0x3fb08000}, {0x3fb0a000}, {0x3fb0c000}, {0x3fb0e000}, {0x3fb10000}, {0x3fb12000}, {0x3fb14000}, {0x3fb16000}, {0x3fb18000}, {0x3fb1a000}, {0x3fb1c000}, {0x3fb1e000}, {0x3fb20000}, {0x3fb22000}, {0x3fb24000}, {0x3fb26000}, {0x3fb28000}, {0x3fb2a000}, {0x3fb2c000}, {0x3fb2e000}, {0x3fb30000}, {0x3fb32000}, {0x3fb34000}, {0x3fb36000}, {0x3fb38000}, {0x3fb3a000}, {0x3fb3c000}, {0x3fb3e000}, {0x3fb40000}, {0x3fb42000}, {0x3fb44000}, {0x3fb46000}, {0x3fb48000}, {0x3fb4a000}, {0x3fb4c000}, {0x3fb4e000}, {0x3fb50000}, {0x3fb52000}, {0x3fb54000}, {0x3fb56000}, {0x3fb58000}, {0x3fb5a000}, {0x3fb5c000}, {0x3fb5e000}, {0x3fb60000}, {0x3fb62000}, {0x3fb64000}, {0x3fb66000}, {0x3fb68000}, {0x3fb6a000}, {0x3fb6c000}, {0x3fb6e000}, {0x3fb70000}, {0x3fb72000}, {0x3fb74000}, {0x3fb76000}, {0x3fb78000}, {0x3fb7a000}, {0x3fb7c000}, {0x3fb7e000}, {0x3fb80000}, {0x3fb82000}, {0x3fb84000}, {0x3fb86000}, {0x3fb88000}, {0x3fb8a000}, {0x3fb8c000}, {0x3fb8e000}, {0x3fb90000}, {0x3fb92000}, {0x3fb94000}, {0x3fb96000}, {0x3fb98000}, {0x3fb9a000}, {0x3fb9c000}, {0x3fb9e000}, {0x3fba0000}, {0x3fba2000}, {0x3fba4000}, {0x3fba6000}, {0x3fba8000}, {0x3fbaa000}, {0x3fbac000}, {0x3fbae000}, {0x3fbb0000}, {0x3fbb2000}, {0x3fbb4000}, {0x3fbb6000}, {0x3fbb8000}, {0x3fbba000}, {0x3fbbc000}, {0x3fbbe000}, {0x3fbc0000}, {0x3fbc2000}, {0x3fbc4000}, {0x3fbc6000}, {0x3fbc8000}, {0x3fbca000}, {0x3fbcc000}, {0x3fbce000}, {0x3fbd0000}, {0x3fbd2000}, {0x3fbd4000}, {0x3fbd6000}, {0x3fbd8000}, {0x3fbda000}, {0x3fbdc000}, {0x3fbde000}, {0x3fbe0000}, {0x3fbe2000}, {0x3fbe4000}, {0x3fbe6000}, {0x3fbe8000}, {0x3fbea000}, {0x3fbec000}, {0x3fbee000}, {0x3fbf0000}, {0x3fbf2000}, {0x3fbf4000}, {0x3fbf6000}, {0x3fbf8000}, {0x3fbfa000}, {0x3fbfc000}, {0x3fbfe000}, {0x3fc00000}, {0x3fc02000}, {0x3fc04000}, {0x3fc06000}, {0x3fc08000}, {0x3fc0a000}, {0x3fc0c000}, {0x3fc0e000}, {0x3fc10000}, {0x3fc12000}, {0x3fc14000}, {0x3fc16000}, {0x3fc18000}, {0x3fc1a000}, {0x3fc1c000}, {0x3fc1e000}, {0x3fc20000}, {0x3fc22000}, {0x3fc24000}, {0x3fc26000}, {0x3fc28000}, {0x3fc2a000}, {0x3fc2c000}, {0x3fc2e000}, {0x3fc30000}, {0x3fc32000}, {0x3fc34000}, {0x3fc36000}, {0x3fc38000}, {0x3fc3a000}, {0x3fc3c000}, {0x3fc3e000}, {0x3fc40000}, {0x3fc42000}, {0x3fc44000}, {0x3fc46000}, {0x3fc48000}, {0x3fc4a000}, {0x3fc4c000}, {0x3fc4e000}, {0x3fc50000}, {0x3fc52000}, {0x3fc54000}, {0x3fc56000}, {0x3fc58000}, {0x3fc5a000}, {0x3fc5c000}, {0x3fc5e000}, {0x3fc60000}, {0x3fc62000}, {0x3fc64000}, {0x3fc66000}, {0x3fc68000}, {0x3fc6a000}, {0x3fc6c000}, {0x3fc6e000}, {0x3fc70000}, {0x3fc72000}, {0x3fc74000}, {0x3fc76000}, {0x3fc78000}, {0x3fc7a000}, {0x3fc7c000}, {0x3fc7e000}, {0x3fc80000}, {0x3fc82000}, {0x3fc84000}, {0x3fc86000}, {0x3fc88000}, {0x3fc8a000}, {0x3fc8c000}, {0x3fc8e000}, {0x3fc90000}, {0x3fc92000}, {0x3fc94000}, {0x3fc96000}, {0x3fc98000}, {0x3fc9a000}, {0x3fc9c000}, {0x3fc9e000}, {0x3fca0000}, {0x3fca2000}, {0x3fca4000}, {0x3fca6000}, {0x3fca8000}, {0x3fcaa000}, {0x3fcac000}, {0x3fcae000}, {0x3fcb0000}, {0x3fcb2000}, {0x3fcb4000}, {0x3fcb6000}, {0x3fcb8000}, {0x3fcba000}, {0x3fcbc000}, {0x3fcbe000}, {0x3fcc0000}, {0x3fcc2000}, {0x3fcc4000}, {0x3fcc6000}, {0x3fcc8000}, {0x3fcca000}, {0x3fccc000}, {0x3fcce000}, {0x3fcd0000}, {0x3fcd2000}, {0x3fcd4000}, {0x3fcd6000}, {0x3fcd8000}, {0x3fcda000}, {0x3fcdc000}, {0x3fcde000}, {0x3fce0000}, {0x3fce2000}, {0x3fce4000}, {0x3fce6000}, {0x3fce8000}, {0x3fcea000}, {0x3fcec000}, {0x3fcee000}, {0x3fcf0000}, {0x3fcf2000}, {0x3fcf4000}, {0x3fcf6000}, {0x3fcf8000}, {0x3fcfa000}, {0x3fcfc000}, {0x3fcfe000}, {0x3fd00000}, {0x3fd02000}, {0x3fd04000}, {0x3fd06000}, {0x3fd08000}, {0x3fd0a000}, {0x3fd0c000}, {0x3fd0e000}, {0x3fd10000}, {0x3fd12000}, {0x3fd14000}, {0x3fd16000}, {0x3fd18000}, {0x3fd1a000}, {0x3fd1c000}, {0x3fd1e000}, {0x3fd20000}, {0x3fd22000}, {0x3fd24000}, {0x3fd26000}, {0x3fd28000}, {0x3fd2a000}, {0x3fd2c000}, {0x3fd2e000}, {0x3fd30000}, {0x3fd32000}, {0x3fd34000}, {0x3fd36000}, {0x3fd38000}, {0x3fd3a000}, {0x3fd3c000}, {0x3fd3e000}, {0x3fd40000}, {0x3fd42000}, {0x3fd44000}, {0x3fd46000}, {0x3fd48000}, {0x3fd4a000}, {0x3fd4c000}, {0x3fd4e000}, {0x3fd50000}, {0x3fd52000}, {0x3fd54000}, {0x3fd56000}, {0x3fd58000}, {0x3fd5a000}, {0x3fd5c000}, {0x3fd5e000}, {0x3fd60000}, {0x3fd62000}, {0x3fd64000}, {0x3fd66000}, {0x3fd68000}, {0x3fd6a000}, {0x3fd6c000}, {0x3fd6e000}, {0x3fd70000}, {0x3fd72000}, {0x3fd74000}, {0x3fd76000}, {0x3fd78000}, {0x3fd7a000}, {0x3fd7c000}, {0x3fd7e000}, {0x3fd80000}, {0x3fd82000}, {0x3fd84000}, {0x3fd86000}, {0x3fd88000}, {0x3fd8a000}, {0x3fd8c000}, {0x3fd8e000}, {0x3fd90000}, {0x3fd92000}, {0x3fd94000}, {0x3fd96000}, {0x3fd98000}, {0x3fd9a000}, {0x3fd9c000}, {0x3fd9e000}, {0x3fda0000}, {0x3fda2000}, {0x3fda4000}, {0x3fda6000}, {0x3fda8000}, {0x3fdaa000}, {0x3fdac000}, {0x3fdae000}, {0x3fdb0000}, {0x3fdb2000}, {0x3fdb4000}, {0x3fdb6000}, {0x3fdb8000}, {0x3fdba000}, {0x3fdbc000}, {0x3fdbe000}, {0x3fdc0000}, {0x3fdc2000}, {0x3fdc4000}, {0x3fdc6000}, {0x3fdc8000}, {0x3fdca000}, {0x3fdcc000}, {0x3fdce000}, {0x3fdd0000}, {0x3fdd2000}, {0x3fdd4000}, {0x3fdd6000}, {0x3fdd8000}, {0x3fdda000}, {0x3fddc000}, {0x3fdde000}, {0x3fde0000}, {0x3fde2000}, {0x3fde4000}, {0x3fde6000}, {0x3fde8000}, {0x3fdea000}, {0x3fdec000}, {0x3fdee000}, {0x3fdf0000}, {0x3fdf2000}, {0x3fdf4000}, {0x3fdf6000}, {0x3fdf8000}, {0x3fdfa000}, {0x3fdfc000}, {0x3fdfe000}, {0x3fe00000}, {0x3fe02000}, {0x3fe04000}, {0x3fe06000}, {0x3fe08000}, {0x3fe0a000}, {0x3fe0c000}, {0x3fe0e000}, {0x3fe10000}, {0x3fe12000}, {0x3fe14000}, {0x3fe16000}, {0x3fe18000}, {0x3fe1a000}, {0x3fe1c000}, {0x3fe1e000}, {0x3fe20000}, {0x3fe22000}, {0x3fe24000}, {0x3fe26000}, {0x3fe28000}, {0x3fe2a000}, {0x3fe2c000}, {0x3fe2e000}, {0x3fe30000}, {0x3fe32000}, {0x3fe34000}, {0x3fe36000}, {0x3fe38000}, {0x3fe3a000}, {0x3fe3c000}, {0x3fe3e000}, {0x3fe40000}, {0x3fe42000}, {0x3fe44000}, {0x3fe46000}, {0x3fe48000}, {0x3fe4a000}, {0x3fe4c000}, {0x3fe4e000}, {0x3fe50000}, {0x3fe52000}, {0x3fe54000}, {0x3fe56000}, {0x3fe58000}, {0x3fe5a000}, {0x3fe5c000}, {0x3fe5e000}, {0x3fe60000}, {0x3fe62000}, {0x3fe64000}, {0x3fe66000}, {0x3fe68000}, {0x3fe6a000}, {0x3fe6c000}, {0x3fe6e000}, {0x3fe70000}, {0x3fe72000}, {0x3fe74000}, {0x3fe76000}, {0x3fe78000}, {0x3fe7a000}, {0x3fe7c000}, {0x3fe7e000}, {0x3fe80000}, {0x3fe82000}, {0x3fe84000}, {0x3fe86000}, {0x3fe88000}, {0x3fe8a000}, {0x3fe8c000}, {0x3fe8e000}, {0x3fe90000}, {0x3fe92000}, {0x3fe94000}, {0x3fe96000}, {0x3fe98000}, {0x3fe9a000}, {0x3fe9c000}, {0x3fe9e000}, {0x3fea0000}, {0x3fea2000}, {0x3fea4000}, {0x3fea6000}, {0x3fea8000}, {0x3feaa000}, {0x3feac000}, {0x3feae000}, {0x3feb0000}, {0x3feb2000}, {0x3feb4000}, {0x3feb6000}, {0x3feb8000}, {0x3feba000}, {0x3febc000}, {0x3febe000}, {0x3fec0000}, {0x3fec2000}, {0x3fec4000}, {0x3fec6000}, {0x3fec8000}, {0x3feca000}, {0x3fecc000}, {0x3fece000}, {0x3fed0000}, {0x3fed2000}, {0x3fed4000}, {0x3fed6000}, {0x3fed8000}, {0x3feda000}, {0x3fedc000}, {0x3fede000}, {0x3fee0000}, {0x3fee2000}, {0x3fee4000}, {0x3fee6000}, {0x3fee8000}, {0x3feea000}, {0x3feec000}, {0x3feee000}, {0x3fef0000}, {0x3fef2000}, {0x3fef4000}, {0x3fef6000}, {0x3fef8000}, {0x3fefa000}, {0x3fefc000}, {0x3fefe000}, {0x3ff00000}, {0x3ff02000}, {0x3ff04000}, {0x3ff06000}, {0x3ff08000}, {0x3ff0a000}, {0x3ff0c000}, {0x3ff0e000}, {0x3ff10000}, {0x3ff12000}, {0x3ff14000}, {0x3ff16000}, {0x3ff18000}, {0x3ff1a000}, {0x3ff1c000}, {0x3ff1e000}, {0x3ff20000}, {0x3ff22000}, {0x3ff24000}, {0x3ff26000}, {0x3ff28000}, {0x3ff2a000}, {0x3ff2c000}, {0x3ff2e000}, {0x3ff30000}, {0x3ff32000}, {0x3ff34000}, {0x3ff36000}, {0x3ff38000}, {0x3ff3a000}, {0x3ff3c000}, {0x3ff3e000}, {0x3ff40000}, {0x3ff42000}, {0x3ff44000}, {0x3ff46000}, {0x3ff48000}, {0x3ff4a000}, {0x3ff4c000}, {0x3ff4e000}, {0x3ff50000}, {0x3ff52000}, {0x3ff54000}, {0x3ff56000}, {0x3ff58000}, {0x3ff5a000}, {0x3ff5c000}, {0x3ff5e000}, {0x3ff60000}, {0x3ff62000}, {0x3ff64000}, {0x3ff66000}, {0x3ff68000}, {0x3ff6a000}, {0x3ff6c000}, {0x3ff6e000}, {0x3ff70000}, {0x3ff72000}, {0x3ff74000}, {0x3ff76000}, {0x3ff78000}, {0x3ff7a000}, {0x3ff7c000}, {0x3ff7e000}, {0x3ff80000}, {0x3ff82000}, {0x3ff84000}, {0x3ff86000}, {0x3ff88000}, {0x3ff8a000}, {0x3ff8c000}, {0x3ff8e000}, {0x3ff90000}, {0x3ff92000}, {0x3ff94000}, {0x3ff96000}, {0x3ff98000}, {0x3ff9a000}, {0x3ff9c000}, {0x3ff9e000}, {0x3ffa0000}, {0x3ffa2000}, {0x3ffa4000}, {0x3ffa6000}, {0x3ffa8000}, {0x3ffaa000}, {0x3ffac000}, {0x3ffae000}, {0x3ffb0000}, {0x3ffb2000}, {0x3ffb4000}, {0x3ffb6000}, {0x3ffb8000}, {0x3ffba000}, {0x3ffbc000}, {0x3ffbe000}, {0x3ffc0000}, {0x3ffc2000}, {0x3ffc4000}, {0x3ffc6000}, {0x3ffc8000}, {0x3ffca000}, {0x3ffcc000}, {0x3ffce000}, {0x3ffd0000}, {0x3ffd2000}, {0x3ffd4000}, {0x3ffd6000}, {0x3ffd8000}, {0x3ffda000}, {0x3ffdc000}, {0x3ffde000}, {0x3ffe0000}, {0x3ffe2000}, {0x3ffe4000}, {0x3ffe6000}, {0x3ffe8000}, {0x3ffea000}, {0x3ffec000}, {0x3ffee000}, {0x3fff0000}, {0x3fff2000}, {0x3fff4000}, {0x3fff6000}, {0x3fff8000}, {0x3fffa000}, {0x3fffc000}, {0x3fffe000}, {0x40000000}, {0x40002000}, {0x40004000}, {0x40006000}, {0x40008000}, {0x4000a000}, {0x4000c000}, {0x4000e000}, {0x40010000}, {0x40012000}, {0x40014000}, {0x40016000}, {0x40018000}, {0x4001a000}, {0x4001c000}, {0x4001e000}, {0x40020000}, {0x40022000}, {0x40024000}, {0x40026000}, {0x40028000}, {0x4002a000}, {0x4002c000}, {0x4002e000}, {0x40030000}, {0x40032000}, {0x40034000}, {0x40036000}, {0x40038000}, {0x4003a000}, {0x4003c000}, {0x4003e000}, {0x40040000}, {0x40042000}, {0x40044000}, {0x40046000}, {0x40048000}, {0x4004a000}, {0x4004c000}, {0x4004e000}, {0x40050000}, {0x40052000}, {0x40054000}, {0x40056000}, {0x40058000}, {0x4005a000}, {0x4005c000}, {0x4005e000}, {0x40060000}, {0x40062000}, {0x40064000}, {0x40066000}, {0x40068000}, {0x4006a000}, {0x4006c000}, {0x4006e000}, {0x40070000}, {0x40072000}, {0x40074000}, {0x40076000}, {0x40078000}, {0x4007a000}, {0x4007c000}, {0x4007e000}, {0x40080000}, {0x40082000}, {0x40084000}, {0x40086000}, {0x40088000}, {0x4008a000}, {0x4008c000}, {0x4008e000}, {0x40090000}, {0x40092000}, {0x40094000}, {0x40096000}, {0x40098000}, {0x4009a000}, {0x4009c000}, {0x4009e000}, {0x400a0000}, {0x400a2000}, {0x400a4000}, {0x400a6000}, {0x400a8000}, {0x400aa000}, {0x400ac000}, {0x400ae000}, {0x400b0000}, {0x400b2000}, {0x400b4000}, {0x400b6000}, {0x400b8000}, {0x400ba000}, {0x400bc000}, {0x400be000}, {0x400c0000}, {0x400c2000}, {0x400c4000}, {0x400c6000}, {0x400c8000}, {0x400ca000}, {0x400cc000}, {0x400ce000}, {0x400d0000}, {0x400d2000}, {0x400d4000}, {0x400d6000}, {0x400d8000}, {0x400da000}, {0x400dc000}, {0x400de000}, {0x400e0000}, {0x400e2000}, {0x400e4000}, {0x400e6000}, {0x400e8000}, {0x400ea000}, {0x400ec000}, {0x400ee000}, {0x400f0000}, {0x400f2000}, {0x400f4000}, {0x400f6000}, {0x400f8000}, {0x400fa000}, {0x400fc000}, {0x400fe000}, {0x40100000}, {0x40102000}, {0x40104000}, {0x40106000}, {0x40108000}, {0x4010a000}, {0x4010c000}, {0x4010e000}, {0x40110000}, {0x40112000}, {0x40114000}, {0x40116000}, {0x40118000}, {0x4011a000}, {0x4011c000}, {0x4011e000}, {0x40120000}, {0x40122000}, {0x40124000}, {0x40126000}, {0x40128000}, {0x4012a000}, {0x4012c000}, {0x4012e000}, {0x40130000}, {0x40132000}, {0x40134000}, {0x40136000}, {0x40138000}, {0x4013a000}, {0x4013c000}, {0x4013e000}, {0x40140000}, {0x40142000}, {0x40144000}, {0x40146000}, {0x40148000}, {0x4014a000}, {0x4014c000}, {0x4014e000}, {0x40150000}, {0x40152000}, {0x40154000}, {0x40156000}, {0x40158000}, {0x4015a000}, {0x4015c000}, {0x4015e000}, {0x40160000}, {0x40162000}, {0x40164000}, {0x40166000}, {0x40168000}, {0x4016a000}, {0x4016c000}, {0x4016e000}, {0x40170000}, {0x40172000}, {0x40174000}, {0x40176000}, {0x40178000}, {0x4017a000}, {0x4017c000}, {0x4017e000}, {0x40180000}, {0x40182000}, {0x40184000}, {0x40186000}, {0x40188000}, {0x4018a000}, {0x4018c000}, {0x4018e000}, {0x40190000}, {0x40192000}, {0x40194000}, {0x40196000}, {0x40198000}, {0x4019a000}, {0x4019c000}, {0x4019e000}, {0x401a0000}, {0x401a2000}, {0x401a4000}, {0x401a6000}, {0x401a8000}, {0x401aa000}, {0x401ac000}, {0x401ae000}, {0x401b0000}, {0x401b2000}, {0x401b4000}, {0x401b6000}, {0x401b8000}, {0x401ba000}, {0x401bc000}, {0x401be000}, {0x401c0000}, {0x401c2000}, {0x401c4000}, {0x401c6000}, {0x401c8000}, {0x401ca000}, {0x401cc000}, {0x401ce000}, {0x401d0000}, {0x401d2000}, {0x401d4000}, {0x401d6000}, {0x401d8000}, {0x401da000}, {0x401dc000}, {0x401de000}, {0x401e0000}, {0x401e2000}, {0x401e4000}, {0x401e6000}, {0x401e8000}, {0x401ea000}, {0x401ec000}, {0x401ee000}, {0x401f0000}, {0x401f2000}, {0x401f4000}, {0x401f6000}, {0x401f8000}, {0x401fa000}, {0x401fc000}, {0x401fe000}, {0x40200000}, {0x40202000}, {0x40204000}, {0x40206000}, {0x40208000}, {0x4020a000}, {0x4020c000}, {0x4020e000}, {0x40210000}, {0x40212000}, {0x40214000}, {0x40216000}, {0x40218000}, {0x4021a000}, {0x4021c000}, {0x4021e000}, {0x40220000}, {0x40222000}, {0x40224000}, {0x40226000}, {0x40228000}, {0x4022a000}, {0x4022c000}, {0x4022e000}, {0x40230000}, {0x40232000}, {0x40234000}, {0x40236000}, {0x40238000}, {0x4023a000}, {0x4023c000}, {0x4023e000}, {0x40240000}, {0x40242000}, {0x40244000}, {0x40246000}, {0x40248000}, {0x4024a000}, {0x4024c000}, {0x4024e000}, {0x40250000}, {0x40252000}, {0x40254000}, {0x40256000}, {0x40258000}, {0x4025a000}, {0x4025c000}, {0x4025e000}, {0x40260000}, {0x40262000}, {0x40264000}, {0x40266000}, {0x40268000}, {0x4026a000}, {0x4026c000}, {0x4026e000}, {0x40270000}, {0x40272000}, {0x40274000}, {0x40276000}, {0x40278000}, {0x4027a000}, {0x4027c000}, {0x4027e000}, {0x40280000}, {0x40282000}, {0x40284000}, {0x40286000}, {0x40288000}, {0x4028a000}, {0x4028c000}, {0x4028e000}, {0x40290000}, {0x40292000}, {0x40294000}, {0x40296000}, {0x40298000}, {0x4029a000}, {0x4029c000}, {0x4029e000}, {0x402a0000}, {0x402a2000}, {0x402a4000}, {0x402a6000}, {0x402a8000}, {0x402aa000}, {0x402ac000}, {0x402ae000}, {0x402b0000}, {0x402b2000}, {0x402b4000}, {0x402b6000}, {0x402b8000}, {0x402ba000}, {0x402bc000}, {0x402be000}, {0x402c0000}, {0x402c2000}, {0x402c4000}, {0x402c6000}, {0x402c8000}, {0x402ca000}, {0x402cc000}, {0x402ce000}, {0x402d0000}, {0x402d2000}, {0x402d4000}, {0x402d6000}, {0x402d8000}, {0x402da000}, {0x402dc000}, {0x402de000}, {0x402e0000}, {0x402e2000}, {0x402e4000}, {0x402e6000}, {0x402e8000}, {0x402ea000}, {0x402ec000}, {0x402ee000}, {0x402f0000}, {0x402f2000}, {0x402f4000}, {0x402f6000}, {0x402f8000}, {0x402fa000}, {0x402fc000}, {0x402fe000}, {0x40300000}, {0x40302000}, {0x40304000}, {0x40306000}, {0x40308000}, {0x4030a000}, {0x4030c000}, {0x4030e000}, {0x40310000}, {0x40312000}, {0x40314000}, {0x40316000}, {0x40318000}, {0x4031a000}, {0x4031c000}, {0x4031e000}, {0x40320000}, {0x40322000}, {0x40324000}, {0x40326000}, {0x40328000}, {0x4032a000}, {0x4032c000}, {0x4032e000}, {0x40330000}, {0x40332000}, {0x40334000}, {0x40336000}, {0x40338000}, {0x4033a000}, {0x4033c000}, {0x4033e000}, {0x40340000}, {0x40342000}, {0x40344000}, {0x40346000}, {0x40348000}, {0x4034a000}, {0x4034c000}, {0x4034e000}, {0x40350000}, {0x40352000}, {0x40354000}, {0x40356000}, {0x40358000}, {0x4035a000}, {0x4035c000}, {0x4035e000}, {0x40360000}, {0x40362000}, {0x40364000}, {0x40366000}, {0x40368000}, {0x4036a000}, {0x4036c000}, {0x4036e000}, {0x40370000}, {0x40372000}, {0x40374000}, {0x40376000}, {0x40378000}, {0x4037a000}, {0x4037c000}, {0x4037e000}, {0x40380000}, {0x40382000}, {0x40384000}, {0x40386000}, {0x40388000}, {0x4038a000}, {0x4038c000}, {0x4038e000}, {0x40390000}, {0x40392000}, {0x40394000}, {0x40396000}, {0x40398000}, {0x4039a000}, {0x4039c000}, {0x4039e000}, {0x403a0000}, {0x403a2000}, {0x403a4000}, {0x403a6000}, {0x403a8000}, {0x403aa000}, {0x403ac000}, {0x403ae000}, {0x403b0000}, {0x403b2000}, {0x403b4000}, {0x403b6000}, {0x403b8000}, {0x403ba000}, {0x403bc000}, {0x403be000}, {0x403c0000}, {0x403c2000}, {0x403c4000}, {0x403c6000}, {0x403c8000}, {0x403ca000}, {0x403cc000}, {0x403ce000}, {0x403d0000}, {0x403d2000}, {0x403d4000}, {0x403d6000}, {0x403d8000}, {0x403da000}, {0x403dc000}, {0x403de000}, {0x403e0000}, {0x403e2000}, {0x403e4000}, {0x403e6000}, {0x403e8000}, {0x403ea000}, {0x403ec000}, {0x403ee000}, {0x403f0000}, {0x403f2000}, {0x403f4000}, {0x403f6000}, {0x403f8000}, {0x403fa000}, {0x403fc000}, {0x403fe000}, {0x40400000}, {0x40402000}, {0x40404000}, {0x40406000}, {0x40408000}, {0x4040a000}, {0x4040c000}, {0x4040e000}, {0x40410000}, {0x40412000}, {0x40414000}, {0x40416000}, {0x40418000}, {0x4041a000}, {0x4041c000}, {0x4041e000}, {0x40420000}, {0x40422000}, {0x40424000}, {0x40426000}, {0x40428000}, {0x4042a000}, {0x4042c000}, {0x4042e000}, {0x40430000}, {0x40432000}, {0x40434000}, {0x40436000}, {0x40438000}, {0x4043a000}, {0x4043c000}, {0x4043e000}, {0x40440000}, {0x40442000}, {0x40444000}, {0x40446000}, {0x40448000}, {0x4044a000}, {0x4044c000}, {0x4044e000}, {0x40450000}, {0x40452000}, {0x40454000}, {0x40456000}, {0x40458000}, {0x4045a000}, {0x4045c000}, {0x4045e000}, {0x40460000}, {0x40462000}, {0x40464000}, {0x40466000}, {0x40468000}, {0x4046a000}, {0x4046c000}, {0x4046e000}, {0x40470000}, {0x40472000}, {0x40474000}, {0x40476000}, {0x40478000}, {0x4047a000}, {0x4047c000}, {0x4047e000}, {0x40480000}, {0x40482000}, {0x40484000}, {0x40486000}, {0x40488000}, {0x4048a000}, {0x4048c000}, {0x4048e000}, {0x40490000}, {0x40492000}, {0x40494000}, {0x40496000}, {0x40498000}, {0x4049a000}, {0x4049c000}, {0x4049e000}, {0x404a0000}, {0x404a2000}, {0x404a4000}, {0x404a6000}, {0x404a8000}, {0x404aa000}, {0x404ac000}, {0x404ae000}, {0x404b0000}, {0x404b2000}, {0x404b4000}, {0x404b6000}, {0x404b8000}, {0x404ba000}, {0x404bc000}, {0x404be000}, {0x404c0000}, {0x404c2000}, {0x404c4000}, {0x404c6000}, {0x404c8000}, {0x404ca000}, {0x404cc000}, {0x404ce000}, {0x404d0000}, {0x404d2000}, {0x404d4000}, {0x404d6000}, {0x404d8000}, {0x404da000}, {0x404dc000}, {0x404de000}, {0x404e0000}, {0x404e2000}, {0x404e4000}, {0x404e6000}, {0x404e8000}, {0x404ea000}, {0x404ec000}, {0x404ee000}, {0x404f0000}, {0x404f2000}, {0x404f4000}, {0x404f6000}, {0x404f8000}, {0x404fa000}, {0x404fc000}, {0x404fe000}, {0x40500000}, {0x40502000}, {0x40504000}, {0x40506000}, {0x40508000}, {0x4050a000}, {0x4050c000}, {0x4050e000}, {0x40510000}, {0x40512000}, {0x40514000}, {0x40516000}, {0x40518000}, {0x4051a000}, {0x4051c000}, {0x4051e000}, {0x40520000}, {0x40522000}, {0x40524000}, {0x40526000}, {0x40528000}, {0x4052a000}, {0x4052c000}, {0x4052e000}, {0x40530000}, {0x40532000}, {0x40534000}, {0x40536000}, {0x40538000}, {0x4053a000}, {0x4053c000}, {0x4053e000}, {0x40540000}, {0x40542000}, {0x40544000}, {0x40546000}, {0x40548000}, {0x4054a000}, {0x4054c000}, {0x4054e000}, {0x40550000}, {0x40552000}, {0x40554000}, {0x40556000}, {0x40558000}, {0x4055a000}, {0x4055c000}, {0x4055e000}, {0x40560000}, {0x40562000}, {0x40564000}, {0x40566000}, {0x40568000}, {0x4056a000}, {0x4056c000}, {0x4056e000}, {0x40570000}, {0x40572000}, {0x40574000}, {0x40576000}, {0x40578000}, {0x4057a000}, {0x4057c000}, {0x4057e000}, {0x40580000}, {0x40582000}, {0x40584000}, {0x40586000}, {0x40588000}, {0x4058a000}, {0x4058c000}, {0x4058e000}, {0x40590000}, {0x40592000}, {0x40594000}, {0x40596000}, {0x40598000}, {0x4059a000}, {0x4059c000}, {0x4059e000}, {0x405a0000}, {0x405a2000}, {0x405a4000}, {0x405a6000}, {0x405a8000}, {0x405aa000}, {0x405ac000}, {0x405ae000}, {0x405b0000}, {0x405b2000}, {0x405b4000}, {0x405b6000}, {0x405b8000}, {0x405ba000}, {0x405bc000}, {0x405be000}, {0x405c0000}, {0x405c2000}, {0x405c4000}, {0x405c6000}, {0x405c8000}, {0x405ca000}, {0x405cc000}, {0x405ce000}, {0x405d0000}, {0x405d2000}, {0x405d4000}, {0x405d6000}, {0x405d8000}, {0x405da000}, {0x405dc000}, {0x405de000}, {0x405e0000}, {0x405e2000}, {0x405e4000}, {0x405e6000}, {0x405e8000}, {0x405ea000}, {0x405ec000}, {0x405ee000}, {0x405f0000}, {0x405f2000}, {0x405f4000}, {0x405f6000}, {0x405f8000}, {0x405fa000}, {0x405fc000}, {0x405fe000}, {0x40600000}, {0x40602000}, {0x40604000}, {0x40606000}, {0x40608000}, {0x4060a000}, {0x4060c000}, {0x4060e000}, {0x40610000}, {0x40612000}, {0x40614000}, {0x40616000}, {0x40618000}, {0x4061a000}, {0x4061c000}, {0x4061e000}, {0x40620000}, {0x40622000}, {0x40624000}, {0x40626000}, {0x40628000}, {0x4062a000}, {0x4062c000}, {0x4062e000}, {0x40630000}, {0x40632000}, {0x40634000}, {0x40636000}, {0x40638000}, {0x4063a000}, {0x4063c000}, {0x4063e000}, {0x40640000}, {0x40642000}, {0x40644000}, {0x40646000}, {0x40648000}, {0x4064a000}, {0x4064c000}, {0x4064e000}, {0x40650000}, {0x40652000}, {0x40654000}, {0x40656000}, {0x40658000}, {0x4065a000}, {0x4065c000}, {0x4065e000}, {0x40660000}, {0x40662000}, {0x40664000}, {0x40666000}, {0x40668000}, {0x4066a000}, {0x4066c000}, {0x4066e000}, {0x40670000}, {0x40672000}, {0x40674000}, {0x40676000}, {0x40678000}, {0x4067a000}, {0x4067c000}, {0x4067e000}, {0x40680000}, {0x40682000}, {0x40684000}, {0x40686000}, {0x40688000}, {0x4068a000}, {0x4068c000}, {0x4068e000}, {0x40690000}, {0x40692000}, {0x40694000}, {0x40696000}, {0x40698000}, {0x4069a000}, {0x4069c000}, {0x4069e000}, {0x406a0000}, {0x406a2000}, {0x406a4000}, {0x406a6000}, {0x406a8000}, {0x406aa000}, {0x406ac000}, {0x406ae000}, {0x406b0000}, {0x406b2000}, {0x406b4000}, {0x406b6000}, {0x406b8000}, {0x406ba000}, {0x406bc000}, {0x406be000}, {0x406c0000}, {0x406c2000}, {0x406c4000}, {0x406c6000}, {0x406c8000}, {0x406ca000}, {0x406cc000}, {0x406ce000}, {0x406d0000}, {0x406d2000}, {0x406d4000}, {0x406d6000}, {0x406d8000}, {0x406da000}, {0x406dc000}, {0x406de000}, {0x406e0000}, {0x406e2000}, {0x406e4000}, {0x406e6000}, {0x406e8000}, {0x406ea000}, {0x406ec000}, {0x406ee000}, {0x406f0000}, {0x406f2000}, {0x406f4000}, {0x406f6000}, {0x406f8000}, {0x406fa000}, {0x406fc000}, {0x406fe000}, {0x40700000}, {0x40702000}, {0x40704000}, {0x40706000}, {0x40708000}, {0x4070a000}, {0x4070c000}, {0x4070e000}, {0x40710000}, {0x40712000}, {0x40714000}, {0x40716000}, {0x40718000}, {0x4071a000}, {0x4071c000}, {0x4071e000}, {0x40720000}, {0x40722000}, {0x40724000}, {0x40726000}, {0x40728000}, {0x4072a000}, {0x4072c000}, {0x4072e000}, {0x40730000}, {0x40732000}, {0x40734000}, {0x40736000}, {0x40738000}, {0x4073a000}, {0x4073c000}, {0x4073e000}, {0x40740000}, {0x40742000}, {0x40744000}, {0x40746000}, {0x40748000}, {0x4074a000}, {0x4074c000}, {0x4074e000}, {0x40750000}, {0x40752000}, {0x40754000}, {0x40756000}, {0x40758000}, {0x4075a000}, {0x4075c000}, {0x4075e000}, {0x40760000}, {0x40762000}, {0x40764000}, {0x40766000}, {0x40768000}, {0x4076a000}, {0x4076c000}, {0x4076e000}, {0x40770000}, {0x40772000}, {0x40774000}, {0x40776000}, {0x40778000}, {0x4077a000}, {0x4077c000}, {0x4077e000}, {0x40780000}, {0x40782000}, {0x40784000}, {0x40786000}, {0x40788000}, {0x4078a000}, {0x4078c000}, {0x4078e000}, {0x40790000}, {0x40792000}, {0x40794000}, {0x40796000}, {0x40798000}, {0x4079a000}, {0x4079c000}, {0x4079e000}, {0x407a0000}, {0x407a2000}, {0x407a4000}, {0x407a6000}, {0x407a8000}, {0x407aa000}, {0x407ac000}, {0x407ae000}, {0x407b0000}, {0x407b2000}, {0x407b4000}, {0x407b6000}, {0x407b8000}, {0x407ba000}, {0x407bc000}, {0x407be000}, {0x407c0000}, {0x407c2000}, {0x407c4000}, {0x407c6000}, {0x407c8000}, {0x407ca000}, {0x407cc000}, {0x407ce000}, {0x407d0000}, {0x407d2000}, {0x407d4000}, {0x407d6000}, {0x407d8000}, {0x407da000}, {0x407dc000}, {0x407de000}, {0x407e0000}, {0x407e2000}, {0x407e4000}, {0x407e6000}, {0x407e8000}, {0x407ea000}, {0x407ec000}, {0x407ee000}, {0x407f0000}, {0x407f2000}, {0x407f4000}, {0x407f6000}, {0x407f8000}, {0x407fa000}, {0x407fc000}, {0x407fe000}, {0x40800000}, {0x40802000}, {0x40804000}, {0x40806000}, {0x40808000}, {0x4080a000}, {0x4080c000}, {0x4080e000}, {0x40810000}, {0x40812000}, {0x40814000}, {0x40816000}, {0x40818000}, {0x4081a000}, {0x4081c000}, {0x4081e000}, {0x40820000}, {0x40822000}, {0x40824000}, {0x40826000}, {0x40828000}, {0x4082a000}, {0x4082c000}, {0x4082e000}, {0x40830000}, {0x40832000}, {0x40834000}, {0x40836000}, {0x40838000}, {0x4083a000}, {0x4083c000}, {0x4083e000}, {0x40840000}, {0x40842000}, {0x40844000}, {0x40846000}, {0x40848000}, {0x4084a000}, {0x4084c000}, {0x4084e000}, {0x40850000}, {0x40852000}, {0x40854000}, {0x40856000}, {0x40858000}, {0x4085a000}, {0x4085c000}, {0x4085e000}, {0x40860000}, {0x40862000}, {0x40864000}, {0x40866000}, {0x40868000}, {0x4086a000}, {0x4086c000}, {0x4086e000}, {0x40870000}, {0x40872000}, {0x40874000}, {0x40876000}, {0x40878000}, {0x4087a000}, {0x4087c000}, {0x4087e000}, {0x40880000}, {0x40882000}, {0x40884000}, {0x40886000}, {0x40888000}, {0x4088a000}, {0x4088c000}, {0x4088e000}, {0x40890000}, {0x40892000}, {0x40894000}, {0x40896000}, {0x40898000}, {0x4089a000}, {0x4089c000}, {0x4089e000}, {0x408a0000}, {0x408a2000}, {0x408a4000}, {0x408a6000}, {0x408a8000}, {0x408aa000}, {0x408ac000}, {0x408ae000}, {0x408b0000}, {0x408b2000}, {0x408b4000}, {0x408b6000}, {0x408b8000}, {0x408ba000}, {0x408bc000}, {0x408be000}, {0x408c0000}, {0x408c2000}, {0x408c4000}, {0x408c6000}, {0x408c8000}, {0x408ca000}, {0x408cc000}, {0x408ce000}, {0x408d0000}, {0x408d2000}, {0x408d4000}, {0x408d6000}, {0x408d8000}, {0x408da000}, {0x408dc000}, {0x408de000}, {0x408e0000}, {0x408e2000}, {0x408e4000}, {0x408e6000}, {0x408e8000}, {0x408ea000}, {0x408ec000}, {0x408ee000}, {0x408f0000}, {0x408f2000}, {0x408f4000}, {0x408f6000}, {0x408f8000}, {0x408fa000}, {0x408fc000}, {0x408fe000}, {0x40900000}, {0x40902000}, {0x40904000}, {0x40906000}, {0x40908000}, {0x4090a000}, {0x4090c000}, {0x4090e000}, {0x40910000}, {0x40912000}, {0x40914000}, {0x40916000}, {0x40918000}, {0x4091a000}, {0x4091c000}, {0x4091e000}, {0x40920000}, {0x40922000}, {0x40924000}, {0x40926000}, {0x40928000}, {0x4092a000}, {0x4092c000}, {0x4092e000}, {0x40930000}, {0x40932000}, {0x40934000}, {0x40936000}, {0x40938000}, {0x4093a000}, {0x4093c000}, {0x4093e000}, {0x40940000}, {0x40942000}, {0x40944000}, {0x40946000}, {0x40948000}, {0x4094a000}, {0x4094c000}, {0x4094e000}, {0x40950000}, {0x40952000}, {0x40954000}, {0x40956000}, {0x40958000}, {0x4095a000}, {0x4095c000}, {0x4095e000}, {0x40960000}, {0x40962000}, {0x40964000}, {0x40966000}, {0x40968000}, {0x4096a000}, {0x4096c000}, {0x4096e000}, {0x40970000}, {0x40972000}, {0x40974000}, {0x40976000}, {0x40978000}, {0x4097a000}, {0x4097c000}, {0x4097e000}, {0x40980000}, {0x40982000}, {0x40984000}, {0x40986000}, {0x40988000}, {0x4098a000}, {0x4098c000}, {0x4098e000}, {0x40990000}, {0x40992000}, {0x40994000}, {0x40996000}, {0x40998000}, {0x4099a000}, {0x4099c000}, {0x4099e000}, {0x409a0000}, {0x409a2000}, {0x409a4000}, {0x409a6000}, {0x409a8000}, {0x409aa000}, {0x409ac000}, {0x409ae000}, {0x409b0000}, {0x409b2000}, {0x409b4000}, {0x409b6000}, {0x409b8000}, {0x409ba000}, {0x409bc000}, {0x409be000}, {0x409c0000}, {0x409c2000}, {0x409c4000}, {0x409c6000}, {0x409c8000}, {0x409ca000}, {0x409cc000}, {0x409ce000}, {0x409d0000}, {0x409d2000}, {0x409d4000}, {0x409d6000}, {0x409d8000}, {0x409da000}, {0x409dc000}, {0x409de000}, {0x409e0000}, {0x409e2000}, {0x409e4000}, {0x409e6000}, {0x409e8000}, {0x409ea000}, {0x409ec000}, {0x409ee000}, {0x409f0000}, {0x409f2000}, {0x409f4000}, {0x409f6000}, {0x409f8000}, {0x409fa000}, {0x409fc000}, {0x409fe000}, {0x40a00000}, {0x40a02000}, {0x40a04000}, {0x40a06000}, {0x40a08000}, {0x40a0a000}, {0x40a0c000}, {0x40a0e000}, {0x40a10000}, {0x40a12000}, {0x40a14000}, {0x40a16000}, {0x40a18000}, {0x40a1a000}, {0x40a1c000}, {0x40a1e000}, {0x40a20000}, {0x40a22000}, {0x40a24000}, {0x40a26000}, {0x40a28000}, {0x40a2a000}, {0x40a2c000}, {0x40a2e000}, {0x40a30000}, {0x40a32000}, {0x40a34000}, {0x40a36000}, {0x40a38000}, {0x40a3a000}, {0x40a3c000}, {0x40a3e000}, {0x40a40000}, {0x40a42000}, {0x40a44000}, {0x40a46000}, {0x40a48000}, {0x40a4a000}, {0x40a4c000}, {0x40a4e000}, {0x40a50000}, {0x40a52000}, {0x40a54000}, {0x40a56000}, {0x40a58000}, {0x40a5a000}, {0x40a5c000}, {0x40a5e000}, {0x40a60000}, {0x40a62000}, {0x40a64000}, {0x40a66000}, {0x40a68000}, {0x40a6a000}, {0x40a6c000}, {0x40a6e000}, {0x40a70000}, {0x40a72000}, {0x40a74000}, {0x40a76000}, {0x40a78000}, {0x40a7a000}, {0x40a7c000}, {0x40a7e000}, {0x40a80000}, {0x40a82000}, {0x40a84000}, {0x40a86000}, {0x40a88000}, {0x40a8a000}, {0x40a8c000}, {0x40a8e000}, {0x40a90000}, {0x40a92000}, {0x40a94000}, {0x40a96000}, {0x40a98000}, {0x40a9a000}, {0x40a9c000}, {0x40a9e000}, {0x40aa0000}, {0x40aa2000}, {0x40aa4000}, {0x40aa6000}, {0x40aa8000}, {0x40aaa000}, {0x40aac000}, {0x40aae000}, {0x40ab0000}, {0x40ab2000}, {0x40ab4000}, {0x40ab6000}, {0x40ab8000}, {0x40aba000}, {0x40abc000}, {0x40abe000}, {0x40ac0000}, {0x40ac2000}, {0x40ac4000}, {0x40ac6000}, {0x40ac8000}, {0x40aca000}, {0x40acc000}, {0x40ace000}, {0x40ad0000}, {0x40ad2000}, {0x40ad4000}, {0x40ad6000}, {0x40ad8000}, {0x40ada000}, {0x40adc000}, {0x40ade000}, {0x40ae0000}, {0x40ae2000}, {0x40ae4000}, {0x40ae6000}, {0x40ae8000}, {0x40aea000}, {0x40aec000}, {0x40aee000}, {0x40af0000}, {0x40af2000}, {0x40af4000}, {0x40af6000}, {0x40af8000}, {0x40afa000}, {0x40afc000}, {0x40afe000}, {0x40b00000}, {0x40b02000}, {0x40b04000}, {0x40b06000}, {0x40b08000}, {0x40b0a000}, {0x40b0c000}, {0x40b0e000}, {0x40b10000}, {0x40b12000}, {0x40b14000}, {0x40b16000}, {0x40b18000}, {0x40b1a000}, {0x40b1c000}, {0x40b1e000}, {0x40b20000}, {0x40b22000}, {0x40b24000}, {0x40b26000}, {0x40b28000}, {0x40b2a000}, {0x40b2c000}, {0x40b2e000}, {0x40b30000}, {0x40b32000}, {0x40b34000}, {0x40b36000}, {0x40b38000}, {0x40b3a000}, {0x40b3c000}, {0x40b3e000}, {0x40b40000}, {0x40b42000}, {0x40b44000}, {0x40b46000}, {0x40b48000}, {0x40b4a000}, {0x40b4c000}, {0x40b4e000}, {0x40b50000}, {0x40b52000}, {0x40b54000}, {0x40b56000}, {0x40b58000}, {0x40b5a000}, {0x40b5c000}, {0x40b5e000}, {0x40b60000}, {0x40b62000}, {0x40b64000}, {0x40b66000}, {0x40b68000}, {0x40b6a000}, {0x40b6c000}, {0x40b6e000}, {0x40b70000}, {0x40b72000}, {0x40b74000}, {0x40b76000}, {0x40b78000}, {0x40b7a000}, {0x40b7c000}, {0x40b7e000}, {0x40b80000}, {0x40b82000}, {0x40b84000}, {0x40b86000}, {0x40b88000}, {0x40b8a000}, {0x40b8c000}, {0x40b8e000}, {0x40b90000}, {0x40b92000}, {0x40b94000}, {0x40b96000}, {0x40b98000}, {0x40b9a000}, {0x40b9c000}, {0x40b9e000}, {0x40ba0000}, {0x40ba2000}, {0x40ba4000}, {0x40ba6000}, {0x40ba8000}, {0x40baa000}, {0x40bac000}, {0x40bae000}, {0x40bb0000}, {0x40bb2000}, {0x40bb4000}, {0x40bb6000}, {0x40bb8000}, {0x40bba000}, {0x40bbc000}, {0x40bbe000}, {0x40bc0000}, {0x40bc2000}, {0x40bc4000}, {0x40bc6000}, {0x40bc8000}, {0x40bca000}, {0x40bcc000}, {0x40bce000}, {0x40bd0000}, {0x40bd2000}, {0x40bd4000}, {0x40bd6000}, {0x40bd8000}, {0x40bda000}, {0x40bdc000}, {0x40bde000}, {0x40be0000}, {0x40be2000}, {0x40be4000}, {0x40be6000}, {0x40be8000}, {0x40bea000}, {0x40bec000}, {0x40bee000}, {0x40bf0000}, {0x40bf2000}, {0x40bf4000}, {0x40bf6000}, {0x40bf8000}, {0x40bfa000}, {0x40bfc000}, {0x40bfe000}, {0x40c00000}, {0x40c02000}, {0x40c04000}, {0x40c06000}, {0x40c08000}, {0x40c0a000}, {0x40c0c000}, {0x40c0e000}, {0x40c10000}, {0x40c12000}, {0x40c14000}, {0x40c16000}, {0x40c18000}, {0x40c1a000}, {0x40c1c000}, {0x40c1e000}, {0x40c20000}, {0x40c22000}, {0x40c24000}, {0x40c26000}, {0x40c28000}, {0x40c2a000}, {0x40c2c000}, {0x40c2e000}, {0x40c30000}, {0x40c32000}, {0x40c34000}, {0x40c36000}, {0x40c38000}, {0x40c3a000}, {0x40c3c000}, {0x40c3e000}, {0x40c40000}, {0x40c42000}, {0x40c44000}, {0x40c46000}, {0x40c48000}, {0x40c4a000}, {0x40c4c000}, {0x40c4e000}, {0x40c50000}, {0x40c52000}, {0x40c54000}, {0x40c56000}, {0x40c58000}, {0x40c5a000}, {0x40c5c000}, {0x40c5e000}, {0x40c60000}, {0x40c62000}, {0x40c64000}, {0x40c66000}, {0x40c68000}, {0x40c6a000}, {0x40c6c000}, {0x40c6e000}, {0x40c70000}, {0x40c72000}, {0x40c74000}, {0x40c76000}, {0x40c78000}, {0x40c7a000}, {0x40c7c000}, {0x40c7e000}, {0x40c80000}, {0x40c82000}, {0x40c84000}, {0x40c86000}, {0x40c88000}, {0x40c8a000}, {0x40c8c000}, {0x40c8e000}, {0x40c90000}, {0x40c92000}, {0x40c94000}, {0x40c96000}, {0x40c98000}, {0x40c9a000}, {0x40c9c000}, {0x40c9e000}, {0x40ca0000}, {0x40ca2000}, {0x40ca4000}, {0x40ca6000}, {0x40ca8000}, {0x40caa000}, {0x40cac000}, {0x40cae000}, {0x40cb0000}, {0x40cb2000}, {0x40cb4000}, {0x40cb6000}, {0x40cb8000}, {0x40cba000}, {0x40cbc000}, {0x40cbe000}, {0x40cc0000}, {0x40cc2000}, {0x40cc4000}, {0x40cc6000}, {0x40cc8000}, {0x40cca000}, {0x40ccc000}, {0x40cce000}, {0x40cd0000}, {0x40cd2000}, {0x40cd4000}, {0x40cd6000}, {0x40cd8000}, {0x40cda000}, {0x40cdc000}, {0x40cde000}, {0x40ce0000}, {0x40ce2000}, {0x40ce4000}, {0x40ce6000}, {0x40ce8000}, {0x40cea000}, {0x40cec000}, {0x40cee000}, {0x40cf0000}, {0x40cf2000}, {0x40cf4000}, {0x40cf6000}, {0x40cf8000}, {0x40cfa000}, {0x40cfc000}, {0x40cfe000}, {0x40d00000}, {0x40d02000}, {0x40d04000}, {0x40d06000}, {0x40d08000}, {0x40d0a000}, {0x40d0c000}, {0x40d0e000}, {0x40d10000}, {0x40d12000}, {0x40d14000}, {0x40d16000}, {0x40d18000}, {0x40d1a000}, {0x40d1c000}, {0x40d1e000}, {0x40d20000}, {0x40d22000}, {0x40d24000}, {0x40d26000}, {0x40d28000}, {0x40d2a000}, {0x40d2c000}, {0x40d2e000}, {0x40d30000}, {0x40d32000}, {0x40d34000}, {0x40d36000}, {0x40d38000}, {0x40d3a000}, {0x40d3c000}, {0x40d3e000}, {0x40d40000}, {0x40d42000}, {0x40d44000}, {0x40d46000}, {0x40d48000}, {0x40d4a000}, {0x40d4c000}, {0x40d4e000}, {0x40d50000}, {0x40d52000}, {0x40d54000}, {0x40d56000}, {0x40d58000}, {0x40d5a000}, {0x40d5c000}, {0x40d5e000}, {0x40d60000}, {0x40d62000}, {0x40d64000}, {0x40d66000}, {0x40d68000}, {0x40d6a000}, {0x40d6c000}, {0x40d6e000}, {0x40d70000}, {0x40d72000}, {0x40d74000}, {0x40d76000}, {0x40d78000}, {0x40d7a000}, {0x40d7c000}, {0x40d7e000}, {0x40d80000}, {0x40d82000}, {0x40d84000}, {0x40d86000}, {0x40d88000}, {0x40d8a000}, {0x40d8c000}, {0x40d8e000}, {0x40d90000}, {0x40d92000}, {0x40d94000}, {0x40d96000}, {0x40d98000}, {0x40d9a000}, {0x40d9c000}, {0x40d9e000}, {0x40da0000}, {0x40da2000}, {0x40da4000}, {0x40da6000}, {0x40da8000}, {0x40daa000}, {0x40dac000}, {0x40dae000}, {0x40db0000}, {0x40db2000}, {0x40db4000}, {0x40db6000}, {0x40db8000}, {0x40dba000}, {0x40dbc000}, {0x40dbe000}, {0x40dc0000}, {0x40dc2000}, {0x40dc4000}, {0x40dc6000}, {0x40dc8000}, {0x40dca000}, {0x40dcc000}, {0x40dce000}, {0x40dd0000}, {0x40dd2000}, {0x40dd4000}, {0x40dd6000}, {0x40dd8000}, {0x40dda000}, {0x40ddc000}, {0x40dde000}, {0x40de0000}, {0x40de2000}, {0x40de4000}, {0x40de6000}, {0x40de8000}, {0x40dea000}, {0x40dec000}, {0x40dee000}, {0x40df0000}, {0x40df2000}, {0x40df4000}, {0x40df6000}, {0x40df8000}, {0x40dfa000}, {0x40dfc000}, {0x40dfe000}, {0x40e00000}, {0x40e02000}, {0x40e04000}, {0x40e06000}, {0x40e08000}, {0x40e0a000}, {0x40e0c000}, {0x40e0e000}, {0x40e10000}, {0x40e12000}, {0x40e14000}, {0x40e16000}, {0x40e18000}, {0x40e1a000}, {0x40e1c000}, {0x40e1e000}, {0x40e20000}, {0x40e22000}, {0x40e24000}, {0x40e26000}, {0x40e28000}, {0x40e2a000}, {0x40e2c000}, {0x40e2e000}, {0x40e30000}, {0x40e32000}, {0x40e34000}, {0x40e36000}, {0x40e38000}, {0x40e3a000}, {0x40e3c000}, {0x40e3e000}, {0x40e40000}, {0x40e42000}, {0x40e44000}, {0x40e46000}, {0x40e48000}, {0x40e4a000}, {0x40e4c000}, {0x40e4e000}, {0x40e50000}, {0x40e52000}, {0x40e54000}, {0x40e56000}, {0x40e58000}, {0x40e5a000}, {0x40e5c000}, {0x40e5e000}, {0x40e60000}, {0x40e62000}, {0x40e64000}, {0x40e66000}, {0x40e68000}, {0x40e6a000}, {0x40e6c000}, {0x40e6e000}, {0x40e70000}, {0x40e72000}, {0x40e74000}, {0x40e76000}, {0x40e78000}, {0x40e7a000}, {0x40e7c000}, {0x40e7e000}, {0x40e80000}, {0x40e82000}, {0x40e84000}, {0x40e86000}, {0x40e88000}, {0x40e8a000}, {0x40e8c000}, {0x40e8e000}, {0x40e90000}, {0x40e92000}, {0x40e94000}, {0x40e96000}, {0x40e98000}, {0x40e9a000}, {0x40e9c000}, {0x40e9e000}, {0x40ea0000}, {0x40ea2000}, {0x40ea4000}, {0x40ea6000}, {0x40ea8000}, {0x40eaa000}, {0x40eac000}, {0x40eae000}, {0x40eb0000}, {0x40eb2000}, {0x40eb4000}, {0x40eb6000}, {0x40eb8000}, {0x40eba000}, {0x40ebc000}, {0x40ebe000}, {0x40ec0000}, {0x40ec2000}, {0x40ec4000}, {0x40ec6000}, {0x40ec8000}, {0x40eca000}, {0x40ecc000}, {0x40ece000}, {0x40ed0000}, {0x40ed2000}, {0x40ed4000}, {0x40ed6000}, {0x40ed8000}, {0x40eda000}, {0x40edc000}, {0x40ede000}, {0x40ee0000}, {0x40ee2000}, {0x40ee4000}, {0x40ee6000}, {0x40ee8000}, {0x40eea000}, {0x40eec000}, {0x40eee000}, {0x40ef0000}, {0x40ef2000}, {0x40ef4000}, {0x40ef6000}, {0x40ef8000}, {0x40efa000}, {0x40efc000}, {0x40efe000}, {0x40f00000}, {0x40f02000}, {0x40f04000}, {0x40f06000}, {0x40f08000}, {0x40f0a000}, {0x40f0c000}, {0x40f0e000}, {0x40f10000}, {0x40f12000}, {0x40f14000}, {0x40f16000}, {0x40f18000}, {0x40f1a000}, {0x40f1c000}, {0x40f1e000}, {0x40f20000}, {0x40f22000}, {0x40f24000}, {0x40f26000}, {0x40f28000}, {0x40f2a000}, {0x40f2c000}, {0x40f2e000}, {0x40f30000}, {0x40f32000}, {0x40f34000}, {0x40f36000}, {0x40f38000}, {0x40f3a000}, {0x40f3c000}, {0x40f3e000}, {0x40f40000}, {0x40f42000}, {0x40f44000}, {0x40f46000}, {0x40f48000}, {0x40f4a000}, {0x40f4c000}, {0x40f4e000}, {0x40f50000}, {0x40f52000}, {0x40f54000}, {0x40f56000}, {0x40f58000}, {0x40f5a000}, {0x40f5c000}, {0x40f5e000}, {0x40f60000}, {0x40f62000}, {0x40f64000}, {0x40f66000}, {0x40f68000}, {0x40f6a000}, {0x40f6c000}, {0x40f6e000}, {0x40f70000}, {0x40f72000}, {0x40f74000}, {0x40f76000}, {0x40f78000}, {0x40f7a000}, {0x40f7c000}, {0x40f7e000}, {0x40f80000}, {0x40f82000}, {0x40f84000}, {0x40f86000}, {0x40f88000}, {0x40f8a000}, {0x40f8c000}, {0x40f8e000}, {0x40f90000}, {0x40f92000}, {0x40f94000}, {0x40f96000}, {0x40f98000}, {0x40f9a000}, {0x40f9c000}, {0x40f9e000}, {0x40fa0000}, {0x40fa2000}, {0x40fa4000}, {0x40fa6000}, {0x40fa8000}, {0x40faa000}, {0x40fac000}, {0x40fae000}, {0x40fb0000}, {0x40fb2000}, {0x40fb4000}, {0x40fb6000}, {0x40fb8000}, {0x40fba000}, {0x40fbc000}, {0x40fbe000}, {0x40fc0000}, {0x40fc2000}, {0x40fc4000}, {0x40fc6000}, {0x40fc8000}, {0x40fca000}, {0x40fcc000}, {0x40fce000}, {0x40fd0000}, {0x40fd2000}, {0x40fd4000}, {0x40fd6000}, {0x40fd8000}, {0x40fda000}, {0x40fdc000}, {0x40fde000}, {0x40fe0000}, {0x40fe2000}, {0x40fe4000}, {0x40fe6000}, {0x40fe8000}, {0x40fea000}, {0x40fec000}, {0x40fee000}, {0x40ff0000}, {0x40ff2000}, {0x40ff4000}, {0x40ff6000}, {0x40ff8000}, {0x40ffa000}, {0x40ffc000}, {0x40ffe000}, {0x41000000}, {0x41002000}, {0x41004000}, {0x41006000}, {0x41008000}, {0x4100a000}, {0x4100c000}, {0x4100e000}, {0x41010000}, {0x41012000}, {0x41014000}, {0x41016000}, {0x41018000}, {0x4101a000}, {0x4101c000}, {0x4101e000}, {0x41020000}, {0x41022000}, {0x41024000}, {0x41026000}, {0x41028000}, {0x4102a000}, {0x4102c000}, {0x4102e000}, {0x41030000}, {0x41032000}, {0x41034000}, {0x41036000}, {0x41038000}, {0x4103a000}, {0x4103c000}, {0x4103e000}, {0x41040000}, {0x41042000}, {0x41044000}, {0x41046000}, {0x41048000}, {0x4104a000}, {0x4104c000}, {0x4104e000}, {0x41050000}, {0x41052000}, {0x41054000}, {0x41056000}, {0x41058000}, {0x4105a000}, {0x4105c000}, {0x4105e000}, {0x41060000}, {0x41062000}, {0x41064000}, {0x41066000}, {0x41068000}, {0x4106a000}, {0x4106c000}, {0x4106e000}, {0x41070000}, {0x41072000}, {0x41074000}, {0x41076000}, {0x41078000}, {0x4107a000}, {0x4107c000}, {0x4107e000}, {0x41080000}, {0x41082000}, {0x41084000}, {0x41086000}, {0x41088000}, {0x4108a000}, {0x4108c000}, {0x4108e000}, {0x41090000}, {0x41092000}, {0x41094000}, {0x41096000}, {0x41098000}, {0x4109a000}, {0x4109c000}, {0x4109e000}, {0x410a0000}, {0x410a2000}, {0x410a4000}, {0x410a6000}, {0x410a8000}, {0x410aa000}, {0x410ac000}, {0x410ae000}, {0x410b0000}, {0x410b2000}, {0x410b4000}, {0x410b6000}, {0x410b8000}, {0x410ba000}, {0x410bc000}, {0x410be000}, {0x410c0000}, {0x410c2000}, {0x410c4000}, {0x410c6000}, {0x410c8000}, {0x410ca000}, {0x410cc000}, {0x410ce000}, {0x410d0000}, {0x410d2000}, {0x410d4000}, {0x410d6000}, {0x410d8000}, {0x410da000}, {0x410dc000}, {0x410de000}, {0x410e0000}, {0x410e2000}, {0x410e4000}, {0x410e6000}, {0x410e8000}, {0x410ea000}, {0x410ec000}, {0x410ee000}, {0x410f0000}, {0x410f2000}, {0x410f4000}, {0x410f6000}, {0x410f8000}, {0x410fa000}, {0x410fc000}, {0x410fe000}, {0x41100000}, {0x41102000}, {0x41104000}, {0x41106000}, {0x41108000}, {0x4110a000}, {0x4110c000}, {0x4110e000}, {0x41110000}, {0x41112000}, {0x41114000}, {0x41116000}, {0x41118000}, {0x4111a000}, {0x4111c000}, {0x4111e000}, {0x41120000}, {0x41122000}, {0x41124000}, {0x41126000}, {0x41128000}, {0x4112a000}, {0x4112c000}, {0x4112e000}, {0x41130000}, {0x41132000}, {0x41134000}, {0x41136000}, {0x41138000}, {0x4113a000}, {0x4113c000}, {0x4113e000}, {0x41140000}, {0x41142000}, {0x41144000}, {0x41146000}, {0x41148000}, {0x4114a000}, {0x4114c000}, {0x4114e000}, {0x41150000}, {0x41152000}, {0x41154000}, {0x41156000}, {0x41158000}, {0x4115a000}, {0x4115c000}, {0x4115e000}, {0x41160000}, {0x41162000}, {0x41164000}, {0x41166000}, {0x41168000}, {0x4116a000}, {0x4116c000}, {0x4116e000}, {0x41170000}, {0x41172000}, {0x41174000}, {0x41176000}, {0x41178000}, {0x4117a000}, {0x4117c000}, {0x4117e000}, {0x41180000}, {0x41182000}, {0x41184000}, {0x41186000}, {0x41188000}, {0x4118a000}, {0x4118c000}, {0x4118e000}, {0x41190000}, {0x41192000}, {0x41194000}, {0x41196000}, {0x41198000}, {0x4119a000}, {0x4119c000}, {0x4119e000}, {0x411a0000}, {0x411a2000}, {0x411a4000}, {0x411a6000}, {0x411a8000}, {0x411aa000}, {0x411ac000}, {0x411ae000}, {0x411b0000}, {0x411b2000}, {0x411b4000}, {0x411b6000}, {0x411b8000}, {0x411ba000}, {0x411bc000}, {0x411be000}, {0x411c0000}, {0x411c2000}, {0x411c4000}, {0x411c6000}, {0x411c8000}, {0x411ca000}, {0x411cc000}, {0x411ce000}, {0x411d0000}, {0x411d2000}, {0x411d4000}, {0x411d6000}, {0x411d8000}, {0x411da000}, {0x411dc000}, {0x411de000}, {0x411e0000}, {0x411e2000}, {0x411e4000}, {0x411e6000}, {0x411e8000}, {0x411ea000}, {0x411ec000}, {0x411ee000}, {0x411f0000}, {0x411f2000}, {0x411f4000}, {0x411f6000}, {0x411f8000}, {0x411fa000}, {0x411fc000}, {0x411fe000}, {0x41200000}, {0x41202000}, {0x41204000}, {0x41206000}, {0x41208000}, {0x4120a000}, {0x4120c000}, {0x4120e000}, {0x41210000}, {0x41212000}, {0x41214000}, {0x41216000}, {0x41218000}, {0x4121a000}, {0x4121c000}, {0x4121e000}, {0x41220000}, {0x41222000}, {0x41224000}, {0x41226000}, {0x41228000}, {0x4122a000}, {0x4122c000}, {0x4122e000}, {0x41230000}, {0x41232000}, {0x41234000}, {0x41236000}, {0x41238000}, {0x4123a000}, {0x4123c000}, {0x4123e000}, {0x41240000}, {0x41242000}, {0x41244000}, {0x41246000}, {0x41248000}, {0x4124a000}, {0x4124c000}, {0x4124e000}, {0x41250000}, {0x41252000}, {0x41254000}, {0x41256000}, {0x41258000}, {0x4125a000}, {0x4125c000}, {0x4125e000}, {0x41260000}, {0x41262000}, {0x41264000}, {0x41266000}, {0x41268000}, {0x4126a000}, {0x4126c000}, {0x4126e000}, {0x41270000}, {0x41272000}, {0x41274000}, {0x41276000}, {0x41278000}, {0x4127a000}, {0x4127c000}, {0x4127e000}, {0x41280000}, {0x41282000}, {0x41284000}, {0x41286000}, {0x41288000}, {0x4128a000}, {0x4128c000}, {0x4128e000}, {0x41290000}, {0x41292000}, {0x41294000}, {0x41296000}, {0x41298000}, {0x4129a000}, {0x4129c000}, {0x4129e000}, {0x412a0000}, {0x412a2000}, {0x412a4000}, {0x412a6000}, {0x412a8000}, {0x412aa000}, {0x412ac000}, {0x412ae000}, {0x412b0000}, {0x412b2000}, {0x412b4000}, {0x412b6000}, {0x412b8000}, {0x412ba000}, {0x412bc000}, {0x412be000}, {0x412c0000}, {0x412c2000}, {0x412c4000}, {0x412c6000}, {0x412c8000}, {0x412ca000}, {0x412cc000}, {0x412ce000}, {0x412d0000}, {0x412d2000}, {0x412d4000}, {0x412d6000}, {0x412d8000}, {0x412da000}, {0x412dc000}, {0x412de000}, {0x412e0000}, {0x412e2000}, {0x412e4000}, {0x412e6000}, {0x412e8000}, {0x412ea000}, {0x412ec000}, {0x412ee000}, {0x412f0000}, {0x412f2000}, {0x412f4000}, {0x412f6000}, {0x412f8000}, {0x412fa000}, {0x412fc000}, {0x412fe000}, {0x41300000}, {0x41302000}, {0x41304000}, {0x41306000}, {0x41308000}, {0x4130a000}, {0x4130c000}, {0x4130e000}, {0x41310000}, {0x41312000}, {0x41314000}, {0x41316000}, {0x41318000}, {0x4131a000}, {0x4131c000}, {0x4131e000}, {0x41320000}, {0x41322000}, {0x41324000}, {0x41326000}, {0x41328000}, {0x4132a000}, {0x4132c000}, {0x4132e000}, {0x41330000}, {0x41332000}, {0x41334000}, {0x41336000}, {0x41338000}, {0x4133a000}, {0x4133c000}, {0x4133e000}, {0x41340000}, {0x41342000}, {0x41344000}, {0x41346000}, {0x41348000}, {0x4134a000}, {0x4134c000}, {0x4134e000}, {0x41350000}, {0x41352000}, {0x41354000}, {0x41356000}, {0x41358000}, {0x4135a000}, {0x4135c000}, {0x4135e000}, {0x41360000}, {0x41362000}, {0x41364000}, {0x41366000}, {0x41368000}, {0x4136a000}, {0x4136c000}, {0x4136e000}, {0x41370000}, {0x41372000}, {0x41374000}, {0x41376000}, {0x41378000}, {0x4137a000}, {0x4137c000}, {0x4137e000}, {0x41380000}, {0x41382000}, {0x41384000}, {0x41386000}, {0x41388000}, {0x4138a000}, {0x4138c000}, {0x4138e000}, {0x41390000}, {0x41392000}, {0x41394000}, {0x41396000}, {0x41398000}, {0x4139a000}, {0x4139c000}, {0x4139e000}, {0x413a0000}, {0x413a2000}, {0x413a4000}, {0x413a6000}, {0x413a8000}, {0x413aa000}, {0x413ac000}, {0x413ae000}, {0x413b0000}, {0x413b2000}, {0x413b4000}, {0x413b6000}, {0x413b8000}, {0x413ba000}, {0x413bc000}, {0x413be000}, {0x413c0000}, {0x413c2000}, {0x413c4000}, {0x413c6000}, {0x413c8000}, {0x413ca000}, {0x413cc000}, {0x413ce000}, {0x413d0000}, {0x413d2000}, {0x413d4000}, {0x413d6000}, {0x413d8000}, {0x413da000}, {0x413dc000}, {0x413de000}, {0x413e0000}, {0x413e2000}, {0x413e4000}, {0x413e6000}, {0x413e8000}, {0x413ea000}, {0x413ec000}, {0x413ee000}, {0x413f0000}, {0x413f2000}, {0x413f4000}, {0x413f6000}, {0x413f8000}, {0x413fa000}, {0x413fc000}, {0x413fe000}, {0x41400000}, {0x41402000}, {0x41404000}, {0x41406000}, {0x41408000}, {0x4140a000}, {0x4140c000}, {0x4140e000}, {0x41410000}, {0x41412000}, {0x41414000}, {0x41416000}, {0x41418000}, {0x4141a000}, {0x4141c000}, {0x4141e000}, {0x41420000}, {0x41422000}, {0x41424000}, {0x41426000}, {0x41428000}, {0x4142a000}, {0x4142c000}, {0x4142e000}, {0x41430000}, {0x41432000}, {0x41434000}, {0x41436000}, {0x41438000}, {0x4143a000}, {0x4143c000}, {0x4143e000}, {0x41440000}, {0x41442000}, {0x41444000}, {0x41446000}, {0x41448000}, {0x4144a000}, {0x4144c000}, {0x4144e000}, {0x41450000}, {0x41452000}, {0x41454000}, {0x41456000}, {0x41458000}, {0x4145a000}, {0x4145c000}, {0x4145e000}, {0x41460000}, {0x41462000}, {0x41464000}, {0x41466000}, {0x41468000}, {0x4146a000}, {0x4146c000}, {0x4146e000}, {0x41470000}, {0x41472000}, {0x41474000}, {0x41476000}, {0x41478000}, {0x4147a000}, {0x4147c000}, {0x4147e000}, {0x41480000}, {0x41482000}, {0x41484000}, {0x41486000}, {0x41488000}, {0x4148a000}, {0x4148c000}, {0x4148e000}, {0x41490000}, {0x41492000}, {0x41494000}, {0x41496000}, {0x41498000}, {0x4149a000}, {0x4149c000}, {0x4149e000}, {0x414a0000}, {0x414a2000}, {0x414a4000}, {0x414a6000}, {0x414a8000}, {0x414aa000}, {0x414ac000}, {0x414ae000}, {0x414b0000}, {0x414b2000}, {0x414b4000}, {0x414b6000}, {0x414b8000}, {0x414ba000}, {0x414bc000}, {0x414be000}, {0x414c0000}, {0x414c2000}, {0x414c4000}, {0x414c6000}, {0x414c8000}, {0x414ca000}, {0x414cc000}, {0x414ce000}, {0x414d0000}, {0x414d2000}, {0x414d4000}, {0x414d6000}, {0x414d8000}, {0x414da000}, {0x414dc000}, {0x414de000}, {0x414e0000}, {0x414e2000}, {0x414e4000}, {0x414e6000}, {0x414e8000}, {0x414ea000}, {0x414ec000}, {0x414ee000}, {0x414f0000}, {0x414f2000}, {0x414f4000}, {0x414f6000}, {0x414f8000}, {0x414fa000}, {0x414fc000}, {0x414fe000}, {0x41500000}, {0x41502000}, {0x41504000}, {0x41506000}, {0x41508000}, {0x4150a000}, {0x4150c000}, {0x4150e000}, {0x41510000}, {0x41512000}, {0x41514000}, {0x41516000}, {0x41518000}, {0x4151a000}, {0x4151c000}, {0x4151e000}, {0x41520000}, {0x41522000}, {0x41524000}, {0x41526000}, {0x41528000}, {0x4152a000}, {0x4152c000}, {0x4152e000}, {0x41530000}, {0x41532000}, {0x41534000}, {0x41536000}, {0x41538000}, {0x4153a000}, {0x4153c000}, {0x4153e000}, {0x41540000}, {0x41542000}, {0x41544000}, {0x41546000}, {0x41548000}, {0x4154a000}, {0x4154c000}, {0x4154e000}, {0x41550000}, {0x41552000}, {0x41554000}, {0x41556000}, {0x41558000}, {0x4155a000}, {0x4155c000}, {0x4155e000}, {0x41560000}, {0x41562000}, {0x41564000}, {0x41566000}, {0x41568000}, {0x4156a000}, {0x4156c000}, {0x4156e000}, {0x41570000}, {0x41572000}, {0x41574000}, {0x41576000}, {0x41578000}, {0x4157a000}, {0x4157c000}, {0x4157e000}, {0x41580000}, {0x41582000}, {0x41584000}, {0x41586000}, {0x41588000}, {0x4158a000}, {0x4158c000}, {0x4158e000}, {0x41590000}, {0x41592000}, {0x41594000}, {0x41596000}, {0x41598000}, {0x4159a000}, {0x4159c000}, {0x4159e000}, {0x415a0000}, {0x415a2000}, {0x415a4000}, {0x415a6000}, {0x415a8000}, {0x415aa000}, {0x415ac000}, {0x415ae000}, {0x415b0000}, {0x415b2000}, {0x415b4000}, {0x415b6000}, {0x415b8000}, {0x415ba000}, {0x415bc000}, {0x415be000}, {0x415c0000}, {0x415c2000}, {0x415c4000}, {0x415c6000}, {0x415c8000}, {0x415ca000}, {0x415cc000}, {0x415ce000}, {0x415d0000}, {0x415d2000}, {0x415d4000}, {0x415d6000}, {0x415d8000}, {0x415da000}, {0x415dc000}, {0x415de000}, {0x415e0000}, {0x415e2000}, {0x415e4000}, {0x415e6000}, {0x415e8000}, {0x415ea000}, {0x415ec000}, {0x415ee000}, {0x415f0000}, {0x415f2000}, {0x415f4000}, {0x415f6000}, {0x415f8000}, {0x415fa000}, {0x415fc000}, {0x415fe000}, {0x41600000}, {0x41602000}, {0x41604000}, {0x41606000}, {0x41608000}, {0x4160a000}, {0x4160c000}, {0x4160e000}, {0x41610000}, {0x41612000}, {0x41614000}, {0x41616000}, {0x41618000}, {0x4161a000}, {0x4161c000}, {0x4161e000}, {0x41620000}, {0x41622000}, {0x41624000}, {0x41626000}, {0x41628000}, {0x4162a000}, {0x4162c000}, {0x4162e000}, {0x41630000}, {0x41632000}, {0x41634000}, {0x41636000}, {0x41638000}, {0x4163a000}, {0x4163c000}, {0x4163e000}, {0x41640000}, {0x41642000}, {0x41644000}, {0x41646000}, {0x41648000}, {0x4164a000}, {0x4164c000}, {0x4164e000}, {0x41650000}, {0x41652000}, {0x41654000}, {0x41656000}, {0x41658000}, {0x4165a000}, {0x4165c000}, {0x4165e000}, {0x41660000}, {0x41662000}, {0x41664000}, {0x41666000}, {0x41668000}, {0x4166a000}, {0x4166c000}, {0x4166e000}, {0x41670000}, {0x41672000}, {0x41674000}, {0x41676000}, {0x41678000}, {0x4167a000}, {0x4167c000}, {0x4167e000}, {0x41680000}, {0x41682000}, {0x41684000}, {0x41686000}, {0x41688000}, {0x4168a000}, {0x4168c000}, {0x4168e000}, {0x41690000}, {0x41692000}, {0x41694000}, {0x41696000}, {0x41698000}, {0x4169a000}, {0x4169c000}, {0x4169e000}, {0x416a0000}, {0x416a2000}, {0x416a4000}, {0x416a6000}, {0x416a8000}, {0x416aa000}, {0x416ac000}, {0x416ae000}, {0x416b0000}, {0x416b2000}, {0x416b4000}, {0x416b6000}, {0x416b8000}, {0x416ba000}, {0x416bc000}, {0x416be000}, {0x416c0000}, {0x416c2000}, {0x416c4000}, {0x416c6000}, {0x416c8000}, {0x416ca000}, {0x416cc000}, {0x416ce000}, {0x416d0000}, {0x416d2000}, {0x416d4000}, {0x416d6000}, {0x416d8000}, {0x416da000}, {0x416dc000}, {0x416de000}, {0x416e0000}, {0x416e2000}, {0x416e4000}, {0x416e6000}, {0x416e8000}, {0x416ea000}, {0x416ec000}, {0x416ee000}, {0x416f0000}, {0x416f2000}, {0x416f4000}, {0x416f6000}, {0x416f8000}, {0x416fa000}, {0x416fc000}, {0x416fe000}, {0x41700000}, {0x41702000}, {0x41704000}, {0x41706000}, {0x41708000}, {0x4170a000}, {0x4170c000}, {0x4170e000}, {0x41710000}, {0x41712000}, {0x41714000}, {0x41716000}, {0x41718000}, {0x4171a000}, {0x4171c000}, {0x4171e000}, {0x41720000}, {0x41722000}, {0x41724000}, {0x41726000}, {0x41728000}, {0x4172a000}, {0x4172c000}, {0x4172e000}, {0x41730000}, {0x41732000}, {0x41734000}, {0x41736000}, {0x41738000}, {0x4173a000}, {0x4173c000}, {0x4173e000}, {0x41740000}, {0x41742000}, {0x41744000}, {0x41746000}, {0x41748000}, {0x4174a000}, {0x4174c000}, {0x4174e000}, {0x41750000}, {0x41752000}, {0x41754000}, {0x41756000}, {0x41758000}, {0x4175a000}, {0x4175c000}, {0x4175e000}, {0x41760000}, {0x41762000}, {0x41764000}, {0x41766000}, {0x41768000}, {0x4176a000}, {0x4176c000}, {0x4176e000}, {0x41770000}, {0x41772000}, {0x41774000}, {0x41776000}, {0x41778000}, {0x4177a000}, {0x4177c000}, {0x4177e000}, {0x41780000}, {0x41782000}, {0x41784000}, {0x41786000}, {0x41788000}, {0x4178a000}, {0x4178c000}, {0x4178e000}, {0x41790000}, {0x41792000}, {0x41794000}, {0x41796000}, {0x41798000}, {0x4179a000}, {0x4179c000}, {0x4179e000}, {0x417a0000}, {0x417a2000}, {0x417a4000}, {0x417a6000}, {0x417a8000}, {0x417aa000}, {0x417ac000}, {0x417ae000}, {0x417b0000}, {0x417b2000}, {0x417b4000}, {0x417b6000}, {0x417b8000}, {0x417ba000}, {0x417bc000}, {0x417be000}, {0x417c0000}, {0x417c2000}, {0x417c4000}, {0x417c6000}, {0x417c8000}, {0x417ca000}, {0x417cc000}, {0x417ce000}, {0x417d0000}, {0x417d2000}, {0x417d4000}, {0x417d6000}, {0x417d8000}, {0x417da000}, {0x417dc000}, {0x417de000}, {0x417e0000}, {0x417e2000}, {0x417e4000}, {0x417e6000}, {0x417e8000}, {0x417ea000}, {0x417ec000}, {0x417ee000}, {0x417f0000}, {0x417f2000}, {0x417f4000}, {0x417f6000}, {0x417f8000}, {0x417fa000}, {0x417fc000}, {0x417fe000}, {0x41800000}, {0x41802000}, {0x41804000}, {0x41806000}, {0x41808000}, {0x4180a000}, {0x4180c000}, {0x4180e000}, {0x41810000}, {0x41812000}, {0x41814000}, {0x41816000}, {0x41818000}, {0x4181a000}, {0x4181c000}, {0x4181e000}, {0x41820000}, {0x41822000}, {0x41824000}, {0x41826000}, {0x41828000}, {0x4182a000}, {0x4182c000}, {0x4182e000}, {0x41830000}, {0x41832000}, {0x41834000}, {0x41836000}, {0x41838000}, {0x4183a000}, {0x4183c000}, {0x4183e000}, {0x41840000}, {0x41842000}, {0x41844000}, {0x41846000}, {0x41848000}, {0x4184a000}, {0x4184c000}, {0x4184e000}, {0x41850000}, {0x41852000}, {0x41854000}, {0x41856000}, {0x41858000}, {0x4185a000}, {0x4185c000}, {0x4185e000}, {0x41860000}, {0x41862000}, {0x41864000}, {0x41866000}, {0x41868000}, {0x4186a000}, {0x4186c000}, {0x4186e000}, {0x41870000}, {0x41872000}, {0x41874000}, {0x41876000}, {0x41878000}, {0x4187a000}, {0x4187c000}, {0x4187e000}, {0x41880000}, {0x41882000}, {0x41884000}, {0x41886000}, {0x41888000}, {0x4188a000}, {0x4188c000}, {0x4188e000}, {0x41890000}, {0x41892000}, {0x41894000}, {0x41896000}, {0x41898000}, {0x4189a000}, {0x4189c000}, {0x4189e000}, {0x418a0000}, {0x418a2000}, {0x418a4000}, {0x418a6000}, {0x418a8000}, {0x418aa000}, {0x418ac000}, {0x418ae000}, {0x418b0000}, {0x418b2000}, {0x418b4000}, {0x418b6000}, {0x418b8000}, {0x418ba000}, {0x418bc000}, {0x418be000}, {0x418c0000}, {0x418c2000}, {0x418c4000}, {0x418c6000}, {0x418c8000}, {0x418ca000}, {0x418cc000}, {0x418ce000}, {0x418d0000}, {0x418d2000}, {0x418d4000}, {0x418d6000}, {0x418d8000}, {0x418da000}, {0x418dc000}, {0x418de000}, {0x418e0000}, {0x418e2000}, {0x418e4000}, {0x418e6000}, {0x418e8000}, {0x418ea000}, {0x418ec000}, {0x418ee000}, {0x418f0000}, {0x418f2000}, {0x418f4000}, {0x418f6000}, {0x418f8000}, {0x418fa000}, {0x418fc000}, {0x418fe000}, {0x41900000}, {0x41902000}, {0x41904000}, {0x41906000}, {0x41908000}, {0x4190a000}, {0x4190c000}, {0x4190e000}, {0x41910000}, {0x41912000}, {0x41914000}, {0x41916000}, {0x41918000}, {0x4191a000}, {0x4191c000}, {0x4191e000}, {0x41920000}, {0x41922000}, {0x41924000}, {0x41926000}, {0x41928000}, {0x4192a000}, {0x4192c000}, {0x4192e000}, {0x41930000}, {0x41932000}, {0x41934000}, {0x41936000}, {0x41938000}, {0x4193a000}, {0x4193c000}, {0x4193e000}, {0x41940000}, {0x41942000}, {0x41944000}, {0x41946000}, {0x41948000}, {0x4194a000}, {0x4194c000}, {0x4194e000}, {0x41950000}, {0x41952000}, {0x41954000}, {0x41956000}, {0x41958000}, {0x4195a000}, {0x4195c000}, {0x4195e000}, {0x41960000}, {0x41962000}, {0x41964000}, {0x41966000}, {0x41968000}, {0x4196a000}, {0x4196c000}, {0x4196e000}, {0x41970000}, {0x41972000}, {0x41974000}, {0x41976000}, {0x41978000}, {0x4197a000}, {0x4197c000}, {0x4197e000}, {0x41980000}, {0x41982000}, {0x41984000}, {0x41986000}, {0x41988000}, {0x4198a000}, {0x4198c000}, {0x4198e000}, {0x41990000}, {0x41992000}, {0x41994000}, {0x41996000}, {0x41998000}, {0x4199a000}, {0x4199c000}, {0x4199e000}, {0x419a0000}, {0x419a2000}, {0x419a4000}, {0x419a6000}, {0x419a8000}, {0x419aa000}, {0x419ac000}, {0x419ae000}, {0x419b0000}, {0x419b2000}, {0x419b4000}, {0x419b6000}, {0x419b8000}, {0x419ba000}, {0x419bc000}, {0x419be000}, {0x419c0000}, {0x419c2000}, {0x419c4000}, {0x419c6000}, {0x419c8000}, {0x419ca000}, {0x419cc000}, {0x419ce000}, {0x419d0000}, {0x419d2000}, {0x419d4000}, {0x419d6000}, {0x419d8000}, {0x419da000}, {0x419dc000}, {0x419de000}, {0x419e0000}, {0x419e2000}, {0x419e4000}, {0x419e6000}, {0x419e8000}, {0x419ea000}, {0x419ec000}, {0x419ee000}, {0x419f0000}, {0x419f2000}, {0x419f4000}, {0x419f6000}, {0x419f8000}, {0x419fa000}, {0x419fc000}, {0x419fe000}, {0x41a00000}, {0x41a02000}, {0x41a04000}, {0x41a06000}, {0x41a08000}, {0x41a0a000}, {0x41a0c000}, {0x41a0e000}, {0x41a10000}, {0x41a12000}, {0x41a14000}, {0x41a16000}, {0x41a18000}, {0x41a1a000}, {0x41a1c000}, {0x41a1e000}, {0x41a20000}, {0x41a22000}, {0x41a24000}, {0x41a26000}, {0x41a28000}, {0x41a2a000}, {0x41a2c000}, {0x41a2e000}, {0x41a30000}, {0x41a32000}, {0x41a34000}, {0x41a36000}, {0x41a38000}, {0x41a3a000}, {0x41a3c000}, {0x41a3e000}, {0x41a40000}, {0x41a42000}, {0x41a44000}, {0x41a46000}, {0x41a48000}, {0x41a4a000}, {0x41a4c000}, {0x41a4e000}, {0x41a50000}, {0x41a52000}, {0x41a54000}, {0x41a56000}, {0x41a58000}, {0x41a5a000}, {0x41a5c000}, {0x41a5e000}, {0x41a60000}, {0x41a62000}, {0x41a64000}, {0x41a66000}, {0x41a68000}, {0x41a6a000}, {0x41a6c000}, {0x41a6e000}, {0x41a70000}, {0x41a72000}, {0x41a74000}, {0x41a76000}, {0x41a78000}, {0x41a7a000}, {0x41a7c000}, {0x41a7e000}, {0x41a80000}, {0x41a82000}, {0x41a84000}, {0x41a86000}, {0x41a88000}, {0x41a8a000}, {0x41a8c000}, {0x41a8e000}, {0x41a90000}, {0x41a92000}, {0x41a94000}, {0x41a96000}, {0x41a98000}, {0x41a9a000}, {0x41a9c000}, {0x41a9e000}, {0x41aa0000}, {0x41aa2000}, {0x41aa4000}, {0x41aa6000}, {0x41aa8000}, {0x41aaa000}, {0x41aac000}, {0x41aae000}, {0x41ab0000}, {0x41ab2000}, {0x41ab4000}, {0x41ab6000}, {0x41ab8000}, {0x41aba000}, {0x41abc000}, {0x41abe000}, {0x41ac0000}, {0x41ac2000}, {0x41ac4000}, {0x41ac6000}, {0x41ac8000}, {0x41aca000}, {0x41acc000}, {0x41ace000}, {0x41ad0000}, {0x41ad2000}, {0x41ad4000}, {0x41ad6000}, {0x41ad8000}, {0x41ada000}, {0x41adc000}, {0x41ade000}, {0x41ae0000}, {0x41ae2000}, {0x41ae4000}, {0x41ae6000}, {0x41ae8000}, {0x41aea000}, {0x41aec000}, {0x41aee000}, {0x41af0000}, {0x41af2000}, {0x41af4000}, {0x41af6000}, {0x41af8000}, {0x41afa000}, {0x41afc000}, {0x41afe000}, {0x41b00000}, {0x41b02000}, {0x41b04000}, {0x41b06000}, {0x41b08000}, {0x41b0a000}, {0x41b0c000}, {0x41b0e000}, {0x41b10000}, {0x41b12000}, {0x41b14000}, {0x41b16000}, {0x41b18000}, {0x41b1a000}, {0x41b1c000}, {0x41b1e000}, {0x41b20000}, {0x41b22000}, {0x41b24000}, {0x41b26000}, {0x41b28000}, {0x41b2a000}, {0x41b2c000}, {0x41b2e000}, {0x41b30000}, {0x41b32000}, {0x41b34000}, {0x41b36000}, {0x41b38000}, {0x41b3a000}, {0x41b3c000}, {0x41b3e000}, {0x41b40000}, {0x41b42000}, {0x41b44000}, {0x41b46000}, {0x41b48000}, {0x41b4a000}, {0x41b4c000}, {0x41b4e000}, {0x41b50000}, {0x41b52000}, {0x41b54000}, {0x41b56000}, {0x41b58000}, {0x41b5a000}, {0x41b5c000}, {0x41b5e000}, {0x41b60000}, {0x41b62000}, {0x41b64000}, {0x41b66000}, {0x41b68000}, {0x41b6a000}, {0x41b6c000}, {0x41b6e000}, {0x41b70000}, {0x41b72000}, {0x41b74000}, {0x41b76000}, {0x41b78000}, {0x41b7a000}, {0x41b7c000}, {0x41b7e000}, {0x41b80000}, {0x41b82000}, {0x41b84000}, {0x41b86000}, {0x41b88000}, {0x41b8a000}, {0x41b8c000}, {0x41b8e000}, {0x41b90000}, {0x41b92000}, {0x41b94000}, {0x41b96000}, {0x41b98000}, {0x41b9a000}, {0x41b9c000}, {0x41b9e000}, {0x41ba0000}, {0x41ba2000}, {0x41ba4000}, {0x41ba6000}, {0x41ba8000}, {0x41baa000}, {0x41bac000}, {0x41bae000}, {0x41bb0000}, {0x41bb2000}, {0x41bb4000}, {0x41bb6000}, {0x41bb8000}, {0x41bba000}, {0x41bbc000}, {0x41bbe000}, {0x41bc0000}, {0x41bc2000}, {0x41bc4000}, {0x41bc6000}, {0x41bc8000}, {0x41bca000}, {0x41bcc000}, {0x41bce000}, {0x41bd0000}, {0x41bd2000}, {0x41bd4000}, {0x41bd6000}, {0x41bd8000}, {0x41bda000}, {0x41bdc000}, {0x41bde000}, {0x41be0000}, {0x41be2000}, {0x41be4000}, {0x41be6000}, {0x41be8000}, {0x41bea000}, {0x41bec000}, {0x41bee000}, {0x41bf0000}, {0x41bf2000}, {0x41bf4000}, {0x41bf6000}, {0x41bf8000}, {0x41bfa000}, {0x41bfc000}, {0x41bfe000}, {0x41c00000}, {0x41c02000}, {0x41c04000}, {0x41c06000}, {0x41c08000}, {0x41c0a000}, {0x41c0c000}, {0x41c0e000}, {0x41c10000}, {0x41c12000}, {0x41c14000}, {0x41c16000}, {0x41c18000}, {0x41c1a000}, {0x41c1c000}, {0x41c1e000}, {0x41c20000}, {0x41c22000}, {0x41c24000}, {0x41c26000}, {0x41c28000}, {0x41c2a000}, {0x41c2c000}, {0x41c2e000}, {0x41c30000}, {0x41c32000}, {0x41c34000}, {0x41c36000}, {0x41c38000}, {0x41c3a000}, {0x41c3c000}, {0x41c3e000}, {0x41c40000}, {0x41c42000}, {0x41c44000}, {0x41c46000}, {0x41c48000}, {0x41c4a000}, {0x41c4c000}, {0x41c4e000}, {0x41c50000}, {0x41c52000}, {0x41c54000}, {0x41c56000}, {0x41c58000}, {0x41c5a000}, {0x41c5c000}, {0x41c5e000}, {0x41c60000}, {0x41c62000}, {0x41c64000}, {0x41c66000}, {0x41c68000}, {0x41c6a000}, {0x41c6c000}, {0x41c6e000}, {0x41c70000}, {0x41c72000}, {0x41c74000}, {0x41c76000}, {0x41c78000}, {0x41c7a000}, {0x41c7c000}, {0x41c7e000}, {0x41c80000}, {0x41c82000}, {0x41c84000}, {0x41c86000}, {0x41c88000}, {0x41c8a000}, {0x41c8c000}, {0x41c8e000}, {0x41c90000}, {0x41c92000}, {0x41c94000}, {0x41c96000}, {0x41c98000}, {0x41c9a000}, {0x41c9c000}, {0x41c9e000}, {0x41ca0000}, {0x41ca2000}, {0x41ca4000}, {0x41ca6000}, {0x41ca8000}, {0x41caa000}, {0x41cac000}, {0x41cae000}, {0x41cb0000}, {0x41cb2000}, {0x41cb4000}, {0x41cb6000}, {0x41cb8000}, {0x41cba000}, {0x41cbc000}, {0x41cbe000}, {0x41cc0000}, {0x41cc2000}, {0x41cc4000}, {0x41cc6000}, {0x41cc8000}, {0x41cca000}, {0x41ccc000}, {0x41cce000}, {0x41cd0000}, {0x41cd2000}, {0x41cd4000}, {0x41cd6000}, {0x41cd8000}, {0x41cda000}, {0x41cdc000}, {0x41cde000}, {0x41ce0000}, {0x41ce2000}, {0x41ce4000}, {0x41ce6000}, {0x41ce8000}, {0x41cea000}, {0x41cec000}, {0x41cee000}, {0x41cf0000}, {0x41cf2000}, {0x41cf4000}, {0x41cf6000}, {0x41cf8000}, {0x41cfa000}, {0x41cfc000}, {0x41cfe000}, {0x41d00000}, {0x41d02000}, {0x41d04000}, {0x41d06000}, {0x41d08000}, {0x41d0a000}, {0x41d0c000}, {0x41d0e000}, {0x41d10000}, {0x41d12000}, {0x41d14000}, {0x41d16000}, {0x41d18000}, {0x41d1a000}, {0x41d1c000}, {0x41d1e000}, {0x41d20000}, {0x41d22000}, {0x41d24000}, {0x41d26000}, {0x41d28000}, {0x41d2a000}, {0x41d2c000}, {0x41d2e000}, {0x41d30000}, {0x41d32000}, {0x41d34000}, {0x41d36000}, {0x41d38000}, {0x41d3a000}, {0x41d3c000}, {0x41d3e000}, {0x41d40000}, {0x41d42000}, {0x41d44000}, {0x41d46000}, {0x41d48000}, {0x41d4a000}, {0x41d4c000}, {0x41d4e000}, {0x41d50000}, {0x41d52000}, {0x41d54000}, {0x41d56000}, {0x41d58000}, {0x41d5a000}, {0x41d5c000}, {0x41d5e000}, {0x41d60000}, {0x41d62000}, {0x41d64000}, {0x41d66000}, {0x41d68000}, {0x41d6a000}, {0x41d6c000}, {0x41d6e000}, {0x41d70000}, {0x41d72000}, {0x41d74000}, {0x41d76000}, {0x41d78000}, {0x41d7a000}, {0x41d7c000}, {0x41d7e000}, {0x41d80000}, {0x41d82000}, {0x41d84000}, {0x41d86000}, {0x41d88000}, {0x41d8a000}, {0x41d8c000}, {0x41d8e000}, {0x41d90000}, {0x41d92000}, {0x41d94000}, {0x41d96000}, {0x41d98000}, {0x41d9a000}, {0x41d9c000}, {0x41d9e000}, {0x41da0000}, {0x41da2000}, {0x41da4000}, {0x41da6000}, {0x41da8000}, {0x41daa000}, {0x41dac000}, {0x41dae000}, {0x41db0000}, {0x41db2000}, {0x41db4000}, {0x41db6000}, {0x41db8000}, {0x41dba000}, {0x41dbc000}, {0x41dbe000}, {0x41dc0000}, {0x41dc2000}, {0x41dc4000}, {0x41dc6000}, {0x41dc8000}, {0x41dca000}, {0x41dcc000}, {0x41dce000}, {0x41dd0000}, {0x41dd2000}, {0x41dd4000}, {0x41dd6000}, {0x41dd8000}, {0x41dda000}, {0x41ddc000}, {0x41dde000}, {0x41de0000}, {0x41de2000}, {0x41de4000}, {0x41de6000}, {0x41de8000}, {0x41dea000}, {0x41dec000}, {0x41dee000}, {0x41df0000}, {0x41df2000}, {0x41df4000}, {0x41df6000}, {0x41df8000}, {0x41dfa000}, {0x41dfc000}, {0x41dfe000}, {0x41e00000}, {0x41e02000}, {0x41e04000}, {0x41e06000}, {0x41e08000}, {0x41e0a000}, {0x41e0c000}, {0x41e0e000}, {0x41e10000}, {0x41e12000}, {0x41e14000}, {0x41e16000}, {0x41e18000}, {0x41e1a000}, {0x41e1c000}, {0x41e1e000}, {0x41e20000}, {0x41e22000}, {0x41e24000}, {0x41e26000}, {0x41e28000}, {0x41e2a000}, {0x41e2c000}, {0x41e2e000}, {0x41e30000}, {0x41e32000}, {0x41e34000}, {0x41e36000}, {0x41e38000}, {0x41e3a000}, {0x41e3c000}, {0x41e3e000}, {0x41e40000}, {0x41e42000}, {0x41e44000}, {0x41e46000}, {0x41e48000}, {0x41e4a000}, {0x41e4c000}, {0x41e4e000}, {0x41e50000}, {0x41e52000}, {0x41e54000}, {0x41e56000}, {0x41e58000}, {0x41e5a000}, {0x41e5c000}, {0x41e5e000}, {0x41e60000}, {0x41e62000}, {0x41e64000}, {0x41e66000}, {0x41e68000}, {0x41e6a000}, {0x41e6c000}, {0x41e6e000}, {0x41e70000}, {0x41e72000}, {0x41e74000}, {0x41e76000}, {0x41e78000}, {0x41e7a000}, {0x41e7c000}, {0x41e7e000}, {0x41e80000}, {0x41e82000}, {0x41e84000}, {0x41e86000}, {0x41e88000}, {0x41e8a000}, {0x41e8c000}, {0x41e8e000}, {0x41e90000}, {0x41e92000}, {0x41e94000}, {0x41e96000}, {0x41e98000}, {0x41e9a000}, {0x41e9c000}, {0x41e9e000}, {0x41ea0000}, {0x41ea2000}, {0x41ea4000}, {0x41ea6000}, {0x41ea8000}, {0x41eaa000}, {0x41eac000}, {0x41eae000}, {0x41eb0000}, {0x41eb2000}, {0x41eb4000}, {0x41eb6000}, {0x41eb8000}, {0x41eba000}, {0x41ebc000}, {0x41ebe000}, {0x41ec0000}, {0x41ec2000}, {0x41ec4000}, {0x41ec6000}, {0x41ec8000}, {0x41eca000}, {0x41ecc000}, {0x41ece000}, {0x41ed0000}, {0x41ed2000}, {0x41ed4000}, {0x41ed6000}, {0x41ed8000}, {0x41eda000}, {0x41edc000}, {0x41ede000}, {0x41ee0000}, {0x41ee2000}, {0x41ee4000}, {0x41ee6000}, {0x41ee8000}, {0x41eea000}, {0x41eec000}, {0x41eee000}, {0x41ef0000}, {0x41ef2000}, {0x41ef4000}, {0x41ef6000}, {0x41ef8000}, {0x41efa000}, {0x41efc000}, {0x41efe000}, {0x41f00000}, {0x41f02000}, {0x41f04000}, {0x41f06000}, {0x41f08000}, {0x41f0a000}, {0x41f0c000}, {0x41f0e000}, {0x41f10000}, {0x41f12000}, {0x41f14000}, {0x41f16000}, {0x41f18000}, {0x41f1a000}, {0x41f1c000}, {0x41f1e000}, {0x41f20000}, {0x41f22000}, {0x41f24000}, {0x41f26000}, {0x41f28000}, {0x41f2a000}, {0x41f2c000}, {0x41f2e000}, {0x41f30000}, {0x41f32000}, {0x41f34000}, {0x41f36000}, {0x41f38000}, {0x41f3a000}, {0x41f3c000}, {0x41f3e000}, {0x41f40000}, {0x41f42000}, {0x41f44000}, {0x41f46000}, {0x41f48000}, {0x41f4a000}, {0x41f4c000}, {0x41f4e000}, {0x41f50000}, {0x41f52000}, {0x41f54000}, {0x41f56000}, {0x41f58000}, {0x41f5a000}, {0x41f5c000}, {0x41f5e000}, {0x41f60000}, {0x41f62000}, {0x41f64000}, {0x41f66000}, {0x41f68000}, {0x41f6a000}, {0x41f6c000}, {0x41f6e000}, {0x41f70000}, {0x41f72000}, {0x41f74000}, {0x41f76000}, {0x41f78000}, {0x41f7a000}, {0x41f7c000}, {0x41f7e000}, {0x41f80000}, {0x41f82000}, {0x41f84000}, {0x41f86000}, {0x41f88000}, {0x41f8a000}, {0x41f8c000}, {0x41f8e000}, {0x41f90000}, {0x41f92000}, {0x41f94000}, {0x41f96000}, {0x41f98000}, {0x41f9a000}, {0x41f9c000}, {0x41f9e000}, {0x41fa0000}, {0x41fa2000}, {0x41fa4000}, {0x41fa6000}, {0x41fa8000}, {0x41faa000}, {0x41fac000}, {0x41fae000}, {0x41fb0000}, {0x41fb2000}, {0x41fb4000}, {0x41fb6000}, {0x41fb8000}, {0x41fba000}, {0x41fbc000}, {0x41fbe000}, {0x41fc0000}, {0x41fc2000}, {0x41fc4000}, {0x41fc6000}, {0x41fc8000}, {0x41fca000}, {0x41fcc000}, {0x41fce000}, {0x41fd0000}, {0x41fd2000}, {0x41fd4000}, {0x41fd6000}, {0x41fd8000}, {0x41fda000}, {0x41fdc000}, {0x41fde000}, {0x41fe0000}, {0x41fe2000}, {0x41fe4000}, {0x41fe6000}, {0x41fe8000}, {0x41fea000}, {0x41fec000}, {0x41fee000}, {0x41ff0000}, {0x41ff2000}, {0x41ff4000}, {0x41ff6000}, {0x41ff8000}, {0x41ffa000}, {0x41ffc000}, {0x41ffe000}, {0x42000000}, {0x42002000}, {0x42004000}, {0x42006000}, {0x42008000}, {0x4200a000}, {0x4200c000}, {0x4200e000}, {0x42010000}, {0x42012000}, {0x42014000}, {0x42016000}, {0x42018000}, {0x4201a000}, {0x4201c000}, {0x4201e000}, {0x42020000}, {0x42022000}, {0x42024000}, {0x42026000}, {0x42028000}, {0x4202a000}, {0x4202c000}, {0x4202e000}, {0x42030000}, {0x42032000}, {0x42034000}, {0x42036000}, {0x42038000}, {0x4203a000}, {0x4203c000}, {0x4203e000}, {0x42040000}, {0x42042000}, {0x42044000}, {0x42046000}, {0x42048000}, {0x4204a000}, {0x4204c000}, {0x4204e000}, {0x42050000}, {0x42052000}, {0x42054000}, {0x42056000}, {0x42058000}, {0x4205a000}, {0x4205c000}, {0x4205e000}, {0x42060000}, {0x42062000}, {0x42064000}, {0x42066000}, {0x42068000}, {0x4206a000}, {0x4206c000}, {0x4206e000}, {0x42070000}, {0x42072000}, {0x42074000}, {0x42076000}, {0x42078000}, {0x4207a000}, {0x4207c000}, {0x4207e000}, {0x42080000}, {0x42082000}, {0x42084000}, {0x42086000}, {0x42088000}, {0x4208a000}, {0x4208c000}, {0x4208e000}, {0x42090000}, {0x42092000}, {0x42094000}, {0x42096000}, {0x42098000}, {0x4209a000}, {0x4209c000}, {0x4209e000}, {0x420a0000}, {0x420a2000}, {0x420a4000}, {0x420a6000}, {0x420a8000}, {0x420aa000}, {0x420ac000}, {0x420ae000}, {0x420b0000}, {0x420b2000}, {0x420b4000}, {0x420b6000}, {0x420b8000}, {0x420ba000}, {0x420bc000}, {0x420be000}, {0x420c0000}, {0x420c2000}, {0x420c4000}, {0x420c6000}, {0x420c8000}, {0x420ca000}, {0x420cc000}, {0x420ce000}, {0x420d0000}, {0x420d2000}, {0x420d4000}, {0x420d6000}, {0x420d8000}, {0x420da000}, {0x420dc000}, {0x420de000}, {0x420e0000}, {0x420e2000}, {0x420e4000}, {0x420e6000}, {0x420e8000}, {0x420ea000}, {0x420ec000}, {0x420ee000}, {0x420f0000}, {0x420f2000}, {0x420f4000}, {0x420f6000}, {0x420f8000}, {0x420fa000}, {0x420fc000}, {0x420fe000}, {0x42100000}, {0x42102000}, {0x42104000}, {0x42106000}, {0x42108000}, {0x4210a000}, {0x4210c000}, {0x4210e000}, {0x42110000}, {0x42112000}, {0x42114000}, {0x42116000}, {0x42118000}, {0x4211a000}, {0x4211c000}, {0x4211e000}, {0x42120000}, {0x42122000}, {0x42124000}, {0x42126000}, {0x42128000}, {0x4212a000}, {0x4212c000}, {0x4212e000}, {0x42130000}, {0x42132000}, {0x42134000}, {0x42136000}, {0x42138000}, {0x4213a000}, {0x4213c000}, {0x4213e000}, {0x42140000}, {0x42142000}, {0x42144000}, {0x42146000}, {0x42148000}, {0x4214a000}, {0x4214c000}, {0x4214e000}, {0x42150000}, {0x42152000}, {0x42154000}, {0x42156000}, {0x42158000}, {0x4215a000}, {0x4215c000}, {0x4215e000}, {0x42160000}, {0x42162000}, {0x42164000}, {0x42166000}, {0x42168000}, {0x4216a000}, {0x4216c000}, {0x4216e000}, {0x42170000}, {0x42172000}, {0x42174000}, {0x42176000}, {0x42178000}, {0x4217a000}, {0x4217c000}, {0x4217e000}, {0x42180000}, {0x42182000}, {0x42184000}, {0x42186000}, {0x42188000}, {0x4218a000}, {0x4218c000}, {0x4218e000}, {0x42190000}, {0x42192000}, {0x42194000}, {0x42196000}, {0x42198000}, {0x4219a000}, {0x4219c000}, {0x4219e000}, {0x421a0000}, {0x421a2000}, {0x421a4000}, {0x421a6000}, {0x421a8000}, {0x421aa000}, {0x421ac000}, {0x421ae000}, {0x421b0000}, {0x421b2000}, {0x421b4000}, {0x421b6000}, {0x421b8000}, {0x421ba000}, {0x421bc000}, {0x421be000}, {0x421c0000}, {0x421c2000}, {0x421c4000}, {0x421c6000}, {0x421c8000}, {0x421ca000}, {0x421cc000}, {0x421ce000}, {0x421d0000}, {0x421d2000}, {0x421d4000}, {0x421d6000}, {0x421d8000}, {0x421da000}, {0x421dc000}, {0x421de000}, {0x421e0000}, {0x421e2000}, {0x421e4000}, {0x421e6000}, {0x421e8000}, {0x421ea000}, {0x421ec000}, {0x421ee000}, {0x421f0000}, {0x421f2000}, {0x421f4000}, {0x421f6000}, {0x421f8000}, {0x421fa000}, {0x421fc000}, {0x421fe000}, {0x42200000}, {0x42202000}, {0x42204000}, {0x42206000}, {0x42208000}, {0x4220a000}, {0x4220c000}, {0x4220e000}, {0x42210000}, {0x42212000}, {0x42214000}, {0x42216000}, {0x42218000}, {0x4221a000}, {0x4221c000}, {0x4221e000}, {0x42220000}, {0x42222000}, {0x42224000}, {0x42226000}, {0x42228000}, {0x4222a000}, {0x4222c000}, {0x4222e000}, {0x42230000}, {0x42232000}, {0x42234000}, {0x42236000}, {0x42238000}, {0x4223a000}, {0x4223c000}, {0x4223e000}, {0x42240000}, {0x42242000}, {0x42244000}, {0x42246000}, {0x42248000}, {0x4224a000}, {0x4224c000}, {0x4224e000}, {0x42250000}, {0x42252000}, {0x42254000}, {0x42256000}, {0x42258000}, {0x4225a000}, {0x4225c000}, {0x4225e000}, {0x42260000}, {0x42262000}, {0x42264000}, {0x42266000}, {0x42268000}, {0x4226a000}, {0x4226c000}, {0x4226e000}, {0x42270000}, {0x42272000}, {0x42274000}, {0x42276000}, {0x42278000}, {0x4227a000}, {0x4227c000}, {0x4227e000}, {0x42280000}, {0x42282000}, {0x42284000}, {0x42286000}, {0x42288000}, {0x4228a000}, {0x4228c000}, {0x4228e000}, {0x42290000}, {0x42292000}, {0x42294000}, {0x42296000}, {0x42298000}, {0x4229a000}, {0x4229c000}, {0x4229e000}, {0x422a0000}, {0x422a2000}, {0x422a4000}, {0x422a6000}, {0x422a8000}, {0x422aa000}, {0x422ac000}, {0x422ae000}, {0x422b0000}, {0x422b2000}, {0x422b4000}, {0x422b6000}, {0x422b8000}, {0x422ba000}, {0x422bc000}, {0x422be000}, {0x422c0000}, {0x422c2000}, {0x422c4000}, {0x422c6000}, {0x422c8000}, {0x422ca000}, {0x422cc000}, {0x422ce000}, {0x422d0000}, {0x422d2000}, {0x422d4000}, {0x422d6000}, {0x422d8000}, {0x422da000}, {0x422dc000}, {0x422de000}, {0x422e0000}, {0x422e2000}, {0x422e4000}, {0x422e6000}, {0x422e8000}, {0x422ea000}, {0x422ec000}, {0x422ee000}, {0x422f0000}, {0x422f2000}, {0x422f4000}, {0x422f6000}, {0x422f8000}, {0x422fa000}, {0x422fc000}, {0x422fe000}, {0x42300000}, {0x42302000}, {0x42304000}, {0x42306000}, {0x42308000}, {0x4230a000}, {0x4230c000}, {0x4230e000}, {0x42310000}, {0x42312000}, {0x42314000}, {0x42316000}, {0x42318000}, {0x4231a000}, {0x4231c000}, {0x4231e000}, {0x42320000}, {0x42322000}, {0x42324000}, {0x42326000}, {0x42328000}, {0x4232a000}, {0x4232c000}, {0x4232e000}, {0x42330000}, {0x42332000}, {0x42334000}, {0x42336000}, {0x42338000}, {0x4233a000}, {0x4233c000}, {0x4233e000}, {0x42340000}, {0x42342000}, {0x42344000}, {0x42346000}, {0x42348000}, {0x4234a000}, {0x4234c000}, {0x4234e000}, {0x42350000}, {0x42352000}, {0x42354000}, {0x42356000}, {0x42358000}, {0x4235a000}, {0x4235c000}, {0x4235e000}, {0x42360000}, {0x42362000}, {0x42364000}, {0x42366000}, {0x42368000}, {0x4236a000}, {0x4236c000}, {0x4236e000}, {0x42370000}, {0x42372000}, {0x42374000}, {0x42376000}, {0x42378000}, {0x4237a000}, {0x4237c000}, {0x4237e000}, {0x42380000}, {0x42382000}, {0x42384000}, {0x42386000}, {0x42388000}, {0x4238a000}, {0x4238c000}, {0x4238e000}, {0x42390000}, {0x42392000}, {0x42394000}, {0x42396000}, {0x42398000}, {0x4239a000}, {0x4239c000}, {0x4239e000}, {0x423a0000}, {0x423a2000}, {0x423a4000}, {0x423a6000}, {0x423a8000}, {0x423aa000}, {0x423ac000}, {0x423ae000}, {0x423b0000}, {0x423b2000}, {0x423b4000}, {0x423b6000}, {0x423b8000}, {0x423ba000}, {0x423bc000}, {0x423be000}, {0x423c0000}, {0x423c2000}, {0x423c4000}, {0x423c6000}, {0x423c8000}, {0x423ca000}, {0x423cc000}, {0x423ce000}, {0x423d0000}, {0x423d2000}, {0x423d4000}, {0x423d6000}, {0x423d8000}, {0x423da000}, {0x423dc000}, {0x423de000}, {0x423e0000}, {0x423e2000}, {0x423e4000}, {0x423e6000}, {0x423e8000}, {0x423ea000}, {0x423ec000}, {0x423ee000}, {0x423f0000}, {0x423f2000}, {0x423f4000}, {0x423f6000}, {0x423f8000}, {0x423fa000}, {0x423fc000}, {0x423fe000}, {0x42400000}, {0x42402000}, {0x42404000}, {0x42406000}, {0x42408000}, {0x4240a000}, {0x4240c000}, {0x4240e000}, {0x42410000}, {0x42412000}, {0x42414000}, {0x42416000}, {0x42418000}, {0x4241a000}, {0x4241c000}, {0x4241e000}, {0x42420000}, {0x42422000}, {0x42424000}, {0x42426000}, {0x42428000}, {0x4242a000}, {0x4242c000}, {0x4242e000}, {0x42430000}, {0x42432000}, {0x42434000}, {0x42436000}, {0x42438000}, {0x4243a000}, {0x4243c000}, {0x4243e000}, {0x42440000}, {0x42442000}, {0x42444000}, {0x42446000}, {0x42448000}, {0x4244a000}, {0x4244c000}, {0x4244e000}, {0x42450000}, {0x42452000}, {0x42454000}, {0x42456000}, {0x42458000}, {0x4245a000}, {0x4245c000}, {0x4245e000}, {0x42460000}, {0x42462000}, {0x42464000}, {0x42466000}, {0x42468000}, {0x4246a000}, {0x4246c000}, {0x4246e000}, {0x42470000}, {0x42472000}, {0x42474000}, {0x42476000}, {0x42478000}, {0x4247a000}, {0x4247c000}, {0x4247e000}, {0x42480000}, {0x42482000}, {0x42484000}, {0x42486000}, {0x42488000}, {0x4248a000}, {0x4248c000}, {0x4248e000}, {0x42490000}, {0x42492000}, {0x42494000}, {0x42496000}, {0x42498000}, {0x4249a000}, {0x4249c000}, {0x4249e000}, {0x424a0000}, {0x424a2000}, {0x424a4000}, {0x424a6000}, {0x424a8000}, {0x424aa000}, {0x424ac000}, {0x424ae000}, {0x424b0000}, {0x424b2000}, {0x424b4000}, {0x424b6000}, {0x424b8000}, {0x424ba000}, {0x424bc000}, {0x424be000}, {0x424c0000}, {0x424c2000}, {0x424c4000}, {0x424c6000}, {0x424c8000}, {0x424ca000}, {0x424cc000}, {0x424ce000}, {0x424d0000}, {0x424d2000}, {0x424d4000}, {0x424d6000}, {0x424d8000}, {0x424da000}, {0x424dc000}, {0x424de000}, {0x424e0000}, {0x424e2000}, {0x424e4000}, {0x424e6000}, {0x424e8000}, {0x424ea000}, {0x424ec000}, {0x424ee000}, {0x424f0000}, {0x424f2000}, {0x424f4000}, {0x424f6000}, {0x424f8000}, {0x424fa000}, {0x424fc000}, {0x424fe000}, {0x42500000}, {0x42502000}, {0x42504000}, {0x42506000}, {0x42508000}, {0x4250a000}, {0x4250c000}, {0x4250e000}, {0x42510000}, {0x42512000}, {0x42514000}, {0x42516000}, {0x42518000}, {0x4251a000}, {0x4251c000}, {0x4251e000}, {0x42520000}, {0x42522000}, {0x42524000}, {0x42526000}, {0x42528000}, {0x4252a000}, {0x4252c000}, {0x4252e000}, {0x42530000}, {0x42532000}, {0x42534000}, {0x42536000}, {0x42538000}, {0x4253a000}, {0x4253c000}, {0x4253e000}, {0x42540000}, {0x42542000}, {0x42544000}, {0x42546000}, {0x42548000}, {0x4254a000}, {0x4254c000}, {0x4254e000}, {0x42550000}, {0x42552000}, {0x42554000}, {0x42556000}, {0x42558000}, {0x4255a000}, {0x4255c000}, {0x4255e000}, {0x42560000}, {0x42562000}, {0x42564000}, {0x42566000}, {0x42568000}, {0x4256a000}, {0x4256c000}, {0x4256e000}, {0x42570000}, {0x42572000}, {0x42574000}, {0x42576000}, {0x42578000}, {0x4257a000}, {0x4257c000}, {0x4257e000}, {0x42580000}, {0x42582000}, {0x42584000}, {0x42586000}, {0x42588000}, {0x4258a000}, {0x4258c000}, {0x4258e000}, {0x42590000}, {0x42592000}, {0x42594000}, {0x42596000}, {0x42598000}, {0x4259a000}, {0x4259c000}, {0x4259e000}, {0x425a0000}, {0x425a2000}, {0x425a4000}, {0x425a6000}, {0x425a8000}, {0x425aa000}, {0x425ac000}, {0x425ae000}, {0x425b0000}, {0x425b2000}, {0x425b4000}, {0x425b6000}, {0x425b8000}, {0x425ba000}, {0x425bc000}, {0x425be000}, {0x425c0000}, {0x425c2000}, {0x425c4000}, {0x425c6000}, {0x425c8000}, {0x425ca000}, {0x425cc000}, {0x425ce000}, {0x425d0000}, {0x425d2000}, {0x425d4000}, {0x425d6000}, {0x425d8000}, {0x425da000}, {0x425dc000}, {0x425de000}, {0x425e0000}, {0x425e2000}, {0x425e4000}, {0x425e6000}, {0x425e8000}, {0x425ea000}, {0x425ec000}, {0x425ee000}, {0x425f0000}, {0x425f2000}, {0x425f4000}, {0x425f6000}, {0x425f8000}, {0x425fa000}, {0x425fc000}, {0x425fe000}, {0x42600000}, {0x42602000}, {0x42604000}, {0x42606000}, {0x42608000}, {0x4260a000}, {0x4260c000}, {0x4260e000}, {0x42610000}, {0x42612000}, {0x42614000}, {0x42616000}, {0x42618000}, {0x4261a000}, {0x4261c000}, {0x4261e000}, {0x42620000}, {0x42622000}, {0x42624000}, {0x42626000}, {0x42628000}, {0x4262a000}, {0x4262c000}, {0x4262e000}, {0x42630000}, {0x42632000}, {0x42634000}, {0x42636000}, {0x42638000}, {0x4263a000}, {0x4263c000}, {0x4263e000}, {0x42640000}, {0x42642000}, {0x42644000}, {0x42646000}, {0x42648000}, {0x4264a000}, {0x4264c000}, {0x4264e000}, {0x42650000}, {0x42652000}, {0x42654000}, {0x42656000}, {0x42658000}, {0x4265a000}, {0x4265c000}, {0x4265e000}, {0x42660000}, {0x42662000}, {0x42664000}, {0x42666000}, {0x42668000}, {0x4266a000}, {0x4266c000}, {0x4266e000}, {0x42670000}, {0x42672000}, {0x42674000}, {0x42676000}, {0x42678000}, {0x4267a000}, {0x4267c000}, {0x4267e000}, {0x42680000}, {0x42682000}, {0x42684000}, {0x42686000}, {0x42688000}, {0x4268a000}, {0x4268c000}, {0x4268e000}, {0x42690000}, {0x42692000}, {0x42694000}, {0x42696000}, {0x42698000}, {0x4269a000}, {0x4269c000}, {0x4269e000}, {0x426a0000}, {0x426a2000}, {0x426a4000}, {0x426a6000}, {0x426a8000}, {0x426aa000}, {0x426ac000}, {0x426ae000}, {0x426b0000}, {0x426b2000}, {0x426b4000}, {0x426b6000}, {0x426b8000}, {0x426ba000}, {0x426bc000}, {0x426be000}, {0x426c0000}, {0x426c2000}, {0x426c4000}, {0x426c6000}, {0x426c8000}, {0x426ca000}, {0x426cc000}, {0x426ce000}, {0x426d0000}, {0x426d2000}, {0x426d4000}, {0x426d6000}, {0x426d8000}, {0x426da000}, {0x426dc000}, {0x426de000}, {0x426e0000}, {0x426e2000}, {0x426e4000}, {0x426e6000}, {0x426e8000}, {0x426ea000}, {0x426ec000}, {0x426ee000}, {0x426f0000}, {0x426f2000}, {0x426f4000}, {0x426f6000}, {0x426f8000}, {0x426fa000}, {0x426fc000}, {0x426fe000}, {0x42700000}, {0x42702000}, {0x42704000}, {0x42706000}, {0x42708000}, {0x4270a000}, {0x4270c000}, {0x4270e000}, {0x42710000}, {0x42712000}, {0x42714000}, {0x42716000}, {0x42718000}, {0x4271a000}, {0x4271c000}, {0x4271e000}, {0x42720000}, {0x42722000}, {0x42724000}, {0x42726000}, {0x42728000}, {0x4272a000}, {0x4272c000}, {0x4272e000}, {0x42730000}, {0x42732000}, {0x42734000}, {0x42736000}, {0x42738000}, {0x4273a000}, {0x4273c000}, {0x4273e000}, {0x42740000}, {0x42742000}, {0x42744000}, {0x42746000}, {0x42748000}, {0x4274a000}, {0x4274c000}, {0x4274e000}, {0x42750000}, {0x42752000}, {0x42754000}, {0x42756000}, {0x42758000}, {0x4275a000}, {0x4275c000}, {0x4275e000}, {0x42760000}, {0x42762000}, {0x42764000}, {0x42766000}, {0x42768000}, {0x4276a000}, {0x4276c000}, {0x4276e000}, {0x42770000}, {0x42772000}, {0x42774000}, {0x42776000}, {0x42778000}, {0x4277a000}, {0x4277c000}, {0x4277e000}, {0x42780000}, {0x42782000}, {0x42784000}, {0x42786000}, {0x42788000}, {0x4278a000}, {0x4278c000}, {0x4278e000}, {0x42790000}, {0x42792000}, {0x42794000}, {0x42796000}, {0x42798000}, {0x4279a000}, {0x4279c000}, {0x4279e000}, {0x427a0000}, {0x427a2000}, {0x427a4000}, {0x427a6000}, {0x427a8000}, {0x427aa000}, {0x427ac000}, {0x427ae000}, {0x427b0000}, {0x427b2000}, {0x427b4000}, {0x427b6000}, {0x427b8000}, {0x427ba000}, {0x427bc000}, {0x427be000}, {0x427c0000}, {0x427c2000}, {0x427c4000}, {0x427c6000}, {0x427c8000}, {0x427ca000}, {0x427cc000}, {0x427ce000}, {0x427d0000}, {0x427d2000}, {0x427d4000}, {0x427d6000}, {0x427d8000}, {0x427da000}, {0x427dc000}, {0x427de000}, {0x427e0000}, {0x427e2000}, {0x427e4000}, {0x427e6000}, {0x427e8000}, {0x427ea000}, {0x427ec000}, {0x427ee000}, {0x427f0000}, {0x427f2000}, {0x427f4000}, {0x427f6000}, {0x427f8000}, {0x427fa000}, {0x427fc000}, {0x427fe000}, {0x42800000}, {0x42802000}, {0x42804000}, {0x42806000}, {0x42808000}, {0x4280a000}, {0x4280c000}, {0x4280e000}, {0x42810000}, {0x42812000}, {0x42814000}, {0x42816000}, {0x42818000}, {0x4281a000}, {0x4281c000}, {0x4281e000}, {0x42820000}, {0x42822000}, {0x42824000}, {0x42826000}, {0x42828000}, {0x4282a000}, {0x4282c000}, {0x4282e000}, {0x42830000}, {0x42832000}, {0x42834000}, {0x42836000}, {0x42838000}, {0x4283a000}, {0x4283c000}, {0x4283e000}, {0x42840000}, {0x42842000}, {0x42844000}, {0x42846000}, {0x42848000}, {0x4284a000}, {0x4284c000}, {0x4284e000}, {0x42850000}, {0x42852000}, {0x42854000}, {0x42856000}, {0x42858000}, {0x4285a000}, {0x4285c000}, {0x4285e000}, {0x42860000}, {0x42862000}, {0x42864000}, {0x42866000}, {0x42868000}, {0x4286a000}, {0x4286c000}, {0x4286e000}, {0x42870000}, {0x42872000}, {0x42874000}, {0x42876000}, {0x42878000}, {0x4287a000}, {0x4287c000}, {0x4287e000}, {0x42880000}, {0x42882000}, {0x42884000}, {0x42886000}, {0x42888000}, {0x4288a000}, {0x4288c000}, {0x4288e000}, {0x42890000}, {0x42892000}, {0x42894000}, {0x42896000}, {0x42898000}, {0x4289a000}, {0x4289c000}, {0x4289e000}, {0x428a0000}, {0x428a2000}, {0x428a4000}, {0x428a6000}, {0x428a8000}, {0x428aa000}, {0x428ac000}, {0x428ae000}, {0x428b0000}, {0x428b2000}, {0x428b4000}, {0x428b6000}, {0x428b8000}, {0x428ba000}, {0x428bc000}, {0x428be000}, {0x428c0000}, {0x428c2000}, {0x428c4000}, {0x428c6000}, {0x428c8000}, {0x428ca000}, {0x428cc000}, {0x428ce000}, {0x428d0000}, {0x428d2000}, {0x428d4000}, {0x428d6000}, {0x428d8000}, {0x428da000}, {0x428dc000}, {0x428de000}, {0x428e0000}, {0x428e2000}, {0x428e4000}, {0x428e6000}, {0x428e8000}, {0x428ea000}, {0x428ec000}, {0x428ee000}, {0x428f0000}, {0x428f2000}, {0x428f4000}, {0x428f6000}, {0x428f8000}, {0x428fa000}, {0x428fc000}, {0x428fe000}, {0x42900000}, {0x42902000}, {0x42904000}, {0x42906000}, {0x42908000}, {0x4290a000}, {0x4290c000}, {0x4290e000}, {0x42910000}, {0x42912000}, {0x42914000}, {0x42916000}, {0x42918000}, {0x4291a000}, {0x4291c000}, {0x4291e000}, {0x42920000}, {0x42922000}, {0x42924000}, {0x42926000}, {0x42928000}, {0x4292a000}, {0x4292c000}, {0x4292e000}, {0x42930000}, {0x42932000}, {0x42934000}, {0x42936000}, {0x42938000}, {0x4293a000}, {0x4293c000}, {0x4293e000}, {0x42940000}, {0x42942000}, {0x42944000}, {0x42946000}, {0x42948000}, {0x4294a000}, {0x4294c000}, {0x4294e000}, {0x42950000}, {0x42952000}, {0x42954000}, {0x42956000}, {0x42958000}, {0x4295a000}, {0x4295c000}, {0x4295e000}, {0x42960000}, {0x42962000}, {0x42964000}, {0x42966000}, {0x42968000}, {0x4296a000}, {0x4296c000}, {0x4296e000}, {0x42970000}, {0x42972000}, {0x42974000}, {0x42976000}, {0x42978000}, {0x4297a000}, {0x4297c000}, {0x4297e000}, {0x42980000}, {0x42982000}, {0x42984000}, {0x42986000}, {0x42988000}, {0x4298a000}, {0x4298c000}, {0x4298e000}, {0x42990000}, {0x42992000}, {0x42994000}, {0x42996000}, {0x42998000}, {0x4299a000}, {0x4299c000}, {0x4299e000}, {0x429a0000}, {0x429a2000}, {0x429a4000}, {0x429a6000}, {0x429a8000}, {0x429aa000}, {0x429ac000}, {0x429ae000}, {0x429b0000}, {0x429b2000}, {0x429b4000}, {0x429b6000}, {0x429b8000}, {0x429ba000}, {0x429bc000}, {0x429be000}, {0x429c0000}, {0x429c2000}, {0x429c4000}, {0x429c6000}, {0x429c8000}, {0x429ca000}, {0x429cc000}, {0x429ce000}, {0x429d0000}, {0x429d2000}, {0x429d4000}, {0x429d6000}, {0x429d8000}, {0x429da000}, {0x429dc000}, {0x429de000}, {0x429e0000}, {0x429e2000}, {0x429e4000}, {0x429e6000}, {0x429e8000}, {0x429ea000}, {0x429ec000}, {0x429ee000}, {0x429f0000}, {0x429f2000}, {0x429f4000}, {0x429f6000}, {0x429f8000}, {0x429fa000}, {0x429fc000}, {0x429fe000}, {0x42a00000}, {0x42a02000}, {0x42a04000}, {0x42a06000}, {0x42a08000}, {0x42a0a000}, {0x42a0c000}, {0x42a0e000}, {0x42a10000}, {0x42a12000}, {0x42a14000}, {0x42a16000}, {0x42a18000}, {0x42a1a000}, {0x42a1c000}, {0x42a1e000}, {0x42a20000}, {0x42a22000}, {0x42a24000}, {0x42a26000}, {0x42a28000}, {0x42a2a000}, {0x42a2c000}, {0x42a2e000}, {0x42a30000}, {0x42a32000}, {0x42a34000}, {0x42a36000}, {0x42a38000}, {0x42a3a000}, {0x42a3c000}, {0x42a3e000}, {0x42a40000}, {0x42a42000}, {0x42a44000}, {0x42a46000}, {0x42a48000}, {0x42a4a000}, {0x42a4c000}, {0x42a4e000}, {0x42a50000}, {0x42a52000}, {0x42a54000}, {0x42a56000}, {0x42a58000}, {0x42a5a000}, {0x42a5c000}, {0x42a5e000}, {0x42a60000}, {0x42a62000}, {0x42a64000}, {0x42a66000}, {0x42a68000}, {0x42a6a000}, {0x42a6c000}, {0x42a6e000}, {0x42a70000}, {0x42a72000}, {0x42a74000}, {0x42a76000}, {0x42a78000}, {0x42a7a000}, {0x42a7c000}, {0x42a7e000}, {0x42a80000}, {0x42a82000}, {0x42a84000}, {0x42a86000}, {0x42a88000}, {0x42a8a000}, {0x42a8c000}, {0x42a8e000}, {0x42a90000}, {0x42a92000}, {0x42a94000}, {0x42a96000}, {0x42a98000}, {0x42a9a000}, {0x42a9c000}, {0x42a9e000}, {0x42aa0000}, {0x42aa2000}, {0x42aa4000}, {0x42aa6000}, {0x42aa8000}, {0x42aaa000}, {0x42aac000}, {0x42aae000}, {0x42ab0000}, {0x42ab2000}, {0x42ab4000}, {0x42ab6000}, {0x42ab8000}, {0x42aba000}, {0x42abc000}, {0x42abe000}, {0x42ac0000}, {0x42ac2000}, {0x42ac4000}, {0x42ac6000}, {0x42ac8000}, {0x42aca000}, {0x42acc000}, {0x42ace000}, {0x42ad0000}, {0x42ad2000}, {0x42ad4000}, {0x42ad6000}, {0x42ad8000}, {0x42ada000}, {0x42adc000}, {0x42ade000}, {0x42ae0000}, {0x42ae2000}, {0x42ae4000}, {0x42ae6000}, {0x42ae8000}, {0x42aea000}, {0x42aec000}, {0x42aee000}, {0x42af0000}, {0x42af2000}, {0x42af4000}, {0x42af6000}, {0x42af8000}, {0x42afa000}, {0x42afc000}, {0x42afe000}, {0x42b00000}, {0x42b02000}, {0x42b04000}, {0x42b06000}, {0x42b08000}, {0x42b0a000}, {0x42b0c000}, {0x42b0e000}, {0x42b10000}, {0x42b12000}, {0x42b14000}, {0x42b16000}, {0x42b18000}, {0x42b1a000}, {0x42b1c000}, {0x42b1e000}, {0x42b20000}, {0x42b22000}, {0x42b24000}, {0x42b26000}, {0x42b28000}, {0x42b2a000}, {0x42b2c000}, {0x42b2e000}, {0x42b30000}, {0x42b32000}, {0x42b34000}, {0x42b36000}, {0x42b38000}, {0x42b3a000}, {0x42b3c000}, {0x42b3e000}, {0x42b40000}, {0x42b42000}, {0x42b44000}, {0x42b46000}, {0x42b48000}, {0x42b4a000}, {0x42b4c000}, {0x42b4e000}, {0x42b50000}, {0x42b52000}, {0x42b54000}, {0x42b56000}, {0x42b58000}, {0x42b5a000}, {0x42b5c000}, {0x42b5e000}, {0x42b60000}, {0x42b62000}, {0x42b64000}, {0x42b66000}, {0x42b68000}, {0x42b6a000}, {0x42b6c000}, {0x42b6e000}, {0x42b70000}, {0x42b72000}, {0x42b74000}, {0x42b76000}, {0x42b78000}, {0x42b7a000}, {0x42b7c000}, {0x42b7e000}, {0x42b80000}, {0x42b82000}, {0x42b84000}, {0x42b86000}, {0x42b88000}, {0x42b8a000}, {0x42b8c000}, {0x42b8e000}, {0x42b90000}, {0x42b92000}, {0x42b94000}, {0x42b96000}, {0x42b98000}, {0x42b9a000}, {0x42b9c000}, {0x42b9e000}, {0x42ba0000}, {0x42ba2000}, {0x42ba4000}, {0x42ba6000}, {0x42ba8000}, {0x42baa000}, {0x42bac000}, {0x42bae000}, {0x42bb0000}, {0x42bb2000}, {0x42bb4000}, {0x42bb6000}, {0x42bb8000}, {0x42bba000}, {0x42bbc000}, {0x42bbe000}, {0x42bc0000}, {0x42bc2000}, {0x42bc4000}, {0x42bc6000}, {0x42bc8000}, {0x42bca000}, {0x42bcc000}, {0x42bce000}, {0x42bd0000}, {0x42bd2000}, {0x42bd4000}, {0x42bd6000}, {0x42bd8000}, {0x42bda000}, {0x42bdc000}, {0x42bde000}, {0x42be0000}, {0x42be2000}, {0x42be4000}, {0x42be6000}, {0x42be8000}, {0x42bea000}, {0x42bec000}, {0x42bee000}, {0x42bf0000}, {0x42bf2000}, {0x42bf4000}, {0x42bf6000}, {0x42bf8000}, {0x42bfa000}, {0x42bfc000}, {0x42bfe000}, {0x42c00000}, {0x42c02000}, {0x42c04000}, {0x42c06000}, {0x42c08000}, {0x42c0a000}, {0x42c0c000}, {0x42c0e000}, {0x42c10000}, {0x42c12000}, {0x42c14000}, {0x42c16000}, {0x42c18000}, {0x42c1a000}, {0x42c1c000}, {0x42c1e000}, {0x42c20000}, {0x42c22000}, {0x42c24000}, {0x42c26000}, {0x42c28000}, {0x42c2a000}, {0x42c2c000}, {0x42c2e000}, {0x42c30000}, {0x42c32000}, {0x42c34000}, {0x42c36000}, {0x42c38000}, {0x42c3a000}, {0x42c3c000}, {0x42c3e000}, {0x42c40000}, {0x42c42000}, {0x42c44000}, {0x42c46000}, {0x42c48000}, {0x42c4a000}, {0x42c4c000}, {0x42c4e000}, {0x42c50000}, {0x42c52000}, {0x42c54000}, {0x42c56000}, {0x42c58000}, {0x42c5a000}, {0x42c5c000}, {0x42c5e000}, {0x42c60000}, {0x42c62000}, {0x42c64000}, {0x42c66000}, {0x42c68000}, {0x42c6a000}, {0x42c6c000}, {0x42c6e000}, {0x42c70000}, {0x42c72000}, {0x42c74000}, {0x42c76000}, {0x42c78000}, {0x42c7a000}, {0x42c7c000}, {0x42c7e000}, {0x42c80000}, {0x42c82000}, {0x42c84000}, {0x42c86000}, {0x42c88000}, {0x42c8a000}, {0x42c8c000}, {0x42c8e000}, {0x42c90000}, {0x42c92000}, {0x42c94000}, {0x42c96000}, {0x42c98000}, {0x42c9a000}, {0x42c9c000}, {0x42c9e000}, {0x42ca0000}, {0x42ca2000}, {0x42ca4000}, {0x42ca6000}, {0x42ca8000}, {0x42caa000}, {0x42cac000}, {0x42cae000}, {0x42cb0000}, {0x42cb2000}, {0x42cb4000}, {0x42cb6000}, {0x42cb8000}, {0x42cba000}, {0x42cbc000}, {0x42cbe000}, {0x42cc0000}, {0x42cc2000}, {0x42cc4000}, {0x42cc6000}, {0x42cc8000}, {0x42cca000}, {0x42ccc000}, {0x42cce000}, {0x42cd0000}, {0x42cd2000}, {0x42cd4000}, {0x42cd6000}, {0x42cd8000}, {0x42cda000}, {0x42cdc000}, {0x42cde000}, {0x42ce0000}, {0x42ce2000}, {0x42ce4000}, {0x42ce6000}, {0x42ce8000}, {0x42cea000}, {0x42cec000}, {0x42cee000}, {0x42cf0000}, {0x42cf2000}, {0x42cf4000}, {0x42cf6000}, {0x42cf8000}, {0x42cfa000}, {0x42cfc000}, {0x42cfe000}, {0x42d00000}, {0x42d02000}, {0x42d04000}, {0x42d06000}, {0x42d08000}, {0x42d0a000}, {0x42d0c000}, {0x42d0e000}, {0x42d10000}, {0x42d12000}, {0x42d14000}, {0x42d16000}, {0x42d18000}, {0x42d1a000}, {0x42d1c000}, {0x42d1e000}, {0x42d20000}, {0x42d22000}, {0x42d24000}, {0x42d26000}, {0x42d28000}, {0x42d2a000}, {0x42d2c000}, {0x42d2e000}, {0x42d30000}, {0x42d32000}, {0x42d34000}, {0x42d36000}, {0x42d38000}, {0x42d3a000}, {0x42d3c000}, {0x42d3e000}, {0x42d40000}, {0x42d42000}, {0x42d44000}, {0x42d46000}, {0x42d48000}, {0x42d4a000}, {0x42d4c000}, {0x42d4e000}, {0x42d50000}, {0x42d52000}, {0x42d54000}, {0x42d56000}, {0x42d58000}, {0x42d5a000}, {0x42d5c000}, {0x42d5e000}, {0x42d60000}, {0x42d62000}, {0x42d64000}, {0x42d66000}, {0x42d68000}, {0x42d6a000}, {0x42d6c000}, {0x42d6e000}, {0x42d70000}, {0x42d72000}, {0x42d74000}, {0x42d76000}, {0x42d78000}, {0x42d7a000}, {0x42d7c000}, {0x42d7e000}, {0x42d80000}, {0x42d82000}, {0x42d84000}, {0x42d86000}, {0x42d88000}, {0x42d8a000}, {0x42d8c000}, {0x42d8e000}, {0x42d90000}, {0x42d92000}, {0x42d94000}, {0x42d96000}, {0x42d98000}, {0x42d9a000}, {0x42d9c000}, {0x42d9e000}, {0x42da0000}, {0x42da2000}, {0x42da4000}, {0x42da6000}, {0x42da8000}, {0x42daa000}, {0x42dac000}, {0x42dae000}, {0x42db0000}, {0x42db2000}, {0x42db4000}, {0x42db6000}, {0x42db8000}, {0x42dba000}, {0x42dbc000}, {0x42dbe000}, {0x42dc0000}, {0x42dc2000}, {0x42dc4000}, {0x42dc6000}, {0x42dc8000}, {0x42dca000}, {0x42dcc000}, {0x42dce000}, {0x42dd0000}, {0x42dd2000}, {0x42dd4000}, {0x42dd6000}, {0x42dd8000}, {0x42dda000}, {0x42ddc000}, {0x42dde000}, {0x42de0000}, {0x42de2000}, {0x42de4000}, {0x42de6000}, {0x42de8000}, {0x42dea000}, {0x42dec000}, {0x42dee000}, {0x42df0000}, {0x42df2000}, {0x42df4000}, {0x42df6000}, {0x42df8000}, {0x42dfa000}, {0x42dfc000}, {0x42dfe000}, {0x42e00000}, {0x42e02000}, {0x42e04000}, {0x42e06000}, {0x42e08000}, {0x42e0a000}, {0x42e0c000}, {0x42e0e000}, {0x42e10000}, {0x42e12000}, {0x42e14000}, {0x42e16000}, {0x42e18000}, {0x42e1a000}, {0x42e1c000}, {0x42e1e000}, {0x42e20000}, {0x42e22000}, {0x42e24000}, {0x42e26000}, {0x42e28000}, {0x42e2a000}, {0x42e2c000}, {0x42e2e000}, {0x42e30000}, {0x42e32000}, {0x42e34000}, {0x42e36000}, {0x42e38000}, {0x42e3a000}, {0x42e3c000}, {0x42e3e000}, {0x42e40000}, {0x42e42000}, {0x42e44000}, {0x42e46000}, {0x42e48000}, {0x42e4a000}, {0x42e4c000}, {0x42e4e000}, {0x42e50000}, {0x42e52000}, {0x42e54000}, {0x42e56000}, {0x42e58000}, {0x42e5a000}, {0x42e5c000}, {0x42e5e000}, {0x42e60000}, {0x42e62000}, {0x42e64000}, {0x42e66000}, {0x42e68000}, {0x42e6a000}, {0x42e6c000}, {0x42e6e000}, {0x42e70000}, {0x42e72000}, {0x42e74000}, {0x42e76000}, {0x42e78000}, {0x42e7a000}, {0x42e7c000}, {0x42e7e000}, {0x42e80000}, {0x42e82000}, {0x42e84000}, {0x42e86000}, {0x42e88000}, {0x42e8a000}, {0x42e8c000}, {0x42e8e000}, {0x42e90000}, {0x42e92000}, {0x42e94000}, {0x42e96000}, {0x42e98000}, {0x42e9a000}, {0x42e9c000}, {0x42e9e000}, {0x42ea0000}, {0x42ea2000}, {0x42ea4000}, {0x42ea6000}, {0x42ea8000}, {0x42eaa000}, {0x42eac000}, {0x42eae000}, {0x42eb0000}, {0x42eb2000}, {0x42eb4000}, {0x42eb6000}, {0x42eb8000}, {0x42eba000}, {0x42ebc000}, {0x42ebe000}, {0x42ec0000}, {0x42ec2000}, {0x42ec4000}, {0x42ec6000}, {0x42ec8000}, {0x42eca000}, {0x42ecc000}, {0x42ece000}, {0x42ed0000}, {0x42ed2000}, {0x42ed4000}, {0x42ed6000}, {0x42ed8000}, {0x42eda000}, {0x42edc000}, {0x42ede000}, {0x42ee0000}, {0x42ee2000}, {0x42ee4000}, {0x42ee6000}, {0x42ee8000}, {0x42eea000}, {0x42eec000}, {0x42eee000}, {0x42ef0000}, {0x42ef2000}, {0x42ef4000}, {0x42ef6000}, {0x42ef8000}, {0x42efa000}, {0x42efc000}, {0x42efe000}, {0x42f00000}, {0x42f02000}, {0x42f04000}, {0x42f06000}, {0x42f08000}, {0x42f0a000}, {0x42f0c000}, {0x42f0e000}, {0x42f10000}, {0x42f12000}, {0x42f14000}, {0x42f16000}, {0x42f18000}, {0x42f1a000}, {0x42f1c000}, {0x42f1e000}, {0x42f20000}, {0x42f22000}, {0x42f24000}, {0x42f26000}, {0x42f28000}, {0x42f2a000}, {0x42f2c000}, {0x42f2e000}, {0x42f30000}, {0x42f32000}, {0x42f34000}, {0x42f36000}, {0x42f38000}, {0x42f3a000}, {0x42f3c000}, {0x42f3e000}, {0x42f40000}, {0x42f42000}, {0x42f44000}, {0x42f46000}, {0x42f48000}, {0x42f4a000}, {0x42f4c000}, {0x42f4e000}, {0x42f50000}, {0x42f52000}, {0x42f54000}, {0x42f56000}, {0x42f58000}, {0x42f5a000}, {0x42f5c000}, {0x42f5e000}, {0x42f60000}, {0x42f62000}, {0x42f64000}, {0x42f66000}, {0x42f68000}, {0x42f6a000}, {0x42f6c000}, {0x42f6e000}, {0x42f70000}, {0x42f72000}, {0x42f74000}, {0x42f76000}, {0x42f78000}, {0x42f7a000}, {0x42f7c000}, {0x42f7e000}, {0x42f80000}, {0x42f82000}, {0x42f84000}, {0x42f86000}, {0x42f88000}, {0x42f8a000}, {0x42f8c000}, {0x42f8e000}, {0x42f90000}, {0x42f92000}, {0x42f94000}, {0x42f96000}, {0x42f98000}, {0x42f9a000}, {0x42f9c000}, {0x42f9e000}, {0x42fa0000}, {0x42fa2000}, {0x42fa4000}, {0x42fa6000}, {0x42fa8000}, {0x42faa000}, {0x42fac000}, {0x42fae000}, {0x42fb0000}, {0x42fb2000}, {0x42fb4000}, {0x42fb6000}, {0x42fb8000}, {0x42fba000}, {0x42fbc000}, {0x42fbe000}, {0x42fc0000}, {0x42fc2000}, {0x42fc4000}, {0x42fc6000}, {0x42fc8000}, {0x42fca000}, {0x42fcc000}, {0x42fce000}, {0x42fd0000}, {0x42fd2000}, {0x42fd4000}, {0x42fd6000}, {0x42fd8000}, {0x42fda000}, {0x42fdc000}, {0x42fde000}, {0x42fe0000}, {0x42fe2000}, {0x42fe4000}, {0x42fe6000}, {0x42fe8000}, {0x42fea000}, {0x42fec000}, {0x42fee000}, {0x42ff0000}, {0x42ff2000}, {0x42ff4000}, {0x42ff6000}, {0x42ff8000}, {0x42ffa000}, {0x42ffc000}, {0x42ffe000}, {0x43000000}, {0x43002000}, {0x43004000}, {0x43006000}, {0x43008000}, {0x4300a000}, {0x4300c000}, {0x4300e000}, {0x43010000}, {0x43012000}, {0x43014000}, {0x43016000}, {0x43018000}, {0x4301a000}, {0x4301c000}, {0x4301e000}, {0x43020000}, {0x43022000}, {0x43024000}, {0x43026000}, {0x43028000}, {0x4302a000}, {0x4302c000}, {0x4302e000}, {0x43030000}, {0x43032000}, {0x43034000}, {0x43036000}, {0x43038000}, {0x4303a000}, {0x4303c000}, {0x4303e000}, {0x43040000}, {0x43042000}, {0x43044000}, {0x43046000}, {0x43048000}, {0x4304a000}, {0x4304c000}, {0x4304e000}, {0x43050000}, {0x43052000}, {0x43054000}, {0x43056000}, {0x43058000}, {0x4305a000}, {0x4305c000}, {0x4305e000}, {0x43060000}, {0x43062000}, {0x43064000}, {0x43066000}, {0x43068000}, {0x4306a000}, {0x4306c000}, {0x4306e000}, {0x43070000}, {0x43072000}, {0x43074000}, {0x43076000}, {0x43078000}, {0x4307a000}, {0x4307c000}, {0x4307e000}, {0x43080000}, {0x43082000}, {0x43084000}, {0x43086000}, {0x43088000}, {0x4308a000}, {0x4308c000}, {0x4308e000}, {0x43090000}, {0x43092000}, {0x43094000}, {0x43096000}, {0x43098000}, {0x4309a000}, {0x4309c000}, {0x4309e000}, {0x430a0000}, {0x430a2000}, {0x430a4000}, {0x430a6000}, {0x430a8000}, {0x430aa000}, {0x430ac000}, {0x430ae000}, {0x430b0000}, {0x430b2000}, {0x430b4000}, {0x430b6000}, {0x430b8000}, {0x430ba000}, {0x430bc000}, {0x430be000}, {0x430c0000}, {0x430c2000}, {0x430c4000}, {0x430c6000}, {0x430c8000}, {0x430ca000}, {0x430cc000}, {0x430ce000}, {0x430d0000}, {0x430d2000}, {0x430d4000}, {0x430d6000}, {0x430d8000}, {0x430da000}, {0x430dc000}, {0x430de000}, {0x430e0000}, {0x430e2000}, {0x430e4000}, {0x430e6000}, {0x430e8000}, {0x430ea000}, {0x430ec000}, {0x430ee000}, {0x430f0000}, {0x430f2000}, {0x430f4000}, {0x430f6000}, {0x430f8000}, {0x430fa000}, {0x430fc000}, {0x430fe000}, {0x43100000}, {0x43102000}, {0x43104000}, {0x43106000}, {0x43108000}, {0x4310a000}, {0x4310c000}, {0x4310e000}, {0x43110000}, {0x43112000}, {0x43114000}, {0x43116000}, {0x43118000}, {0x4311a000}, {0x4311c000}, {0x4311e000}, {0x43120000}, {0x43122000}, {0x43124000}, {0x43126000}, {0x43128000}, {0x4312a000}, {0x4312c000}, {0x4312e000}, {0x43130000}, {0x43132000}, {0x43134000}, {0x43136000}, {0x43138000}, {0x4313a000}, {0x4313c000}, {0x4313e000}, {0x43140000}, {0x43142000}, {0x43144000}, {0x43146000}, {0x43148000}, {0x4314a000}, {0x4314c000}, {0x4314e000}, {0x43150000}, {0x43152000}, {0x43154000}, {0x43156000}, {0x43158000}, {0x4315a000}, {0x4315c000}, {0x4315e000}, {0x43160000}, {0x43162000}, {0x43164000}, {0x43166000}, {0x43168000}, {0x4316a000}, {0x4316c000}, {0x4316e000}, {0x43170000}, {0x43172000}, {0x43174000}, {0x43176000}, {0x43178000}, {0x4317a000}, {0x4317c000}, {0x4317e000}, {0x43180000}, {0x43182000}, {0x43184000}, {0x43186000}, {0x43188000}, {0x4318a000}, {0x4318c000}, {0x4318e000}, {0x43190000}, {0x43192000}, {0x43194000}, {0x43196000}, {0x43198000}, {0x4319a000}, {0x4319c000}, {0x4319e000}, {0x431a0000}, {0x431a2000}, {0x431a4000}, {0x431a6000}, {0x431a8000}, {0x431aa000}, {0x431ac000}, {0x431ae000}, {0x431b0000}, {0x431b2000}, {0x431b4000}, {0x431b6000}, {0x431b8000}, {0x431ba000}, {0x431bc000}, {0x431be000}, {0x431c0000}, {0x431c2000}, {0x431c4000}, {0x431c6000}, {0x431c8000}, {0x431ca000}, {0x431cc000}, {0x431ce000}, {0x431d0000}, {0x431d2000}, {0x431d4000}, {0x431d6000}, {0x431d8000}, {0x431da000}, {0x431dc000}, {0x431de000}, {0x431e0000}, {0x431e2000}, {0x431e4000}, {0x431e6000}, {0x431e8000}, {0x431ea000}, {0x431ec000}, {0x431ee000}, {0x431f0000}, {0x431f2000}, {0x431f4000}, {0x431f6000}, {0x431f8000}, {0x431fa000}, {0x431fc000}, {0x431fe000}, {0x43200000}, {0x43202000}, {0x43204000}, {0x43206000}, {0x43208000}, {0x4320a000}, {0x4320c000}, {0x4320e000}, {0x43210000}, {0x43212000}, {0x43214000}, {0x43216000}, {0x43218000}, {0x4321a000}, {0x4321c000}, {0x4321e000}, {0x43220000}, {0x43222000}, {0x43224000}, {0x43226000}, {0x43228000}, {0x4322a000}, {0x4322c000}, {0x4322e000}, {0x43230000}, {0x43232000}, {0x43234000}, {0x43236000}, {0x43238000}, {0x4323a000}, {0x4323c000}, {0x4323e000}, {0x43240000}, {0x43242000}, {0x43244000}, {0x43246000}, {0x43248000}, {0x4324a000}, {0x4324c000}, {0x4324e000}, {0x43250000}, {0x43252000}, {0x43254000}, {0x43256000}, {0x43258000}, {0x4325a000}, {0x4325c000}, {0x4325e000}, {0x43260000}, {0x43262000}, {0x43264000}, {0x43266000}, {0x43268000}, {0x4326a000}, {0x4326c000}, {0x4326e000}, {0x43270000}, {0x43272000}, {0x43274000}, {0x43276000}, {0x43278000}, {0x4327a000}, {0x4327c000}, {0x4327e000}, {0x43280000}, {0x43282000}, {0x43284000}, {0x43286000}, {0x43288000}, {0x4328a000}, {0x4328c000}, {0x4328e000}, {0x43290000}, {0x43292000}, {0x43294000}, {0x43296000}, {0x43298000}, {0x4329a000}, {0x4329c000}, {0x4329e000}, {0x432a0000}, {0x432a2000}, {0x432a4000}, {0x432a6000}, {0x432a8000}, {0x432aa000}, {0x432ac000}, {0x432ae000}, {0x432b0000}, {0x432b2000}, {0x432b4000}, {0x432b6000}, {0x432b8000}, {0x432ba000}, {0x432bc000}, {0x432be000}, {0x432c0000}, {0x432c2000}, {0x432c4000}, {0x432c6000}, {0x432c8000}, {0x432ca000}, {0x432cc000}, {0x432ce000}, {0x432d0000}, {0x432d2000}, {0x432d4000}, {0x432d6000}, {0x432d8000}, {0x432da000}, {0x432dc000}, {0x432de000}, {0x432e0000}, {0x432e2000}, {0x432e4000}, {0x432e6000}, {0x432e8000}, {0x432ea000}, {0x432ec000}, {0x432ee000}, {0x432f0000}, {0x432f2000}, {0x432f4000}, {0x432f6000}, {0x432f8000}, {0x432fa000}, {0x432fc000}, {0x432fe000}, {0x43300000}, {0x43302000}, {0x43304000}, {0x43306000}, {0x43308000}, {0x4330a000}, {0x4330c000}, {0x4330e000}, {0x43310000}, {0x43312000}, {0x43314000}, {0x43316000}, {0x43318000}, {0x4331a000}, {0x4331c000}, {0x4331e000}, {0x43320000}, {0x43322000}, {0x43324000}, {0x43326000}, {0x43328000}, {0x4332a000}, {0x4332c000}, {0x4332e000}, {0x43330000}, {0x43332000}, {0x43334000}, {0x43336000}, {0x43338000}, {0x4333a000}, {0x4333c000}, {0x4333e000}, {0x43340000}, {0x43342000}, {0x43344000}, {0x43346000}, {0x43348000}, {0x4334a000}, {0x4334c000}, {0x4334e000}, {0x43350000}, {0x43352000}, {0x43354000}, {0x43356000}, {0x43358000}, {0x4335a000}, {0x4335c000}, {0x4335e000}, {0x43360000}, {0x43362000}, {0x43364000}, {0x43366000}, {0x43368000}, {0x4336a000}, {0x4336c000}, {0x4336e000}, {0x43370000}, {0x43372000}, {0x43374000}, {0x43376000}, {0x43378000}, {0x4337a000}, {0x4337c000}, {0x4337e000}, {0x43380000}, {0x43382000}, {0x43384000}, {0x43386000}, {0x43388000}, {0x4338a000}, {0x4338c000}, {0x4338e000}, {0x43390000}, {0x43392000}, {0x43394000}, {0x43396000}, {0x43398000}, {0x4339a000}, {0x4339c000}, {0x4339e000}, {0x433a0000}, {0x433a2000}, {0x433a4000}, {0x433a6000}, {0x433a8000}, {0x433aa000}, {0x433ac000}, {0x433ae000}, {0x433b0000}, {0x433b2000}, {0x433b4000}, {0x433b6000}, {0x433b8000}, {0x433ba000}, {0x433bc000}, {0x433be000}, {0x433c0000}, {0x433c2000}, {0x433c4000}, {0x433c6000}, {0x433c8000}, {0x433ca000}, {0x433cc000}, {0x433ce000}, {0x433d0000}, {0x433d2000}, {0x433d4000}, {0x433d6000}, {0x433d8000}, {0x433da000}, {0x433dc000}, {0x433de000}, {0x433e0000}, {0x433e2000}, {0x433e4000}, {0x433e6000}, {0x433e8000}, {0x433ea000}, {0x433ec000}, {0x433ee000}, {0x433f0000}, {0x433f2000}, {0x433f4000}, {0x433f6000}, {0x433f8000}, {0x433fa000}, {0x433fc000}, {0x433fe000}, {0x43400000}, {0x43402000}, {0x43404000}, {0x43406000}, {0x43408000}, {0x4340a000}, {0x4340c000}, {0x4340e000}, {0x43410000}, {0x43412000}, {0x43414000}, {0x43416000}, {0x43418000}, {0x4341a000}, {0x4341c000}, {0x4341e000}, {0x43420000}, {0x43422000}, {0x43424000}, {0x43426000}, {0x43428000}, {0x4342a000}, {0x4342c000}, {0x4342e000}, {0x43430000}, {0x43432000}, {0x43434000}, {0x43436000}, {0x43438000}, {0x4343a000}, {0x4343c000}, {0x4343e000}, {0x43440000}, {0x43442000}, {0x43444000}, {0x43446000}, {0x43448000}, {0x4344a000}, {0x4344c000}, {0x4344e000}, {0x43450000}, {0x43452000}, {0x43454000}, {0x43456000}, {0x43458000}, {0x4345a000}, {0x4345c000}, {0x4345e000}, {0x43460000}, {0x43462000}, {0x43464000}, {0x43466000}, {0x43468000}, {0x4346a000}, {0x4346c000}, {0x4346e000}, {0x43470000}, {0x43472000}, {0x43474000}, {0x43476000}, {0x43478000}, {0x4347a000}, {0x4347c000}, {0x4347e000}, {0x43480000}, {0x43482000}, {0x43484000}, {0x43486000}, {0x43488000}, {0x4348a000}, {0x4348c000}, {0x4348e000}, {0x43490000}, {0x43492000}, {0x43494000}, {0x43496000}, {0x43498000}, {0x4349a000}, {0x4349c000}, {0x4349e000}, {0x434a0000}, {0x434a2000}, {0x434a4000}, {0x434a6000}, {0x434a8000}, {0x434aa000}, {0x434ac000}, {0x434ae000}, {0x434b0000}, {0x434b2000}, {0x434b4000}, {0x434b6000}, {0x434b8000}, {0x434ba000}, {0x434bc000}, {0x434be000}, {0x434c0000}, {0x434c2000}, {0x434c4000}, {0x434c6000}, {0x434c8000}, {0x434ca000}, {0x434cc000}, {0x434ce000}, {0x434d0000}, {0x434d2000}, {0x434d4000}, {0x434d6000}, {0x434d8000}, {0x434da000}, {0x434dc000}, {0x434de000}, {0x434e0000}, {0x434e2000}, {0x434e4000}, {0x434e6000}, {0x434e8000}, {0x434ea000}, {0x434ec000}, {0x434ee000}, {0x434f0000}, {0x434f2000}, {0x434f4000}, {0x434f6000}, {0x434f8000}, {0x434fa000}, {0x434fc000}, {0x434fe000}, {0x43500000}, {0x43502000}, {0x43504000}, {0x43506000}, {0x43508000}, {0x4350a000}, {0x4350c000}, {0x4350e000}, {0x43510000}, {0x43512000}, {0x43514000}, {0x43516000}, {0x43518000}, {0x4351a000}, {0x4351c000}, {0x4351e000}, {0x43520000}, {0x43522000}, {0x43524000}, {0x43526000}, {0x43528000}, {0x4352a000}, {0x4352c000}, {0x4352e000}, {0x43530000}, {0x43532000}, {0x43534000}, {0x43536000}, {0x43538000}, {0x4353a000}, {0x4353c000}, {0x4353e000}, {0x43540000}, {0x43542000}, {0x43544000}, {0x43546000}, {0x43548000}, {0x4354a000}, {0x4354c000}, {0x4354e000}, {0x43550000}, {0x43552000}, {0x43554000}, {0x43556000}, {0x43558000}, {0x4355a000}, {0x4355c000}, {0x4355e000}, {0x43560000}, {0x43562000}, {0x43564000}, {0x43566000}, {0x43568000}, {0x4356a000}, {0x4356c000}, {0x4356e000}, {0x43570000}, {0x43572000}, {0x43574000}, {0x43576000}, {0x43578000}, {0x4357a000}, {0x4357c000}, {0x4357e000}, {0x43580000}, {0x43582000}, {0x43584000}, {0x43586000}, {0x43588000}, {0x4358a000}, {0x4358c000}, {0x4358e000}, {0x43590000}, {0x43592000}, {0x43594000}, {0x43596000}, {0x43598000}, {0x4359a000}, {0x4359c000}, {0x4359e000}, {0x435a0000}, {0x435a2000}, {0x435a4000}, {0x435a6000}, {0x435a8000}, {0x435aa000}, {0x435ac000}, {0x435ae000}, {0x435b0000}, {0x435b2000}, {0x435b4000}, {0x435b6000}, {0x435b8000}, {0x435ba000}, {0x435bc000}, {0x435be000}, {0x435c0000}, {0x435c2000}, {0x435c4000}, {0x435c6000}, {0x435c8000}, {0x435ca000}, {0x435cc000}, {0x435ce000}, {0x435d0000}, {0x435d2000}, {0x435d4000}, {0x435d6000}, {0x435d8000}, {0x435da000}, {0x435dc000}, {0x435de000}, {0x435e0000}, {0x435e2000}, {0x435e4000}, {0x435e6000}, {0x435e8000}, {0x435ea000}, {0x435ec000}, {0x435ee000}, {0x435f0000}, {0x435f2000}, {0x435f4000}, {0x435f6000}, {0x435f8000}, {0x435fa000}, {0x435fc000}, {0x435fe000}, {0x43600000}, {0x43602000}, {0x43604000}, {0x43606000}, {0x43608000}, {0x4360a000}, {0x4360c000}, {0x4360e000}, {0x43610000}, {0x43612000}, {0x43614000}, {0x43616000}, {0x43618000}, {0x4361a000}, {0x4361c000}, {0x4361e000}, {0x43620000}, {0x43622000}, {0x43624000}, {0x43626000}, {0x43628000}, {0x4362a000}, {0x4362c000}, {0x4362e000}, {0x43630000}, {0x43632000}, {0x43634000}, {0x43636000}, {0x43638000}, {0x4363a000}, {0x4363c000}, {0x4363e000}, {0x43640000}, {0x43642000}, {0x43644000}, {0x43646000}, {0x43648000}, {0x4364a000}, {0x4364c000}, {0x4364e000}, {0x43650000}, {0x43652000}, {0x43654000}, {0x43656000}, {0x43658000}, {0x4365a000}, {0x4365c000}, {0x4365e000}, {0x43660000}, {0x43662000}, {0x43664000}, {0x43666000}, {0x43668000}, {0x4366a000}, {0x4366c000}, {0x4366e000}, {0x43670000}, {0x43672000}, {0x43674000}, {0x43676000}, {0x43678000}, {0x4367a000}, {0x4367c000}, {0x4367e000}, {0x43680000}, {0x43682000}, {0x43684000}, {0x43686000}, {0x43688000}, {0x4368a000}, {0x4368c000}, {0x4368e000}, {0x43690000}, {0x43692000}, {0x43694000}, {0x43696000}, {0x43698000}, {0x4369a000}, {0x4369c000}, {0x4369e000}, {0x436a0000}, {0x436a2000}, {0x436a4000}, {0x436a6000}, {0x436a8000}, {0x436aa000}, {0x436ac000}, {0x436ae000}, {0x436b0000}, {0x436b2000}, {0x436b4000}, {0x436b6000}, {0x436b8000}, {0x436ba000}, {0x436bc000}, {0x436be000}, {0x436c0000}, {0x436c2000}, {0x436c4000}, {0x436c6000}, {0x436c8000}, {0x436ca000}, {0x436cc000}, {0x436ce000}, {0x436d0000}, {0x436d2000}, {0x436d4000}, {0x436d6000}, {0x436d8000}, {0x436da000}, {0x436dc000}, {0x436de000}, {0x436e0000}, {0x436e2000}, {0x436e4000}, {0x436e6000}, {0x436e8000}, {0x436ea000}, {0x436ec000}, {0x436ee000}, {0x436f0000}, {0x436f2000}, {0x436f4000}, {0x436f6000}, {0x436f8000}, {0x436fa000}, {0x436fc000}, {0x436fe000}, {0x43700000}, {0x43702000}, {0x43704000}, {0x43706000}, {0x43708000}, {0x4370a000}, {0x4370c000}, {0x4370e000}, {0x43710000}, {0x43712000}, {0x43714000}, {0x43716000}, {0x43718000}, {0x4371a000}, {0x4371c000}, {0x4371e000}, {0x43720000}, {0x43722000}, {0x43724000}, {0x43726000}, {0x43728000}, {0x4372a000}, {0x4372c000}, {0x4372e000}, {0x43730000}, {0x43732000}, {0x43734000}, {0x43736000}, {0x43738000}, {0x4373a000}, {0x4373c000}, {0x4373e000}, {0x43740000}, {0x43742000}, {0x43744000}, {0x43746000}, {0x43748000}, {0x4374a000}, {0x4374c000}, {0x4374e000}, {0x43750000}, {0x43752000}, {0x43754000}, {0x43756000}, {0x43758000}, {0x4375a000}, {0x4375c000}, {0x4375e000}, {0x43760000}, {0x43762000}, {0x43764000}, {0x43766000}, {0x43768000}, {0x4376a000}, {0x4376c000}, {0x4376e000}, {0x43770000}, {0x43772000}, {0x43774000}, {0x43776000}, {0x43778000}, {0x4377a000}, {0x4377c000}, {0x4377e000}, {0x43780000}, {0x43782000}, {0x43784000}, {0x43786000}, {0x43788000}, {0x4378a000}, {0x4378c000}, {0x4378e000}, {0x43790000}, {0x43792000}, {0x43794000}, {0x43796000}, {0x43798000}, {0x4379a000}, {0x4379c000}, {0x4379e000}, {0x437a0000}, {0x437a2000}, {0x437a4000}, {0x437a6000}, {0x437a8000}, {0x437aa000}, {0x437ac000}, {0x437ae000}, {0x437b0000}, {0x437b2000}, {0x437b4000}, {0x437b6000}, {0x437b8000}, {0x437ba000}, {0x437bc000}, {0x437be000}, {0x437c0000}, {0x437c2000}, {0x437c4000}, {0x437c6000}, {0x437c8000}, {0x437ca000}, {0x437cc000}, {0x437ce000}, {0x437d0000}, {0x437d2000}, {0x437d4000}, {0x437d6000}, {0x437d8000}, {0x437da000}, {0x437dc000}, {0x437de000}, {0x437e0000}, {0x437e2000}, {0x437e4000}, {0x437e6000}, {0x437e8000}, {0x437ea000}, {0x437ec000}, {0x437ee000}, {0x437f0000}, {0x437f2000}, {0x437f4000}, {0x437f6000}, {0x437f8000}, {0x437fa000}, {0x437fc000}, {0x437fe000}, {0x43800000}, {0x43802000}, {0x43804000}, {0x43806000}, {0x43808000}, {0x4380a000}, {0x4380c000}, {0x4380e000}, {0x43810000}, {0x43812000}, {0x43814000}, {0x43816000}, {0x43818000}, {0x4381a000}, {0x4381c000}, {0x4381e000}, {0x43820000}, {0x43822000}, {0x43824000}, {0x43826000}, {0x43828000}, {0x4382a000}, {0x4382c000}, {0x4382e000}, {0x43830000}, {0x43832000}, {0x43834000}, {0x43836000}, {0x43838000}, {0x4383a000}, {0x4383c000}, {0x4383e000}, {0x43840000}, {0x43842000}, {0x43844000}, {0x43846000}, {0x43848000}, {0x4384a000}, {0x4384c000}, {0x4384e000}, {0x43850000}, {0x43852000}, {0x43854000}, {0x43856000}, {0x43858000}, {0x4385a000}, {0x4385c000}, {0x4385e000}, {0x43860000}, {0x43862000}, {0x43864000}, {0x43866000}, {0x43868000}, {0x4386a000}, {0x4386c000}, {0x4386e000}, {0x43870000}, {0x43872000}, {0x43874000}, {0x43876000}, {0x43878000}, {0x4387a000}, {0x4387c000}, {0x4387e000}, {0x43880000}, {0x43882000}, {0x43884000}, {0x43886000}, {0x43888000}, {0x4388a000}, {0x4388c000}, {0x4388e000}, {0x43890000}, {0x43892000}, {0x43894000}, {0x43896000}, {0x43898000}, {0x4389a000}, {0x4389c000}, {0x4389e000}, {0x438a0000}, {0x438a2000}, {0x438a4000}, {0x438a6000}, {0x438a8000}, {0x438aa000}, {0x438ac000}, {0x438ae000}, {0x438b0000}, {0x438b2000}, {0x438b4000}, {0x438b6000}, {0x438b8000}, {0x438ba000}, {0x438bc000}, {0x438be000}, {0x438c0000}, {0x438c2000}, {0x438c4000}, {0x438c6000}, {0x438c8000}, {0x438ca000}, {0x438cc000}, {0x438ce000}, {0x438d0000}, {0x438d2000}, {0x438d4000}, {0x438d6000}, {0x438d8000}, {0x438da000}, {0x438dc000}, {0x438de000}, {0x438e0000}, {0x438e2000}, {0x438e4000}, {0x438e6000}, {0x438e8000}, {0x438ea000}, {0x438ec000}, {0x438ee000}, {0x438f0000}, {0x438f2000}, {0x438f4000}, {0x438f6000}, {0x438f8000}, {0x438fa000}, {0x438fc000}, {0x438fe000}, {0x43900000}, {0x43902000}, {0x43904000}, {0x43906000}, {0x43908000}, {0x4390a000}, {0x4390c000}, {0x4390e000}, {0x43910000}, {0x43912000}, {0x43914000}, {0x43916000}, {0x43918000}, {0x4391a000}, {0x4391c000}, {0x4391e000}, {0x43920000}, {0x43922000}, {0x43924000}, {0x43926000}, {0x43928000}, {0x4392a000}, {0x4392c000}, {0x4392e000}, {0x43930000}, {0x43932000}, {0x43934000}, {0x43936000}, {0x43938000}, {0x4393a000}, {0x4393c000}, {0x4393e000}, {0x43940000}, {0x43942000}, {0x43944000}, {0x43946000}, {0x43948000}, {0x4394a000}, {0x4394c000}, {0x4394e000}, {0x43950000}, {0x43952000}, {0x43954000}, {0x43956000}, {0x43958000}, {0x4395a000}, {0x4395c000}, {0x4395e000}, {0x43960000}, {0x43962000}, {0x43964000}, {0x43966000}, {0x43968000}, {0x4396a000}, {0x4396c000}, {0x4396e000}, {0x43970000}, {0x43972000}, {0x43974000}, {0x43976000}, {0x43978000}, {0x4397a000}, {0x4397c000}, {0x4397e000}, {0x43980000}, {0x43982000}, {0x43984000}, {0x43986000}, {0x43988000}, {0x4398a000}, {0x4398c000}, {0x4398e000}, {0x43990000}, {0x43992000}, {0x43994000}, {0x43996000}, {0x43998000}, {0x4399a000}, {0x4399c000}, {0x4399e000}, {0x439a0000}, {0x439a2000}, {0x439a4000}, {0x439a6000}, {0x439a8000}, {0x439aa000}, {0x439ac000}, {0x439ae000}, {0x439b0000}, {0x439b2000}, {0x439b4000}, {0x439b6000}, {0x439b8000}, {0x439ba000}, {0x439bc000}, {0x439be000}, {0x439c0000}, {0x439c2000}, {0x439c4000}, {0x439c6000}, {0x439c8000}, {0x439ca000}, {0x439cc000}, {0x439ce000}, {0x439d0000}, {0x439d2000}, {0x439d4000}, {0x439d6000}, {0x439d8000}, {0x439da000}, {0x439dc000}, {0x439de000}, {0x439e0000}, {0x439e2000}, {0x439e4000}, {0x439e6000}, {0x439e8000}, {0x439ea000}, {0x439ec000}, {0x439ee000}, {0x439f0000}, {0x439f2000}, {0x439f4000}, {0x439f6000}, {0x439f8000}, {0x439fa000}, {0x439fc000}, {0x439fe000}, {0x43a00000}, {0x43a02000}, {0x43a04000}, {0x43a06000}, {0x43a08000}, {0x43a0a000}, {0x43a0c000}, {0x43a0e000}, {0x43a10000}, {0x43a12000}, {0x43a14000}, {0x43a16000}, {0x43a18000}, {0x43a1a000}, {0x43a1c000}, {0x43a1e000}, {0x43a20000}, {0x43a22000}, {0x43a24000}, {0x43a26000}, {0x43a28000}, {0x43a2a000}, {0x43a2c000}, {0x43a2e000}, {0x43a30000}, {0x43a32000}, {0x43a34000}, {0x43a36000}, {0x43a38000}, {0x43a3a000}, {0x43a3c000}, {0x43a3e000}, {0x43a40000}, {0x43a42000}, {0x43a44000}, {0x43a46000}, {0x43a48000}, {0x43a4a000}, {0x43a4c000}, {0x43a4e000}, {0x43a50000}, {0x43a52000}, {0x43a54000}, {0x43a56000}, {0x43a58000}, {0x43a5a000}, {0x43a5c000}, {0x43a5e000}, {0x43a60000}, {0x43a62000}, {0x43a64000}, {0x43a66000}, {0x43a68000}, {0x43a6a000}, {0x43a6c000}, {0x43a6e000}, {0x43a70000}, {0x43a72000}, {0x43a74000}, {0x43a76000}, {0x43a78000}, {0x43a7a000}, {0x43a7c000}, {0x43a7e000}, {0x43a80000}, {0x43a82000}, {0x43a84000}, {0x43a86000}, {0x43a88000}, {0x43a8a000}, {0x43a8c000}, {0x43a8e000}, {0x43a90000}, {0x43a92000}, {0x43a94000}, {0x43a96000}, {0x43a98000}, {0x43a9a000}, {0x43a9c000}, {0x43a9e000}, {0x43aa0000}, {0x43aa2000}, {0x43aa4000}, {0x43aa6000}, {0x43aa8000}, {0x43aaa000}, {0x43aac000}, {0x43aae000}, {0x43ab0000}, {0x43ab2000}, {0x43ab4000}, {0x43ab6000}, {0x43ab8000}, {0x43aba000}, {0x43abc000}, {0x43abe000}, {0x43ac0000}, {0x43ac2000}, {0x43ac4000}, {0x43ac6000}, {0x43ac8000}, {0x43aca000}, {0x43acc000}, {0x43ace000}, {0x43ad0000}, {0x43ad2000}, {0x43ad4000}, {0x43ad6000}, {0x43ad8000}, {0x43ada000}, {0x43adc000}, {0x43ade000}, {0x43ae0000}, {0x43ae2000}, {0x43ae4000}, {0x43ae6000}, {0x43ae8000}, {0x43aea000}, {0x43aec000}, {0x43aee000}, {0x43af0000}, {0x43af2000}, {0x43af4000}, {0x43af6000}, {0x43af8000}, {0x43afa000}, {0x43afc000}, {0x43afe000}, {0x43b00000}, {0x43b02000}, {0x43b04000}, {0x43b06000}, {0x43b08000}, {0x43b0a000}, {0x43b0c000}, {0x43b0e000}, {0x43b10000}, {0x43b12000}, {0x43b14000}, {0x43b16000}, {0x43b18000}, {0x43b1a000}, {0x43b1c000}, {0x43b1e000}, {0x43b20000}, {0x43b22000}, {0x43b24000}, {0x43b26000}, {0x43b28000}, {0x43b2a000}, {0x43b2c000}, {0x43b2e000}, {0x43b30000}, {0x43b32000}, {0x43b34000}, {0x43b36000}, {0x43b38000}, {0x43b3a000}, {0x43b3c000}, {0x43b3e000}, {0x43b40000}, {0x43b42000}, {0x43b44000}, {0x43b46000}, {0x43b48000}, {0x43b4a000}, {0x43b4c000}, {0x43b4e000}, {0x43b50000}, {0x43b52000}, {0x43b54000}, {0x43b56000}, {0x43b58000}, {0x43b5a000}, {0x43b5c000}, {0x43b5e000}, {0x43b60000}, {0x43b62000}, {0x43b64000}, {0x43b66000}, {0x43b68000}, {0x43b6a000}, {0x43b6c000}, {0x43b6e000}, {0x43b70000}, {0x43b72000}, {0x43b74000}, {0x43b76000}, {0x43b78000}, {0x43b7a000}, {0x43b7c000}, {0x43b7e000}, {0x43b80000}, {0x43b82000}, {0x43b84000}, {0x43b86000}, {0x43b88000}, {0x43b8a000}, {0x43b8c000}, {0x43b8e000}, {0x43b90000}, {0x43b92000}, {0x43b94000}, {0x43b96000}, {0x43b98000}, {0x43b9a000}, {0x43b9c000}, {0x43b9e000}, {0x43ba0000}, {0x43ba2000}, {0x43ba4000}, {0x43ba6000}, {0x43ba8000}, {0x43baa000}, {0x43bac000}, {0x43bae000}, {0x43bb0000}, {0x43bb2000}, {0x43bb4000}, {0x43bb6000}, {0x43bb8000}, {0x43bba000}, {0x43bbc000}, {0x43bbe000}, {0x43bc0000}, {0x43bc2000}, {0x43bc4000}, {0x43bc6000}, {0x43bc8000}, {0x43bca000}, {0x43bcc000}, {0x43bce000}, {0x43bd0000}, {0x43bd2000}, {0x43bd4000}, {0x43bd6000}, {0x43bd8000}, {0x43bda000}, {0x43bdc000}, {0x43bde000}, {0x43be0000}, {0x43be2000}, {0x43be4000}, {0x43be6000}, {0x43be8000}, {0x43bea000}, {0x43bec000}, {0x43bee000}, {0x43bf0000}, {0x43bf2000}, {0x43bf4000}, {0x43bf6000}, {0x43bf8000}, {0x43bfa000}, {0x43bfc000}, {0x43bfe000}, {0x43c00000}, {0x43c02000}, {0x43c04000}, {0x43c06000}, {0x43c08000}, {0x43c0a000}, {0x43c0c000}, {0x43c0e000}, {0x43c10000}, {0x43c12000}, {0x43c14000}, {0x43c16000}, {0x43c18000}, {0x43c1a000}, {0x43c1c000}, {0x43c1e000}, {0x43c20000}, {0x43c22000}, {0x43c24000}, {0x43c26000}, {0x43c28000}, {0x43c2a000}, {0x43c2c000}, {0x43c2e000}, {0x43c30000}, {0x43c32000}, {0x43c34000}, {0x43c36000}, {0x43c38000}, {0x43c3a000}, {0x43c3c000}, {0x43c3e000}, {0x43c40000}, {0x43c42000}, {0x43c44000}, {0x43c46000}, {0x43c48000}, {0x43c4a000}, {0x43c4c000}, {0x43c4e000}, {0x43c50000}, {0x43c52000}, {0x43c54000}, {0x43c56000}, {0x43c58000}, {0x43c5a000}, {0x43c5c000}, {0x43c5e000}, {0x43c60000}, {0x43c62000}, {0x43c64000}, {0x43c66000}, {0x43c68000}, {0x43c6a000}, {0x43c6c000}, {0x43c6e000}, {0x43c70000}, {0x43c72000}, {0x43c74000}, {0x43c76000}, {0x43c78000}, {0x43c7a000}, {0x43c7c000}, {0x43c7e000}, {0x43c80000}, {0x43c82000}, {0x43c84000}, {0x43c86000}, {0x43c88000}, {0x43c8a000}, {0x43c8c000}, {0x43c8e000}, {0x43c90000}, {0x43c92000}, {0x43c94000}, {0x43c96000}, {0x43c98000}, {0x43c9a000}, {0x43c9c000}, {0x43c9e000}, {0x43ca0000}, {0x43ca2000}, {0x43ca4000}, {0x43ca6000}, {0x43ca8000}, {0x43caa000}, {0x43cac000}, {0x43cae000}, {0x43cb0000}, {0x43cb2000}, {0x43cb4000}, {0x43cb6000}, {0x43cb8000}, {0x43cba000}, {0x43cbc000}, {0x43cbe000}, {0x43cc0000}, {0x43cc2000}, {0x43cc4000}, {0x43cc6000}, {0x43cc8000}, {0x43cca000}, {0x43ccc000}, {0x43cce000}, {0x43cd0000}, {0x43cd2000}, {0x43cd4000}, {0x43cd6000}, {0x43cd8000}, {0x43cda000}, {0x43cdc000}, {0x43cde000}, {0x43ce0000}, {0x43ce2000}, {0x43ce4000}, {0x43ce6000}, {0x43ce8000}, {0x43cea000}, {0x43cec000}, {0x43cee000}, {0x43cf0000}, {0x43cf2000}, {0x43cf4000}, {0x43cf6000}, {0x43cf8000}, {0x43cfa000}, {0x43cfc000}, {0x43cfe000}, {0x43d00000}, {0x43d02000}, {0x43d04000}, {0x43d06000}, {0x43d08000}, {0x43d0a000}, {0x43d0c000}, {0x43d0e000}, {0x43d10000}, {0x43d12000}, {0x43d14000}, {0x43d16000}, {0x43d18000}, {0x43d1a000}, {0x43d1c000}, {0x43d1e000}, {0x43d20000}, {0x43d22000}, {0x43d24000}, {0x43d26000}, {0x43d28000}, {0x43d2a000}, {0x43d2c000}, {0x43d2e000}, {0x43d30000}, {0x43d32000}, {0x43d34000}, {0x43d36000}, {0x43d38000}, {0x43d3a000}, {0x43d3c000}, {0x43d3e000}, {0x43d40000}, {0x43d42000}, {0x43d44000}, {0x43d46000}, {0x43d48000}, {0x43d4a000}, {0x43d4c000}, {0x43d4e000}, {0x43d50000}, {0x43d52000}, {0x43d54000}, {0x43d56000}, {0x43d58000}, {0x43d5a000}, {0x43d5c000}, {0x43d5e000}, {0x43d60000}, {0x43d62000}, {0x43d64000}, {0x43d66000}, {0x43d68000}, {0x43d6a000}, {0x43d6c000}, {0x43d6e000}, {0x43d70000}, {0x43d72000}, {0x43d74000}, {0x43d76000}, {0x43d78000}, {0x43d7a000}, {0x43d7c000}, {0x43d7e000}, {0x43d80000}, {0x43d82000}, {0x43d84000}, {0x43d86000}, {0x43d88000}, {0x43d8a000}, {0x43d8c000}, {0x43d8e000}, {0x43d90000}, {0x43d92000}, {0x43d94000}, {0x43d96000}, {0x43d98000}, {0x43d9a000}, {0x43d9c000}, {0x43d9e000}, {0x43da0000}, {0x43da2000}, {0x43da4000}, {0x43da6000}, {0x43da8000}, {0x43daa000}, {0x43dac000}, {0x43dae000}, {0x43db0000}, {0x43db2000}, {0x43db4000}, {0x43db6000}, {0x43db8000}, {0x43dba000}, {0x43dbc000}, {0x43dbe000}, {0x43dc0000}, {0x43dc2000}, {0x43dc4000}, {0x43dc6000}, {0x43dc8000}, {0x43dca000}, {0x43dcc000}, {0x43dce000}, {0x43dd0000}, {0x43dd2000}, {0x43dd4000}, {0x43dd6000}, {0x43dd8000}, {0x43dda000}, {0x43ddc000}, {0x43dde000}, {0x43de0000}, {0x43de2000}, {0x43de4000}, {0x43de6000}, {0x43de8000}, {0x43dea000}, {0x43dec000}, {0x43dee000}, {0x43df0000}, {0x43df2000}, {0x43df4000}, {0x43df6000}, {0x43df8000}, {0x43dfa000}, {0x43dfc000}, {0x43dfe000}, {0x43e00000}, {0x43e02000}, {0x43e04000}, {0x43e06000}, {0x43e08000}, {0x43e0a000}, {0x43e0c000}, {0x43e0e000}, {0x43e10000}, {0x43e12000}, {0x43e14000}, {0x43e16000}, {0x43e18000}, {0x43e1a000}, {0x43e1c000}, {0x43e1e000}, {0x43e20000}, {0x43e22000}, {0x43e24000}, {0x43e26000}, {0x43e28000}, {0x43e2a000}, {0x43e2c000}, {0x43e2e000}, {0x43e30000}, {0x43e32000}, {0x43e34000}, {0x43e36000}, {0x43e38000}, {0x43e3a000}, {0x43e3c000}, {0x43e3e000}, {0x43e40000}, {0x43e42000}, {0x43e44000}, {0x43e46000}, {0x43e48000}, {0x43e4a000}, {0x43e4c000}, {0x43e4e000}, {0x43e50000}, {0x43e52000}, {0x43e54000}, {0x43e56000}, {0x43e58000}, {0x43e5a000}, {0x43e5c000}, {0x43e5e000}, {0x43e60000}, {0x43e62000}, {0x43e64000}, {0x43e66000}, {0x43e68000}, {0x43e6a000}, {0x43e6c000}, {0x43e6e000}, {0x43e70000}, {0x43e72000}, {0x43e74000}, {0x43e76000}, {0x43e78000}, {0x43e7a000}, {0x43e7c000}, {0x43e7e000}, {0x43e80000}, {0x43e82000}, {0x43e84000}, {0x43e86000}, {0x43e88000}, {0x43e8a000}, {0x43e8c000}, {0x43e8e000}, {0x43e90000}, {0x43e92000}, {0x43e94000}, {0x43e96000}, {0x43e98000}, {0x43e9a000}, {0x43e9c000}, {0x43e9e000}, {0x43ea0000}, {0x43ea2000}, {0x43ea4000}, {0x43ea6000}, {0x43ea8000}, {0x43eaa000}, {0x43eac000}, {0x43eae000}, {0x43eb0000}, {0x43eb2000}, {0x43eb4000}, {0x43eb6000}, {0x43eb8000}, {0x43eba000}, {0x43ebc000}, {0x43ebe000}, {0x43ec0000}, {0x43ec2000}, {0x43ec4000}, {0x43ec6000}, {0x43ec8000}, {0x43eca000}, {0x43ecc000}, {0x43ece000}, {0x43ed0000}, {0x43ed2000}, {0x43ed4000}, {0x43ed6000}, {0x43ed8000}, {0x43eda000}, {0x43edc000}, {0x43ede000}, {0x43ee0000}, {0x43ee2000}, {0x43ee4000}, {0x43ee6000}, {0x43ee8000}, {0x43eea000}, {0x43eec000}, {0x43eee000}, {0x43ef0000}, {0x43ef2000}, {0x43ef4000}, {0x43ef6000}, {0x43ef8000}, {0x43efa000}, {0x43efc000}, {0x43efe000}, {0x43f00000}, {0x43f02000}, {0x43f04000}, {0x43f06000}, {0x43f08000}, {0x43f0a000}, {0x43f0c000}, {0x43f0e000}, {0x43f10000}, {0x43f12000}, {0x43f14000}, {0x43f16000}, {0x43f18000}, {0x43f1a000}, {0x43f1c000}, {0x43f1e000}, {0x43f20000}, {0x43f22000}, {0x43f24000}, {0x43f26000}, {0x43f28000}, {0x43f2a000}, {0x43f2c000}, {0x43f2e000}, {0x43f30000}, {0x43f32000}, {0x43f34000}, {0x43f36000}, {0x43f38000}, {0x43f3a000}, {0x43f3c000}, {0x43f3e000}, {0x43f40000}, {0x43f42000}, {0x43f44000}, {0x43f46000}, {0x43f48000}, {0x43f4a000}, {0x43f4c000}, {0x43f4e000}, {0x43f50000}, {0x43f52000}, {0x43f54000}, {0x43f56000}, {0x43f58000}, {0x43f5a000}, {0x43f5c000}, {0x43f5e000}, {0x43f60000}, {0x43f62000}, {0x43f64000}, {0x43f66000}, {0x43f68000}, {0x43f6a000}, {0x43f6c000}, {0x43f6e000}, {0x43f70000}, {0x43f72000}, {0x43f74000}, {0x43f76000}, {0x43f78000}, {0x43f7a000}, {0x43f7c000}, {0x43f7e000}, {0x43f80000}, {0x43f82000}, {0x43f84000}, {0x43f86000}, {0x43f88000}, {0x43f8a000}, {0x43f8c000}, {0x43f8e000}, {0x43f90000}, {0x43f92000}, {0x43f94000}, {0x43f96000}, {0x43f98000}, {0x43f9a000}, {0x43f9c000}, {0x43f9e000}, {0x43fa0000}, {0x43fa2000}, {0x43fa4000}, {0x43fa6000}, {0x43fa8000}, {0x43faa000}, {0x43fac000}, {0x43fae000}, {0x43fb0000}, {0x43fb2000}, {0x43fb4000}, {0x43fb6000}, {0x43fb8000}, {0x43fba000}, {0x43fbc000}, {0x43fbe000}, {0x43fc0000}, {0x43fc2000}, {0x43fc4000}, {0x43fc6000}, {0x43fc8000}, {0x43fca000}, {0x43fcc000}, {0x43fce000}, {0x43fd0000}, {0x43fd2000}, {0x43fd4000}, {0x43fd6000}, {0x43fd8000}, {0x43fda000}, {0x43fdc000}, {0x43fde000}, {0x43fe0000}, {0x43fe2000}, {0x43fe4000}, {0x43fe6000}, {0x43fe8000}, {0x43fea000}, {0x43fec000}, {0x43fee000}, {0x43ff0000}, {0x43ff2000}, {0x43ff4000}, {0x43ff6000}, {0x43ff8000}, {0x43ffa000}, {0x43ffc000}, {0x43ffe000}, {0x44000000}, {0x44002000}, {0x44004000}, {0x44006000}, {0x44008000}, {0x4400a000}, {0x4400c000}, {0x4400e000}, {0x44010000}, {0x44012000}, {0x44014000}, {0x44016000}, {0x44018000}, {0x4401a000}, {0x4401c000}, {0x4401e000}, {0x44020000}, {0x44022000}, {0x44024000}, {0x44026000}, {0x44028000}, {0x4402a000}, {0x4402c000}, {0x4402e000}, {0x44030000}, {0x44032000}, {0x44034000}, {0x44036000}, {0x44038000}, {0x4403a000}, {0x4403c000}, {0x4403e000}, {0x44040000}, {0x44042000}, {0x44044000}, {0x44046000}, {0x44048000}, {0x4404a000}, {0x4404c000}, {0x4404e000}, {0x44050000}, {0x44052000}, {0x44054000}, {0x44056000}, {0x44058000}, {0x4405a000}, {0x4405c000}, {0x4405e000}, {0x44060000}, {0x44062000}, {0x44064000}, {0x44066000}, {0x44068000}, {0x4406a000}, {0x4406c000}, {0x4406e000}, {0x44070000}, {0x44072000}, {0x44074000}, {0x44076000}, {0x44078000}, {0x4407a000}, {0x4407c000}, {0x4407e000}, {0x44080000}, {0x44082000}, {0x44084000}, {0x44086000}, {0x44088000}, {0x4408a000}, {0x4408c000}, {0x4408e000}, {0x44090000}, {0x44092000}, {0x44094000}, {0x44096000}, {0x44098000}, {0x4409a000}, {0x4409c000}, {0x4409e000}, {0x440a0000}, {0x440a2000}, {0x440a4000}, {0x440a6000}, {0x440a8000}, {0x440aa000}, {0x440ac000}, {0x440ae000}, {0x440b0000}, {0x440b2000}, {0x440b4000}, {0x440b6000}, {0x440b8000}, {0x440ba000}, {0x440bc000}, {0x440be000}, {0x440c0000}, {0x440c2000}, {0x440c4000}, {0x440c6000}, {0x440c8000}, {0x440ca000}, {0x440cc000}, {0x440ce000}, {0x440d0000}, {0x440d2000}, {0x440d4000}, {0x440d6000}, {0x440d8000}, {0x440da000}, {0x440dc000}, {0x440de000}, {0x440e0000}, {0x440e2000}, {0x440e4000}, {0x440e6000}, {0x440e8000}, {0x440ea000}, {0x440ec000}, {0x440ee000}, {0x440f0000}, {0x440f2000}, {0x440f4000}, {0x440f6000}, {0x440f8000}, {0x440fa000}, {0x440fc000}, {0x440fe000}, {0x44100000}, {0x44102000}, {0x44104000}, {0x44106000}, {0x44108000}, {0x4410a000}, {0x4410c000}, {0x4410e000}, {0x44110000}, {0x44112000}, {0x44114000}, {0x44116000}, {0x44118000}, {0x4411a000}, {0x4411c000}, {0x4411e000}, {0x44120000}, {0x44122000}, {0x44124000}, {0x44126000}, {0x44128000}, {0x4412a000}, {0x4412c000}, {0x4412e000}, {0x44130000}, {0x44132000}, {0x44134000}, {0x44136000}, {0x44138000}, {0x4413a000}, {0x4413c000}, {0x4413e000}, {0x44140000}, {0x44142000}, {0x44144000}, {0x44146000}, {0x44148000}, {0x4414a000}, {0x4414c000}, {0x4414e000}, {0x44150000}, {0x44152000}, {0x44154000}, {0x44156000}, {0x44158000}, {0x4415a000}, {0x4415c000}, {0x4415e000}, {0x44160000}, {0x44162000}, {0x44164000}, {0x44166000}, {0x44168000}, {0x4416a000}, {0x4416c000}, {0x4416e000}, {0x44170000}, {0x44172000}, {0x44174000}, {0x44176000}, {0x44178000}, {0x4417a000}, {0x4417c000}, {0x4417e000}, {0x44180000}, {0x44182000}, {0x44184000}, {0x44186000}, {0x44188000}, {0x4418a000}, {0x4418c000}, {0x4418e000}, {0x44190000}, {0x44192000}, {0x44194000}, {0x44196000}, {0x44198000}, {0x4419a000}, {0x4419c000}, {0x4419e000}, {0x441a0000}, {0x441a2000}, {0x441a4000}, {0x441a6000}, {0x441a8000}, {0x441aa000}, {0x441ac000}, {0x441ae000}, {0x441b0000}, {0x441b2000}, {0x441b4000}, {0x441b6000}, {0x441b8000}, {0x441ba000}, {0x441bc000}, {0x441be000}, {0x441c0000}, {0x441c2000}, {0x441c4000}, {0x441c6000}, {0x441c8000}, {0x441ca000}, {0x441cc000}, {0x441ce000}, {0x441d0000}, {0x441d2000}, {0x441d4000}, {0x441d6000}, {0x441d8000}, {0x441da000}, {0x441dc000}, {0x441de000}, {0x441e0000}, {0x441e2000}, {0x441e4000}, {0x441e6000}, {0x441e8000}, {0x441ea000}, {0x441ec000}, {0x441ee000}, {0x441f0000}, {0x441f2000}, {0x441f4000}, {0x441f6000}, {0x441f8000}, {0x441fa000}, {0x441fc000}, {0x441fe000}, {0x44200000}, {0x44202000}, {0x44204000}, {0x44206000}, {0x44208000}, {0x4420a000}, {0x4420c000}, {0x4420e000}, {0x44210000}, {0x44212000}, {0x44214000}, {0x44216000}, {0x44218000}, {0x4421a000}, {0x4421c000}, {0x4421e000}, {0x44220000}, {0x44222000}, {0x44224000}, {0x44226000}, {0x44228000}, {0x4422a000}, {0x4422c000}, {0x4422e000}, {0x44230000}, {0x44232000}, {0x44234000}, {0x44236000}, {0x44238000}, {0x4423a000}, {0x4423c000}, {0x4423e000}, {0x44240000}, {0x44242000}, {0x44244000}, {0x44246000}, {0x44248000}, {0x4424a000}, {0x4424c000}, {0x4424e000}, {0x44250000}, {0x44252000}, {0x44254000}, {0x44256000}, {0x44258000}, {0x4425a000}, {0x4425c000}, {0x4425e000}, {0x44260000}, {0x44262000}, {0x44264000}, {0x44266000}, {0x44268000}, {0x4426a000}, {0x4426c000}, {0x4426e000}, {0x44270000}, {0x44272000}, {0x44274000}, {0x44276000}, {0x44278000}, {0x4427a000}, {0x4427c000}, {0x4427e000}, {0x44280000}, {0x44282000}, {0x44284000}, {0x44286000}, {0x44288000}, {0x4428a000}, {0x4428c000}, {0x4428e000}, {0x44290000}, {0x44292000}, {0x44294000}, {0x44296000}, {0x44298000}, {0x4429a000}, {0x4429c000}, {0x4429e000}, {0x442a0000}, {0x442a2000}, {0x442a4000}, {0x442a6000}, {0x442a8000}, {0x442aa000}, {0x442ac000}, {0x442ae000}, {0x442b0000}, {0x442b2000}, {0x442b4000}, {0x442b6000}, {0x442b8000}, {0x442ba000}, {0x442bc000}, {0x442be000}, {0x442c0000}, {0x442c2000}, {0x442c4000}, {0x442c6000}, {0x442c8000}, {0x442ca000}, {0x442cc000}, {0x442ce000}, {0x442d0000}, {0x442d2000}, {0x442d4000}, {0x442d6000}, {0x442d8000}, {0x442da000}, {0x442dc000}, {0x442de000}, {0x442e0000}, {0x442e2000}, {0x442e4000}, {0x442e6000}, {0x442e8000}, {0x442ea000}, {0x442ec000}, {0x442ee000}, {0x442f0000}, {0x442f2000}, {0x442f4000}, {0x442f6000}, {0x442f8000}, {0x442fa000}, {0x442fc000}, {0x442fe000}, {0x44300000}, {0x44302000}, {0x44304000}, {0x44306000}, {0x44308000}, {0x4430a000}, {0x4430c000}, {0x4430e000}, {0x44310000}, {0x44312000}, {0x44314000}, {0x44316000}, {0x44318000}, {0x4431a000}, {0x4431c000}, {0x4431e000}, {0x44320000}, {0x44322000}, {0x44324000}, {0x44326000}, {0x44328000}, {0x4432a000}, {0x4432c000}, {0x4432e000}, {0x44330000}, {0x44332000}, {0x44334000}, {0x44336000}, {0x44338000}, {0x4433a000}, {0x4433c000}, {0x4433e000}, {0x44340000}, {0x44342000}, {0x44344000}, {0x44346000}, {0x44348000}, {0x4434a000}, {0x4434c000}, {0x4434e000}, {0x44350000}, {0x44352000}, {0x44354000}, {0x44356000}, {0x44358000}, {0x4435a000}, {0x4435c000}, {0x4435e000}, {0x44360000}, {0x44362000}, {0x44364000}, {0x44366000}, {0x44368000}, {0x4436a000}, {0x4436c000}, {0x4436e000}, {0x44370000}, {0x44372000}, {0x44374000}, {0x44376000}, {0x44378000}, {0x4437a000}, {0x4437c000}, {0x4437e000}, {0x44380000}, {0x44382000}, {0x44384000}, {0x44386000}, {0x44388000}, {0x4438a000}, {0x4438c000}, {0x4438e000}, {0x44390000}, {0x44392000}, {0x44394000}, {0x44396000}, {0x44398000}, {0x4439a000}, {0x4439c000}, {0x4439e000}, {0x443a0000}, {0x443a2000}, {0x443a4000}, {0x443a6000}, {0x443a8000}, {0x443aa000}, {0x443ac000}, {0x443ae000}, {0x443b0000}, {0x443b2000}, {0x443b4000}, {0x443b6000}, {0x443b8000}, {0x443ba000}, {0x443bc000}, {0x443be000}, {0x443c0000}, {0x443c2000}, {0x443c4000}, {0x443c6000}, {0x443c8000}, {0x443ca000}, {0x443cc000}, {0x443ce000}, {0x443d0000}, {0x443d2000}, {0x443d4000}, {0x443d6000}, {0x443d8000}, {0x443da000}, {0x443dc000}, {0x443de000}, {0x443e0000}, {0x443e2000}, {0x443e4000}, {0x443e6000}, {0x443e8000}, {0x443ea000}, {0x443ec000}, {0x443ee000}, {0x443f0000}, {0x443f2000}, {0x443f4000}, {0x443f6000}, {0x443f8000}, {0x443fa000}, {0x443fc000}, {0x443fe000}, {0x44400000}, {0x44402000}, {0x44404000}, {0x44406000}, {0x44408000}, {0x4440a000}, {0x4440c000}, {0x4440e000}, {0x44410000}, {0x44412000}, {0x44414000}, {0x44416000}, {0x44418000}, {0x4441a000}, {0x4441c000}, {0x4441e000}, {0x44420000}, {0x44422000}, {0x44424000}, {0x44426000}, {0x44428000}, {0x4442a000}, {0x4442c000}, {0x4442e000}, {0x44430000}, {0x44432000}, {0x44434000}, {0x44436000}, {0x44438000}, {0x4443a000}, {0x4443c000}, {0x4443e000}, {0x44440000}, {0x44442000}, {0x44444000}, {0x44446000}, {0x44448000}, {0x4444a000}, {0x4444c000}, {0x4444e000}, {0x44450000}, {0x44452000}, {0x44454000}, {0x44456000}, {0x44458000}, {0x4445a000}, {0x4445c000}, {0x4445e000}, {0x44460000}, {0x44462000}, {0x44464000}, {0x44466000}, {0x44468000}, {0x4446a000}, {0x4446c000}, {0x4446e000}, {0x44470000}, {0x44472000}, {0x44474000}, {0x44476000}, {0x44478000}, {0x4447a000}, {0x4447c000}, {0x4447e000}, {0x44480000}, {0x44482000}, {0x44484000}, {0x44486000}, {0x44488000}, {0x4448a000}, {0x4448c000}, {0x4448e000}, {0x44490000}, {0x44492000}, {0x44494000}, {0x44496000}, {0x44498000}, {0x4449a000}, {0x4449c000}, {0x4449e000}, {0x444a0000}, {0x444a2000}, {0x444a4000}, {0x444a6000}, {0x444a8000}, {0x444aa000}, {0x444ac000}, {0x444ae000}, {0x444b0000}, {0x444b2000}, {0x444b4000}, {0x444b6000}, {0x444b8000}, {0x444ba000}, {0x444bc000}, {0x444be000}, {0x444c0000}, {0x444c2000}, {0x444c4000}, {0x444c6000}, {0x444c8000}, {0x444ca000}, {0x444cc000}, {0x444ce000}, {0x444d0000}, {0x444d2000}, {0x444d4000}, {0x444d6000}, {0x444d8000}, {0x444da000}, {0x444dc000}, {0x444de000}, {0x444e0000}, {0x444e2000}, {0x444e4000}, {0x444e6000}, {0x444e8000}, {0x444ea000}, {0x444ec000}, {0x444ee000}, {0x444f0000}, {0x444f2000}, {0x444f4000}, {0x444f6000}, {0x444f8000}, {0x444fa000}, {0x444fc000}, {0x444fe000}, {0x44500000}, {0x44502000}, {0x44504000}, {0x44506000}, {0x44508000}, {0x4450a000}, {0x4450c000}, {0x4450e000}, {0x44510000}, {0x44512000}, {0x44514000}, {0x44516000}, {0x44518000}, {0x4451a000}, {0x4451c000}, {0x4451e000}, {0x44520000}, {0x44522000}, {0x44524000}, {0x44526000}, {0x44528000}, {0x4452a000}, {0x4452c000}, {0x4452e000}, {0x44530000}, {0x44532000}, {0x44534000}, {0x44536000}, {0x44538000}, {0x4453a000}, {0x4453c000}, {0x4453e000}, {0x44540000}, {0x44542000}, {0x44544000}, {0x44546000}, {0x44548000}, {0x4454a000}, {0x4454c000}, {0x4454e000}, {0x44550000}, {0x44552000}, {0x44554000}, {0x44556000}, {0x44558000}, {0x4455a000}, {0x4455c000}, {0x4455e000}, {0x44560000}, {0x44562000}, {0x44564000}, {0x44566000}, {0x44568000}, {0x4456a000}, {0x4456c000}, {0x4456e000}, {0x44570000}, {0x44572000}, {0x44574000}, {0x44576000}, {0x44578000}, {0x4457a000}, {0x4457c000}, {0x4457e000}, {0x44580000}, {0x44582000}, {0x44584000}, {0x44586000}, {0x44588000}, {0x4458a000}, {0x4458c000}, {0x4458e000}, {0x44590000}, {0x44592000}, {0x44594000}, {0x44596000}, {0x44598000}, {0x4459a000}, {0x4459c000}, {0x4459e000}, {0x445a0000}, {0x445a2000}, {0x445a4000}, {0x445a6000}, {0x445a8000}, {0x445aa000}, {0x445ac000}, {0x445ae000}, {0x445b0000}, {0x445b2000}, {0x445b4000}, {0x445b6000}, {0x445b8000}, {0x445ba000}, {0x445bc000}, {0x445be000}, {0x445c0000}, {0x445c2000}, {0x445c4000}, {0x445c6000}, {0x445c8000}, {0x445ca000}, {0x445cc000}, {0x445ce000}, {0x445d0000}, {0x445d2000}, {0x445d4000}, {0x445d6000}, {0x445d8000}, {0x445da000}, {0x445dc000}, {0x445de000}, {0x445e0000}, {0x445e2000}, {0x445e4000}, {0x445e6000}, {0x445e8000}, {0x445ea000}, {0x445ec000}, {0x445ee000}, {0x445f0000}, {0x445f2000}, {0x445f4000}, {0x445f6000}, {0x445f8000}, {0x445fa000}, {0x445fc000}, {0x445fe000}, {0x44600000}, {0x44602000}, {0x44604000}, {0x44606000}, {0x44608000}, {0x4460a000}, {0x4460c000}, {0x4460e000}, {0x44610000}, {0x44612000}, {0x44614000}, {0x44616000}, {0x44618000}, {0x4461a000}, {0x4461c000}, {0x4461e000}, {0x44620000}, {0x44622000}, {0x44624000}, {0x44626000}, {0x44628000}, {0x4462a000}, {0x4462c000}, {0x4462e000}, {0x44630000}, {0x44632000}, {0x44634000}, {0x44636000}, {0x44638000}, {0x4463a000}, {0x4463c000}, {0x4463e000}, {0x44640000}, {0x44642000}, {0x44644000}, {0x44646000}, {0x44648000}, {0x4464a000}, {0x4464c000}, {0x4464e000}, {0x44650000}, {0x44652000}, {0x44654000}, {0x44656000}, {0x44658000}, {0x4465a000}, {0x4465c000}, {0x4465e000}, {0x44660000}, {0x44662000}, {0x44664000}, {0x44666000}, {0x44668000}, {0x4466a000}, {0x4466c000}, {0x4466e000}, {0x44670000}, {0x44672000}, {0x44674000}, {0x44676000}, {0x44678000}, {0x4467a000}, {0x4467c000}, {0x4467e000}, {0x44680000}, {0x44682000}, {0x44684000}, {0x44686000}, {0x44688000}, {0x4468a000}, {0x4468c000}, {0x4468e000}, {0x44690000}, {0x44692000}, {0x44694000}, {0x44696000}, {0x44698000}, {0x4469a000}, {0x4469c000}, {0x4469e000}, {0x446a0000}, {0x446a2000}, {0x446a4000}, {0x446a6000}, {0x446a8000}, {0x446aa000}, {0x446ac000}, {0x446ae000}, {0x446b0000}, {0x446b2000}, {0x446b4000}, {0x446b6000}, {0x446b8000}, {0x446ba000}, {0x446bc000}, {0x446be000}, {0x446c0000}, {0x446c2000}, {0x446c4000}, {0x446c6000}, {0x446c8000}, {0x446ca000}, {0x446cc000}, {0x446ce000}, {0x446d0000}, {0x446d2000}, {0x446d4000}, {0x446d6000}, {0x446d8000}, {0x446da000}, {0x446dc000}, {0x446de000}, {0x446e0000}, {0x446e2000}, {0x446e4000}, {0x446e6000}, {0x446e8000}, {0x446ea000}, {0x446ec000}, {0x446ee000}, {0x446f0000}, {0x446f2000}, {0x446f4000}, {0x446f6000}, {0x446f8000}, {0x446fa000}, {0x446fc000}, {0x446fe000}, {0x44700000}, {0x44702000}, {0x44704000}, {0x44706000}, {0x44708000}, {0x4470a000}, {0x4470c000}, {0x4470e000}, {0x44710000}, {0x44712000}, {0x44714000}, {0x44716000}, {0x44718000}, {0x4471a000}, {0x4471c000}, {0x4471e000}, {0x44720000}, {0x44722000}, {0x44724000}, {0x44726000}, {0x44728000}, {0x4472a000}, {0x4472c000}, {0x4472e000}, {0x44730000}, {0x44732000}, {0x44734000}, {0x44736000}, {0x44738000}, {0x4473a000}, {0x4473c000}, {0x4473e000}, {0x44740000}, {0x44742000}, {0x44744000}, {0x44746000}, {0x44748000}, {0x4474a000}, {0x4474c000}, {0x4474e000}, {0x44750000}, {0x44752000}, {0x44754000}, {0x44756000}, {0x44758000}, {0x4475a000}, {0x4475c000}, {0x4475e000}, {0x44760000}, {0x44762000}, {0x44764000}, {0x44766000}, {0x44768000}, {0x4476a000}, {0x4476c000}, {0x4476e000}, {0x44770000}, {0x44772000}, {0x44774000}, {0x44776000}, {0x44778000}, {0x4477a000}, {0x4477c000}, {0x4477e000}, {0x44780000}, {0x44782000}, {0x44784000}, {0x44786000}, {0x44788000}, {0x4478a000}, {0x4478c000}, {0x4478e000}, {0x44790000}, {0x44792000}, {0x44794000}, {0x44796000}, {0x44798000}, {0x4479a000}, {0x4479c000}, {0x4479e000}, {0x447a0000}, {0x447a2000}, {0x447a4000}, {0x447a6000}, {0x447a8000}, {0x447aa000}, {0x447ac000}, {0x447ae000}, {0x447b0000}, {0x447b2000}, {0x447b4000}, {0x447b6000}, {0x447b8000}, {0x447ba000}, {0x447bc000}, {0x447be000}, {0x447c0000}, {0x447c2000}, {0x447c4000}, {0x447c6000}, {0x447c8000}, {0x447ca000}, {0x447cc000}, {0x447ce000}, {0x447d0000}, {0x447d2000}, {0x447d4000}, {0x447d6000}, {0x447d8000}, {0x447da000}, {0x447dc000}, {0x447de000}, {0x447e0000}, {0x447e2000}, {0x447e4000}, {0x447e6000}, {0x447e8000}, {0x447ea000}, {0x447ec000}, {0x447ee000}, {0x447f0000}, {0x447f2000}, {0x447f4000}, {0x447f6000}, {0x447f8000}, {0x447fa000}, {0x447fc000}, {0x447fe000}, {0x44800000}, {0x44802000}, {0x44804000}, {0x44806000}, {0x44808000}, {0x4480a000}, {0x4480c000}, {0x4480e000}, {0x44810000}, {0x44812000}, {0x44814000}, {0x44816000}, {0x44818000}, {0x4481a000}, {0x4481c000}, {0x4481e000}, {0x44820000}, {0x44822000}, {0x44824000}, {0x44826000}, {0x44828000}, {0x4482a000}, {0x4482c000}, {0x4482e000}, {0x44830000}, {0x44832000}, {0x44834000}, {0x44836000}, {0x44838000}, {0x4483a000}, {0x4483c000}, {0x4483e000}, {0x44840000}, {0x44842000}, {0x44844000}, {0x44846000}, {0x44848000}, {0x4484a000}, {0x4484c000}, {0x4484e000}, {0x44850000}, {0x44852000}, {0x44854000}, {0x44856000}, {0x44858000}, {0x4485a000}, {0x4485c000}, {0x4485e000}, {0x44860000}, {0x44862000}, {0x44864000}, {0x44866000}, {0x44868000}, {0x4486a000}, {0x4486c000}, {0x4486e000}, {0x44870000}, {0x44872000}, {0x44874000}, {0x44876000}, {0x44878000}, {0x4487a000}, {0x4487c000}, {0x4487e000}, {0x44880000}, {0x44882000}, {0x44884000}, {0x44886000}, {0x44888000}, {0x4488a000}, {0x4488c000}, {0x4488e000}, {0x44890000}, {0x44892000}, {0x44894000}, {0x44896000}, {0x44898000}, {0x4489a000}, {0x4489c000}, {0x4489e000}, {0x448a0000}, {0x448a2000}, {0x448a4000}, {0x448a6000}, {0x448a8000}, {0x448aa000}, {0x448ac000}, {0x448ae000}, {0x448b0000}, {0x448b2000}, {0x448b4000}, {0x448b6000}, {0x448b8000}, {0x448ba000}, {0x448bc000}, {0x448be000}, {0x448c0000}, {0x448c2000}, {0x448c4000}, {0x448c6000}, {0x448c8000}, {0x448ca000}, {0x448cc000}, {0x448ce000}, {0x448d0000}, {0x448d2000}, {0x448d4000}, {0x448d6000}, {0x448d8000}, {0x448da000}, {0x448dc000}, {0x448de000}, {0x448e0000}, {0x448e2000}, {0x448e4000}, {0x448e6000}, {0x448e8000}, {0x448ea000}, {0x448ec000}, {0x448ee000}, {0x448f0000}, {0x448f2000}, {0x448f4000}, {0x448f6000}, {0x448f8000}, {0x448fa000}, {0x448fc000}, {0x448fe000}, {0x44900000}, {0x44902000}, {0x44904000}, {0x44906000}, {0x44908000}, {0x4490a000}, {0x4490c000}, {0x4490e000}, {0x44910000}, {0x44912000}, {0x44914000}, {0x44916000}, {0x44918000}, {0x4491a000}, {0x4491c000}, {0x4491e000}, {0x44920000}, {0x44922000}, {0x44924000}, {0x44926000}, {0x44928000}, {0x4492a000}, {0x4492c000}, {0x4492e000}, {0x44930000}, {0x44932000}, {0x44934000}, {0x44936000}, {0x44938000}, {0x4493a000}, {0x4493c000}, {0x4493e000}, {0x44940000}, {0x44942000}, {0x44944000}, {0x44946000}, {0x44948000}, {0x4494a000}, {0x4494c000}, {0x4494e000}, {0x44950000}, {0x44952000}, {0x44954000}, {0x44956000}, {0x44958000}, {0x4495a000}, {0x4495c000}, {0x4495e000}, {0x44960000}, {0x44962000}, {0x44964000}, {0x44966000}, {0x44968000}, {0x4496a000}, {0x4496c000}, {0x4496e000}, {0x44970000}, {0x44972000}, {0x44974000}, {0x44976000}, {0x44978000}, {0x4497a000}, {0x4497c000}, {0x4497e000}, {0x44980000}, {0x44982000}, {0x44984000}, {0x44986000}, {0x44988000}, {0x4498a000}, {0x4498c000}, {0x4498e000}, {0x44990000}, {0x44992000}, {0x44994000}, {0x44996000}, {0x44998000}, {0x4499a000}, {0x4499c000}, {0x4499e000}, {0x449a0000}, {0x449a2000}, {0x449a4000}, {0x449a6000}, {0x449a8000}, {0x449aa000}, {0x449ac000}, {0x449ae000}, {0x449b0000}, {0x449b2000}, {0x449b4000}, {0x449b6000}, {0x449b8000}, {0x449ba000}, {0x449bc000}, {0x449be000}, {0x449c0000}, {0x449c2000}, {0x449c4000}, {0x449c6000}, {0x449c8000}, {0x449ca000}, {0x449cc000}, {0x449ce000}, {0x449d0000}, {0x449d2000}, {0x449d4000}, {0x449d6000}, {0x449d8000}, {0x449da000}, {0x449dc000}, {0x449de000}, {0x449e0000}, {0x449e2000}, {0x449e4000}, {0x449e6000}, {0x449e8000}, {0x449ea000}, {0x449ec000}, {0x449ee000}, {0x449f0000}, {0x449f2000}, {0x449f4000}, {0x449f6000}, {0x449f8000}, {0x449fa000}, {0x449fc000}, {0x449fe000}, {0x44a00000}, {0x44a02000}, {0x44a04000}, {0x44a06000}, {0x44a08000}, {0x44a0a000}, {0x44a0c000}, {0x44a0e000}, {0x44a10000}, {0x44a12000}, {0x44a14000}, {0x44a16000}, {0x44a18000}, {0x44a1a000}, {0x44a1c000}, {0x44a1e000}, {0x44a20000}, {0x44a22000}, {0x44a24000}, {0x44a26000}, {0x44a28000}, {0x44a2a000}, {0x44a2c000}, {0x44a2e000}, {0x44a30000}, {0x44a32000}, {0x44a34000}, {0x44a36000}, {0x44a38000}, {0x44a3a000}, {0x44a3c000}, {0x44a3e000}, {0x44a40000}, {0x44a42000}, {0x44a44000}, {0x44a46000}, {0x44a48000}, {0x44a4a000}, {0x44a4c000}, {0x44a4e000}, {0x44a50000}, {0x44a52000}, {0x44a54000}, {0x44a56000}, {0x44a58000}, {0x44a5a000}, {0x44a5c000}, {0x44a5e000}, {0x44a60000}, {0x44a62000}, {0x44a64000}, {0x44a66000}, {0x44a68000}, {0x44a6a000}, {0x44a6c000}, {0x44a6e000}, {0x44a70000}, {0x44a72000}, {0x44a74000}, {0x44a76000}, {0x44a78000}, {0x44a7a000}, {0x44a7c000}, {0x44a7e000}, {0x44a80000}, {0x44a82000}, {0x44a84000}, {0x44a86000}, {0x44a88000}, {0x44a8a000}, {0x44a8c000}, {0x44a8e000}, {0x44a90000}, {0x44a92000}, {0x44a94000}, {0x44a96000}, {0x44a98000}, {0x44a9a000}, {0x44a9c000}, {0x44a9e000}, {0x44aa0000}, {0x44aa2000}, {0x44aa4000}, {0x44aa6000}, {0x44aa8000}, {0x44aaa000}, {0x44aac000}, {0x44aae000}, {0x44ab0000}, {0x44ab2000}, {0x44ab4000}, {0x44ab6000}, {0x44ab8000}, {0x44aba000}, {0x44abc000}, {0x44abe000}, {0x44ac0000}, {0x44ac2000}, {0x44ac4000}, {0x44ac6000}, {0x44ac8000}, {0x44aca000}, {0x44acc000}, {0x44ace000}, {0x44ad0000}, {0x44ad2000}, {0x44ad4000}, {0x44ad6000}, {0x44ad8000}, {0x44ada000}, {0x44adc000}, {0x44ade000}, {0x44ae0000}, {0x44ae2000}, {0x44ae4000}, {0x44ae6000}, {0x44ae8000}, {0x44aea000}, {0x44aec000}, {0x44aee000}, {0x44af0000}, {0x44af2000}, {0x44af4000}, {0x44af6000}, {0x44af8000}, {0x44afa000}, {0x44afc000}, {0x44afe000}, {0x44b00000}, {0x44b02000}, {0x44b04000}, {0x44b06000}, {0x44b08000}, {0x44b0a000}, {0x44b0c000}, {0x44b0e000}, {0x44b10000}, {0x44b12000}, {0x44b14000}, {0x44b16000}, {0x44b18000}, {0x44b1a000}, {0x44b1c000}, {0x44b1e000}, {0x44b20000}, {0x44b22000}, {0x44b24000}, {0x44b26000}, {0x44b28000}, {0x44b2a000}, {0x44b2c000}, {0x44b2e000}, {0x44b30000}, {0x44b32000}, {0x44b34000}, {0x44b36000}, {0x44b38000}, {0x44b3a000}, {0x44b3c000}, {0x44b3e000}, {0x44b40000}, {0x44b42000}, {0x44b44000}, {0x44b46000}, {0x44b48000}, {0x44b4a000}, {0x44b4c000}, {0x44b4e000}, {0x44b50000}, {0x44b52000}, {0x44b54000}, {0x44b56000}, {0x44b58000}, {0x44b5a000}, {0x44b5c000}, {0x44b5e000}, {0x44b60000}, {0x44b62000}, {0x44b64000}, {0x44b66000}, {0x44b68000}, {0x44b6a000}, {0x44b6c000}, {0x44b6e000}, {0x44b70000}, {0x44b72000}, {0x44b74000}, {0x44b76000}, {0x44b78000}, {0x44b7a000}, {0x44b7c000}, {0x44b7e000}, {0x44b80000}, {0x44b82000}, {0x44b84000}, {0x44b86000}, {0x44b88000}, {0x44b8a000}, {0x44b8c000}, {0x44b8e000}, {0x44b90000}, {0x44b92000}, {0x44b94000}, {0x44b96000}, {0x44b98000}, {0x44b9a000}, {0x44b9c000}, {0x44b9e000}, {0x44ba0000}, {0x44ba2000}, {0x44ba4000}, {0x44ba6000}, {0x44ba8000}, {0x44baa000}, {0x44bac000}, {0x44bae000}, {0x44bb0000}, {0x44bb2000}, {0x44bb4000}, {0x44bb6000}, {0x44bb8000}, {0x44bba000}, {0x44bbc000}, {0x44bbe000}, {0x44bc0000}, {0x44bc2000}, {0x44bc4000}, {0x44bc6000}, {0x44bc8000}, {0x44bca000}, {0x44bcc000}, {0x44bce000}, {0x44bd0000}, {0x44bd2000}, {0x44bd4000}, {0x44bd6000}, {0x44bd8000}, {0x44bda000}, {0x44bdc000}, {0x44bde000}, {0x44be0000}, {0x44be2000}, {0x44be4000}, {0x44be6000}, {0x44be8000}, {0x44bea000}, {0x44bec000}, {0x44bee000}, {0x44bf0000}, {0x44bf2000}, {0x44bf4000}, {0x44bf6000}, {0x44bf8000}, {0x44bfa000}, {0x44bfc000}, {0x44bfe000}, {0x44c00000}, {0x44c02000}, {0x44c04000}, {0x44c06000}, {0x44c08000}, {0x44c0a000}, {0x44c0c000}, {0x44c0e000}, {0x44c10000}, {0x44c12000}, {0x44c14000}, {0x44c16000}, {0x44c18000}, {0x44c1a000}, {0x44c1c000}, {0x44c1e000}, {0x44c20000}, {0x44c22000}, {0x44c24000}, {0x44c26000}, {0x44c28000}, {0x44c2a000}, {0x44c2c000}, {0x44c2e000}, {0x44c30000}, {0x44c32000}, {0x44c34000}, {0x44c36000}, {0x44c38000}, {0x44c3a000}, {0x44c3c000}, {0x44c3e000}, {0x44c40000}, {0x44c42000}, {0x44c44000}, {0x44c46000}, {0x44c48000}, {0x44c4a000}, {0x44c4c000}, {0x44c4e000}, {0x44c50000}, {0x44c52000}, {0x44c54000}, {0x44c56000}, {0x44c58000}, {0x44c5a000}, {0x44c5c000}, {0x44c5e000}, {0x44c60000}, {0x44c62000}, {0x44c64000}, {0x44c66000}, {0x44c68000}, {0x44c6a000}, {0x44c6c000}, {0x44c6e000}, {0x44c70000}, {0x44c72000}, {0x44c74000}, {0x44c76000}, {0x44c78000}, {0x44c7a000}, {0x44c7c000}, {0x44c7e000}, {0x44c80000}, {0x44c82000}, {0x44c84000}, {0x44c86000}, {0x44c88000}, {0x44c8a000}, {0x44c8c000}, {0x44c8e000}, {0x44c90000}, {0x44c92000}, {0x44c94000}, {0x44c96000}, {0x44c98000}, {0x44c9a000}, {0x44c9c000}, {0x44c9e000}, {0x44ca0000}, {0x44ca2000}, {0x44ca4000}, {0x44ca6000}, {0x44ca8000}, {0x44caa000}, {0x44cac000}, {0x44cae000}, {0x44cb0000}, {0x44cb2000}, {0x44cb4000}, {0x44cb6000}, {0x44cb8000}, {0x44cba000}, {0x44cbc000}, {0x44cbe000}, {0x44cc0000}, {0x44cc2000}, {0x44cc4000}, {0x44cc6000}, {0x44cc8000}, {0x44cca000}, {0x44ccc000}, {0x44cce000}, {0x44cd0000}, {0x44cd2000}, {0x44cd4000}, {0x44cd6000}, {0x44cd8000}, {0x44cda000}, {0x44cdc000}, {0x44cde000}, {0x44ce0000}, {0x44ce2000}, {0x44ce4000}, {0x44ce6000}, {0x44ce8000}, {0x44cea000}, {0x44cec000}, {0x44cee000}, {0x44cf0000}, {0x44cf2000}, {0x44cf4000}, {0x44cf6000}, {0x44cf8000}, {0x44cfa000}, {0x44cfc000}, {0x44cfe000}, {0x44d00000}, {0x44d02000}, {0x44d04000}, {0x44d06000}, {0x44d08000}, {0x44d0a000}, {0x44d0c000}, {0x44d0e000}, {0x44d10000}, {0x44d12000}, {0x44d14000}, {0x44d16000}, {0x44d18000}, {0x44d1a000}, {0x44d1c000}, {0x44d1e000}, {0x44d20000}, {0x44d22000}, {0x44d24000}, {0x44d26000}, {0x44d28000}, {0x44d2a000}, {0x44d2c000}, {0x44d2e000}, {0x44d30000}, {0x44d32000}, {0x44d34000}, {0x44d36000}, {0x44d38000}, {0x44d3a000}, {0x44d3c000}, {0x44d3e000}, {0x44d40000}, {0x44d42000}, {0x44d44000}, {0x44d46000}, {0x44d48000}, {0x44d4a000}, {0x44d4c000}, {0x44d4e000}, {0x44d50000}, {0x44d52000}, {0x44d54000}, {0x44d56000}, {0x44d58000}, {0x44d5a000}, {0x44d5c000}, {0x44d5e000}, {0x44d60000}, {0x44d62000}, {0x44d64000}, {0x44d66000}, {0x44d68000}, {0x44d6a000}, {0x44d6c000}, {0x44d6e000}, {0x44d70000}, {0x44d72000}, {0x44d74000}, {0x44d76000}, {0x44d78000}, {0x44d7a000}, {0x44d7c000}, {0x44d7e000}, {0x44d80000}, {0x44d82000}, {0x44d84000}, {0x44d86000}, {0x44d88000}, {0x44d8a000}, {0x44d8c000}, {0x44d8e000}, {0x44d90000}, {0x44d92000}, {0x44d94000}, {0x44d96000}, {0x44d98000}, {0x44d9a000}, {0x44d9c000}, {0x44d9e000}, {0x44da0000}, {0x44da2000}, {0x44da4000}, {0x44da6000}, {0x44da8000}, {0x44daa000}, {0x44dac000}, {0x44dae000}, {0x44db0000}, {0x44db2000}, {0x44db4000}, {0x44db6000}, {0x44db8000}, {0x44dba000}, {0x44dbc000}, {0x44dbe000}, {0x44dc0000}, {0x44dc2000}, {0x44dc4000}, {0x44dc6000}, {0x44dc8000}, {0x44dca000}, {0x44dcc000}, {0x44dce000}, {0x44dd0000}, {0x44dd2000}, {0x44dd4000}, {0x44dd6000}, {0x44dd8000}, {0x44dda000}, {0x44ddc000}, {0x44dde000}, {0x44de0000}, {0x44de2000}, {0x44de4000}, {0x44de6000}, {0x44de8000}, {0x44dea000}, {0x44dec000}, {0x44dee000}, {0x44df0000}, {0x44df2000}, {0x44df4000}, {0x44df6000}, {0x44df8000}, {0x44dfa000}, {0x44dfc000}, {0x44dfe000}, {0x44e00000}, {0x44e02000}, {0x44e04000}, {0x44e06000}, {0x44e08000}, {0x44e0a000}, {0x44e0c000}, {0x44e0e000}, {0x44e10000}, {0x44e12000}, {0x44e14000}, {0x44e16000}, {0x44e18000}, {0x44e1a000}, {0x44e1c000}, {0x44e1e000}, {0x44e20000}, {0x44e22000}, {0x44e24000}, {0x44e26000}, {0x44e28000}, {0x44e2a000}, {0x44e2c000}, {0x44e2e000}, {0x44e30000}, {0x44e32000}, {0x44e34000}, {0x44e36000}, {0x44e38000}, {0x44e3a000}, {0x44e3c000}, {0x44e3e000}, {0x44e40000}, {0x44e42000}, {0x44e44000}, {0x44e46000}, {0x44e48000}, {0x44e4a000}, {0x44e4c000}, {0x44e4e000}, {0x44e50000}, {0x44e52000}, {0x44e54000}, {0x44e56000}, {0x44e58000}, {0x44e5a000}, {0x44e5c000}, {0x44e5e000}, {0x44e60000}, {0x44e62000}, {0x44e64000}, {0x44e66000}, {0x44e68000}, {0x44e6a000}, {0x44e6c000}, {0x44e6e000}, {0x44e70000}, {0x44e72000}, {0x44e74000}, {0x44e76000}, {0x44e78000}, {0x44e7a000}, {0x44e7c000}, {0x44e7e000}, {0x44e80000}, {0x44e82000}, {0x44e84000}, {0x44e86000}, {0x44e88000}, {0x44e8a000}, {0x44e8c000}, {0x44e8e000}, {0x44e90000}, {0x44e92000}, {0x44e94000}, {0x44e96000}, {0x44e98000}, {0x44e9a000}, {0x44e9c000}, {0x44e9e000}, {0x44ea0000}, {0x44ea2000}, {0x44ea4000}, {0x44ea6000}, {0x44ea8000}, {0x44eaa000}, {0x44eac000}, {0x44eae000}, {0x44eb0000}, {0x44eb2000}, {0x44eb4000}, {0x44eb6000}, {0x44eb8000}, {0x44eba000}, {0x44ebc000}, {0x44ebe000}, {0x44ec0000}, {0x44ec2000}, {0x44ec4000}, {0x44ec6000}, {0x44ec8000}, {0x44eca000}, {0x44ecc000}, {0x44ece000}, {0x44ed0000}, {0x44ed2000}, {0x44ed4000}, {0x44ed6000}, {0x44ed8000}, {0x44eda000}, {0x44edc000}, {0x44ede000}, {0x44ee0000}, {0x44ee2000}, {0x44ee4000}, {0x44ee6000}, {0x44ee8000}, {0x44eea000}, {0x44eec000}, {0x44eee000}, {0x44ef0000}, {0x44ef2000}, {0x44ef4000}, {0x44ef6000}, {0x44ef8000}, {0x44efa000}, {0x44efc000}, {0x44efe000}, {0x44f00000}, {0x44f02000}, {0x44f04000}, {0x44f06000}, {0x44f08000}, {0x44f0a000}, {0x44f0c000}, {0x44f0e000}, {0x44f10000}, {0x44f12000}, {0x44f14000}, {0x44f16000}, {0x44f18000}, {0x44f1a000}, {0x44f1c000}, {0x44f1e000}, {0x44f20000}, {0x44f22000}, {0x44f24000}, {0x44f26000}, {0x44f28000}, {0x44f2a000}, {0x44f2c000}, {0x44f2e000}, {0x44f30000}, {0x44f32000}, {0x44f34000}, {0x44f36000}, {0x44f38000}, {0x44f3a000}, {0x44f3c000}, {0x44f3e000}, {0x44f40000}, {0x44f42000}, {0x44f44000}, {0x44f46000}, {0x44f48000}, {0x44f4a000}, {0x44f4c000}, {0x44f4e000}, {0x44f50000}, {0x44f52000}, {0x44f54000}, {0x44f56000}, {0x44f58000}, {0x44f5a000}, {0x44f5c000}, {0x44f5e000}, {0x44f60000}, {0x44f62000}, {0x44f64000}, {0x44f66000}, {0x44f68000}, {0x44f6a000}, {0x44f6c000}, {0x44f6e000}, {0x44f70000}, {0x44f72000}, {0x44f74000}, {0x44f76000}, {0x44f78000}, {0x44f7a000}, {0x44f7c000}, {0x44f7e000}, {0x44f80000}, {0x44f82000}, {0x44f84000}, {0x44f86000}, {0x44f88000}, {0x44f8a000}, {0x44f8c000}, {0x44f8e000}, {0x44f90000}, {0x44f92000}, {0x44f94000}, {0x44f96000}, {0x44f98000}, {0x44f9a000}, {0x44f9c000}, {0x44f9e000}, {0x44fa0000}, {0x44fa2000}, {0x44fa4000}, {0x44fa6000}, {0x44fa8000}, {0x44faa000}, {0x44fac000}, {0x44fae000}, {0x44fb0000}, {0x44fb2000}, {0x44fb4000}, {0x44fb6000}, {0x44fb8000}, {0x44fba000}, {0x44fbc000}, {0x44fbe000}, {0x44fc0000}, {0x44fc2000}, {0x44fc4000}, {0x44fc6000}, {0x44fc8000}, {0x44fca000}, {0x44fcc000}, {0x44fce000}, {0x44fd0000}, {0x44fd2000}, {0x44fd4000}, {0x44fd6000}, {0x44fd8000}, {0x44fda000}, {0x44fdc000}, {0x44fde000}, {0x44fe0000}, {0x44fe2000}, {0x44fe4000}, {0x44fe6000}, {0x44fe8000}, {0x44fea000}, {0x44fec000}, {0x44fee000}, {0x44ff0000}, {0x44ff2000}, {0x44ff4000}, {0x44ff6000}, {0x44ff8000}, {0x44ffa000}, {0x44ffc000}, {0x44ffe000}, {0x45000000}, {0x45002000}, {0x45004000}, {0x45006000}, {0x45008000}, {0x4500a000}, {0x4500c000}, {0x4500e000}, {0x45010000}, {0x45012000}, {0x45014000}, {0x45016000}, {0x45018000}, {0x4501a000}, {0x4501c000}, {0x4501e000}, {0x45020000}, {0x45022000}, {0x45024000}, {0x45026000}, {0x45028000}, {0x4502a000}, {0x4502c000}, {0x4502e000}, {0x45030000}, {0x45032000}, {0x45034000}, {0x45036000}, {0x45038000}, {0x4503a000}, {0x4503c000}, {0x4503e000}, {0x45040000}, {0x45042000}, {0x45044000}, {0x45046000}, {0x45048000}, {0x4504a000}, {0x4504c000}, {0x4504e000}, {0x45050000}, {0x45052000}, {0x45054000}, {0x45056000}, {0x45058000}, {0x4505a000}, {0x4505c000}, {0x4505e000}, {0x45060000}, {0x45062000}, {0x45064000}, {0x45066000}, {0x45068000}, {0x4506a000}, {0x4506c000}, {0x4506e000}, {0x45070000}, {0x45072000}, {0x45074000}, {0x45076000}, {0x45078000}, {0x4507a000}, {0x4507c000}, {0x4507e000}, {0x45080000}, {0x45082000}, {0x45084000}, {0x45086000}, {0x45088000}, {0x4508a000}, {0x4508c000}, {0x4508e000}, {0x45090000}, {0x45092000}, {0x45094000}, {0x45096000}, {0x45098000}, {0x4509a000}, {0x4509c000}, {0x4509e000}, {0x450a0000}, {0x450a2000}, {0x450a4000}, {0x450a6000}, {0x450a8000}, {0x450aa000}, {0x450ac000}, {0x450ae000}, {0x450b0000}, {0x450b2000}, {0x450b4000}, {0x450b6000}, {0x450b8000}, {0x450ba000}, {0x450bc000}, {0x450be000}, {0x450c0000}, {0x450c2000}, {0x450c4000}, {0x450c6000}, {0x450c8000}, {0x450ca000}, {0x450cc000}, {0x450ce000}, {0x450d0000}, {0x450d2000}, {0x450d4000}, {0x450d6000}, {0x450d8000}, {0x450da000}, {0x450dc000}, {0x450de000}, {0x450e0000}, {0x450e2000}, {0x450e4000}, {0x450e6000}, {0x450e8000}, {0x450ea000}, {0x450ec000}, {0x450ee000}, {0x450f0000}, {0x450f2000}, {0x450f4000}, {0x450f6000}, {0x450f8000}, {0x450fa000}, {0x450fc000}, {0x450fe000}, {0x45100000}, {0x45102000}, {0x45104000}, {0x45106000}, {0x45108000}, {0x4510a000}, {0x4510c000}, {0x4510e000}, {0x45110000}, {0x45112000}, {0x45114000}, {0x45116000}, {0x45118000}, {0x4511a000}, {0x4511c000}, {0x4511e000}, {0x45120000}, {0x45122000}, {0x45124000}, {0x45126000}, {0x45128000}, {0x4512a000}, {0x4512c000}, {0x4512e000}, {0x45130000}, {0x45132000}, {0x45134000}, {0x45136000}, {0x45138000}, {0x4513a000}, {0x4513c000}, {0x4513e000}, {0x45140000}, {0x45142000}, {0x45144000}, {0x45146000}, {0x45148000}, {0x4514a000}, {0x4514c000}, {0x4514e000}, {0x45150000}, {0x45152000}, {0x45154000}, {0x45156000}, {0x45158000}, {0x4515a000}, {0x4515c000}, {0x4515e000}, {0x45160000}, {0x45162000}, {0x45164000}, {0x45166000}, {0x45168000}, {0x4516a000}, {0x4516c000}, {0x4516e000}, {0x45170000}, {0x45172000}, {0x45174000}, {0x45176000}, {0x45178000}, {0x4517a000}, {0x4517c000}, {0x4517e000}, {0x45180000}, {0x45182000}, {0x45184000}, {0x45186000}, {0x45188000}, {0x4518a000}, {0x4518c000}, {0x4518e000}, {0x45190000}, {0x45192000}, {0x45194000}, {0x45196000}, {0x45198000}, {0x4519a000}, {0x4519c000}, {0x4519e000}, {0x451a0000}, {0x451a2000}, {0x451a4000}, {0x451a6000}, {0x451a8000}, {0x451aa000}, {0x451ac000}, {0x451ae000}, {0x451b0000}, {0x451b2000}, {0x451b4000}, {0x451b6000}, {0x451b8000}, {0x451ba000}, {0x451bc000}, {0x451be000}, {0x451c0000}, {0x451c2000}, {0x451c4000}, {0x451c6000}, {0x451c8000}, {0x451ca000}, {0x451cc000}, {0x451ce000}, {0x451d0000}, {0x451d2000}, {0x451d4000}, {0x451d6000}, {0x451d8000}, {0x451da000}, {0x451dc000}, {0x451de000}, {0x451e0000}, {0x451e2000}, {0x451e4000}, {0x451e6000}, {0x451e8000}, {0x451ea000}, {0x451ec000}, {0x451ee000}, {0x451f0000}, {0x451f2000}, {0x451f4000}, {0x451f6000}, {0x451f8000}, {0x451fa000}, {0x451fc000}, {0x451fe000}, {0x45200000}, {0x45202000}, {0x45204000}, {0x45206000}, {0x45208000}, {0x4520a000}, {0x4520c000}, {0x4520e000}, {0x45210000}, {0x45212000}, {0x45214000}, {0x45216000}, {0x45218000}, {0x4521a000}, {0x4521c000}, {0x4521e000}, {0x45220000}, {0x45222000}, {0x45224000}, {0x45226000}, {0x45228000}, {0x4522a000}, {0x4522c000}, {0x4522e000}, {0x45230000}, {0x45232000}, {0x45234000}, {0x45236000}, {0x45238000}, {0x4523a000}, {0x4523c000}, {0x4523e000}, {0x45240000}, {0x45242000}, {0x45244000}, {0x45246000}, {0x45248000}, {0x4524a000}, {0x4524c000}, {0x4524e000}, {0x45250000}, {0x45252000}, {0x45254000}, {0x45256000}, {0x45258000}, {0x4525a000}, {0x4525c000}, {0x4525e000}, {0x45260000}, {0x45262000}, {0x45264000}, {0x45266000}, {0x45268000}, {0x4526a000}, {0x4526c000}, {0x4526e000}, {0x45270000}, {0x45272000}, {0x45274000}, {0x45276000}, {0x45278000}, {0x4527a000}, {0x4527c000}, {0x4527e000}, {0x45280000}, {0x45282000}, {0x45284000}, {0x45286000}, {0x45288000}, {0x4528a000}, {0x4528c000}, {0x4528e000}, {0x45290000}, {0x45292000}, {0x45294000}, {0x45296000}, {0x45298000}, {0x4529a000}, {0x4529c000}, {0x4529e000}, {0x452a0000}, {0x452a2000}, {0x452a4000}, {0x452a6000}, {0x452a8000}, {0x452aa000}, {0x452ac000}, {0x452ae000}, {0x452b0000}, {0x452b2000}, {0x452b4000}, {0x452b6000}, {0x452b8000}, {0x452ba000}, {0x452bc000}, {0x452be000}, {0x452c0000}, {0x452c2000}, {0x452c4000}, {0x452c6000}, {0x452c8000}, {0x452ca000}, {0x452cc000}, {0x452ce000}, {0x452d0000}, {0x452d2000}, {0x452d4000}, {0x452d6000}, {0x452d8000}, {0x452da000}, {0x452dc000}, {0x452de000}, {0x452e0000}, {0x452e2000}, {0x452e4000}, {0x452e6000}, {0x452e8000}, {0x452ea000}, {0x452ec000}, {0x452ee000}, {0x452f0000}, {0x452f2000}, {0x452f4000}, {0x452f6000}, {0x452f8000}, {0x452fa000}, {0x452fc000}, {0x452fe000}, {0x45300000}, {0x45302000}, {0x45304000}, {0x45306000}, {0x45308000}, {0x4530a000}, {0x4530c000}, {0x4530e000}, {0x45310000}, {0x45312000}, {0x45314000}, {0x45316000}, {0x45318000}, {0x4531a000}, {0x4531c000}, {0x4531e000}, {0x45320000}, {0x45322000}, {0x45324000}, {0x45326000}, {0x45328000}, {0x4532a000}, {0x4532c000}, {0x4532e000}, {0x45330000}, {0x45332000}, {0x45334000}, {0x45336000}, {0x45338000}, {0x4533a000}, {0x4533c000}, {0x4533e000}, {0x45340000}, {0x45342000}, {0x45344000}, {0x45346000}, {0x45348000}, {0x4534a000}, {0x4534c000}, {0x4534e000}, {0x45350000}, {0x45352000}, {0x45354000}, {0x45356000}, {0x45358000}, {0x4535a000}, {0x4535c000}, {0x4535e000}, {0x45360000}, {0x45362000}, {0x45364000}, {0x45366000}, {0x45368000}, {0x4536a000}, {0x4536c000}, {0x4536e000}, {0x45370000}, {0x45372000}, {0x45374000}, {0x45376000}, {0x45378000}, {0x4537a000}, {0x4537c000}, {0x4537e000}, {0x45380000}, {0x45382000}, {0x45384000}, {0x45386000}, {0x45388000}, {0x4538a000}, {0x4538c000}, {0x4538e000}, {0x45390000}, {0x45392000}, {0x45394000}, {0x45396000}, {0x45398000}, {0x4539a000}, {0x4539c000}, {0x4539e000}, {0x453a0000}, {0x453a2000}, {0x453a4000}, {0x453a6000}, {0x453a8000}, {0x453aa000}, {0x453ac000}, {0x453ae000}, {0x453b0000}, {0x453b2000}, {0x453b4000}, {0x453b6000}, {0x453b8000}, {0x453ba000}, {0x453bc000}, {0x453be000}, {0x453c0000}, {0x453c2000}, {0x453c4000}, {0x453c6000}, {0x453c8000}, {0x453ca000}, {0x453cc000}, {0x453ce000}, {0x453d0000}, {0x453d2000}, {0x453d4000}, {0x453d6000}, {0x453d8000}, {0x453da000}, {0x453dc000}, {0x453de000}, {0x453e0000}, {0x453e2000}, {0x453e4000}, {0x453e6000}, {0x453e8000}, {0x453ea000}, {0x453ec000}, {0x453ee000}, {0x453f0000}, {0x453f2000}, {0x453f4000}, {0x453f6000}, {0x453f8000}, {0x453fa000}, {0x453fc000}, {0x453fe000}, {0x45400000}, {0x45402000}, {0x45404000}, {0x45406000}, {0x45408000}, {0x4540a000}, {0x4540c000}, {0x4540e000}, {0x45410000}, {0x45412000}, {0x45414000}, {0x45416000}, {0x45418000}, {0x4541a000}, {0x4541c000}, {0x4541e000}, {0x45420000}, {0x45422000}, {0x45424000}, {0x45426000}, {0x45428000}, {0x4542a000}, {0x4542c000}, {0x4542e000}, {0x45430000}, {0x45432000}, {0x45434000}, {0x45436000}, {0x45438000}, {0x4543a000}, {0x4543c000}, {0x4543e000}, {0x45440000}, {0x45442000}, {0x45444000}, {0x45446000}, {0x45448000}, {0x4544a000}, {0x4544c000}, {0x4544e000}, {0x45450000}, {0x45452000}, {0x45454000}, {0x45456000}, {0x45458000}, {0x4545a000}, {0x4545c000}, {0x4545e000}, {0x45460000}, {0x45462000}, {0x45464000}, {0x45466000}, {0x45468000}, {0x4546a000}, {0x4546c000}, {0x4546e000}, {0x45470000}, {0x45472000}, {0x45474000}, {0x45476000}, {0x45478000}, {0x4547a000}, {0x4547c000}, {0x4547e000}, {0x45480000}, {0x45482000}, {0x45484000}, {0x45486000}, {0x45488000}, {0x4548a000}, {0x4548c000}, {0x4548e000}, {0x45490000}, {0x45492000}, {0x45494000}, {0x45496000}, {0x45498000}, {0x4549a000}, {0x4549c000}, {0x4549e000}, {0x454a0000}, {0x454a2000}, {0x454a4000}, {0x454a6000}, {0x454a8000}, {0x454aa000}, {0x454ac000}, {0x454ae000}, {0x454b0000}, {0x454b2000}, {0x454b4000}, {0x454b6000}, {0x454b8000}, {0x454ba000}, {0x454bc000}, {0x454be000}, {0x454c0000}, {0x454c2000}, {0x454c4000}, {0x454c6000}, {0x454c8000}, {0x454ca000}, {0x454cc000}, {0x454ce000}, {0x454d0000}, {0x454d2000}, {0x454d4000}, {0x454d6000}, {0x454d8000}, {0x454da000}, {0x454dc000}, {0x454de000}, {0x454e0000}, {0x454e2000}, {0x454e4000}, {0x454e6000}, {0x454e8000}, {0x454ea000}, {0x454ec000}, {0x454ee000}, {0x454f0000}, {0x454f2000}, {0x454f4000}, {0x454f6000}, {0x454f8000}, {0x454fa000}, {0x454fc000}, {0x454fe000}, {0x45500000}, {0x45502000}, {0x45504000}, {0x45506000}, {0x45508000}, {0x4550a000}, {0x4550c000}, {0x4550e000}, {0x45510000}, {0x45512000}, {0x45514000}, {0x45516000}, {0x45518000}, {0x4551a000}, {0x4551c000}, {0x4551e000}, {0x45520000}, {0x45522000}, {0x45524000}, {0x45526000}, {0x45528000}, {0x4552a000}, {0x4552c000}, {0x4552e000}, {0x45530000}, {0x45532000}, {0x45534000}, {0x45536000}, {0x45538000}, {0x4553a000}, {0x4553c000}, {0x4553e000}, {0x45540000}, {0x45542000}, {0x45544000}, {0x45546000}, {0x45548000}, {0x4554a000}, {0x4554c000}, {0x4554e000}, {0x45550000}, {0x45552000}, {0x45554000}, {0x45556000}, {0x45558000}, {0x4555a000}, {0x4555c000}, {0x4555e000}, {0x45560000}, {0x45562000}, {0x45564000}, {0x45566000}, {0x45568000}, {0x4556a000}, {0x4556c000}, {0x4556e000}, {0x45570000}, {0x45572000}, {0x45574000}, {0x45576000}, {0x45578000}, {0x4557a000}, {0x4557c000}, {0x4557e000}, {0x45580000}, {0x45582000}, {0x45584000}, {0x45586000}, {0x45588000}, {0x4558a000}, {0x4558c000}, {0x4558e000}, {0x45590000}, {0x45592000}, {0x45594000}, {0x45596000}, {0x45598000}, {0x4559a000}, {0x4559c000}, {0x4559e000}, {0x455a0000}, {0x455a2000}, {0x455a4000}, {0x455a6000}, {0x455a8000}, {0x455aa000}, {0x455ac000}, {0x455ae000}, {0x455b0000}, {0x455b2000}, {0x455b4000}, {0x455b6000}, {0x455b8000}, {0x455ba000}, {0x455bc000}, {0x455be000}, {0x455c0000}, {0x455c2000}, {0x455c4000}, {0x455c6000}, {0x455c8000}, {0x455ca000}, {0x455cc000}, {0x455ce000}, {0x455d0000}, {0x455d2000}, {0x455d4000}, {0x455d6000}, {0x455d8000}, {0x455da000}, {0x455dc000}, {0x455de000}, {0x455e0000}, {0x455e2000}, {0x455e4000}, {0x455e6000}, {0x455e8000}, {0x455ea000}, {0x455ec000}, {0x455ee000}, {0x455f0000}, {0x455f2000}, {0x455f4000}, {0x455f6000}, {0x455f8000}, {0x455fa000}, {0x455fc000}, {0x455fe000}, {0x45600000}, {0x45602000}, {0x45604000}, {0x45606000}, {0x45608000}, {0x4560a000}, {0x4560c000}, {0x4560e000}, {0x45610000}, {0x45612000}, {0x45614000}, {0x45616000}, {0x45618000}, {0x4561a000}, {0x4561c000}, {0x4561e000}, {0x45620000}, {0x45622000}, {0x45624000}, {0x45626000}, {0x45628000}, {0x4562a000}, {0x4562c000}, {0x4562e000}, {0x45630000}, {0x45632000}, {0x45634000}, {0x45636000}, {0x45638000}, {0x4563a000}, {0x4563c000}, {0x4563e000}, {0x45640000}, {0x45642000}, {0x45644000}, {0x45646000}, {0x45648000}, {0x4564a000}, {0x4564c000}, {0x4564e000}, {0x45650000}, {0x45652000}, {0x45654000}, {0x45656000}, {0x45658000}, {0x4565a000}, {0x4565c000}, {0x4565e000}, {0x45660000}, {0x45662000}, {0x45664000}, {0x45666000}, {0x45668000}, {0x4566a000}, {0x4566c000}, {0x4566e000}, {0x45670000}, {0x45672000}, {0x45674000}, {0x45676000}, {0x45678000}, {0x4567a000}, {0x4567c000}, {0x4567e000}, {0x45680000}, {0x45682000}, {0x45684000}, {0x45686000}, {0x45688000}, {0x4568a000}, {0x4568c000}, {0x4568e000}, {0x45690000}, {0x45692000}, {0x45694000}, {0x45696000}, {0x45698000}, {0x4569a000}, {0x4569c000}, {0x4569e000}, {0x456a0000}, {0x456a2000}, {0x456a4000}, {0x456a6000}, {0x456a8000}, {0x456aa000}, {0x456ac000}, {0x456ae000}, {0x456b0000}, {0x456b2000}, {0x456b4000}, {0x456b6000}, {0x456b8000}, {0x456ba000}, {0x456bc000}, {0x456be000}, {0x456c0000}, {0x456c2000}, {0x456c4000}, {0x456c6000}, {0x456c8000}, {0x456ca000}, {0x456cc000}, {0x456ce000}, {0x456d0000}, {0x456d2000}, {0x456d4000}, {0x456d6000}, {0x456d8000}, {0x456da000}, {0x456dc000}, {0x456de000}, {0x456e0000}, {0x456e2000}, {0x456e4000}, {0x456e6000}, {0x456e8000}, {0x456ea000}, {0x456ec000}, {0x456ee000}, {0x456f0000}, {0x456f2000}, {0x456f4000}, {0x456f6000}, {0x456f8000}, {0x456fa000}, {0x456fc000}, {0x456fe000}, {0x45700000}, {0x45702000}, {0x45704000}, {0x45706000}, {0x45708000}, {0x4570a000}, {0x4570c000}, {0x4570e000}, {0x45710000}, {0x45712000}, {0x45714000}, {0x45716000}, {0x45718000}, {0x4571a000}, {0x4571c000}, {0x4571e000}, {0x45720000}, {0x45722000}, {0x45724000}, {0x45726000}, {0x45728000}, {0x4572a000}, {0x4572c000}, {0x4572e000}, {0x45730000}, {0x45732000}, {0x45734000}, {0x45736000}, {0x45738000}, {0x4573a000}, {0x4573c000}, {0x4573e000}, {0x45740000}, {0x45742000}, {0x45744000}, {0x45746000}, {0x45748000}, {0x4574a000}, {0x4574c000}, {0x4574e000}, {0x45750000}, {0x45752000}, {0x45754000}, {0x45756000}, {0x45758000}, {0x4575a000}, {0x4575c000}, {0x4575e000}, {0x45760000}, {0x45762000}, {0x45764000}, {0x45766000}, {0x45768000}, {0x4576a000}, {0x4576c000}, {0x4576e000}, {0x45770000}, {0x45772000}, {0x45774000}, {0x45776000}, {0x45778000}, {0x4577a000}, {0x4577c000}, {0x4577e000}, {0x45780000}, {0x45782000}, {0x45784000}, {0x45786000}, {0x45788000}, {0x4578a000}, {0x4578c000}, {0x4578e000}, {0x45790000}, {0x45792000}, {0x45794000}, {0x45796000}, {0x45798000}, {0x4579a000}, {0x4579c000}, {0x4579e000}, {0x457a0000}, {0x457a2000}, {0x457a4000}, {0x457a6000}, {0x457a8000}, {0x457aa000}, {0x457ac000}, {0x457ae000}, {0x457b0000}, {0x457b2000}, {0x457b4000}, {0x457b6000}, {0x457b8000}, {0x457ba000}, {0x457bc000}, {0x457be000}, {0x457c0000}, {0x457c2000}, {0x457c4000}, {0x457c6000}, {0x457c8000}, {0x457ca000}, {0x457cc000}, {0x457ce000}, {0x457d0000}, {0x457d2000}, {0x457d4000}, {0x457d6000}, {0x457d8000}, {0x457da000}, {0x457dc000}, {0x457de000}, {0x457e0000}, {0x457e2000}, {0x457e4000}, {0x457e6000}, {0x457e8000}, {0x457ea000}, {0x457ec000}, {0x457ee000}, {0x457f0000}, {0x457f2000}, {0x457f4000}, {0x457f6000}, {0x457f8000}, {0x457fa000}, {0x457fc000}, {0x457fe000}, {0x45800000}, {0x45802000}, {0x45804000}, {0x45806000}, {0x45808000}, {0x4580a000}, {0x4580c000}, {0x4580e000}, {0x45810000}, {0x45812000}, {0x45814000}, {0x45816000}, {0x45818000}, {0x4581a000}, {0x4581c000}, {0x4581e000}, {0x45820000}, {0x45822000}, {0x45824000}, {0x45826000}, {0x45828000}, {0x4582a000}, {0x4582c000}, {0x4582e000}, {0x45830000}, {0x45832000}, {0x45834000}, {0x45836000}, {0x45838000}, {0x4583a000}, {0x4583c000}, {0x4583e000}, {0x45840000}, {0x45842000}, {0x45844000}, {0x45846000}, {0x45848000}, {0x4584a000}, {0x4584c000}, {0x4584e000}, {0x45850000}, {0x45852000}, {0x45854000}, {0x45856000}, {0x45858000}, {0x4585a000}, {0x4585c000}, {0x4585e000}, {0x45860000}, {0x45862000}, {0x45864000}, {0x45866000}, {0x45868000}, {0x4586a000}, {0x4586c000}, {0x4586e000}, {0x45870000}, {0x45872000}, {0x45874000}, {0x45876000}, {0x45878000}, {0x4587a000}, {0x4587c000}, {0x4587e000}, {0x45880000}, {0x45882000}, {0x45884000}, {0x45886000}, {0x45888000}, {0x4588a000}, {0x4588c000}, {0x4588e000}, {0x45890000}, {0x45892000}, {0x45894000}, {0x45896000}, {0x45898000}, {0x4589a000}, {0x4589c000}, {0x4589e000}, {0x458a0000}, {0x458a2000}, {0x458a4000}, {0x458a6000}, {0x458a8000}, {0x458aa000}, {0x458ac000}, {0x458ae000}, {0x458b0000}, {0x458b2000}, {0x458b4000}, {0x458b6000}, {0x458b8000}, {0x458ba000}, {0x458bc000}, {0x458be000}, {0x458c0000}, {0x458c2000}, {0x458c4000}, {0x458c6000}, {0x458c8000}, {0x458ca000}, {0x458cc000}, {0x458ce000}, {0x458d0000}, {0x458d2000}, {0x458d4000}, {0x458d6000}, {0x458d8000}, {0x458da000}, {0x458dc000}, {0x458de000}, {0x458e0000}, {0x458e2000}, {0x458e4000}, {0x458e6000}, {0x458e8000}, {0x458ea000}, {0x458ec000}, {0x458ee000}, {0x458f0000}, {0x458f2000}, {0x458f4000}, {0x458f6000}, {0x458f8000}, {0x458fa000}, {0x458fc000}, {0x458fe000}, {0x45900000}, {0x45902000}, {0x45904000}, {0x45906000}, {0x45908000}, {0x4590a000}, {0x4590c000}, {0x4590e000}, {0x45910000}, {0x45912000}, {0x45914000}, {0x45916000}, {0x45918000}, {0x4591a000}, {0x4591c000}, {0x4591e000}, {0x45920000}, {0x45922000}, {0x45924000}, {0x45926000}, {0x45928000}, {0x4592a000}, {0x4592c000}, {0x4592e000}, {0x45930000}, {0x45932000}, {0x45934000}, {0x45936000}, {0x45938000}, {0x4593a000}, {0x4593c000}, {0x4593e000}, {0x45940000}, {0x45942000}, {0x45944000}, {0x45946000}, {0x45948000}, {0x4594a000}, {0x4594c000}, {0x4594e000}, {0x45950000}, {0x45952000}, {0x45954000}, {0x45956000}, {0x45958000}, {0x4595a000}, {0x4595c000}, {0x4595e000}, {0x45960000}, {0x45962000}, {0x45964000}, {0x45966000}, {0x45968000}, {0x4596a000}, {0x4596c000}, {0x4596e000}, {0x45970000}, {0x45972000}, {0x45974000}, {0x45976000}, {0x45978000}, {0x4597a000}, {0x4597c000}, {0x4597e000}, {0x45980000}, {0x45982000}, {0x45984000}, {0x45986000}, {0x45988000}, {0x4598a000}, {0x4598c000}, {0x4598e000}, {0x45990000}, {0x45992000}, {0x45994000}, {0x45996000}, {0x45998000}, {0x4599a000}, {0x4599c000}, {0x4599e000}, {0x459a0000}, {0x459a2000}, {0x459a4000}, {0x459a6000}, {0x459a8000}, {0x459aa000}, {0x459ac000}, {0x459ae000}, {0x459b0000}, {0x459b2000}, {0x459b4000}, {0x459b6000}, {0x459b8000}, {0x459ba000}, {0x459bc000}, {0x459be000}, {0x459c0000}, {0x459c2000}, {0x459c4000}, {0x459c6000}, {0x459c8000}, {0x459ca000}, {0x459cc000}, {0x459ce000}, {0x459d0000}, {0x459d2000}, {0x459d4000}, {0x459d6000}, {0x459d8000}, {0x459da000}, {0x459dc000}, {0x459de000}, {0x459e0000}, {0x459e2000}, {0x459e4000}, {0x459e6000}, {0x459e8000}, {0x459ea000}, {0x459ec000}, {0x459ee000}, {0x459f0000}, {0x459f2000}, {0x459f4000}, {0x459f6000}, {0x459f8000}, {0x459fa000}, {0x459fc000}, {0x459fe000}, {0x45a00000}, {0x45a02000}, {0x45a04000}, {0x45a06000}, {0x45a08000}, {0x45a0a000}, {0x45a0c000}, {0x45a0e000}, {0x45a10000}, {0x45a12000}, {0x45a14000}, {0x45a16000}, {0x45a18000}, {0x45a1a000}, {0x45a1c000}, {0x45a1e000}, {0x45a20000}, {0x45a22000}, {0x45a24000}, {0x45a26000}, {0x45a28000}, {0x45a2a000}, {0x45a2c000}, {0x45a2e000}, {0x45a30000}, {0x45a32000}, {0x45a34000}, {0x45a36000}, {0x45a38000}, {0x45a3a000}, {0x45a3c000}, {0x45a3e000}, {0x45a40000}, {0x45a42000}, {0x45a44000}, {0x45a46000}, {0x45a48000}, {0x45a4a000}, {0x45a4c000}, {0x45a4e000}, {0x45a50000}, {0x45a52000}, {0x45a54000}, {0x45a56000}, {0x45a58000}, {0x45a5a000}, {0x45a5c000}, {0x45a5e000}, {0x45a60000}, {0x45a62000}, {0x45a64000}, {0x45a66000}, {0x45a68000}, {0x45a6a000}, {0x45a6c000}, {0x45a6e000}, {0x45a70000}, {0x45a72000}, {0x45a74000}, {0x45a76000}, {0x45a78000}, {0x45a7a000}, {0x45a7c000}, {0x45a7e000}, {0x45a80000}, {0x45a82000}, {0x45a84000}, {0x45a86000}, {0x45a88000}, {0x45a8a000}, {0x45a8c000}, {0x45a8e000}, {0x45a90000}, {0x45a92000}, {0x45a94000}, {0x45a96000}, {0x45a98000}, {0x45a9a000}, {0x45a9c000}, {0x45a9e000}, {0x45aa0000}, {0x45aa2000}, {0x45aa4000}, {0x45aa6000}, {0x45aa8000}, {0x45aaa000}, {0x45aac000}, {0x45aae000}, {0x45ab0000}, {0x45ab2000}, {0x45ab4000}, {0x45ab6000}, {0x45ab8000}, {0x45aba000}, {0x45abc000}, {0x45abe000}, {0x45ac0000}, {0x45ac2000}, {0x45ac4000}, {0x45ac6000}, {0x45ac8000}, {0x45aca000}, {0x45acc000}, {0x45ace000}, {0x45ad0000}, {0x45ad2000}, {0x45ad4000}, {0x45ad6000}, {0x45ad8000}, {0x45ada000}, {0x45adc000}, {0x45ade000}, {0x45ae0000}, {0x45ae2000}, {0x45ae4000}, {0x45ae6000}, {0x45ae8000}, {0x45aea000}, {0x45aec000}, {0x45aee000}, {0x45af0000}, {0x45af2000}, {0x45af4000}, {0x45af6000}, {0x45af8000}, {0x45afa000}, {0x45afc000}, {0x45afe000}, {0x45b00000}, {0x45b02000}, {0x45b04000}, {0x45b06000}, {0x45b08000}, {0x45b0a000}, {0x45b0c000}, {0x45b0e000}, {0x45b10000}, {0x45b12000}, {0x45b14000}, {0x45b16000}, {0x45b18000}, {0x45b1a000}, {0x45b1c000}, {0x45b1e000}, {0x45b20000}, {0x45b22000}, {0x45b24000}, {0x45b26000}, {0x45b28000}, {0x45b2a000}, {0x45b2c000}, {0x45b2e000}, {0x45b30000}, {0x45b32000}, {0x45b34000}, {0x45b36000}, {0x45b38000}, {0x45b3a000}, {0x45b3c000}, {0x45b3e000}, {0x45b40000}, {0x45b42000}, {0x45b44000}, {0x45b46000}, {0x45b48000}, {0x45b4a000}, {0x45b4c000}, {0x45b4e000}, {0x45b50000}, {0x45b52000}, {0x45b54000}, {0x45b56000}, {0x45b58000}, {0x45b5a000}, {0x45b5c000}, {0x45b5e000}, {0x45b60000}, {0x45b62000}, {0x45b64000}, {0x45b66000}, {0x45b68000}, {0x45b6a000}, {0x45b6c000}, {0x45b6e000}, {0x45b70000}, {0x45b72000}, {0x45b74000}, {0x45b76000}, {0x45b78000}, {0x45b7a000}, {0x45b7c000}, {0x45b7e000}, {0x45b80000}, {0x45b82000}, {0x45b84000}, {0x45b86000}, {0x45b88000}, {0x45b8a000}, {0x45b8c000}, {0x45b8e000}, {0x45b90000}, {0x45b92000}, {0x45b94000}, {0x45b96000}, {0x45b98000}, {0x45b9a000}, {0x45b9c000}, {0x45b9e000}, {0x45ba0000}, {0x45ba2000}, {0x45ba4000}, {0x45ba6000}, {0x45ba8000}, {0x45baa000}, {0x45bac000}, {0x45bae000}, {0x45bb0000}, {0x45bb2000}, {0x45bb4000}, {0x45bb6000}, {0x45bb8000}, {0x45bba000}, {0x45bbc000}, {0x45bbe000}, {0x45bc0000}, {0x45bc2000}, {0x45bc4000}, {0x45bc6000}, {0x45bc8000}, {0x45bca000}, {0x45bcc000}, {0x45bce000}, {0x45bd0000}, {0x45bd2000}, {0x45bd4000}, {0x45bd6000}, {0x45bd8000}, {0x45bda000}, {0x45bdc000}, {0x45bde000}, {0x45be0000}, {0x45be2000}, {0x45be4000}, {0x45be6000}, {0x45be8000}, {0x45bea000}, {0x45bec000}, {0x45bee000}, {0x45bf0000}, {0x45bf2000}, {0x45bf4000}, {0x45bf6000}, {0x45bf8000}, {0x45bfa000}, {0x45bfc000}, {0x45bfe000}, {0x45c00000}, {0x45c02000}, {0x45c04000}, {0x45c06000}, {0x45c08000}, {0x45c0a000}, {0x45c0c000}, {0x45c0e000}, {0x45c10000}, {0x45c12000}, {0x45c14000}, {0x45c16000}, {0x45c18000}, {0x45c1a000}, {0x45c1c000}, {0x45c1e000}, {0x45c20000}, {0x45c22000}, {0x45c24000}, {0x45c26000}, {0x45c28000}, {0x45c2a000}, {0x45c2c000}, {0x45c2e000}, {0x45c30000}, {0x45c32000}, {0x45c34000}, {0x45c36000}, {0x45c38000}, {0x45c3a000}, {0x45c3c000}, {0x45c3e000}, {0x45c40000}, {0x45c42000}, {0x45c44000}, {0x45c46000}, {0x45c48000}, {0x45c4a000}, {0x45c4c000}, {0x45c4e000}, {0x45c50000}, {0x45c52000}, {0x45c54000}, {0x45c56000}, {0x45c58000}, {0x45c5a000}, {0x45c5c000}, {0x45c5e000}, {0x45c60000}, {0x45c62000}, {0x45c64000}, {0x45c66000}, {0x45c68000}, {0x45c6a000}, {0x45c6c000}, {0x45c6e000}, {0x45c70000}, {0x45c72000}, {0x45c74000}, {0x45c76000}, {0x45c78000}, {0x45c7a000}, {0x45c7c000}, {0x45c7e000}, {0x45c80000}, {0x45c82000}, {0x45c84000}, {0x45c86000}, {0x45c88000}, {0x45c8a000}, {0x45c8c000}, {0x45c8e000}, {0x45c90000}, {0x45c92000}, {0x45c94000}, {0x45c96000}, {0x45c98000}, {0x45c9a000}, {0x45c9c000}, {0x45c9e000}, {0x45ca0000}, {0x45ca2000}, {0x45ca4000}, {0x45ca6000}, {0x45ca8000}, {0x45caa000}, {0x45cac000}, {0x45cae000}, {0x45cb0000}, {0x45cb2000}, {0x45cb4000}, {0x45cb6000}, {0x45cb8000}, {0x45cba000}, {0x45cbc000}, {0x45cbe000}, {0x45cc0000}, {0x45cc2000}, {0x45cc4000}, {0x45cc6000}, {0x45cc8000}, {0x45cca000}, {0x45ccc000}, {0x45cce000}, {0x45cd0000}, {0x45cd2000}, {0x45cd4000}, {0x45cd6000}, {0x45cd8000}, {0x45cda000}, {0x45cdc000}, {0x45cde000}, {0x45ce0000}, {0x45ce2000}, {0x45ce4000}, {0x45ce6000}, {0x45ce8000}, {0x45cea000}, {0x45cec000}, {0x45cee000}, {0x45cf0000}, {0x45cf2000}, {0x45cf4000}, {0x45cf6000}, {0x45cf8000}, {0x45cfa000}, {0x45cfc000}, {0x45cfe000}, {0x45d00000}, {0x45d02000}, {0x45d04000}, {0x45d06000}, {0x45d08000}, {0x45d0a000}, {0x45d0c000}, {0x45d0e000}, {0x45d10000}, {0x45d12000}, {0x45d14000}, {0x45d16000}, {0x45d18000}, {0x45d1a000}, {0x45d1c000}, {0x45d1e000}, {0x45d20000}, {0x45d22000}, {0x45d24000}, {0x45d26000}, {0x45d28000}, {0x45d2a000}, {0x45d2c000}, {0x45d2e000}, {0x45d30000}, {0x45d32000}, {0x45d34000}, {0x45d36000}, {0x45d38000}, {0x45d3a000}, {0x45d3c000}, {0x45d3e000}, {0x45d40000}, {0x45d42000}, {0x45d44000}, {0x45d46000}, {0x45d48000}, {0x45d4a000}, {0x45d4c000}, {0x45d4e000}, {0x45d50000}, {0x45d52000}, {0x45d54000}, {0x45d56000}, {0x45d58000}, {0x45d5a000}, {0x45d5c000}, {0x45d5e000}, {0x45d60000}, {0x45d62000}, {0x45d64000}, {0x45d66000}, {0x45d68000}, {0x45d6a000}, {0x45d6c000}, {0x45d6e000}, {0x45d70000}, {0x45d72000}, {0x45d74000}, {0x45d76000}, {0x45d78000}, {0x45d7a000}, {0x45d7c000}, {0x45d7e000}, {0x45d80000}, {0x45d82000}, {0x45d84000}, {0x45d86000}, {0x45d88000}, {0x45d8a000}, {0x45d8c000}, {0x45d8e000}, {0x45d90000}, {0x45d92000}, {0x45d94000}, {0x45d96000}, {0x45d98000}, {0x45d9a000}, {0x45d9c000}, {0x45d9e000}, {0x45da0000}, {0x45da2000}, {0x45da4000}, {0x45da6000}, {0x45da8000}, {0x45daa000}, {0x45dac000}, {0x45dae000}, {0x45db0000}, {0x45db2000}, {0x45db4000}, {0x45db6000}, {0x45db8000}, {0x45dba000}, {0x45dbc000}, {0x45dbe000}, {0x45dc0000}, {0x45dc2000}, {0x45dc4000}, {0x45dc6000}, {0x45dc8000}, {0x45dca000}, {0x45dcc000}, {0x45dce000}, {0x45dd0000}, {0x45dd2000}, {0x45dd4000}, {0x45dd6000}, {0x45dd8000}, {0x45dda000}, {0x45ddc000}, {0x45dde000}, {0x45de0000}, {0x45de2000}, {0x45de4000}, {0x45de6000}, {0x45de8000}, {0x45dea000}, {0x45dec000}, {0x45dee000}, {0x45df0000}, {0x45df2000}, {0x45df4000}, {0x45df6000}, {0x45df8000}, {0x45dfa000}, {0x45dfc000}, {0x45dfe000}, {0x45e00000}, {0x45e02000}, {0x45e04000}, {0x45e06000}, {0x45e08000}, {0x45e0a000}, {0x45e0c000}, {0x45e0e000}, {0x45e10000}, {0x45e12000}, {0x45e14000}, {0x45e16000}, {0x45e18000}, {0x45e1a000}, {0x45e1c000}, {0x45e1e000}, {0x45e20000}, {0x45e22000}, {0x45e24000}, {0x45e26000}, {0x45e28000}, {0x45e2a000}, {0x45e2c000}, {0x45e2e000}, {0x45e30000}, {0x45e32000}, {0x45e34000}, {0x45e36000}, {0x45e38000}, {0x45e3a000}, {0x45e3c000}, {0x45e3e000}, {0x45e40000}, {0x45e42000}, {0x45e44000}, {0x45e46000}, {0x45e48000}, {0x45e4a000}, {0x45e4c000}, {0x45e4e000}, {0x45e50000}, {0x45e52000}, {0x45e54000}, {0x45e56000}, {0x45e58000}, {0x45e5a000}, {0x45e5c000}, {0x45e5e000}, {0x45e60000}, {0x45e62000}, {0x45e64000}, {0x45e66000}, {0x45e68000}, {0x45e6a000}, {0x45e6c000}, {0x45e6e000}, {0x45e70000}, {0x45e72000}, {0x45e74000}, {0x45e76000}, {0x45e78000}, {0x45e7a000}, {0x45e7c000}, {0x45e7e000}, {0x45e80000}, {0x45e82000}, {0x45e84000}, {0x45e86000}, {0x45e88000}, {0x45e8a000}, {0x45e8c000}, {0x45e8e000}, {0x45e90000}, {0x45e92000}, {0x45e94000}, {0x45e96000}, {0x45e98000}, {0x45e9a000}, {0x45e9c000}, {0x45e9e000}, {0x45ea0000}, {0x45ea2000}, {0x45ea4000}, {0x45ea6000}, {0x45ea8000}, {0x45eaa000}, {0x45eac000}, {0x45eae000}, {0x45eb0000}, {0x45eb2000}, {0x45eb4000}, {0x45eb6000}, {0x45eb8000}, {0x45eba000}, {0x45ebc000}, {0x45ebe000}, {0x45ec0000}, {0x45ec2000}, {0x45ec4000}, {0x45ec6000}, {0x45ec8000}, {0x45eca000}, {0x45ecc000}, {0x45ece000}, {0x45ed0000}, {0x45ed2000}, {0x45ed4000}, {0x45ed6000}, {0x45ed8000}, {0x45eda000}, {0x45edc000}, {0x45ede000}, {0x45ee0000}, {0x45ee2000}, {0x45ee4000}, {0x45ee6000}, {0x45ee8000}, {0x45eea000}, {0x45eec000}, {0x45eee000}, {0x45ef0000}, {0x45ef2000}, {0x45ef4000}, {0x45ef6000}, {0x45ef8000}, {0x45efa000}, {0x45efc000}, {0x45efe000}, {0x45f00000}, {0x45f02000}, {0x45f04000}, {0x45f06000}, {0x45f08000}, {0x45f0a000}, {0x45f0c000}, {0x45f0e000}, {0x45f10000}, {0x45f12000}, {0x45f14000}, {0x45f16000}, {0x45f18000}, {0x45f1a000}, {0x45f1c000}, {0x45f1e000}, {0x45f20000}, {0x45f22000}, {0x45f24000}, {0x45f26000}, {0x45f28000}, {0x45f2a000}, {0x45f2c000}, {0x45f2e000}, {0x45f30000}, {0x45f32000}, {0x45f34000}, {0x45f36000}, {0x45f38000}, {0x45f3a000}, {0x45f3c000}, {0x45f3e000}, {0x45f40000}, {0x45f42000}, {0x45f44000}, {0x45f46000}, {0x45f48000}, {0x45f4a000}, {0x45f4c000}, {0x45f4e000}, {0x45f50000}, {0x45f52000}, {0x45f54000}, {0x45f56000}, {0x45f58000}, {0x45f5a000}, {0x45f5c000}, {0x45f5e000}, {0x45f60000}, {0x45f62000}, {0x45f64000}, {0x45f66000}, {0x45f68000}, {0x45f6a000}, {0x45f6c000}, {0x45f6e000}, {0x45f70000}, {0x45f72000}, {0x45f74000}, {0x45f76000}, {0x45f78000}, {0x45f7a000}, {0x45f7c000}, {0x45f7e000}, {0x45f80000}, {0x45f82000}, {0x45f84000}, {0x45f86000}, {0x45f88000}, {0x45f8a000}, {0x45f8c000}, {0x45f8e000}, {0x45f90000}, {0x45f92000}, {0x45f94000}, {0x45f96000}, {0x45f98000}, {0x45f9a000}, {0x45f9c000}, {0x45f9e000}, {0x45fa0000}, {0x45fa2000}, {0x45fa4000}, {0x45fa6000}, {0x45fa8000}, {0x45faa000}, {0x45fac000}, {0x45fae000}, {0x45fb0000}, {0x45fb2000}, {0x45fb4000}, {0x45fb6000}, {0x45fb8000}, {0x45fba000}, {0x45fbc000}, {0x45fbe000}, {0x45fc0000}, {0x45fc2000}, {0x45fc4000}, {0x45fc6000}, {0x45fc8000}, {0x45fca000}, {0x45fcc000}, {0x45fce000}, {0x45fd0000}, {0x45fd2000}, {0x45fd4000}, {0x45fd6000}, {0x45fd8000}, {0x45fda000}, {0x45fdc000}, {0x45fde000}, {0x45fe0000}, {0x45fe2000}, {0x45fe4000}, {0x45fe6000}, {0x45fe8000}, {0x45fea000}, {0x45fec000}, {0x45fee000}, {0x45ff0000}, {0x45ff2000}, {0x45ff4000}, {0x45ff6000}, {0x45ff8000}, {0x45ffa000}, {0x45ffc000}, {0x45ffe000}, {0x46000000}, {0x46002000}, {0x46004000}, {0x46006000}, {0x46008000}, {0x4600a000}, {0x4600c000}, {0x4600e000}, {0x46010000}, {0x46012000}, {0x46014000}, {0x46016000}, {0x46018000}, {0x4601a000}, {0x4601c000}, {0x4601e000}, {0x46020000}, {0x46022000}, {0x46024000}, {0x46026000}, {0x46028000}, {0x4602a000}, {0x4602c000}, {0x4602e000}, {0x46030000}, {0x46032000}, {0x46034000}, {0x46036000}, {0x46038000}, {0x4603a000}, {0x4603c000}, {0x4603e000}, {0x46040000}, {0x46042000}, {0x46044000}, {0x46046000}, {0x46048000}, {0x4604a000}, {0x4604c000}, {0x4604e000}, {0x46050000}, {0x46052000}, {0x46054000}, {0x46056000}, {0x46058000}, {0x4605a000}, {0x4605c000}, {0x4605e000}, {0x46060000}, {0x46062000}, {0x46064000}, {0x46066000}, {0x46068000}, {0x4606a000}, {0x4606c000}, {0x4606e000}, {0x46070000}, {0x46072000}, {0x46074000}, {0x46076000}, {0x46078000}, {0x4607a000}, {0x4607c000}, {0x4607e000}, {0x46080000}, {0x46082000}, {0x46084000}, {0x46086000}, {0x46088000}, {0x4608a000}, {0x4608c000}, {0x4608e000}, {0x46090000}, {0x46092000}, {0x46094000}, {0x46096000}, {0x46098000}, {0x4609a000}, {0x4609c000}, {0x4609e000}, {0x460a0000}, {0x460a2000}, {0x460a4000}, {0x460a6000}, {0x460a8000}, {0x460aa000}, {0x460ac000}, {0x460ae000}, {0x460b0000}, {0x460b2000}, {0x460b4000}, {0x460b6000}, {0x460b8000}, {0x460ba000}, {0x460bc000}, {0x460be000}, {0x460c0000}, {0x460c2000}, {0x460c4000}, {0x460c6000}, {0x460c8000}, {0x460ca000}, {0x460cc000}, {0x460ce000}, {0x460d0000}, {0x460d2000}, {0x460d4000}, {0x460d6000}, {0x460d8000}, {0x460da000}, {0x460dc000}, {0x460de000}, {0x460e0000}, {0x460e2000}, {0x460e4000}, {0x460e6000}, {0x460e8000}, {0x460ea000}, {0x460ec000}, {0x460ee000}, {0x460f0000}, {0x460f2000}, {0x460f4000}, {0x460f6000}, {0x460f8000}, {0x460fa000}, {0x460fc000}, {0x460fe000}, {0x46100000}, {0x46102000}, {0x46104000}, {0x46106000}, {0x46108000}, {0x4610a000}, {0x4610c000}, {0x4610e000}, {0x46110000}, {0x46112000}, {0x46114000}, {0x46116000}, {0x46118000}, {0x4611a000}, {0x4611c000}, {0x4611e000}, {0x46120000}, {0x46122000}, {0x46124000}, {0x46126000}, {0x46128000}, {0x4612a000}, {0x4612c000}, {0x4612e000}, {0x46130000}, {0x46132000}, {0x46134000}, {0x46136000}, {0x46138000}, {0x4613a000}, {0x4613c000}, {0x4613e000}, {0x46140000}, {0x46142000}, {0x46144000}, {0x46146000}, {0x46148000}, {0x4614a000}, {0x4614c000}, {0x4614e000}, {0x46150000}, {0x46152000}, {0x46154000}, {0x46156000}, {0x46158000}, {0x4615a000}, {0x4615c000}, {0x4615e000}, {0x46160000}, {0x46162000}, {0x46164000}, {0x46166000}, {0x46168000}, {0x4616a000}, {0x4616c000}, {0x4616e000}, {0x46170000}, {0x46172000}, {0x46174000}, {0x46176000}, {0x46178000}, {0x4617a000}, {0x4617c000}, {0x4617e000}, {0x46180000}, {0x46182000}, {0x46184000}, {0x46186000}, {0x46188000}, {0x4618a000}, {0x4618c000}, {0x4618e000}, {0x46190000}, {0x46192000}, {0x46194000}, {0x46196000}, {0x46198000}, {0x4619a000}, {0x4619c000}, {0x4619e000}, {0x461a0000}, {0x461a2000}, {0x461a4000}, {0x461a6000}, {0x461a8000}, {0x461aa000}, {0x461ac000}, {0x461ae000}, {0x461b0000}, {0x461b2000}, {0x461b4000}, {0x461b6000}, {0x461b8000}, {0x461ba000}, {0x461bc000}, {0x461be000}, {0x461c0000}, {0x461c2000}, {0x461c4000}, {0x461c6000}, {0x461c8000}, {0x461ca000}, {0x461cc000}, {0x461ce000}, {0x461d0000}, {0x461d2000}, {0x461d4000}, {0x461d6000}, {0x461d8000}, {0x461da000}, {0x461dc000}, {0x461de000}, {0x461e0000}, {0x461e2000}, {0x461e4000}, {0x461e6000}, {0x461e8000}, {0x461ea000}, {0x461ec000}, {0x461ee000}, {0x461f0000}, {0x461f2000}, {0x461f4000}, {0x461f6000}, {0x461f8000}, {0x461fa000}, {0x461fc000}, {0x461fe000}, {0x46200000}, {0x46202000}, {0x46204000}, {0x46206000}, {0x46208000}, {0x4620a000}, {0x4620c000}, {0x4620e000}, {0x46210000}, {0x46212000}, {0x46214000}, {0x46216000}, {0x46218000}, {0x4621a000}, {0x4621c000}, {0x4621e000}, {0x46220000}, {0x46222000}, {0x46224000}, {0x46226000}, {0x46228000}, {0x4622a000}, {0x4622c000}, {0x4622e000}, {0x46230000}, {0x46232000}, {0x46234000}, {0x46236000}, {0x46238000}, {0x4623a000}, {0x4623c000}, {0x4623e000}, {0x46240000}, {0x46242000}, {0x46244000}, {0x46246000}, {0x46248000}, {0x4624a000}, {0x4624c000}, {0x4624e000}, {0x46250000}, {0x46252000}, {0x46254000}, {0x46256000}, {0x46258000}, {0x4625a000}, {0x4625c000}, {0x4625e000}, {0x46260000}, {0x46262000}, {0x46264000}, {0x46266000}, {0x46268000}, {0x4626a000}, {0x4626c000}, {0x4626e000}, {0x46270000}, {0x46272000}, {0x46274000}, {0x46276000}, {0x46278000}, {0x4627a000}, {0x4627c000}, {0x4627e000}, {0x46280000}, {0x46282000}, {0x46284000}, {0x46286000}, {0x46288000}, {0x4628a000}, {0x4628c000}, {0x4628e000}, {0x46290000}, {0x46292000}, {0x46294000}, {0x46296000}, {0x46298000}, {0x4629a000}, {0x4629c000}, {0x4629e000}, {0x462a0000}, {0x462a2000}, {0x462a4000}, {0x462a6000}, {0x462a8000}, {0x462aa000}, {0x462ac000}, {0x462ae000}, {0x462b0000}, {0x462b2000}, {0x462b4000}, {0x462b6000}, {0x462b8000}, {0x462ba000}, {0x462bc000}, {0x462be000}, {0x462c0000}, {0x462c2000}, {0x462c4000}, {0x462c6000}, {0x462c8000}, {0x462ca000}, {0x462cc000}, {0x462ce000}, {0x462d0000}, {0x462d2000}, {0x462d4000}, {0x462d6000}, {0x462d8000}, {0x462da000}, {0x462dc000}, {0x462de000}, {0x462e0000}, {0x462e2000}, {0x462e4000}, {0x462e6000}, {0x462e8000}, {0x462ea000}, {0x462ec000}, {0x462ee000}, {0x462f0000}, {0x462f2000}, {0x462f4000}, {0x462f6000}, {0x462f8000}, {0x462fa000}, {0x462fc000}, {0x462fe000}, {0x46300000}, {0x46302000}, {0x46304000}, {0x46306000}, {0x46308000}, {0x4630a000}, {0x4630c000}, {0x4630e000}, {0x46310000}, {0x46312000}, {0x46314000}, {0x46316000}, {0x46318000}, {0x4631a000}, {0x4631c000}, {0x4631e000}, {0x46320000}, {0x46322000}, {0x46324000}, {0x46326000}, {0x46328000}, {0x4632a000}, {0x4632c000}, {0x4632e000}, {0x46330000}, {0x46332000}, {0x46334000}, {0x46336000}, {0x46338000}, {0x4633a000}, {0x4633c000}, {0x4633e000}, {0x46340000}, {0x46342000}, {0x46344000}, {0x46346000}, {0x46348000}, {0x4634a000}, {0x4634c000}, {0x4634e000}, {0x46350000}, {0x46352000}, {0x46354000}, {0x46356000}, {0x46358000}, {0x4635a000}, {0x4635c000}, {0x4635e000}, {0x46360000}, {0x46362000}, {0x46364000}, {0x46366000}, {0x46368000}, {0x4636a000}, {0x4636c000}, {0x4636e000}, {0x46370000}, {0x46372000}, {0x46374000}, {0x46376000}, {0x46378000}, {0x4637a000}, {0x4637c000}, {0x4637e000}, {0x46380000}, {0x46382000}, {0x46384000}, {0x46386000}, {0x46388000}, {0x4638a000}, {0x4638c000}, {0x4638e000}, {0x46390000}, {0x46392000}, {0x46394000}, {0x46396000}, {0x46398000}, {0x4639a000}, {0x4639c000}, {0x4639e000}, {0x463a0000}, {0x463a2000}, {0x463a4000}, {0x463a6000}, {0x463a8000}, {0x463aa000}, {0x463ac000}, {0x463ae000}, {0x463b0000}, {0x463b2000}, {0x463b4000}, {0x463b6000}, {0x463b8000}, {0x463ba000}, {0x463bc000}, {0x463be000}, {0x463c0000}, {0x463c2000}, {0x463c4000}, {0x463c6000}, {0x463c8000}, {0x463ca000}, {0x463cc000}, {0x463ce000}, {0x463d0000}, {0x463d2000}, {0x463d4000}, {0x463d6000}, {0x463d8000}, {0x463da000}, {0x463dc000}, {0x463de000}, {0x463e0000}, {0x463e2000}, {0x463e4000}, {0x463e6000}, {0x463e8000}, {0x463ea000}, {0x463ec000}, {0x463ee000}, {0x463f0000}, {0x463f2000}, {0x463f4000}, {0x463f6000}, {0x463f8000}, {0x463fa000}, {0x463fc000}, {0x463fe000}, {0x46400000}, {0x46402000}, {0x46404000}, {0x46406000}, {0x46408000}, {0x4640a000}, {0x4640c000}, {0x4640e000}, {0x46410000}, {0x46412000}, {0x46414000}, {0x46416000}, {0x46418000}, {0x4641a000}, {0x4641c000}, {0x4641e000}, {0x46420000}, {0x46422000}, {0x46424000}, {0x46426000}, {0x46428000}, {0x4642a000}, {0x4642c000}, {0x4642e000}, {0x46430000}, {0x46432000}, {0x46434000}, {0x46436000}, {0x46438000}, {0x4643a000}, {0x4643c000}, {0x4643e000}, {0x46440000}, {0x46442000}, {0x46444000}, {0x46446000}, {0x46448000}, {0x4644a000}, {0x4644c000}, {0x4644e000}, {0x46450000}, {0x46452000}, {0x46454000}, {0x46456000}, {0x46458000}, {0x4645a000}, {0x4645c000}, {0x4645e000}, {0x46460000}, {0x46462000}, {0x46464000}, {0x46466000}, {0x46468000}, {0x4646a000}, {0x4646c000}, {0x4646e000}, {0x46470000}, {0x46472000}, {0x46474000}, {0x46476000}, {0x46478000}, {0x4647a000}, {0x4647c000}, {0x4647e000}, {0x46480000}, {0x46482000}, {0x46484000}, {0x46486000}, {0x46488000}, {0x4648a000}, {0x4648c000}, {0x4648e000}, {0x46490000}, {0x46492000}, {0x46494000}, {0x46496000}, {0x46498000}, {0x4649a000}, {0x4649c000}, {0x4649e000}, {0x464a0000}, {0x464a2000}, {0x464a4000}, {0x464a6000}, {0x464a8000}, {0x464aa000}, {0x464ac000}, {0x464ae000}, {0x464b0000}, {0x464b2000}, {0x464b4000}, {0x464b6000}, {0x464b8000}, {0x464ba000}, {0x464bc000}, {0x464be000}, {0x464c0000}, {0x464c2000}, {0x464c4000}, {0x464c6000}, {0x464c8000}, {0x464ca000}, {0x464cc000}, {0x464ce000}, {0x464d0000}, {0x464d2000}, {0x464d4000}, {0x464d6000}, {0x464d8000}, {0x464da000}, {0x464dc000}, {0x464de000}, {0x464e0000}, {0x464e2000}, {0x464e4000}, {0x464e6000}, {0x464e8000}, {0x464ea000}, {0x464ec000}, {0x464ee000}, {0x464f0000}, {0x464f2000}, {0x464f4000}, {0x464f6000}, {0x464f8000}, {0x464fa000}, {0x464fc000}, {0x464fe000}, {0x46500000}, {0x46502000}, {0x46504000}, {0x46506000}, {0x46508000}, {0x4650a000}, {0x4650c000}, {0x4650e000}, {0x46510000}, {0x46512000}, {0x46514000}, {0x46516000}, {0x46518000}, {0x4651a000}, {0x4651c000}, {0x4651e000}, {0x46520000}, {0x46522000}, {0x46524000}, {0x46526000}, {0x46528000}, {0x4652a000}, {0x4652c000}, {0x4652e000}, {0x46530000}, {0x46532000}, {0x46534000}, {0x46536000}, {0x46538000}, {0x4653a000}, {0x4653c000}, {0x4653e000}, {0x46540000}, {0x46542000}, {0x46544000}, {0x46546000}, {0x46548000}, {0x4654a000}, {0x4654c000}, {0x4654e000}, {0x46550000}, {0x46552000}, {0x46554000}, {0x46556000}, {0x46558000}, {0x4655a000}, {0x4655c000}, {0x4655e000}, {0x46560000}, {0x46562000}, {0x46564000}, {0x46566000}, {0x46568000}, {0x4656a000}, {0x4656c000}, {0x4656e000}, {0x46570000}, {0x46572000}, {0x46574000}, {0x46576000}, {0x46578000}, {0x4657a000}, {0x4657c000}, {0x4657e000}, {0x46580000}, {0x46582000}, {0x46584000}, {0x46586000}, {0x46588000}, {0x4658a000}, {0x4658c000}, {0x4658e000}, {0x46590000}, {0x46592000}, {0x46594000}, {0x46596000}, {0x46598000}, {0x4659a000}, {0x4659c000}, {0x4659e000}, {0x465a0000}, {0x465a2000}, {0x465a4000}, {0x465a6000}, {0x465a8000}, {0x465aa000}, {0x465ac000}, {0x465ae000}, {0x465b0000}, {0x465b2000}, {0x465b4000}, {0x465b6000}, {0x465b8000}, {0x465ba000}, {0x465bc000}, {0x465be000}, {0x465c0000}, {0x465c2000}, {0x465c4000}, {0x465c6000}, {0x465c8000}, {0x465ca000}, {0x465cc000}, {0x465ce000}, {0x465d0000}, {0x465d2000}, {0x465d4000}, {0x465d6000}, {0x465d8000}, {0x465da000}, {0x465dc000}, {0x465de000}, {0x465e0000}, {0x465e2000}, {0x465e4000}, {0x465e6000}, {0x465e8000}, {0x465ea000}, {0x465ec000}, {0x465ee000}, {0x465f0000}, {0x465f2000}, {0x465f4000}, {0x465f6000}, {0x465f8000}, {0x465fa000}, {0x465fc000}, {0x465fe000}, {0x46600000}, {0x46602000}, {0x46604000}, {0x46606000}, {0x46608000}, {0x4660a000}, {0x4660c000}, {0x4660e000}, {0x46610000}, {0x46612000}, {0x46614000}, {0x46616000}, {0x46618000}, {0x4661a000}, {0x4661c000}, {0x4661e000}, {0x46620000}, {0x46622000}, {0x46624000}, {0x46626000}, {0x46628000}, {0x4662a000}, {0x4662c000}, {0x4662e000}, {0x46630000}, {0x46632000}, {0x46634000}, {0x46636000}, {0x46638000}, {0x4663a000}, {0x4663c000}, {0x4663e000}, {0x46640000}, {0x46642000}, {0x46644000}, {0x46646000}, {0x46648000}, {0x4664a000}, {0x4664c000}, {0x4664e000}, {0x46650000}, {0x46652000}, {0x46654000}, {0x46656000}, {0x46658000}, {0x4665a000}, {0x4665c000}, {0x4665e000}, {0x46660000}, {0x46662000}, {0x46664000}, {0x46666000}, {0x46668000}, {0x4666a000}, {0x4666c000}, {0x4666e000}, {0x46670000}, {0x46672000}, {0x46674000}, {0x46676000}, {0x46678000}, {0x4667a000}, {0x4667c000}, {0x4667e000}, {0x46680000}, {0x46682000}, {0x46684000}, {0x46686000}, {0x46688000}, {0x4668a000}, {0x4668c000}, {0x4668e000}, {0x46690000}, {0x46692000}, {0x46694000}, {0x46696000}, {0x46698000}, {0x4669a000}, {0x4669c000}, {0x4669e000}, {0x466a0000}, {0x466a2000}, {0x466a4000}, {0x466a6000}, {0x466a8000}, {0x466aa000}, {0x466ac000}, {0x466ae000}, {0x466b0000}, {0x466b2000}, {0x466b4000}, {0x466b6000}, {0x466b8000}, {0x466ba000}, {0x466bc000}, {0x466be000}, {0x466c0000}, {0x466c2000}, {0x466c4000}, {0x466c6000}, {0x466c8000}, {0x466ca000}, {0x466cc000}, {0x466ce000}, {0x466d0000}, {0x466d2000}, {0x466d4000}, {0x466d6000}, {0x466d8000}, {0x466da000}, {0x466dc000}, {0x466de000}, {0x466e0000}, {0x466e2000}, {0x466e4000}, {0x466e6000}, {0x466e8000}, {0x466ea000}, {0x466ec000}, {0x466ee000}, {0x466f0000}, {0x466f2000}, {0x466f4000}, {0x466f6000}, {0x466f8000}, {0x466fa000}, {0x466fc000}, {0x466fe000}, {0x46700000}, {0x46702000}, {0x46704000}, {0x46706000}, {0x46708000}, {0x4670a000}, {0x4670c000}, {0x4670e000}, {0x46710000}, {0x46712000}, {0x46714000}, {0x46716000}, {0x46718000}, {0x4671a000}, {0x4671c000}, {0x4671e000}, {0x46720000}, {0x46722000}, {0x46724000}, {0x46726000}, {0x46728000}, {0x4672a000}, {0x4672c000}, {0x4672e000}, {0x46730000}, {0x46732000}, {0x46734000}, {0x46736000}, {0x46738000}, {0x4673a000}, {0x4673c000}, {0x4673e000}, {0x46740000}, {0x46742000}, {0x46744000}, {0x46746000}, {0x46748000}, {0x4674a000}, {0x4674c000}, {0x4674e000}, {0x46750000}, {0x46752000}, {0x46754000}, {0x46756000}, {0x46758000}, {0x4675a000}, {0x4675c000}, {0x4675e000}, {0x46760000}, {0x46762000}, {0x46764000}, {0x46766000}, {0x46768000}, {0x4676a000}, {0x4676c000}, {0x4676e000}, {0x46770000}, {0x46772000}, {0x46774000}, {0x46776000}, {0x46778000}, {0x4677a000}, {0x4677c000}, {0x4677e000}, {0x46780000}, {0x46782000}, {0x46784000}, {0x46786000}, {0x46788000}, {0x4678a000}, {0x4678c000}, {0x4678e000}, {0x46790000}, {0x46792000}, {0x46794000}, {0x46796000}, {0x46798000}, {0x4679a000}, {0x4679c000}, {0x4679e000}, {0x467a0000}, {0x467a2000}, {0x467a4000}, {0x467a6000}, {0x467a8000}, {0x467aa000}, {0x467ac000}, {0x467ae000}, {0x467b0000}, {0x467b2000}, {0x467b4000}, {0x467b6000}, {0x467b8000}, {0x467ba000}, {0x467bc000}, {0x467be000}, {0x467c0000}, {0x467c2000}, {0x467c4000}, {0x467c6000}, {0x467c8000}, {0x467ca000}, {0x467cc000}, {0x467ce000}, {0x467d0000}, {0x467d2000}, {0x467d4000}, {0x467d6000}, {0x467d8000}, {0x467da000}, {0x467dc000}, {0x467de000}, {0x467e0000}, {0x467e2000}, {0x467e4000}, {0x467e6000}, {0x467e8000}, {0x467ea000}, {0x467ec000}, {0x467ee000}, {0x467f0000}, {0x467f2000}, {0x467f4000}, {0x467f6000}, {0x467f8000}, {0x467fa000}, {0x467fc000}, {0x467fe000}, {0x46800000}, {0x46802000}, {0x46804000}, {0x46806000}, {0x46808000}, {0x4680a000}, {0x4680c000}, {0x4680e000}, {0x46810000}, {0x46812000}, {0x46814000}, {0x46816000}, {0x46818000}, {0x4681a000}, {0x4681c000}, {0x4681e000}, {0x46820000}, {0x46822000}, {0x46824000}, {0x46826000}, {0x46828000}, {0x4682a000}, {0x4682c000}, {0x4682e000}, {0x46830000}, {0x46832000}, {0x46834000}, {0x46836000}, {0x46838000}, {0x4683a000}, {0x4683c000}, {0x4683e000}, {0x46840000}, {0x46842000}, {0x46844000}, {0x46846000}, {0x46848000}, {0x4684a000}, {0x4684c000}, {0x4684e000}, {0x46850000}, {0x46852000}, {0x46854000}, {0x46856000}, {0x46858000}, {0x4685a000}, {0x4685c000}, {0x4685e000}, {0x46860000}, {0x46862000}, {0x46864000}, {0x46866000}, {0x46868000}, {0x4686a000}, {0x4686c000}, {0x4686e000}, {0x46870000}, {0x46872000}, {0x46874000}, {0x46876000}, {0x46878000}, {0x4687a000}, {0x4687c000}, {0x4687e000}, {0x46880000}, {0x46882000}, {0x46884000}, {0x46886000}, {0x46888000}, {0x4688a000}, {0x4688c000}, {0x4688e000}, {0x46890000}, {0x46892000}, {0x46894000}, {0x46896000}, {0x46898000}, {0x4689a000}, {0x4689c000}, {0x4689e000}, {0x468a0000}, {0x468a2000}, {0x468a4000}, {0x468a6000}, {0x468a8000}, {0x468aa000}, {0x468ac000}, {0x468ae000}, {0x468b0000}, {0x468b2000}, {0x468b4000}, {0x468b6000}, {0x468b8000}, {0x468ba000}, {0x468bc000}, {0x468be000}, {0x468c0000}, {0x468c2000}, {0x468c4000}, {0x468c6000}, {0x468c8000}, {0x468ca000}, {0x468cc000}, {0x468ce000}, {0x468d0000}, {0x468d2000}, {0x468d4000}, {0x468d6000}, {0x468d8000}, {0x468da000}, {0x468dc000}, {0x468de000}, {0x468e0000}, {0x468e2000}, {0x468e4000}, {0x468e6000}, {0x468e8000}, {0x468ea000}, {0x468ec000}, {0x468ee000}, {0x468f0000}, {0x468f2000}, {0x468f4000}, {0x468f6000}, {0x468f8000}, {0x468fa000}, {0x468fc000}, {0x468fe000}, {0x46900000}, {0x46902000}, {0x46904000}, {0x46906000}, {0x46908000}, {0x4690a000}, {0x4690c000}, {0x4690e000}, {0x46910000}, {0x46912000}, {0x46914000}, {0x46916000}, {0x46918000}, {0x4691a000}, {0x4691c000}, {0x4691e000}, {0x46920000}, {0x46922000}, {0x46924000}, {0x46926000}, {0x46928000}, {0x4692a000}, {0x4692c000}, {0x4692e000}, {0x46930000}, {0x46932000}, {0x46934000}, {0x46936000}, {0x46938000}, {0x4693a000}, {0x4693c000}, {0x4693e000}, {0x46940000}, {0x46942000}, {0x46944000}, {0x46946000}, {0x46948000}, {0x4694a000}, {0x4694c000}, {0x4694e000}, {0x46950000}, {0x46952000}, {0x46954000}, {0x46956000}, {0x46958000}, {0x4695a000}, {0x4695c000}, {0x4695e000}, {0x46960000}, {0x46962000}, {0x46964000}, {0x46966000}, {0x46968000}, {0x4696a000}, {0x4696c000}, {0x4696e000}, {0x46970000}, {0x46972000}, {0x46974000}, {0x46976000}, {0x46978000}, {0x4697a000}, {0x4697c000}, {0x4697e000}, {0x46980000}, {0x46982000}, {0x46984000}, {0x46986000}, {0x46988000}, {0x4698a000}, {0x4698c000}, {0x4698e000}, {0x46990000}, {0x46992000}, {0x46994000}, {0x46996000}, {0x46998000}, {0x4699a000}, {0x4699c000}, {0x4699e000}, {0x469a0000}, {0x469a2000}, {0x469a4000}, {0x469a6000}, {0x469a8000}, {0x469aa000}, {0x469ac000}, {0x469ae000}, {0x469b0000}, {0x469b2000}, {0x469b4000}, {0x469b6000}, {0x469b8000}, {0x469ba000}, {0x469bc000}, {0x469be000}, {0x469c0000}, {0x469c2000}, {0x469c4000}, {0x469c6000}, {0x469c8000}, {0x469ca000}, {0x469cc000}, {0x469ce000}, {0x469d0000}, {0x469d2000}, {0x469d4000}, {0x469d6000}, {0x469d8000}, {0x469da000}, {0x469dc000}, {0x469de000}, {0x469e0000}, {0x469e2000}, {0x469e4000}, {0x469e6000}, {0x469e8000}, {0x469ea000}, {0x469ec000}, {0x469ee000}, {0x469f0000}, {0x469f2000}, {0x469f4000}, {0x469f6000}, {0x469f8000}, {0x469fa000}, {0x469fc000}, {0x469fe000}, {0x46a00000}, {0x46a02000}, {0x46a04000}, {0x46a06000}, {0x46a08000}, {0x46a0a000}, {0x46a0c000}, {0x46a0e000}, {0x46a10000}, {0x46a12000}, {0x46a14000}, {0x46a16000}, {0x46a18000}, {0x46a1a000}, {0x46a1c000}, {0x46a1e000}, {0x46a20000}, {0x46a22000}, {0x46a24000}, {0x46a26000}, {0x46a28000}, {0x46a2a000}, {0x46a2c000}, {0x46a2e000}, {0x46a30000}, {0x46a32000}, {0x46a34000}, {0x46a36000}, {0x46a38000}, {0x46a3a000}, {0x46a3c000}, {0x46a3e000}, {0x46a40000}, {0x46a42000}, {0x46a44000}, {0x46a46000}, {0x46a48000}, {0x46a4a000}, {0x46a4c000}, {0x46a4e000}, {0x46a50000}, {0x46a52000}, {0x46a54000}, {0x46a56000}, {0x46a58000}, {0x46a5a000}, {0x46a5c000}, {0x46a5e000}, {0x46a60000}, {0x46a62000}, {0x46a64000}, {0x46a66000}, {0x46a68000}, {0x46a6a000}, {0x46a6c000}, {0x46a6e000}, {0x46a70000}, {0x46a72000}, {0x46a74000}, {0x46a76000}, {0x46a78000}, {0x46a7a000}, {0x46a7c000}, {0x46a7e000}, {0x46a80000}, {0x46a82000}, {0x46a84000}, {0x46a86000}, {0x46a88000}, {0x46a8a000}, {0x46a8c000}, {0x46a8e000}, {0x46a90000}, {0x46a92000}, {0x46a94000}, {0x46a96000}, {0x46a98000}, {0x46a9a000}, {0x46a9c000}, {0x46a9e000}, {0x46aa0000}, {0x46aa2000}, {0x46aa4000}, {0x46aa6000}, {0x46aa8000}, {0x46aaa000}, {0x46aac000}, {0x46aae000}, {0x46ab0000}, {0x46ab2000}, {0x46ab4000}, {0x46ab6000}, {0x46ab8000}, {0x46aba000}, {0x46abc000}, {0x46abe000}, {0x46ac0000}, {0x46ac2000}, {0x46ac4000}, {0x46ac6000}, {0x46ac8000}, {0x46aca000}, {0x46acc000}, {0x46ace000}, {0x46ad0000}, {0x46ad2000}, {0x46ad4000}, {0x46ad6000}, {0x46ad8000}, {0x46ada000}, {0x46adc000}, {0x46ade000}, {0x46ae0000}, {0x46ae2000}, {0x46ae4000}, {0x46ae6000}, {0x46ae8000}, {0x46aea000}, {0x46aec000}, {0x46aee000}, {0x46af0000}, {0x46af2000}, {0x46af4000}, {0x46af6000}, {0x46af8000}, {0x46afa000}, {0x46afc000}, {0x46afe000}, {0x46b00000}, {0x46b02000}, {0x46b04000}, {0x46b06000}, {0x46b08000}, {0x46b0a000}, {0x46b0c000}, {0x46b0e000}, {0x46b10000}, {0x46b12000}, {0x46b14000}, {0x46b16000}, {0x46b18000}, {0x46b1a000}, {0x46b1c000}, {0x46b1e000}, {0x46b20000}, {0x46b22000}, {0x46b24000}, {0x46b26000}, {0x46b28000}, {0x46b2a000}, {0x46b2c000}, {0x46b2e000}, {0x46b30000}, {0x46b32000}, {0x46b34000}, {0x46b36000}, {0x46b38000}, {0x46b3a000}, {0x46b3c000}, {0x46b3e000}, {0x46b40000}, {0x46b42000}, {0x46b44000}, {0x46b46000}, {0x46b48000}, {0x46b4a000}, {0x46b4c000}, {0x46b4e000}, {0x46b50000}, {0x46b52000}, {0x46b54000}, {0x46b56000}, {0x46b58000}, {0x46b5a000}, {0x46b5c000}, {0x46b5e000}, {0x46b60000}, {0x46b62000}, {0x46b64000}, {0x46b66000}, {0x46b68000}, {0x46b6a000}, {0x46b6c000}, {0x46b6e000}, {0x46b70000}, {0x46b72000}, {0x46b74000}, {0x46b76000}, {0x46b78000}, {0x46b7a000}, {0x46b7c000}, {0x46b7e000}, {0x46b80000}, {0x46b82000}, {0x46b84000}, {0x46b86000}, {0x46b88000}, {0x46b8a000}, {0x46b8c000}, {0x46b8e000}, {0x46b90000}, {0x46b92000}, {0x46b94000}, {0x46b96000}, {0x46b98000}, {0x46b9a000}, {0x46b9c000}, {0x46b9e000}, {0x46ba0000}, {0x46ba2000}, {0x46ba4000}, {0x46ba6000}, {0x46ba8000}, {0x46baa000}, {0x46bac000}, {0x46bae000}, {0x46bb0000}, {0x46bb2000}, {0x46bb4000}, {0x46bb6000}, {0x46bb8000}, {0x46bba000}, {0x46bbc000}, {0x46bbe000}, {0x46bc0000}, {0x46bc2000}, {0x46bc4000}, {0x46bc6000}, {0x46bc8000}, {0x46bca000}, {0x46bcc000}, {0x46bce000}, {0x46bd0000}, {0x46bd2000}, {0x46bd4000}, {0x46bd6000}, {0x46bd8000}, {0x46bda000}, {0x46bdc000}, {0x46bde000}, {0x46be0000}, {0x46be2000}, {0x46be4000}, {0x46be6000}, {0x46be8000}, {0x46bea000}, {0x46bec000}, {0x46bee000}, {0x46bf0000}, {0x46bf2000}, {0x46bf4000}, {0x46bf6000}, {0x46bf8000}, {0x46bfa000}, {0x46bfc000}, {0x46bfe000}, {0x46c00000}, {0x46c02000}, {0x46c04000}, {0x46c06000}, {0x46c08000}, {0x46c0a000}, {0x46c0c000}, {0x46c0e000}, {0x46c10000}, {0x46c12000}, {0x46c14000}, {0x46c16000}, {0x46c18000}, {0x46c1a000}, {0x46c1c000}, {0x46c1e000}, {0x46c20000}, {0x46c22000}, {0x46c24000}, {0x46c26000}, {0x46c28000}, {0x46c2a000}, {0x46c2c000}, {0x46c2e000}, {0x46c30000}, {0x46c32000}, {0x46c34000}, {0x46c36000}, {0x46c38000}, {0x46c3a000}, {0x46c3c000}, {0x46c3e000}, {0x46c40000}, {0x46c42000}, {0x46c44000}, {0x46c46000}, {0x46c48000}, {0x46c4a000}, {0x46c4c000}, {0x46c4e000}, {0x46c50000}, {0x46c52000}, {0x46c54000}, {0x46c56000}, {0x46c58000}, {0x46c5a000}, {0x46c5c000}, {0x46c5e000}, {0x46c60000}, {0x46c62000}, {0x46c64000}, {0x46c66000}, {0x46c68000}, {0x46c6a000}, {0x46c6c000}, {0x46c6e000}, {0x46c70000}, {0x46c72000}, {0x46c74000}, {0x46c76000}, {0x46c78000}, {0x46c7a000}, {0x46c7c000}, {0x46c7e000}, {0x46c80000}, {0x46c82000}, {0x46c84000}, {0x46c86000}, {0x46c88000}, {0x46c8a000}, {0x46c8c000}, {0x46c8e000}, {0x46c90000}, {0x46c92000}, {0x46c94000}, {0x46c96000}, {0x46c98000}, {0x46c9a000}, {0x46c9c000}, {0x46c9e000}, {0x46ca0000}, {0x46ca2000}, {0x46ca4000}, {0x46ca6000}, {0x46ca8000}, {0x46caa000}, {0x46cac000}, {0x46cae000}, {0x46cb0000}, {0x46cb2000}, {0x46cb4000}, {0x46cb6000}, {0x46cb8000}, {0x46cba000}, {0x46cbc000}, {0x46cbe000}, {0x46cc0000}, {0x46cc2000}, {0x46cc4000}, {0x46cc6000}, {0x46cc8000}, {0x46cca000}, {0x46ccc000}, {0x46cce000}, {0x46cd0000}, {0x46cd2000}, {0x46cd4000}, {0x46cd6000}, {0x46cd8000}, {0x46cda000}, {0x46cdc000}, {0x46cde000}, {0x46ce0000}, {0x46ce2000}, {0x46ce4000}, {0x46ce6000}, {0x46ce8000}, {0x46cea000}, {0x46cec000}, {0x46cee000}, {0x46cf0000}, {0x46cf2000}, {0x46cf4000}, {0x46cf6000}, {0x46cf8000}, {0x46cfa000}, {0x46cfc000}, {0x46cfe000}, {0x46d00000}, {0x46d02000}, {0x46d04000}, {0x46d06000}, {0x46d08000}, {0x46d0a000}, {0x46d0c000}, {0x46d0e000}, {0x46d10000}, {0x46d12000}, {0x46d14000}, {0x46d16000}, {0x46d18000}, {0x46d1a000}, {0x46d1c000}, {0x46d1e000}, {0x46d20000}, {0x46d22000}, {0x46d24000}, {0x46d26000}, {0x46d28000}, {0x46d2a000}, {0x46d2c000}, {0x46d2e000}, {0x46d30000}, {0x46d32000}, {0x46d34000}, {0x46d36000}, {0x46d38000}, {0x46d3a000}, {0x46d3c000}, {0x46d3e000}, {0x46d40000}, {0x46d42000}, {0x46d44000}, {0x46d46000}, {0x46d48000}, {0x46d4a000}, {0x46d4c000}, {0x46d4e000}, {0x46d50000}, {0x46d52000}, {0x46d54000}, {0x46d56000}, {0x46d58000}, {0x46d5a000}, {0x46d5c000}, {0x46d5e000}, {0x46d60000}, {0x46d62000}, {0x46d64000}, {0x46d66000}, {0x46d68000}, {0x46d6a000}, {0x46d6c000}, {0x46d6e000}, {0x46d70000}, {0x46d72000}, {0x46d74000}, {0x46d76000}, {0x46d78000}, {0x46d7a000}, {0x46d7c000}, {0x46d7e000}, {0x46d80000}, {0x46d82000}, {0x46d84000}, {0x46d86000}, {0x46d88000}, {0x46d8a000}, {0x46d8c000}, {0x46d8e000}, {0x46d90000}, {0x46d92000}, {0x46d94000}, {0x46d96000}, {0x46d98000}, {0x46d9a000}, {0x46d9c000}, {0x46d9e000}, {0x46da0000}, {0x46da2000}, {0x46da4000}, {0x46da6000}, {0x46da8000}, {0x46daa000}, {0x46dac000}, {0x46dae000}, {0x46db0000}, {0x46db2000}, {0x46db4000}, {0x46db6000}, {0x46db8000}, {0x46dba000}, {0x46dbc000}, {0x46dbe000}, {0x46dc0000}, {0x46dc2000}, {0x46dc4000}, {0x46dc6000}, {0x46dc8000}, {0x46dca000}, {0x46dcc000}, {0x46dce000}, {0x46dd0000}, {0x46dd2000}, {0x46dd4000}, {0x46dd6000}, {0x46dd8000}, {0x46dda000}, {0x46ddc000}, {0x46dde000}, {0x46de0000}, {0x46de2000}, {0x46de4000}, {0x46de6000}, {0x46de8000}, {0x46dea000}, {0x46dec000}, {0x46dee000}, {0x46df0000}, {0x46df2000}, {0x46df4000}, {0x46df6000}, {0x46df8000}, {0x46dfa000}, {0x46dfc000}, {0x46dfe000}, {0x46e00000}, {0x46e02000}, {0x46e04000}, {0x46e06000}, {0x46e08000}, {0x46e0a000}, {0x46e0c000}, {0x46e0e000}, {0x46e10000}, {0x46e12000}, {0x46e14000}, {0x46e16000}, {0x46e18000}, {0x46e1a000}, {0x46e1c000}, {0x46e1e000}, {0x46e20000}, {0x46e22000}, {0x46e24000}, {0x46e26000}, {0x46e28000}, {0x46e2a000}, {0x46e2c000}, {0x46e2e000}, {0x46e30000}, {0x46e32000}, {0x46e34000}, {0x46e36000}, {0x46e38000}, {0x46e3a000}, {0x46e3c000}, {0x46e3e000}, {0x46e40000}, {0x46e42000}, {0x46e44000}, {0x46e46000}, {0x46e48000}, {0x46e4a000}, {0x46e4c000}, {0x46e4e000}, {0x46e50000}, {0x46e52000}, {0x46e54000}, {0x46e56000}, {0x46e58000}, {0x46e5a000}, {0x46e5c000}, {0x46e5e000}, {0x46e60000}, {0x46e62000}, {0x46e64000}, {0x46e66000}, {0x46e68000}, {0x46e6a000}, {0x46e6c000}, {0x46e6e000}, {0x46e70000}, {0x46e72000}, {0x46e74000}, {0x46e76000}, {0x46e78000}, {0x46e7a000}, {0x46e7c000}, {0x46e7e000}, {0x46e80000}, {0x46e82000}, {0x46e84000}, {0x46e86000}, {0x46e88000}, {0x46e8a000}, {0x46e8c000}, {0x46e8e000}, {0x46e90000}, {0x46e92000}, {0x46e94000}, {0x46e96000}, {0x46e98000}, {0x46e9a000}, {0x46e9c000}, {0x46e9e000}, {0x46ea0000}, {0x46ea2000}, {0x46ea4000}, {0x46ea6000}, {0x46ea8000}, {0x46eaa000}, {0x46eac000}, {0x46eae000}, {0x46eb0000}, {0x46eb2000}, {0x46eb4000}, {0x46eb6000}, {0x46eb8000}, {0x46eba000}, {0x46ebc000}, {0x46ebe000}, {0x46ec0000}, {0x46ec2000}, {0x46ec4000}, {0x46ec6000}, {0x46ec8000}, {0x46eca000}, {0x46ecc000}, {0x46ece000}, {0x46ed0000}, {0x46ed2000}, {0x46ed4000}, {0x46ed6000}, {0x46ed8000}, {0x46eda000}, {0x46edc000}, {0x46ede000}, {0x46ee0000}, {0x46ee2000}, {0x46ee4000}, {0x46ee6000}, {0x46ee8000}, {0x46eea000}, {0x46eec000}, {0x46eee000}, {0x46ef0000}, {0x46ef2000}, {0x46ef4000}, {0x46ef6000}, {0x46ef8000}, {0x46efa000}, {0x46efc000}, {0x46efe000}, {0x46f00000}, {0x46f02000}, {0x46f04000}, {0x46f06000}, {0x46f08000}, {0x46f0a000}, {0x46f0c000}, {0x46f0e000}, {0x46f10000}, {0x46f12000}, {0x46f14000}, {0x46f16000}, {0x46f18000}, {0x46f1a000}, {0x46f1c000}, {0x46f1e000}, {0x46f20000}, {0x46f22000}, {0x46f24000}, {0x46f26000}, {0x46f28000}, {0x46f2a000}, {0x46f2c000}, {0x46f2e000}, {0x46f30000}, {0x46f32000}, {0x46f34000}, {0x46f36000}, {0x46f38000}, {0x46f3a000}, {0x46f3c000}, {0x46f3e000}, {0x46f40000}, {0x46f42000}, {0x46f44000}, {0x46f46000}, {0x46f48000}, {0x46f4a000}, {0x46f4c000}, {0x46f4e000}, {0x46f50000}, {0x46f52000}, {0x46f54000}, {0x46f56000}, {0x46f58000}, {0x46f5a000}, {0x46f5c000}, {0x46f5e000}, {0x46f60000}, {0x46f62000}, {0x46f64000}, {0x46f66000}, {0x46f68000}, {0x46f6a000}, {0x46f6c000}, {0x46f6e000}, {0x46f70000}, {0x46f72000}, {0x46f74000}, {0x46f76000}, {0x46f78000}, {0x46f7a000}, {0x46f7c000}, {0x46f7e000}, {0x46f80000}, {0x46f82000}, {0x46f84000}, {0x46f86000}, {0x46f88000}, {0x46f8a000}, {0x46f8c000}, {0x46f8e000}, {0x46f90000}, {0x46f92000}, {0x46f94000}, {0x46f96000}, {0x46f98000}, {0x46f9a000}, {0x46f9c000}, {0x46f9e000}, {0x46fa0000}, {0x46fa2000}, {0x46fa4000}, {0x46fa6000}, {0x46fa8000}, {0x46faa000}, {0x46fac000}, {0x46fae000}, {0x46fb0000}, {0x46fb2000}, {0x46fb4000}, {0x46fb6000}, {0x46fb8000}, {0x46fba000}, {0x46fbc000}, {0x46fbe000}, {0x46fc0000}, {0x46fc2000}, {0x46fc4000}, {0x46fc6000}, {0x46fc8000}, {0x46fca000}, {0x46fcc000}, {0x46fce000}, {0x46fd0000}, {0x46fd2000}, {0x46fd4000}, {0x46fd6000}, {0x46fd8000}, {0x46fda000}, {0x46fdc000}, {0x46fde000}, {0x46fe0000}, {0x46fe2000}, {0x46fe4000}, {0x46fe6000}, {0x46fe8000}, {0x46fea000}, {0x46fec000}, {0x46fee000}, {0x46ff0000}, {0x46ff2000}, {0x46ff4000}, {0x46ff6000}, {0x46ff8000}, {0x46ffa000}, {0x46ffc000}, {0x46ffe000}, {0x47000000}, {0x47002000}, {0x47004000}, {0x47006000}, {0x47008000}, {0x4700a000}, {0x4700c000}, {0x4700e000}, {0x47010000}, {0x47012000}, {0x47014000}, {0x47016000}, {0x47018000}, {0x4701a000}, {0x4701c000}, {0x4701e000}, {0x47020000}, {0x47022000}, {0x47024000}, {0x47026000}, {0x47028000}, {0x4702a000}, {0x4702c000}, {0x4702e000}, {0x47030000}, {0x47032000}, {0x47034000}, {0x47036000}, {0x47038000}, {0x4703a000}, {0x4703c000}, {0x4703e000}, {0x47040000}, {0x47042000}, {0x47044000}, {0x47046000}, {0x47048000}, {0x4704a000}, {0x4704c000}, {0x4704e000}, {0x47050000}, {0x47052000}, {0x47054000}, {0x47056000}, {0x47058000}, {0x4705a000}, {0x4705c000}, {0x4705e000}, {0x47060000}, {0x47062000}, {0x47064000}, {0x47066000}, {0x47068000}, {0x4706a000}, {0x4706c000}, {0x4706e000}, {0x47070000}, {0x47072000}, {0x47074000}, {0x47076000}, {0x47078000}, {0x4707a000}, {0x4707c000}, {0x4707e000}, {0x47080000}, {0x47082000}, {0x47084000}, {0x47086000}, {0x47088000}, {0x4708a000}, {0x4708c000}, {0x4708e000}, {0x47090000}, {0x47092000}, {0x47094000}, {0x47096000}, {0x47098000}, {0x4709a000}, {0x4709c000}, {0x4709e000}, {0x470a0000}, {0x470a2000}, {0x470a4000}, {0x470a6000}, {0x470a8000}, {0x470aa000}, {0x470ac000}, {0x470ae000}, {0x470b0000}, {0x470b2000}, {0x470b4000}, {0x470b6000}, {0x470b8000}, {0x470ba000}, {0x470bc000}, {0x470be000}, {0x470c0000}, {0x470c2000}, {0x470c4000}, {0x470c6000}, {0x470c8000}, {0x470ca000}, {0x470cc000}, {0x470ce000}, {0x470d0000}, {0x470d2000}, {0x470d4000}, {0x470d6000}, {0x470d8000}, {0x470da000}, {0x470dc000}, {0x470de000}, {0x470e0000}, {0x470e2000}, {0x470e4000}, {0x470e6000}, {0x470e8000}, {0x470ea000}, {0x470ec000}, {0x470ee000}, {0x470f0000}, {0x470f2000}, {0x470f4000}, {0x470f6000}, {0x470f8000}, {0x470fa000}, {0x470fc000}, {0x470fe000}, {0x47100000}, {0x47102000}, {0x47104000}, {0x47106000}, {0x47108000}, {0x4710a000}, {0x4710c000}, {0x4710e000}, {0x47110000}, {0x47112000}, {0x47114000}, {0x47116000}, {0x47118000}, {0x4711a000}, {0x4711c000}, {0x4711e000}, {0x47120000}, {0x47122000}, {0x47124000}, {0x47126000}, {0x47128000}, {0x4712a000}, {0x4712c000}, {0x4712e000}, {0x47130000}, {0x47132000}, {0x47134000}, {0x47136000}, {0x47138000}, {0x4713a000}, {0x4713c000}, {0x4713e000}, {0x47140000}, {0x47142000}, {0x47144000}, {0x47146000}, {0x47148000}, {0x4714a000}, {0x4714c000}, {0x4714e000}, {0x47150000}, {0x47152000}, {0x47154000}, {0x47156000}, {0x47158000}, {0x4715a000}, {0x4715c000}, {0x4715e000}, {0x47160000}, {0x47162000}, {0x47164000}, {0x47166000}, {0x47168000}, {0x4716a000}, {0x4716c000}, {0x4716e000}, {0x47170000}, {0x47172000}, {0x47174000}, {0x47176000}, {0x47178000}, {0x4717a000}, {0x4717c000}, {0x4717e000}, {0x47180000}, {0x47182000}, {0x47184000}, {0x47186000}, {0x47188000}, {0x4718a000}, {0x4718c000}, {0x4718e000}, {0x47190000}, {0x47192000}, {0x47194000}, {0x47196000}, {0x47198000}, {0x4719a000}, {0x4719c000}, {0x4719e000}, {0x471a0000}, {0x471a2000}, {0x471a4000}, {0x471a6000}, {0x471a8000}, {0x471aa000}, {0x471ac000}, {0x471ae000}, {0x471b0000}, {0x471b2000}, {0x471b4000}, {0x471b6000}, {0x471b8000}, {0x471ba000}, {0x471bc000}, {0x471be000}, {0x471c0000}, {0x471c2000}, {0x471c4000}, {0x471c6000}, {0x471c8000}, {0x471ca000}, {0x471cc000}, {0x471ce000}, {0x471d0000}, {0x471d2000}, {0x471d4000}, {0x471d6000}, {0x471d8000}, {0x471da000}, {0x471dc000}, {0x471de000}, {0x471e0000}, {0x471e2000}, {0x471e4000}, {0x471e6000}, {0x471e8000}, {0x471ea000}, {0x471ec000}, {0x471ee000}, {0x471f0000}, {0x471f2000}, {0x471f4000}, {0x471f6000}, {0x471f8000}, {0x471fa000}, {0x471fc000}, {0x471fe000}, {0x47200000}, {0x47202000}, {0x47204000}, {0x47206000}, {0x47208000}, {0x4720a000}, {0x4720c000}, {0x4720e000}, {0x47210000}, {0x47212000}, {0x47214000}, {0x47216000}, {0x47218000}, {0x4721a000}, {0x4721c000}, {0x4721e000}, {0x47220000}, {0x47222000}, {0x47224000}, {0x47226000}, {0x47228000}, {0x4722a000}, {0x4722c000}, {0x4722e000}, {0x47230000}, {0x47232000}, {0x47234000}, {0x47236000}, {0x47238000}, {0x4723a000}, {0x4723c000}, {0x4723e000}, {0x47240000}, {0x47242000}, {0x47244000}, {0x47246000}, {0x47248000}, {0x4724a000}, {0x4724c000}, {0x4724e000}, {0x47250000}, {0x47252000}, {0x47254000}, {0x47256000}, {0x47258000}, {0x4725a000}, {0x4725c000}, {0x4725e000}, {0x47260000}, {0x47262000}, {0x47264000}, {0x47266000}, {0x47268000}, {0x4726a000}, {0x4726c000}, {0x4726e000}, {0x47270000}, {0x47272000}, {0x47274000}, {0x47276000}, {0x47278000}, {0x4727a000}, {0x4727c000}, {0x4727e000}, {0x47280000}, {0x47282000}, {0x47284000}, {0x47286000}, {0x47288000}, {0x4728a000}, {0x4728c000}, {0x4728e000}, {0x47290000}, {0x47292000}, {0x47294000}, {0x47296000}, {0x47298000}, {0x4729a000}, {0x4729c000}, {0x4729e000}, {0x472a0000}, {0x472a2000}, {0x472a4000}, {0x472a6000}, {0x472a8000}, {0x472aa000}, {0x472ac000}, {0x472ae000}, {0x472b0000}, {0x472b2000}, {0x472b4000}, {0x472b6000}, {0x472b8000}, {0x472ba000}, {0x472bc000}, {0x472be000}, {0x472c0000}, {0x472c2000}, {0x472c4000}, {0x472c6000}, {0x472c8000}, {0x472ca000}, {0x472cc000}, {0x472ce000}, {0x472d0000}, {0x472d2000}, {0x472d4000}, {0x472d6000}, {0x472d8000}, {0x472da000}, {0x472dc000}, {0x472de000}, {0x472e0000}, {0x472e2000}, {0x472e4000}, {0x472e6000}, {0x472e8000}, {0x472ea000}, {0x472ec000}, {0x472ee000}, {0x472f0000}, {0x472f2000}, {0x472f4000}, {0x472f6000}, {0x472f8000}, {0x472fa000}, {0x472fc000}, {0x472fe000}, {0x47300000}, {0x47302000}, {0x47304000}, {0x47306000}, {0x47308000}, {0x4730a000}, {0x4730c000}, {0x4730e000}, {0x47310000}, {0x47312000}, {0x47314000}, {0x47316000}, {0x47318000}, {0x4731a000}, {0x4731c000}, {0x4731e000}, {0x47320000}, {0x47322000}, {0x47324000}, {0x47326000}, {0x47328000}, {0x4732a000}, {0x4732c000}, {0x4732e000}, {0x47330000}, {0x47332000}, {0x47334000}, {0x47336000}, {0x47338000}, {0x4733a000}, {0x4733c000}, {0x4733e000}, {0x47340000}, {0x47342000}, {0x47344000}, {0x47346000}, {0x47348000}, {0x4734a000}, {0x4734c000}, {0x4734e000}, {0x47350000}, {0x47352000}, {0x47354000}, {0x47356000}, {0x47358000}, {0x4735a000}, {0x4735c000}, {0x4735e000}, {0x47360000}, {0x47362000}, {0x47364000}, {0x47366000}, {0x47368000}, {0x4736a000}, {0x4736c000}, {0x4736e000}, {0x47370000}, {0x47372000}, {0x47374000}, {0x47376000}, {0x47378000}, {0x4737a000}, {0x4737c000}, {0x4737e000}, {0x47380000}, {0x47382000}, {0x47384000}, {0x47386000}, {0x47388000}, {0x4738a000}, {0x4738c000}, {0x4738e000}, {0x47390000}, {0x47392000}, {0x47394000}, {0x47396000}, {0x47398000}, {0x4739a000}, {0x4739c000}, {0x4739e000}, {0x473a0000}, {0x473a2000}, {0x473a4000}, {0x473a6000}, {0x473a8000}, {0x473aa000}, {0x473ac000}, {0x473ae000}, {0x473b0000}, {0x473b2000}, {0x473b4000}, {0x473b6000}, {0x473b8000}, {0x473ba000}, {0x473bc000}, {0x473be000}, {0x473c0000}, {0x473c2000}, {0x473c4000}, {0x473c6000}, {0x473c8000}, {0x473ca000}, {0x473cc000}, {0x473ce000}, {0x473d0000}, {0x473d2000}, {0x473d4000}, {0x473d6000}, {0x473d8000}, {0x473da000}, {0x473dc000}, {0x473de000}, {0x473e0000}, {0x473e2000}, {0x473e4000}, {0x473e6000}, {0x473e8000}, {0x473ea000}, {0x473ec000}, {0x473ee000}, {0x473f0000}, {0x473f2000}, {0x473f4000}, {0x473f6000}, {0x473f8000}, {0x473fa000}, {0x473fc000}, {0x473fe000}, {0x47400000}, {0x47402000}, {0x47404000}, {0x47406000}, {0x47408000}, {0x4740a000}, {0x4740c000}, {0x4740e000}, {0x47410000}, {0x47412000}, {0x47414000}, {0x47416000}, {0x47418000}, {0x4741a000}, {0x4741c000}, {0x4741e000}, {0x47420000}, {0x47422000}, {0x47424000}, {0x47426000}, {0x47428000}, {0x4742a000}, {0x4742c000}, {0x4742e000}, {0x47430000}, {0x47432000}, {0x47434000}, {0x47436000}, {0x47438000}, {0x4743a000}, {0x4743c000}, {0x4743e000}, {0x47440000}, {0x47442000}, {0x47444000}, {0x47446000}, {0x47448000}, {0x4744a000}, {0x4744c000}, {0x4744e000}, {0x47450000}, {0x47452000}, {0x47454000}, {0x47456000}, {0x47458000}, {0x4745a000}, {0x4745c000}, {0x4745e000}, {0x47460000}, {0x47462000}, {0x47464000}, {0x47466000}, {0x47468000}, {0x4746a000}, {0x4746c000}, {0x4746e000}, {0x47470000}, {0x47472000}, {0x47474000}, {0x47476000}, {0x47478000}, {0x4747a000}, {0x4747c000}, {0x4747e000}, {0x47480000}, {0x47482000}, {0x47484000}, {0x47486000}, {0x47488000}, {0x4748a000}, {0x4748c000}, {0x4748e000}, {0x47490000}, {0x47492000}, {0x47494000}, {0x47496000}, {0x47498000}, {0x4749a000}, {0x4749c000}, {0x4749e000}, {0x474a0000}, {0x474a2000}, {0x474a4000}, {0x474a6000}, {0x474a8000}, {0x474aa000}, {0x474ac000}, {0x474ae000}, {0x474b0000}, {0x474b2000}, {0x474b4000}, {0x474b6000}, {0x474b8000}, {0x474ba000}, {0x474bc000}, {0x474be000}, {0x474c0000}, {0x474c2000}, {0x474c4000}, {0x474c6000}, {0x474c8000}, {0x474ca000}, {0x474cc000}, {0x474ce000}, {0x474d0000}, {0x474d2000}, {0x474d4000}, {0x474d6000}, {0x474d8000}, {0x474da000}, {0x474dc000}, {0x474de000}, {0x474e0000}, {0x474e2000}, {0x474e4000}, {0x474e6000}, {0x474e8000}, {0x474ea000}, {0x474ec000}, {0x474ee000}, {0x474f0000}, {0x474f2000}, {0x474f4000}, {0x474f6000}, {0x474f8000}, {0x474fa000}, {0x474fc000}, {0x474fe000}, {0x47500000}, {0x47502000}, {0x47504000}, {0x47506000}, {0x47508000}, {0x4750a000}, {0x4750c000}, {0x4750e000}, {0x47510000}, {0x47512000}, {0x47514000}, {0x47516000}, {0x47518000}, {0x4751a000}, {0x4751c000}, {0x4751e000}, {0x47520000}, {0x47522000}, {0x47524000}, {0x47526000}, {0x47528000}, {0x4752a000}, {0x4752c000}, {0x4752e000}, {0x47530000}, {0x47532000}, {0x47534000}, {0x47536000}, {0x47538000}, {0x4753a000}, {0x4753c000}, {0x4753e000}, {0x47540000}, {0x47542000}, {0x47544000}, {0x47546000}, {0x47548000}, {0x4754a000}, {0x4754c000}, {0x4754e000}, {0x47550000}, {0x47552000}, {0x47554000}, {0x47556000}, {0x47558000}, {0x4755a000}, {0x4755c000}, {0x4755e000}, {0x47560000}, {0x47562000}, {0x47564000}, {0x47566000}, {0x47568000}, {0x4756a000}, {0x4756c000}, {0x4756e000}, {0x47570000}, {0x47572000}, {0x47574000}, {0x47576000}, {0x47578000}, {0x4757a000}, {0x4757c000}, {0x4757e000}, {0x47580000}, {0x47582000}, {0x47584000}, {0x47586000}, {0x47588000}, {0x4758a000}, {0x4758c000}, {0x4758e000}, {0x47590000}, {0x47592000}, {0x47594000}, {0x47596000}, {0x47598000}, {0x4759a000}, {0x4759c000}, {0x4759e000}, {0x475a0000}, {0x475a2000}, {0x475a4000}, {0x475a6000}, {0x475a8000}, {0x475aa000}, {0x475ac000}, {0x475ae000}, {0x475b0000}, {0x475b2000}, {0x475b4000}, {0x475b6000}, {0x475b8000}, {0x475ba000}, {0x475bc000}, {0x475be000}, {0x475c0000}, {0x475c2000}, {0x475c4000}, {0x475c6000}, {0x475c8000}, {0x475ca000}, {0x475cc000}, {0x475ce000}, {0x475d0000}, {0x475d2000}, {0x475d4000}, {0x475d6000}, {0x475d8000}, {0x475da000}, {0x475dc000}, {0x475de000}, {0x475e0000}, {0x475e2000}, {0x475e4000}, {0x475e6000}, {0x475e8000}, {0x475ea000}, {0x475ec000}, {0x475ee000}, {0x475f0000}, {0x475f2000}, {0x475f4000}, {0x475f6000}, {0x475f8000}, {0x475fa000}, {0x475fc000}, {0x475fe000}, {0x47600000}, {0x47602000}, {0x47604000}, {0x47606000}, {0x47608000}, {0x4760a000}, {0x4760c000}, {0x4760e000}, {0x47610000}, {0x47612000}, {0x47614000}, {0x47616000}, {0x47618000}, {0x4761a000}, {0x4761c000}, {0x4761e000}, {0x47620000}, {0x47622000}, {0x47624000}, {0x47626000}, {0x47628000}, {0x4762a000}, {0x4762c000}, {0x4762e000}, {0x47630000}, {0x47632000}, {0x47634000}, {0x47636000}, {0x47638000}, {0x4763a000}, {0x4763c000}, {0x4763e000}, {0x47640000}, {0x47642000}, {0x47644000}, {0x47646000}, {0x47648000}, {0x4764a000}, {0x4764c000}, {0x4764e000}, {0x47650000}, {0x47652000}, {0x47654000}, {0x47656000}, {0x47658000}, {0x4765a000}, {0x4765c000}, {0x4765e000}, {0x47660000}, {0x47662000}, {0x47664000}, {0x47666000}, {0x47668000}, {0x4766a000}, {0x4766c000}, {0x4766e000}, {0x47670000}, {0x47672000}, {0x47674000}, {0x47676000}, {0x47678000}, {0x4767a000}, {0x4767c000}, {0x4767e000}, {0x47680000}, {0x47682000}, {0x47684000}, {0x47686000}, {0x47688000}, {0x4768a000}, {0x4768c000}, {0x4768e000}, {0x47690000}, {0x47692000}, {0x47694000}, {0x47696000}, {0x47698000}, {0x4769a000}, {0x4769c000}, {0x4769e000}, {0x476a0000}, {0x476a2000}, {0x476a4000}, {0x476a6000}, {0x476a8000}, {0x476aa000}, {0x476ac000}, {0x476ae000}, {0x476b0000}, {0x476b2000}, {0x476b4000}, {0x476b6000}, {0x476b8000}, {0x476ba000}, {0x476bc000}, {0x476be000}, {0x476c0000}, {0x476c2000}, {0x476c4000}, {0x476c6000}, {0x476c8000}, {0x476ca000}, {0x476cc000}, {0x476ce000}, {0x476d0000}, {0x476d2000}, {0x476d4000}, {0x476d6000}, {0x476d8000}, {0x476da000}, {0x476dc000}, {0x476de000}, {0x476e0000}, {0x476e2000}, {0x476e4000}, {0x476e6000}, {0x476e8000}, {0x476ea000}, {0x476ec000}, {0x476ee000}, {0x476f0000}, {0x476f2000}, {0x476f4000}, {0x476f6000}, {0x476f8000}, {0x476fa000}, {0x476fc000}, {0x476fe000}, {0x47700000}, {0x47702000}, {0x47704000}, {0x47706000}, {0x47708000}, {0x4770a000}, {0x4770c000}, {0x4770e000}, {0x47710000}, {0x47712000}, {0x47714000}, {0x47716000}, {0x47718000}, {0x4771a000}, {0x4771c000}, {0x4771e000}, {0x47720000}, {0x47722000}, {0x47724000}, {0x47726000}, {0x47728000}, {0x4772a000}, {0x4772c000}, {0x4772e000}, {0x47730000}, {0x47732000}, {0x47734000}, {0x47736000}, {0x47738000}, {0x4773a000}, {0x4773c000}, {0x4773e000}, {0x47740000}, {0x47742000}, {0x47744000}, {0x47746000}, {0x47748000}, {0x4774a000}, {0x4774c000}, {0x4774e000}, {0x47750000}, {0x47752000}, {0x47754000}, {0x47756000}, {0x47758000}, {0x4775a000}, {0x4775c000}, {0x4775e000}, {0x47760000}, {0x47762000}, {0x47764000}, {0x47766000}, {0x47768000}, {0x4776a000}, {0x4776c000}, {0x4776e000}, {0x47770000}, {0x47772000}, {0x47774000}, {0x47776000}, {0x47778000}, {0x4777a000}, {0x4777c000}, {0x4777e000}, {0x47780000}, {0x47782000}, {0x47784000}, {0x47786000}, {0x47788000}, {0x4778a000}, {0x4778c000}, {0x4778e000}, {0x47790000}, {0x47792000}, {0x47794000}, {0x47796000}, {0x47798000}, {0x4779a000}, {0x4779c000}, {0x4779e000}, {0x477a0000}, {0x477a2000}, {0x477a4000}, {0x477a6000}, {0x477a8000}, {0x477aa000}, {0x477ac000}, {0x477ae000}, {0x477b0000}, {0x477b2000}, {0x477b4000}, {0x477b6000}, {0x477b8000}, {0x477ba000}, {0x477bc000}, {0x477be000}, {0x477c0000}, {0x477c2000}, {0x477c4000}, {0x477c6000}, {0x477c8000}, {0x477ca000}, {0x477cc000}, {0x477ce000}, {0x477d0000}, {0x477d2000}, {0x477d4000}, {0x477d6000}, {0x477d8000}, {0x477da000}, {0x477dc000}, {0x477de000}, {0x477e0000}, {0x477e2000}, {0x477e4000}, {0x477e6000}, {0x477e8000}, {0x477ea000}, {0x477ec000}, {0x477ee000}, {0x477f0000}, {0x477f2000}, {0x477f4000}, {0x477f6000}, {0x477f8000}, {0x477fa000}, {0x477fc000}, {0x477fe000}, {0x7f800000}, {0x7f802000}, {0x7f804000}, {0x7f806000}, {0x7f808000}, {0x7f80a000}, {0x7f80c000}, {0x7f80e000}, {0x7f810000}, {0x7f812000}, {0x7f814000}, {0x7f816000}, {0x7f818000}, {0x7f81a000}, {0x7f81c000}, {0x7f81e000}, {0x7f820000}, {0x7f822000}, {0x7f824000}, {0x7f826000}, {0x7f828000}, {0x7f82a000}, {0x7f82c000}, {0x7f82e000}, {0x7f830000}, {0x7f832000}, {0x7f834000}, {0x7f836000}, {0x7f838000}, {0x7f83a000}, {0x7f83c000}, {0x7f83e000}, {0x7f840000}, {0x7f842000}, {0x7f844000}, {0x7f846000}, {0x7f848000}, {0x7f84a000}, {0x7f84c000}, {0x7f84e000}, {0x7f850000}, {0x7f852000}, {0x7f854000}, {0x7f856000}, {0x7f858000}, {0x7f85a000}, {0x7f85c000}, {0x7f85e000}, {0x7f860000}, {0x7f862000}, {0x7f864000}, {0x7f866000}, {0x7f868000}, {0x7f86a000}, {0x7f86c000}, {0x7f86e000}, {0x7f870000}, {0x7f872000}, {0x7f874000}, {0x7f876000}, {0x7f878000}, {0x7f87a000}, {0x7f87c000}, {0x7f87e000}, {0x7f880000}, {0x7f882000}, {0x7f884000}, {0x7f886000}, {0x7f888000}, {0x7f88a000}, {0x7f88c000}, {0x7f88e000}, {0x7f890000}, {0x7f892000}, {0x7f894000}, {0x7f896000}, {0x7f898000}, {0x7f89a000}, {0x7f89c000}, {0x7f89e000}, {0x7f8a0000}, {0x7f8a2000}, {0x7f8a4000}, {0x7f8a6000}, {0x7f8a8000}, {0x7f8aa000}, {0x7f8ac000}, {0x7f8ae000}, {0x7f8b0000}, {0x7f8b2000}, {0x7f8b4000}, {0x7f8b6000}, {0x7f8b8000}, {0x7f8ba000}, {0x7f8bc000}, {0x7f8be000}, {0x7f8c0000}, {0x7f8c2000}, {0x7f8c4000}, {0x7f8c6000}, {0x7f8c8000}, {0x7f8ca000}, {0x7f8cc000}, {0x7f8ce000}, {0x7f8d0000}, {0x7f8d2000}, {0x7f8d4000}, {0x7f8d6000}, {0x7f8d8000}, {0x7f8da000}, {0x7f8dc000}, {0x7f8de000}, {0x7f8e0000}, {0x7f8e2000}, {0x7f8e4000}, {0x7f8e6000}, {0x7f8e8000}, {0x7f8ea000}, {0x7f8ec000}, {0x7f8ee000}, {0x7f8f0000}, {0x7f8f2000}, {0x7f8f4000}, {0x7f8f6000}, {0x7f8f8000}, {0x7f8fa000}, {0x7f8fc000}, {0x7f8fe000}, {0x7f900000}, {0x7f902000}, {0x7f904000}, {0x7f906000}, {0x7f908000}, {0x7f90a000}, {0x7f90c000}, {0x7f90e000}, {0x7f910000}, {0x7f912000}, {0x7f914000}, {0x7f916000}, {0x7f918000}, {0x7f91a000}, {0x7f91c000}, {0x7f91e000}, {0x7f920000}, {0x7f922000}, {0x7f924000}, {0x7f926000}, {0x7f928000}, {0x7f92a000}, {0x7f92c000}, {0x7f92e000}, {0x7f930000}, {0x7f932000}, {0x7f934000}, {0x7f936000}, {0x7f938000}, {0x7f93a000}, {0x7f93c000}, {0x7f93e000}, {0x7f940000}, {0x7f942000}, {0x7f944000}, {0x7f946000}, {0x7f948000}, {0x7f94a000}, {0x7f94c000}, {0x7f94e000}, {0x7f950000}, {0x7f952000}, {0x7f954000}, {0x7f956000}, {0x7f958000}, {0x7f95a000}, {0x7f95c000}, {0x7f95e000}, {0x7f960000}, {0x7f962000}, {0x7f964000}, {0x7f966000}, {0x7f968000}, {0x7f96a000}, {0x7f96c000}, {0x7f96e000}, {0x7f970000}, {0x7f972000}, {0x7f974000}, {0x7f976000}, {0x7f978000}, {0x7f97a000}, {0x7f97c000}, {0x7f97e000}, {0x7f980000}, {0x7f982000}, {0x7f984000}, {0x7f986000}, {0x7f988000}, {0x7f98a000}, {0x7f98c000}, {0x7f98e000}, {0x7f990000}, {0x7f992000}, {0x7f994000}, {0x7f996000}, {0x7f998000}, {0x7f99a000}, {0x7f99c000}, {0x7f99e000}, {0x7f9a0000}, {0x7f9a2000}, {0x7f9a4000}, {0x7f9a6000}, {0x7f9a8000}, {0x7f9aa000}, {0x7f9ac000}, {0x7f9ae000}, {0x7f9b0000}, {0x7f9b2000}, {0x7f9b4000}, {0x7f9b6000}, {0x7f9b8000}, {0x7f9ba000}, {0x7f9bc000}, {0x7f9be000}, {0x7f9c0000}, {0x7f9c2000}, {0x7f9c4000}, {0x7f9c6000}, {0x7f9c8000}, {0x7f9ca000}, {0x7f9cc000}, {0x7f9ce000}, {0x7f9d0000}, {0x7f9d2000}, {0x7f9d4000}, {0x7f9d6000}, {0x7f9d8000}, {0x7f9da000}, {0x7f9dc000}, {0x7f9de000}, {0x7f9e0000}, {0x7f9e2000}, {0x7f9e4000}, {0x7f9e6000}, {0x7f9e8000}, {0x7f9ea000}, {0x7f9ec000}, {0x7f9ee000}, {0x7f9f0000}, {0x7f9f2000}, {0x7f9f4000}, {0x7f9f6000}, {0x7f9f8000}, {0x7f9fa000}, {0x7f9fc000}, {0x7f9fe000}, {0x7fa00000}, {0x7fa02000}, {0x7fa04000}, {0x7fa06000}, {0x7fa08000}, {0x7fa0a000}, {0x7fa0c000}, {0x7fa0e000}, {0x7fa10000}, {0x7fa12000}, {0x7fa14000}, {0x7fa16000}, {0x7fa18000}, {0x7fa1a000}, {0x7fa1c000}, {0x7fa1e000}, {0x7fa20000}, {0x7fa22000}, {0x7fa24000}, {0x7fa26000}, {0x7fa28000}, {0x7fa2a000}, {0x7fa2c000}, {0x7fa2e000}, {0x7fa30000}, {0x7fa32000}, {0x7fa34000}, {0x7fa36000}, {0x7fa38000}, {0x7fa3a000}, {0x7fa3c000}, {0x7fa3e000}, {0x7fa40000}, {0x7fa42000}, {0x7fa44000}, {0x7fa46000}, {0x7fa48000}, {0x7fa4a000}, {0x7fa4c000}, {0x7fa4e000}, {0x7fa50000}, {0x7fa52000}, {0x7fa54000}, {0x7fa56000}, {0x7fa58000}, {0x7fa5a000}, {0x7fa5c000}, {0x7fa5e000}, {0x7fa60000}, {0x7fa62000}, {0x7fa64000}, {0x7fa66000}, {0x7fa68000}, {0x7fa6a000}, {0x7fa6c000}, {0x7fa6e000}, {0x7fa70000}, {0x7fa72000}, {0x7fa74000}, {0x7fa76000}, {0x7fa78000}, {0x7fa7a000}, {0x7fa7c000}, {0x7fa7e000}, {0x7fa80000}, {0x7fa82000}, {0x7fa84000}, {0x7fa86000}, {0x7fa88000}, {0x7fa8a000}, {0x7fa8c000}, {0x7fa8e000}, {0x7fa90000}, {0x7fa92000}, {0x7fa94000}, {0x7fa96000}, {0x7fa98000}, {0x7fa9a000}, {0x7fa9c000}, {0x7fa9e000}, {0x7faa0000}, {0x7faa2000}, {0x7faa4000}, {0x7faa6000}, {0x7faa8000}, {0x7faaa000}, {0x7faac000}, {0x7faae000}, {0x7fab0000}, {0x7fab2000}, {0x7fab4000}, {0x7fab6000}, {0x7fab8000}, {0x7faba000}, {0x7fabc000}, {0x7fabe000}, {0x7fac0000}, {0x7fac2000}, {0x7fac4000}, {0x7fac6000}, {0x7fac8000}, {0x7faca000}, {0x7facc000}, {0x7face000}, {0x7fad0000}, {0x7fad2000}, {0x7fad4000}, {0x7fad6000}, {0x7fad8000}, {0x7fada000}, {0x7fadc000}, {0x7fade000}, {0x7fae0000}, {0x7fae2000}, {0x7fae4000}, {0x7fae6000}, {0x7fae8000}, {0x7faea000}, {0x7faec000}, {0x7faee000}, {0x7faf0000}, {0x7faf2000}, {0x7faf4000}, {0x7faf6000}, {0x7faf8000}, {0x7fafa000}, {0x7fafc000}, {0x7fafe000}, {0x7fb00000}, {0x7fb02000}, {0x7fb04000}, {0x7fb06000}, {0x7fb08000}, {0x7fb0a000}, {0x7fb0c000}, {0x7fb0e000}, {0x7fb10000}, {0x7fb12000}, {0x7fb14000}, {0x7fb16000}, {0x7fb18000}, {0x7fb1a000}, {0x7fb1c000}, {0x7fb1e000}, {0x7fb20000}, {0x7fb22000}, {0x7fb24000}, {0x7fb26000}, {0x7fb28000}, {0x7fb2a000}, {0x7fb2c000}, {0x7fb2e000}, {0x7fb30000}, {0x7fb32000}, {0x7fb34000}, {0x7fb36000}, {0x7fb38000}, {0x7fb3a000}, {0x7fb3c000}, {0x7fb3e000}, {0x7fb40000}, {0x7fb42000}, {0x7fb44000}, {0x7fb46000}, {0x7fb48000}, {0x7fb4a000}, {0x7fb4c000}, {0x7fb4e000}, {0x7fb50000}, {0x7fb52000}, {0x7fb54000}, {0x7fb56000}, {0x7fb58000}, {0x7fb5a000}, {0x7fb5c000}, {0x7fb5e000}, {0x7fb60000}, {0x7fb62000}, {0x7fb64000}, {0x7fb66000}, {0x7fb68000}, {0x7fb6a000}, {0x7fb6c000}, {0x7fb6e000}, {0x7fb70000}, {0x7fb72000}, {0x7fb74000}, {0x7fb76000}, {0x7fb78000}, {0x7fb7a000}, {0x7fb7c000}, {0x7fb7e000}, {0x7fb80000}, {0x7fb82000}, {0x7fb84000}, {0x7fb86000}, {0x7fb88000}, {0x7fb8a000}, {0x7fb8c000}, {0x7fb8e000}, {0x7fb90000}, {0x7fb92000}, {0x7fb94000}, {0x7fb96000}, {0x7fb98000}, {0x7fb9a000}, {0x7fb9c000}, {0x7fb9e000}, {0x7fba0000}, {0x7fba2000}, {0x7fba4000}, {0x7fba6000}, {0x7fba8000}, {0x7fbaa000}, {0x7fbac000}, {0x7fbae000}, {0x7fbb0000}, {0x7fbb2000}, {0x7fbb4000}, {0x7fbb6000}, {0x7fbb8000}, {0x7fbba000}, {0x7fbbc000}, {0x7fbbe000}, {0x7fbc0000}, {0x7fbc2000}, {0x7fbc4000}, {0x7fbc6000}, {0x7fbc8000}, {0x7fbca000}, {0x7fbcc000}, {0x7fbce000}, {0x7fbd0000}, {0x7fbd2000}, {0x7fbd4000}, {0x7fbd6000}, {0x7fbd8000}, {0x7fbda000}, {0x7fbdc000}, {0x7fbde000}, {0x7fbe0000}, {0x7fbe2000}, {0x7fbe4000}, {0x7fbe6000}, {0x7fbe8000}, {0x7fbea000}, {0x7fbec000}, {0x7fbee000}, {0x7fbf0000}, {0x7fbf2000}, {0x7fbf4000}, {0x7fbf6000}, {0x7fbf8000}, {0x7fbfa000}, {0x7fbfc000}, {0x7fbfe000}, {0x7fc00000}, {0x7fc02000}, {0x7fc04000}, {0x7fc06000}, {0x7fc08000}, {0x7fc0a000}, {0x7fc0c000}, {0x7fc0e000}, {0x7fc10000}, {0x7fc12000}, {0x7fc14000}, {0x7fc16000}, {0x7fc18000}, {0x7fc1a000}, {0x7fc1c000}, {0x7fc1e000}, {0x7fc20000}, {0x7fc22000}, {0x7fc24000}, {0x7fc26000}, {0x7fc28000}, {0x7fc2a000}, {0x7fc2c000}, {0x7fc2e000}, {0x7fc30000}, {0x7fc32000}, {0x7fc34000}, {0x7fc36000}, {0x7fc38000}, {0x7fc3a000}, {0x7fc3c000}, {0x7fc3e000}, {0x7fc40000}, {0x7fc42000}, {0x7fc44000}, {0x7fc46000}, {0x7fc48000}, {0x7fc4a000}, {0x7fc4c000}, {0x7fc4e000}, {0x7fc50000}, {0x7fc52000}, {0x7fc54000}, {0x7fc56000}, {0x7fc58000}, {0x7fc5a000}, {0x7fc5c000}, {0x7fc5e000}, {0x7fc60000}, {0x7fc62000}, {0x7fc64000}, {0x7fc66000}, {0x7fc68000}, {0x7fc6a000}, {0x7fc6c000}, {0x7fc6e000}, {0x7fc70000}, {0x7fc72000}, {0x7fc74000}, {0x7fc76000}, {0x7fc78000}, {0x7fc7a000}, {0x7fc7c000}, {0x7fc7e000}, {0x7fc80000}, {0x7fc82000}, {0x7fc84000}, {0x7fc86000}, {0x7fc88000}, {0x7fc8a000}, {0x7fc8c000}, {0x7fc8e000}, {0x7fc90000}, {0x7fc92000}, {0x7fc94000}, {0x7fc96000}, {0x7fc98000}, {0x7fc9a000}, {0x7fc9c000}, {0x7fc9e000}, {0x7fca0000}, {0x7fca2000}, {0x7fca4000}, {0x7fca6000}, {0x7fca8000}, {0x7fcaa000}, {0x7fcac000}, {0x7fcae000}, {0x7fcb0000}, {0x7fcb2000}, {0x7fcb4000}, {0x7fcb6000}, {0x7fcb8000}, {0x7fcba000}, {0x7fcbc000}, {0x7fcbe000}, {0x7fcc0000}, {0x7fcc2000}, {0x7fcc4000}, {0x7fcc6000}, {0x7fcc8000}, {0x7fcca000}, {0x7fccc000}, {0x7fcce000}, {0x7fcd0000}, {0x7fcd2000}, {0x7fcd4000}, {0x7fcd6000}, {0x7fcd8000}, {0x7fcda000}, {0x7fcdc000}, {0x7fcde000}, {0x7fce0000}, {0x7fce2000}, {0x7fce4000}, {0x7fce6000}, {0x7fce8000}, {0x7fcea000}, {0x7fcec000}, {0x7fcee000}, {0x7fcf0000}, {0x7fcf2000}, {0x7fcf4000}, {0x7fcf6000}, {0x7fcf8000}, {0x7fcfa000}, {0x7fcfc000}, {0x7fcfe000}, {0x7fd00000}, {0x7fd02000}, {0x7fd04000}, {0x7fd06000}, {0x7fd08000}, {0x7fd0a000}, {0x7fd0c000}, {0x7fd0e000}, {0x7fd10000}, {0x7fd12000}, {0x7fd14000}, {0x7fd16000}, {0x7fd18000}, {0x7fd1a000}, {0x7fd1c000}, {0x7fd1e000}, {0x7fd20000}, {0x7fd22000}, {0x7fd24000}, {0x7fd26000}, {0x7fd28000}, {0x7fd2a000}, {0x7fd2c000}, {0x7fd2e000}, {0x7fd30000}, {0x7fd32000}, {0x7fd34000}, {0x7fd36000}, {0x7fd38000}, {0x7fd3a000}, {0x7fd3c000}, {0x7fd3e000}, {0x7fd40000}, {0x7fd42000}, {0x7fd44000}, {0x7fd46000}, {0x7fd48000}, {0x7fd4a000}, {0x7fd4c000}, {0x7fd4e000}, {0x7fd50000}, {0x7fd52000}, {0x7fd54000}, {0x7fd56000}, {0x7fd58000}, {0x7fd5a000}, {0x7fd5c000}, {0x7fd5e000}, {0x7fd60000}, {0x7fd62000}, {0x7fd64000}, {0x7fd66000}, {0x7fd68000}, {0x7fd6a000}, {0x7fd6c000}, {0x7fd6e000}, {0x7fd70000}, {0x7fd72000}, {0x7fd74000}, {0x7fd76000}, {0x7fd78000}, {0x7fd7a000}, {0x7fd7c000}, {0x7fd7e000}, {0x7fd80000}, {0x7fd82000}, {0x7fd84000}, {0x7fd86000}, {0x7fd88000}, {0x7fd8a000}, {0x7fd8c000}, {0x7fd8e000}, {0x7fd90000}, {0x7fd92000}, {0x7fd94000}, {0x7fd96000}, {0x7fd98000}, {0x7fd9a000}, {0x7fd9c000}, {0x7fd9e000}, {0x7fda0000}, {0x7fda2000}, {0x7fda4000}, {0x7fda6000}, {0x7fda8000}, {0x7fdaa000}, {0x7fdac000}, {0x7fdae000}, {0x7fdb0000}, {0x7fdb2000}, {0x7fdb4000}, {0x7fdb6000}, {0x7fdb8000}, {0x7fdba000}, {0x7fdbc000}, {0x7fdbe000}, {0x7fdc0000}, {0x7fdc2000}, {0x7fdc4000}, {0x7fdc6000}, {0x7fdc8000}, {0x7fdca000}, {0x7fdcc000}, {0x7fdce000}, {0x7fdd0000}, {0x7fdd2000}, {0x7fdd4000}, {0x7fdd6000}, {0x7fdd8000}, {0x7fdda000}, {0x7fddc000}, {0x7fdde000}, {0x7fde0000}, {0x7fde2000}, {0x7fde4000}, {0x7fde6000}, {0x7fde8000}, {0x7fdea000}, {0x7fdec000}, {0x7fdee000}, {0x7fdf0000}, {0x7fdf2000}, {0x7fdf4000}, {0x7fdf6000}, {0x7fdf8000}, {0x7fdfa000}, {0x7fdfc000}, {0x7fdfe000}, {0x7fe00000}, {0x7fe02000}, {0x7fe04000}, {0x7fe06000}, {0x7fe08000}, {0x7fe0a000}, {0x7fe0c000}, {0x7fe0e000}, {0x7fe10000}, {0x7fe12000}, {0x7fe14000}, {0x7fe16000}, {0x7fe18000}, {0x7fe1a000}, {0x7fe1c000}, {0x7fe1e000}, {0x7fe20000}, {0x7fe22000}, {0x7fe24000}, {0x7fe26000}, {0x7fe28000}, {0x7fe2a000}, {0x7fe2c000}, {0x7fe2e000}, {0x7fe30000}, {0x7fe32000}, {0x7fe34000}, {0x7fe36000}, {0x7fe38000}, {0x7fe3a000}, {0x7fe3c000}, {0x7fe3e000}, {0x7fe40000}, {0x7fe42000}, {0x7fe44000}, {0x7fe46000}, {0x7fe48000}, {0x7fe4a000}, {0x7fe4c000}, {0x7fe4e000}, {0x7fe50000}, {0x7fe52000}, {0x7fe54000}, {0x7fe56000}, {0x7fe58000}, {0x7fe5a000}, {0x7fe5c000}, {0x7fe5e000}, {0x7fe60000}, {0x7fe62000}, {0x7fe64000}, {0x7fe66000}, {0x7fe68000}, {0x7fe6a000}, {0x7fe6c000}, {0x7fe6e000}, {0x7fe70000}, {0x7fe72000}, {0x7fe74000}, {0x7fe76000}, {0x7fe78000}, {0x7fe7a000}, {0x7fe7c000}, {0x7fe7e000}, {0x7fe80000}, {0x7fe82000}, {0x7fe84000}, {0x7fe86000}, {0x7fe88000}, {0x7fe8a000}, {0x7fe8c000}, {0x7fe8e000}, {0x7fe90000}, {0x7fe92000}, {0x7fe94000}, {0x7fe96000}, {0x7fe98000}, {0x7fe9a000}, {0x7fe9c000}, {0x7fe9e000}, {0x7fea0000}, {0x7fea2000}, {0x7fea4000}, {0x7fea6000}, {0x7fea8000}, {0x7feaa000}, {0x7feac000}, {0x7feae000}, {0x7feb0000}, {0x7feb2000}, {0x7feb4000}, {0x7feb6000}, {0x7feb8000}, {0x7feba000}, {0x7febc000}, {0x7febe000}, {0x7fec0000}, {0x7fec2000}, {0x7fec4000}, {0x7fec6000}, {0x7fec8000}, {0x7feca000}, {0x7fecc000}, {0x7fece000}, {0x7fed0000}, {0x7fed2000}, {0x7fed4000}, {0x7fed6000}, {0x7fed8000}, {0x7feda000}, {0x7fedc000}, {0x7fede000}, {0x7fee0000}, {0x7fee2000}, {0x7fee4000}, {0x7fee6000}, {0x7fee8000}, {0x7feea000}, {0x7feec000}, {0x7feee000}, {0x7fef0000}, {0x7fef2000}, {0x7fef4000}, {0x7fef6000}, {0x7fef8000}, {0x7fefa000}, {0x7fefc000}, {0x7fefe000}, {0x7ff00000}, {0x7ff02000}, {0x7ff04000}, {0x7ff06000}, {0x7ff08000}, {0x7ff0a000}, {0x7ff0c000}, {0x7ff0e000}, {0x7ff10000}, {0x7ff12000}, {0x7ff14000}, {0x7ff16000}, {0x7ff18000}, {0x7ff1a000}, {0x7ff1c000}, {0x7ff1e000}, {0x7ff20000}, {0x7ff22000}, {0x7ff24000}, {0x7ff26000}, {0x7ff28000}, {0x7ff2a000}, {0x7ff2c000}, {0x7ff2e000}, {0x7ff30000}, {0x7ff32000}, {0x7ff34000}, {0x7ff36000}, {0x7ff38000}, {0x7ff3a000}, {0x7ff3c000}, {0x7ff3e000}, {0x7ff40000}, {0x7ff42000}, {0x7ff44000}, {0x7ff46000}, {0x7ff48000}, {0x7ff4a000}, {0x7ff4c000}, {0x7ff4e000}, {0x7ff50000}, {0x7ff52000}, {0x7ff54000}, {0x7ff56000}, {0x7ff58000}, {0x7ff5a000}, {0x7ff5c000}, {0x7ff5e000}, {0x7ff60000}, {0x7ff62000}, {0x7ff64000}, {0x7ff66000}, {0x7ff68000}, {0x7ff6a000}, {0x7ff6c000}, {0x7ff6e000}, {0x7ff70000}, {0x7ff72000}, {0x7ff74000}, {0x7ff76000}, {0x7ff78000}, {0x7ff7a000}, {0x7ff7c000}, {0x7ff7e000}, {0x7ff80000}, {0x7ff82000}, {0x7ff84000}, {0x7ff86000}, {0x7ff88000}, {0x7ff8a000}, {0x7ff8c000}, {0x7ff8e000}, {0x7ff90000}, {0x7ff92000}, {0x7ff94000}, {0x7ff96000}, {0x7ff98000}, {0x7ff9a000}, {0x7ff9c000}, {0x7ff9e000}, {0x7ffa0000}, {0x7ffa2000}, {0x7ffa4000}, {0x7ffa6000}, {0x7ffa8000}, {0x7ffaa000}, {0x7ffac000}, {0x7ffae000}, {0x7ffb0000}, {0x7ffb2000}, {0x7ffb4000}, {0x7ffb6000}, {0x7ffb8000}, {0x7ffba000}, {0x7ffbc000}, {0x7ffbe000}, {0x7ffc0000}, {0x7ffc2000}, {0x7ffc4000}, {0x7ffc6000}, {0x7ffc8000}, {0x7ffca000}, {0x7ffcc000}, {0x7ffce000}, {0x7ffd0000}, {0x7ffd2000}, {0x7ffd4000}, {0x7ffd6000}, {0x7ffd8000}, {0x7ffda000}, {0x7ffdc000}, {0x7ffde000}, {0x7ffe0000}, {0x7ffe2000}, {0x7ffe4000}, {0x7ffe6000}, {0x7ffe8000}, {0x7ffea000}, {0x7ffec000}, {0x7ffee000}, {0x7fff0000}, {0x7fff2000}, {0x7fff4000}, {0x7fff6000}, {0x7fff8000}, {0x7fffa000}, {0x7fffc000}, {0x7fffe000}, {0x80000000}, {0xb3800000}, {0xb4000000}, {0xb4400000}, {0xb4800000}, {0xb4a00000}, {0xb4c00000}, {0xb4e00000}, {0xb5000000}, {0xb5100000}, {0xb5200000}, {0xb5300000}, {0xb5400000}, {0xb5500000}, {0xb5600000}, {0xb5700000}, {0xb5800000}, {0xb5880000}, {0xb5900000}, {0xb5980000}, {0xb5a00000}, {0xb5a80000}, {0xb5b00000}, {0xb5b80000}, {0xb5c00000}, {0xb5c80000}, {0xb5d00000}, {0xb5d80000}, {0xb5e00000}, {0xb5e80000}, {0xb5f00000}, {0xb5f80000}, {0xb6000000}, {0xb6040000}, {0xb6080000}, {0xb60c0000}, {0xb6100000}, {0xb6140000}, {0xb6180000}, {0xb61c0000}, {0xb6200000}, {0xb6240000}, {0xb6280000}, {0xb62c0000}, {0xb6300000}, {0xb6340000}, {0xb6380000}, {0xb63c0000}, {0xb6400000}, {0xb6440000}, {0xb6480000}, {0xb64c0000}, {0xb6500000}, {0xb6540000}, {0xb6580000}, {0xb65c0000}, {0xb6600000}, {0xb6640000}, {0xb6680000}, {0xb66c0000}, {0xb6700000}, {0xb6740000}, {0xb6780000}, {0xb67c0000}, {0xb6800000}, {0xb6820000}, {0xb6840000}, {0xb6860000}, {0xb6880000}, {0xb68a0000}, {0xb68c0000}, {0xb68e0000}, {0xb6900000}, {0xb6920000}, {0xb6940000}, {0xb6960000}, {0xb6980000}, {0xb69a0000}, {0xb69c0000}, {0xb69e0000}, {0xb6a00000}, {0xb6a20000}, {0xb6a40000}, {0xb6a60000}, {0xb6a80000}, {0xb6aa0000}, {0xb6ac0000}, {0xb6ae0000}, {0xb6b00000}, {0xb6b20000}, {0xb6b40000}, {0xb6b60000}, {0xb6b80000}, {0xb6ba0000}, {0xb6bc0000}, {0xb6be0000}, {0xb6c00000}, {0xb6c20000}, {0xb6c40000}, {0xb6c60000}, {0xb6c80000}, {0xb6ca0000}, {0xb6cc0000}, {0xb6ce0000}, {0xb6d00000}, {0xb6d20000}, {0xb6d40000}, {0xb6d60000}, {0xb6d80000}, {0xb6da0000}, {0xb6dc0000}, {0xb6de0000}, {0xb6e00000}, {0xb6e20000}, {0xb6e40000}, {0xb6e60000}, {0xb6e80000}, {0xb6ea0000}, {0xb6ec0000}, {0xb6ee0000}, {0xb6f00000}, {0xb6f20000}, {0xb6f40000}, {0xb6f60000}, {0xb6f80000}, {0xb6fa0000}, {0xb6fc0000}, {0xb6fe0000}, {0xb7000000}, {0xb7010000}, {0xb7020000}, {0xb7030000}, {0xb7040000}, {0xb7050000}, {0xb7060000}, {0xb7070000}, {0xb7080000}, {0xb7090000}, {0xb70a0000}, {0xb70b0000}, {0xb70c0000}, {0xb70d0000}, {0xb70e0000}, {0xb70f0000}, {0xb7100000}, {0xb7110000}, {0xb7120000}, {0xb7130000}, {0xb7140000}, {0xb7150000}, {0xb7160000}, {0xb7170000}, {0xb7180000}, {0xb7190000}, {0xb71a0000}, {0xb71b0000}, {0xb71c0000}, {0xb71d0000}, {0xb71e0000}, {0xb71f0000}, {0xb7200000}, {0xb7210000}, {0xb7220000}, {0xb7230000}, {0xb7240000}, {0xb7250000}, {0xb7260000}, {0xb7270000}, {0xb7280000}, {0xb7290000}, {0xb72a0000}, {0xb72b0000}, {0xb72c0000}, {0xb72d0000}, {0xb72e0000}, {0xb72f0000}, {0xb7300000}, {0xb7310000}, {0xb7320000}, {0xb7330000}, {0xb7340000}, {0xb7350000}, {0xb7360000}, {0xb7370000}, {0xb7380000}, {0xb7390000}, {0xb73a0000}, {0xb73b0000}, {0xb73c0000}, {0xb73d0000}, {0xb73e0000}, {0xb73f0000}, {0xb7400000}, {0xb7410000}, {0xb7420000}, {0xb7430000}, {0xb7440000}, {0xb7450000}, {0xb7460000}, {0xb7470000}, {0xb7480000}, {0xb7490000}, {0xb74a0000}, {0xb74b0000}, {0xb74c0000}, {0xb74d0000}, {0xb74e0000}, {0xb74f0000}, {0xb7500000}, {0xb7510000}, {0xb7520000}, {0xb7530000}, {0xb7540000}, {0xb7550000}, {0xb7560000}, {0xb7570000}, {0xb7580000}, {0xb7590000}, {0xb75a0000}, {0xb75b0000}, {0xb75c0000}, {0xb75d0000}, {0xb75e0000}, {0xb75f0000}, {0xb7600000}, {0xb7610000}, {0xb7620000}, {0xb7630000}, {0xb7640000}, {0xb7650000}, {0xb7660000}, {0xb7670000}, {0xb7680000}, {0xb7690000}, {0xb76a0000}, {0xb76b0000}, {0xb76c0000}, {0xb76d0000}, {0xb76e0000}, {0xb76f0000}, {0xb7700000}, {0xb7710000}, {0xb7720000}, {0xb7730000}, {0xb7740000}, {0xb7750000}, {0xb7760000}, {0xb7770000}, {0xb7780000}, {0xb7790000}, {0xb77a0000}, {0xb77b0000}, {0xb77c0000}, {0xb77d0000}, {0xb77e0000}, {0xb77f0000}, {0xb7800000}, {0xb7808000}, {0xb7810000}, {0xb7818000}, {0xb7820000}, {0xb7828000}, {0xb7830000}, {0xb7838000}, {0xb7840000}, {0xb7848000}, {0xb7850000}, {0xb7858000}, {0xb7860000}, {0xb7868000}, {0xb7870000}, {0xb7878000}, {0xb7880000}, {0xb7888000}, {0xb7890000}, {0xb7898000}, {0xb78a0000}, {0xb78a8000}, {0xb78b0000}, {0xb78b8000}, {0xb78c0000}, {0xb78c8000}, {0xb78d0000}, {0xb78d8000}, {0xb78e0000}, {0xb78e8000}, {0xb78f0000}, {0xb78f8000}, {0xb7900000}, {0xb7908000}, {0xb7910000}, {0xb7918000}, {0xb7920000}, {0xb7928000}, {0xb7930000}, {0xb7938000}, {0xb7940000}, {0xb7948000}, {0xb7950000}, {0xb7958000}, {0xb7960000}, {0xb7968000}, {0xb7970000}, {0xb7978000}, {0xb7980000}, {0xb7988000}, {0xb7990000}, {0xb7998000}, {0xb79a0000}, {0xb79a8000}, {0xb79b0000}, {0xb79b8000}, {0xb79c0000}, {0xb79c8000}, {0xb79d0000}, {0xb79d8000}, {0xb79e0000}, {0xb79e8000}, {0xb79f0000}, {0xb79f8000}, {0xb7a00000}, {0xb7a08000}, {0xb7a10000}, {0xb7a18000}, {0xb7a20000}, {0xb7a28000}, {0xb7a30000}, {0xb7a38000}, {0xb7a40000}, {0xb7a48000}, {0xb7a50000}, {0xb7a58000}, {0xb7a60000}, {0xb7a68000}, {0xb7a70000}, {0xb7a78000}, {0xb7a80000}, {0xb7a88000}, {0xb7a90000}, {0xb7a98000}, {0xb7aa0000}, {0xb7aa8000}, {0xb7ab0000}, {0xb7ab8000}, {0xb7ac0000}, {0xb7ac8000}, {0xb7ad0000}, {0xb7ad8000}, {0xb7ae0000}, {0xb7ae8000}, {0xb7af0000}, {0xb7af8000}, {0xb7b00000}, {0xb7b08000}, {0xb7b10000}, {0xb7b18000}, {0xb7b20000}, {0xb7b28000}, {0xb7b30000}, {0xb7b38000}, {0xb7b40000}, {0xb7b48000}, {0xb7b50000}, {0xb7b58000}, {0xb7b60000}, {0xb7b68000}, {0xb7b70000}, {0xb7b78000}, {0xb7b80000}, {0xb7b88000}, {0xb7b90000}, {0xb7b98000}, {0xb7ba0000}, {0xb7ba8000}, {0xb7bb0000}, {0xb7bb8000}, {0xb7bc0000}, {0xb7bc8000}, {0xb7bd0000}, {0xb7bd8000}, {0xb7be0000}, {0xb7be8000}, {0xb7bf0000}, {0xb7bf8000}, {0xb7c00000}, {0xb7c08000}, {0xb7c10000}, {0xb7c18000}, {0xb7c20000}, {0xb7c28000}, {0xb7c30000}, {0xb7c38000}, {0xb7c40000}, {0xb7c48000}, {0xb7c50000}, {0xb7c58000}, {0xb7c60000}, {0xb7c68000}, {0xb7c70000}, {0xb7c78000}, {0xb7c80000}, {0xb7c88000}, {0xb7c90000}, {0xb7c98000}, {0xb7ca0000}, {0xb7ca8000}, {0xb7cb0000}, {0xb7cb8000}, {0xb7cc0000}, {0xb7cc8000}, {0xb7cd0000}, {0xb7cd8000}, {0xb7ce0000}, {0xb7ce8000}, {0xb7cf0000}, {0xb7cf8000}, {0xb7d00000}, {0xb7d08000}, {0xb7d10000}, {0xb7d18000}, {0xb7d20000}, {0xb7d28000}, {0xb7d30000}, {0xb7d38000}, {0xb7d40000}, {0xb7d48000}, {0xb7d50000}, {0xb7d58000}, {0xb7d60000}, {0xb7d68000}, {0xb7d70000}, {0xb7d78000}, {0xb7d80000}, {0xb7d88000}, {0xb7d90000}, {0xb7d98000}, {0xb7da0000}, {0xb7da8000}, {0xb7db0000}, {0xb7db8000}, {0xb7dc0000}, {0xb7dc8000}, {0xb7dd0000}, {0xb7dd8000}, {0xb7de0000}, {0xb7de8000}, {0xb7df0000}, {0xb7df8000}, {0xb7e00000}, {0xb7e08000}, {0xb7e10000}, {0xb7e18000}, {0xb7e20000}, {0xb7e28000}, {0xb7e30000}, {0xb7e38000}, {0xb7e40000}, {0xb7e48000}, {0xb7e50000}, {0xb7e58000}, {0xb7e60000}, {0xb7e68000}, {0xb7e70000}, {0xb7e78000}, {0xb7e80000}, {0xb7e88000}, {0xb7e90000}, {0xb7e98000}, {0xb7ea0000}, {0xb7ea8000}, {0xb7eb0000}, {0xb7eb8000}, {0xb7ec0000}, {0xb7ec8000}, {0xb7ed0000}, {0xb7ed8000}, {0xb7ee0000}, {0xb7ee8000}, {0xb7ef0000}, {0xb7ef8000}, {0xb7f00000}, {0xb7f08000}, {0xb7f10000}, {0xb7f18000}, {0xb7f20000}, {0xb7f28000}, {0xb7f30000}, {0xb7f38000}, {0xb7f40000}, {0xb7f48000}, {0xb7f50000}, {0xb7f58000}, {0xb7f60000}, {0xb7f68000}, {0xb7f70000}, {0xb7f78000}, {0xb7f80000}, {0xb7f88000}, {0xb7f90000}, {0xb7f98000}, {0xb7fa0000}, {0xb7fa8000}, {0xb7fb0000}, {0xb7fb8000}, {0xb7fc0000}, {0xb7fc8000}, {0xb7fd0000}, {0xb7fd8000}, {0xb7fe0000}, {0xb7fe8000}, {0xb7ff0000}, {0xb7ff8000}, {0xb8000000}, {0xb8004000}, {0xb8008000}, {0xb800c000}, {0xb8010000}, {0xb8014000}, {0xb8018000}, {0xb801c000}, {0xb8020000}, {0xb8024000}, {0xb8028000}, {0xb802c000}, {0xb8030000}, {0xb8034000}, {0xb8038000}, {0xb803c000}, {0xb8040000}, {0xb8044000}, {0xb8048000}, {0xb804c000}, {0xb8050000}, {0xb8054000}, {0xb8058000}, {0xb805c000}, {0xb8060000}, {0xb8064000}, {0xb8068000}, {0xb806c000}, {0xb8070000}, {0xb8074000}, {0xb8078000}, {0xb807c000}, {0xb8080000}, {0xb8084000}, {0xb8088000}, {0xb808c000}, {0xb8090000}, {0xb8094000}, {0xb8098000}, {0xb809c000}, {0xb80a0000}, {0xb80a4000}, {0xb80a8000}, {0xb80ac000}, {0xb80b0000}, {0xb80b4000}, {0xb80b8000}, {0xb80bc000}, {0xb80c0000}, {0xb80c4000}, {0xb80c8000}, {0xb80cc000}, {0xb80d0000}, {0xb80d4000}, {0xb80d8000}, {0xb80dc000}, {0xb80e0000}, {0xb80e4000}, {0xb80e8000}, {0xb80ec000}, {0xb80f0000}, {0xb80f4000}, {0xb80f8000}, {0xb80fc000}, {0xb8100000}, {0xb8104000}, {0xb8108000}, {0xb810c000}, {0xb8110000}, {0xb8114000}, {0xb8118000}, {0xb811c000}, {0xb8120000}, {0xb8124000}, {0xb8128000}, {0xb812c000}, {0xb8130000}, {0xb8134000}, {0xb8138000}, {0xb813c000}, {0xb8140000}, {0xb8144000}, {0xb8148000}, {0xb814c000}, {0xb8150000}, {0xb8154000}, {0xb8158000}, {0xb815c000}, {0xb8160000}, {0xb8164000}, {0xb8168000}, {0xb816c000}, {0xb8170000}, {0xb8174000}, {0xb8178000}, {0xb817c000}, {0xb8180000}, {0xb8184000}, {0xb8188000}, {0xb818c000}, {0xb8190000}, {0xb8194000}, {0xb8198000}, {0xb819c000}, {0xb81a0000}, {0xb81a4000}, {0xb81a8000}, {0xb81ac000}, {0xb81b0000}, {0xb81b4000}, {0xb81b8000}, {0xb81bc000}, {0xb81c0000}, {0xb81c4000}, {0xb81c8000}, {0xb81cc000}, {0xb81d0000}, {0xb81d4000}, {0xb81d8000}, {0xb81dc000}, {0xb81e0000}, {0xb81e4000}, {0xb81e8000}, {0xb81ec000}, {0xb81f0000}, {0xb81f4000}, {0xb81f8000}, {0xb81fc000}, {0xb8200000}, {0xb8204000}, {0xb8208000}, {0xb820c000}, {0xb8210000}, {0xb8214000}, {0xb8218000}, {0xb821c000}, {0xb8220000}, {0xb8224000}, {0xb8228000}, {0xb822c000}, {0xb8230000}, {0xb8234000}, {0xb8238000}, {0xb823c000}, {0xb8240000}, {0xb8244000}, {0xb8248000}, {0xb824c000}, {0xb8250000}, {0xb8254000}, {0xb8258000}, {0xb825c000}, {0xb8260000}, {0xb8264000}, {0xb8268000}, {0xb826c000}, {0xb8270000}, {0xb8274000}, {0xb8278000}, {0xb827c000}, {0xb8280000}, {0xb8284000}, {0xb8288000}, {0xb828c000}, {0xb8290000}, {0xb8294000}, {0xb8298000}, {0xb829c000}, {0xb82a0000}, {0xb82a4000}, {0xb82a8000}, {0xb82ac000}, {0xb82b0000}, {0xb82b4000}, {0xb82b8000}, {0xb82bc000}, {0xb82c0000}, {0xb82c4000}, {0xb82c8000}, {0xb82cc000}, {0xb82d0000}, {0xb82d4000}, {0xb82d8000}, {0xb82dc000}, {0xb82e0000}, {0xb82e4000}, {0xb82e8000}, {0xb82ec000}, {0xb82f0000}, {0xb82f4000}, {0xb82f8000}, {0xb82fc000}, {0xb8300000}, {0xb8304000}, {0xb8308000}, {0xb830c000}, {0xb8310000}, {0xb8314000}, {0xb8318000}, {0xb831c000}, {0xb8320000}, {0xb8324000}, {0xb8328000}, {0xb832c000}, {0xb8330000}, {0xb8334000}, {0xb8338000}, {0xb833c000}, {0xb8340000}, {0xb8344000}, {0xb8348000}, {0xb834c000}, {0xb8350000}, {0xb8354000}, {0xb8358000}, {0xb835c000}, {0xb8360000}, {0xb8364000}, {0xb8368000}, {0xb836c000}, {0xb8370000}, {0xb8374000}, {0xb8378000}, {0xb837c000}, {0xb8380000}, {0xb8384000}, {0xb8388000}, {0xb838c000}, {0xb8390000}, {0xb8394000}, {0xb8398000}, {0xb839c000}, {0xb83a0000}, {0xb83a4000}, {0xb83a8000}, {0xb83ac000}, {0xb83b0000}, {0xb83b4000}, {0xb83b8000}, {0xb83bc000}, {0xb83c0000}, {0xb83c4000}, {0xb83c8000}, {0xb83cc000}, {0xb83d0000}, {0xb83d4000}, {0xb83d8000}, {0xb83dc000}, {0xb83e0000}, {0xb83e4000}, {0xb83e8000}, {0xb83ec000}, {0xb83f0000}, {0xb83f4000}, {0xb83f8000}, {0xb83fc000}, {0xb8400000}, {0xb8404000}, {0xb8408000}, {0xb840c000}, {0xb8410000}, {0xb8414000}, {0xb8418000}, {0xb841c000}, {0xb8420000}, {0xb8424000}, {0xb8428000}, {0xb842c000}, {0xb8430000}, {0xb8434000}, {0xb8438000}, {0xb843c000}, {0xb8440000}, {0xb8444000}, {0xb8448000}, {0xb844c000}, {0xb8450000}, {0xb8454000}, {0xb8458000}, {0xb845c000}, {0xb8460000}, {0xb8464000}, {0xb8468000}, {0xb846c000}, {0xb8470000}, {0xb8474000}, {0xb8478000}, {0xb847c000}, {0xb8480000}, {0xb8484000}, {0xb8488000}, {0xb848c000}, {0xb8490000}, {0xb8494000}, {0xb8498000}, {0xb849c000}, {0xb84a0000}, {0xb84a4000}, {0xb84a8000}, {0xb84ac000}, {0xb84b0000}, {0xb84b4000}, {0xb84b8000}, {0xb84bc000}, {0xb84c0000}, {0xb84c4000}, {0xb84c8000}, {0xb84cc000}, {0xb84d0000}, {0xb84d4000}, {0xb84d8000}, {0xb84dc000}, {0xb84e0000}, {0xb84e4000}, {0xb84e8000}, {0xb84ec000}, {0xb84f0000}, {0xb84f4000}, {0xb84f8000}, {0xb84fc000}, {0xb8500000}, {0xb8504000}, {0xb8508000}, {0xb850c000}, {0xb8510000}, {0xb8514000}, {0xb8518000}, {0xb851c000}, {0xb8520000}, {0xb8524000}, {0xb8528000}, {0xb852c000}, {0xb8530000}, {0xb8534000}, {0xb8538000}, {0xb853c000}, {0xb8540000}, {0xb8544000}, {0xb8548000}, {0xb854c000}, {0xb8550000}, {0xb8554000}, {0xb8558000}, {0xb855c000}, {0xb8560000}, {0xb8564000}, {0xb8568000}, {0xb856c000}, {0xb8570000}, {0xb8574000}, {0xb8578000}, {0xb857c000}, {0xb8580000}, {0xb8584000}, {0xb8588000}, {0xb858c000}, {0xb8590000}, {0xb8594000}, {0xb8598000}, {0xb859c000}, {0xb85a0000}, {0xb85a4000}, {0xb85a8000}, {0xb85ac000}, {0xb85b0000}, {0xb85b4000}, {0xb85b8000}, {0xb85bc000}, {0xb85c0000}, {0xb85c4000}, {0xb85c8000}, {0xb85cc000}, {0xb85d0000}, {0xb85d4000}, {0xb85d8000}, {0xb85dc000}, {0xb85e0000}, {0xb85e4000}, {0xb85e8000}, {0xb85ec000}, {0xb85f0000}, {0xb85f4000}, {0xb85f8000}, {0xb85fc000}, {0xb8600000}, {0xb8604000}, {0xb8608000}, {0xb860c000}, {0xb8610000}, {0xb8614000}, {0xb8618000}, {0xb861c000}, {0xb8620000}, {0xb8624000}, {0xb8628000}, {0xb862c000}, {0xb8630000}, {0xb8634000}, {0xb8638000}, {0xb863c000}, {0xb8640000}, {0xb8644000}, {0xb8648000}, {0xb864c000}, {0xb8650000}, {0xb8654000}, {0xb8658000}, {0xb865c000}, {0xb8660000}, {0xb8664000}, {0xb8668000}, {0xb866c000}, {0xb8670000}, {0xb8674000}, {0xb8678000}, {0xb867c000}, {0xb8680000}, {0xb8684000}, {0xb8688000}, {0xb868c000}, {0xb8690000}, {0xb8694000}, {0xb8698000}, {0xb869c000}, {0xb86a0000}, {0xb86a4000}, {0xb86a8000}, {0xb86ac000}, {0xb86b0000}, {0xb86b4000}, {0xb86b8000}, {0xb86bc000}, {0xb86c0000}, {0xb86c4000}, {0xb86c8000}, {0xb86cc000}, {0xb86d0000}, {0xb86d4000}, {0xb86d8000}, {0xb86dc000}, {0xb86e0000}, {0xb86e4000}, {0xb86e8000}, {0xb86ec000}, {0xb86f0000}, {0xb86f4000}, {0xb86f8000}, {0xb86fc000}, {0xb8700000}, {0xb8704000}, {0xb8708000}, {0xb870c000}, {0xb8710000}, {0xb8714000}, {0xb8718000}, {0xb871c000}, {0xb8720000}, {0xb8724000}, {0xb8728000}, {0xb872c000}, {0xb8730000}, {0xb8734000}, {0xb8738000}, {0xb873c000}, {0xb8740000}, {0xb8744000}, {0xb8748000}, {0xb874c000}, {0xb8750000}, {0xb8754000}, {0xb8758000}, {0xb875c000}, {0xb8760000}, {0xb8764000}, {0xb8768000}, {0xb876c000}, {0xb8770000}, {0xb8774000}, {0xb8778000}, {0xb877c000}, {0xb8780000}, {0xb8784000}, {0xb8788000}, {0xb878c000}, {0xb8790000}, {0xb8794000}, {0xb8798000}, {0xb879c000}, {0xb87a0000}, {0xb87a4000}, {0xb87a8000}, {0xb87ac000}, {0xb87b0000}, {0xb87b4000}, {0xb87b8000}, {0xb87bc000}, {0xb87c0000}, {0xb87c4000}, {0xb87c8000}, {0xb87cc000}, {0xb87d0000}, {0xb87d4000}, {0xb87d8000}, {0xb87dc000}, {0xb87e0000}, {0xb87e4000}, {0xb87e8000}, {0xb87ec000}, {0xb87f0000}, {0xb87f4000}, {0xb87f8000}, {0xb87fc000}, {0xb8800000}, {0xb8802000}, {0xb8804000}, {0xb8806000}, {0xb8808000}, {0xb880a000}, {0xb880c000}, {0xb880e000}, {0xb8810000}, {0xb8812000}, {0xb8814000}, {0xb8816000}, {0xb8818000}, {0xb881a000}, {0xb881c000}, {0xb881e000}, {0xb8820000}, {0xb8822000}, {0xb8824000}, {0xb8826000}, {0xb8828000}, {0xb882a000}, {0xb882c000}, {0xb882e000}, {0xb8830000}, {0xb8832000}, {0xb8834000}, {0xb8836000}, {0xb8838000}, {0xb883a000}, {0xb883c000}, {0xb883e000}, {0xb8840000}, {0xb8842000}, {0xb8844000}, {0xb8846000}, {0xb8848000}, {0xb884a000}, {0xb884c000}, {0xb884e000}, {0xb8850000}, {0xb8852000}, {0xb8854000}, {0xb8856000}, {0xb8858000}, {0xb885a000}, {0xb885c000}, {0xb885e000}, {0xb8860000}, {0xb8862000}, {0xb8864000}, {0xb8866000}, {0xb8868000}, {0xb886a000}, {0xb886c000}, {0xb886e000}, {0xb8870000}, {0xb8872000}, {0xb8874000}, {0xb8876000}, {0xb8878000}, {0xb887a000}, {0xb887c000}, {0xb887e000}, {0xb8880000}, {0xb8882000}, {0xb8884000}, {0xb8886000}, {0xb8888000}, {0xb888a000}, {0xb888c000}, {0xb888e000}, {0xb8890000}, {0xb8892000}, {0xb8894000}, {0xb8896000}, {0xb8898000}, {0xb889a000}, {0xb889c000}, {0xb889e000}, {0xb88a0000}, {0xb88a2000}, {0xb88a4000}, {0xb88a6000}, {0xb88a8000}, {0xb88aa000}, {0xb88ac000}, {0xb88ae000}, {0xb88b0000}, {0xb88b2000}, {0xb88b4000}, {0xb88b6000}, {0xb88b8000}, {0xb88ba000}, {0xb88bc000}, {0xb88be000}, {0xb88c0000}, {0xb88c2000}, {0xb88c4000}, {0xb88c6000}, {0xb88c8000}, {0xb88ca000}, {0xb88cc000}, {0xb88ce000}, {0xb88d0000}, {0xb88d2000}, {0xb88d4000}, {0xb88d6000}, {0xb88d8000}, {0xb88da000}, {0xb88dc000}, {0xb88de000}, {0xb88e0000}, {0xb88e2000}, {0xb88e4000}, {0xb88e6000}, {0xb88e8000}, {0xb88ea000}, {0xb88ec000}, {0xb88ee000}, {0xb88f0000}, {0xb88f2000}, {0xb88f4000}, {0xb88f6000}, {0xb88f8000}, {0xb88fa000}, {0xb88fc000}, {0xb88fe000}, {0xb8900000}, {0xb8902000}, {0xb8904000}, {0xb8906000}, {0xb8908000}, {0xb890a000}, {0xb890c000}, {0xb890e000}, {0xb8910000}, {0xb8912000}, {0xb8914000}, {0xb8916000}, {0xb8918000}, {0xb891a000}, {0xb891c000}, {0xb891e000}, {0xb8920000}, {0xb8922000}, {0xb8924000}, {0xb8926000}, {0xb8928000}, {0xb892a000}, {0xb892c000}, {0xb892e000}, {0xb8930000}, {0xb8932000}, {0xb8934000}, {0xb8936000}, {0xb8938000}, {0xb893a000}, {0xb893c000}, {0xb893e000}, {0xb8940000}, {0xb8942000}, {0xb8944000}, {0xb8946000}, {0xb8948000}, {0xb894a000}, {0xb894c000}, {0xb894e000}, {0xb8950000}, {0xb8952000}, {0xb8954000}, {0xb8956000}, {0xb8958000}, {0xb895a000}, {0xb895c000}, {0xb895e000}, {0xb8960000}, {0xb8962000}, {0xb8964000}, {0xb8966000}, {0xb8968000}, {0xb896a000}, {0xb896c000}, {0xb896e000}, {0xb8970000}, {0xb8972000}, {0xb8974000}, {0xb8976000}, {0xb8978000}, {0xb897a000}, {0xb897c000}, {0xb897e000}, {0xb8980000}, {0xb8982000}, {0xb8984000}, {0xb8986000}, {0xb8988000}, {0xb898a000}, {0xb898c000}, {0xb898e000}, {0xb8990000}, {0xb8992000}, {0xb8994000}, {0xb8996000}, {0xb8998000}, {0xb899a000}, {0xb899c000}, {0xb899e000}, {0xb89a0000}, {0xb89a2000}, {0xb89a4000}, {0xb89a6000}, {0xb89a8000}, {0xb89aa000}, {0xb89ac000}, {0xb89ae000}, {0xb89b0000}, {0xb89b2000}, {0xb89b4000}, {0xb89b6000}, {0xb89b8000}, {0xb89ba000}, {0xb89bc000}, {0xb89be000}, {0xb89c0000}, {0xb89c2000}, {0xb89c4000}, {0xb89c6000}, {0xb89c8000}, {0xb89ca000}, {0xb89cc000}, {0xb89ce000}, {0xb89d0000}, {0xb89d2000}, {0xb89d4000}, {0xb89d6000}, {0xb89d8000}, {0xb89da000}, {0xb89dc000}, {0xb89de000}, {0xb89e0000}, {0xb89e2000}, {0xb89e4000}, {0xb89e6000}, {0xb89e8000}, {0xb89ea000}, {0xb89ec000}, {0xb89ee000}, {0xb89f0000}, {0xb89f2000}, {0xb89f4000}, {0xb89f6000}, {0xb89f8000}, {0xb89fa000}, {0xb89fc000}, {0xb89fe000}, {0xb8a00000}, {0xb8a02000}, {0xb8a04000}, {0xb8a06000}, {0xb8a08000}, {0xb8a0a000}, {0xb8a0c000}, {0xb8a0e000}, {0xb8a10000}, {0xb8a12000}, {0xb8a14000}, {0xb8a16000}, {0xb8a18000}, {0xb8a1a000}, {0xb8a1c000}, {0xb8a1e000}, {0xb8a20000}, {0xb8a22000}, {0xb8a24000}, {0xb8a26000}, {0xb8a28000}, {0xb8a2a000}, {0xb8a2c000}, {0xb8a2e000}, {0xb8a30000}, {0xb8a32000}, {0xb8a34000}, {0xb8a36000}, {0xb8a38000}, {0xb8a3a000}, {0xb8a3c000}, {0xb8a3e000}, {0xb8a40000}, {0xb8a42000}, {0xb8a44000}, {0xb8a46000}, {0xb8a48000}, {0xb8a4a000}, {0xb8a4c000}, {0xb8a4e000}, {0xb8a50000}, {0xb8a52000}, {0xb8a54000}, {0xb8a56000}, {0xb8a58000}, {0xb8a5a000}, {0xb8a5c000}, {0xb8a5e000}, {0xb8a60000}, {0xb8a62000}, {0xb8a64000}, {0xb8a66000}, {0xb8a68000}, {0xb8a6a000}, {0xb8a6c000}, {0xb8a6e000}, {0xb8a70000}, {0xb8a72000}, {0xb8a74000}, {0xb8a76000}, {0xb8a78000}, {0xb8a7a000}, {0xb8a7c000}, {0xb8a7e000}, {0xb8a80000}, {0xb8a82000}, {0xb8a84000}, {0xb8a86000}, {0xb8a88000}, {0xb8a8a000}, {0xb8a8c000}, {0xb8a8e000}, {0xb8a90000}, {0xb8a92000}, {0xb8a94000}, {0xb8a96000}, {0xb8a98000}, {0xb8a9a000}, {0xb8a9c000}, {0xb8a9e000}, {0xb8aa0000}, {0xb8aa2000}, {0xb8aa4000}, {0xb8aa6000}, {0xb8aa8000}, {0xb8aaa000}, {0xb8aac000}, {0xb8aae000}, {0xb8ab0000}, {0xb8ab2000}, {0xb8ab4000}, {0xb8ab6000}, {0xb8ab8000}, {0xb8aba000}, {0xb8abc000}, {0xb8abe000}, {0xb8ac0000}, {0xb8ac2000}, {0xb8ac4000}, {0xb8ac6000}, {0xb8ac8000}, {0xb8aca000}, {0xb8acc000}, {0xb8ace000}, {0xb8ad0000}, {0xb8ad2000}, {0xb8ad4000}, {0xb8ad6000}, {0xb8ad8000}, {0xb8ada000}, {0xb8adc000}, {0xb8ade000}, {0xb8ae0000}, {0xb8ae2000}, {0xb8ae4000}, {0xb8ae6000}, {0xb8ae8000}, {0xb8aea000}, {0xb8aec000}, {0xb8aee000}, {0xb8af0000}, {0xb8af2000}, {0xb8af4000}, {0xb8af6000}, {0xb8af8000}, {0xb8afa000}, {0xb8afc000}, {0xb8afe000}, {0xb8b00000}, {0xb8b02000}, {0xb8b04000}, {0xb8b06000}, {0xb8b08000}, {0xb8b0a000}, {0xb8b0c000}, {0xb8b0e000}, {0xb8b10000}, {0xb8b12000}, {0xb8b14000}, {0xb8b16000}, {0xb8b18000}, {0xb8b1a000}, {0xb8b1c000}, {0xb8b1e000}, {0xb8b20000}, {0xb8b22000}, {0xb8b24000}, {0xb8b26000}, {0xb8b28000}, {0xb8b2a000}, {0xb8b2c000}, {0xb8b2e000}, {0xb8b30000}, {0xb8b32000}, {0xb8b34000}, {0xb8b36000}, {0xb8b38000}, {0xb8b3a000}, {0xb8b3c000}, {0xb8b3e000}, {0xb8b40000}, {0xb8b42000}, {0xb8b44000}, {0xb8b46000}, {0xb8b48000}, {0xb8b4a000}, {0xb8b4c000}, {0xb8b4e000}, {0xb8b50000}, {0xb8b52000}, {0xb8b54000}, {0xb8b56000}, {0xb8b58000}, {0xb8b5a000}, {0xb8b5c000}, {0xb8b5e000}, {0xb8b60000}, {0xb8b62000}, {0xb8b64000}, {0xb8b66000}, {0xb8b68000}, {0xb8b6a000}, {0xb8b6c000}, {0xb8b6e000}, {0xb8b70000}, {0xb8b72000}, {0xb8b74000}, {0xb8b76000}, {0xb8b78000}, {0xb8b7a000}, {0xb8b7c000}, {0xb8b7e000}, {0xb8b80000}, {0xb8b82000}, {0xb8b84000}, {0xb8b86000}, {0xb8b88000}, {0xb8b8a000}, {0xb8b8c000}, {0xb8b8e000}, {0xb8b90000}, {0xb8b92000}, {0xb8b94000}, {0xb8b96000}, {0xb8b98000}, {0xb8b9a000}, {0xb8b9c000}, {0xb8b9e000}, {0xb8ba0000}, {0xb8ba2000}, {0xb8ba4000}, {0xb8ba6000}, {0xb8ba8000}, {0xb8baa000}, {0xb8bac000}, {0xb8bae000}, {0xb8bb0000}, {0xb8bb2000}, {0xb8bb4000}, {0xb8bb6000}, {0xb8bb8000}, {0xb8bba000}, {0xb8bbc000}, {0xb8bbe000}, {0xb8bc0000}, {0xb8bc2000}, {0xb8bc4000}, {0xb8bc6000}, {0xb8bc8000}, {0xb8bca000}, {0xb8bcc000}, {0xb8bce000}, {0xb8bd0000}, {0xb8bd2000}, {0xb8bd4000}, {0xb8bd6000}, {0xb8bd8000}, {0xb8bda000}, {0xb8bdc000}, {0xb8bde000}, {0xb8be0000}, {0xb8be2000}, {0xb8be4000}, {0xb8be6000}, {0xb8be8000}, {0xb8bea000}, {0xb8bec000}, {0xb8bee000}, {0xb8bf0000}, {0xb8bf2000}, {0xb8bf4000}, {0xb8bf6000}, {0xb8bf8000}, {0xb8bfa000}, {0xb8bfc000}, {0xb8bfe000}, {0xb8c00000}, {0xb8c02000}, {0xb8c04000}, {0xb8c06000}, {0xb8c08000}, {0xb8c0a000}, {0xb8c0c000}, {0xb8c0e000}, {0xb8c10000}, {0xb8c12000}, {0xb8c14000}, {0xb8c16000}, {0xb8c18000}, {0xb8c1a000}, {0xb8c1c000}, {0xb8c1e000}, {0xb8c20000}, {0xb8c22000}, {0xb8c24000}, {0xb8c26000}, {0xb8c28000}, {0xb8c2a000}, {0xb8c2c000}, {0xb8c2e000}, {0xb8c30000}, {0xb8c32000}, {0xb8c34000}, {0xb8c36000}, {0xb8c38000}, {0xb8c3a000}, {0xb8c3c000}, {0xb8c3e000}, {0xb8c40000}, {0xb8c42000}, {0xb8c44000}, {0xb8c46000}, {0xb8c48000}, {0xb8c4a000}, {0xb8c4c000}, {0xb8c4e000}, {0xb8c50000}, {0xb8c52000}, {0xb8c54000}, {0xb8c56000}, {0xb8c58000}, {0xb8c5a000}, {0xb8c5c000}, {0xb8c5e000}, {0xb8c60000}, {0xb8c62000}, {0xb8c64000}, {0xb8c66000}, {0xb8c68000}, {0xb8c6a000}, {0xb8c6c000}, {0xb8c6e000}, {0xb8c70000}, {0xb8c72000}, {0xb8c74000}, {0xb8c76000}, {0xb8c78000}, {0xb8c7a000}, {0xb8c7c000}, {0xb8c7e000}, {0xb8c80000}, {0xb8c82000}, {0xb8c84000}, {0xb8c86000}, {0xb8c88000}, {0xb8c8a000}, {0xb8c8c000}, {0xb8c8e000}, {0xb8c90000}, {0xb8c92000}, {0xb8c94000}, {0xb8c96000}, {0xb8c98000}, {0xb8c9a000}, {0xb8c9c000}, {0xb8c9e000}, {0xb8ca0000}, {0xb8ca2000}, {0xb8ca4000}, {0xb8ca6000}, {0xb8ca8000}, {0xb8caa000}, {0xb8cac000}, {0xb8cae000}, {0xb8cb0000}, {0xb8cb2000}, {0xb8cb4000}, {0xb8cb6000}, {0xb8cb8000}, {0xb8cba000}, {0xb8cbc000}, {0xb8cbe000}, {0xb8cc0000}, {0xb8cc2000}, {0xb8cc4000}, {0xb8cc6000}, {0xb8cc8000}, {0xb8cca000}, {0xb8ccc000}, {0xb8cce000}, {0xb8cd0000}, {0xb8cd2000}, {0xb8cd4000}, {0xb8cd6000}, {0xb8cd8000}, {0xb8cda000}, {0xb8cdc000}, {0xb8cde000}, {0xb8ce0000}, {0xb8ce2000}, {0xb8ce4000}, {0xb8ce6000}, {0xb8ce8000}, {0xb8cea000}, {0xb8cec000}, {0xb8cee000}, {0xb8cf0000}, {0xb8cf2000}, {0xb8cf4000}, {0xb8cf6000}, {0xb8cf8000}, {0xb8cfa000}, {0xb8cfc000}, {0xb8cfe000}, {0xb8d00000}, {0xb8d02000}, {0xb8d04000}, {0xb8d06000}, {0xb8d08000}, {0xb8d0a000}, {0xb8d0c000}, {0xb8d0e000}, {0xb8d10000}, {0xb8d12000}, {0xb8d14000}, {0xb8d16000}, {0xb8d18000}, {0xb8d1a000}, {0xb8d1c000}, {0xb8d1e000}, {0xb8d20000}, {0xb8d22000}, {0xb8d24000}, {0xb8d26000}, {0xb8d28000}, {0xb8d2a000}, {0xb8d2c000}, {0xb8d2e000}, {0xb8d30000}, {0xb8d32000}, {0xb8d34000}, {0xb8d36000}, {0xb8d38000}, {0xb8d3a000}, {0xb8d3c000}, {0xb8d3e000}, {0xb8d40000}, {0xb8d42000}, {0xb8d44000}, {0xb8d46000}, {0xb8d48000}, {0xb8d4a000}, {0xb8d4c000}, {0xb8d4e000}, {0xb8d50000}, {0xb8d52000}, {0xb8d54000}, {0xb8d56000}, {0xb8d58000}, {0xb8d5a000}, {0xb8d5c000}, {0xb8d5e000}, {0xb8d60000}, {0xb8d62000}, {0xb8d64000}, {0xb8d66000}, {0xb8d68000}, {0xb8d6a000}, {0xb8d6c000}, {0xb8d6e000}, {0xb8d70000}, {0xb8d72000}, {0xb8d74000}, {0xb8d76000}, {0xb8d78000}, {0xb8d7a000}, {0xb8d7c000}, {0xb8d7e000}, {0xb8d80000}, {0xb8d82000}, {0xb8d84000}, {0xb8d86000}, {0xb8d88000}, {0xb8d8a000}, {0xb8d8c000}, {0xb8d8e000}, {0xb8d90000}, {0xb8d92000}, {0xb8d94000}, {0xb8d96000}, {0xb8d98000}, {0xb8d9a000}, {0xb8d9c000}, {0xb8d9e000}, {0xb8da0000}, {0xb8da2000}, {0xb8da4000}, {0xb8da6000}, {0xb8da8000}, {0xb8daa000}, {0xb8dac000}, {0xb8dae000}, {0xb8db0000}, {0xb8db2000}, {0xb8db4000}, {0xb8db6000}, {0xb8db8000}, {0xb8dba000}, {0xb8dbc000}, {0xb8dbe000}, {0xb8dc0000}, {0xb8dc2000}, {0xb8dc4000}, {0xb8dc6000}, {0xb8dc8000}, {0xb8dca000}, {0xb8dcc000}, {0xb8dce000}, {0xb8dd0000}, {0xb8dd2000}, {0xb8dd4000}, {0xb8dd6000}, {0xb8dd8000}, {0xb8dda000}, {0xb8ddc000}, {0xb8dde000}, {0xb8de0000}, {0xb8de2000}, {0xb8de4000}, {0xb8de6000}, {0xb8de8000}, {0xb8dea000}, {0xb8dec000}, {0xb8dee000}, {0xb8df0000}, {0xb8df2000}, {0xb8df4000}, {0xb8df6000}, {0xb8df8000}, {0xb8dfa000}, {0xb8dfc000}, {0xb8dfe000}, {0xb8e00000}, {0xb8e02000}, {0xb8e04000}, {0xb8e06000}, {0xb8e08000}, {0xb8e0a000}, {0xb8e0c000}, {0xb8e0e000}, {0xb8e10000}, {0xb8e12000}, {0xb8e14000}, {0xb8e16000}, {0xb8e18000}, {0xb8e1a000}, {0xb8e1c000}, {0xb8e1e000}, {0xb8e20000}, {0xb8e22000}, {0xb8e24000}, {0xb8e26000}, {0xb8e28000}, {0xb8e2a000}, {0xb8e2c000}, {0xb8e2e000}, {0xb8e30000}, {0xb8e32000}, {0xb8e34000}, {0xb8e36000}, {0xb8e38000}, {0xb8e3a000}, {0xb8e3c000}, {0xb8e3e000}, {0xb8e40000}, {0xb8e42000}, {0xb8e44000}, {0xb8e46000}, {0xb8e48000}, {0xb8e4a000}, {0xb8e4c000}, {0xb8e4e000}, {0xb8e50000}, {0xb8e52000}, {0xb8e54000}, {0xb8e56000}, {0xb8e58000}, {0xb8e5a000}, {0xb8e5c000}, {0xb8e5e000}, {0xb8e60000}, {0xb8e62000}, {0xb8e64000}, {0xb8e66000}, {0xb8e68000}, {0xb8e6a000}, {0xb8e6c000}, {0xb8e6e000}, {0xb8e70000}, {0xb8e72000}, {0xb8e74000}, {0xb8e76000}, {0xb8e78000}, {0xb8e7a000}, {0xb8e7c000}, {0xb8e7e000}, {0xb8e80000}, {0xb8e82000}, {0xb8e84000}, {0xb8e86000}, {0xb8e88000}, {0xb8e8a000}, {0xb8e8c000}, {0xb8e8e000}, {0xb8e90000}, {0xb8e92000}, {0xb8e94000}, {0xb8e96000}, {0xb8e98000}, {0xb8e9a000}, {0xb8e9c000}, {0xb8e9e000}, {0xb8ea0000}, {0xb8ea2000}, {0xb8ea4000}, {0xb8ea6000}, {0xb8ea8000}, {0xb8eaa000}, {0xb8eac000}, {0xb8eae000}, {0xb8eb0000}, {0xb8eb2000}, {0xb8eb4000}, {0xb8eb6000}, {0xb8eb8000}, {0xb8eba000}, {0xb8ebc000}, {0xb8ebe000}, {0xb8ec0000}, {0xb8ec2000}, {0xb8ec4000}, {0xb8ec6000}, {0xb8ec8000}, {0xb8eca000}, {0xb8ecc000}, {0xb8ece000}, {0xb8ed0000}, {0xb8ed2000}, {0xb8ed4000}, {0xb8ed6000}, {0xb8ed8000}, {0xb8eda000}, {0xb8edc000}, {0xb8ede000}, {0xb8ee0000}, {0xb8ee2000}, {0xb8ee4000}, {0xb8ee6000}, {0xb8ee8000}, {0xb8eea000}, {0xb8eec000}, {0xb8eee000}, {0xb8ef0000}, {0xb8ef2000}, {0xb8ef4000}, {0xb8ef6000}, {0xb8ef8000}, {0xb8efa000}, {0xb8efc000}, {0xb8efe000}, {0xb8f00000}, {0xb8f02000}, {0xb8f04000}, {0xb8f06000}, {0xb8f08000}, {0xb8f0a000}, {0xb8f0c000}, {0xb8f0e000}, {0xb8f10000}, {0xb8f12000}, {0xb8f14000}, {0xb8f16000}, {0xb8f18000}, {0xb8f1a000}, {0xb8f1c000}, {0xb8f1e000}, {0xb8f20000}, {0xb8f22000}, {0xb8f24000}, {0xb8f26000}, {0xb8f28000}, {0xb8f2a000}, {0xb8f2c000}, {0xb8f2e000}, {0xb8f30000}, {0xb8f32000}, {0xb8f34000}, {0xb8f36000}, {0xb8f38000}, {0xb8f3a000}, {0xb8f3c000}, {0xb8f3e000}, {0xb8f40000}, {0xb8f42000}, {0xb8f44000}, {0xb8f46000}, {0xb8f48000}, {0xb8f4a000}, {0xb8f4c000}, {0xb8f4e000}, {0xb8f50000}, {0xb8f52000}, {0xb8f54000}, {0xb8f56000}, {0xb8f58000}, {0xb8f5a000}, {0xb8f5c000}, {0xb8f5e000}, {0xb8f60000}, {0xb8f62000}, {0xb8f64000}, {0xb8f66000}, {0xb8f68000}, {0xb8f6a000}, {0xb8f6c000}, {0xb8f6e000}, {0xb8f70000}, {0xb8f72000}, {0xb8f74000}, {0xb8f76000}, {0xb8f78000}, {0xb8f7a000}, {0xb8f7c000}, {0xb8f7e000}, {0xb8f80000}, {0xb8f82000}, {0xb8f84000}, {0xb8f86000}, {0xb8f88000}, {0xb8f8a000}, {0xb8f8c000}, {0xb8f8e000}, {0xb8f90000}, {0xb8f92000}, {0xb8f94000}, {0xb8f96000}, {0xb8f98000}, {0xb8f9a000}, {0xb8f9c000}, {0xb8f9e000}, {0xb8fa0000}, {0xb8fa2000}, {0xb8fa4000}, {0xb8fa6000}, {0xb8fa8000}, {0xb8faa000}, {0xb8fac000}, {0xb8fae000}, {0xb8fb0000}, {0xb8fb2000}, {0xb8fb4000}, {0xb8fb6000}, {0xb8fb8000}, {0xb8fba000}, {0xb8fbc000}, {0xb8fbe000}, {0xb8fc0000}, {0xb8fc2000}, {0xb8fc4000}, {0xb8fc6000}, {0xb8fc8000}, {0xb8fca000}, {0xb8fcc000}, {0xb8fce000}, {0xb8fd0000}, {0xb8fd2000}, {0xb8fd4000}, {0xb8fd6000}, {0xb8fd8000}, {0xb8fda000}, {0xb8fdc000}, {0xb8fde000}, {0xb8fe0000}, {0xb8fe2000}, {0xb8fe4000}, {0xb8fe6000}, {0xb8fe8000}, {0xb8fea000}, {0xb8fec000}, {0xb8fee000}, {0xb8ff0000}, {0xb8ff2000}, {0xb8ff4000}, {0xb8ff6000}, {0xb8ff8000}, {0xb8ffa000}, {0xb8ffc000}, {0xb8ffe000}, {0xb9000000}, {0xb9002000}, {0xb9004000}, {0xb9006000}, {0xb9008000}, {0xb900a000}, {0xb900c000}, {0xb900e000}, {0xb9010000}, {0xb9012000}, {0xb9014000}, {0xb9016000}, {0xb9018000}, {0xb901a000}, {0xb901c000}, {0xb901e000}, {0xb9020000}, {0xb9022000}, {0xb9024000}, {0xb9026000}, {0xb9028000}, {0xb902a000}, {0xb902c000}, {0xb902e000}, {0xb9030000}, {0xb9032000}, {0xb9034000}, {0xb9036000}, {0xb9038000}, {0xb903a000}, {0xb903c000}, {0xb903e000}, {0xb9040000}, {0xb9042000}, {0xb9044000}, {0xb9046000}, {0xb9048000}, {0xb904a000}, {0xb904c000}, {0xb904e000}, {0xb9050000}, {0xb9052000}, {0xb9054000}, {0xb9056000}, {0xb9058000}, {0xb905a000}, {0xb905c000}, {0xb905e000}, {0xb9060000}, {0xb9062000}, {0xb9064000}, {0xb9066000}, {0xb9068000}, {0xb906a000}, {0xb906c000}, {0xb906e000}, {0xb9070000}, {0xb9072000}, {0xb9074000}, {0xb9076000}, {0xb9078000}, {0xb907a000}, {0xb907c000}, {0xb907e000}, {0xb9080000}, {0xb9082000}, {0xb9084000}, {0xb9086000}, {0xb9088000}, {0xb908a000}, {0xb908c000}, {0xb908e000}, {0xb9090000}, {0xb9092000}, {0xb9094000}, {0xb9096000}, {0xb9098000}, {0xb909a000}, {0xb909c000}, {0xb909e000}, {0xb90a0000}, {0xb90a2000}, {0xb90a4000}, {0xb90a6000}, {0xb90a8000}, {0xb90aa000}, {0xb90ac000}, {0xb90ae000}, {0xb90b0000}, {0xb90b2000}, {0xb90b4000}, {0xb90b6000}, {0xb90b8000}, {0xb90ba000}, {0xb90bc000}, {0xb90be000}, {0xb90c0000}, {0xb90c2000}, {0xb90c4000}, {0xb90c6000}, {0xb90c8000}, {0xb90ca000}, {0xb90cc000}, {0xb90ce000}, {0xb90d0000}, {0xb90d2000}, {0xb90d4000}, {0xb90d6000}, {0xb90d8000}, {0xb90da000}, {0xb90dc000}, {0xb90de000}, {0xb90e0000}, {0xb90e2000}, {0xb90e4000}, {0xb90e6000}, {0xb90e8000}, {0xb90ea000}, {0xb90ec000}, {0xb90ee000}, {0xb90f0000}, {0xb90f2000}, {0xb90f4000}, {0xb90f6000}, {0xb90f8000}, {0xb90fa000}, {0xb90fc000}, {0xb90fe000}, {0xb9100000}, {0xb9102000}, {0xb9104000}, {0xb9106000}, {0xb9108000}, {0xb910a000}, {0xb910c000}, {0xb910e000}, {0xb9110000}, {0xb9112000}, {0xb9114000}, {0xb9116000}, {0xb9118000}, {0xb911a000}, {0xb911c000}, {0xb911e000}, {0xb9120000}, {0xb9122000}, {0xb9124000}, {0xb9126000}, {0xb9128000}, {0xb912a000}, {0xb912c000}, {0xb912e000}, {0xb9130000}, {0xb9132000}, {0xb9134000}, {0xb9136000}, {0xb9138000}, {0xb913a000}, {0xb913c000}, {0xb913e000}, {0xb9140000}, {0xb9142000}, {0xb9144000}, {0xb9146000}, {0xb9148000}, {0xb914a000}, {0xb914c000}, {0xb914e000}, {0xb9150000}, {0xb9152000}, {0xb9154000}, {0xb9156000}, {0xb9158000}, {0xb915a000}, {0xb915c000}, {0xb915e000}, {0xb9160000}, {0xb9162000}, {0xb9164000}, {0xb9166000}, {0xb9168000}, {0xb916a000}, {0xb916c000}, {0xb916e000}, {0xb9170000}, {0xb9172000}, {0xb9174000}, {0xb9176000}, {0xb9178000}, {0xb917a000}, {0xb917c000}, {0xb917e000}, {0xb9180000}, {0xb9182000}, {0xb9184000}, {0xb9186000}, {0xb9188000}, {0xb918a000}, {0xb918c000}, {0xb918e000}, {0xb9190000}, {0xb9192000}, {0xb9194000}, {0xb9196000}, {0xb9198000}, {0xb919a000}, {0xb919c000}, {0xb919e000}, {0xb91a0000}, {0xb91a2000}, {0xb91a4000}, {0xb91a6000}, {0xb91a8000}, {0xb91aa000}, {0xb91ac000}, {0xb91ae000}, {0xb91b0000}, {0xb91b2000}, {0xb91b4000}, {0xb91b6000}, {0xb91b8000}, {0xb91ba000}, {0xb91bc000}, {0xb91be000}, {0xb91c0000}, {0xb91c2000}, {0xb91c4000}, {0xb91c6000}, {0xb91c8000}, {0xb91ca000}, {0xb91cc000}, {0xb91ce000}, {0xb91d0000}, {0xb91d2000}, {0xb91d4000}, {0xb91d6000}, {0xb91d8000}, {0xb91da000}, {0xb91dc000}, {0xb91de000}, {0xb91e0000}, {0xb91e2000}, {0xb91e4000}, {0xb91e6000}, {0xb91e8000}, {0xb91ea000}, {0xb91ec000}, {0xb91ee000}, {0xb91f0000}, {0xb91f2000}, {0xb91f4000}, {0xb91f6000}, {0xb91f8000}, {0xb91fa000}, {0xb91fc000}, {0xb91fe000}, {0xb9200000}, {0xb9202000}, {0xb9204000}, {0xb9206000}, {0xb9208000}, {0xb920a000}, {0xb920c000}, {0xb920e000}, {0xb9210000}, {0xb9212000}, {0xb9214000}, {0xb9216000}, {0xb9218000}, {0xb921a000}, {0xb921c000}, {0xb921e000}, {0xb9220000}, {0xb9222000}, {0xb9224000}, {0xb9226000}, {0xb9228000}, {0xb922a000}, {0xb922c000}, {0xb922e000}, {0xb9230000}, {0xb9232000}, {0xb9234000}, {0xb9236000}, {0xb9238000}, {0xb923a000}, {0xb923c000}, {0xb923e000}, {0xb9240000}, {0xb9242000}, {0xb9244000}, {0xb9246000}, {0xb9248000}, {0xb924a000}, {0xb924c000}, {0xb924e000}, {0xb9250000}, {0xb9252000}, {0xb9254000}, {0xb9256000}, {0xb9258000}, {0xb925a000}, {0xb925c000}, {0xb925e000}, {0xb9260000}, {0xb9262000}, {0xb9264000}, {0xb9266000}, {0xb9268000}, {0xb926a000}, {0xb926c000}, {0xb926e000}, {0xb9270000}, {0xb9272000}, {0xb9274000}, {0xb9276000}, {0xb9278000}, {0xb927a000}, {0xb927c000}, {0xb927e000}, {0xb9280000}, {0xb9282000}, {0xb9284000}, {0xb9286000}, {0xb9288000}, {0xb928a000}, {0xb928c000}, {0xb928e000}, {0xb9290000}, {0xb9292000}, {0xb9294000}, {0xb9296000}, {0xb9298000}, {0xb929a000}, {0xb929c000}, {0xb929e000}, {0xb92a0000}, {0xb92a2000}, {0xb92a4000}, {0xb92a6000}, {0xb92a8000}, {0xb92aa000}, {0xb92ac000}, {0xb92ae000}, {0xb92b0000}, {0xb92b2000}, {0xb92b4000}, {0xb92b6000}, {0xb92b8000}, {0xb92ba000}, {0xb92bc000}, {0xb92be000}, {0xb92c0000}, {0xb92c2000}, {0xb92c4000}, {0xb92c6000}, {0xb92c8000}, {0xb92ca000}, {0xb92cc000}, {0xb92ce000}, {0xb92d0000}, {0xb92d2000}, {0xb92d4000}, {0xb92d6000}, {0xb92d8000}, {0xb92da000}, {0xb92dc000}, {0xb92de000}, {0xb92e0000}, {0xb92e2000}, {0xb92e4000}, {0xb92e6000}, {0xb92e8000}, {0xb92ea000}, {0xb92ec000}, {0xb92ee000}, {0xb92f0000}, {0xb92f2000}, {0xb92f4000}, {0xb92f6000}, {0xb92f8000}, {0xb92fa000}, {0xb92fc000}, {0xb92fe000}, {0xb9300000}, {0xb9302000}, {0xb9304000}, {0xb9306000}, {0xb9308000}, {0xb930a000}, {0xb930c000}, {0xb930e000}, {0xb9310000}, {0xb9312000}, {0xb9314000}, {0xb9316000}, {0xb9318000}, {0xb931a000}, {0xb931c000}, {0xb931e000}, {0xb9320000}, {0xb9322000}, {0xb9324000}, {0xb9326000}, {0xb9328000}, {0xb932a000}, {0xb932c000}, {0xb932e000}, {0xb9330000}, {0xb9332000}, {0xb9334000}, {0xb9336000}, {0xb9338000}, {0xb933a000}, {0xb933c000}, {0xb933e000}, {0xb9340000}, {0xb9342000}, {0xb9344000}, {0xb9346000}, {0xb9348000}, {0xb934a000}, {0xb934c000}, {0xb934e000}, {0xb9350000}, {0xb9352000}, {0xb9354000}, {0xb9356000}, {0xb9358000}, {0xb935a000}, {0xb935c000}, {0xb935e000}, {0xb9360000}, {0xb9362000}, {0xb9364000}, {0xb9366000}, {0xb9368000}, {0xb936a000}, {0xb936c000}, {0xb936e000}, {0xb9370000}, {0xb9372000}, {0xb9374000}, {0xb9376000}, {0xb9378000}, {0xb937a000}, {0xb937c000}, {0xb937e000}, {0xb9380000}, {0xb9382000}, {0xb9384000}, {0xb9386000}, {0xb9388000}, {0xb938a000}, {0xb938c000}, {0xb938e000}, {0xb9390000}, {0xb9392000}, {0xb9394000}, {0xb9396000}, {0xb9398000}, {0xb939a000}, {0xb939c000}, {0xb939e000}, {0xb93a0000}, {0xb93a2000}, {0xb93a4000}, {0xb93a6000}, {0xb93a8000}, {0xb93aa000}, {0xb93ac000}, {0xb93ae000}, {0xb93b0000}, {0xb93b2000}, {0xb93b4000}, {0xb93b6000}, {0xb93b8000}, {0xb93ba000}, {0xb93bc000}, {0xb93be000}, {0xb93c0000}, {0xb93c2000}, {0xb93c4000}, {0xb93c6000}, {0xb93c8000}, {0xb93ca000}, {0xb93cc000}, {0xb93ce000}, {0xb93d0000}, {0xb93d2000}, {0xb93d4000}, {0xb93d6000}, {0xb93d8000}, {0xb93da000}, {0xb93dc000}, {0xb93de000}, {0xb93e0000}, {0xb93e2000}, {0xb93e4000}, {0xb93e6000}, {0xb93e8000}, {0xb93ea000}, {0xb93ec000}, {0xb93ee000}, {0xb93f0000}, {0xb93f2000}, {0xb93f4000}, {0xb93f6000}, {0xb93f8000}, {0xb93fa000}, {0xb93fc000}, {0xb93fe000}, {0xb9400000}, {0xb9402000}, {0xb9404000}, {0xb9406000}, {0xb9408000}, {0xb940a000}, {0xb940c000}, {0xb940e000}, {0xb9410000}, {0xb9412000}, {0xb9414000}, {0xb9416000}, {0xb9418000}, {0xb941a000}, {0xb941c000}, {0xb941e000}, {0xb9420000}, {0xb9422000}, {0xb9424000}, {0xb9426000}, {0xb9428000}, {0xb942a000}, {0xb942c000}, {0xb942e000}, {0xb9430000}, {0xb9432000}, {0xb9434000}, {0xb9436000}, {0xb9438000}, {0xb943a000}, {0xb943c000}, {0xb943e000}, {0xb9440000}, {0xb9442000}, {0xb9444000}, {0xb9446000}, {0xb9448000}, {0xb944a000}, {0xb944c000}, {0xb944e000}, {0xb9450000}, {0xb9452000}, {0xb9454000}, {0xb9456000}, {0xb9458000}, {0xb945a000}, {0xb945c000}, {0xb945e000}, {0xb9460000}, {0xb9462000}, {0xb9464000}, {0xb9466000}, {0xb9468000}, {0xb946a000}, {0xb946c000}, {0xb946e000}, {0xb9470000}, {0xb9472000}, {0xb9474000}, {0xb9476000}, {0xb9478000}, {0xb947a000}, {0xb947c000}, {0xb947e000}, {0xb9480000}, {0xb9482000}, {0xb9484000}, {0xb9486000}, {0xb9488000}, {0xb948a000}, {0xb948c000}, {0xb948e000}, {0xb9490000}, {0xb9492000}, {0xb9494000}, {0xb9496000}, {0xb9498000}, {0xb949a000}, {0xb949c000}, {0xb949e000}, {0xb94a0000}, {0xb94a2000}, {0xb94a4000}, {0xb94a6000}, {0xb94a8000}, {0xb94aa000}, {0xb94ac000}, {0xb94ae000}, {0xb94b0000}, {0xb94b2000}, {0xb94b4000}, {0xb94b6000}, {0xb94b8000}, {0xb94ba000}, {0xb94bc000}, {0xb94be000}, {0xb94c0000}, {0xb94c2000}, {0xb94c4000}, {0xb94c6000}, {0xb94c8000}, {0xb94ca000}, {0xb94cc000}, {0xb94ce000}, {0xb94d0000}, {0xb94d2000}, {0xb94d4000}, {0xb94d6000}, {0xb94d8000}, {0xb94da000}, {0xb94dc000}, {0xb94de000}, {0xb94e0000}, {0xb94e2000}, {0xb94e4000}, {0xb94e6000}, {0xb94e8000}, {0xb94ea000}, {0xb94ec000}, {0xb94ee000}, {0xb94f0000}, {0xb94f2000}, {0xb94f4000}, {0xb94f6000}, {0xb94f8000}, {0xb94fa000}, {0xb94fc000}, {0xb94fe000}, {0xb9500000}, {0xb9502000}, {0xb9504000}, {0xb9506000}, {0xb9508000}, {0xb950a000}, {0xb950c000}, {0xb950e000}, {0xb9510000}, {0xb9512000}, {0xb9514000}, {0xb9516000}, {0xb9518000}, {0xb951a000}, {0xb951c000}, {0xb951e000}, {0xb9520000}, {0xb9522000}, {0xb9524000}, {0xb9526000}, {0xb9528000}, {0xb952a000}, {0xb952c000}, {0xb952e000}, {0xb9530000}, {0xb9532000}, {0xb9534000}, {0xb9536000}, {0xb9538000}, {0xb953a000}, {0xb953c000}, {0xb953e000}, {0xb9540000}, {0xb9542000}, {0xb9544000}, {0xb9546000}, {0xb9548000}, {0xb954a000}, {0xb954c000}, {0xb954e000}, {0xb9550000}, {0xb9552000}, {0xb9554000}, {0xb9556000}, {0xb9558000}, {0xb955a000}, {0xb955c000}, {0xb955e000}, {0xb9560000}, {0xb9562000}, {0xb9564000}, {0xb9566000}, {0xb9568000}, {0xb956a000}, {0xb956c000}, {0xb956e000}, {0xb9570000}, {0xb9572000}, {0xb9574000}, {0xb9576000}, {0xb9578000}, {0xb957a000}, {0xb957c000}, {0xb957e000}, {0xb9580000}, {0xb9582000}, {0xb9584000}, {0xb9586000}, {0xb9588000}, {0xb958a000}, {0xb958c000}, {0xb958e000}, {0xb9590000}, {0xb9592000}, {0xb9594000}, {0xb9596000}, {0xb9598000}, {0xb959a000}, {0xb959c000}, {0xb959e000}, {0xb95a0000}, {0xb95a2000}, {0xb95a4000}, {0xb95a6000}, {0xb95a8000}, {0xb95aa000}, {0xb95ac000}, {0xb95ae000}, {0xb95b0000}, {0xb95b2000}, {0xb95b4000}, {0xb95b6000}, {0xb95b8000}, {0xb95ba000}, {0xb95bc000}, {0xb95be000}, {0xb95c0000}, {0xb95c2000}, {0xb95c4000}, {0xb95c6000}, {0xb95c8000}, {0xb95ca000}, {0xb95cc000}, {0xb95ce000}, {0xb95d0000}, {0xb95d2000}, {0xb95d4000}, {0xb95d6000}, {0xb95d8000}, {0xb95da000}, {0xb95dc000}, {0xb95de000}, {0xb95e0000}, {0xb95e2000}, {0xb95e4000}, {0xb95e6000}, {0xb95e8000}, {0xb95ea000}, {0xb95ec000}, {0xb95ee000}, {0xb95f0000}, {0xb95f2000}, {0xb95f4000}, {0xb95f6000}, {0xb95f8000}, {0xb95fa000}, {0xb95fc000}, {0xb95fe000}, {0xb9600000}, {0xb9602000}, {0xb9604000}, {0xb9606000}, {0xb9608000}, {0xb960a000}, {0xb960c000}, {0xb960e000}, {0xb9610000}, {0xb9612000}, {0xb9614000}, {0xb9616000}, {0xb9618000}, {0xb961a000}, {0xb961c000}, {0xb961e000}, {0xb9620000}, {0xb9622000}, {0xb9624000}, {0xb9626000}, {0xb9628000}, {0xb962a000}, {0xb962c000}, {0xb962e000}, {0xb9630000}, {0xb9632000}, {0xb9634000}, {0xb9636000}, {0xb9638000}, {0xb963a000}, {0xb963c000}, {0xb963e000}, {0xb9640000}, {0xb9642000}, {0xb9644000}, {0xb9646000}, {0xb9648000}, {0xb964a000}, {0xb964c000}, {0xb964e000}, {0xb9650000}, {0xb9652000}, {0xb9654000}, {0xb9656000}, {0xb9658000}, {0xb965a000}, {0xb965c000}, {0xb965e000}, {0xb9660000}, {0xb9662000}, {0xb9664000}, {0xb9666000}, {0xb9668000}, {0xb966a000}, {0xb966c000}, {0xb966e000}, {0xb9670000}, {0xb9672000}, {0xb9674000}, {0xb9676000}, {0xb9678000}, {0xb967a000}, {0xb967c000}, {0xb967e000}, {0xb9680000}, {0xb9682000}, {0xb9684000}, {0xb9686000}, {0xb9688000}, {0xb968a000}, {0xb968c000}, {0xb968e000}, {0xb9690000}, {0xb9692000}, {0xb9694000}, {0xb9696000}, {0xb9698000}, {0xb969a000}, {0xb969c000}, {0xb969e000}, {0xb96a0000}, {0xb96a2000}, {0xb96a4000}, {0xb96a6000}, {0xb96a8000}, {0xb96aa000}, {0xb96ac000}, {0xb96ae000}, {0xb96b0000}, {0xb96b2000}, {0xb96b4000}, {0xb96b6000}, {0xb96b8000}, {0xb96ba000}, {0xb96bc000}, {0xb96be000}, {0xb96c0000}, {0xb96c2000}, {0xb96c4000}, {0xb96c6000}, {0xb96c8000}, {0xb96ca000}, {0xb96cc000}, {0xb96ce000}, {0xb96d0000}, {0xb96d2000}, {0xb96d4000}, {0xb96d6000}, {0xb96d8000}, {0xb96da000}, {0xb96dc000}, {0xb96de000}, {0xb96e0000}, {0xb96e2000}, {0xb96e4000}, {0xb96e6000}, {0xb96e8000}, {0xb96ea000}, {0xb96ec000}, {0xb96ee000}, {0xb96f0000}, {0xb96f2000}, {0xb96f4000}, {0xb96f6000}, {0xb96f8000}, {0xb96fa000}, {0xb96fc000}, {0xb96fe000}, {0xb9700000}, {0xb9702000}, {0xb9704000}, {0xb9706000}, {0xb9708000}, {0xb970a000}, {0xb970c000}, {0xb970e000}, {0xb9710000}, {0xb9712000}, {0xb9714000}, {0xb9716000}, {0xb9718000}, {0xb971a000}, {0xb971c000}, {0xb971e000}, {0xb9720000}, {0xb9722000}, {0xb9724000}, {0xb9726000}, {0xb9728000}, {0xb972a000}, {0xb972c000}, {0xb972e000}, {0xb9730000}, {0xb9732000}, {0xb9734000}, {0xb9736000}, {0xb9738000}, {0xb973a000}, {0xb973c000}, {0xb973e000}, {0xb9740000}, {0xb9742000}, {0xb9744000}, {0xb9746000}, {0xb9748000}, {0xb974a000}, {0xb974c000}, {0xb974e000}, {0xb9750000}, {0xb9752000}, {0xb9754000}, {0xb9756000}, {0xb9758000}, {0xb975a000}, {0xb975c000}, {0xb975e000}, {0xb9760000}, {0xb9762000}, {0xb9764000}, {0xb9766000}, {0xb9768000}, {0xb976a000}, {0xb976c000}, {0xb976e000}, {0xb9770000}, {0xb9772000}, {0xb9774000}, {0xb9776000}, {0xb9778000}, {0xb977a000}, {0xb977c000}, {0xb977e000}, {0xb9780000}, {0xb9782000}, {0xb9784000}, {0xb9786000}, {0xb9788000}, {0xb978a000}, {0xb978c000}, {0xb978e000}, {0xb9790000}, {0xb9792000}, {0xb9794000}, {0xb9796000}, {0xb9798000}, {0xb979a000}, {0xb979c000}, {0xb979e000}, {0xb97a0000}, {0xb97a2000}, {0xb97a4000}, {0xb97a6000}, {0xb97a8000}, {0xb97aa000}, {0xb97ac000}, {0xb97ae000}, {0xb97b0000}, {0xb97b2000}, {0xb97b4000}, {0xb97b6000}, {0xb97b8000}, {0xb97ba000}, {0xb97bc000}, {0xb97be000}, {0xb97c0000}, {0xb97c2000}, {0xb97c4000}, {0xb97c6000}, {0xb97c8000}, {0xb97ca000}, {0xb97cc000}, {0xb97ce000}, {0xb97d0000}, {0xb97d2000}, {0xb97d4000}, {0xb97d6000}, {0xb97d8000}, {0xb97da000}, {0xb97dc000}, {0xb97de000}, {0xb97e0000}, {0xb97e2000}, {0xb97e4000}, {0xb97e6000}, {0xb97e8000}, {0xb97ea000}, {0xb97ec000}, {0xb97ee000}, {0xb97f0000}, {0xb97f2000}, {0xb97f4000}, {0xb97f6000}, {0xb97f8000}, {0xb97fa000}, {0xb97fc000}, {0xb97fe000}, {0xb9800000}, {0xb9802000}, {0xb9804000}, {0xb9806000}, {0xb9808000}, {0xb980a000}, {0xb980c000}, {0xb980e000}, {0xb9810000}, {0xb9812000}, {0xb9814000}, {0xb9816000}, {0xb9818000}, {0xb981a000}, {0xb981c000}, {0xb981e000}, {0xb9820000}, {0xb9822000}, {0xb9824000}, {0xb9826000}, {0xb9828000}, {0xb982a000}, {0xb982c000}, {0xb982e000}, {0xb9830000}, {0xb9832000}, {0xb9834000}, {0xb9836000}, {0xb9838000}, {0xb983a000}, {0xb983c000}, {0xb983e000}, {0xb9840000}, {0xb9842000}, {0xb9844000}, {0xb9846000}, {0xb9848000}, {0xb984a000}, {0xb984c000}, {0xb984e000}, {0xb9850000}, {0xb9852000}, {0xb9854000}, {0xb9856000}, {0xb9858000}, {0xb985a000}, {0xb985c000}, {0xb985e000}, {0xb9860000}, {0xb9862000}, {0xb9864000}, {0xb9866000}, {0xb9868000}, {0xb986a000}, {0xb986c000}, {0xb986e000}, {0xb9870000}, {0xb9872000}, {0xb9874000}, {0xb9876000}, {0xb9878000}, {0xb987a000}, {0xb987c000}, {0xb987e000}, {0xb9880000}, {0xb9882000}, {0xb9884000}, {0xb9886000}, {0xb9888000}, {0xb988a000}, {0xb988c000}, {0xb988e000}, {0xb9890000}, {0xb9892000}, {0xb9894000}, {0xb9896000}, {0xb9898000}, {0xb989a000}, {0xb989c000}, {0xb989e000}, {0xb98a0000}, {0xb98a2000}, {0xb98a4000}, {0xb98a6000}, {0xb98a8000}, {0xb98aa000}, {0xb98ac000}, {0xb98ae000}, {0xb98b0000}, {0xb98b2000}, {0xb98b4000}, {0xb98b6000}, {0xb98b8000}, {0xb98ba000}, {0xb98bc000}, {0xb98be000}, {0xb98c0000}, {0xb98c2000}, {0xb98c4000}, {0xb98c6000}, {0xb98c8000}, {0xb98ca000}, {0xb98cc000}, {0xb98ce000}, {0xb98d0000}, {0xb98d2000}, {0xb98d4000}, {0xb98d6000}, {0xb98d8000}, {0xb98da000}, {0xb98dc000}, {0xb98de000}, {0xb98e0000}, {0xb98e2000}, {0xb98e4000}, {0xb98e6000}, {0xb98e8000}, {0xb98ea000}, {0xb98ec000}, {0xb98ee000}, {0xb98f0000}, {0xb98f2000}, {0xb98f4000}, {0xb98f6000}, {0xb98f8000}, {0xb98fa000}, {0xb98fc000}, {0xb98fe000}, {0xb9900000}, {0xb9902000}, {0xb9904000}, {0xb9906000}, {0xb9908000}, {0xb990a000}, {0xb990c000}, {0xb990e000}, {0xb9910000}, {0xb9912000}, {0xb9914000}, {0xb9916000}, {0xb9918000}, {0xb991a000}, {0xb991c000}, {0xb991e000}, {0xb9920000}, {0xb9922000}, {0xb9924000}, {0xb9926000}, {0xb9928000}, {0xb992a000}, {0xb992c000}, {0xb992e000}, {0xb9930000}, {0xb9932000}, {0xb9934000}, {0xb9936000}, {0xb9938000}, {0xb993a000}, {0xb993c000}, {0xb993e000}, {0xb9940000}, {0xb9942000}, {0xb9944000}, {0xb9946000}, {0xb9948000}, {0xb994a000}, {0xb994c000}, {0xb994e000}, {0xb9950000}, {0xb9952000}, {0xb9954000}, {0xb9956000}, {0xb9958000}, {0xb995a000}, {0xb995c000}, {0xb995e000}, {0xb9960000}, {0xb9962000}, {0xb9964000}, {0xb9966000}, {0xb9968000}, {0xb996a000}, {0xb996c000}, {0xb996e000}, {0xb9970000}, {0xb9972000}, {0xb9974000}, {0xb9976000}, {0xb9978000}, {0xb997a000}, {0xb997c000}, {0xb997e000}, {0xb9980000}, {0xb9982000}, {0xb9984000}, {0xb9986000}, {0xb9988000}, {0xb998a000}, {0xb998c000}, {0xb998e000}, {0xb9990000}, {0xb9992000}, {0xb9994000}, {0xb9996000}, {0xb9998000}, {0xb999a000}, {0xb999c000}, {0xb999e000}, {0xb99a0000}, {0xb99a2000}, {0xb99a4000}, {0xb99a6000}, {0xb99a8000}, {0xb99aa000}, {0xb99ac000}, {0xb99ae000}, {0xb99b0000}, {0xb99b2000}, {0xb99b4000}, {0xb99b6000}, {0xb99b8000}, {0xb99ba000}, {0xb99bc000}, {0xb99be000}, {0xb99c0000}, {0xb99c2000}, {0xb99c4000}, {0xb99c6000}, {0xb99c8000}, {0xb99ca000}, {0xb99cc000}, {0xb99ce000}, {0xb99d0000}, {0xb99d2000}, {0xb99d4000}, {0xb99d6000}, {0xb99d8000}, {0xb99da000}, {0xb99dc000}, {0xb99de000}, {0xb99e0000}, {0xb99e2000}, {0xb99e4000}, {0xb99e6000}, {0xb99e8000}, {0xb99ea000}, {0xb99ec000}, {0xb99ee000}, {0xb99f0000}, {0xb99f2000}, {0xb99f4000}, {0xb99f6000}, {0xb99f8000}, {0xb99fa000}, {0xb99fc000}, {0xb99fe000}, {0xb9a00000}, {0xb9a02000}, {0xb9a04000}, {0xb9a06000}, {0xb9a08000}, {0xb9a0a000}, {0xb9a0c000}, {0xb9a0e000}, {0xb9a10000}, {0xb9a12000}, {0xb9a14000}, {0xb9a16000}, {0xb9a18000}, {0xb9a1a000}, {0xb9a1c000}, {0xb9a1e000}, {0xb9a20000}, {0xb9a22000}, {0xb9a24000}, {0xb9a26000}, {0xb9a28000}, {0xb9a2a000}, {0xb9a2c000}, {0xb9a2e000}, {0xb9a30000}, {0xb9a32000}, {0xb9a34000}, {0xb9a36000}, {0xb9a38000}, {0xb9a3a000}, {0xb9a3c000}, {0xb9a3e000}, {0xb9a40000}, {0xb9a42000}, {0xb9a44000}, {0xb9a46000}, {0xb9a48000}, {0xb9a4a000}, {0xb9a4c000}, {0xb9a4e000}, {0xb9a50000}, {0xb9a52000}, {0xb9a54000}, {0xb9a56000}, {0xb9a58000}, {0xb9a5a000}, {0xb9a5c000}, {0xb9a5e000}, {0xb9a60000}, {0xb9a62000}, {0xb9a64000}, {0xb9a66000}, {0xb9a68000}, {0xb9a6a000}, {0xb9a6c000}, {0xb9a6e000}, {0xb9a70000}, {0xb9a72000}, {0xb9a74000}, {0xb9a76000}, {0xb9a78000}, {0xb9a7a000}, {0xb9a7c000}, {0xb9a7e000}, {0xb9a80000}, {0xb9a82000}, {0xb9a84000}, {0xb9a86000}, {0xb9a88000}, {0xb9a8a000}, {0xb9a8c000}, {0xb9a8e000}, {0xb9a90000}, {0xb9a92000}, {0xb9a94000}, {0xb9a96000}, {0xb9a98000}, {0xb9a9a000}, {0xb9a9c000}, {0xb9a9e000}, {0xb9aa0000}, {0xb9aa2000}, {0xb9aa4000}, {0xb9aa6000}, {0xb9aa8000}, {0xb9aaa000}, {0xb9aac000}, {0xb9aae000}, {0xb9ab0000}, {0xb9ab2000}, {0xb9ab4000}, {0xb9ab6000}, {0xb9ab8000}, {0xb9aba000}, {0xb9abc000}, {0xb9abe000}, {0xb9ac0000}, {0xb9ac2000}, {0xb9ac4000}, {0xb9ac6000}, {0xb9ac8000}, {0xb9aca000}, {0xb9acc000}, {0xb9ace000}, {0xb9ad0000}, {0xb9ad2000}, {0xb9ad4000}, {0xb9ad6000}, {0xb9ad8000}, {0xb9ada000}, {0xb9adc000}, {0xb9ade000}, {0xb9ae0000}, {0xb9ae2000}, {0xb9ae4000}, {0xb9ae6000}, {0xb9ae8000}, {0xb9aea000}, {0xb9aec000}, {0xb9aee000}, {0xb9af0000}, {0xb9af2000}, {0xb9af4000}, {0xb9af6000}, {0xb9af8000}, {0xb9afa000}, {0xb9afc000}, {0xb9afe000}, {0xb9b00000}, {0xb9b02000}, {0xb9b04000}, {0xb9b06000}, {0xb9b08000}, {0xb9b0a000}, {0xb9b0c000}, {0xb9b0e000}, {0xb9b10000}, {0xb9b12000}, {0xb9b14000}, {0xb9b16000}, {0xb9b18000}, {0xb9b1a000}, {0xb9b1c000}, {0xb9b1e000}, {0xb9b20000}, {0xb9b22000}, {0xb9b24000}, {0xb9b26000}, {0xb9b28000}, {0xb9b2a000}, {0xb9b2c000}, {0xb9b2e000}, {0xb9b30000}, {0xb9b32000}, {0xb9b34000}, {0xb9b36000}, {0xb9b38000}, {0xb9b3a000}, {0xb9b3c000}, {0xb9b3e000}, {0xb9b40000}, {0xb9b42000}, {0xb9b44000}, {0xb9b46000}, {0xb9b48000}, {0xb9b4a000}, {0xb9b4c000}, {0xb9b4e000}, {0xb9b50000}, {0xb9b52000}, {0xb9b54000}, {0xb9b56000}, {0xb9b58000}, {0xb9b5a000}, {0xb9b5c000}, {0xb9b5e000}, {0xb9b60000}, {0xb9b62000}, {0xb9b64000}, {0xb9b66000}, {0xb9b68000}, {0xb9b6a000}, {0xb9b6c000}, {0xb9b6e000}, {0xb9b70000}, {0xb9b72000}, {0xb9b74000}, {0xb9b76000}, {0xb9b78000}, {0xb9b7a000}, {0xb9b7c000}, {0xb9b7e000}, {0xb9b80000}, {0xb9b82000}, {0xb9b84000}, {0xb9b86000}, {0xb9b88000}, {0xb9b8a000}, {0xb9b8c000}, {0xb9b8e000}, {0xb9b90000}, {0xb9b92000}, {0xb9b94000}, {0xb9b96000}, {0xb9b98000}, {0xb9b9a000}, {0xb9b9c000}, {0xb9b9e000}, {0xb9ba0000}, {0xb9ba2000}, {0xb9ba4000}, {0xb9ba6000}, {0xb9ba8000}, {0xb9baa000}, {0xb9bac000}, {0xb9bae000}, {0xb9bb0000}, {0xb9bb2000}, {0xb9bb4000}, {0xb9bb6000}, {0xb9bb8000}, {0xb9bba000}, {0xb9bbc000}, {0xb9bbe000}, {0xb9bc0000}, {0xb9bc2000}, {0xb9bc4000}, {0xb9bc6000}, {0xb9bc8000}, {0xb9bca000}, {0xb9bcc000}, {0xb9bce000}, {0xb9bd0000}, {0xb9bd2000}, {0xb9bd4000}, {0xb9bd6000}, {0xb9bd8000}, {0xb9bda000}, {0xb9bdc000}, {0xb9bde000}, {0xb9be0000}, {0xb9be2000}, {0xb9be4000}, {0xb9be6000}, {0xb9be8000}, {0xb9bea000}, {0xb9bec000}, {0xb9bee000}, {0xb9bf0000}, {0xb9bf2000}, {0xb9bf4000}, {0xb9bf6000}, {0xb9bf8000}, {0xb9bfa000}, {0xb9bfc000}, {0xb9bfe000}, {0xb9c00000}, {0xb9c02000}, {0xb9c04000}, {0xb9c06000}, {0xb9c08000}, {0xb9c0a000}, {0xb9c0c000}, {0xb9c0e000}, {0xb9c10000}, {0xb9c12000}, {0xb9c14000}, {0xb9c16000}, {0xb9c18000}, {0xb9c1a000}, {0xb9c1c000}, {0xb9c1e000}, {0xb9c20000}, {0xb9c22000}, {0xb9c24000}, {0xb9c26000}, {0xb9c28000}, {0xb9c2a000}, {0xb9c2c000}, {0xb9c2e000}, {0xb9c30000}, {0xb9c32000}, {0xb9c34000}, {0xb9c36000}, {0xb9c38000}, {0xb9c3a000}, {0xb9c3c000}, {0xb9c3e000}, {0xb9c40000}, {0xb9c42000}, {0xb9c44000}, {0xb9c46000}, {0xb9c48000}, {0xb9c4a000}, {0xb9c4c000}, {0xb9c4e000}, {0xb9c50000}, {0xb9c52000}, {0xb9c54000}, {0xb9c56000}, {0xb9c58000}, {0xb9c5a000}, {0xb9c5c000}, {0xb9c5e000}, {0xb9c60000}, {0xb9c62000}, {0xb9c64000}, {0xb9c66000}, {0xb9c68000}, {0xb9c6a000}, {0xb9c6c000}, {0xb9c6e000}, {0xb9c70000}, {0xb9c72000}, {0xb9c74000}, {0xb9c76000}, {0xb9c78000}, {0xb9c7a000}, {0xb9c7c000}, {0xb9c7e000}, {0xb9c80000}, {0xb9c82000}, {0xb9c84000}, {0xb9c86000}, {0xb9c88000}, {0xb9c8a000}, {0xb9c8c000}, {0xb9c8e000}, {0xb9c90000}, {0xb9c92000}, {0xb9c94000}, {0xb9c96000}, {0xb9c98000}, {0xb9c9a000}, {0xb9c9c000}, {0xb9c9e000}, {0xb9ca0000}, {0xb9ca2000}, {0xb9ca4000}, {0xb9ca6000}, {0xb9ca8000}, {0xb9caa000}, {0xb9cac000}, {0xb9cae000}, {0xb9cb0000}, {0xb9cb2000}, {0xb9cb4000}, {0xb9cb6000}, {0xb9cb8000}, {0xb9cba000}, {0xb9cbc000}, {0xb9cbe000}, {0xb9cc0000}, {0xb9cc2000}, {0xb9cc4000}, {0xb9cc6000}, {0xb9cc8000}, {0xb9cca000}, {0xb9ccc000}, {0xb9cce000}, {0xb9cd0000}, {0xb9cd2000}, {0xb9cd4000}, {0xb9cd6000}, {0xb9cd8000}, {0xb9cda000}, {0xb9cdc000}, {0xb9cde000}, {0xb9ce0000}, {0xb9ce2000}, {0xb9ce4000}, {0xb9ce6000}, {0xb9ce8000}, {0xb9cea000}, {0xb9cec000}, {0xb9cee000}, {0xb9cf0000}, {0xb9cf2000}, {0xb9cf4000}, {0xb9cf6000}, {0xb9cf8000}, {0xb9cfa000}, {0xb9cfc000}, {0xb9cfe000}, {0xb9d00000}, {0xb9d02000}, {0xb9d04000}, {0xb9d06000}, {0xb9d08000}, {0xb9d0a000}, {0xb9d0c000}, {0xb9d0e000}, {0xb9d10000}, {0xb9d12000}, {0xb9d14000}, {0xb9d16000}, {0xb9d18000}, {0xb9d1a000}, {0xb9d1c000}, {0xb9d1e000}, {0xb9d20000}, {0xb9d22000}, {0xb9d24000}, {0xb9d26000}, {0xb9d28000}, {0xb9d2a000}, {0xb9d2c000}, {0xb9d2e000}, {0xb9d30000}, {0xb9d32000}, {0xb9d34000}, {0xb9d36000}, {0xb9d38000}, {0xb9d3a000}, {0xb9d3c000}, {0xb9d3e000}, {0xb9d40000}, {0xb9d42000}, {0xb9d44000}, {0xb9d46000}, {0xb9d48000}, {0xb9d4a000}, {0xb9d4c000}, {0xb9d4e000}, {0xb9d50000}, {0xb9d52000}, {0xb9d54000}, {0xb9d56000}, {0xb9d58000}, {0xb9d5a000}, {0xb9d5c000}, {0xb9d5e000}, {0xb9d60000}, {0xb9d62000}, {0xb9d64000}, {0xb9d66000}, {0xb9d68000}, {0xb9d6a000}, {0xb9d6c000}, {0xb9d6e000}, {0xb9d70000}, {0xb9d72000}, {0xb9d74000}, {0xb9d76000}, {0xb9d78000}, {0xb9d7a000}, {0xb9d7c000}, {0xb9d7e000}, {0xb9d80000}, {0xb9d82000}, {0xb9d84000}, {0xb9d86000}, {0xb9d88000}, {0xb9d8a000}, {0xb9d8c000}, {0xb9d8e000}, {0xb9d90000}, {0xb9d92000}, {0xb9d94000}, {0xb9d96000}, {0xb9d98000}, {0xb9d9a000}, {0xb9d9c000}, {0xb9d9e000}, {0xb9da0000}, {0xb9da2000}, {0xb9da4000}, {0xb9da6000}, {0xb9da8000}, {0xb9daa000}, {0xb9dac000}, {0xb9dae000}, {0xb9db0000}, {0xb9db2000}, {0xb9db4000}, {0xb9db6000}, {0xb9db8000}, {0xb9dba000}, {0xb9dbc000}, {0xb9dbe000}, {0xb9dc0000}, {0xb9dc2000}, {0xb9dc4000}, {0xb9dc6000}, {0xb9dc8000}, {0xb9dca000}, {0xb9dcc000}, {0xb9dce000}, {0xb9dd0000}, {0xb9dd2000}, {0xb9dd4000}, {0xb9dd6000}, {0xb9dd8000}, {0xb9dda000}, {0xb9ddc000}, {0xb9dde000}, {0xb9de0000}, {0xb9de2000}, {0xb9de4000}, {0xb9de6000}, {0xb9de8000}, {0xb9dea000}, {0xb9dec000}, {0xb9dee000}, {0xb9df0000}, {0xb9df2000}, {0xb9df4000}, {0xb9df6000}, {0xb9df8000}, {0xb9dfa000}, {0xb9dfc000}, {0xb9dfe000}, {0xb9e00000}, {0xb9e02000}, {0xb9e04000}, {0xb9e06000}, {0xb9e08000}, {0xb9e0a000}, {0xb9e0c000}, {0xb9e0e000}, {0xb9e10000}, {0xb9e12000}, {0xb9e14000}, {0xb9e16000}, {0xb9e18000}, {0xb9e1a000}, {0xb9e1c000}, {0xb9e1e000}, {0xb9e20000}, {0xb9e22000}, {0xb9e24000}, {0xb9e26000}, {0xb9e28000}, {0xb9e2a000}, {0xb9e2c000}, {0xb9e2e000}, {0xb9e30000}, {0xb9e32000}, {0xb9e34000}, {0xb9e36000}, {0xb9e38000}, {0xb9e3a000}, {0xb9e3c000}, {0xb9e3e000}, {0xb9e40000}, {0xb9e42000}, {0xb9e44000}, {0xb9e46000}, {0xb9e48000}, {0xb9e4a000}, {0xb9e4c000}, {0xb9e4e000}, {0xb9e50000}, {0xb9e52000}, {0xb9e54000}, {0xb9e56000}, {0xb9e58000}, {0xb9e5a000}, {0xb9e5c000}, {0xb9e5e000}, {0xb9e60000}, {0xb9e62000}, {0xb9e64000}, {0xb9e66000}, {0xb9e68000}, {0xb9e6a000}, {0xb9e6c000}, {0xb9e6e000}, {0xb9e70000}, {0xb9e72000}, {0xb9e74000}, {0xb9e76000}, {0xb9e78000}, {0xb9e7a000}, {0xb9e7c000}, {0xb9e7e000}, {0xb9e80000}, {0xb9e82000}, {0xb9e84000}, {0xb9e86000}, {0xb9e88000}, {0xb9e8a000}, {0xb9e8c000}, {0xb9e8e000}, {0xb9e90000}, {0xb9e92000}, {0xb9e94000}, {0xb9e96000}, {0xb9e98000}, {0xb9e9a000}, {0xb9e9c000}, {0xb9e9e000}, {0xb9ea0000}, {0xb9ea2000}, {0xb9ea4000}, {0xb9ea6000}, {0xb9ea8000}, {0xb9eaa000}, {0xb9eac000}, {0xb9eae000}, {0xb9eb0000}, {0xb9eb2000}, {0xb9eb4000}, {0xb9eb6000}, {0xb9eb8000}, {0xb9eba000}, {0xb9ebc000}, {0xb9ebe000}, {0xb9ec0000}, {0xb9ec2000}, {0xb9ec4000}, {0xb9ec6000}, {0xb9ec8000}, {0xb9eca000}, {0xb9ecc000}, {0xb9ece000}, {0xb9ed0000}, {0xb9ed2000}, {0xb9ed4000}, {0xb9ed6000}, {0xb9ed8000}, {0xb9eda000}, {0xb9edc000}, {0xb9ede000}, {0xb9ee0000}, {0xb9ee2000}, {0xb9ee4000}, {0xb9ee6000}, {0xb9ee8000}, {0xb9eea000}, {0xb9eec000}, {0xb9eee000}, {0xb9ef0000}, {0xb9ef2000}, {0xb9ef4000}, {0xb9ef6000}, {0xb9ef8000}, {0xb9efa000}, {0xb9efc000}, {0xb9efe000}, {0xb9f00000}, {0xb9f02000}, {0xb9f04000}, {0xb9f06000}, {0xb9f08000}, {0xb9f0a000}, {0xb9f0c000}, {0xb9f0e000}, {0xb9f10000}, {0xb9f12000}, {0xb9f14000}, {0xb9f16000}, {0xb9f18000}, {0xb9f1a000}, {0xb9f1c000}, {0xb9f1e000}, {0xb9f20000}, {0xb9f22000}, {0xb9f24000}, {0xb9f26000}, {0xb9f28000}, {0xb9f2a000}, {0xb9f2c000}, {0xb9f2e000}, {0xb9f30000}, {0xb9f32000}, {0xb9f34000}, {0xb9f36000}, {0xb9f38000}, {0xb9f3a000}, {0xb9f3c000}, {0xb9f3e000}, {0xb9f40000}, {0xb9f42000}, {0xb9f44000}, {0xb9f46000}, {0xb9f48000}, {0xb9f4a000}, {0xb9f4c000}, {0xb9f4e000}, {0xb9f50000}, {0xb9f52000}, {0xb9f54000}, {0xb9f56000}, {0xb9f58000}, {0xb9f5a000}, {0xb9f5c000}, {0xb9f5e000}, {0xb9f60000}, {0xb9f62000}, {0xb9f64000}, {0xb9f66000}, {0xb9f68000}, {0xb9f6a000}, {0xb9f6c000}, {0xb9f6e000}, {0xb9f70000}, {0xb9f72000}, {0xb9f74000}, {0xb9f76000}, {0xb9f78000}, {0xb9f7a000}, {0xb9f7c000}, {0xb9f7e000}, {0xb9f80000}, {0xb9f82000}, {0xb9f84000}, {0xb9f86000}, {0xb9f88000}, {0xb9f8a000}, {0xb9f8c000}, {0xb9f8e000}, {0xb9f90000}, {0xb9f92000}, {0xb9f94000}, {0xb9f96000}, {0xb9f98000}, {0xb9f9a000}, {0xb9f9c000}, {0xb9f9e000}, {0xb9fa0000}, {0xb9fa2000}, {0xb9fa4000}, {0xb9fa6000}, {0xb9fa8000}, {0xb9faa000}, {0xb9fac000}, {0xb9fae000}, {0xb9fb0000}, {0xb9fb2000}, {0xb9fb4000}, {0xb9fb6000}, {0xb9fb8000}, {0xb9fba000}, {0xb9fbc000}, {0xb9fbe000}, {0xb9fc0000}, {0xb9fc2000}, {0xb9fc4000}, {0xb9fc6000}, {0xb9fc8000}, {0xb9fca000}, {0xb9fcc000}, {0xb9fce000}, {0xb9fd0000}, {0xb9fd2000}, {0xb9fd4000}, {0xb9fd6000}, {0xb9fd8000}, {0xb9fda000}, {0xb9fdc000}, {0xb9fde000}, {0xb9fe0000}, {0xb9fe2000}, {0xb9fe4000}, {0xb9fe6000}, {0xb9fe8000}, {0xb9fea000}, {0xb9fec000}, {0xb9fee000}, {0xb9ff0000}, {0xb9ff2000}, {0xb9ff4000}, {0xb9ff6000}, {0xb9ff8000}, {0xb9ffa000}, {0xb9ffc000}, {0xb9ffe000}, {0xba000000}, {0xba002000}, {0xba004000}, {0xba006000}, {0xba008000}, {0xba00a000}, {0xba00c000}, {0xba00e000}, {0xba010000}, {0xba012000}, {0xba014000}, {0xba016000}, {0xba018000}, {0xba01a000}, {0xba01c000}, {0xba01e000}, {0xba020000}, {0xba022000}, {0xba024000}, {0xba026000}, {0xba028000}, {0xba02a000}, {0xba02c000}, {0xba02e000}, {0xba030000}, {0xba032000}, {0xba034000}, {0xba036000}, {0xba038000}, {0xba03a000}, {0xba03c000}, {0xba03e000}, {0xba040000}, {0xba042000}, {0xba044000}, {0xba046000}, {0xba048000}, {0xba04a000}, {0xba04c000}, {0xba04e000}, {0xba050000}, {0xba052000}, {0xba054000}, {0xba056000}, {0xba058000}, {0xba05a000}, {0xba05c000}, {0xba05e000}, {0xba060000}, {0xba062000}, {0xba064000}, {0xba066000}, {0xba068000}, {0xba06a000}, {0xba06c000}, {0xba06e000}, {0xba070000}, {0xba072000}, {0xba074000}, {0xba076000}, {0xba078000}, {0xba07a000}, {0xba07c000}, {0xba07e000}, {0xba080000}, {0xba082000}, {0xba084000}, {0xba086000}, {0xba088000}, {0xba08a000}, {0xba08c000}, {0xba08e000}, {0xba090000}, {0xba092000}, {0xba094000}, {0xba096000}, {0xba098000}, {0xba09a000}, {0xba09c000}, {0xba09e000}, {0xba0a0000}, {0xba0a2000}, {0xba0a4000}, {0xba0a6000}, {0xba0a8000}, {0xba0aa000}, {0xba0ac000}, {0xba0ae000}, {0xba0b0000}, {0xba0b2000}, {0xba0b4000}, {0xba0b6000}, {0xba0b8000}, {0xba0ba000}, {0xba0bc000}, {0xba0be000}, {0xba0c0000}, {0xba0c2000}, {0xba0c4000}, {0xba0c6000}, {0xba0c8000}, {0xba0ca000}, {0xba0cc000}, {0xba0ce000}, {0xba0d0000}, {0xba0d2000}, {0xba0d4000}, {0xba0d6000}, {0xba0d8000}, {0xba0da000}, {0xba0dc000}, {0xba0de000}, {0xba0e0000}, {0xba0e2000}, {0xba0e4000}, {0xba0e6000}, {0xba0e8000}, {0xba0ea000}, {0xba0ec000}, {0xba0ee000}, {0xba0f0000}, {0xba0f2000}, {0xba0f4000}, {0xba0f6000}, {0xba0f8000}, {0xba0fa000}, {0xba0fc000}, {0xba0fe000}, {0xba100000}, {0xba102000}, {0xba104000}, {0xba106000}, {0xba108000}, {0xba10a000}, {0xba10c000}, {0xba10e000}, {0xba110000}, {0xba112000}, {0xba114000}, {0xba116000}, {0xba118000}, {0xba11a000}, {0xba11c000}, {0xba11e000}, {0xba120000}, {0xba122000}, {0xba124000}, {0xba126000}, {0xba128000}, {0xba12a000}, {0xba12c000}, {0xba12e000}, {0xba130000}, {0xba132000}, {0xba134000}, {0xba136000}, {0xba138000}, {0xba13a000}, {0xba13c000}, {0xba13e000}, {0xba140000}, {0xba142000}, {0xba144000}, {0xba146000}, {0xba148000}, {0xba14a000}, {0xba14c000}, {0xba14e000}, {0xba150000}, {0xba152000}, {0xba154000}, {0xba156000}, {0xba158000}, {0xba15a000}, {0xba15c000}, {0xba15e000}, {0xba160000}, {0xba162000}, {0xba164000}, {0xba166000}, {0xba168000}, {0xba16a000}, {0xba16c000}, {0xba16e000}, {0xba170000}, {0xba172000}, {0xba174000}, {0xba176000}, {0xba178000}, {0xba17a000}, {0xba17c000}, {0xba17e000}, {0xba180000}, {0xba182000}, {0xba184000}, {0xba186000}, {0xba188000}, {0xba18a000}, {0xba18c000}, {0xba18e000}, {0xba190000}, {0xba192000}, {0xba194000}, {0xba196000}, {0xba198000}, {0xba19a000}, {0xba19c000}, {0xba19e000}, {0xba1a0000}, {0xba1a2000}, {0xba1a4000}, {0xba1a6000}, {0xba1a8000}, {0xba1aa000}, {0xba1ac000}, {0xba1ae000}, {0xba1b0000}, {0xba1b2000}, {0xba1b4000}, {0xba1b6000}, {0xba1b8000}, {0xba1ba000}, {0xba1bc000}, {0xba1be000}, {0xba1c0000}, {0xba1c2000}, {0xba1c4000}, {0xba1c6000}, {0xba1c8000}, {0xba1ca000}, {0xba1cc000}, {0xba1ce000}, {0xba1d0000}, {0xba1d2000}, {0xba1d4000}, {0xba1d6000}, {0xba1d8000}, {0xba1da000}, {0xba1dc000}, {0xba1de000}, {0xba1e0000}, {0xba1e2000}, {0xba1e4000}, {0xba1e6000}, {0xba1e8000}, {0xba1ea000}, {0xba1ec000}, {0xba1ee000}, {0xba1f0000}, {0xba1f2000}, {0xba1f4000}, {0xba1f6000}, {0xba1f8000}, {0xba1fa000}, {0xba1fc000}, {0xba1fe000}, {0xba200000}, {0xba202000}, {0xba204000}, {0xba206000}, {0xba208000}, {0xba20a000}, {0xba20c000}, {0xba20e000}, {0xba210000}, {0xba212000}, {0xba214000}, {0xba216000}, {0xba218000}, {0xba21a000}, {0xba21c000}, {0xba21e000}, {0xba220000}, {0xba222000}, {0xba224000}, {0xba226000}, {0xba228000}, {0xba22a000}, {0xba22c000}, {0xba22e000}, {0xba230000}, {0xba232000}, {0xba234000}, {0xba236000}, {0xba238000}, {0xba23a000}, {0xba23c000}, {0xba23e000}, {0xba240000}, {0xba242000}, {0xba244000}, {0xba246000}, {0xba248000}, {0xba24a000}, {0xba24c000}, {0xba24e000}, {0xba250000}, {0xba252000}, {0xba254000}, {0xba256000}, {0xba258000}, {0xba25a000}, {0xba25c000}, {0xba25e000}, {0xba260000}, {0xba262000}, {0xba264000}, {0xba266000}, {0xba268000}, {0xba26a000}, {0xba26c000}, {0xba26e000}, {0xba270000}, {0xba272000}, {0xba274000}, {0xba276000}, {0xba278000}, {0xba27a000}, {0xba27c000}, {0xba27e000}, {0xba280000}, {0xba282000}, {0xba284000}, {0xba286000}, {0xba288000}, {0xba28a000}, {0xba28c000}, {0xba28e000}, {0xba290000}, {0xba292000}, {0xba294000}, {0xba296000}, {0xba298000}, {0xba29a000}, {0xba29c000}, {0xba29e000}, {0xba2a0000}, {0xba2a2000}, {0xba2a4000}, {0xba2a6000}, {0xba2a8000}, {0xba2aa000}, {0xba2ac000}, {0xba2ae000}, {0xba2b0000}, {0xba2b2000}, {0xba2b4000}, {0xba2b6000}, {0xba2b8000}, {0xba2ba000}, {0xba2bc000}, {0xba2be000}, {0xba2c0000}, {0xba2c2000}, {0xba2c4000}, {0xba2c6000}, {0xba2c8000}, {0xba2ca000}, {0xba2cc000}, {0xba2ce000}, {0xba2d0000}, {0xba2d2000}, {0xba2d4000}, {0xba2d6000}, {0xba2d8000}, {0xba2da000}, {0xba2dc000}, {0xba2de000}, {0xba2e0000}, {0xba2e2000}, {0xba2e4000}, {0xba2e6000}, {0xba2e8000}, {0xba2ea000}, {0xba2ec000}, {0xba2ee000}, {0xba2f0000}, {0xba2f2000}, {0xba2f4000}, {0xba2f6000}, {0xba2f8000}, {0xba2fa000}, {0xba2fc000}, {0xba2fe000}, {0xba300000}, {0xba302000}, {0xba304000}, {0xba306000}, {0xba308000}, {0xba30a000}, {0xba30c000}, {0xba30e000}, {0xba310000}, {0xba312000}, {0xba314000}, {0xba316000}, {0xba318000}, {0xba31a000}, {0xba31c000}, {0xba31e000}, {0xba320000}, {0xba322000}, {0xba324000}, {0xba326000}, {0xba328000}, {0xba32a000}, {0xba32c000}, {0xba32e000}, {0xba330000}, {0xba332000}, {0xba334000}, {0xba336000}, {0xba338000}, {0xba33a000}, {0xba33c000}, {0xba33e000}, {0xba340000}, {0xba342000}, {0xba344000}, {0xba346000}, {0xba348000}, {0xba34a000}, {0xba34c000}, {0xba34e000}, {0xba350000}, {0xba352000}, {0xba354000}, {0xba356000}, {0xba358000}, {0xba35a000}, {0xba35c000}, {0xba35e000}, {0xba360000}, {0xba362000}, {0xba364000}, {0xba366000}, {0xba368000}, {0xba36a000}, {0xba36c000}, {0xba36e000}, {0xba370000}, {0xba372000}, {0xba374000}, {0xba376000}, {0xba378000}, {0xba37a000}, {0xba37c000}, {0xba37e000}, {0xba380000}, {0xba382000}, {0xba384000}, {0xba386000}, {0xba388000}, {0xba38a000}, {0xba38c000}, {0xba38e000}, {0xba390000}, {0xba392000}, {0xba394000}, {0xba396000}, {0xba398000}, {0xba39a000}, {0xba39c000}, {0xba39e000}, {0xba3a0000}, {0xba3a2000}, {0xba3a4000}, {0xba3a6000}, {0xba3a8000}, {0xba3aa000}, {0xba3ac000}, {0xba3ae000}, {0xba3b0000}, {0xba3b2000}, {0xba3b4000}, {0xba3b6000}, {0xba3b8000}, {0xba3ba000}, {0xba3bc000}, {0xba3be000}, {0xba3c0000}, {0xba3c2000}, {0xba3c4000}, {0xba3c6000}, {0xba3c8000}, {0xba3ca000}, {0xba3cc000}, {0xba3ce000}, {0xba3d0000}, {0xba3d2000}, {0xba3d4000}, {0xba3d6000}, {0xba3d8000}, {0xba3da000}, {0xba3dc000}, {0xba3de000}, {0xba3e0000}, {0xba3e2000}, {0xba3e4000}, {0xba3e6000}, {0xba3e8000}, {0xba3ea000}, {0xba3ec000}, {0xba3ee000}, {0xba3f0000}, {0xba3f2000}, {0xba3f4000}, {0xba3f6000}, {0xba3f8000}, {0xba3fa000}, {0xba3fc000}, {0xba3fe000}, {0xba400000}, {0xba402000}, {0xba404000}, {0xba406000}, {0xba408000}, {0xba40a000}, {0xba40c000}, {0xba40e000}, {0xba410000}, {0xba412000}, {0xba414000}, {0xba416000}, {0xba418000}, {0xba41a000}, {0xba41c000}, {0xba41e000}, {0xba420000}, {0xba422000}, {0xba424000}, {0xba426000}, {0xba428000}, {0xba42a000}, {0xba42c000}, {0xba42e000}, {0xba430000}, {0xba432000}, {0xba434000}, {0xba436000}, {0xba438000}, {0xba43a000}, {0xba43c000}, {0xba43e000}, {0xba440000}, {0xba442000}, {0xba444000}, {0xba446000}, {0xba448000}, {0xba44a000}, {0xba44c000}, {0xba44e000}, {0xba450000}, {0xba452000}, {0xba454000}, {0xba456000}, {0xba458000}, {0xba45a000}, {0xba45c000}, {0xba45e000}, {0xba460000}, {0xba462000}, {0xba464000}, {0xba466000}, {0xba468000}, {0xba46a000}, {0xba46c000}, {0xba46e000}, {0xba470000}, {0xba472000}, {0xba474000}, {0xba476000}, {0xba478000}, {0xba47a000}, {0xba47c000}, {0xba47e000}, {0xba480000}, {0xba482000}, {0xba484000}, {0xba486000}, {0xba488000}, {0xba48a000}, {0xba48c000}, {0xba48e000}, {0xba490000}, {0xba492000}, {0xba494000}, {0xba496000}, {0xba498000}, {0xba49a000}, {0xba49c000}, {0xba49e000}, {0xba4a0000}, {0xba4a2000}, {0xba4a4000}, {0xba4a6000}, {0xba4a8000}, {0xba4aa000}, {0xba4ac000}, {0xba4ae000}, {0xba4b0000}, {0xba4b2000}, {0xba4b4000}, {0xba4b6000}, {0xba4b8000}, {0xba4ba000}, {0xba4bc000}, {0xba4be000}, {0xba4c0000}, {0xba4c2000}, {0xba4c4000}, {0xba4c6000}, {0xba4c8000}, {0xba4ca000}, {0xba4cc000}, {0xba4ce000}, {0xba4d0000}, {0xba4d2000}, {0xba4d4000}, {0xba4d6000}, {0xba4d8000}, {0xba4da000}, {0xba4dc000}, {0xba4de000}, {0xba4e0000}, {0xba4e2000}, {0xba4e4000}, {0xba4e6000}, {0xba4e8000}, {0xba4ea000}, {0xba4ec000}, {0xba4ee000}, {0xba4f0000}, {0xba4f2000}, {0xba4f4000}, {0xba4f6000}, {0xba4f8000}, {0xba4fa000}, {0xba4fc000}, {0xba4fe000}, {0xba500000}, {0xba502000}, {0xba504000}, {0xba506000}, {0xba508000}, {0xba50a000}, {0xba50c000}, {0xba50e000}, {0xba510000}, {0xba512000}, {0xba514000}, {0xba516000}, {0xba518000}, {0xba51a000}, {0xba51c000}, {0xba51e000}, {0xba520000}, {0xba522000}, {0xba524000}, {0xba526000}, {0xba528000}, {0xba52a000}, {0xba52c000}, {0xba52e000}, {0xba530000}, {0xba532000}, {0xba534000}, {0xba536000}, {0xba538000}, {0xba53a000}, {0xba53c000}, {0xba53e000}, {0xba540000}, {0xba542000}, {0xba544000}, {0xba546000}, {0xba548000}, {0xba54a000}, {0xba54c000}, {0xba54e000}, {0xba550000}, {0xba552000}, {0xba554000}, {0xba556000}, {0xba558000}, {0xba55a000}, {0xba55c000}, {0xba55e000}, {0xba560000}, {0xba562000}, {0xba564000}, {0xba566000}, {0xba568000}, {0xba56a000}, {0xba56c000}, {0xba56e000}, {0xba570000}, {0xba572000}, {0xba574000}, {0xba576000}, {0xba578000}, {0xba57a000}, {0xba57c000}, {0xba57e000}, {0xba580000}, {0xba582000}, {0xba584000}, {0xba586000}, {0xba588000}, {0xba58a000}, {0xba58c000}, {0xba58e000}, {0xba590000}, {0xba592000}, {0xba594000}, {0xba596000}, {0xba598000}, {0xba59a000}, {0xba59c000}, {0xba59e000}, {0xba5a0000}, {0xba5a2000}, {0xba5a4000}, {0xba5a6000}, {0xba5a8000}, {0xba5aa000}, {0xba5ac000}, {0xba5ae000}, {0xba5b0000}, {0xba5b2000}, {0xba5b4000}, {0xba5b6000}, {0xba5b8000}, {0xba5ba000}, {0xba5bc000}, {0xba5be000}, {0xba5c0000}, {0xba5c2000}, {0xba5c4000}, {0xba5c6000}, {0xba5c8000}, {0xba5ca000}, {0xba5cc000}, {0xba5ce000}, {0xba5d0000}, {0xba5d2000}, {0xba5d4000}, {0xba5d6000}, {0xba5d8000}, {0xba5da000}, {0xba5dc000}, {0xba5de000}, {0xba5e0000}, {0xba5e2000}, {0xba5e4000}, {0xba5e6000}, {0xba5e8000}, {0xba5ea000}, {0xba5ec000}, {0xba5ee000}, {0xba5f0000}, {0xba5f2000}, {0xba5f4000}, {0xba5f6000}, {0xba5f8000}, {0xba5fa000}, {0xba5fc000}, {0xba5fe000}, {0xba600000}, {0xba602000}, {0xba604000}, {0xba606000}, {0xba608000}, {0xba60a000}, {0xba60c000}, {0xba60e000}, {0xba610000}, {0xba612000}, {0xba614000}, {0xba616000}, {0xba618000}, {0xba61a000}, {0xba61c000}, {0xba61e000}, {0xba620000}, {0xba622000}, {0xba624000}, {0xba626000}, {0xba628000}, {0xba62a000}, {0xba62c000}, {0xba62e000}, {0xba630000}, {0xba632000}, {0xba634000}, {0xba636000}, {0xba638000}, {0xba63a000}, {0xba63c000}, {0xba63e000}, {0xba640000}, {0xba642000}, {0xba644000}, {0xba646000}, {0xba648000}, {0xba64a000}, {0xba64c000}, {0xba64e000}, {0xba650000}, {0xba652000}, {0xba654000}, {0xba656000}, {0xba658000}, {0xba65a000}, {0xba65c000}, {0xba65e000}, {0xba660000}, {0xba662000}, {0xba664000}, {0xba666000}, {0xba668000}, {0xba66a000}, {0xba66c000}, {0xba66e000}, {0xba670000}, {0xba672000}, {0xba674000}, {0xba676000}, {0xba678000}, {0xba67a000}, {0xba67c000}, {0xba67e000}, {0xba680000}, {0xba682000}, {0xba684000}, {0xba686000}, {0xba688000}, {0xba68a000}, {0xba68c000}, {0xba68e000}, {0xba690000}, {0xba692000}, {0xba694000}, {0xba696000}, {0xba698000}, {0xba69a000}, {0xba69c000}, {0xba69e000}, {0xba6a0000}, {0xba6a2000}, {0xba6a4000}, {0xba6a6000}, {0xba6a8000}, {0xba6aa000}, {0xba6ac000}, {0xba6ae000}, {0xba6b0000}, {0xba6b2000}, {0xba6b4000}, {0xba6b6000}, {0xba6b8000}, {0xba6ba000}, {0xba6bc000}, {0xba6be000}, {0xba6c0000}, {0xba6c2000}, {0xba6c4000}, {0xba6c6000}, {0xba6c8000}, {0xba6ca000}, {0xba6cc000}, {0xba6ce000}, {0xba6d0000}, {0xba6d2000}, {0xba6d4000}, {0xba6d6000}, {0xba6d8000}, {0xba6da000}, {0xba6dc000}, {0xba6de000}, {0xba6e0000}, {0xba6e2000}, {0xba6e4000}, {0xba6e6000}, {0xba6e8000}, {0xba6ea000}, {0xba6ec000}, {0xba6ee000}, {0xba6f0000}, {0xba6f2000}, {0xba6f4000}, {0xba6f6000}, {0xba6f8000}, {0xba6fa000}, {0xba6fc000}, {0xba6fe000}, {0xba700000}, {0xba702000}, {0xba704000}, {0xba706000}, {0xba708000}, {0xba70a000}, {0xba70c000}, {0xba70e000}, {0xba710000}, {0xba712000}, {0xba714000}, {0xba716000}, {0xba718000}, {0xba71a000}, {0xba71c000}, {0xba71e000}, {0xba720000}, {0xba722000}, {0xba724000}, {0xba726000}, {0xba728000}, {0xba72a000}, {0xba72c000}, {0xba72e000}, {0xba730000}, {0xba732000}, {0xba734000}, {0xba736000}, {0xba738000}, {0xba73a000}, {0xba73c000}, {0xba73e000}, {0xba740000}, {0xba742000}, {0xba744000}, {0xba746000}, {0xba748000}, {0xba74a000}, {0xba74c000}, {0xba74e000}, {0xba750000}, {0xba752000}, {0xba754000}, {0xba756000}, {0xba758000}, {0xba75a000}, {0xba75c000}, {0xba75e000}, {0xba760000}, {0xba762000}, {0xba764000}, {0xba766000}, {0xba768000}, {0xba76a000}, {0xba76c000}, {0xba76e000}, {0xba770000}, {0xba772000}, {0xba774000}, {0xba776000}, {0xba778000}, {0xba77a000}, {0xba77c000}, {0xba77e000}, {0xba780000}, {0xba782000}, {0xba784000}, {0xba786000}, {0xba788000}, {0xba78a000}, {0xba78c000}, {0xba78e000}, {0xba790000}, {0xba792000}, {0xba794000}, {0xba796000}, {0xba798000}, {0xba79a000}, {0xba79c000}, {0xba79e000}, {0xba7a0000}, {0xba7a2000}, {0xba7a4000}, {0xba7a6000}, {0xba7a8000}, {0xba7aa000}, {0xba7ac000}, {0xba7ae000}, {0xba7b0000}, {0xba7b2000}, {0xba7b4000}, {0xba7b6000}, {0xba7b8000}, {0xba7ba000}, {0xba7bc000}, {0xba7be000}, {0xba7c0000}, {0xba7c2000}, {0xba7c4000}, {0xba7c6000}, {0xba7c8000}, {0xba7ca000}, {0xba7cc000}, {0xba7ce000}, {0xba7d0000}, {0xba7d2000}, {0xba7d4000}, {0xba7d6000}, {0xba7d8000}, {0xba7da000}, {0xba7dc000}, {0xba7de000}, {0xba7e0000}, {0xba7e2000}, {0xba7e4000}, {0xba7e6000}, {0xba7e8000}, {0xba7ea000}, {0xba7ec000}, {0xba7ee000}, {0xba7f0000}, {0xba7f2000}, {0xba7f4000}, {0xba7f6000}, {0xba7f8000}, {0xba7fa000}, {0xba7fc000}, {0xba7fe000}, {0xba800000}, {0xba802000}, {0xba804000}, {0xba806000}, {0xba808000}, {0xba80a000}, {0xba80c000}, {0xba80e000}, {0xba810000}, {0xba812000}, {0xba814000}, {0xba816000}, {0xba818000}, {0xba81a000}, {0xba81c000}, {0xba81e000}, {0xba820000}, {0xba822000}, {0xba824000}, {0xba826000}, {0xba828000}, {0xba82a000}, {0xba82c000}, {0xba82e000}, {0xba830000}, {0xba832000}, {0xba834000}, {0xba836000}, {0xba838000}, {0xba83a000}, {0xba83c000}, {0xba83e000}, {0xba840000}, {0xba842000}, {0xba844000}, {0xba846000}, {0xba848000}, {0xba84a000}, {0xba84c000}, {0xba84e000}, {0xba850000}, {0xba852000}, {0xba854000}, {0xba856000}, {0xba858000}, {0xba85a000}, {0xba85c000}, {0xba85e000}, {0xba860000}, {0xba862000}, {0xba864000}, {0xba866000}, {0xba868000}, {0xba86a000}, {0xba86c000}, {0xba86e000}, {0xba870000}, {0xba872000}, {0xba874000}, {0xba876000}, {0xba878000}, {0xba87a000}, {0xba87c000}, {0xba87e000}, {0xba880000}, {0xba882000}, {0xba884000}, {0xba886000}, {0xba888000}, {0xba88a000}, {0xba88c000}, {0xba88e000}, {0xba890000}, {0xba892000}, {0xba894000}, {0xba896000}, {0xba898000}, {0xba89a000}, {0xba89c000}, {0xba89e000}, {0xba8a0000}, {0xba8a2000}, {0xba8a4000}, {0xba8a6000}, {0xba8a8000}, {0xba8aa000}, {0xba8ac000}, {0xba8ae000}, {0xba8b0000}, {0xba8b2000}, {0xba8b4000}, {0xba8b6000}, {0xba8b8000}, {0xba8ba000}, {0xba8bc000}, {0xba8be000}, {0xba8c0000}, {0xba8c2000}, {0xba8c4000}, {0xba8c6000}, {0xba8c8000}, {0xba8ca000}, {0xba8cc000}, {0xba8ce000}, {0xba8d0000}, {0xba8d2000}, {0xba8d4000}, {0xba8d6000}, {0xba8d8000}, {0xba8da000}, {0xba8dc000}, {0xba8de000}, {0xba8e0000}, {0xba8e2000}, {0xba8e4000}, {0xba8e6000}, {0xba8e8000}, {0xba8ea000}, {0xba8ec000}, {0xba8ee000}, {0xba8f0000}, {0xba8f2000}, {0xba8f4000}, {0xba8f6000}, {0xba8f8000}, {0xba8fa000}, {0xba8fc000}, {0xba8fe000}, {0xba900000}, {0xba902000}, {0xba904000}, {0xba906000}, {0xba908000}, {0xba90a000}, {0xba90c000}, {0xba90e000}, {0xba910000}, {0xba912000}, {0xba914000}, {0xba916000}, {0xba918000}, {0xba91a000}, {0xba91c000}, {0xba91e000}, {0xba920000}, {0xba922000}, {0xba924000}, {0xba926000}, {0xba928000}, {0xba92a000}, {0xba92c000}, {0xba92e000}, {0xba930000}, {0xba932000}, {0xba934000}, {0xba936000}, {0xba938000}, {0xba93a000}, {0xba93c000}, {0xba93e000}, {0xba940000}, {0xba942000}, {0xba944000}, {0xba946000}, {0xba948000}, {0xba94a000}, {0xba94c000}, {0xba94e000}, {0xba950000}, {0xba952000}, {0xba954000}, {0xba956000}, {0xba958000}, {0xba95a000}, {0xba95c000}, {0xba95e000}, {0xba960000}, {0xba962000}, {0xba964000}, {0xba966000}, {0xba968000}, {0xba96a000}, {0xba96c000}, {0xba96e000}, {0xba970000}, {0xba972000}, {0xba974000}, {0xba976000}, {0xba978000}, {0xba97a000}, {0xba97c000}, {0xba97e000}, {0xba980000}, {0xba982000}, {0xba984000}, {0xba986000}, {0xba988000}, {0xba98a000}, {0xba98c000}, {0xba98e000}, {0xba990000}, {0xba992000}, {0xba994000}, {0xba996000}, {0xba998000}, {0xba99a000}, {0xba99c000}, {0xba99e000}, {0xba9a0000}, {0xba9a2000}, {0xba9a4000}, {0xba9a6000}, {0xba9a8000}, {0xba9aa000}, {0xba9ac000}, {0xba9ae000}, {0xba9b0000}, {0xba9b2000}, {0xba9b4000}, {0xba9b6000}, {0xba9b8000}, {0xba9ba000}, {0xba9bc000}, {0xba9be000}, {0xba9c0000}, {0xba9c2000}, {0xba9c4000}, {0xba9c6000}, {0xba9c8000}, {0xba9ca000}, {0xba9cc000}, {0xba9ce000}, {0xba9d0000}, {0xba9d2000}, {0xba9d4000}, {0xba9d6000}, {0xba9d8000}, {0xba9da000}, {0xba9dc000}, {0xba9de000}, {0xba9e0000}, {0xba9e2000}, {0xba9e4000}, {0xba9e6000}, {0xba9e8000}, {0xba9ea000}, {0xba9ec000}, {0xba9ee000}, {0xba9f0000}, {0xba9f2000}, {0xba9f4000}, {0xba9f6000}, {0xba9f8000}, {0xba9fa000}, {0xba9fc000}, {0xba9fe000}, {0xbaa00000}, {0xbaa02000}, {0xbaa04000}, {0xbaa06000}, {0xbaa08000}, {0xbaa0a000}, {0xbaa0c000}, {0xbaa0e000}, {0xbaa10000}, {0xbaa12000}, {0xbaa14000}, {0xbaa16000}, {0xbaa18000}, {0xbaa1a000}, {0xbaa1c000}, {0xbaa1e000}, {0xbaa20000}, {0xbaa22000}, {0xbaa24000}, {0xbaa26000}, {0xbaa28000}, {0xbaa2a000}, {0xbaa2c000}, {0xbaa2e000}, {0xbaa30000}, {0xbaa32000}, {0xbaa34000}, {0xbaa36000}, {0xbaa38000}, {0xbaa3a000}, {0xbaa3c000}, {0xbaa3e000}, {0xbaa40000}, {0xbaa42000}, {0xbaa44000}, {0xbaa46000}, {0xbaa48000}, {0xbaa4a000}, {0xbaa4c000}, {0xbaa4e000}, {0xbaa50000}, {0xbaa52000}, {0xbaa54000}, {0xbaa56000}, {0xbaa58000}, {0xbaa5a000}, {0xbaa5c000}, {0xbaa5e000}, {0xbaa60000}, {0xbaa62000}, {0xbaa64000}, {0xbaa66000}, {0xbaa68000}, {0xbaa6a000}, {0xbaa6c000}, {0xbaa6e000}, {0xbaa70000}, {0xbaa72000}, {0xbaa74000}, {0xbaa76000}, {0xbaa78000}, {0xbaa7a000}, {0xbaa7c000}, {0xbaa7e000}, {0xbaa80000}, {0xbaa82000}, {0xbaa84000}, {0xbaa86000}, {0xbaa88000}, {0xbaa8a000}, {0xbaa8c000}, {0xbaa8e000}, {0xbaa90000}, {0xbaa92000}, {0xbaa94000}, {0xbaa96000}, {0xbaa98000}, {0xbaa9a000}, {0xbaa9c000}, {0xbaa9e000}, {0xbaaa0000}, {0xbaaa2000}, {0xbaaa4000}, {0xbaaa6000}, {0xbaaa8000}, {0xbaaaa000}, {0xbaaac000}, {0xbaaae000}, {0xbaab0000}, {0xbaab2000}, {0xbaab4000}, {0xbaab6000}, {0xbaab8000}, {0xbaaba000}, {0xbaabc000}, {0xbaabe000}, {0xbaac0000}, {0xbaac2000}, {0xbaac4000}, {0xbaac6000}, {0xbaac8000}, {0xbaaca000}, {0xbaacc000}, {0xbaace000}, {0xbaad0000}, {0xbaad2000}, {0xbaad4000}, {0xbaad6000}, {0xbaad8000}, {0xbaada000}, {0xbaadc000}, {0xbaade000}, {0xbaae0000}, {0xbaae2000}, {0xbaae4000}, {0xbaae6000}, {0xbaae8000}, {0xbaaea000}, {0xbaaec000}, {0xbaaee000}, {0xbaaf0000}, {0xbaaf2000}, {0xbaaf4000}, {0xbaaf6000}, {0xbaaf8000}, {0xbaafa000}, {0xbaafc000}, {0xbaafe000}, {0xbab00000}, {0xbab02000}, {0xbab04000}, {0xbab06000}, {0xbab08000}, {0xbab0a000}, {0xbab0c000}, {0xbab0e000}, {0xbab10000}, {0xbab12000}, {0xbab14000}, {0xbab16000}, {0xbab18000}, {0xbab1a000}, {0xbab1c000}, {0xbab1e000}, {0xbab20000}, {0xbab22000}, {0xbab24000}, {0xbab26000}, {0xbab28000}, {0xbab2a000}, {0xbab2c000}, {0xbab2e000}, {0xbab30000}, {0xbab32000}, {0xbab34000}, {0xbab36000}, {0xbab38000}, {0xbab3a000}, {0xbab3c000}, {0xbab3e000}, {0xbab40000}, {0xbab42000}, {0xbab44000}, {0xbab46000}, {0xbab48000}, {0xbab4a000}, {0xbab4c000}, {0xbab4e000}, {0xbab50000}, {0xbab52000}, {0xbab54000}, {0xbab56000}, {0xbab58000}, {0xbab5a000}, {0xbab5c000}, {0xbab5e000}, {0xbab60000}, {0xbab62000}, {0xbab64000}, {0xbab66000}, {0xbab68000}, {0xbab6a000}, {0xbab6c000}, {0xbab6e000}, {0xbab70000}, {0xbab72000}, {0xbab74000}, {0xbab76000}, {0xbab78000}, {0xbab7a000}, {0xbab7c000}, {0xbab7e000}, {0xbab80000}, {0xbab82000}, {0xbab84000}, {0xbab86000}, {0xbab88000}, {0xbab8a000}, {0xbab8c000}, {0xbab8e000}, {0xbab90000}, {0xbab92000}, {0xbab94000}, {0xbab96000}, {0xbab98000}, {0xbab9a000}, {0xbab9c000}, {0xbab9e000}, {0xbaba0000}, {0xbaba2000}, {0xbaba4000}, {0xbaba6000}, {0xbaba8000}, {0xbabaa000}, {0xbabac000}, {0xbabae000}, {0xbabb0000}, {0xbabb2000}, {0xbabb4000}, {0xbabb6000}, {0xbabb8000}, {0xbabba000}, {0xbabbc000}, {0xbabbe000}, {0xbabc0000}, {0xbabc2000}, {0xbabc4000}, {0xbabc6000}, {0xbabc8000}, {0xbabca000}, {0xbabcc000}, {0xbabce000}, {0xbabd0000}, {0xbabd2000}, {0xbabd4000}, {0xbabd6000}, {0xbabd8000}, {0xbabda000}, {0xbabdc000}, {0xbabde000}, {0xbabe0000}, {0xbabe2000}, {0xbabe4000}, {0xbabe6000}, {0xbabe8000}, {0xbabea000}, {0xbabec000}, {0xbabee000}, {0xbabf0000}, {0xbabf2000}, {0xbabf4000}, {0xbabf6000}, {0xbabf8000}, {0xbabfa000}, {0xbabfc000}, {0xbabfe000}, {0xbac00000}, {0xbac02000}, {0xbac04000}, {0xbac06000}, {0xbac08000}, {0xbac0a000}, {0xbac0c000}, {0xbac0e000}, {0xbac10000}, {0xbac12000}, {0xbac14000}, {0xbac16000}, {0xbac18000}, {0xbac1a000}, {0xbac1c000}, {0xbac1e000}, {0xbac20000}, {0xbac22000}, {0xbac24000}, {0xbac26000}, {0xbac28000}, {0xbac2a000}, {0xbac2c000}, {0xbac2e000}, {0xbac30000}, {0xbac32000}, {0xbac34000}, {0xbac36000}, {0xbac38000}, {0xbac3a000}, {0xbac3c000}, {0xbac3e000}, {0xbac40000}, {0xbac42000}, {0xbac44000}, {0xbac46000}, {0xbac48000}, {0xbac4a000}, {0xbac4c000}, {0xbac4e000}, {0xbac50000}, {0xbac52000}, {0xbac54000}, {0xbac56000}, {0xbac58000}, {0xbac5a000}, {0xbac5c000}, {0xbac5e000}, {0xbac60000}, {0xbac62000}, {0xbac64000}, {0xbac66000}, {0xbac68000}, {0xbac6a000}, {0xbac6c000}, {0xbac6e000}, {0xbac70000}, {0xbac72000}, {0xbac74000}, {0xbac76000}, {0xbac78000}, {0xbac7a000}, {0xbac7c000}, {0xbac7e000}, {0xbac80000}, {0xbac82000}, {0xbac84000}, {0xbac86000}, {0xbac88000}, {0xbac8a000}, {0xbac8c000}, {0xbac8e000}, {0xbac90000}, {0xbac92000}, {0xbac94000}, {0xbac96000}, {0xbac98000}, {0xbac9a000}, {0xbac9c000}, {0xbac9e000}, {0xbaca0000}, {0xbaca2000}, {0xbaca4000}, {0xbaca6000}, {0xbaca8000}, {0xbacaa000}, {0xbacac000}, {0xbacae000}, {0xbacb0000}, {0xbacb2000}, {0xbacb4000}, {0xbacb6000}, {0xbacb8000}, {0xbacba000}, {0xbacbc000}, {0xbacbe000}, {0xbacc0000}, {0xbacc2000}, {0xbacc4000}, {0xbacc6000}, {0xbacc8000}, {0xbacca000}, {0xbaccc000}, {0xbacce000}, {0xbacd0000}, {0xbacd2000}, {0xbacd4000}, {0xbacd6000}, {0xbacd8000}, {0xbacda000}, {0xbacdc000}, {0xbacde000}, {0xbace0000}, {0xbace2000}, {0xbace4000}, {0xbace6000}, {0xbace8000}, {0xbacea000}, {0xbacec000}, {0xbacee000}, {0xbacf0000}, {0xbacf2000}, {0xbacf4000}, {0xbacf6000}, {0xbacf8000}, {0xbacfa000}, {0xbacfc000}, {0xbacfe000}, {0xbad00000}, {0xbad02000}, {0xbad04000}, {0xbad06000}, {0xbad08000}, {0xbad0a000}, {0xbad0c000}, {0xbad0e000}, {0xbad10000}, {0xbad12000}, {0xbad14000}, {0xbad16000}, {0xbad18000}, {0xbad1a000}, {0xbad1c000}, {0xbad1e000}, {0xbad20000}, {0xbad22000}, {0xbad24000}, {0xbad26000}, {0xbad28000}, {0xbad2a000}, {0xbad2c000}, {0xbad2e000}, {0xbad30000}, {0xbad32000}, {0xbad34000}, {0xbad36000}, {0xbad38000}, {0xbad3a000}, {0xbad3c000}, {0xbad3e000}, {0xbad40000}, {0xbad42000}, {0xbad44000}, {0xbad46000}, {0xbad48000}, {0xbad4a000}, {0xbad4c000}, {0xbad4e000}, {0xbad50000}, {0xbad52000}, {0xbad54000}, {0xbad56000}, {0xbad58000}, {0xbad5a000}, {0xbad5c000}, {0xbad5e000}, {0xbad60000}, {0xbad62000}, {0xbad64000}, {0xbad66000}, {0xbad68000}, {0xbad6a000}, {0xbad6c000}, {0xbad6e000}, {0xbad70000}, {0xbad72000}, {0xbad74000}, {0xbad76000}, {0xbad78000}, {0xbad7a000}, {0xbad7c000}, {0xbad7e000}, {0xbad80000}, {0xbad82000}, {0xbad84000}, {0xbad86000}, {0xbad88000}, {0xbad8a000}, {0xbad8c000}, {0xbad8e000}, {0xbad90000}, {0xbad92000}, {0xbad94000}, {0xbad96000}, {0xbad98000}, {0xbad9a000}, {0xbad9c000}, {0xbad9e000}, {0xbada0000}, {0xbada2000}, {0xbada4000}, {0xbada6000}, {0xbada8000}, {0xbadaa000}, {0xbadac000}, {0xbadae000}, {0xbadb0000}, {0xbadb2000}, {0xbadb4000}, {0xbadb6000}, {0xbadb8000}, {0xbadba000}, {0xbadbc000}, {0xbadbe000}, {0xbadc0000}, {0xbadc2000}, {0xbadc4000}, {0xbadc6000}, {0xbadc8000}, {0xbadca000}, {0xbadcc000}, {0xbadce000}, {0xbadd0000}, {0xbadd2000}, {0xbadd4000}, {0xbadd6000}, {0xbadd8000}, {0xbadda000}, {0xbaddc000}, {0xbadde000}, {0xbade0000}, {0xbade2000}, {0xbade4000}, {0xbade6000}, {0xbade8000}, {0xbadea000}, {0xbadec000}, {0xbadee000}, {0xbadf0000}, {0xbadf2000}, {0xbadf4000}, {0xbadf6000}, {0xbadf8000}, {0xbadfa000}, {0xbadfc000}, {0xbadfe000}, {0xbae00000}, {0xbae02000}, {0xbae04000}, {0xbae06000}, {0xbae08000}, {0xbae0a000}, {0xbae0c000}, {0xbae0e000}, {0xbae10000}, {0xbae12000}, {0xbae14000}, {0xbae16000}, {0xbae18000}, {0xbae1a000}, {0xbae1c000}, {0xbae1e000}, {0xbae20000}, {0xbae22000}, {0xbae24000}, {0xbae26000}, {0xbae28000}, {0xbae2a000}, {0xbae2c000}, {0xbae2e000}, {0xbae30000}, {0xbae32000}, {0xbae34000}, {0xbae36000}, {0xbae38000}, {0xbae3a000}, {0xbae3c000}, {0xbae3e000}, {0xbae40000}, {0xbae42000}, {0xbae44000}, {0xbae46000}, {0xbae48000}, {0xbae4a000}, {0xbae4c000}, {0xbae4e000}, {0xbae50000}, {0xbae52000}, {0xbae54000}, {0xbae56000}, {0xbae58000}, {0xbae5a000}, {0xbae5c000}, {0xbae5e000}, {0xbae60000}, {0xbae62000}, {0xbae64000}, {0xbae66000}, {0xbae68000}, {0xbae6a000}, {0xbae6c000}, {0xbae6e000}, {0xbae70000}, {0xbae72000}, {0xbae74000}, {0xbae76000}, {0xbae78000}, {0xbae7a000}, {0xbae7c000}, {0xbae7e000}, {0xbae80000}, {0xbae82000}, {0xbae84000}, {0xbae86000}, {0xbae88000}, {0xbae8a000}, {0xbae8c000}, {0xbae8e000}, {0xbae90000}, {0xbae92000}, {0xbae94000}, {0xbae96000}, {0xbae98000}, {0xbae9a000}, {0xbae9c000}, {0xbae9e000}, {0xbaea0000}, {0xbaea2000}, {0xbaea4000}, {0xbaea6000}, {0xbaea8000}, {0xbaeaa000}, {0xbaeac000}, {0xbaeae000}, {0xbaeb0000}, {0xbaeb2000}, {0xbaeb4000}, {0xbaeb6000}, {0xbaeb8000}, {0xbaeba000}, {0xbaebc000}, {0xbaebe000}, {0xbaec0000}, {0xbaec2000}, {0xbaec4000}, {0xbaec6000}, {0xbaec8000}, {0xbaeca000}, {0xbaecc000}, {0xbaece000}, {0xbaed0000}, {0xbaed2000}, {0xbaed4000}, {0xbaed6000}, {0xbaed8000}, {0xbaeda000}, {0xbaedc000}, {0xbaede000}, {0xbaee0000}, {0xbaee2000}, {0xbaee4000}, {0xbaee6000}, {0xbaee8000}, {0xbaeea000}, {0xbaeec000}, {0xbaeee000}, {0xbaef0000}, {0xbaef2000}, {0xbaef4000}, {0xbaef6000}, {0xbaef8000}, {0xbaefa000}, {0xbaefc000}, {0xbaefe000}, {0xbaf00000}, {0xbaf02000}, {0xbaf04000}, {0xbaf06000}, {0xbaf08000}, {0xbaf0a000}, {0xbaf0c000}, {0xbaf0e000}, {0xbaf10000}, {0xbaf12000}, {0xbaf14000}, {0xbaf16000}, {0xbaf18000}, {0xbaf1a000}, {0xbaf1c000}, {0xbaf1e000}, {0xbaf20000}, {0xbaf22000}, {0xbaf24000}, {0xbaf26000}, {0xbaf28000}, {0xbaf2a000}, {0xbaf2c000}, {0xbaf2e000}, {0xbaf30000}, {0xbaf32000}, {0xbaf34000}, {0xbaf36000}, {0xbaf38000}, {0xbaf3a000}, {0xbaf3c000}, {0xbaf3e000}, {0xbaf40000}, {0xbaf42000}, {0xbaf44000}, {0xbaf46000}, {0xbaf48000}, {0xbaf4a000}, {0xbaf4c000}, {0xbaf4e000}, {0xbaf50000}, {0xbaf52000}, {0xbaf54000}, {0xbaf56000}, {0xbaf58000}, {0xbaf5a000}, {0xbaf5c000}, {0xbaf5e000}, {0xbaf60000}, {0xbaf62000}, {0xbaf64000}, {0xbaf66000}, {0xbaf68000}, {0xbaf6a000}, {0xbaf6c000}, {0xbaf6e000}, {0xbaf70000}, {0xbaf72000}, {0xbaf74000}, {0xbaf76000}, {0xbaf78000}, {0xbaf7a000}, {0xbaf7c000}, {0xbaf7e000}, {0xbaf80000}, {0xbaf82000}, {0xbaf84000}, {0xbaf86000}, {0xbaf88000}, {0xbaf8a000}, {0xbaf8c000}, {0xbaf8e000}, {0xbaf90000}, {0xbaf92000}, {0xbaf94000}, {0xbaf96000}, {0xbaf98000}, {0xbaf9a000}, {0xbaf9c000}, {0xbaf9e000}, {0xbafa0000}, {0xbafa2000}, {0xbafa4000}, {0xbafa6000}, {0xbafa8000}, {0xbafaa000}, {0xbafac000}, {0xbafae000}, {0xbafb0000}, {0xbafb2000}, {0xbafb4000}, {0xbafb6000}, {0xbafb8000}, {0xbafba000}, {0xbafbc000}, {0xbafbe000}, {0xbafc0000}, {0xbafc2000}, {0xbafc4000}, {0xbafc6000}, {0xbafc8000}, {0xbafca000}, {0xbafcc000}, {0xbafce000}, {0xbafd0000}, {0xbafd2000}, {0xbafd4000}, {0xbafd6000}, {0xbafd8000}, {0xbafda000}, {0xbafdc000}, {0xbafde000}, {0xbafe0000}, {0xbafe2000}, {0xbafe4000}, {0xbafe6000}, {0xbafe8000}, {0xbafea000}, {0xbafec000}, {0xbafee000}, {0xbaff0000}, {0xbaff2000}, {0xbaff4000}, {0xbaff6000}, {0xbaff8000}, {0xbaffa000}, {0xbaffc000}, {0xbaffe000}, {0xbb000000}, {0xbb002000}, {0xbb004000}, {0xbb006000}, {0xbb008000}, {0xbb00a000}, {0xbb00c000}, {0xbb00e000}, {0xbb010000}, {0xbb012000}, {0xbb014000}, {0xbb016000}, {0xbb018000}, {0xbb01a000}, {0xbb01c000}, {0xbb01e000}, {0xbb020000}, {0xbb022000}, {0xbb024000}, {0xbb026000}, {0xbb028000}, {0xbb02a000}, {0xbb02c000}, {0xbb02e000}, {0xbb030000}, {0xbb032000}, {0xbb034000}, {0xbb036000}, {0xbb038000}, {0xbb03a000}, {0xbb03c000}, {0xbb03e000}, {0xbb040000}, {0xbb042000}, {0xbb044000}, {0xbb046000}, {0xbb048000}, {0xbb04a000}, {0xbb04c000}, {0xbb04e000}, {0xbb050000}, {0xbb052000}, {0xbb054000}, {0xbb056000}, {0xbb058000}, {0xbb05a000}, {0xbb05c000}, {0xbb05e000}, {0xbb060000}, {0xbb062000}, {0xbb064000}, {0xbb066000}, {0xbb068000}, {0xbb06a000}, {0xbb06c000}, {0xbb06e000}, {0xbb070000}, {0xbb072000}, {0xbb074000}, {0xbb076000}, {0xbb078000}, {0xbb07a000}, {0xbb07c000}, {0xbb07e000}, {0xbb080000}, {0xbb082000}, {0xbb084000}, {0xbb086000}, {0xbb088000}, {0xbb08a000}, {0xbb08c000}, {0xbb08e000}, {0xbb090000}, {0xbb092000}, {0xbb094000}, {0xbb096000}, {0xbb098000}, {0xbb09a000}, {0xbb09c000}, {0xbb09e000}, {0xbb0a0000}, {0xbb0a2000}, {0xbb0a4000}, {0xbb0a6000}, {0xbb0a8000}, {0xbb0aa000}, {0xbb0ac000}, {0xbb0ae000}, {0xbb0b0000}, {0xbb0b2000}, {0xbb0b4000}, {0xbb0b6000}, {0xbb0b8000}, {0xbb0ba000}, {0xbb0bc000}, {0xbb0be000}, {0xbb0c0000}, {0xbb0c2000}, {0xbb0c4000}, {0xbb0c6000}, {0xbb0c8000}, {0xbb0ca000}, {0xbb0cc000}, {0xbb0ce000}, {0xbb0d0000}, {0xbb0d2000}, {0xbb0d4000}, {0xbb0d6000}, {0xbb0d8000}, {0xbb0da000}, {0xbb0dc000}, {0xbb0de000}, {0xbb0e0000}, {0xbb0e2000}, {0xbb0e4000}, {0xbb0e6000}, {0xbb0e8000}, {0xbb0ea000}, {0xbb0ec000}, {0xbb0ee000}, {0xbb0f0000}, {0xbb0f2000}, {0xbb0f4000}, {0xbb0f6000}, {0xbb0f8000}, {0xbb0fa000}, {0xbb0fc000}, {0xbb0fe000}, {0xbb100000}, {0xbb102000}, {0xbb104000}, {0xbb106000}, {0xbb108000}, {0xbb10a000}, {0xbb10c000}, {0xbb10e000}, {0xbb110000}, {0xbb112000}, {0xbb114000}, {0xbb116000}, {0xbb118000}, {0xbb11a000}, {0xbb11c000}, {0xbb11e000}, {0xbb120000}, {0xbb122000}, {0xbb124000}, {0xbb126000}, {0xbb128000}, {0xbb12a000}, {0xbb12c000}, {0xbb12e000}, {0xbb130000}, {0xbb132000}, {0xbb134000}, {0xbb136000}, {0xbb138000}, {0xbb13a000}, {0xbb13c000}, {0xbb13e000}, {0xbb140000}, {0xbb142000}, {0xbb144000}, {0xbb146000}, {0xbb148000}, {0xbb14a000}, {0xbb14c000}, {0xbb14e000}, {0xbb150000}, {0xbb152000}, {0xbb154000}, {0xbb156000}, {0xbb158000}, {0xbb15a000}, {0xbb15c000}, {0xbb15e000}, {0xbb160000}, {0xbb162000}, {0xbb164000}, {0xbb166000}, {0xbb168000}, {0xbb16a000}, {0xbb16c000}, {0xbb16e000}, {0xbb170000}, {0xbb172000}, {0xbb174000}, {0xbb176000}, {0xbb178000}, {0xbb17a000}, {0xbb17c000}, {0xbb17e000}, {0xbb180000}, {0xbb182000}, {0xbb184000}, {0xbb186000}, {0xbb188000}, {0xbb18a000}, {0xbb18c000}, {0xbb18e000}, {0xbb190000}, {0xbb192000}, {0xbb194000}, {0xbb196000}, {0xbb198000}, {0xbb19a000}, {0xbb19c000}, {0xbb19e000}, {0xbb1a0000}, {0xbb1a2000}, {0xbb1a4000}, {0xbb1a6000}, {0xbb1a8000}, {0xbb1aa000}, {0xbb1ac000}, {0xbb1ae000}, {0xbb1b0000}, {0xbb1b2000}, {0xbb1b4000}, {0xbb1b6000}, {0xbb1b8000}, {0xbb1ba000}, {0xbb1bc000}, {0xbb1be000}, {0xbb1c0000}, {0xbb1c2000}, {0xbb1c4000}, {0xbb1c6000}, {0xbb1c8000}, {0xbb1ca000}, {0xbb1cc000}, {0xbb1ce000}, {0xbb1d0000}, {0xbb1d2000}, {0xbb1d4000}, {0xbb1d6000}, {0xbb1d8000}, {0xbb1da000}, {0xbb1dc000}, {0xbb1de000}, {0xbb1e0000}, {0xbb1e2000}, {0xbb1e4000}, {0xbb1e6000}, {0xbb1e8000}, {0xbb1ea000}, {0xbb1ec000}, {0xbb1ee000}, {0xbb1f0000}, {0xbb1f2000}, {0xbb1f4000}, {0xbb1f6000}, {0xbb1f8000}, {0xbb1fa000}, {0xbb1fc000}, {0xbb1fe000}, {0xbb200000}, {0xbb202000}, {0xbb204000}, {0xbb206000}, {0xbb208000}, {0xbb20a000}, {0xbb20c000}, {0xbb20e000}, {0xbb210000}, {0xbb212000}, {0xbb214000}, {0xbb216000}, {0xbb218000}, {0xbb21a000}, {0xbb21c000}, {0xbb21e000}, {0xbb220000}, {0xbb222000}, {0xbb224000}, {0xbb226000}, {0xbb228000}, {0xbb22a000}, {0xbb22c000}, {0xbb22e000}, {0xbb230000}, {0xbb232000}, {0xbb234000}, {0xbb236000}, {0xbb238000}, {0xbb23a000}, {0xbb23c000}, {0xbb23e000}, {0xbb240000}, {0xbb242000}, {0xbb244000}, {0xbb246000}, {0xbb248000}, {0xbb24a000}, {0xbb24c000}, {0xbb24e000}, {0xbb250000}, {0xbb252000}, {0xbb254000}, {0xbb256000}, {0xbb258000}, {0xbb25a000}, {0xbb25c000}, {0xbb25e000}, {0xbb260000}, {0xbb262000}, {0xbb264000}, {0xbb266000}, {0xbb268000}, {0xbb26a000}, {0xbb26c000}, {0xbb26e000}, {0xbb270000}, {0xbb272000}, {0xbb274000}, {0xbb276000}, {0xbb278000}, {0xbb27a000}, {0xbb27c000}, {0xbb27e000}, {0xbb280000}, {0xbb282000}, {0xbb284000}, {0xbb286000}, {0xbb288000}, {0xbb28a000}, {0xbb28c000}, {0xbb28e000}, {0xbb290000}, {0xbb292000}, {0xbb294000}, {0xbb296000}, {0xbb298000}, {0xbb29a000}, {0xbb29c000}, {0xbb29e000}, {0xbb2a0000}, {0xbb2a2000}, {0xbb2a4000}, {0xbb2a6000}, {0xbb2a8000}, {0xbb2aa000}, {0xbb2ac000}, {0xbb2ae000}, {0xbb2b0000}, {0xbb2b2000}, {0xbb2b4000}, {0xbb2b6000}, {0xbb2b8000}, {0xbb2ba000}, {0xbb2bc000}, {0xbb2be000}, {0xbb2c0000}, {0xbb2c2000}, {0xbb2c4000}, {0xbb2c6000}, {0xbb2c8000}, {0xbb2ca000}, {0xbb2cc000}, {0xbb2ce000}, {0xbb2d0000}, {0xbb2d2000}, {0xbb2d4000}, {0xbb2d6000}, {0xbb2d8000}, {0xbb2da000}, {0xbb2dc000}, {0xbb2de000}, {0xbb2e0000}, {0xbb2e2000}, {0xbb2e4000}, {0xbb2e6000}, {0xbb2e8000}, {0xbb2ea000}, {0xbb2ec000}, {0xbb2ee000}, {0xbb2f0000}, {0xbb2f2000}, {0xbb2f4000}, {0xbb2f6000}, {0xbb2f8000}, {0xbb2fa000}, {0xbb2fc000}, {0xbb2fe000}, {0xbb300000}, {0xbb302000}, {0xbb304000}, {0xbb306000}, {0xbb308000}, {0xbb30a000}, {0xbb30c000}, {0xbb30e000}, {0xbb310000}, {0xbb312000}, {0xbb314000}, {0xbb316000}, {0xbb318000}, {0xbb31a000}, {0xbb31c000}, {0xbb31e000}, {0xbb320000}, {0xbb322000}, {0xbb324000}, {0xbb326000}, {0xbb328000}, {0xbb32a000}, {0xbb32c000}, {0xbb32e000}, {0xbb330000}, {0xbb332000}, {0xbb334000}, {0xbb336000}, {0xbb338000}, {0xbb33a000}, {0xbb33c000}, {0xbb33e000}, {0xbb340000}, {0xbb342000}, {0xbb344000}, {0xbb346000}, {0xbb348000}, {0xbb34a000}, {0xbb34c000}, {0xbb34e000}, {0xbb350000}, {0xbb352000}, {0xbb354000}, {0xbb356000}, {0xbb358000}, {0xbb35a000}, {0xbb35c000}, {0xbb35e000}, {0xbb360000}, {0xbb362000}, {0xbb364000}, {0xbb366000}, {0xbb368000}, {0xbb36a000}, {0xbb36c000}, {0xbb36e000}, {0xbb370000}, {0xbb372000}, {0xbb374000}, {0xbb376000}, {0xbb378000}, {0xbb37a000}, {0xbb37c000}, {0xbb37e000}, {0xbb380000}, {0xbb382000}, {0xbb384000}, {0xbb386000}, {0xbb388000}, {0xbb38a000}, {0xbb38c000}, {0xbb38e000}, {0xbb390000}, {0xbb392000}, {0xbb394000}, {0xbb396000}, {0xbb398000}, {0xbb39a000}, {0xbb39c000}, {0xbb39e000}, {0xbb3a0000}, {0xbb3a2000}, {0xbb3a4000}, {0xbb3a6000}, {0xbb3a8000}, {0xbb3aa000}, {0xbb3ac000}, {0xbb3ae000}, {0xbb3b0000}, {0xbb3b2000}, {0xbb3b4000}, {0xbb3b6000}, {0xbb3b8000}, {0xbb3ba000}, {0xbb3bc000}, {0xbb3be000}, {0xbb3c0000}, {0xbb3c2000}, {0xbb3c4000}, {0xbb3c6000}, {0xbb3c8000}, {0xbb3ca000}, {0xbb3cc000}, {0xbb3ce000}, {0xbb3d0000}, {0xbb3d2000}, {0xbb3d4000}, {0xbb3d6000}, {0xbb3d8000}, {0xbb3da000}, {0xbb3dc000}, {0xbb3de000}, {0xbb3e0000}, {0xbb3e2000}, {0xbb3e4000}, {0xbb3e6000}, {0xbb3e8000}, {0xbb3ea000}, {0xbb3ec000}, {0xbb3ee000}, {0xbb3f0000}, {0xbb3f2000}, {0xbb3f4000}, {0xbb3f6000}, {0xbb3f8000}, {0xbb3fa000}, {0xbb3fc000}, {0xbb3fe000}, {0xbb400000}, {0xbb402000}, {0xbb404000}, {0xbb406000}, {0xbb408000}, {0xbb40a000}, {0xbb40c000}, {0xbb40e000}, {0xbb410000}, {0xbb412000}, {0xbb414000}, {0xbb416000}, {0xbb418000}, {0xbb41a000}, {0xbb41c000}, {0xbb41e000}, {0xbb420000}, {0xbb422000}, {0xbb424000}, {0xbb426000}, {0xbb428000}, {0xbb42a000}, {0xbb42c000}, {0xbb42e000}, {0xbb430000}, {0xbb432000}, {0xbb434000}, {0xbb436000}, {0xbb438000}, {0xbb43a000}, {0xbb43c000}, {0xbb43e000}, {0xbb440000}, {0xbb442000}, {0xbb444000}, {0xbb446000}, {0xbb448000}, {0xbb44a000}, {0xbb44c000}, {0xbb44e000}, {0xbb450000}, {0xbb452000}, {0xbb454000}, {0xbb456000}, {0xbb458000}, {0xbb45a000}, {0xbb45c000}, {0xbb45e000}, {0xbb460000}, {0xbb462000}, {0xbb464000}, {0xbb466000}, {0xbb468000}, {0xbb46a000}, {0xbb46c000}, {0xbb46e000}, {0xbb470000}, {0xbb472000}, {0xbb474000}, {0xbb476000}, {0xbb478000}, {0xbb47a000}, {0xbb47c000}, {0xbb47e000}, {0xbb480000}, {0xbb482000}, {0xbb484000}, {0xbb486000}, {0xbb488000}, {0xbb48a000}, {0xbb48c000}, {0xbb48e000}, {0xbb490000}, {0xbb492000}, {0xbb494000}, {0xbb496000}, {0xbb498000}, {0xbb49a000}, {0xbb49c000}, {0xbb49e000}, {0xbb4a0000}, {0xbb4a2000}, {0xbb4a4000}, {0xbb4a6000}, {0xbb4a8000}, {0xbb4aa000}, {0xbb4ac000}, {0xbb4ae000}, {0xbb4b0000}, {0xbb4b2000}, {0xbb4b4000}, {0xbb4b6000}, {0xbb4b8000}, {0xbb4ba000}, {0xbb4bc000}, {0xbb4be000}, {0xbb4c0000}, {0xbb4c2000}, {0xbb4c4000}, {0xbb4c6000}, {0xbb4c8000}, {0xbb4ca000}, {0xbb4cc000}, {0xbb4ce000}, {0xbb4d0000}, {0xbb4d2000}, {0xbb4d4000}, {0xbb4d6000}, {0xbb4d8000}, {0xbb4da000}, {0xbb4dc000}, {0xbb4de000}, {0xbb4e0000}, {0xbb4e2000}, {0xbb4e4000}, {0xbb4e6000}, {0xbb4e8000}, {0xbb4ea000}, {0xbb4ec000}, {0xbb4ee000}, {0xbb4f0000}, {0xbb4f2000}, {0xbb4f4000}, {0xbb4f6000}, {0xbb4f8000}, {0xbb4fa000}, {0xbb4fc000}, {0xbb4fe000}, {0xbb500000}, {0xbb502000}, {0xbb504000}, {0xbb506000}, {0xbb508000}, {0xbb50a000}, {0xbb50c000}, {0xbb50e000}, {0xbb510000}, {0xbb512000}, {0xbb514000}, {0xbb516000}, {0xbb518000}, {0xbb51a000}, {0xbb51c000}, {0xbb51e000}, {0xbb520000}, {0xbb522000}, {0xbb524000}, {0xbb526000}, {0xbb528000}, {0xbb52a000}, {0xbb52c000}, {0xbb52e000}, {0xbb530000}, {0xbb532000}, {0xbb534000}, {0xbb536000}, {0xbb538000}, {0xbb53a000}, {0xbb53c000}, {0xbb53e000}, {0xbb540000}, {0xbb542000}, {0xbb544000}, {0xbb546000}, {0xbb548000}, {0xbb54a000}, {0xbb54c000}, {0xbb54e000}, {0xbb550000}, {0xbb552000}, {0xbb554000}, {0xbb556000}, {0xbb558000}, {0xbb55a000}, {0xbb55c000}, {0xbb55e000}, {0xbb560000}, {0xbb562000}, {0xbb564000}, {0xbb566000}, {0xbb568000}, {0xbb56a000}, {0xbb56c000}, {0xbb56e000}, {0xbb570000}, {0xbb572000}, {0xbb574000}, {0xbb576000}, {0xbb578000}, {0xbb57a000}, {0xbb57c000}, {0xbb57e000}, {0xbb580000}, {0xbb582000}, {0xbb584000}, {0xbb586000}, {0xbb588000}, {0xbb58a000}, {0xbb58c000}, {0xbb58e000}, {0xbb590000}, {0xbb592000}, {0xbb594000}, {0xbb596000}, {0xbb598000}, {0xbb59a000}, {0xbb59c000}, {0xbb59e000}, {0xbb5a0000}, {0xbb5a2000}, {0xbb5a4000}, {0xbb5a6000}, {0xbb5a8000}, {0xbb5aa000}, {0xbb5ac000}, {0xbb5ae000}, {0xbb5b0000}, {0xbb5b2000}, {0xbb5b4000}, {0xbb5b6000}, {0xbb5b8000}, {0xbb5ba000}, {0xbb5bc000}, {0xbb5be000}, {0xbb5c0000}, {0xbb5c2000}, {0xbb5c4000}, {0xbb5c6000}, {0xbb5c8000}, {0xbb5ca000}, {0xbb5cc000}, {0xbb5ce000}, {0xbb5d0000}, {0xbb5d2000}, {0xbb5d4000}, {0xbb5d6000}, {0xbb5d8000}, {0xbb5da000}, {0xbb5dc000}, {0xbb5de000}, {0xbb5e0000}, {0xbb5e2000}, {0xbb5e4000}, {0xbb5e6000}, {0xbb5e8000}, {0xbb5ea000}, {0xbb5ec000}, {0xbb5ee000}, {0xbb5f0000}, {0xbb5f2000}, {0xbb5f4000}, {0xbb5f6000}, {0xbb5f8000}, {0xbb5fa000}, {0xbb5fc000}, {0xbb5fe000}, {0xbb600000}, {0xbb602000}, {0xbb604000}, {0xbb606000}, {0xbb608000}, {0xbb60a000}, {0xbb60c000}, {0xbb60e000}, {0xbb610000}, {0xbb612000}, {0xbb614000}, {0xbb616000}, {0xbb618000}, {0xbb61a000}, {0xbb61c000}, {0xbb61e000}, {0xbb620000}, {0xbb622000}, {0xbb624000}, {0xbb626000}, {0xbb628000}, {0xbb62a000}, {0xbb62c000}, {0xbb62e000}, {0xbb630000}, {0xbb632000}, {0xbb634000}, {0xbb636000}, {0xbb638000}, {0xbb63a000}, {0xbb63c000}, {0xbb63e000}, {0xbb640000}, {0xbb642000}, {0xbb644000}, {0xbb646000}, {0xbb648000}, {0xbb64a000}, {0xbb64c000}, {0xbb64e000}, {0xbb650000}, {0xbb652000}, {0xbb654000}, {0xbb656000}, {0xbb658000}, {0xbb65a000}, {0xbb65c000}, {0xbb65e000}, {0xbb660000}, {0xbb662000}, {0xbb664000}, {0xbb666000}, {0xbb668000}, {0xbb66a000}, {0xbb66c000}, {0xbb66e000}, {0xbb670000}, {0xbb672000}, {0xbb674000}, {0xbb676000}, {0xbb678000}, {0xbb67a000}, {0xbb67c000}, {0xbb67e000}, {0xbb680000}, {0xbb682000}, {0xbb684000}, {0xbb686000}, {0xbb688000}, {0xbb68a000}, {0xbb68c000}, {0xbb68e000}, {0xbb690000}, {0xbb692000}, {0xbb694000}, {0xbb696000}, {0xbb698000}, {0xbb69a000}, {0xbb69c000}, {0xbb69e000}, {0xbb6a0000}, {0xbb6a2000}, {0xbb6a4000}, {0xbb6a6000}, {0xbb6a8000}, {0xbb6aa000}, {0xbb6ac000}, {0xbb6ae000}, {0xbb6b0000}, {0xbb6b2000}, {0xbb6b4000}, {0xbb6b6000}, {0xbb6b8000}, {0xbb6ba000}, {0xbb6bc000}, {0xbb6be000}, {0xbb6c0000}, {0xbb6c2000}, {0xbb6c4000}, {0xbb6c6000}, {0xbb6c8000}, {0xbb6ca000}, {0xbb6cc000}, {0xbb6ce000}, {0xbb6d0000}, {0xbb6d2000}, {0xbb6d4000}, {0xbb6d6000}, {0xbb6d8000}, {0xbb6da000}, {0xbb6dc000}, {0xbb6de000}, {0xbb6e0000}, {0xbb6e2000}, {0xbb6e4000}, {0xbb6e6000}, {0xbb6e8000}, {0xbb6ea000}, {0xbb6ec000}, {0xbb6ee000}, {0xbb6f0000}, {0xbb6f2000}, {0xbb6f4000}, {0xbb6f6000}, {0xbb6f8000}, {0xbb6fa000}, {0xbb6fc000}, {0xbb6fe000}, {0xbb700000}, {0xbb702000}, {0xbb704000}, {0xbb706000}, {0xbb708000}, {0xbb70a000}, {0xbb70c000}, {0xbb70e000}, {0xbb710000}, {0xbb712000}, {0xbb714000}, {0xbb716000}, {0xbb718000}, {0xbb71a000}, {0xbb71c000}, {0xbb71e000}, {0xbb720000}, {0xbb722000}, {0xbb724000}, {0xbb726000}, {0xbb728000}, {0xbb72a000}, {0xbb72c000}, {0xbb72e000}, {0xbb730000}, {0xbb732000}, {0xbb734000}, {0xbb736000}, {0xbb738000}, {0xbb73a000}, {0xbb73c000}, {0xbb73e000}, {0xbb740000}, {0xbb742000}, {0xbb744000}, {0xbb746000}, {0xbb748000}, {0xbb74a000}, {0xbb74c000}, {0xbb74e000}, {0xbb750000}, {0xbb752000}, {0xbb754000}, {0xbb756000}, {0xbb758000}, {0xbb75a000}, {0xbb75c000}, {0xbb75e000}, {0xbb760000}, {0xbb762000}, {0xbb764000}, {0xbb766000}, {0xbb768000}, {0xbb76a000}, {0xbb76c000}, {0xbb76e000}, {0xbb770000}, {0xbb772000}, {0xbb774000}, {0xbb776000}, {0xbb778000}, {0xbb77a000}, {0xbb77c000}, {0xbb77e000}, {0xbb780000}, {0xbb782000}, {0xbb784000}, {0xbb786000}, {0xbb788000}, {0xbb78a000}, {0xbb78c000}, {0xbb78e000}, {0xbb790000}, {0xbb792000}, {0xbb794000}, {0xbb796000}, {0xbb798000}, {0xbb79a000}, {0xbb79c000}, {0xbb79e000}, {0xbb7a0000}, {0xbb7a2000}, {0xbb7a4000}, {0xbb7a6000}, {0xbb7a8000}, {0xbb7aa000}, {0xbb7ac000}, {0xbb7ae000}, {0xbb7b0000}, {0xbb7b2000}, {0xbb7b4000}, {0xbb7b6000}, {0xbb7b8000}, {0xbb7ba000}, {0xbb7bc000}, {0xbb7be000}, {0xbb7c0000}, {0xbb7c2000}, {0xbb7c4000}, {0xbb7c6000}, {0xbb7c8000}, {0xbb7ca000}, {0xbb7cc000}, {0xbb7ce000}, {0xbb7d0000}, {0xbb7d2000}, {0xbb7d4000}, {0xbb7d6000}, {0xbb7d8000}, {0xbb7da000}, {0xbb7dc000}, {0xbb7de000}, {0xbb7e0000}, {0xbb7e2000}, {0xbb7e4000}, {0xbb7e6000}, {0xbb7e8000}, {0xbb7ea000}, {0xbb7ec000}, {0xbb7ee000}, {0xbb7f0000}, {0xbb7f2000}, {0xbb7f4000}, {0xbb7f6000}, {0xbb7f8000}, {0xbb7fa000}, {0xbb7fc000}, {0xbb7fe000}, {0xbb800000}, {0xbb802000}, {0xbb804000}, {0xbb806000}, {0xbb808000}, {0xbb80a000}, {0xbb80c000}, {0xbb80e000}, {0xbb810000}, {0xbb812000}, {0xbb814000}, {0xbb816000}, {0xbb818000}, {0xbb81a000}, {0xbb81c000}, {0xbb81e000}, {0xbb820000}, {0xbb822000}, {0xbb824000}, {0xbb826000}, {0xbb828000}, {0xbb82a000}, {0xbb82c000}, {0xbb82e000}, {0xbb830000}, {0xbb832000}, {0xbb834000}, {0xbb836000}, {0xbb838000}, {0xbb83a000}, {0xbb83c000}, {0xbb83e000}, {0xbb840000}, {0xbb842000}, {0xbb844000}, {0xbb846000}, {0xbb848000}, {0xbb84a000}, {0xbb84c000}, {0xbb84e000}, {0xbb850000}, {0xbb852000}, {0xbb854000}, {0xbb856000}, {0xbb858000}, {0xbb85a000}, {0xbb85c000}, {0xbb85e000}, {0xbb860000}, {0xbb862000}, {0xbb864000}, {0xbb866000}, {0xbb868000}, {0xbb86a000}, {0xbb86c000}, {0xbb86e000}, {0xbb870000}, {0xbb872000}, {0xbb874000}, {0xbb876000}, {0xbb878000}, {0xbb87a000}, {0xbb87c000}, {0xbb87e000}, {0xbb880000}, {0xbb882000}, {0xbb884000}, {0xbb886000}, {0xbb888000}, {0xbb88a000}, {0xbb88c000}, {0xbb88e000}, {0xbb890000}, {0xbb892000}, {0xbb894000}, {0xbb896000}, {0xbb898000}, {0xbb89a000}, {0xbb89c000}, {0xbb89e000}, {0xbb8a0000}, {0xbb8a2000}, {0xbb8a4000}, {0xbb8a6000}, {0xbb8a8000}, {0xbb8aa000}, {0xbb8ac000}, {0xbb8ae000}, {0xbb8b0000}, {0xbb8b2000}, {0xbb8b4000}, {0xbb8b6000}, {0xbb8b8000}, {0xbb8ba000}, {0xbb8bc000}, {0xbb8be000}, {0xbb8c0000}, {0xbb8c2000}, {0xbb8c4000}, {0xbb8c6000}, {0xbb8c8000}, {0xbb8ca000}, {0xbb8cc000}, {0xbb8ce000}, {0xbb8d0000}, {0xbb8d2000}, {0xbb8d4000}, {0xbb8d6000}, {0xbb8d8000}, {0xbb8da000}, {0xbb8dc000}, {0xbb8de000}, {0xbb8e0000}, {0xbb8e2000}, {0xbb8e4000}, {0xbb8e6000}, {0xbb8e8000}, {0xbb8ea000}, {0xbb8ec000}, {0xbb8ee000}, {0xbb8f0000}, {0xbb8f2000}, {0xbb8f4000}, {0xbb8f6000}, {0xbb8f8000}, {0xbb8fa000}, {0xbb8fc000}, {0xbb8fe000}, {0xbb900000}, {0xbb902000}, {0xbb904000}, {0xbb906000}, {0xbb908000}, {0xbb90a000}, {0xbb90c000}, {0xbb90e000}, {0xbb910000}, {0xbb912000}, {0xbb914000}, {0xbb916000}, {0xbb918000}, {0xbb91a000}, {0xbb91c000}, {0xbb91e000}, {0xbb920000}, {0xbb922000}, {0xbb924000}, {0xbb926000}, {0xbb928000}, {0xbb92a000}, {0xbb92c000}, {0xbb92e000}, {0xbb930000}, {0xbb932000}, {0xbb934000}, {0xbb936000}, {0xbb938000}, {0xbb93a000}, {0xbb93c000}, {0xbb93e000}, {0xbb940000}, {0xbb942000}, {0xbb944000}, {0xbb946000}, {0xbb948000}, {0xbb94a000}, {0xbb94c000}, {0xbb94e000}, {0xbb950000}, {0xbb952000}, {0xbb954000}, {0xbb956000}, {0xbb958000}, {0xbb95a000}, {0xbb95c000}, {0xbb95e000}, {0xbb960000}, {0xbb962000}, {0xbb964000}, {0xbb966000}, {0xbb968000}, {0xbb96a000}, {0xbb96c000}, {0xbb96e000}, {0xbb970000}, {0xbb972000}, {0xbb974000}, {0xbb976000}, {0xbb978000}, {0xbb97a000}, {0xbb97c000}, {0xbb97e000}, {0xbb980000}, {0xbb982000}, {0xbb984000}, {0xbb986000}, {0xbb988000}, {0xbb98a000}, {0xbb98c000}, {0xbb98e000}, {0xbb990000}, {0xbb992000}, {0xbb994000}, {0xbb996000}, {0xbb998000}, {0xbb99a000}, {0xbb99c000}, {0xbb99e000}, {0xbb9a0000}, {0xbb9a2000}, {0xbb9a4000}, {0xbb9a6000}, {0xbb9a8000}, {0xbb9aa000}, {0xbb9ac000}, {0xbb9ae000}, {0xbb9b0000}, {0xbb9b2000}, {0xbb9b4000}, {0xbb9b6000}, {0xbb9b8000}, {0xbb9ba000}, {0xbb9bc000}, {0xbb9be000}, {0xbb9c0000}, {0xbb9c2000}, {0xbb9c4000}, {0xbb9c6000}, {0xbb9c8000}, {0xbb9ca000}, {0xbb9cc000}, {0xbb9ce000}, {0xbb9d0000}, {0xbb9d2000}, {0xbb9d4000}, {0xbb9d6000}, {0xbb9d8000}, {0xbb9da000}, {0xbb9dc000}, {0xbb9de000}, {0xbb9e0000}, {0xbb9e2000}, {0xbb9e4000}, {0xbb9e6000}, {0xbb9e8000}, {0xbb9ea000}, {0xbb9ec000}, {0xbb9ee000}, {0xbb9f0000}, {0xbb9f2000}, {0xbb9f4000}, {0xbb9f6000}, {0xbb9f8000}, {0xbb9fa000}, {0xbb9fc000}, {0xbb9fe000}, {0xbba00000}, {0xbba02000}, {0xbba04000}, {0xbba06000}, {0xbba08000}, {0xbba0a000}, {0xbba0c000}, {0xbba0e000}, {0xbba10000}, {0xbba12000}, {0xbba14000}, {0xbba16000}, {0xbba18000}, {0xbba1a000}, {0xbba1c000}, {0xbba1e000}, {0xbba20000}, {0xbba22000}, {0xbba24000}, {0xbba26000}, {0xbba28000}, {0xbba2a000}, {0xbba2c000}, {0xbba2e000}, {0xbba30000}, {0xbba32000}, {0xbba34000}, {0xbba36000}, {0xbba38000}, {0xbba3a000}, {0xbba3c000}, {0xbba3e000}, {0xbba40000}, {0xbba42000}, {0xbba44000}, {0xbba46000}, {0xbba48000}, {0xbba4a000}, {0xbba4c000}, {0xbba4e000}, {0xbba50000}, {0xbba52000}, {0xbba54000}, {0xbba56000}, {0xbba58000}, {0xbba5a000}, {0xbba5c000}, {0xbba5e000}, {0xbba60000}, {0xbba62000}, {0xbba64000}, {0xbba66000}, {0xbba68000}, {0xbba6a000}, {0xbba6c000}, {0xbba6e000}, {0xbba70000}, {0xbba72000}, {0xbba74000}, {0xbba76000}, {0xbba78000}, {0xbba7a000}, {0xbba7c000}, {0xbba7e000}, {0xbba80000}, {0xbba82000}, {0xbba84000}, {0xbba86000}, {0xbba88000}, {0xbba8a000}, {0xbba8c000}, {0xbba8e000}, {0xbba90000}, {0xbba92000}, {0xbba94000}, {0xbba96000}, {0xbba98000}, {0xbba9a000}, {0xbba9c000}, {0xbba9e000}, {0xbbaa0000}, {0xbbaa2000}, {0xbbaa4000}, {0xbbaa6000}, {0xbbaa8000}, {0xbbaaa000}, {0xbbaac000}, {0xbbaae000}, {0xbbab0000}, {0xbbab2000}, {0xbbab4000}, {0xbbab6000}, {0xbbab8000}, {0xbbaba000}, {0xbbabc000}, {0xbbabe000}, {0xbbac0000}, {0xbbac2000}, {0xbbac4000}, {0xbbac6000}, {0xbbac8000}, {0xbbaca000}, {0xbbacc000}, {0xbbace000}, {0xbbad0000}, {0xbbad2000}, {0xbbad4000}, {0xbbad6000}, {0xbbad8000}, {0xbbada000}, {0xbbadc000}, {0xbbade000}, {0xbbae0000}, {0xbbae2000}, {0xbbae4000}, {0xbbae6000}, {0xbbae8000}, {0xbbaea000}, {0xbbaec000}, {0xbbaee000}, {0xbbaf0000}, {0xbbaf2000}, {0xbbaf4000}, {0xbbaf6000}, {0xbbaf8000}, {0xbbafa000}, {0xbbafc000}, {0xbbafe000}, {0xbbb00000}, {0xbbb02000}, {0xbbb04000}, {0xbbb06000}, {0xbbb08000}, {0xbbb0a000}, {0xbbb0c000}, {0xbbb0e000}, {0xbbb10000}, {0xbbb12000}, {0xbbb14000}, {0xbbb16000}, {0xbbb18000}, {0xbbb1a000}, {0xbbb1c000}, {0xbbb1e000}, {0xbbb20000}, {0xbbb22000}, {0xbbb24000}, {0xbbb26000}, {0xbbb28000}, {0xbbb2a000}, {0xbbb2c000}, {0xbbb2e000}, {0xbbb30000}, {0xbbb32000}, {0xbbb34000}, {0xbbb36000}, {0xbbb38000}, {0xbbb3a000}, {0xbbb3c000}, {0xbbb3e000}, {0xbbb40000}, {0xbbb42000}, {0xbbb44000}, {0xbbb46000}, {0xbbb48000}, {0xbbb4a000}, {0xbbb4c000}, {0xbbb4e000}, {0xbbb50000}, {0xbbb52000}, {0xbbb54000}, {0xbbb56000}, {0xbbb58000}, {0xbbb5a000}, {0xbbb5c000}, {0xbbb5e000}, {0xbbb60000}, {0xbbb62000}, {0xbbb64000}, {0xbbb66000}, {0xbbb68000}, {0xbbb6a000}, {0xbbb6c000}, {0xbbb6e000}, {0xbbb70000}, {0xbbb72000}, {0xbbb74000}, {0xbbb76000}, {0xbbb78000}, {0xbbb7a000}, {0xbbb7c000}, {0xbbb7e000}, {0xbbb80000}, {0xbbb82000}, {0xbbb84000}, {0xbbb86000}, {0xbbb88000}, {0xbbb8a000}, {0xbbb8c000}, {0xbbb8e000}, {0xbbb90000}, {0xbbb92000}, {0xbbb94000}, {0xbbb96000}, {0xbbb98000}, {0xbbb9a000}, {0xbbb9c000}, {0xbbb9e000}, {0xbbba0000}, {0xbbba2000}, {0xbbba4000}, {0xbbba6000}, {0xbbba8000}, {0xbbbaa000}, {0xbbbac000}, {0xbbbae000}, {0xbbbb0000}, {0xbbbb2000}, {0xbbbb4000}, {0xbbbb6000}, {0xbbbb8000}, {0xbbbba000}, {0xbbbbc000}, {0xbbbbe000}, {0xbbbc0000}, {0xbbbc2000}, {0xbbbc4000}, {0xbbbc6000}, {0xbbbc8000}, {0xbbbca000}, {0xbbbcc000}, {0xbbbce000}, {0xbbbd0000}, {0xbbbd2000}, {0xbbbd4000}, {0xbbbd6000}, {0xbbbd8000}, {0xbbbda000}, {0xbbbdc000}, {0xbbbde000}, {0xbbbe0000}, {0xbbbe2000}, {0xbbbe4000}, {0xbbbe6000}, {0xbbbe8000}, {0xbbbea000}, {0xbbbec000}, {0xbbbee000}, {0xbbbf0000}, {0xbbbf2000}, {0xbbbf4000}, {0xbbbf6000}, {0xbbbf8000}, {0xbbbfa000}, {0xbbbfc000}, {0xbbbfe000}, {0xbbc00000}, {0xbbc02000}, {0xbbc04000}, {0xbbc06000}, {0xbbc08000}, {0xbbc0a000}, {0xbbc0c000}, {0xbbc0e000}, {0xbbc10000}, {0xbbc12000}, {0xbbc14000}, {0xbbc16000}, {0xbbc18000}, {0xbbc1a000}, {0xbbc1c000}, {0xbbc1e000}, {0xbbc20000}, {0xbbc22000}, {0xbbc24000}, {0xbbc26000}, {0xbbc28000}, {0xbbc2a000}, {0xbbc2c000}, {0xbbc2e000}, {0xbbc30000}, {0xbbc32000}, {0xbbc34000}, {0xbbc36000}, {0xbbc38000}, {0xbbc3a000}, {0xbbc3c000}, {0xbbc3e000}, {0xbbc40000}, {0xbbc42000}, {0xbbc44000}, {0xbbc46000}, {0xbbc48000}, {0xbbc4a000}, {0xbbc4c000}, {0xbbc4e000}, {0xbbc50000}, {0xbbc52000}, {0xbbc54000}, {0xbbc56000}, {0xbbc58000}, {0xbbc5a000}, {0xbbc5c000}, {0xbbc5e000}, {0xbbc60000}, {0xbbc62000}, {0xbbc64000}, {0xbbc66000}, {0xbbc68000}, {0xbbc6a000}, {0xbbc6c000}, {0xbbc6e000}, {0xbbc70000}, {0xbbc72000}, {0xbbc74000}, {0xbbc76000}, {0xbbc78000}, {0xbbc7a000}, {0xbbc7c000}, {0xbbc7e000}, {0xbbc80000}, {0xbbc82000}, {0xbbc84000}, {0xbbc86000}, {0xbbc88000}, {0xbbc8a000}, {0xbbc8c000}, {0xbbc8e000}, {0xbbc90000}, {0xbbc92000}, {0xbbc94000}, {0xbbc96000}, {0xbbc98000}, {0xbbc9a000}, {0xbbc9c000}, {0xbbc9e000}, {0xbbca0000}, {0xbbca2000}, {0xbbca4000}, {0xbbca6000}, {0xbbca8000}, {0xbbcaa000}, {0xbbcac000}, {0xbbcae000}, {0xbbcb0000}, {0xbbcb2000}, {0xbbcb4000}, {0xbbcb6000}, {0xbbcb8000}, {0xbbcba000}, {0xbbcbc000}, {0xbbcbe000}, {0xbbcc0000}, {0xbbcc2000}, {0xbbcc4000}, {0xbbcc6000}, {0xbbcc8000}, {0xbbcca000}, {0xbbccc000}, {0xbbcce000}, {0xbbcd0000}, {0xbbcd2000}, {0xbbcd4000}, {0xbbcd6000}, {0xbbcd8000}, {0xbbcda000}, {0xbbcdc000}, {0xbbcde000}, {0xbbce0000}, {0xbbce2000}, {0xbbce4000}, {0xbbce6000}, {0xbbce8000}, {0xbbcea000}, {0xbbcec000}, {0xbbcee000}, {0xbbcf0000}, {0xbbcf2000}, {0xbbcf4000}, {0xbbcf6000}, {0xbbcf8000}, {0xbbcfa000}, {0xbbcfc000}, {0xbbcfe000}, {0xbbd00000}, {0xbbd02000}, {0xbbd04000}, {0xbbd06000}, {0xbbd08000}, {0xbbd0a000}, {0xbbd0c000}, {0xbbd0e000}, {0xbbd10000}, {0xbbd12000}, {0xbbd14000}, {0xbbd16000}, {0xbbd18000}, {0xbbd1a000}, {0xbbd1c000}, {0xbbd1e000}, {0xbbd20000}, {0xbbd22000}, {0xbbd24000}, {0xbbd26000}, {0xbbd28000}, {0xbbd2a000}, {0xbbd2c000}, {0xbbd2e000}, {0xbbd30000}, {0xbbd32000}, {0xbbd34000}, {0xbbd36000}, {0xbbd38000}, {0xbbd3a000}, {0xbbd3c000}, {0xbbd3e000}, {0xbbd40000}, {0xbbd42000}, {0xbbd44000}, {0xbbd46000}, {0xbbd48000}, {0xbbd4a000}, {0xbbd4c000}, {0xbbd4e000}, {0xbbd50000}, {0xbbd52000}, {0xbbd54000}, {0xbbd56000}, {0xbbd58000}, {0xbbd5a000}, {0xbbd5c000}, {0xbbd5e000}, {0xbbd60000}, {0xbbd62000}, {0xbbd64000}, {0xbbd66000}, {0xbbd68000}, {0xbbd6a000}, {0xbbd6c000}, {0xbbd6e000}, {0xbbd70000}, {0xbbd72000}, {0xbbd74000}, {0xbbd76000}, {0xbbd78000}, {0xbbd7a000}, {0xbbd7c000}, {0xbbd7e000}, {0xbbd80000}, {0xbbd82000}, {0xbbd84000}, {0xbbd86000}, {0xbbd88000}, {0xbbd8a000}, {0xbbd8c000}, {0xbbd8e000}, {0xbbd90000}, {0xbbd92000}, {0xbbd94000}, {0xbbd96000}, {0xbbd98000}, {0xbbd9a000}, {0xbbd9c000}, {0xbbd9e000}, {0xbbda0000}, {0xbbda2000}, {0xbbda4000}, {0xbbda6000}, {0xbbda8000}, {0xbbdaa000}, {0xbbdac000}, {0xbbdae000}, {0xbbdb0000}, {0xbbdb2000}, {0xbbdb4000}, {0xbbdb6000}, {0xbbdb8000}, {0xbbdba000}, {0xbbdbc000}, {0xbbdbe000}, {0xbbdc0000}, {0xbbdc2000}, {0xbbdc4000}, {0xbbdc6000}, {0xbbdc8000}, {0xbbdca000}, {0xbbdcc000}, {0xbbdce000}, {0xbbdd0000}, {0xbbdd2000}, {0xbbdd4000}, {0xbbdd6000}, {0xbbdd8000}, {0xbbdda000}, {0xbbddc000}, {0xbbdde000}, {0xbbde0000}, {0xbbde2000}, {0xbbde4000}, {0xbbde6000}, {0xbbde8000}, {0xbbdea000}, {0xbbdec000}, {0xbbdee000}, {0xbbdf0000}, {0xbbdf2000}, {0xbbdf4000}, {0xbbdf6000}, {0xbbdf8000}, {0xbbdfa000}, {0xbbdfc000}, {0xbbdfe000}, {0xbbe00000}, {0xbbe02000}, {0xbbe04000}, {0xbbe06000}, {0xbbe08000}, {0xbbe0a000}, {0xbbe0c000}, {0xbbe0e000}, {0xbbe10000}, {0xbbe12000}, {0xbbe14000}, {0xbbe16000}, {0xbbe18000}, {0xbbe1a000}, {0xbbe1c000}, {0xbbe1e000}, {0xbbe20000}, {0xbbe22000}, {0xbbe24000}, {0xbbe26000}, {0xbbe28000}, {0xbbe2a000}, {0xbbe2c000}, {0xbbe2e000}, {0xbbe30000}, {0xbbe32000}, {0xbbe34000}, {0xbbe36000}, {0xbbe38000}, {0xbbe3a000}, {0xbbe3c000}, {0xbbe3e000}, {0xbbe40000}, {0xbbe42000}, {0xbbe44000}, {0xbbe46000}, {0xbbe48000}, {0xbbe4a000}, {0xbbe4c000}, {0xbbe4e000}, {0xbbe50000}, {0xbbe52000}, {0xbbe54000}, {0xbbe56000}, {0xbbe58000}, {0xbbe5a000}, {0xbbe5c000}, {0xbbe5e000}, {0xbbe60000}, {0xbbe62000}, {0xbbe64000}, {0xbbe66000}, {0xbbe68000}, {0xbbe6a000}, {0xbbe6c000}, {0xbbe6e000}, {0xbbe70000}, {0xbbe72000}, {0xbbe74000}, {0xbbe76000}, {0xbbe78000}, {0xbbe7a000}, {0xbbe7c000}, {0xbbe7e000}, {0xbbe80000}, {0xbbe82000}, {0xbbe84000}, {0xbbe86000}, {0xbbe88000}, {0xbbe8a000}, {0xbbe8c000}, {0xbbe8e000}, {0xbbe90000}, {0xbbe92000}, {0xbbe94000}, {0xbbe96000}, {0xbbe98000}, {0xbbe9a000}, {0xbbe9c000}, {0xbbe9e000}, {0xbbea0000}, {0xbbea2000}, {0xbbea4000}, {0xbbea6000}, {0xbbea8000}, {0xbbeaa000}, {0xbbeac000}, {0xbbeae000}, {0xbbeb0000}, {0xbbeb2000}, {0xbbeb4000}, {0xbbeb6000}, {0xbbeb8000}, {0xbbeba000}, {0xbbebc000}, {0xbbebe000}, {0xbbec0000}, {0xbbec2000}, {0xbbec4000}, {0xbbec6000}, {0xbbec8000}, {0xbbeca000}, {0xbbecc000}, {0xbbece000}, {0xbbed0000}, {0xbbed2000}, {0xbbed4000}, {0xbbed6000}, {0xbbed8000}, {0xbbeda000}, {0xbbedc000}, {0xbbede000}, {0xbbee0000}, {0xbbee2000}, {0xbbee4000}, {0xbbee6000}, {0xbbee8000}, {0xbbeea000}, {0xbbeec000}, {0xbbeee000}, {0xbbef0000}, {0xbbef2000}, {0xbbef4000}, {0xbbef6000}, {0xbbef8000}, {0xbbefa000}, {0xbbefc000}, {0xbbefe000}, {0xbbf00000}, {0xbbf02000}, {0xbbf04000}, {0xbbf06000}, {0xbbf08000}, {0xbbf0a000}, {0xbbf0c000}, {0xbbf0e000}, {0xbbf10000}, {0xbbf12000}, {0xbbf14000}, {0xbbf16000}, {0xbbf18000}, {0xbbf1a000}, {0xbbf1c000}, {0xbbf1e000}, {0xbbf20000}, {0xbbf22000}, {0xbbf24000}, {0xbbf26000}, {0xbbf28000}, {0xbbf2a000}, {0xbbf2c000}, {0xbbf2e000}, {0xbbf30000}, {0xbbf32000}, {0xbbf34000}, {0xbbf36000}, {0xbbf38000}, {0xbbf3a000}, {0xbbf3c000}, {0xbbf3e000}, {0xbbf40000}, {0xbbf42000}, {0xbbf44000}, {0xbbf46000}, {0xbbf48000}, {0xbbf4a000}, {0xbbf4c000}, {0xbbf4e000}, {0xbbf50000}, {0xbbf52000}, {0xbbf54000}, {0xbbf56000}, {0xbbf58000}, {0xbbf5a000}, {0xbbf5c000}, {0xbbf5e000}, {0xbbf60000}, {0xbbf62000}, {0xbbf64000}, {0xbbf66000}, {0xbbf68000}, {0xbbf6a000}, {0xbbf6c000}, {0xbbf6e000}, {0xbbf70000}, {0xbbf72000}, {0xbbf74000}, {0xbbf76000}, {0xbbf78000}, {0xbbf7a000}, {0xbbf7c000}, {0xbbf7e000}, {0xbbf80000}, {0xbbf82000}, {0xbbf84000}, {0xbbf86000}, {0xbbf88000}, {0xbbf8a000}, {0xbbf8c000}, {0xbbf8e000}, {0xbbf90000}, {0xbbf92000}, {0xbbf94000}, {0xbbf96000}, {0xbbf98000}, {0xbbf9a000}, {0xbbf9c000}, {0xbbf9e000}, {0xbbfa0000}, {0xbbfa2000}, {0xbbfa4000}, {0xbbfa6000}, {0xbbfa8000}, {0xbbfaa000}, {0xbbfac000}, {0xbbfae000}, {0xbbfb0000}, {0xbbfb2000}, {0xbbfb4000}, {0xbbfb6000}, {0xbbfb8000}, {0xbbfba000}, {0xbbfbc000}, {0xbbfbe000}, {0xbbfc0000}, {0xbbfc2000}, {0xbbfc4000}, {0xbbfc6000}, {0xbbfc8000}, {0xbbfca000}, {0xbbfcc000}, {0xbbfce000}, {0xbbfd0000}, {0xbbfd2000}, {0xbbfd4000}, {0xbbfd6000}, {0xbbfd8000}, {0xbbfda000}, {0xbbfdc000}, {0xbbfde000}, {0xbbfe0000}, {0xbbfe2000}, {0xbbfe4000}, {0xbbfe6000}, {0xbbfe8000}, {0xbbfea000}, {0xbbfec000}, {0xbbfee000}, {0xbbff0000}, {0xbbff2000}, {0xbbff4000}, {0xbbff6000}, {0xbbff8000}, {0xbbffa000}, {0xbbffc000}, {0xbbffe000}, {0xbc000000}, {0xbc002000}, {0xbc004000}, {0xbc006000}, {0xbc008000}, {0xbc00a000}, {0xbc00c000}, {0xbc00e000}, {0xbc010000}, {0xbc012000}, {0xbc014000}, {0xbc016000}, {0xbc018000}, {0xbc01a000}, {0xbc01c000}, {0xbc01e000}, {0xbc020000}, {0xbc022000}, {0xbc024000}, {0xbc026000}, {0xbc028000}, {0xbc02a000}, {0xbc02c000}, {0xbc02e000}, {0xbc030000}, {0xbc032000}, {0xbc034000}, {0xbc036000}, {0xbc038000}, {0xbc03a000}, {0xbc03c000}, {0xbc03e000}, {0xbc040000}, {0xbc042000}, {0xbc044000}, {0xbc046000}, {0xbc048000}, {0xbc04a000}, {0xbc04c000}, {0xbc04e000}, {0xbc050000}, {0xbc052000}, {0xbc054000}, {0xbc056000}, {0xbc058000}, {0xbc05a000}, {0xbc05c000}, {0xbc05e000}, {0xbc060000}, {0xbc062000}, {0xbc064000}, {0xbc066000}, {0xbc068000}, {0xbc06a000}, {0xbc06c000}, {0xbc06e000}, {0xbc070000}, {0xbc072000}, {0xbc074000}, {0xbc076000}, {0xbc078000}, {0xbc07a000}, {0xbc07c000}, {0xbc07e000}, {0xbc080000}, {0xbc082000}, {0xbc084000}, {0xbc086000}, {0xbc088000}, {0xbc08a000}, {0xbc08c000}, {0xbc08e000}, {0xbc090000}, {0xbc092000}, {0xbc094000}, {0xbc096000}, {0xbc098000}, {0xbc09a000}, {0xbc09c000}, {0xbc09e000}, {0xbc0a0000}, {0xbc0a2000}, {0xbc0a4000}, {0xbc0a6000}, {0xbc0a8000}, {0xbc0aa000}, {0xbc0ac000}, {0xbc0ae000}, {0xbc0b0000}, {0xbc0b2000}, {0xbc0b4000}, {0xbc0b6000}, {0xbc0b8000}, {0xbc0ba000}, {0xbc0bc000}, {0xbc0be000}, {0xbc0c0000}, {0xbc0c2000}, {0xbc0c4000}, {0xbc0c6000}, {0xbc0c8000}, {0xbc0ca000}, {0xbc0cc000}, {0xbc0ce000}, {0xbc0d0000}, {0xbc0d2000}, {0xbc0d4000}, {0xbc0d6000}, {0xbc0d8000}, {0xbc0da000}, {0xbc0dc000}, {0xbc0de000}, {0xbc0e0000}, {0xbc0e2000}, {0xbc0e4000}, {0xbc0e6000}, {0xbc0e8000}, {0xbc0ea000}, {0xbc0ec000}, {0xbc0ee000}, {0xbc0f0000}, {0xbc0f2000}, {0xbc0f4000}, {0xbc0f6000}, {0xbc0f8000}, {0xbc0fa000}, {0xbc0fc000}, {0xbc0fe000}, {0xbc100000}, {0xbc102000}, {0xbc104000}, {0xbc106000}, {0xbc108000}, {0xbc10a000}, {0xbc10c000}, {0xbc10e000}, {0xbc110000}, {0xbc112000}, {0xbc114000}, {0xbc116000}, {0xbc118000}, {0xbc11a000}, {0xbc11c000}, {0xbc11e000}, {0xbc120000}, {0xbc122000}, {0xbc124000}, {0xbc126000}, {0xbc128000}, {0xbc12a000}, {0xbc12c000}, {0xbc12e000}, {0xbc130000}, {0xbc132000}, {0xbc134000}, {0xbc136000}, {0xbc138000}, {0xbc13a000}, {0xbc13c000}, {0xbc13e000}, {0xbc140000}, {0xbc142000}, {0xbc144000}, {0xbc146000}, {0xbc148000}, {0xbc14a000}, {0xbc14c000}, {0xbc14e000}, {0xbc150000}, {0xbc152000}, {0xbc154000}, {0xbc156000}, {0xbc158000}, {0xbc15a000}, {0xbc15c000}, {0xbc15e000}, {0xbc160000}, {0xbc162000}, {0xbc164000}, {0xbc166000}, {0xbc168000}, {0xbc16a000}, {0xbc16c000}, {0xbc16e000}, {0xbc170000}, {0xbc172000}, {0xbc174000}, {0xbc176000}, {0xbc178000}, {0xbc17a000}, {0xbc17c000}, {0xbc17e000}, {0xbc180000}, {0xbc182000}, {0xbc184000}, {0xbc186000}, {0xbc188000}, {0xbc18a000}, {0xbc18c000}, {0xbc18e000}, {0xbc190000}, {0xbc192000}, {0xbc194000}, {0xbc196000}, {0xbc198000}, {0xbc19a000}, {0xbc19c000}, {0xbc19e000}, {0xbc1a0000}, {0xbc1a2000}, {0xbc1a4000}, {0xbc1a6000}, {0xbc1a8000}, {0xbc1aa000}, {0xbc1ac000}, {0xbc1ae000}, {0xbc1b0000}, {0xbc1b2000}, {0xbc1b4000}, {0xbc1b6000}, {0xbc1b8000}, {0xbc1ba000}, {0xbc1bc000}, {0xbc1be000}, {0xbc1c0000}, {0xbc1c2000}, {0xbc1c4000}, {0xbc1c6000}, {0xbc1c8000}, {0xbc1ca000}, {0xbc1cc000}, {0xbc1ce000}, {0xbc1d0000}, {0xbc1d2000}, {0xbc1d4000}, {0xbc1d6000}, {0xbc1d8000}, {0xbc1da000}, {0xbc1dc000}, {0xbc1de000}, {0xbc1e0000}, {0xbc1e2000}, {0xbc1e4000}, {0xbc1e6000}, {0xbc1e8000}, {0xbc1ea000}, {0xbc1ec000}, {0xbc1ee000}, {0xbc1f0000}, {0xbc1f2000}, {0xbc1f4000}, {0xbc1f6000}, {0xbc1f8000}, {0xbc1fa000}, {0xbc1fc000}, {0xbc1fe000}, {0xbc200000}, {0xbc202000}, {0xbc204000}, {0xbc206000}, {0xbc208000}, {0xbc20a000}, {0xbc20c000}, {0xbc20e000}, {0xbc210000}, {0xbc212000}, {0xbc214000}, {0xbc216000}, {0xbc218000}, {0xbc21a000}, {0xbc21c000}, {0xbc21e000}, {0xbc220000}, {0xbc222000}, {0xbc224000}, {0xbc226000}, {0xbc228000}, {0xbc22a000}, {0xbc22c000}, {0xbc22e000}, {0xbc230000}, {0xbc232000}, {0xbc234000}, {0xbc236000}, {0xbc238000}, {0xbc23a000}, {0xbc23c000}, {0xbc23e000}, {0xbc240000}, {0xbc242000}, {0xbc244000}, {0xbc246000}, {0xbc248000}, {0xbc24a000}, {0xbc24c000}, {0xbc24e000}, {0xbc250000}, {0xbc252000}, {0xbc254000}, {0xbc256000}, {0xbc258000}, {0xbc25a000}, {0xbc25c000}, {0xbc25e000}, {0xbc260000}, {0xbc262000}, {0xbc264000}, {0xbc266000}, {0xbc268000}, {0xbc26a000}, {0xbc26c000}, {0xbc26e000}, {0xbc270000}, {0xbc272000}, {0xbc274000}, {0xbc276000}, {0xbc278000}, {0xbc27a000}, {0xbc27c000}, {0xbc27e000}, {0xbc280000}, {0xbc282000}, {0xbc284000}, {0xbc286000}, {0xbc288000}, {0xbc28a000}, {0xbc28c000}, {0xbc28e000}, {0xbc290000}, {0xbc292000}, {0xbc294000}, {0xbc296000}, {0xbc298000}, {0xbc29a000}, {0xbc29c000}, {0xbc29e000}, {0xbc2a0000}, {0xbc2a2000}, {0xbc2a4000}, {0xbc2a6000}, {0xbc2a8000}, {0xbc2aa000}, {0xbc2ac000}, {0xbc2ae000}, {0xbc2b0000}, {0xbc2b2000}, {0xbc2b4000}, {0xbc2b6000}, {0xbc2b8000}, {0xbc2ba000}, {0xbc2bc000}, {0xbc2be000}, {0xbc2c0000}, {0xbc2c2000}, {0xbc2c4000}, {0xbc2c6000}, {0xbc2c8000}, {0xbc2ca000}, {0xbc2cc000}, {0xbc2ce000}, {0xbc2d0000}, {0xbc2d2000}, {0xbc2d4000}, {0xbc2d6000}, {0xbc2d8000}, {0xbc2da000}, {0xbc2dc000}, {0xbc2de000}, {0xbc2e0000}, {0xbc2e2000}, {0xbc2e4000}, {0xbc2e6000}, {0xbc2e8000}, {0xbc2ea000}, {0xbc2ec000}, {0xbc2ee000}, {0xbc2f0000}, {0xbc2f2000}, {0xbc2f4000}, {0xbc2f6000}, {0xbc2f8000}, {0xbc2fa000}, {0xbc2fc000}, {0xbc2fe000}, {0xbc300000}, {0xbc302000}, {0xbc304000}, {0xbc306000}, {0xbc308000}, {0xbc30a000}, {0xbc30c000}, {0xbc30e000}, {0xbc310000}, {0xbc312000}, {0xbc314000}, {0xbc316000}, {0xbc318000}, {0xbc31a000}, {0xbc31c000}, {0xbc31e000}, {0xbc320000}, {0xbc322000}, {0xbc324000}, {0xbc326000}, {0xbc328000}, {0xbc32a000}, {0xbc32c000}, {0xbc32e000}, {0xbc330000}, {0xbc332000}, {0xbc334000}, {0xbc336000}, {0xbc338000}, {0xbc33a000}, {0xbc33c000}, {0xbc33e000}, {0xbc340000}, {0xbc342000}, {0xbc344000}, {0xbc346000}, {0xbc348000}, {0xbc34a000}, {0xbc34c000}, {0xbc34e000}, {0xbc350000}, {0xbc352000}, {0xbc354000}, {0xbc356000}, {0xbc358000}, {0xbc35a000}, {0xbc35c000}, {0xbc35e000}, {0xbc360000}, {0xbc362000}, {0xbc364000}, {0xbc366000}, {0xbc368000}, {0xbc36a000}, {0xbc36c000}, {0xbc36e000}, {0xbc370000}, {0xbc372000}, {0xbc374000}, {0xbc376000}, {0xbc378000}, {0xbc37a000}, {0xbc37c000}, {0xbc37e000}, {0xbc380000}, {0xbc382000}, {0xbc384000}, {0xbc386000}, {0xbc388000}, {0xbc38a000}, {0xbc38c000}, {0xbc38e000}, {0xbc390000}, {0xbc392000}, {0xbc394000}, {0xbc396000}, {0xbc398000}, {0xbc39a000}, {0xbc39c000}, {0xbc39e000}, {0xbc3a0000}, {0xbc3a2000}, {0xbc3a4000}, {0xbc3a6000}, {0xbc3a8000}, {0xbc3aa000}, {0xbc3ac000}, {0xbc3ae000}, {0xbc3b0000}, {0xbc3b2000}, {0xbc3b4000}, {0xbc3b6000}, {0xbc3b8000}, {0xbc3ba000}, {0xbc3bc000}, {0xbc3be000}, {0xbc3c0000}, {0xbc3c2000}, {0xbc3c4000}, {0xbc3c6000}, {0xbc3c8000}, {0xbc3ca000}, {0xbc3cc000}, {0xbc3ce000}, {0xbc3d0000}, {0xbc3d2000}, {0xbc3d4000}, {0xbc3d6000}, {0xbc3d8000}, {0xbc3da000}, {0xbc3dc000}, {0xbc3de000}, {0xbc3e0000}, {0xbc3e2000}, {0xbc3e4000}, {0xbc3e6000}, {0xbc3e8000}, {0xbc3ea000}, {0xbc3ec000}, {0xbc3ee000}, {0xbc3f0000}, {0xbc3f2000}, {0xbc3f4000}, {0xbc3f6000}, {0xbc3f8000}, {0xbc3fa000}, {0xbc3fc000}, {0xbc3fe000}, {0xbc400000}, {0xbc402000}, {0xbc404000}, {0xbc406000}, {0xbc408000}, {0xbc40a000}, {0xbc40c000}, {0xbc40e000}, {0xbc410000}, {0xbc412000}, {0xbc414000}, {0xbc416000}, {0xbc418000}, {0xbc41a000}, {0xbc41c000}, {0xbc41e000}, {0xbc420000}, {0xbc422000}, {0xbc424000}, {0xbc426000}, {0xbc428000}, {0xbc42a000}, {0xbc42c000}, {0xbc42e000}, {0xbc430000}, {0xbc432000}, {0xbc434000}, {0xbc436000}, {0xbc438000}, {0xbc43a000}, {0xbc43c000}, {0xbc43e000}, {0xbc440000}, {0xbc442000}, {0xbc444000}, {0xbc446000}, {0xbc448000}, {0xbc44a000}, {0xbc44c000}, {0xbc44e000}, {0xbc450000}, {0xbc452000}, {0xbc454000}, {0xbc456000}, {0xbc458000}, {0xbc45a000}, {0xbc45c000}, {0xbc45e000}, {0xbc460000}, {0xbc462000}, {0xbc464000}, {0xbc466000}, {0xbc468000}, {0xbc46a000}, {0xbc46c000}, {0xbc46e000}, {0xbc470000}, {0xbc472000}, {0xbc474000}, {0xbc476000}, {0xbc478000}, {0xbc47a000}, {0xbc47c000}, {0xbc47e000}, {0xbc480000}, {0xbc482000}, {0xbc484000}, {0xbc486000}, {0xbc488000}, {0xbc48a000}, {0xbc48c000}, {0xbc48e000}, {0xbc490000}, {0xbc492000}, {0xbc494000}, {0xbc496000}, {0xbc498000}, {0xbc49a000}, {0xbc49c000}, {0xbc49e000}, {0xbc4a0000}, {0xbc4a2000}, {0xbc4a4000}, {0xbc4a6000}, {0xbc4a8000}, {0xbc4aa000}, {0xbc4ac000}, {0xbc4ae000}, {0xbc4b0000}, {0xbc4b2000}, {0xbc4b4000}, {0xbc4b6000}, {0xbc4b8000}, {0xbc4ba000}, {0xbc4bc000}, {0xbc4be000}, {0xbc4c0000}, {0xbc4c2000}, {0xbc4c4000}, {0xbc4c6000}, {0xbc4c8000}, {0xbc4ca000}, {0xbc4cc000}, {0xbc4ce000}, {0xbc4d0000}, {0xbc4d2000}, {0xbc4d4000}, {0xbc4d6000}, {0xbc4d8000}, {0xbc4da000}, {0xbc4dc000}, {0xbc4de000}, {0xbc4e0000}, {0xbc4e2000}, {0xbc4e4000}, {0xbc4e6000}, {0xbc4e8000}, {0xbc4ea000}, {0xbc4ec000}, {0xbc4ee000}, {0xbc4f0000}, {0xbc4f2000}, {0xbc4f4000}, {0xbc4f6000}, {0xbc4f8000}, {0xbc4fa000}, {0xbc4fc000}, {0xbc4fe000}, {0xbc500000}, {0xbc502000}, {0xbc504000}, {0xbc506000}, {0xbc508000}, {0xbc50a000}, {0xbc50c000}, {0xbc50e000}, {0xbc510000}, {0xbc512000}, {0xbc514000}, {0xbc516000}, {0xbc518000}, {0xbc51a000}, {0xbc51c000}, {0xbc51e000}, {0xbc520000}, {0xbc522000}, {0xbc524000}, {0xbc526000}, {0xbc528000}, {0xbc52a000}, {0xbc52c000}, {0xbc52e000}, {0xbc530000}, {0xbc532000}, {0xbc534000}, {0xbc536000}, {0xbc538000}, {0xbc53a000}, {0xbc53c000}, {0xbc53e000}, {0xbc540000}, {0xbc542000}, {0xbc544000}, {0xbc546000}, {0xbc548000}, {0xbc54a000}, {0xbc54c000}, {0xbc54e000}, {0xbc550000}, {0xbc552000}, {0xbc554000}, {0xbc556000}, {0xbc558000}, {0xbc55a000}, {0xbc55c000}, {0xbc55e000}, {0xbc560000}, {0xbc562000}, {0xbc564000}, {0xbc566000}, {0xbc568000}, {0xbc56a000}, {0xbc56c000}, {0xbc56e000}, {0xbc570000}, {0xbc572000}, {0xbc574000}, {0xbc576000}, {0xbc578000}, {0xbc57a000}, {0xbc57c000}, {0xbc57e000}, {0xbc580000}, {0xbc582000}, {0xbc584000}, {0xbc586000}, {0xbc588000}, {0xbc58a000}, {0xbc58c000}, {0xbc58e000}, {0xbc590000}, {0xbc592000}, {0xbc594000}, {0xbc596000}, {0xbc598000}, {0xbc59a000}, {0xbc59c000}, {0xbc59e000}, {0xbc5a0000}, {0xbc5a2000}, {0xbc5a4000}, {0xbc5a6000}, {0xbc5a8000}, {0xbc5aa000}, {0xbc5ac000}, {0xbc5ae000}, {0xbc5b0000}, {0xbc5b2000}, {0xbc5b4000}, {0xbc5b6000}, {0xbc5b8000}, {0xbc5ba000}, {0xbc5bc000}, {0xbc5be000}, {0xbc5c0000}, {0xbc5c2000}, {0xbc5c4000}, {0xbc5c6000}, {0xbc5c8000}, {0xbc5ca000}, {0xbc5cc000}, {0xbc5ce000}, {0xbc5d0000}, {0xbc5d2000}, {0xbc5d4000}, {0xbc5d6000}, {0xbc5d8000}, {0xbc5da000}, {0xbc5dc000}, {0xbc5de000}, {0xbc5e0000}, {0xbc5e2000}, {0xbc5e4000}, {0xbc5e6000}, {0xbc5e8000}, {0xbc5ea000}, {0xbc5ec000}, {0xbc5ee000}, {0xbc5f0000}, {0xbc5f2000}, {0xbc5f4000}, {0xbc5f6000}, {0xbc5f8000}, {0xbc5fa000}, {0xbc5fc000}, {0xbc5fe000}, {0xbc600000}, {0xbc602000}, {0xbc604000}, {0xbc606000}, {0xbc608000}, {0xbc60a000}, {0xbc60c000}, {0xbc60e000}, {0xbc610000}, {0xbc612000}, {0xbc614000}, {0xbc616000}, {0xbc618000}, {0xbc61a000}, {0xbc61c000}, {0xbc61e000}, {0xbc620000}, {0xbc622000}, {0xbc624000}, {0xbc626000}, {0xbc628000}, {0xbc62a000}, {0xbc62c000}, {0xbc62e000}, {0xbc630000}, {0xbc632000}, {0xbc634000}, {0xbc636000}, {0xbc638000}, {0xbc63a000}, {0xbc63c000}, {0xbc63e000}, {0xbc640000}, {0xbc642000}, {0xbc644000}, {0xbc646000}, {0xbc648000}, {0xbc64a000}, {0xbc64c000}, {0xbc64e000}, {0xbc650000}, {0xbc652000}, {0xbc654000}, {0xbc656000}, {0xbc658000}, {0xbc65a000}, {0xbc65c000}, {0xbc65e000}, {0xbc660000}, {0xbc662000}, {0xbc664000}, {0xbc666000}, {0xbc668000}, {0xbc66a000}, {0xbc66c000}, {0xbc66e000}, {0xbc670000}, {0xbc672000}, {0xbc674000}, {0xbc676000}, {0xbc678000}, {0xbc67a000}, {0xbc67c000}, {0xbc67e000}, {0xbc680000}, {0xbc682000}, {0xbc684000}, {0xbc686000}, {0xbc688000}, {0xbc68a000}, {0xbc68c000}, {0xbc68e000}, {0xbc690000}, {0xbc692000}, {0xbc694000}, {0xbc696000}, {0xbc698000}, {0xbc69a000}, {0xbc69c000}, {0xbc69e000}, {0xbc6a0000}, {0xbc6a2000}, {0xbc6a4000}, {0xbc6a6000}, {0xbc6a8000}, {0xbc6aa000}, {0xbc6ac000}, {0xbc6ae000}, {0xbc6b0000}, {0xbc6b2000}, {0xbc6b4000}, {0xbc6b6000}, {0xbc6b8000}, {0xbc6ba000}, {0xbc6bc000}, {0xbc6be000}, {0xbc6c0000}, {0xbc6c2000}, {0xbc6c4000}, {0xbc6c6000}, {0xbc6c8000}, {0xbc6ca000}, {0xbc6cc000}, {0xbc6ce000}, {0xbc6d0000}, {0xbc6d2000}, {0xbc6d4000}, {0xbc6d6000}, {0xbc6d8000}, {0xbc6da000}, {0xbc6dc000}, {0xbc6de000}, {0xbc6e0000}, {0xbc6e2000}, {0xbc6e4000}, {0xbc6e6000}, {0xbc6e8000}, {0xbc6ea000}, {0xbc6ec000}, {0xbc6ee000}, {0xbc6f0000}, {0xbc6f2000}, {0xbc6f4000}, {0xbc6f6000}, {0xbc6f8000}, {0xbc6fa000}, {0xbc6fc000}, {0xbc6fe000}, {0xbc700000}, {0xbc702000}, {0xbc704000}, {0xbc706000}, {0xbc708000}, {0xbc70a000}, {0xbc70c000}, {0xbc70e000}, {0xbc710000}, {0xbc712000}, {0xbc714000}, {0xbc716000}, {0xbc718000}, {0xbc71a000}, {0xbc71c000}, {0xbc71e000}, {0xbc720000}, {0xbc722000}, {0xbc724000}, {0xbc726000}, {0xbc728000}, {0xbc72a000}, {0xbc72c000}, {0xbc72e000}, {0xbc730000}, {0xbc732000}, {0xbc734000}, {0xbc736000}, {0xbc738000}, {0xbc73a000}, {0xbc73c000}, {0xbc73e000}, {0xbc740000}, {0xbc742000}, {0xbc744000}, {0xbc746000}, {0xbc748000}, {0xbc74a000}, {0xbc74c000}, {0xbc74e000}, {0xbc750000}, {0xbc752000}, {0xbc754000}, {0xbc756000}, {0xbc758000}, {0xbc75a000}, {0xbc75c000}, {0xbc75e000}, {0xbc760000}, {0xbc762000}, {0xbc764000}, {0xbc766000}, {0xbc768000}, {0xbc76a000}, {0xbc76c000}, {0xbc76e000}, {0xbc770000}, {0xbc772000}, {0xbc774000}, {0xbc776000}, {0xbc778000}, {0xbc77a000}, {0xbc77c000}, {0xbc77e000}, {0xbc780000}, {0xbc782000}, {0xbc784000}, {0xbc786000}, {0xbc788000}, {0xbc78a000}, {0xbc78c000}, {0xbc78e000}, {0xbc790000}, {0xbc792000}, {0xbc794000}, {0xbc796000}, {0xbc798000}, {0xbc79a000}, {0xbc79c000}, {0xbc79e000}, {0xbc7a0000}, {0xbc7a2000}, {0xbc7a4000}, {0xbc7a6000}, {0xbc7a8000}, {0xbc7aa000}, {0xbc7ac000}, {0xbc7ae000}, {0xbc7b0000}, {0xbc7b2000}, {0xbc7b4000}, {0xbc7b6000}, {0xbc7b8000}, {0xbc7ba000}, {0xbc7bc000}, {0xbc7be000}, {0xbc7c0000}, {0xbc7c2000}, {0xbc7c4000}, {0xbc7c6000}, {0xbc7c8000}, {0xbc7ca000}, {0xbc7cc000}, {0xbc7ce000}, {0xbc7d0000}, {0xbc7d2000}, {0xbc7d4000}, {0xbc7d6000}, {0xbc7d8000}, {0xbc7da000}, {0xbc7dc000}, {0xbc7de000}, {0xbc7e0000}, {0xbc7e2000}, {0xbc7e4000}, {0xbc7e6000}, {0xbc7e8000}, {0xbc7ea000}, {0xbc7ec000}, {0xbc7ee000}, {0xbc7f0000}, {0xbc7f2000}, {0xbc7f4000}, {0xbc7f6000}, {0xbc7f8000}, {0xbc7fa000}, {0xbc7fc000}, {0xbc7fe000}, {0xbc800000}, {0xbc802000}, {0xbc804000}, {0xbc806000}, {0xbc808000}, {0xbc80a000}, {0xbc80c000}, {0xbc80e000}, {0xbc810000}, {0xbc812000}, {0xbc814000}, {0xbc816000}, {0xbc818000}, {0xbc81a000}, {0xbc81c000}, {0xbc81e000}, {0xbc820000}, {0xbc822000}, {0xbc824000}, {0xbc826000}, {0xbc828000}, {0xbc82a000}, {0xbc82c000}, {0xbc82e000}, {0xbc830000}, {0xbc832000}, {0xbc834000}, {0xbc836000}, {0xbc838000}, {0xbc83a000}, {0xbc83c000}, {0xbc83e000}, {0xbc840000}, {0xbc842000}, {0xbc844000}, {0xbc846000}, {0xbc848000}, {0xbc84a000}, {0xbc84c000}, {0xbc84e000}, {0xbc850000}, {0xbc852000}, {0xbc854000}, {0xbc856000}, {0xbc858000}, {0xbc85a000}, {0xbc85c000}, {0xbc85e000}, {0xbc860000}, {0xbc862000}, {0xbc864000}, {0xbc866000}, {0xbc868000}, {0xbc86a000}, {0xbc86c000}, {0xbc86e000}, {0xbc870000}, {0xbc872000}, {0xbc874000}, {0xbc876000}, {0xbc878000}, {0xbc87a000}, {0xbc87c000}, {0xbc87e000}, {0xbc880000}, {0xbc882000}, {0xbc884000}, {0xbc886000}, {0xbc888000}, {0xbc88a000}, {0xbc88c000}, {0xbc88e000}, {0xbc890000}, {0xbc892000}, {0xbc894000}, {0xbc896000}, {0xbc898000}, {0xbc89a000}, {0xbc89c000}, {0xbc89e000}, {0xbc8a0000}, {0xbc8a2000}, {0xbc8a4000}, {0xbc8a6000}, {0xbc8a8000}, {0xbc8aa000}, {0xbc8ac000}, {0xbc8ae000}, {0xbc8b0000}, {0xbc8b2000}, {0xbc8b4000}, {0xbc8b6000}, {0xbc8b8000}, {0xbc8ba000}, {0xbc8bc000}, {0xbc8be000}, {0xbc8c0000}, {0xbc8c2000}, {0xbc8c4000}, {0xbc8c6000}, {0xbc8c8000}, {0xbc8ca000}, {0xbc8cc000}, {0xbc8ce000}, {0xbc8d0000}, {0xbc8d2000}, {0xbc8d4000}, {0xbc8d6000}, {0xbc8d8000}, {0xbc8da000}, {0xbc8dc000}, {0xbc8de000}, {0xbc8e0000}, {0xbc8e2000}, {0xbc8e4000}, {0xbc8e6000}, {0xbc8e8000}, {0xbc8ea000}, {0xbc8ec000}, {0xbc8ee000}, {0xbc8f0000}, {0xbc8f2000}, {0xbc8f4000}, {0xbc8f6000}, {0xbc8f8000}, {0xbc8fa000}, {0xbc8fc000}, {0xbc8fe000}, {0xbc900000}, {0xbc902000}, {0xbc904000}, {0xbc906000}, {0xbc908000}, {0xbc90a000}, {0xbc90c000}, {0xbc90e000}, {0xbc910000}, {0xbc912000}, {0xbc914000}, {0xbc916000}, {0xbc918000}, {0xbc91a000}, {0xbc91c000}, {0xbc91e000}, {0xbc920000}, {0xbc922000}, {0xbc924000}, {0xbc926000}, {0xbc928000}, {0xbc92a000}, {0xbc92c000}, {0xbc92e000}, {0xbc930000}, {0xbc932000}, {0xbc934000}, {0xbc936000}, {0xbc938000}, {0xbc93a000}, {0xbc93c000}, {0xbc93e000}, {0xbc940000}, {0xbc942000}, {0xbc944000}, {0xbc946000}, {0xbc948000}, {0xbc94a000}, {0xbc94c000}, {0xbc94e000}, {0xbc950000}, {0xbc952000}, {0xbc954000}, {0xbc956000}, {0xbc958000}, {0xbc95a000}, {0xbc95c000}, {0xbc95e000}, {0xbc960000}, {0xbc962000}, {0xbc964000}, {0xbc966000}, {0xbc968000}, {0xbc96a000}, {0xbc96c000}, {0xbc96e000}, {0xbc970000}, {0xbc972000}, {0xbc974000}, {0xbc976000}, {0xbc978000}, {0xbc97a000}, {0xbc97c000}, {0xbc97e000}, {0xbc980000}, {0xbc982000}, {0xbc984000}, {0xbc986000}, {0xbc988000}, {0xbc98a000}, {0xbc98c000}, {0xbc98e000}, {0xbc990000}, {0xbc992000}, {0xbc994000}, {0xbc996000}, {0xbc998000}, {0xbc99a000}, {0xbc99c000}, {0xbc99e000}, {0xbc9a0000}, {0xbc9a2000}, {0xbc9a4000}, {0xbc9a6000}, {0xbc9a8000}, {0xbc9aa000}, {0xbc9ac000}, {0xbc9ae000}, {0xbc9b0000}, {0xbc9b2000}, {0xbc9b4000}, {0xbc9b6000}, {0xbc9b8000}, {0xbc9ba000}, {0xbc9bc000}, {0xbc9be000}, {0xbc9c0000}, {0xbc9c2000}, {0xbc9c4000}, {0xbc9c6000}, {0xbc9c8000}, {0xbc9ca000}, {0xbc9cc000}, {0xbc9ce000}, {0xbc9d0000}, {0xbc9d2000}, {0xbc9d4000}, {0xbc9d6000}, {0xbc9d8000}, {0xbc9da000}, {0xbc9dc000}, {0xbc9de000}, {0xbc9e0000}, {0xbc9e2000}, {0xbc9e4000}, {0xbc9e6000}, {0xbc9e8000}, {0xbc9ea000}, {0xbc9ec000}, {0xbc9ee000}, {0xbc9f0000}, {0xbc9f2000}, {0xbc9f4000}, {0xbc9f6000}, {0xbc9f8000}, {0xbc9fa000}, {0xbc9fc000}, {0xbc9fe000}, {0xbca00000}, {0xbca02000}, {0xbca04000}, {0xbca06000}, {0xbca08000}, {0xbca0a000}, {0xbca0c000}, {0xbca0e000}, {0xbca10000}, {0xbca12000}, {0xbca14000}, {0xbca16000}, {0xbca18000}, {0xbca1a000}, {0xbca1c000}, {0xbca1e000}, {0xbca20000}, {0xbca22000}, {0xbca24000}, {0xbca26000}, {0xbca28000}, {0xbca2a000}, {0xbca2c000}, {0xbca2e000}, {0xbca30000}, {0xbca32000}, {0xbca34000}, {0xbca36000}, {0xbca38000}, {0xbca3a000}, {0xbca3c000}, {0xbca3e000}, {0xbca40000}, {0xbca42000}, {0xbca44000}, {0xbca46000}, {0xbca48000}, {0xbca4a000}, {0xbca4c000}, {0xbca4e000}, {0xbca50000}, {0xbca52000}, {0xbca54000}, {0xbca56000}, {0xbca58000}, {0xbca5a000}, {0xbca5c000}, {0xbca5e000}, {0xbca60000}, {0xbca62000}, {0xbca64000}, {0xbca66000}, {0xbca68000}, {0xbca6a000}, {0xbca6c000}, {0xbca6e000}, {0xbca70000}, {0xbca72000}, {0xbca74000}, {0xbca76000}, {0xbca78000}, {0xbca7a000}, {0xbca7c000}, {0xbca7e000}, {0xbca80000}, {0xbca82000}, {0xbca84000}, {0xbca86000}, {0xbca88000}, {0xbca8a000}, {0xbca8c000}, {0xbca8e000}, {0xbca90000}, {0xbca92000}, {0xbca94000}, {0xbca96000}, {0xbca98000}, {0xbca9a000}, {0xbca9c000}, {0xbca9e000}, {0xbcaa0000}, {0xbcaa2000}, {0xbcaa4000}, {0xbcaa6000}, {0xbcaa8000}, {0xbcaaa000}, {0xbcaac000}, {0xbcaae000}, {0xbcab0000}, {0xbcab2000}, {0xbcab4000}, {0xbcab6000}, {0xbcab8000}, {0xbcaba000}, {0xbcabc000}, {0xbcabe000}, {0xbcac0000}, {0xbcac2000}, {0xbcac4000}, {0xbcac6000}, {0xbcac8000}, {0xbcaca000}, {0xbcacc000}, {0xbcace000}, {0xbcad0000}, {0xbcad2000}, {0xbcad4000}, {0xbcad6000}, {0xbcad8000}, {0xbcada000}, {0xbcadc000}, {0xbcade000}, {0xbcae0000}, {0xbcae2000}, {0xbcae4000}, {0xbcae6000}, {0xbcae8000}, {0xbcaea000}, {0xbcaec000}, {0xbcaee000}, {0xbcaf0000}, {0xbcaf2000}, {0xbcaf4000}, {0xbcaf6000}, {0xbcaf8000}, {0xbcafa000}, {0xbcafc000}, {0xbcafe000}, {0xbcb00000}, {0xbcb02000}, {0xbcb04000}, {0xbcb06000}, {0xbcb08000}, {0xbcb0a000}, {0xbcb0c000}, {0xbcb0e000}, {0xbcb10000}, {0xbcb12000}, {0xbcb14000}, {0xbcb16000}, {0xbcb18000}, {0xbcb1a000}, {0xbcb1c000}, {0xbcb1e000}, {0xbcb20000}, {0xbcb22000}, {0xbcb24000}, {0xbcb26000}, {0xbcb28000}, {0xbcb2a000}, {0xbcb2c000}, {0xbcb2e000}, {0xbcb30000}, {0xbcb32000}, {0xbcb34000}, {0xbcb36000}, {0xbcb38000}, {0xbcb3a000}, {0xbcb3c000}, {0xbcb3e000}, {0xbcb40000}, {0xbcb42000}, {0xbcb44000}, {0xbcb46000}, {0xbcb48000}, {0xbcb4a000}, {0xbcb4c000}, {0xbcb4e000}, {0xbcb50000}, {0xbcb52000}, {0xbcb54000}, {0xbcb56000}, {0xbcb58000}, {0xbcb5a000}, {0xbcb5c000}, {0xbcb5e000}, {0xbcb60000}, {0xbcb62000}, {0xbcb64000}, {0xbcb66000}, {0xbcb68000}, {0xbcb6a000}, {0xbcb6c000}, {0xbcb6e000}, {0xbcb70000}, {0xbcb72000}, {0xbcb74000}, {0xbcb76000}, {0xbcb78000}, {0xbcb7a000}, {0xbcb7c000}, {0xbcb7e000}, {0xbcb80000}, {0xbcb82000}, {0xbcb84000}, {0xbcb86000}, {0xbcb88000}, {0xbcb8a000}, {0xbcb8c000}, {0xbcb8e000}, {0xbcb90000}, {0xbcb92000}, {0xbcb94000}, {0xbcb96000}, {0xbcb98000}, {0xbcb9a000}, {0xbcb9c000}, {0xbcb9e000}, {0xbcba0000}, {0xbcba2000}, {0xbcba4000}, {0xbcba6000}, {0xbcba8000}, {0xbcbaa000}, {0xbcbac000}, {0xbcbae000}, {0xbcbb0000}, {0xbcbb2000}, {0xbcbb4000}, {0xbcbb6000}, {0xbcbb8000}, {0xbcbba000}, {0xbcbbc000}, {0xbcbbe000}, {0xbcbc0000}, {0xbcbc2000}, {0xbcbc4000}, {0xbcbc6000}, {0xbcbc8000}, {0xbcbca000}, {0xbcbcc000}, {0xbcbce000}, {0xbcbd0000}, {0xbcbd2000}, {0xbcbd4000}, {0xbcbd6000}, {0xbcbd8000}, {0xbcbda000}, {0xbcbdc000}, {0xbcbde000}, {0xbcbe0000}, {0xbcbe2000}, {0xbcbe4000}, {0xbcbe6000}, {0xbcbe8000}, {0xbcbea000}, {0xbcbec000}, {0xbcbee000}, {0xbcbf0000}, {0xbcbf2000}, {0xbcbf4000}, {0xbcbf6000}, {0xbcbf8000}, {0xbcbfa000}, {0xbcbfc000}, {0xbcbfe000}, {0xbcc00000}, {0xbcc02000}, {0xbcc04000}, {0xbcc06000}, {0xbcc08000}, {0xbcc0a000}, {0xbcc0c000}, {0xbcc0e000}, {0xbcc10000}, {0xbcc12000}, {0xbcc14000}, {0xbcc16000}, {0xbcc18000}, {0xbcc1a000}, {0xbcc1c000}, {0xbcc1e000}, {0xbcc20000}, {0xbcc22000}, {0xbcc24000}, {0xbcc26000}, {0xbcc28000}, {0xbcc2a000}, {0xbcc2c000}, {0xbcc2e000}, {0xbcc30000}, {0xbcc32000}, {0xbcc34000}, {0xbcc36000}, {0xbcc38000}, {0xbcc3a000}, {0xbcc3c000}, {0xbcc3e000}, {0xbcc40000}, {0xbcc42000}, {0xbcc44000}, {0xbcc46000}, {0xbcc48000}, {0xbcc4a000}, {0xbcc4c000}, {0xbcc4e000}, {0xbcc50000}, {0xbcc52000}, {0xbcc54000}, {0xbcc56000}, {0xbcc58000}, {0xbcc5a000}, {0xbcc5c000}, {0xbcc5e000}, {0xbcc60000}, {0xbcc62000}, {0xbcc64000}, {0xbcc66000}, {0xbcc68000}, {0xbcc6a000}, {0xbcc6c000}, {0xbcc6e000}, {0xbcc70000}, {0xbcc72000}, {0xbcc74000}, {0xbcc76000}, {0xbcc78000}, {0xbcc7a000}, {0xbcc7c000}, {0xbcc7e000}, {0xbcc80000}, {0xbcc82000}, {0xbcc84000}, {0xbcc86000}, {0xbcc88000}, {0xbcc8a000}, {0xbcc8c000}, {0xbcc8e000}, {0xbcc90000}, {0xbcc92000}, {0xbcc94000}, {0xbcc96000}, {0xbcc98000}, {0xbcc9a000}, {0xbcc9c000}, {0xbcc9e000}, {0xbcca0000}, {0xbcca2000}, {0xbcca4000}, {0xbcca6000}, {0xbcca8000}, {0xbccaa000}, {0xbccac000}, {0xbccae000}, {0xbccb0000}, {0xbccb2000}, {0xbccb4000}, {0xbccb6000}, {0xbccb8000}, {0xbccba000}, {0xbccbc000}, {0xbccbe000}, {0xbccc0000}, {0xbccc2000}, {0xbccc4000}, {0xbccc6000}, {0xbccc8000}, {0xbccca000}, {0xbcccc000}, {0xbccce000}, {0xbccd0000}, {0xbccd2000}, {0xbccd4000}, {0xbccd6000}, {0xbccd8000}, {0xbccda000}, {0xbccdc000}, {0xbccde000}, {0xbcce0000}, {0xbcce2000}, {0xbcce4000}, {0xbcce6000}, {0xbcce8000}, {0xbccea000}, {0xbccec000}, {0xbccee000}, {0xbccf0000}, {0xbccf2000}, {0xbccf4000}, {0xbccf6000}, {0xbccf8000}, {0xbccfa000}, {0xbccfc000}, {0xbccfe000}, {0xbcd00000}, {0xbcd02000}, {0xbcd04000}, {0xbcd06000}, {0xbcd08000}, {0xbcd0a000}, {0xbcd0c000}, {0xbcd0e000}, {0xbcd10000}, {0xbcd12000}, {0xbcd14000}, {0xbcd16000}, {0xbcd18000}, {0xbcd1a000}, {0xbcd1c000}, {0xbcd1e000}, {0xbcd20000}, {0xbcd22000}, {0xbcd24000}, {0xbcd26000}, {0xbcd28000}, {0xbcd2a000}, {0xbcd2c000}, {0xbcd2e000}, {0xbcd30000}, {0xbcd32000}, {0xbcd34000}, {0xbcd36000}, {0xbcd38000}, {0xbcd3a000}, {0xbcd3c000}, {0xbcd3e000}, {0xbcd40000}, {0xbcd42000}, {0xbcd44000}, {0xbcd46000}, {0xbcd48000}, {0xbcd4a000}, {0xbcd4c000}, {0xbcd4e000}, {0xbcd50000}, {0xbcd52000}, {0xbcd54000}, {0xbcd56000}, {0xbcd58000}, {0xbcd5a000}, {0xbcd5c000}, {0xbcd5e000}, {0xbcd60000}, {0xbcd62000}, {0xbcd64000}, {0xbcd66000}, {0xbcd68000}, {0xbcd6a000}, {0xbcd6c000}, {0xbcd6e000}, {0xbcd70000}, {0xbcd72000}, {0xbcd74000}, {0xbcd76000}, {0xbcd78000}, {0xbcd7a000}, {0xbcd7c000}, {0xbcd7e000}, {0xbcd80000}, {0xbcd82000}, {0xbcd84000}, {0xbcd86000}, {0xbcd88000}, {0xbcd8a000}, {0xbcd8c000}, {0xbcd8e000}, {0xbcd90000}, {0xbcd92000}, {0xbcd94000}, {0xbcd96000}, {0xbcd98000}, {0xbcd9a000}, {0xbcd9c000}, {0xbcd9e000}, {0xbcda0000}, {0xbcda2000}, {0xbcda4000}, {0xbcda6000}, {0xbcda8000}, {0xbcdaa000}, {0xbcdac000}, {0xbcdae000}, {0xbcdb0000}, {0xbcdb2000}, {0xbcdb4000}, {0xbcdb6000}, {0xbcdb8000}, {0xbcdba000}, {0xbcdbc000}, {0xbcdbe000}, {0xbcdc0000}, {0xbcdc2000}, {0xbcdc4000}, {0xbcdc6000}, {0xbcdc8000}, {0xbcdca000}, {0xbcdcc000}, {0xbcdce000}, {0xbcdd0000}, {0xbcdd2000}, {0xbcdd4000}, {0xbcdd6000}, {0xbcdd8000}, {0xbcdda000}, {0xbcddc000}, {0xbcdde000}, {0xbcde0000}, {0xbcde2000}, {0xbcde4000}, {0xbcde6000}, {0xbcde8000}, {0xbcdea000}, {0xbcdec000}, {0xbcdee000}, {0xbcdf0000}, {0xbcdf2000}, {0xbcdf4000}, {0xbcdf6000}, {0xbcdf8000}, {0xbcdfa000}, {0xbcdfc000}, {0xbcdfe000}, {0xbce00000}, {0xbce02000}, {0xbce04000}, {0xbce06000}, {0xbce08000}, {0xbce0a000}, {0xbce0c000}, {0xbce0e000}, {0xbce10000}, {0xbce12000}, {0xbce14000}, {0xbce16000}, {0xbce18000}, {0xbce1a000}, {0xbce1c000}, {0xbce1e000}, {0xbce20000}, {0xbce22000}, {0xbce24000}, {0xbce26000}, {0xbce28000}, {0xbce2a000}, {0xbce2c000}, {0xbce2e000}, {0xbce30000}, {0xbce32000}, {0xbce34000}, {0xbce36000}, {0xbce38000}, {0xbce3a000}, {0xbce3c000}, {0xbce3e000}, {0xbce40000}, {0xbce42000}, {0xbce44000}, {0xbce46000}, {0xbce48000}, {0xbce4a000}, {0xbce4c000}, {0xbce4e000}, {0xbce50000}, {0xbce52000}, {0xbce54000}, {0xbce56000}, {0xbce58000}, {0xbce5a000}, {0xbce5c000}, {0xbce5e000}, {0xbce60000}, {0xbce62000}, {0xbce64000}, {0xbce66000}, {0xbce68000}, {0xbce6a000}, {0xbce6c000}, {0xbce6e000}, {0xbce70000}, {0xbce72000}, {0xbce74000}, {0xbce76000}, {0xbce78000}, {0xbce7a000}, {0xbce7c000}, {0xbce7e000}, {0xbce80000}, {0xbce82000}, {0xbce84000}, {0xbce86000}, {0xbce88000}, {0xbce8a000}, {0xbce8c000}, {0xbce8e000}, {0xbce90000}, {0xbce92000}, {0xbce94000}, {0xbce96000}, {0xbce98000}, {0xbce9a000}, {0xbce9c000}, {0xbce9e000}, {0xbcea0000}, {0xbcea2000}, {0xbcea4000}, {0xbcea6000}, {0xbcea8000}, {0xbceaa000}, {0xbceac000}, {0xbceae000}, {0xbceb0000}, {0xbceb2000}, {0xbceb4000}, {0xbceb6000}, {0xbceb8000}, {0xbceba000}, {0xbcebc000}, {0xbcebe000}, {0xbcec0000}, {0xbcec2000}, {0xbcec4000}, {0xbcec6000}, {0xbcec8000}, {0xbceca000}, {0xbcecc000}, {0xbcece000}, {0xbced0000}, {0xbced2000}, {0xbced4000}, {0xbced6000}, {0xbced8000}, {0xbceda000}, {0xbcedc000}, {0xbcede000}, {0xbcee0000}, {0xbcee2000}, {0xbcee4000}, {0xbcee6000}, {0xbcee8000}, {0xbceea000}, {0xbceec000}, {0xbceee000}, {0xbcef0000}, {0xbcef2000}, {0xbcef4000}, {0xbcef6000}, {0xbcef8000}, {0xbcefa000}, {0xbcefc000}, {0xbcefe000}, {0xbcf00000}, {0xbcf02000}, {0xbcf04000}, {0xbcf06000}, {0xbcf08000}, {0xbcf0a000}, {0xbcf0c000}, {0xbcf0e000}, {0xbcf10000}, {0xbcf12000}, {0xbcf14000}, {0xbcf16000}, {0xbcf18000}, {0xbcf1a000}, {0xbcf1c000}, {0xbcf1e000}, {0xbcf20000}, {0xbcf22000}, {0xbcf24000}, {0xbcf26000}, {0xbcf28000}, {0xbcf2a000}, {0xbcf2c000}, {0xbcf2e000}, {0xbcf30000}, {0xbcf32000}, {0xbcf34000}, {0xbcf36000}, {0xbcf38000}, {0xbcf3a000}, {0xbcf3c000}, {0xbcf3e000}, {0xbcf40000}, {0xbcf42000}, {0xbcf44000}, {0xbcf46000}, {0xbcf48000}, {0xbcf4a000}, {0xbcf4c000}, {0xbcf4e000}, {0xbcf50000}, {0xbcf52000}, {0xbcf54000}, {0xbcf56000}, {0xbcf58000}, {0xbcf5a000}, {0xbcf5c000}, {0xbcf5e000}, {0xbcf60000}, {0xbcf62000}, {0xbcf64000}, {0xbcf66000}, {0xbcf68000}, {0xbcf6a000}, {0xbcf6c000}, {0xbcf6e000}, {0xbcf70000}, {0xbcf72000}, {0xbcf74000}, {0xbcf76000}, {0xbcf78000}, {0xbcf7a000}, {0xbcf7c000}, {0xbcf7e000}, {0xbcf80000}, {0xbcf82000}, {0xbcf84000}, {0xbcf86000}, {0xbcf88000}, {0xbcf8a000}, {0xbcf8c000}, {0xbcf8e000}, {0xbcf90000}, {0xbcf92000}, {0xbcf94000}, {0xbcf96000}, {0xbcf98000}, {0xbcf9a000}, {0xbcf9c000}, {0xbcf9e000}, {0xbcfa0000}, {0xbcfa2000}, {0xbcfa4000}, {0xbcfa6000}, {0xbcfa8000}, {0xbcfaa000}, {0xbcfac000}, {0xbcfae000}, {0xbcfb0000}, {0xbcfb2000}, {0xbcfb4000}, {0xbcfb6000}, {0xbcfb8000}, {0xbcfba000}, {0xbcfbc000}, {0xbcfbe000}, {0xbcfc0000}, {0xbcfc2000}, {0xbcfc4000}, {0xbcfc6000}, {0xbcfc8000}, {0xbcfca000}, {0xbcfcc000}, {0xbcfce000}, {0xbcfd0000}, {0xbcfd2000}, {0xbcfd4000}, {0xbcfd6000}, {0xbcfd8000}, {0xbcfda000}, {0xbcfdc000}, {0xbcfde000}, {0xbcfe0000}, {0xbcfe2000}, {0xbcfe4000}, {0xbcfe6000}, {0xbcfe8000}, {0xbcfea000}, {0xbcfec000}, {0xbcfee000}, {0xbcff0000}, {0xbcff2000}, {0xbcff4000}, {0xbcff6000}, {0xbcff8000}, {0xbcffa000}, {0xbcffc000}, {0xbcffe000}, {0xbd000000}, {0xbd002000}, {0xbd004000}, {0xbd006000}, {0xbd008000}, {0xbd00a000}, {0xbd00c000}, {0xbd00e000}, {0xbd010000}, {0xbd012000}, {0xbd014000}, {0xbd016000}, {0xbd018000}, {0xbd01a000}, {0xbd01c000}, {0xbd01e000}, {0xbd020000}, {0xbd022000}, {0xbd024000}, {0xbd026000}, {0xbd028000}, {0xbd02a000}, {0xbd02c000}, {0xbd02e000}, {0xbd030000}, {0xbd032000}, {0xbd034000}, {0xbd036000}, {0xbd038000}, {0xbd03a000}, {0xbd03c000}, {0xbd03e000}, {0xbd040000}, {0xbd042000}, {0xbd044000}, {0xbd046000}, {0xbd048000}, {0xbd04a000}, {0xbd04c000}, {0xbd04e000}, {0xbd050000}, {0xbd052000}, {0xbd054000}, {0xbd056000}, {0xbd058000}, {0xbd05a000}, {0xbd05c000}, {0xbd05e000}, {0xbd060000}, {0xbd062000}, {0xbd064000}, {0xbd066000}, {0xbd068000}, {0xbd06a000}, {0xbd06c000}, {0xbd06e000}, {0xbd070000}, {0xbd072000}, {0xbd074000}, {0xbd076000}, {0xbd078000}, {0xbd07a000}, {0xbd07c000}, {0xbd07e000}, {0xbd080000}, {0xbd082000}, {0xbd084000}, {0xbd086000}, {0xbd088000}, {0xbd08a000}, {0xbd08c000}, {0xbd08e000}, {0xbd090000}, {0xbd092000}, {0xbd094000}, {0xbd096000}, {0xbd098000}, {0xbd09a000}, {0xbd09c000}, {0xbd09e000}, {0xbd0a0000}, {0xbd0a2000}, {0xbd0a4000}, {0xbd0a6000}, {0xbd0a8000}, {0xbd0aa000}, {0xbd0ac000}, {0xbd0ae000}, {0xbd0b0000}, {0xbd0b2000}, {0xbd0b4000}, {0xbd0b6000}, {0xbd0b8000}, {0xbd0ba000}, {0xbd0bc000}, {0xbd0be000}, {0xbd0c0000}, {0xbd0c2000}, {0xbd0c4000}, {0xbd0c6000}, {0xbd0c8000}, {0xbd0ca000}, {0xbd0cc000}, {0xbd0ce000}, {0xbd0d0000}, {0xbd0d2000}, {0xbd0d4000}, {0xbd0d6000}, {0xbd0d8000}, {0xbd0da000}, {0xbd0dc000}, {0xbd0de000}, {0xbd0e0000}, {0xbd0e2000}, {0xbd0e4000}, {0xbd0e6000}, {0xbd0e8000}, {0xbd0ea000}, {0xbd0ec000}, {0xbd0ee000}, {0xbd0f0000}, {0xbd0f2000}, {0xbd0f4000}, {0xbd0f6000}, {0xbd0f8000}, {0xbd0fa000}, {0xbd0fc000}, {0xbd0fe000}, {0xbd100000}, {0xbd102000}, {0xbd104000}, {0xbd106000}, {0xbd108000}, {0xbd10a000}, {0xbd10c000}, {0xbd10e000}, {0xbd110000}, {0xbd112000}, {0xbd114000}, {0xbd116000}, {0xbd118000}, {0xbd11a000}, {0xbd11c000}, {0xbd11e000}, {0xbd120000}, {0xbd122000}, {0xbd124000}, {0xbd126000}, {0xbd128000}, {0xbd12a000}, {0xbd12c000}, {0xbd12e000}, {0xbd130000}, {0xbd132000}, {0xbd134000}, {0xbd136000}, {0xbd138000}, {0xbd13a000}, {0xbd13c000}, {0xbd13e000}, {0xbd140000}, {0xbd142000}, {0xbd144000}, {0xbd146000}, {0xbd148000}, {0xbd14a000}, {0xbd14c000}, {0xbd14e000}, {0xbd150000}, {0xbd152000}, {0xbd154000}, {0xbd156000}, {0xbd158000}, {0xbd15a000}, {0xbd15c000}, {0xbd15e000}, {0xbd160000}, {0xbd162000}, {0xbd164000}, {0xbd166000}, {0xbd168000}, {0xbd16a000}, {0xbd16c000}, {0xbd16e000}, {0xbd170000}, {0xbd172000}, {0xbd174000}, {0xbd176000}, {0xbd178000}, {0xbd17a000}, {0xbd17c000}, {0xbd17e000}, {0xbd180000}, {0xbd182000}, {0xbd184000}, {0xbd186000}, {0xbd188000}, {0xbd18a000}, {0xbd18c000}, {0xbd18e000}, {0xbd190000}, {0xbd192000}, {0xbd194000}, {0xbd196000}, {0xbd198000}, {0xbd19a000}, {0xbd19c000}, {0xbd19e000}, {0xbd1a0000}, {0xbd1a2000}, {0xbd1a4000}, {0xbd1a6000}, {0xbd1a8000}, {0xbd1aa000}, {0xbd1ac000}, {0xbd1ae000}, {0xbd1b0000}, {0xbd1b2000}, {0xbd1b4000}, {0xbd1b6000}, {0xbd1b8000}, {0xbd1ba000}, {0xbd1bc000}, {0xbd1be000}, {0xbd1c0000}, {0xbd1c2000}, {0xbd1c4000}, {0xbd1c6000}, {0xbd1c8000}, {0xbd1ca000}, {0xbd1cc000}, {0xbd1ce000}, {0xbd1d0000}, {0xbd1d2000}, {0xbd1d4000}, {0xbd1d6000}, {0xbd1d8000}, {0xbd1da000}, {0xbd1dc000}, {0xbd1de000}, {0xbd1e0000}, {0xbd1e2000}, {0xbd1e4000}, {0xbd1e6000}, {0xbd1e8000}, {0xbd1ea000}, {0xbd1ec000}, {0xbd1ee000}, {0xbd1f0000}, {0xbd1f2000}, {0xbd1f4000}, {0xbd1f6000}, {0xbd1f8000}, {0xbd1fa000}, {0xbd1fc000}, {0xbd1fe000}, {0xbd200000}, {0xbd202000}, {0xbd204000}, {0xbd206000}, {0xbd208000}, {0xbd20a000}, {0xbd20c000}, {0xbd20e000}, {0xbd210000}, {0xbd212000}, {0xbd214000}, {0xbd216000}, {0xbd218000}, {0xbd21a000}, {0xbd21c000}, {0xbd21e000}, {0xbd220000}, {0xbd222000}, {0xbd224000}, {0xbd226000}, {0xbd228000}, {0xbd22a000}, {0xbd22c000}, {0xbd22e000}, {0xbd230000}, {0xbd232000}, {0xbd234000}, {0xbd236000}, {0xbd238000}, {0xbd23a000}, {0xbd23c000}, {0xbd23e000}, {0xbd240000}, {0xbd242000}, {0xbd244000}, {0xbd246000}, {0xbd248000}, {0xbd24a000}, {0xbd24c000}, {0xbd24e000}, {0xbd250000}, {0xbd252000}, {0xbd254000}, {0xbd256000}, {0xbd258000}, {0xbd25a000}, {0xbd25c000}, {0xbd25e000}, {0xbd260000}, {0xbd262000}, {0xbd264000}, {0xbd266000}, {0xbd268000}, {0xbd26a000}, {0xbd26c000}, {0xbd26e000}, {0xbd270000}, {0xbd272000}, {0xbd274000}, {0xbd276000}, {0xbd278000}, {0xbd27a000}, {0xbd27c000}, {0xbd27e000}, {0xbd280000}, {0xbd282000}, {0xbd284000}, {0xbd286000}, {0xbd288000}, {0xbd28a000}, {0xbd28c000}, {0xbd28e000}, {0xbd290000}, {0xbd292000}, {0xbd294000}, {0xbd296000}, {0xbd298000}, {0xbd29a000}, {0xbd29c000}, {0xbd29e000}, {0xbd2a0000}, {0xbd2a2000}, {0xbd2a4000}, {0xbd2a6000}, {0xbd2a8000}, {0xbd2aa000}, {0xbd2ac000}, {0xbd2ae000}, {0xbd2b0000}, {0xbd2b2000}, {0xbd2b4000}, {0xbd2b6000}, {0xbd2b8000}, {0xbd2ba000}, {0xbd2bc000}, {0xbd2be000}, {0xbd2c0000}, {0xbd2c2000}, {0xbd2c4000}, {0xbd2c6000}, {0xbd2c8000}, {0xbd2ca000}, {0xbd2cc000}, {0xbd2ce000}, {0xbd2d0000}, {0xbd2d2000}, {0xbd2d4000}, {0xbd2d6000}, {0xbd2d8000}, {0xbd2da000}, {0xbd2dc000}, {0xbd2de000}, {0xbd2e0000}, {0xbd2e2000}, {0xbd2e4000}, {0xbd2e6000}, {0xbd2e8000}, {0xbd2ea000}, {0xbd2ec000}, {0xbd2ee000}, {0xbd2f0000}, {0xbd2f2000}, {0xbd2f4000}, {0xbd2f6000}, {0xbd2f8000}, {0xbd2fa000}, {0xbd2fc000}, {0xbd2fe000}, {0xbd300000}, {0xbd302000}, {0xbd304000}, {0xbd306000}, {0xbd308000}, {0xbd30a000}, {0xbd30c000}, {0xbd30e000}, {0xbd310000}, {0xbd312000}, {0xbd314000}, {0xbd316000}, {0xbd318000}, {0xbd31a000}, {0xbd31c000}, {0xbd31e000}, {0xbd320000}, {0xbd322000}, {0xbd324000}, {0xbd326000}, {0xbd328000}, {0xbd32a000}, {0xbd32c000}, {0xbd32e000}, {0xbd330000}, {0xbd332000}, {0xbd334000}, {0xbd336000}, {0xbd338000}, {0xbd33a000}, {0xbd33c000}, {0xbd33e000}, {0xbd340000}, {0xbd342000}, {0xbd344000}, {0xbd346000}, {0xbd348000}, {0xbd34a000}, {0xbd34c000}, {0xbd34e000}, {0xbd350000}, {0xbd352000}, {0xbd354000}, {0xbd356000}, {0xbd358000}, {0xbd35a000}, {0xbd35c000}, {0xbd35e000}, {0xbd360000}, {0xbd362000}, {0xbd364000}, {0xbd366000}, {0xbd368000}, {0xbd36a000}, {0xbd36c000}, {0xbd36e000}, {0xbd370000}, {0xbd372000}, {0xbd374000}, {0xbd376000}, {0xbd378000}, {0xbd37a000}, {0xbd37c000}, {0xbd37e000}, {0xbd380000}, {0xbd382000}, {0xbd384000}, {0xbd386000}, {0xbd388000}, {0xbd38a000}, {0xbd38c000}, {0xbd38e000}, {0xbd390000}, {0xbd392000}, {0xbd394000}, {0xbd396000}, {0xbd398000}, {0xbd39a000}, {0xbd39c000}, {0xbd39e000}, {0xbd3a0000}, {0xbd3a2000}, {0xbd3a4000}, {0xbd3a6000}, {0xbd3a8000}, {0xbd3aa000}, {0xbd3ac000}, {0xbd3ae000}, {0xbd3b0000}, {0xbd3b2000}, {0xbd3b4000}, {0xbd3b6000}, {0xbd3b8000}, {0xbd3ba000}, {0xbd3bc000}, {0xbd3be000}, {0xbd3c0000}, {0xbd3c2000}, {0xbd3c4000}, {0xbd3c6000}, {0xbd3c8000}, {0xbd3ca000}, {0xbd3cc000}, {0xbd3ce000}, {0xbd3d0000}, {0xbd3d2000}, {0xbd3d4000}, {0xbd3d6000}, {0xbd3d8000}, {0xbd3da000}, {0xbd3dc000}, {0xbd3de000}, {0xbd3e0000}, {0xbd3e2000}, {0xbd3e4000}, {0xbd3e6000}, {0xbd3e8000}, {0xbd3ea000}, {0xbd3ec000}, {0xbd3ee000}, {0xbd3f0000}, {0xbd3f2000}, {0xbd3f4000}, {0xbd3f6000}, {0xbd3f8000}, {0xbd3fa000}, {0xbd3fc000}, {0xbd3fe000}, {0xbd400000}, {0xbd402000}, {0xbd404000}, {0xbd406000}, {0xbd408000}, {0xbd40a000}, {0xbd40c000}, {0xbd40e000}, {0xbd410000}, {0xbd412000}, {0xbd414000}, {0xbd416000}, {0xbd418000}, {0xbd41a000}, {0xbd41c000}, {0xbd41e000}, {0xbd420000}, {0xbd422000}, {0xbd424000}, {0xbd426000}, {0xbd428000}, {0xbd42a000}, {0xbd42c000}, {0xbd42e000}, {0xbd430000}, {0xbd432000}, {0xbd434000}, {0xbd436000}, {0xbd438000}, {0xbd43a000}, {0xbd43c000}, {0xbd43e000}, {0xbd440000}, {0xbd442000}, {0xbd444000}, {0xbd446000}, {0xbd448000}, {0xbd44a000}, {0xbd44c000}, {0xbd44e000}, {0xbd450000}, {0xbd452000}, {0xbd454000}, {0xbd456000}, {0xbd458000}, {0xbd45a000}, {0xbd45c000}, {0xbd45e000}, {0xbd460000}, {0xbd462000}, {0xbd464000}, {0xbd466000}, {0xbd468000}, {0xbd46a000}, {0xbd46c000}, {0xbd46e000}, {0xbd470000}, {0xbd472000}, {0xbd474000}, {0xbd476000}, {0xbd478000}, {0xbd47a000}, {0xbd47c000}, {0xbd47e000}, {0xbd480000}, {0xbd482000}, {0xbd484000}, {0xbd486000}, {0xbd488000}, {0xbd48a000}, {0xbd48c000}, {0xbd48e000}, {0xbd490000}, {0xbd492000}, {0xbd494000}, {0xbd496000}, {0xbd498000}, {0xbd49a000}, {0xbd49c000}, {0xbd49e000}, {0xbd4a0000}, {0xbd4a2000}, {0xbd4a4000}, {0xbd4a6000}, {0xbd4a8000}, {0xbd4aa000}, {0xbd4ac000}, {0xbd4ae000}, {0xbd4b0000}, {0xbd4b2000}, {0xbd4b4000}, {0xbd4b6000}, {0xbd4b8000}, {0xbd4ba000}, {0xbd4bc000}, {0xbd4be000}, {0xbd4c0000}, {0xbd4c2000}, {0xbd4c4000}, {0xbd4c6000}, {0xbd4c8000}, {0xbd4ca000}, {0xbd4cc000}, {0xbd4ce000}, {0xbd4d0000}, {0xbd4d2000}, {0xbd4d4000}, {0xbd4d6000}, {0xbd4d8000}, {0xbd4da000}, {0xbd4dc000}, {0xbd4de000}, {0xbd4e0000}, {0xbd4e2000}, {0xbd4e4000}, {0xbd4e6000}, {0xbd4e8000}, {0xbd4ea000}, {0xbd4ec000}, {0xbd4ee000}, {0xbd4f0000}, {0xbd4f2000}, {0xbd4f4000}, {0xbd4f6000}, {0xbd4f8000}, {0xbd4fa000}, {0xbd4fc000}, {0xbd4fe000}, {0xbd500000}, {0xbd502000}, {0xbd504000}, {0xbd506000}, {0xbd508000}, {0xbd50a000}, {0xbd50c000}, {0xbd50e000}, {0xbd510000}, {0xbd512000}, {0xbd514000}, {0xbd516000}, {0xbd518000}, {0xbd51a000}, {0xbd51c000}, {0xbd51e000}, {0xbd520000}, {0xbd522000}, {0xbd524000}, {0xbd526000}, {0xbd528000}, {0xbd52a000}, {0xbd52c000}, {0xbd52e000}, {0xbd530000}, {0xbd532000}, {0xbd534000}, {0xbd536000}, {0xbd538000}, {0xbd53a000}, {0xbd53c000}, {0xbd53e000}, {0xbd540000}, {0xbd542000}, {0xbd544000}, {0xbd546000}, {0xbd548000}, {0xbd54a000}, {0xbd54c000}, {0xbd54e000}, {0xbd550000}, {0xbd552000}, {0xbd554000}, {0xbd556000}, {0xbd558000}, {0xbd55a000}, {0xbd55c000}, {0xbd55e000}, {0xbd560000}, {0xbd562000}, {0xbd564000}, {0xbd566000}, {0xbd568000}, {0xbd56a000}, {0xbd56c000}, {0xbd56e000}, {0xbd570000}, {0xbd572000}, {0xbd574000}, {0xbd576000}, {0xbd578000}, {0xbd57a000}, {0xbd57c000}, {0xbd57e000}, {0xbd580000}, {0xbd582000}, {0xbd584000}, {0xbd586000}, {0xbd588000}, {0xbd58a000}, {0xbd58c000}, {0xbd58e000}, {0xbd590000}, {0xbd592000}, {0xbd594000}, {0xbd596000}, {0xbd598000}, {0xbd59a000}, {0xbd59c000}, {0xbd59e000}, {0xbd5a0000}, {0xbd5a2000}, {0xbd5a4000}, {0xbd5a6000}, {0xbd5a8000}, {0xbd5aa000}, {0xbd5ac000}, {0xbd5ae000}, {0xbd5b0000}, {0xbd5b2000}, {0xbd5b4000}, {0xbd5b6000}, {0xbd5b8000}, {0xbd5ba000}, {0xbd5bc000}, {0xbd5be000}, {0xbd5c0000}, {0xbd5c2000}, {0xbd5c4000}, {0xbd5c6000}, {0xbd5c8000}, {0xbd5ca000}, {0xbd5cc000}, {0xbd5ce000}, {0xbd5d0000}, {0xbd5d2000}, {0xbd5d4000}, {0xbd5d6000}, {0xbd5d8000}, {0xbd5da000}, {0xbd5dc000}, {0xbd5de000}, {0xbd5e0000}, {0xbd5e2000}, {0xbd5e4000}, {0xbd5e6000}, {0xbd5e8000}, {0xbd5ea000}, {0xbd5ec000}, {0xbd5ee000}, {0xbd5f0000}, {0xbd5f2000}, {0xbd5f4000}, {0xbd5f6000}, {0xbd5f8000}, {0xbd5fa000}, {0xbd5fc000}, {0xbd5fe000}, {0xbd600000}, {0xbd602000}, {0xbd604000}, {0xbd606000}, {0xbd608000}, {0xbd60a000}, {0xbd60c000}, {0xbd60e000}, {0xbd610000}, {0xbd612000}, {0xbd614000}, {0xbd616000}, {0xbd618000}, {0xbd61a000}, {0xbd61c000}, {0xbd61e000}, {0xbd620000}, {0xbd622000}, {0xbd624000}, {0xbd626000}, {0xbd628000}, {0xbd62a000}, {0xbd62c000}, {0xbd62e000}, {0xbd630000}, {0xbd632000}, {0xbd634000}, {0xbd636000}, {0xbd638000}, {0xbd63a000}, {0xbd63c000}, {0xbd63e000}, {0xbd640000}, {0xbd642000}, {0xbd644000}, {0xbd646000}, {0xbd648000}, {0xbd64a000}, {0xbd64c000}, {0xbd64e000}, {0xbd650000}, {0xbd652000}, {0xbd654000}, {0xbd656000}, {0xbd658000}, {0xbd65a000}, {0xbd65c000}, {0xbd65e000}, {0xbd660000}, {0xbd662000}, {0xbd664000}, {0xbd666000}, {0xbd668000}, {0xbd66a000}, {0xbd66c000}, {0xbd66e000}, {0xbd670000}, {0xbd672000}, {0xbd674000}, {0xbd676000}, {0xbd678000}, {0xbd67a000}, {0xbd67c000}, {0xbd67e000}, {0xbd680000}, {0xbd682000}, {0xbd684000}, {0xbd686000}, {0xbd688000}, {0xbd68a000}, {0xbd68c000}, {0xbd68e000}, {0xbd690000}, {0xbd692000}, {0xbd694000}, {0xbd696000}, {0xbd698000}, {0xbd69a000}, {0xbd69c000}, {0xbd69e000}, {0xbd6a0000}, {0xbd6a2000}, {0xbd6a4000}, {0xbd6a6000}, {0xbd6a8000}, {0xbd6aa000}, {0xbd6ac000}, {0xbd6ae000}, {0xbd6b0000}, {0xbd6b2000}, {0xbd6b4000}, {0xbd6b6000}, {0xbd6b8000}, {0xbd6ba000}, {0xbd6bc000}, {0xbd6be000}, {0xbd6c0000}, {0xbd6c2000}, {0xbd6c4000}, {0xbd6c6000}, {0xbd6c8000}, {0xbd6ca000}, {0xbd6cc000}, {0xbd6ce000}, {0xbd6d0000}, {0xbd6d2000}, {0xbd6d4000}, {0xbd6d6000}, {0xbd6d8000}, {0xbd6da000}, {0xbd6dc000}, {0xbd6de000}, {0xbd6e0000}, {0xbd6e2000}, {0xbd6e4000}, {0xbd6e6000}, {0xbd6e8000}, {0xbd6ea000}, {0xbd6ec000}, {0xbd6ee000}, {0xbd6f0000}, {0xbd6f2000}, {0xbd6f4000}, {0xbd6f6000}, {0xbd6f8000}, {0xbd6fa000}, {0xbd6fc000}, {0xbd6fe000}, {0xbd700000}, {0xbd702000}, {0xbd704000}, {0xbd706000}, {0xbd708000}, {0xbd70a000}, {0xbd70c000}, {0xbd70e000}, {0xbd710000}, {0xbd712000}, {0xbd714000}, {0xbd716000}, {0xbd718000}, {0xbd71a000}, {0xbd71c000}, {0xbd71e000}, {0xbd720000}, {0xbd722000}, {0xbd724000}, {0xbd726000}, {0xbd728000}, {0xbd72a000}, {0xbd72c000}, {0xbd72e000}, {0xbd730000}, {0xbd732000}, {0xbd734000}, {0xbd736000}, {0xbd738000}, {0xbd73a000}, {0xbd73c000}, {0xbd73e000}, {0xbd740000}, {0xbd742000}, {0xbd744000}, {0xbd746000}, {0xbd748000}, {0xbd74a000}, {0xbd74c000}, {0xbd74e000}, {0xbd750000}, {0xbd752000}, {0xbd754000}, {0xbd756000}, {0xbd758000}, {0xbd75a000}, {0xbd75c000}, {0xbd75e000}, {0xbd760000}, {0xbd762000}, {0xbd764000}, {0xbd766000}, {0xbd768000}, {0xbd76a000}, {0xbd76c000}, {0xbd76e000}, {0xbd770000}, {0xbd772000}, {0xbd774000}, {0xbd776000}, {0xbd778000}, {0xbd77a000}, {0xbd77c000}, {0xbd77e000}, {0xbd780000}, {0xbd782000}, {0xbd784000}, {0xbd786000}, {0xbd788000}, {0xbd78a000}, {0xbd78c000}, {0xbd78e000}, {0xbd790000}, {0xbd792000}, {0xbd794000}, {0xbd796000}, {0xbd798000}, {0xbd79a000}, {0xbd79c000}, {0xbd79e000}, {0xbd7a0000}, {0xbd7a2000}, {0xbd7a4000}, {0xbd7a6000}, {0xbd7a8000}, {0xbd7aa000}, {0xbd7ac000}, {0xbd7ae000}, {0xbd7b0000}, {0xbd7b2000}, {0xbd7b4000}, {0xbd7b6000}, {0xbd7b8000}, {0xbd7ba000}, {0xbd7bc000}, {0xbd7be000}, {0xbd7c0000}, {0xbd7c2000}, {0xbd7c4000}, {0xbd7c6000}, {0xbd7c8000}, {0xbd7ca000}, {0xbd7cc000}, {0xbd7ce000}, {0xbd7d0000}, {0xbd7d2000}, {0xbd7d4000}, {0xbd7d6000}, {0xbd7d8000}, {0xbd7da000}, {0xbd7dc000}, {0xbd7de000}, {0xbd7e0000}, {0xbd7e2000}, {0xbd7e4000}, {0xbd7e6000}, {0xbd7e8000}, {0xbd7ea000}, {0xbd7ec000}, {0xbd7ee000}, {0xbd7f0000}, {0xbd7f2000}, {0xbd7f4000}, {0xbd7f6000}, {0xbd7f8000}, {0xbd7fa000}, {0xbd7fc000}, {0xbd7fe000}, {0xbd800000}, {0xbd802000}, {0xbd804000}, {0xbd806000}, {0xbd808000}, {0xbd80a000}, {0xbd80c000}, {0xbd80e000}, {0xbd810000}, {0xbd812000}, {0xbd814000}, {0xbd816000}, {0xbd818000}, {0xbd81a000}, {0xbd81c000}, {0xbd81e000}, {0xbd820000}, {0xbd822000}, {0xbd824000}, {0xbd826000}, {0xbd828000}, {0xbd82a000}, {0xbd82c000}, {0xbd82e000}, {0xbd830000}, {0xbd832000}, {0xbd834000}, {0xbd836000}, {0xbd838000}, {0xbd83a000}, {0xbd83c000}, {0xbd83e000}, {0xbd840000}, {0xbd842000}, {0xbd844000}, {0xbd846000}, {0xbd848000}, {0xbd84a000}, {0xbd84c000}, {0xbd84e000}, {0xbd850000}, {0xbd852000}, {0xbd854000}, {0xbd856000}, {0xbd858000}, {0xbd85a000}, {0xbd85c000}, {0xbd85e000}, {0xbd860000}, {0xbd862000}, {0xbd864000}, {0xbd866000}, {0xbd868000}, {0xbd86a000}, {0xbd86c000}, {0xbd86e000}, {0xbd870000}, {0xbd872000}, {0xbd874000}, {0xbd876000}, {0xbd878000}, {0xbd87a000}, {0xbd87c000}, {0xbd87e000}, {0xbd880000}, {0xbd882000}, {0xbd884000}, {0xbd886000}, {0xbd888000}, {0xbd88a000}, {0xbd88c000}, {0xbd88e000}, {0xbd890000}, {0xbd892000}, {0xbd894000}, {0xbd896000}, {0xbd898000}, {0xbd89a000}, {0xbd89c000}, {0xbd89e000}, {0xbd8a0000}, {0xbd8a2000}, {0xbd8a4000}, {0xbd8a6000}, {0xbd8a8000}, {0xbd8aa000}, {0xbd8ac000}, {0xbd8ae000}, {0xbd8b0000}, {0xbd8b2000}, {0xbd8b4000}, {0xbd8b6000}, {0xbd8b8000}, {0xbd8ba000}, {0xbd8bc000}, {0xbd8be000}, {0xbd8c0000}, {0xbd8c2000}, {0xbd8c4000}, {0xbd8c6000}, {0xbd8c8000}, {0xbd8ca000}, {0xbd8cc000}, {0xbd8ce000}, {0xbd8d0000}, {0xbd8d2000}, {0xbd8d4000}, {0xbd8d6000}, {0xbd8d8000}, {0xbd8da000}, {0xbd8dc000}, {0xbd8de000}, {0xbd8e0000}, {0xbd8e2000}, {0xbd8e4000}, {0xbd8e6000}, {0xbd8e8000}, {0xbd8ea000}, {0xbd8ec000}, {0xbd8ee000}, {0xbd8f0000}, {0xbd8f2000}, {0xbd8f4000}, {0xbd8f6000}, {0xbd8f8000}, {0xbd8fa000}, {0xbd8fc000}, {0xbd8fe000}, {0xbd900000}, {0xbd902000}, {0xbd904000}, {0xbd906000}, {0xbd908000}, {0xbd90a000}, {0xbd90c000}, {0xbd90e000}, {0xbd910000}, {0xbd912000}, {0xbd914000}, {0xbd916000}, {0xbd918000}, {0xbd91a000}, {0xbd91c000}, {0xbd91e000}, {0xbd920000}, {0xbd922000}, {0xbd924000}, {0xbd926000}, {0xbd928000}, {0xbd92a000}, {0xbd92c000}, {0xbd92e000}, {0xbd930000}, {0xbd932000}, {0xbd934000}, {0xbd936000}, {0xbd938000}, {0xbd93a000}, {0xbd93c000}, {0xbd93e000}, {0xbd940000}, {0xbd942000}, {0xbd944000}, {0xbd946000}, {0xbd948000}, {0xbd94a000}, {0xbd94c000}, {0xbd94e000}, {0xbd950000}, {0xbd952000}, {0xbd954000}, {0xbd956000}, {0xbd958000}, {0xbd95a000}, {0xbd95c000}, {0xbd95e000}, {0xbd960000}, {0xbd962000}, {0xbd964000}, {0xbd966000}, {0xbd968000}, {0xbd96a000}, {0xbd96c000}, {0xbd96e000}, {0xbd970000}, {0xbd972000}, {0xbd974000}, {0xbd976000}, {0xbd978000}, {0xbd97a000}, {0xbd97c000}, {0xbd97e000}, {0xbd980000}, {0xbd982000}, {0xbd984000}, {0xbd986000}, {0xbd988000}, {0xbd98a000}, {0xbd98c000}, {0xbd98e000}, {0xbd990000}, {0xbd992000}, {0xbd994000}, {0xbd996000}, {0xbd998000}, {0xbd99a000}, {0xbd99c000}, {0xbd99e000}, {0xbd9a0000}, {0xbd9a2000}, {0xbd9a4000}, {0xbd9a6000}, {0xbd9a8000}, {0xbd9aa000}, {0xbd9ac000}, {0xbd9ae000}, {0xbd9b0000}, {0xbd9b2000}, {0xbd9b4000}, {0xbd9b6000}, {0xbd9b8000}, {0xbd9ba000}, {0xbd9bc000}, {0xbd9be000}, {0xbd9c0000}, {0xbd9c2000}, {0xbd9c4000}, {0xbd9c6000}, {0xbd9c8000}, {0xbd9ca000}, {0xbd9cc000}, {0xbd9ce000}, {0xbd9d0000}, {0xbd9d2000}, {0xbd9d4000}, {0xbd9d6000}, {0xbd9d8000}, {0xbd9da000}, {0xbd9dc000}, {0xbd9de000}, {0xbd9e0000}, {0xbd9e2000}, {0xbd9e4000}, {0xbd9e6000}, {0xbd9e8000}, {0xbd9ea000}, {0xbd9ec000}, {0xbd9ee000}, {0xbd9f0000}, {0xbd9f2000}, {0xbd9f4000}, {0xbd9f6000}, {0xbd9f8000}, {0xbd9fa000}, {0xbd9fc000}, {0xbd9fe000}, {0xbda00000}, {0xbda02000}, {0xbda04000}, {0xbda06000}, {0xbda08000}, {0xbda0a000}, {0xbda0c000}, {0xbda0e000}, {0xbda10000}, {0xbda12000}, {0xbda14000}, {0xbda16000}, {0xbda18000}, {0xbda1a000}, {0xbda1c000}, {0xbda1e000}, {0xbda20000}, {0xbda22000}, {0xbda24000}, {0xbda26000}, {0xbda28000}, {0xbda2a000}, {0xbda2c000}, {0xbda2e000}, {0xbda30000}, {0xbda32000}, {0xbda34000}, {0xbda36000}, {0xbda38000}, {0xbda3a000}, {0xbda3c000}, {0xbda3e000}, {0xbda40000}, {0xbda42000}, {0xbda44000}, {0xbda46000}, {0xbda48000}, {0xbda4a000}, {0xbda4c000}, {0xbda4e000}, {0xbda50000}, {0xbda52000}, {0xbda54000}, {0xbda56000}, {0xbda58000}, {0xbda5a000}, {0xbda5c000}, {0xbda5e000}, {0xbda60000}, {0xbda62000}, {0xbda64000}, {0xbda66000}, {0xbda68000}, {0xbda6a000}, {0xbda6c000}, {0xbda6e000}, {0xbda70000}, {0xbda72000}, {0xbda74000}, {0xbda76000}, {0xbda78000}, {0xbda7a000}, {0xbda7c000}, {0xbda7e000}, {0xbda80000}, {0xbda82000}, {0xbda84000}, {0xbda86000}, {0xbda88000}, {0xbda8a000}, {0xbda8c000}, {0xbda8e000}, {0xbda90000}, {0xbda92000}, {0xbda94000}, {0xbda96000}, {0xbda98000}, {0xbda9a000}, {0xbda9c000}, {0xbda9e000}, {0xbdaa0000}, {0xbdaa2000}, {0xbdaa4000}, {0xbdaa6000}, {0xbdaa8000}, {0xbdaaa000}, {0xbdaac000}, {0xbdaae000}, {0xbdab0000}, {0xbdab2000}, {0xbdab4000}, {0xbdab6000}, {0xbdab8000}, {0xbdaba000}, {0xbdabc000}, {0xbdabe000}, {0xbdac0000}, {0xbdac2000}, {0xbdac4000}, {0xbdac6000}, {0xbdac8000}, {0xbdaca000}, {0xbdacc000}, {0xbdace000}, {0xbdad0000}, {0xbdad2000}, {0xbdad4000}, {0xbdad6000}, {0xbdad8000}, {0xbdada000}, {0xbdadc000}, {0xbdade000}, {0xbdae0000}, {0xbdae2000}, {0xbdae4000}, {0xbdae6000}, {0xbdae8000}, {0xbdaea000}, {0xbdaec000}, {0xbdaee000}, {0xbdaf0000}, {0xbdaf2000}, {0xbdaf4000}, {0xbdaf6000}, {0xbdaf8000}, {0xbdafa000}, {0xbdafc000}, {0xbdafe000}, {0xbdb00000}, {0xbdb02000}, {0xbdb04000}, {0xbdb06000}, {0xbdb08000}, {0xbdb0a000}, {0xbdb0c000}, {0xbdb0e000}, {0xbdb10000}, {0xbdb12000}, {0xbdb14000}, {0xbdb16000}, {0xbdb18000}, {0xbdb1a000}, {0xbdb1c000}, {0xbdb1e000}, {0xbdb20000}, {0xbdb22000}, {0xbdb24000}, {0xbdb26000}, {0xbdb28000}, {0xbdb2a000}, {0xbdb2c000}, {0xbdb2e000}, {0xbdb30000}, {0xbdb32000}, {0xbdb34000}, {0xbdb36000}, {0xbdb38000}, {0xbdb3a000}, {0xbdb3c000}, {0xbdb3e000}, {0xbdb40000}, {0xbdb42000}, {0xbdb44000}, {0xbdb46000}, {0xbdb48000}, {0xbdb4a000}, {0xbdb4c000}, {0xbdb4e000}, {0xbdb50000}, {0xbdb52000}, {0xbdb54000}, {0xbdb56000}, {0xbdb58000}, {0xbdb5a000}, {0xbdb5c000}, {0xbdb5e000}, {0xbdb60000}, {0xbdb62000}, {0xbdb64000}, {0xbdb66000}, {0xbdb68000}, {0xbdb6a000}, {0xbdb6c000}, {0xbdb6e000}, {0xbdb70000}, {0xbdb72000}, {0xbdb74000}, {0xbdb76000}, {0xbdb78000}, {0xbdb7a000}, {0xbdb7c000}, {0xbdb7e000}, {0xbdb80000}, {0xbdb82000}, {0xbdb84000}, {0xbdb86000}, {0xbdb88000}, {0xbdb8a000}, {0xbdb8c000}, {0xbdb8e000}, {0xbdb90000}, {0xbdb92000}, {0xbdb94000}, {0xbdb96000}, {0xbdb98000}, {0xbdb9a000}, {0xbdb9c000}, {0xbdb9e000}, {0xbdba0000}, {0xbdba2000}, {0xbdba4000}, {0xbdba6000}, {0xbdba8000}, {0xbdbaa000}, {0xbdbac000}, {0xbdbae000}, {0xbdbb0000}, {0xbdbb2000}, {0xbdbb4000}, {0xbdbb6000}, {0xbdbb8000}, {0xbdbba000}, {0xbdbbc000}, {0xbdbbe000}, {0xbdbc0000}, {0xbdbc2000}, {0xbdbc4000}, {0xbdbc6000}, {0xbdbc8000}, {0xbdbca000}, {0xbdbcc000}, {0xbdbce000}, {0xbdbd0000}, {0xbdbd2000}, {0xbdbd4000}, {0xbdbd6000}, {0xbdbd8000}, {0xbdbda000}, {0xbdbdc000}, {0xbdbde000}, {0xbdbe0000}, {0xbdbe2000}, {0xbdbe4000}, {0xbdbe6000}, {0xbdbe8000}, {0xbdbea000}, {0xbdbec000}, {0xbdbee000}, {0xbdbf0000}, {0xbdbf2000}, {0xbdbf4000}, {0xbdbf6000}, {0xbdbf8000}, {0xbdbfa000}, {0xbdbfc000}, {0xbdbfe000}, {0xbdc00000}, {0xbdc02000}, {0xbdc04000}, {0xbdc06000}, {0xbdc08000}, {0xbdc0a000}, {0xbdc0c000}, {0xbdc0e000}, {0xbdc10000}, {0xbdc12000}, {0xbdc14000}, {0xbdc16000}, {0xbdc18000}, {0xbdc1a000}, {0xbdc1c000}, {0xbdc1e000}, {0xbdc20000}, {0xbdc22000}, {0xbdc24000}, {0xbdc26000}, {0xbdc28000}, {0xbdc2a000}, {0xbdc2c000}, {0xbdc2e000}, {0xbdc30000}, {0xbdc32000}, {0xbdc34000}, {0xbdc36000}, {0xbdc38000}, {0xbdc3a000}, {0xbdc3c000}, {0xbdc3e000}, {0xbdc40000}, {0xbdc42000}, {0xbdc44000}, {0xbdc46000}, {0xbdc48000}, {0xbdc4a000}, {0xbdc4c000}, {0xbdc4e000}, {0xbdc50000}, {0xbdc52000}, {0xbdc54000}, {0xbdc56000}, {0xbdc58000}, {0xbdc5a000}, {0xbdc5c000}, {0xbdc5e000}, {0xbdc60000}, {0xbdc62000}, {0xbdc64000}, {0xbdc66000}, {0xbdc68000}, {0xbdc6a000}, {0xbdc6c000}, {0xbdc6e000}, {0xbdc70000}, {0xbdc72000}, {0xbdc74000}, {0xbdc76000}, {0xbdc78000}, {0xbdc7a000}, {0xbdc7c000}, {0xbdc7e000}, {0xbdc80000}, {0xbdc82000}, {0xbdc84000}, {0xbdc86000}, {0xbdc88000}, {0xbdc8a000}, {0xbdc8c000}, {0xbdc8e000}, {0xbdc90000}, {0xbdc92000}, {0xbdc94000}, {0xbdc96000}, {0xbdc98000}, {0xbdc9a000}, {0xbdc9c000}, {0xbdc9e000}, {0xbdca0000}, {0xbdca2000}, {0xbdca4000}, {0xbdca6000}, {0xbdca8000}, {0xbdcaa000}, {0xbdcac000}, {0xbdcae000}, {0xbdcb0000}, {0xbdcb2000}, {0xbdcb4000}, {0xbdcb6000}, {0xbdcb8000}, {0xbdcba000}, {0xbdcbc000}, {0xbdcbe000}, {0xbdcc0000}, {0xbdcc2000}, {0xbdcc4000}, {0xbdcc6000}, {0xbdcc8000}, {0xbdcca000}, {0xbdccc000}, {0xbdcce000}, {0xbdcd0000}, {0xbdcd2000}, {0xbdcd4000}, {0xbdcd6000}, {0xbdcd8000}, {0xbdcda000}, {0xbdcdc000}, {0xbdcde000}, {0xbdce0000}, {0xbdce2000}, {0xbdce4000}, {0xbdce6000}, {0xbdce8000}, {0xbdcea000}, {0xbdcec000}, {0xbdcee000}, {0xbdcf0000}, {0xbdcf2000}, {0xbdcf4000}, {0xbdcf6000}, {0xbdcf8000}, {0xbdcfa000}, {0xbdcfc000}, {0xbdcfe000}, {0xbdd00000}, {0xbdd02000}, {0xbdd04000}, {0xbdd06000}, {0xbdd08000}, {0xbdd0a000}, {0xbdd0c000}, {0xbdd0e000}, {0xbdd10000}, {0xbdd12000}, {0xbdd14000}, {0xbdd16000}, {0xbdd18000}, {0xbdd1a000}, {0xbdd1c000}, {0xbdd1e000}, {0xbdd20000}, {0xbdd22000}, {0xbdd24000}, {0xbdd26000}, {0xbdd28000}, {0xbdd2a000}, {0xbdd2c000}, {0xbdd2e000}, {0xbdd30000}, {0xbdd32000}, {0xbdd34000}, {0xbdd36000}, {0xbdd38000}, {0xbdd3a000}, {0xbdd3c000}, {0xbdd3e000}, {0xbdd40000}, {0xbdd42000}, {0xbdd44000}, {0xbdd46000}, {0xbdd48000}, {0xbdd4a000}, {0xbdd4c000}, {0xbdd4e000}, {0xbdd50000}, {0xbdd52000}, {0xbdd54000}, {0xbdd56000}, {0xbdd58000}, {0xbdd5a000}, {0xbdd5c000}, {0xbdd5e000}, {0xbdd60000}, {0xbdd62000}, {0xbdd64000}, {0xbdd66000}, {0xbdd68000}, {0xbdd6a000}, {0xbdd6c000}, {0xbdd6e000}, {0xbdd70000}, {0xbdd72000}, {0xbdd74000}, {0xbdd76000}, {0xbdd78000}, {0xbdd7a000}, {0xbdd7c000}, {0xbdd7e000}, {0xbdd80000}, {0xbdd82000}, {0xbdd84000}, {0xbdd86000}, {0xbdd88000}, {0xbdd8a000}, {0xbdd8c000}, {0xbdd8e000}, {0xbdd90000}, {0xbdd92000}, {0xbdd94000}, {0xbdd96000}, {0xbdd98000}, {0xbdd9a000}, {0xbdd9c000}, {0xbdd9e000}, {0xbdda0000}, {0xbdda2000}, {0xbdda4000}, {0xbdda6000}, {0xbdda8000}, {0xbddaa000}, {0xbddac000}, {0xbddae000}, {0xbddb0000}, {0xbddb2000}, {0xbddb4000}, {0xbddb6000}, {0xbddb8000}, {0xbddba000}, {0xbddbc000}, {0xbddbe000}, {0xbddc0000}, {0xbddc2000}, {0xbddc4000}, {0xbddc6000}, {0xbddc8000}, {0xbddca000}, {0xbddcc000}, {0xbddce000}, {0xbddd0000}, {0xbddd2000}, {0xbddd4000}, {0xbddd6000}, {0xbddd8000}, {0xbddda000}, {0xbdddc000}, {0xbddde000}, {0xbdde0000}, {0xbdde2000}, {0xbdde4000}, {0xbdde6000}, {0xbdde8000}, {0xbddea000}, {0xbddec000}, {0xbddee000}, {0xbddf0000}, {0xbddf2000}, {0xbddf4000}, {0xbddf6000}, {0xbddf8000}, {0xbddfa000}, {0xbddfc000}, {0xbddfe000}, {0xbde00000}, {0xbde02000}, {0xbde04000}, {0xbde06000}, {0xbde08000}, {0xbde0a000}, {0xbde0c000}, {0xbde0e000}, {0xbde10000}, {0xbde12000}, {0xbde14000}, {0xbde16000}, {0xbde18000}, {0xbde1a000}, {0xbde1c000}, {0xbde1e000}, {0xbde20000}, {0xbde22000}, {0xbde24000}, {0xbde26000}, {0xbde28000}, {0xbde2a000}, {0xbde2c000}, {0xbde2e000}, {0xbde30000}, {0xbde32000}, {0xbde34000}, {0xbde36000}, {0xbde38000}, {0xbde3a000}, {0xbde3c000}, {0xbde3e000}, {0xbde40000}, {0xbde42000}, {0xbde44000}, {0xbde46000}, {0xbde48000}, {0xbde4a000}, {0xbde4c000}, {0xbde4e000}, {0xbde50000}, {0xbde52000}, {0xbde54000}, {0xbde56000}, {0xbde58000}, {0xbde5a000}, {0xbde5c000}, {0xbde5e000}, {0xbde60000}, {0xbde62000}, {0xbde64000}, {0xbde66000}, {0xbde68000}, {0xbde6a000}, {0xbde6c000}, {0xbde6e000}, {0xbde70000}, {0xbde72000}, {0xbde74000}, {0xbde76000}, {0xbde78000}, {0xbde7a000}, {0xbde7c000}, {0xbde7e000}, {0xbde80000}, {0xbde82000}, {0xbde84000}, {0xbde86000}, {0xbde88000}, {0xbde8a000}, {0xbde8c000}, {0xbde8e000}, {0xbde90000}, {0xbde92000}, {0xbde94000}, {0xbde96000}, {0xbde98000}, {0xbde9a000}, {0xbde9c000}, {0xbde9e000}, {0xbdea0000}, {0xbdea2000}, {0xbdea4000}, {0xbdea6000}, {0xbdea8000}, {0xbdeaa000}, {0xbdeac000}, {0xbdeae000}, {0xbdeb0000}, {0xbdeb2000}, {0xbdeb4000}, {0xbdeb6000}, {0xbdeb8000}, {0xbdeba000}, {0xbdebc000}, {0xbdebe000}, {0xbdec0000}, {0xbdec2000}, {0xbdec4000}, {0xbdec6000}, {0xbdec8000}, {0xbdeca000}, {0xbdecc000}, {0xbdece000}, {0xbded0000}, {0xbded2000}, {0xbded4000}, {0xbded6000}, {0xbded8000}, {0xbdeda000}, {0xbdedc000}, {0xbdede000}, {0xbdee0000}, {0xbdee2000}, {0xbdee4000}, {0xbdee6000}, {0xbdee8000}, {0xbdeea000}, {0xbdeec000}, {0xbdeee000}, {0xbdef0000}, {0xbdef2000}, {0xbdef4000}, {0xbdef6000}, {0xbdef8000}, {0xbdefa000}, {0xbdefc000}, {0xbdefe000}, {0xbdf00000}, {0xbdf02000}, {0xbdf04000}, {0xbdf06000}, {0xbdf08000}, {0xbdf0a000}, {0xbdf0c000}, {0xbdf0e000}, {0xbdf10000}, {0xbdf12000}, {0xbdf14000}, {0xbdf16000}, {0xbdf18000}, {0xbdf1a000}, {0xbdf1c000}, {0xbdf1e000}, {0xbdf20000}, {0xbdf22000}, {0xbdf24000}, {0xbdf26000}, {0xbdf28000}, {0xbdf2a000}, {0xbdf2c000}, {0xbdf2e000}, {0xbdf30000}, {0xbdf32000}, {0xbdf34000}, {0xbdf36000}, {0xbdf38000}, {0xbdf3a000}, {0xbdf3c000}, {0xbdf3e000}, {0xbdf40000}, {0xbdf42000}, {0xbdf44000}, {0xbdf46000}, {0xbdf48000}, {0xbdf4a000}, {0xbdf4c000}, {0xbdf4e000}, {0xbdf50000}, {0xbdf52000}, {0xbdf54000}, {0xbdf56000}, {0xbdf58000}, {0xbdf5a000}, {0xbdf5c000}, {0xbdf5e000}, {0xbdf60000}, {0xbdf62000}, {0xbdf64000}, {0xbdf66000}, {0xbdf68000}, {0xbdf6a000}, {0xbdf6c000}, {0xbdf6e000}, {0xbdf70000}, {0xbdf72000}, {0xbdf74000}, {0xbdf76000}, {0xbdf78000}, {0xbdf7a000}, {0xbdf7c000}, {0xbdf7e000}, {0xbdf80000}, {0xbdf82000}, {0xbdf84000}, {0xbdf86000}, {0xbdf88000}, {0xbdf8a000}, {0xbdf8c000}, {0xbdf8e000}, {0xbdf90000}, {0xbdf92000}, {0xbdf94000}, {0xbdf96000}, {0xbdf98000}, {0xbdf9a000}, {0xbdf9c000}, {0xbdf9e000}, {0xbdfa0000}, {0xbdfa2000}, {0xbdfa4000}, {0xbdfa6000}, {0xbdfa8000}, {0xbdfaa000}, {0xbdfac000}, {0xbdfae000}, {0xbdfb0000}, {0xbdfb2000}, {0xbdfb4000}, {0xbdfb6000}, {0xbdfb8000}, {0xbdfba000}, {0xbdfbc000}, {0xbdfbe000}, {0xbdfc0000}, {0xbdfc2000}, {0xbdfc4000}, {0xbdfc6000}, {0xbdfc8000}, {0xbdfca000}, {0xbdfcc000}, {0xbdfce000}, {0xbdfd0000}, {0xbdfd2000}, {0xbdfd4000}, {0xbdfd6000}, {0xbdfd8000}, {0xbdfda000}, {0xbdfdc000}, {0xbdfde000}, {0xbdfe0000}, {0xbdfe2000}, {0xbdfe4000}, {0xbdfe6000}, {0xbdfe8000}, {0xbdfea000}, {0xbdfec000}, {0xbdfee000}, {0xbdff0000}, {0xbdff2000}, {0xbdff4000}, {0xbdff6000}, {0xbdff8000}, {0xbdffa000}, {0xbdffc000}, {0xbdffe000}, {0xbe000000}, {0xbe002000}, {0xbe004000}, {0xbe006000}, {0xbe008000}, {0xbe00a000}, {0xbe00c000}, {0xbe00e000}, {0xbe010000}, {0xbe012000}, {0xbe014000}, {0xbe016000}, {0xbe018000}, {0xbe01a000}, {0xbe01c000}, {0xbe01e000}, {0xbe020000}, {0xbe022000}, {0xbe024000}, {0xbe026000}, {0xbe028000}, {0xbe02a000}, {0xbe02c000}, {0xbe02e000}, {0xbe030000}, {0xbe032000}, {0xbe034000}, {0xbe036000}, {0xbe038000}, {0xbe03a000}, {0xbe03c000}, {0xbe03e000}, {0xbe040000}, {0xbe042000}, {0xbe044000}, {0xbe046000}, {0xbe048000}, {0xbe04a000}, {0xbe04c000}, {0xbe04e000}, {0xbe050000}, {0xbe052000}, {0xbe054000}, {0xbe056000}, {0xbe058000}, {0xbe05a000}, {0xbe05c000}, {0xbe05e000}, {0xbe060000}, {0xbe062000}, {0xbe064000}, {0xbe066000}, {0xbe068000}, {0xbe06a000}, {0xbe06c000}, {0xbe06e000}, {0xbe070000}, {0xbe072000}, {0xbe074000}, {0xbe076000}, {0xbe078000}, {0xbe07a000}, {0xbe07c000}, {0xbe07e000}, {0xbe080000}, {0xbe082000}, {0xbe084000}, {0xbe086000}, {0xbe088000}, {0xbe08a000}, {0xbe08c000}, {0xbe08e000}, {0xbe090000}, {0xbe092000}, {0xbe094000}, {0xbe096000}, {0xbe098000}, {0xbe09a000}, {0xbe09c000}, {0xbe09e000}, {0xbe0a0000}, {0xbe0a2000}, {0xbe0a4000}, {0xbe0a6000}, {0xbe0a8000}, {0xbe0aa000}, {0xbe0ac000}, {0xbe0ae000}, {0xbe0b0000}, {0xbe0b2000}, {0xbe0b4000}, {0xbe0b6000}, {0xbe0b8000}, {0xbe0ba000}, {0xbe0bc000}, {0xbe0be000}, {0xbe0c0000}, {0xbe0c2000}, {0xbe0c4000}, {0xbe0c6000}, {0xbe0c8000}, {0xbe0ca000}, {0xbe0cc000}, {0xbe0ce000}, {0xbe0d0000}, {0xbe0d2000}, {0xbe0d4000}, {0xbe0d6000}, {0xbe0d8000}, {0xbe0da000}, {0xbe0dc000}, {0xbe0de000}, {0xbe0e0000}, {0xbe0e2000}, {0xbe0e4000}, {0xbe0e6000}, {0xbe0e8000}, {0xbe0ea000}, {0xbe0ec000}, {0xbe0ee000}, {0xbe0f0000}, {0xbe0f2000}, {0xbe0f4000}, {0xbe0f6000}, {0xbe0f8000}, {0xbe0fa000}, {0xbe0fc000}, {0xbe0fe000}, {0xbe100000}, {0xbe102000}, {0xbe104000}, {0xbe106000}, {0xbe108000}, {0xbe10a000}, {0xbe10c000}, {0xbe10e000}, {0xbe110000}, {0xbe112000}, {0xbe114000}, {0xbe116000}, {0xbe118000}, {0xbe11a000}, {0xbe11c000}, {0xbe11e000}, {0xbe120000}, {0xbe122000}, {0xbe124000}, {0xbe126000}, {0xbe128000}, {0xbe12a000}, {0xbe12c000}, {0xbe12e000}, {0xbe130000}, {0xbe132000}, {0xbe134000}, {0xbe136000}, {0xbe138000}, {0xbe13a000}, {0xbe13c000}, {0xbe13e000}, {0xbe140000}, {0xbe142000}, {0xbe144000}, {0xbe146000}, {0xbe148000}, {0xbe14a000}, {0xbe14c000}, {0xbe14e000}, {0xbe150000}, {0xbe152000}, {0xbe154000}, {0xbe156000}, {0xbe158000}, {0xbe15a000}, {0xbe15c000}, {0xbe15e000}, {0xbe160000}, {0xbe162000}, {0xbe164000}, {0xbe166000}, {0xbe168000}, {0xbe16a000}, {0xbe16c000}, {0xbe16e000}, {0xbe170000}, {0xbe172000}, {0xbe174000}, {0xbe176000}, {0xbe178000}, {0xbe17a000}, {0xbe17c000}, {0xbe17e000}, {0xbe180000}, {0xbe182000}, {0xbe184000}, {0xbe186000}, {0xbe188000}, {0xbe18a000}, {0xbe18c000}, {0xbe18e000}, {0xbe190000}, {0xbe192000}, {0xbe194000}, {0xbe196000}, {0xbe198000}, {0xbe19a000}, {0xbe19c000}, {0xbe19e000}, {0xbe1a0000}, {0xbe1a2000}, {0xbe1a4000}, {0xbe1a6000}, {0xbe1a8000}, {0xbe1aa000}, {0xbe1ac000}, {0xbe1ae000}, {0xbe1b0000}, {0xbe1b2000}, {0xbe1b4000}, {0xbe1b6000}, {0xbe1b8000}, {0xbe1ba000}, {0xbe1bc000}, {0xbe1be000}, {0xbe1c0000}, {0xbe1c2000}, {0xbe1c4000}, {0xbe1c6000}, {0xbe1c8000}, {0xbe1ca000}, {0xbe1cc000}, {0xbe1ce000}, {0xbe1d0000}, {0xbe1d2000}, {0xbe1d4000}, {0xbe1d6000}, {0xbe1d8000}, {0xbe1da000}, {0xbe1dc000}, {0xbe1de000}, {0xbe1e0000}, {0xbe1e2000}, {0xbe1e4000}, {0xbe1e6000}, {0xbe1e8000}, {0xbe1ea000}, {0xbe1ec000}, {0xbe1ee000}, {0xbe1f0000}, {0xbe1f2000}, {0xbe1f4000}, {0xbe1f6000}, {0xbe1f8000}, {0xbe1fa000}, {0xbe1fc000}, {0xbe1fe000}, {0xbe200000}, {0xbe202000}, {0xbe204000}, {0xbe206000}, {0xbe208000}, {0xbe20a000}, {0xbe20c000}, {0xbe20e000}, {0xbe210000}, {0xbe212000}, {0xbe214000}, {0xbe216000}, {0xbe218000}, {0xbe21a000}, {0xbe21c000}, {0xbe21e000}, {0xbe220000}, {0xbe222000}, {0xbe224000}, {0xbe226000}, {0xbe228000}, {0xbe22a000}, {0xbe22c000}, {0xbe22e000}, {0xbe230000}, {0xbe232000}, {0xbe234000}, {0xbe236000}, {0xbe238000}, {0xbe23a000}, {0xbe23c000}, {0xbe23e000}, {0xbe240000}, {0xbe242000}, {0xbe244000}, {0xbe246000}, {0xbe248000}, {0xbe24a000}, {0xbe24c000}, {0xbe24e000}, {0xbe250000}, {0xbe252000}, {0xbe254000}, {0xbe256000}, {0xbe258000}, {0xbe25a000}, {0xbe25c000}, {0xbe25e000}, {0xbe260000}, {0xbe262000}, {0xbe264000}, {0xbe266000}, {0xbe268000}, {0xbe26a000}, {0xbe26c000}, {0xbe26e000}, {0xbe270000}, {0xbe272000}, {0xbe274000}, {0xbe276000}, {0xbe278000}, {0xbe27a000}, {0xbe27c000}, {0xbe27e000}, {0xbe280000}, {0xbe282000}, {0xbe284000}, {0xbe286000}, {0xbe288000}, {0xbe28a000}, {0xbe28c000}, {0xbe28e000}, {0xbe290000}, {0xbe292000}, {0xbe294000}, {0xbe296000}, {0xbe298000}, {0xbe29a000}, {0xbe29c000}, {0xbe29e000}, {0xbe2a0000}, {0xbe2a2000}, {0xbe2a4000}, {0xbe2a6000}, {0xbe2a8000}, {0xbe2aa000}, {0xbe2ac000}, {0xbe2ae000}, {0xbe2b0000}, {0xbe2b2000}, {0xbe2b4000}, {0xbe2b6000}, {0xbe2b8000}, {0xbe2ba000}, {0xbe2bc000}, {0xbe2be000}, {0xbe2c0000}, {0xbe2c2000}, {0xbe2c4000}, {0xbe2c6000}, {0xbe2c8000}, {0xbe2ca000}, {0xbe2cc000}, {0xbe2ce000}, {0xbe2d0000}, {0xbe2d2000}, {0xbe2d4000}, {0xbe2d6000}, {0xbe2d8000}, {0xbe2da000}, {0xbe2dc000}, {0xbe2de000}, {0xbe2e0000}, {0xbe2e2000}, {0xbe2e4000}, {0xbe2e6000}, {0xbe2e8000}, {0xbe2ea000}, {0xbe2ec000}, {0xbe2ee000}, {0xbe2f0000}, {0xbe2f2000}, {0xbe2f4000}, {0xbe2f6000}, {0xbe2f8000}, {0xbe2fa000}, {0xbe2fc000}, {0xbe2fe000}, {0xbe300000}, {0xbe302000}, {0xbe304000}, {0xbe306000}, {0xbe308000}, {0xbe30a000}, {0xbe30c000}, {0xbe30e000}, {0xbe310000}, {0xbe312000}, {0xbe314000}, {0xbe316000}, {0xbe318000}, {0xbe31a000}, {0xbe31c000}, {0xbe31e000}, {0xbe320000}, {0xbe322000}, {0xbe324000}, {0xbe326000}, {0xbe328000}, {0xbe32a000}, {0xbe32c000}, {0xbe32e000}, {0xbe330000}, {0xbe332000}, {0xbe334000}, {0xbe336000}, {0xbe338000}, {0xbe33a000}, {0xbe33c000}, {0xbe33e000}, {0xbe340000}, {0xbe342000}, {0xbe344000}, {0xbe346000}, {0xbe348000}, {0xbe34a000}, {0xbe34c000}, {0xbe34e000}, {0xbe350000}, {0xbe352000}, {0xbe354000}, {0xbe356000}, {0xbe358000}, {0xbe35a000}, {0xbe35c000}, {0xbe35e000}, {0xbe360000}, {0xbe362000}, {0xbe364000}, {0xbe366000}, {0xbe368000}, {0xbe36a000}, {0xbe36c000}, {0xbe36e000}, {0xbe370000}, {0xbe372000}, {0xbe374000}, {0xbe376000}, {0xbe378000}, {0xbe37a000}, {0xbe37c000}, {0xbe37e000}, {0xbe380000}, {0xbe382000}, {0xbe384000}, {0xbe386000}, {0xbe388000}, {0xbe38a000}, {0xbe38c000}, {0xbe38e000}, {0xbe390000}, {0xbe392000}, {0xbe394000}, {0xbe396000}, {0xbe398000}, {0xbe39a000}, {0xbe39c000}, {0xbe39e000}, {0xbe3a0000}, {0xbe3a2000}, {0xbe3a4000}, {0xbe3a6000}, {0xbe3a8000}, {0xbe3aa000}, {0xbe3ac000}, {0xbe3ae000}, {0xbe3b0000}, {0xbe3b2000}, {0xbe3b4000}, {0xbe3b6000}, {0xbe3b8000}, {0xbe3ba000}, {0xbe3bc000}, {0xbe3be000}, {0xbe3c0000}, {0xbe3c2000}, {0xbe3c4000}, {0xbe3c6000}, {0xbe3c8000}, {0xbe3ca000}, {0xbe3cc000}, {0xbe3ce000}, {0xbe3d0000}, {0xbe3d2000}, {0xbe3d4000}, {0xbe3d6000}, {0xbe3d8000}, {0xbe3da000}, {0xbe3dc000}, {0xbe3de000}, {0xbe3e0000}, {0xbe3e2000}, {0xbe3e4000}, {0xbe3e6000}, {0xbe3e8000}, {0xbe3ea000}, {0xbe3ec000}, {0xbe3ee000}, {0xbe3f0000}, {0xbe3f2000}, {0xbe3f4000}, {0xbe3f6000}, {0xbe3f8000}, {0xbe3fa000}, {0xbe3fc000}, {0xbe3fe000}, {0xbe400000}, {0xbe402000}, {0xbe404000}, {0xbe406000}, {0xbe408000}, {0xbe40a000}, {0xbe40c000}, {0xbe40e000}, {0xbe410000}, {0xbe412000}, {0xbe414000}, {0xbe416000}, {0xbe418000}, {0xbe41a000}, {0xbe41c000}, {0xbe41e000}, {0xbe420000}, {0xbe422000}, {0xbe424000}, {0xbe426000}, {0xbe428000}, {0xbe42a000}, {0xbe42c000}, {0xbe42e000}, {0xbe430000}, {0xbe432000}, {0xbe434000}, {0xbe436000}, {0xbe438000}, {0xbe43a000}, {0xbe43c000}, {0xbe43e000}, {0xbe440000}, {0xbe442000}, {0xbe444000}, {0xbe446000}, {0xbe448000}, {0xbe44a000}, {0xbe44c000}, {0xbe44e000}, {0xbe450000}, {0xbe452000}, {0xbe454000}, {0xbe456000}, {0xbe458000}, {0xbe45a000}, {0xbe45c000}, {0xbe45e000}, {0xbe460000}, {0xbe462000}, {0xbe464000}, {0xbe466000}, {0xbe468000}, {0xbe46a000}, {0xbe46c000}, {0xbe46e000}, {0xbe470000}, {0xbe472000}, {0xbe474000}, {0xbe476000}, {0xbe478000}, {0xbe47a000}, {0xbe47c000}, {0xbe47e000}, {0xbe480000}, {0xbe482000}, {0xbe484000}, {0xbe486000}, {0xbe488000}, {0xbe48a000}, {0xbe48c000}, {0xbe48e000}, {0xbe490000}, {0xbe492000}, {0xbe494000}, {0xbe496000}, {0xbe498000}, {0xbe49a000}, {0xbe49c000}, {0xbe49e000}, {0xbe4a0000}, {0xbe4a2000}, {0xbe4a4000}, {0xbe4a6000}, {0xbe4a8000}, {0xbe4aa000}, {0xbe4ac000}, {0xbe4ae000}, {0xbe4b0000}, {0xbe4b2000}, {0xbe4b4000}, {0xbe4b6000}, {0xbe4b8000}, {0xbe4ba000}, {0xbe4bc000}, {0xbe4be000}, {0xbe4c0000}, {0xbe4c2000}, {0xbe4c4000}, {0xbe4c6000}, {0xbe4c8000}, {0xbe4ca000}, {0xbe4cc000}, {0xbe4ce000}, {0xbe4d0000}, {0xbe4d2000}, {0xbe4d4000}, {0xbe4d6000}, {0xbe4d8000}, {0xbe4da000}, {0xbe4dc000}, {0xbe4de000}, {0xbe4e0000}, {0xbe4e2000}, {0xbe4e4000}, {0xbe4e6000}, {0xbe4e8000}, {0xbe4ea000}, {0xbe4ec000}, {0xbe4ee000}, {0xbe4f0000}, {0xbe4f2000}, {0xbe4f4000}, {0xbe4f6000}, {0xbe4f8000}, {0xbe4fa000}, {0xbe4fc000}, {0xbe4fe000}, {0xbe500000}, {0xbe502000}, {0xbe504000}, {0xbe506000}, {0xbe508000}, {0xbe50a000}, {0xbe50c000}, {0xbe50e000}, {0xbe510000}, {0xbe512000}, {0xbe514000}, {0xbe516000}, {0xbe518000}, {0xbe51a000}, {0xbe51c000}, {0xbe51e000}, {0xbe520000}, {0xbe522000}, {0xbe524000}, {0xbe526000}, {0xbe528000}, {0xbe52a000}, {0xbe52c000}, {0xbe52e000}, {0xbe530000}, {0xbe532000}, {0xbe534000}, {0xbe536000}, {0xbe538000}, {0xbe53a000}, {0xbe53c000}, {0xbe53e000}, {0xbe540000}, {0xbe542000}, {0xbe544000}, {0xbe546000}, {0xbe548000}, {0xbe54a000}, {0xbe54c000}, {0xbe54e000}, {0xbe550000}, {0xbe552000}, {0xbe554000}, {0xbe556000}, {0xbe558000}, {0xbe55a000}, {0xbe55c000}, {0xbe55e000}, {0xbe560000}, {0xbe562000}, {0xbe564000}, {0xbe566000}, {0xbe568000}, {0xbe56a000}, {0xbe56c000}, {0xbe56e000}, {0xbe570000}, {0xbe572000}, {0xbe574000}, {0xbe576000}, {0xbe578000}, {0xbe57a000}, {0xbe57c000}, {0xbe57e000}, {0xbe580000}, {0xbe582000}, {0xbe584000}, {0xbe586000}, {0xbe588000}, {0xbe58a000}, {0xbe58c000}, {0xbe58e000}, {0xbe590000}, {0xbe592000}, {0xbe594000}, {0xbe596000}, {0xbe598000}, {0xbe59a000}, {0xbe59c000}, {0xbe59e000}, {0xbe5a0000}, {0xbe5a2000}, {0xbe5a4000}, {0xbe5a6000}, {0xbe5a8000}, {0xbe5aa000}, {0xbe5ac000}, {0xbe5ae000}, {0xbe5b0000}, {0xbe5b2000}, {0xbe5b4000}, {0xbe5b6000}, {0xbe5b8000}, {0xbe5ba000}, {0xbe5bc000}, {0xbe5be000}, {0xbe5c0000}, {0xbe5c2000}, {0xbe5c4000}, {0xbe5c6000}, {0xbe5c8000}, {0xbe5ca000}, {0xbe5cc000}, {0xbe5ce000}, {0xbe5d0000}, {0xbe5d2000}, {0xbe5d4000}, {0xbe5d6000}, {0xbe5d8000}, {0xbe5da000}, {0xbe5dc000}, {0xbe5de000}, {0xbe5e0000}, {0xbe5e2000}, {0xbe5e4000}, {0xbe5e6000}, {0xbe5e8000}, {0xbe5ea000}, {0xbe5ec000}, {0xbe5ee000}, {0xbe5f0000}, {0xbe5f2000}, {0xbe5f4000}, {0xbe5f6000}, {0xbe5f8000}, {0xbe5fa000}, {0xbe5fc000}, {0xbe5fe000}, {0xbe600000}, {0xbe602000}, {0xbe604000}, {0xbe606000}, {0xbe608000}, {0xbe60a000}, {0xbe60c000}, {0xbe60e000}, {0xbe610000}, {0xbe612000}, {0xbe614000}, {0xbe616000}, {0xbe618000}, {0xbe61a000}, {0xbe61c000}, {0xbe61e000}, {0xbe620000}, {0xbe622000}, {0xbe624000}, {0xbe626000}, {0xbe628000}, {0xbe62a000}, {0xbe62c000}, {0xbe62e000}, {0xbe630000}, {0xbe632000}, {0xbe634000}, {0xbe636000}, {0xbe638000}, {0xbe63a000}, {0xbe63c000}, {0xbe63e000}, {0xbe640000}, {0xbe642000}, {0xbe644000}, {0xbe646000}, {0xbe648000}, {0xbe64a000}, {0xbe64c000}, {0xbe64e000}, {0xbe650000}, {0xbe652000}, {0xbe654000}, {0xbe656000}, {0xbe658000}, {0xbe65a000}, {0xbe65c000}, {0xbe65e000}, {0xbe660000}, {0xbe662000}, {0xbe664000}, {0xbe666000}, {0xbe668000}, {0xbe66a000}, {0xbe66c000}, {0xbe66e000}, {0xbe670000}, {0xbe672000}, {0xbe674000}, {0xbe676000}, {0xbe678000}, {0xbe67a000}, {0xbe67c000}, {0xbe67e000}, {0xbe680000}, {0xbe682000}, {0xbe684000}, {0xbe686000}, {0xbe688000}, {0xbe68a000}, {0xbe68c000}, {0xbe68e000}, {0xbe690000}, {0xbe692000}, {0xbe694000}, {0xbe696000}, {0xbe698000}, {0xbe69a000}, {0xbe69c000}, {0xbe69e000}, {0xbe6a0000}, {0xbe6a2000}, {0xbe6a4000}, {0xbe6a6000}, {0xbe6a8000}, {0xbe6aa000}, {0xbe6ac000}, {0xbe6ae000}, {0xbe6b0000}, {0xbe6b2000}, {0xbe6b4000}, {0xbe6b6000}, {0xbe6b8000}, {0xbe6ba000}, {0xbe6bc000}, {0xbe6be000}, {0xbe6c0000}, {0xbe6c2000}, {0xbe6c4000}, {0xbe6c6000}, {0xbe6c8000}, {0xbe6ca000}, {0xbe6cc000}, {0xbe6ce000}, {0xbe6d0000}, {0xbe6d2000}, {0xbe6d4000}, {0xbe6d6000}, {0xbe6d8000}, {0xbe6da000}, {0xbe6dc000}, {0xbe6de000}, {0xbe6e0000}, {0xbe6e2000}, {0xbe6e4000}, {0xbe6e6000}, {0xbe6e8000}, {0xbe6ea000}, {0xbe6ec000}, {0xbe6ee000}, {0xbe6f0000}, {0xbe6f2000}, {0xbe6f4000}, {0xbe6f6000}, {0xbe6f8000}, {0xbe6fa000}, {0xbe6fc000}, {0xbe6fe000}, {0xbe700000}, {0xbe702000}, {0xbe704000}, {0xbe706000}, {0xbe708000}, {0xbe70a000}, {0xbe70c000}, {0xbe70e000}, {0xbe710000}, {0xbe712000}, {0xbe714000}, {0xbe716000}, {0xbe718000}, {0xbe71a000}, {0xbe71c000}, {0xbe71e000}, {0xbe720000}, {0xbe722000}, {0xbe724000}, {0xbe726000}, {0xbe728000}, {0xbe72a000}, {0xbe72c000}, {0xbe72e000}, {0xbe730000}, {0xbe732000}, {0xbe734000}, {0xbe736000}, {0xbe738000}, {0xbe73a000}, {0xbe73c000}, {0xbe73e000}, {0xbe740000}, {0xbe742000}, {0xbe744000}, {0xbe746000}, {0xbe748000}, {0xbe74a000}, {0xbe74c000}, {0xbe74e000}, {0xbe750000}, {0xbe752000}, {0xbe754000}, {0xbe756000}, {0xbe758000}, {0xbe75a000}, {0xbe75c000}, {0xbe75e000}, {0xbe760000}, {0xbe762000}, {0xbe764000}, {0xbe766000}, {0xbe768000}, {0xbe76a000}, {0xbe76c000}, {0xbe76e000}, {0xbe770000}, {0xbe772000}, {0xbe774000}, {0xbe776000}, {0xbe778000}, {0xbe77a000}, {0xbe77c000}, {0xbe77e000}, {0xbe780000}, {0xbe782000}, {0xbe784000}, {0xbe786000}, {0xbe788000}, {0xbe78a000}, {0xbe78c000}, {0xbe78e000}, {0xbe790000}, {0xbe792000}, {0xbe794000}, {0xbe796000}, {0xbe798000}, {0xbe79a000}, {0xbe79c000}, {0xbe79e000}, {0xbe7a0000}, {0xbe7a2000}, {0xbe7a4000}, {0xbe7a6000}, {0xbe7a8000}, {0xbe7aa000}, {0xbe7ac000}, {0xbe7ae000}, {0xbe7b0000}, {0xbe7b2000}, {0xbe7b4000}, {0xbe7b6000}, {0xbe7b8000}, {0xbe7ba000}, {0xbe7bc000}, {0xbe7be000}, {0xbe7c0000}, {0xbe7c2000}, {0xbe7c4000}, {0xbe7c6000}, {0xbe7c8000}, {0xbe7ca000}, {0xbe7cc000}, {0xbe7ce000}, {0xbe7d0000}, {0xbe7d2000}, {0xbe7d4000}, {0xbe7d6000}, {0xbe7d8000}, {0xbe7da000}, {0xbe7dc000}, {0xbe7de000}, {0xbe7e0000}, {0xbe7e2000}, {0xbe7e4000}, {0xbe7e6000}, {0xbe7e8000}, {0xbe7ea000}, {0xbe7ec000}, {0xbe7ee000}, {0xbe7f0000}, {0xbe7f2000}, {0xbe7f4000}, {0xbe7f6000}, {0xbe7f8000}, {0xbe7fa000}, {0xbe7fc000}, {0xbe7fe000}, {0xbe800000}, {0xbe802000}, {0xbe804000}, {0xbe806000}, {0xbe808000}, {0xbe80a000}, {0xbe80c000}, {0xbe80e000}, {0xbe810000}, {0xbe812000}, {0xbe814000}, {0xbe816000}, {0xbe818000}, {0xbe81a000}, {0xbe81c000}, {0xbe81e000}, {0xbe820000}, {0xbe822000}, {0xbe824000}, {0xbe826000}, {0xbe828000}, {0xbe82a000}, {0xbe82c000}, {0xbe82e000}, {0xbe830000}, {0xbe832000}, {0xbe834000}, {0xbe836000}, {0xbe838000}, {0xbe83a000}, {0xbe83c000}, {0xbe83e000}, {0xbe840000}, {0xbe842000}, {0xbe844000}, {0xbe846000}, {0xbe848000}, {0xbe84a000}, {0xbe84c000}, {0xbe84e000}, {0xbe850000}, {0xbe852000}, {0xbe854000}, {0xbe856000}, {0xbe858000}, {0xbe85a000}, {0xbe85c000}, {0xbe85e000}, {0xbe860000}, {0xbe862000}, {0xbe864000}, {0xbe866000}, {0xbe868000}, {0xbe86a000}, {0xbe86c000}, {0xbe86e000}, {0xbe870000}, {0xbe872000}, {0xbe874000}, {0xbe876000}, {0xbe878000}, {0xbe87a000}, {0xbe87c000}, {0xbe87e000}, {0xbe880000}, {0xbe882000}, {0xbe884000}, {0xbe886000}, {0xbe888000}, {0xbe88a000}, {0xbe88c000}, {0xbe88e000}, {0xbe890000}, {0xbe892000}, {0xbe894000}, {0xbe896000}, {0xbe898000}, {0xbe89a000}, {0xbe89c000}, {0xbe89e000}, {0xbe8a0000}, {0xbe8a2000}, {0xbe8a4000}, {0xbe8a6000}, {0xbe8a8000}, {0xbe8aa000}, {0xbe8ac000}, {0xbe8ae000}, {0xbe8b0000}, {0xbe8b2000}, {0xbe8b4000}, {0xbe8b6000}, {0xbe8b8000}, {0xbe8ba000}, {0xbe8bc000}, {0xbe8be000}, {0xbe8c0000}, {0xbe8c2000}, {0xbe8c4000}, {0xbe8c6000}, {0xbe8c8000}, {0xbe8ca000}, {0xbe8cc000}, {0xbe8ce000}, {0xbe8d0000}, {0xbe8d2000}, {0xbe8d4000}, {0xbe8d6000}, {0xbe8d8000}, {0xbe8da000}, {0xbe8dc000}, {0xbe8de000}, {0xbe8e0000}, {0xbe8e2000}, {0xbe8e4000}, {0xbe8e6000}, {0xbe8e8000}, {0xbe8ea000}, {0xbe8ec000}, {0xbe8ee000}, {0xbe8f0000}, {0xbe8f2000}, {0xbe8f4000}, {0xbe8f6000}, {0xbe8f8000}, {0xbe8fa000}, {0xbe8fc000}, {0xbe8fe000}, {0xbe900000}, {0xbe902000}, {0xbe904000}, {0xbe906000}, {0xbe908000}, {0xbe90a000}, {0xbe90c000}, {0xbe90e000}, {0xbe910000}, {0xbe912000}, {0xbe914000}, {0xbe916000}, {0xbe918000}, {0xbe91a000}, {0xbe91c000}, {0xbe91e000}, {0xbe920000}, {0xbe922000}, {0xbe924000}, {0xbe926000}, {0xbe928000}, {0xbe92a000}, {0xbe92c000}, {0xbe92e000}, {0xbe930000}, {0xbe932000}, {0xbe934000}, {0xbe936000}, {0xbe938000}, {0xbe93a000}, {0xbe93c000}, {0xbe93e000}, {0xbe940000}, {0xbe942000}, {0xbe944000}, {0xbe946000}, {0xbe948000}, {0xbe94a000}, {0xbe94c000}, {0xbe94e000}, {0xbe950000}, {0xbe952000}, {0xbe954000}, {0xbe956000}, {0xbe958000}, {0xbe95a000}, {0xbe95c000}, {0xbe95e000}, {0xbe960000}, {0xbe962000}, {0xbe964000}, {0xbe966000}, {0xbe968000}, {0xbe96a000}, {0xbe96c000}, {0xbe96e000}, {0xbe970000}, {0xbe972000}, {0xbe974000}, {0xbe976000}, {0xbe978000}, {0xbe97a000}, {0xbe97c000}, {0xbe97e000}, {0xbe980000}, {0xbe982000}, {0xbe984000}, {0xbe986000}, {0xbe988000}, {0xbe98a000}, {0xbe98c000}, {0xbe98e000}, {0xbe990000}, {0xbe992000}, {0xbe994000}, {0xbe996000}, {0xbe998000}, {0xbe99a000}, {0xbe99c000}, {0xbe99e000}, {0xbe9a0000}, {0xbe9a2000}, {0xbe9a4000}, {0xbe9a6000}, {0xbe9a8000}, {0xbe9aa000}, {0xbe9ac000}, {0xbe9ae000}, {0xbe9b0000}, {0xbe9b2000}, {0xbe9b4000}, {0xbe9b6000}, {0xbe9b8000}, {0xbe9ba000}, {0xbe9bc000}, {0xbe9be000}, {0xbe9c0000}, {0xbe9c2000}, {0xbe9c4000}, {0xbe9c6000}, {0xbe9c8000}, {0xbe9ca000}, {0xbe9cc000}, {0xbe9ce000}, {0xbe9d0000}, {0xbe9d2000}, {0xbe9d4000}, {0xbe9d6000}, {0xbe9d8000}, {0xbe9da000}, {0xbe9dc000}, {0xbe9de000}, {0xbe9e0000}, {0xbe9e2000}, {0xbe9e4000}, {0xbe9e6000}, {0xbe9e8000}, {0xbe9ea000}, {0xbe9ec000}, {0xbe9ee000}, {0xbe9f0000}, {0xbe9f2000}, {0xbe9f4000}, {0xbe9f6000}, {0xbe9f8000}, {0xbe9fa000}, {0xbe9fc000}, {0xbe9fe000}, {0xbea00000}, {0xbea02000}, {0xbea04000}, {0xbea06000}, {0xbea08000}, {0xbea0a000}, {0xbea0c000}, {0xbea0e000}, {0xbea10000}, {0xbea12000}, {0xbea14000}, {0xbea16000}, {0xbea18000}, {0xbea1a000}, {0xbea1c000}, {0xbea1e000}, {0xbea20000}, {0xbea22000}, {0xbea24000}, {0xbea26000}, {0xbea28000}, {0xbea2a000}, {0xbea2c000}, {0xbea2e000}, {0xbea30000}, {0xbea32000}, {0xbea34000}, {0xbea36000}, {0xbea38000}, {0xbea3a000}, {0xbea3c000}, {0xbea3e000}, {0xbea40000}, {0xbea42000}, {0xbea44000}, {0xbea46000}, {0xbea48000}, {0xbea4a000}, {0xbea4c000}, {0xbea4e000}, {0xbea50000}, {0xbea52000}, {0xbea54000}, {0xbea56000}, {0xbea58000}, {0xbea5a000}, {0xbea5c000}, {0xbea5e000}, {0xbea60000}, {0xbea62000}, {0xbea64000}, {0xbea66000}, {0xbea68000}, {0xbea6a000}, {0xbea6c000}, {0xbea6e000}, {0xbea70000}, {0xbea72000}, {0xbea74000}, {0xbea76000}, {0xbea78000}, {0xbea7a000}, {0xbea7c000}, {0xbea7e000}, {0xbea80000}, {0xbea82000}, {0xbea84000}, {0xbea86000}, {0xbea88000}, {0xbea8a000}, {0xbea8c000}, {0xbea8e000}, {0xbea90000}, {0xbea92000}, {0xbea94000}, {0xbea96000}, {0xbea98000}, {0xbea9a000}, {0xbea9c000}, {0xbea9e000}, {0xbeaa0000}, {0xbeaa2000}, {0xbeaa4000}, {0xbeaa6000}, {0xbeaa8000}, {0xbeaaa000}, {0xbeaac000}, {0xbeaae000}, {0xbeab0000}, {0xbeab2000}, {0xbeab4000}, {0xbeab6000}, {0xbeab8000}, {0xbeaba000}, {0xbeabc000}, {0xbeabe000}, {0xbeac0000}, {0xbeac2000}, {0xbeac4000}, {0xbeac6000}, {0xbeac8000}, {0xbeaca000}, {0xbeacc000}, {0xbeace000}, {0xbead0000}, {0xbead2000}, {0xbead4000}, {0xbead6000}, {0xbead8000}, {0xbeada000}, {0xbeadc000}, {0xbeade000}, {0xbeae0000}, {0xbeae2000}, {0xbeae4000}, {0xbeae6000}, {0xbeae8000}, {0xbeaea000}, {0xbeaec000}, {0xbeaee000}, {0xbeaf0000}, {0xbeaf2000}, {0xbeaf4000}, {0xbeaf6000}, {0xbeaf8000}, {0xbeafa000}, {0xbeafc000}, {0xbeafe000}, {0xbeb00000}, {0xbeb02000}, {0xbeb04000}, {0xbeb06000}, {0xbeb08000}, {0xbeb0a000}, {0xbeb0c000}, {0xbeb0e000}, {0xbeb10000}, {0xbeb12000}, {0xbeb14000}, {0xbeb16000}, {0xbeb18000}, {0xbeb1a000}, {0xbeb1c000}, {0xbeb1e000}, {0xbeb20000}, {0xbeb22000}, {0xbeb24000}, {0xbeb26000}, {0xbeb28000}, {0xbeb2a000}, {0xbeb2c000}, {0xbeb2e000}, {0xbeb30000}, {0xbeb32000}, {0xbeb34000}, {0xbeb36000}, {0xbeb38000}, {0xbeb3a000}, {0xbeb3c000}, {0xbeb3e000}, {0xbeb40000}, {0xbeb42000}, {0xbeb44000}, {0xbeb46000}, {0xbeb48000}, {0xbeb4a000}, {0xbeb4c000}, {0xbeb4e000}, {0xbeb50000}, {0xbeb52000}, {0xbeb54000}, {0xbeb56000}, {0xbeb58000}, {0xbeb5a000}, {0xbeb5c000}, {0xbeb5e000}, {0xbeb60000}, {0xbeb62000}, {0xbeb64000}, {0xbeb66000}, {0xbeb68000}, {0xbeb6a000}, {0xbeb6c000}, {0xbeb6e000}, {0xbeb70000}, {0xbeb72000}, {0xbeb74000}, {0xbeb76000}, {0xbeb78000}, {0xbeb7a000}, {0xbeb7c000}, {0xbeb7e000}, {0xbeb80000}, {0xbeb82000}, {0xbeb84000}, {0xbeb86000}, {0xbeb88000}, {0xbeb8a000}, {0xbeb8c000}, {0xbeb8e000}, {0xbeb90000}, {0xbeb92000}, {0xbeb94000}, {0xbeb96000}, {0xbeb98000}, {0xbeb9a000}, {0xbeb9c000}, {0xbeb9e000}, {0xbeba0000}, {0xbeba2000}, {0xbeba4000}, {0xbeba6000}, {0xbeba8000}, {0xbebaa000}, {0xbebac000}, {0xbebae000}, {0xbebb0000}, {0xbebb2000}, {0xbebb4000}, {0xbebb6000}, {0xbebb8000}, {0xbebba000}, {0xbebbc000}, {0xbebbe000}, {0xbebc0000}, {0xbebc2000}, {0xbebc4000}, {0xbebc6000}, {0xbebc8000}, {0xbebca000}, {0xbebcc000}, {0xbebce000}, {0xbebd0000}, {0xbebd2000}, {0xbebd4000}, {0xbebd6000}, {0xbebd8000}, {0xbebda000}, {0xbebdc000}, {0xbebde000}, {0xbebe0000}, {0xbebe2000}, {0xbebe4000}, {0xbebe6000}, {0xbebe8000}, {0xbebea000}, {0xbebec000}, {0xbebee000}, {0xbebf0000}, {0xbebf2000}, {0xbebf4000}, {0xbebf6000}, {0xbebf8000}, {0xbebfa000}, {0xbebfc000}, {0xbebfe000}, {0xbec00000}, {0xbec02000}, {0xbec04000}, {0xbec06000}, {0xbec08000}, {0xbec0a000}, {0xbec0c000}, {0xbec0e000}, {0xbec10000}, {0xbec12000}, {0xbec14000}, {0xbec16000}, {0xbec18000}, {0xbec1a000}, {0xbec1c000}, {0xbec1e000}, {0xbec20000}, {0xbec22000}, {0xbec24000}, {0xbec26000}, {0xbec28000}, {0xbec2a000}, {0xbec2c000}, {0xbec2e000}, {0xbec30000}, {0xbec32000}, {0xbec34000}, {0xbec36000}, {0xbec38000}, {0xbec3a000}, {0xbec3c000}, {0xbec3e000}, {0xbec40000}, {0xbec42000}, {0xbec44000}, {0xbec46000}, {0xbec48000}, {0xbec4a000}, {0xbec4c000}, {0xbec4e000}, {0xbec50000}, {0xbec52000}, {0xbec54000}, {0xbec56000}, {0xbec58000}, {0xbec5a000}, {0xbec5c000}, {0xbec5e000}, {0xbec60000}, {0xbec62000}, {0xbec64000}, {0xbec66000}, {0xbec68000}, {0xbec6a000}, {0xbec6c000}, {0xbec6e000}, {0xbec70000}, {0xbec72000}, {0xbec74000}, {0xbec76000}, {0xbec78000}, {0xbec7a000}, {0xbec7c000}, {0xbec7e000}, {0xbec80000}, {0xbec82000}, {0xbec84000}, {0xbec86000}, {0xbec88000}, {0xbec8a000}, {0xbec8c000}, {0xbec8e000}, {0xbec90000}, {0xbec92000}, {0xbec94000}, {0xbec96000}, {0xbec98000}, {0xbec9a000}, {0xbec9c000}, {0xbec9e000}, {0xbeca0000}, {0xbeca2000}, {0xbeca4000}, {0xbeca6000}, {0xbeca8000}, {0xbecaa000}, {0xbecac000}, {0xbecae000}, {0xbecb0000}, {0xbecb2000}, {0xbecb4000}, {0xbecb6000}, {0xbecb8000}, {0xbecba000}, {0xbecbc000}, {0xbecbe000}, {0xbecc0000}, {0xbecc2000}, {0xbecc4000}, {0xbecc6000}, {0xbecc8000}, {0xbecca000}, {0xbeccc000}, {0xbecce000}, {0xbecd0000}, {0xbecd2000}, {0xbecd4000}, {0xbecd6000}, {0xbecd8000}, {0xbecda000}, {0xbecdc000}, {0xbecde000}, {0xbece0000}, {0xbece2000}, {0xbece4000}, {0xbece6000}, {0xbece8000}, {0xbecea000}, {0xbecec000}, {0xbecee000}, {0xbecf0000}, {0xbecf2000}, {0xbecf4000}, {0xbecf6000}, {0xbecf8000}, {0xbecfa000}, {0xbecfc000}, {0xbecfe000}, {0xbed00000}, {0xbed02000}, {0xbed04000}, {0xbed06000}, {0xbed08000}, {0xbed0a000}, {0xbed0c000}, {0xbed0e000}, {0xbed10000}, {0xbed12000}, {0xbed14000}, {0xbed16000}, {0xbed18000}, {0xbed1a000}, {0xbed1c000}, {0xbed1e000}, {0xbed20000}, {0xbed22000}, {0xbed24000}, {0xbed26000}, {0xbed28000}, {0xbed2a000}, {0xbed2c000}, {0xbed2e000}, {0xbed30000}, {0xbed32000}, {0xbed34000}, {0xbed36000}, {0xbed38000}, {0xbed3a000}, {0xbed3c000}, {0xbed3e000}, {0xbed40000}, {0xbed42000}, {0xbed44000}, {0xbed46000}, {0xbed48000}, {0xbed4a000}, {0xbed4c000}, {0xbed4e000}, {0xbed50000}, {0xbed52000}, {0xbed54000}, {0xbed56000}, {0xbed58000}, {0xbed5a000}, {0xbed5c000}, {0xbed5e000}, {0xbed60000}, {0xbed62000}, {0xbed64000}, {0xbed66000}, {0xbed68000}, {0xbed6a000}, {0xbed6c000}, {0xbed6e000}, {0xbed70000}, {0xbed72000}, {0xbed74000}, {0xbed76000}, {0xbed78000}, {0xbed7a000}, {0xbed7c000}, {0xbed7e000}, {0xbed80000}, {0xbed82000}, {0xbed84000}, {0xbed86000}, {0xbed88000}, {0xbed8a000}, {0xbed8c000}, {0xbed8e000}, {0xbed90000}, {0xbed92000}, {0xbed94000}, {0xbed96000}, {0xbed98000}, {0xbed9a000}, {0xbed9c000}, {0xbed9e000}, {0xbeda0000}, {0xbeda2000}, {0xbeda4000}, {0xbeda6000}, {0xbeda8000}, {0xbedaa000}, {0xbedac000}, {0xbedae000}, {0xbedb0000}, {0xbedb2000}, {0xbedb4000}, {0xbedb6000}, {0xbedb8000}, {0xbedba000}, {0xbedbc000}, {0xbedbe000}, {0xbedc0000}, {0xbedc2000}, {0xbedc4000}, {0xbedc6000}, {0xbedc8000}, {0xbedca000}, {0xbedcc000}, {0xbedce000}, {0xbedd0000}, {0xbedd2000}, {0xbedd4000}, {0xbedd6000}, {0xbedd8000}, {0xbedda000}, {0xbeddc000}, {0xbedde000}, {0xbede0000}, {0xbede2000}, {0xbede4000}, {0xbede6000}, {0xbede8000}, {0xbedea000}, {0xbedec000}, {0xbedee000}, {0xbedf0000}, {0xbedf2000}, {0xbedf4000}, {0xbedf6000}, {0xbedf8000}, {0xbedfa000}, {0xbedfc000}, {0xbedfe000}, {0xbee00000}, {0xbee02000}, {0xbee04000}, {0xbee06000}, {0xbee08000}, {0xbee0a000}, {0xbee0c000}, {0xbee0e000}, {0xbee10000}, {0xbee12000}, {0xbee14000}, {0xbee16000}, {0xbee18000}, {0xbee1a000}, {0xbee1c000}, {0xbee1e000}, {0xbee20000}, {0xbee22000}, {0xbee24000}, {0xbee26000}, {0xbee28000}, {0xbee2a000}, {0xbee2c000}, {0xbee2e000}, {0xbee30000}, {0xbee32000}, {0xbee34000}, {0xbee36000}, {0xbee38000}, {0xbee3a000}, {0xbee3c000}, {0xbee3e000}, {0xbee40000}, {0xbee42000}, {0xbee44000}, {0xbee46000}, {0xbee48000}, {0xbee4a000}, {0xbee4c000}, {0xbee4e000}, {0xbee50000}, {0xbee52000}, {0xbee54000}, {0xbee56000}, {0xbee58000}, {0xbee5a000}, {0xbee5c000}, {0xbee5e000}, {0xbee60000}, {0xbee62000}, {0xbee64000}, {0xbee66000}, {0xbee68000}, {0xbee6a000}, {0xbee6c000}, {0xbee6e000}, {0xbee70000}, {0xbee72000}, {0xbee74000}, {0xbee76000}, {0xbee78000}, {0xbee7a000}, {0xbee7c000}, {0xbee7e000}, {0xbee80000}, {0xbee82000}, {0xbee84000}, {0xbee86000}, {0xbee88000}, {0xbee8a000}, {0xbee8c000}, {0xbee8e000}, {0xbee90000}, {0xbee92000}, {0xbee94000}, {0xbee96000}, {0xbee98000}, {0xbee9a000}, {0xbee9c000}, {0xbee9e000}, {0xbeea0000}, {0xbeea2000}, {0xbeea4000}, {0xbeea6000}, {0xbeea8000}, {0xbeeaa000}, {0xbeeac000}, {0xbeeae000}, {0xbeeb0000}, {0xbeeb2000}, {0xbeeb4000}, {0xbeeb6000}, {0xbeeb8000}, {0xbeeba000}, {0xbeebc000}, {0xbeebe000}, {0xbeec0000}, {0xbeec2000}, {0xbeec4000}, {0xbeec6000}, {0xbeec8000}, {0xbeeca000}, {0xbeecc000}, {0xbeece000}, {0xbeed0000}, {0xbeed2000}, {0xbeed4000}, {0xbeed6000}, {0xbeed8000}, {0xbeeda000}, {0xbeedc000}, {0xbeede000}, {0xbeee0000}, {0xbeee2000}, {0xbeee4000}, {0xbeee6000}, {0xbeee8000}, {0xbeeea000}, {0xbeeec000}, {0xbeeee000}, {0xbeef0000}, {0xbeef2000}, {0xbeef4000}, {0xbeef6000}, {0xbeef8000}, {0xbeefa000}, {0xbeefc000}, {0xbeefe000}, {0xbef00000}, {0xbef02000}, {0xbef04000}, {0xbef06000}, {0xbef08000}, {0xbef0a000}, {0xbef0c000}, {0xbef0e000}, {0xbef10000}, {0xbef12000}, {0xbef14000}, {0xbef16000}, {0xbef18000}, {0xbef1a000}, {0xbef1c000}, {0xbef1e000}, {0xbef20000}, {0xbef22000}, {0xbef24000}, {0xbef26000}, {0xbef28000}, {0xbef2a000}, {0xbef2c000}, {0xbef2e000}, {0xbef30000}, {0xbef32000}, {0xbef34000}, {0xbef36000}, {0xbef38000}, {0xbef3a000}, {0xbef3c000}, {0xbef3e000}, {0xbef40000}, {0xbef42000}, {0xbef44000}, {0xbef46000}, {0xbef48000}, {0xbef4a000}, {0xbef4c000}, {0xbef4e000}, {0xbef50000}, {0xbef52000}, {0xbef54000}, {0xbef56000}, {0xbef58000}, {0xbef5a000}, {0xbef5c000}, {0xbef5e000}, {0xbef60000}, {0xbef62000}, {0xbef64000}, {0xbef66000}, {0xbef68000}, {0xbef6a000}, {0xbef6c000}, {0xbef6e000}, {0xbef70000}, {0xbef72000}, {0xbef74000}, {0xbef76000}, {0xbef78000}, {0xbef7a000}, {0xbef7c000}, {0xbef7e000}, {0xbef80000}, {0xbef82000}, {0xbef84000}, {0xbef86000}, {0xbef88000}, {0xbef8a000}, {0xbef8c000}, {0xbef8e000}, {0xbef90000}, {0xbef92000}, {0xbef94000}, {0xbef96000}, {0xbef98000}, {0xbef9a000}, {0xbef9c000}, {0xbef9e000}, {0xbefa0000}, {0xbefa2000}, {0xbefa4000}, {0xbefa6000}, {0xbefa8000}, {0xbefaa000}, {0xbefac000}, {0xbefae000}, {0xbefb0000}, {0xbefb2000}, {0xbefb4000}, {0xbefb6000}, {0xbefb8000}, {0xbefba000}, {0xbefbc000}, {0xbefbe000}, {0xbefc0000}, {0xbefc2000}, {0xbefc4000}, {0xbefc6000}, {0xbefc8000}, {0xbefca000}, {0xbefcc000}, {0xbefce000}, {0xbefd0000}, {0xbefd2000}, {0xbefd4000}, {0xbefd6000}, {0xbefd8000}, {0xbefda000}, {0xbefdc000}, {0xbefde000}, {0xbefe0000}, {0xbefe2000}, {0xbefe4000}, {0xbefe6000}, {0xbefe8000}, {0xbefea000}, {0xbefec000}, {0xbefee000}, {0xbeff0000}, {0xbeff2000}, {0xbeff4000}, {0xbeff6000}, {0xbeff8000}, {0xbeffa000}, {0xbeffc000}, {0xbeffe000}, {0xbf000000}, {0xbf002000}, {0xbf004000}, {0xbf006000}, {0xbf008000}, {0xbf00a000}, {0xbf00c000}, {0xbf00e000}, {0xbf010000}, {0xbf012000}, {0xbf014000}, {0xbf016000}, {0xbf018000}, {0xbf01a000}, {0xbf01c000}, {0xbf01e000}, {0xbf020000}, {0xbf022000}, {0xbf024000}, {0xbf026000}, {0xbf028000}, {0xbf02a000}, {0xbf02c000}, {0xbf02e000}, {0xbf030000}, {0xbf032000}, {0xbf034000}, {0xbf036000}, {0xbf038000}, {0xbf03a000}, {0xbf03c000}, {0xbf03e000}, {0xbf040000}, {0xbf042000}, {0xbf044000}, {0xbf046000}, {0xbf048000}, {0xbf04a000}, {0xbf04c000}, {0xbf04e000}, {0xbf050000}, {0xbf052000}, {0xbf054000}, {0xbf056000}, {0xbf058000}, {0xbf05a000}, {0xbf05c000}, {0xbf05e000}, {0xbf060000}, {0xbf062000}, {0xbf064000}, {0xbf066000}, {0xbf068000}, {0xbf06a000}, {0xbf06c000}, {0xbf06e000}, {0xbf070000}, {0xbf072000}, {0xbf074000}, {0xbf076000}, {0xbf078000}, {0xbf07a000}, {0xbf07c000}, {0xbf07e000}, {0xbf080000}, {0xbf082000}, {0xbf084000}, {0xbf086000}, {0xbf088000}, {0xbf08a000}, {0xbf08c000}, {0xbf08e000}, {0xbf090000}, {0xbf092000}, {0xbf094000}, {0xbf096000}, {0xbf098000}, {0xbf09a000}, {0xbf09c000}, {0xbf09e000}, {0xbf0a0000}, {0xbf0a2000}, {0xbf0a4000}, {0xbf0a6000}, {0xbf0a8000}, {0xbf0aa000}, {0xbf0ac000}, {0xbf0ae000}, {0xbf0b0000}, {0xbf0b2000}, {0xbf0b4000}, {0xbf0b6000}, {0xbf0b8000}, {0xbf0ba000}, {0xbf0bc000}, {0xbf0be000}, {0xbf0c0000}, {0xbf0c2000}, {0xbf0c4000}, {0xbf0c6000}, {0xbf0c8000}, {0xbf0ca000}, {0xbf0cc000}, {0xbf0ce000}, {0xbf0d0000}, {0xbf0d2000}, {0xbf0d4000}, {0xbf0d6000}, {0xbf0d8000}, {0xbf0da000}, {0xbf0dc000}, {0xbf0de000}, {0xbf0e0000}, {0xbf0e2000}, {0xbf0e4000}, {0xbf0e6000}, {0xbf0e8000}, {0xbf0ea000}, {0xbf0ec000}, {0xbf0ee000}, {0xbf0f0000}, {0xbf0f2000}, {0xbf0f4000}, {0xbf0f6000}, {0xbf0f8000}, {0xbf0fa000}, {0xbf0fc000}, {0xbf0fe000}, {0xbf100000}, {0xbf102000}, {0xbf104000}, {0xbf106000}, {0xbf108000}, {0xbf10a000}, {0xbf10c000}, {0xbf10e000}, {0xbf110000}, {0xbf112000}, {0xbf114000}, {0xbf116000}, {0xbf118000}, {0xbf11a000}, {0xbf11c000}, {0xbf11e000}, {0xbf120000}, {0xbf122000}, {0xbf124000}, {0xbf126000}, {0xbf128000}, {0xbf12a000}, {0xbf12c000}, {0xbf12e000}, {0xbf130000}, {0xbf132000}, {0xbf134000}, {0xbf136000}, {0xbf138000}, {0xbf13a000}, {0xbf13c000}, {0xbf13e000}, {0xbf140000}, {0xbf142000}, {0xbf144000}, {0xbf146000}, {0xbf148000}, {0xbf14a000}, {0xbf14c000}, {0xbf14e000}, {0xbf150000}, {0xbf152000}, {0xbf154000}, {0xbf156000}, {0xbf158000}, {0xbf15a000}, {0xbf15c000}, {0xbf15e000}, {0xbf160000}, {0xbf162000}, {0xbf164000}, {0xbf166000}, {0xbf168000}, {0xbf16a000}, {0xbf16c000}, {0xbf16e000}, {0xbf170000}, {0xbf172000}, {0xbf174000}, {0xbf176000}, {0xbf178000}, {0xbf17a000}, {0xbf17c000}, {0xbf17e000}, {0xbf180000}, {0xbf182000}, {0xbf184000}, {0xbf186000}, {0xbf188000}, {0xbf18a000}, {0xbf18c000}, {0xbf18e000}, {0xbf190000}, {0xbf192000}, {0xbf194000}, {0xbf196000}, {0xbf198000}, {0xbf19a000}, {0xbf19c000}, {0xbf19e000}, {0xbf1a0000}, {0xbf1a2000}, {0xbf1a4000}, {0xbf1a6000}, {0xbf1a8000}, {0xbf1aa000}, {0xbf1ac000}, {0xbf1ae000}, {0xbf1b0000}, {0xbf1b2000}, {0xbf1b4000}, {0xbf1b6000}, {0xbf1b8000}, {0xbf1ba000}, {0xbf1bc000}, {0xbf1be000}, {0xbf1c0000}, {0xbf1c2000}, {0xbf1c4000}, {0xbf1c6000}, {0xbf1c8000}, {0xbf1ca000}, {0xbf1cc000}, {0xbf1ce000}, {0xbf1d0000}, {0xbf1d2000}, {0xbf1d4000}, {0xbf1d6000}, {0xbf1d8000}, {0xbf1da000}, {0xbf1dc000}, {0xbf1de000}, {0xbf1e0000}, {0xbf1e2000}, {0xbf1e4000}, {0xbf1e6000}, {0xbf1e8000}, {0xbf1ea000}, {0xbf1ec000}, {0xbf1ee000}, {0xbf1f0000}, {0xbf1f2000}, {0xbf1f4000}, {0xbf1f6000}, {0xbf1f8000}, {0xbf1fa000}, {0xbf1fc000}, {0xbf1fe000}, {0xbf200000}, {0xbf202000}, {0xbf204000}, {0xbf206000}, {0xbf208000}, {0xbf20a000}, {0xbf20c000}, {0xbf20e000}, {0xbf210000}, {0xbf212000}, {0xbf214000}, {0xbf216000}, {0xbf218000}, {0xbf21a000}, {0xbf21c000}, {0xbf21e000}, {0xbf220000}, {0xbf222000}, {0xbf224000}, {0xbf226000}, {0xbf228000}, {0xbf22a000}, {0xbf22c000}, {0xbf22e000}, {0xbf230000}, {0xbf232000}, {0xbf234000}, {0xbf236000}, {0xbf238000}, {0xbf23a000}, {0xbf23c000}, {0xbf23e000}, {0xbf240000}, {0xbf242000}, {0xbf244000}, {0xbf246000}, {0xbf248000}, {0xbf24a000}, {0xbf24c000}, {0xbf24e000}, {0xbf250000}, {0xbf252000}, {0xbf254000}, {0xbf256000}, {0xbf258000}, {0xbf25a000}, {0xbf25c000}, {0xbf25e000}, {0xbf260000}, {0xbf262000}, {0xbf264000}, {0xbf266000}, {0xbf268000}, {0xbf26a000}, {0xbf26c000}, {0xbf26e000}, {0xbf270000}, {0xbf272000}, {0xbf274000}, {0xbf276000}, {0xbf278000}, {0xbf27a000}, {0xbf27c000}, {0xbf27e000}, {0xbf280000}, {0xbf282000}, {0xbf284000}, {0xbf286000}, {0xbf288000}, {0xbf28a000}, {0xbf28c000}, {0xbf28e000}, {0xbf290000}, {0xbf292000}, {0xbf294000}, {0xbf296000}, {0xbf298000}, {0xbf29a000}, {0xbf29c000}, {0xbf29e000}, {0xbf2a0000}, {0xbf2a2000}, {0xbf2a4000}, {0xbf2a6000}, {0xbf2a8000}, {0xbf2aa000}, {0xbf2ac000}, {0xbf2ae000}, {0xbf2b0000}, {0xbf2b2000}, {0xbf2b4000}, {0xbf2b6000}, {0xbf2b8000}, {0xbf2ba000}, {0xbf2bc000}, {0xbf2be000}, {0xbf2c0000}, {0xbf2c2000}, {0xbf2c4000}, {0xbf2c6000}, {0xbf2c8000}, {0xbf2ca000}, {0xbf2cc000}, {0xbf2ce000}, {0xbf2d0000}, {0xbf2d2000}, {0xbf2d4000}, {0xbf2d6000}, {0xbf2d8000}, {0xbf2da000}, {0xbf2dc000}, {0xbf2de000}, {0xbf2e0000}, {0xbf2e2000}, {0xbf2e4000}, {0xbf2e6000}, {0xbf2e8000}, {0xbf2ea000}, {0xbf2ec000}, {0xbf2ee000}, {0xbf2f0000}, {0xbf2f2000}, {0xbf2f4000}, {0xbf2f6000}, {0xbf2f8000}, {0xbf2fa000}, {0xbf2fc000}, {0xbf2fe000}, {0xbf300000}, {0xbf302000}, {0xbf304000}, {0xbf306000}, {0xbf308000}, {0xbf30a000}, {0xbf30c000}, {0xbf30e000}, {0xbf310000}, {0xbf312000}, {0xbf314000}, {0xbf316000}, {0xbf318000}, {0xbf31a000}, {0xbf31c000}, {0xbf31e000}, {0xbf320000}, {0xbf322000}, {0xbf324000}, {0xbf326000}, {0xbf328000}, {0xbf32a000}, {0xbf32c000}, {0xbf32e000}, {0xbf330000}, {0xbf332000}, {0xbf334000}, {0xbf336000}, {0xbf338000}, {0xbf33a000}, {0xbf33c000}, {0xbf33e000}, {0xbf340000}, {0xbf342000}, {0xbf344000}, {0xbf346000}, {0xbf348000}, {0xbf34a000}, {0xbf34c000}, {0xbf34e000}, {0xbf350000}, {0xbf352000}, {0xbf354000}, {0xbf356000}, {0xbf358000}, {0xbf35a000}, {0xbf35c000}, {0xbf35e000}, {0xbf360000}, {0xbf362000}, {0xbf364000}, {0xbf366000}, {0xbf368000}, {0xbf36a000}, {0xbf36c000}, {0xbf36e000}, {0xbf370000}, {0xbf372000}, {0xbf374000}, {0xbf376000}, {0xbf378000}, {0xbf37a000}, {0xbf37c000}, {0xbf37e000}, {0xbf380000}, {0xbf382000}, {0xbf384000}, {0xbf386000}, {0xbf388000}, {0xbf38a000}, {0xbf38c000}, {0xbf38e000}, {0xbf390000}, {0xbf392000}, {0xbf394000}, {0xbf396000}, {0xbf398000}, {0xbf39a000}, {0xbf39c000}, {0xbf39e000}, {0xbf3a0000}, {0xbf3a2000}, {0xbf3a4000}, {0xbf3a6000}, {0xbf3a8000}, {0xbf3aa000}, {0xbf3ac000}, {0xbf3ae000}, {0xbf3b0000}, {0xbf3b2000}, {0xbf3b4000}, {0xbf3b6000}, {0xbf3b8000}, {0xbf3ba000}, {0xbf3bc000}, {0xbf3be000}, {0xbf3c0000}, {0xbf3c2000}, {0xbf3c4000}, {0xbf3c6000}, {0xbf3c8000}, {0xbf3ca000}, {0xbf3cc000}, {0xbf3ce000}, {0xbf3d0000}, {0xbf3d2000}, {0xbf3d4000}, {0xbf3d6000}, {0xbf3d8000}, {0xbf3da000}, {0xbf3dc000}, {0xbf3de000}, {0xbf3e0000}, {0xbf3e2000}, {0xbf3e4000}, {0xbf3e6000}, {0xbf3e8000}, {0xbf3ea000}, {0xbf3ec000}, {0xbf3ee000}, {0xbf3f0000}, {0xbf3f2000}, {0xbf3f4000}, {0xbf3f6000}, {0xbf3f8000}, {0xbf3fa000}, {0xbf3fc000}, {0xbf3fe000}, {0xbf400000}, {0xbf402000}, {0xbf404000}, {0xbf406000}, {0xbf408000}, {0xbf40a000}, {0xbf40c000}, {0xbf40e000}, {0xbf410000}, {0xbf412000}, {0xbf414000}, {0xbf416000}, {0xbf418000}, {0xbf41a000}, {0xbf41c000}, {0xbf41e000}, {0xbf420000}, {0xbf422000}, {0xbf424000}, {0xbf426000}, {0xbf428000}, {0xbf42a000}, {0xbf42c000}, {0xbf42e000}, {0xbf430000}, {0xbf432000}, {0xbf434000}, {0xbf436000}, {0xbf438000}, {0xbf43a000}, {0xbf43c000}, {0xbf43e000}, {0xbf440000}, {0xbf442000}, {0xbf444000}, {0xbf446000}, {0xbf448000}, {0xbf44a000}, {0xbf44c000}, {0xbf44e000}, {0xbf450000}, {0xbf452000}, {0xbf454000}, {0xbf456000}, {0xbf458000}, {0xbf45a000}, {0xbf45c000}, {0xbf45e000}, {0xbf460000}, {0xbf462000}, {0xbf464000}, {0xbf466000}, {0xbf468000}, {0xbf46a000}, {0xbf46c000}, {0xbf46e000}, {0xbf470000}, {0xbf472000}, {0xbf474000}, {0xbf476000}, {0xbf478000}, {0xbf47a000}, {0xbf47c000}, {0xbf47e000}, {0xbf480000}, {0xbf482000}, {0xbf484000}, {0xbf486000}, {0xbf488000}, {0xbf48a000}, {0xbf48c000}, {0xbf48e000}, {0xbf490000}, {0xbf492000}, {0xbf494000}, {0xbf496000}, {0xbf498000}, {0xbf49a000}, {0xbf49c000}, {0xbf49e000}, {0xbf4a0000}, {0xbf4a2000}, {0xbf4a4000}, {0xbf4a6000}, {0xbf4a8000}, {0xbf4aa000}, {0xbf4ac000}, {0xbf4ae000}, {0xbf4b0000}, {0xbf4b2000}, {0xbf4b4000}, {0xbf4b6000}, {0xbf4b8000}, {0xbf4ba000}, {0xbf4bc000}, {0xbf4be000}, {0xbf4c0000}, {0xbf4c2000}, {0xbf4c4000}, {0xbf4c6000}, {0xbf4c8000}, {0xbf4ca000}, {0xbf4cc000}, {0xbf4ce000}, {0xbf4d0000}, {0xbf4d2000}, {0xbf4d4000}, {0xbf4d6000}, {0xbf4d8000}, {0xbf4da000}, {0xbf4dc000}, {0xbf4de000}, {0xbf4e0000}, {0xbf4e2000}, {0xbf4e4000}, {0xbf4e6000}, {0xbf4e8000}, {0xbf4ea000}, {0xbf4ec000}, {0xbf4ee000}, {0xbf4f0000}, {0xbf4f2000}, {0xbf4f4000}, {0xbf4f6000}, {0xbf4f8000}, {0xbf4fa000}, {0xbf4fc000}, {0xbf4fe000}, {0xbf500000}, {0xbf502000}, {0xbf504000}, {0xbf506000}, {0xbf508000}, {0xbf50a000}, {0xbf50c000}, {0xbf50e000}, {0xbf510000}, {0xbf512000}, {0xbf514000}, {0xbf516000}, {0xbf518000}, {0xbf51a000}, {0xbf51c000}, {0xbf51e000}, {0xbf520000}, {0xbf522000}, {0xbf524000}, {0xbf526000}, {0xbf528000}, {0xbf52a000}, {0xbf52c000}, {0xbf52e000}, {0xbf530000}, {0xbf532000}, {0xbf534000}, {0xbf536000}, {0xbf538000}, {0xbf53a000}, {0xbf53c000}, {0xbf53e000}, {0xbf540000}, {0xbf542000}, {0xbf544000}, {0xbf546000}, {0xbf548000}, {0xbf54a000}, {0xbf54c000}, {0xbf54e000}, {0xbf550000}, {0xbf552000}, {0xbf554000}, {0xbf556000}, {0xbf558000}, {0xbf55a000}, {0xbf55c000}, {0xbf55e000}, {0xbf560000}, {0xbf562000}, {0xbf564000}, {0xbf566000}, {0xbf568000}, {0xbf56a000}, {0xbf56c000}, {0xbf56e000}, {0xbf570000}, {0xbf572000}, {0xbf574000}, {0xbf576000}, {0xbf578000}, {0xbf57a000}, {0xbf57c000}, {0xbf57e000}, {0xbf580000}, {0xbf582000}, {0xbf584000}, {0xbf586000}, {0xbf588000}, {0xbf58a000}, {0xbf58c000}, {0xbf58e000}, {0xbf590000}, {0xbf592000}, {0xbf594000}, {0xbf596000}, {0xbf598000}, {0xbf59a000}, {0xbf59c000}, {0xbf59e000}, {0xbf5a0000}, {0xbf5a2000}, {0xbf5a4000}, {0xbf5a6000}, {0xbf5a8000}, {0xbf5aa000}, {0xbf5ac000}, {0xbf5ae000}, {0xbf5b0000}, {0xbf5b2000}, {0xbf5b4000}, {0xbf5b6000}, {0xbf5b8000}, {0xbf5ba000}, {0xbf5bc000}, {0xbf5be000}, {0xbf5c0000}, {0xbf5c2000}, {0xbf5c4000}, {0xbf5c6000}, {0xbf5c8000}, {0xbf5ca000}, {0xbf5cc000}, {0xbf5ce000}, {0xbf5d0000}, {0xbf5d2000}, {0xbf5d4000}, {0xbf5d6000}, {0xbf5d8000}, {0xbf5da000}, {0xbf5dc000}, {0xbf5de000}, {0xbf5e0000}, {0xbf5e2000}, {0xbf5e4000}, {0xbf5e6000}, {0xbf5e8000}, {0xbf5ea000}, {0xbf5ec000}, {0xbf5ee000}, {0xbf5f0000}, {0xbf5f2000}, {0xbf5f4000}, {0xbf5f6000}, {0xbf5f8000}, {0xbf5fa000}, {0xbf5fc000}, {0xbf5fe000}, {0xbf600000}, {0xbf602000}, {0xbf604000}, {0xbf606000}, {0xbf608000}, {0xbf60a000}, {0xbf60c000}, {0xbf60e000}, {0xbf610000}, {0xbf612000}, {0xbf614000}, {0xbf616000}, {0xbf618000}, {0xbf61a000}, {0xbf61c000}, {0xbf61e000}, {0xbf620000}, {0xbf622000}, {0xbf624000}, {0xbf626000}, {0xbf628000}, {0xbf62a000}, {0xbf62c000}, {0xbf62e000}, {0xbf630000}, {0xbf632000}, {0xbf634000}, {0xbf636000}, {0xbf638000}, {0xbf63a000}, {0xbf63c000}, {0xbf63e000}, {0xbf640000}, {0xbf642000}, {0xbf644000}, {0xbf646000}, {0xbf648000}, {0xbf64a000}, {0xbf64c000}, {0xbf64e000}, {0xbf650000}, {0xbf652000}, {0xbf654000}, {0xbf656000}, {0xbf658000}, {0xbf65a000}, {0xbf65c000}, {0xbf65e000}, {0xbf660000}, {0xbf662000}, {0xbf664000}, {0xbf666000}, {0xbf668000}, {0xbf66a000}, {0xbf66c000}, {0xbf66e000}, {0xbf670000}, {0xbf672000}, {0xbf674000}, {0xbf676000}, {0xbf678000}, {0xbf67a000}, {0xbf67c000}, {0xbf67e000}, {0xbf680000}, {0xbf682000}, {0xbf684000}, {0xbf686000}, {0xbf688000}, {0xbf68a000}, {0xbf68c000}, {0xbf68e000}, {0xbf690000}, {0xbf692000}, {0xbf694000}, {0xbf696000}, {0xbf698000}, {0xbf69a000}, {0xbf69c000}, {0xbf69e000}, {0xbf6a0000}, {0xbf6a2000}, {0xbf6a4000}, {0xbf6a6000}, {0xbf6a8000}, {0xbf6aa000}, {0xbf6ac000}, {0xbf6ae000}, {0xbf6b0000}, {0xbf6b2000}, {0xbf6b4000}, {0xbf6b6000}, {0xbf6b8000}, {0xbf6ba000}, {0xbf6bc000}, {0xbf6be000}, {0xbf6c0000}, {0xbf6c2000}, {0xbf6c4000}, {0xbf6c6000}, {0xbf6c8000}, {0xbf6ca000}, {0xbf6cc000}, {0xbf6ce000}, {0xbf6d0000}, {0xbf6d2000}, {0xbf6d4000}, {0xbf6d6000}, {0xbf6d8000}, {0xbf6da000}, {0xbf6dc000}, {0xbf6de000}, {0xbf6e0000}, {0xbf6e2000}, {0xbf6e4000}, {0xbf6e6000}, {0xbf6e8000}, {0xbf6ea000}, {0xbf6ec000}, {0xbf6ee000}, {0xbf6f0000}, {0xbf6f2000}, {0xbf6f4000}, {0xbf6f6000}, {0xbf6f8000}, {0xbf6fa000}, {0xbf6fc000}, {0xbf6fe000}, {0xbf700000}, {0xbf702000}, {0xbf704000}, {0xbf706000}, {0xbf708000}, {0xbf70a000}, {0xbf70c000}, {0xbf70e000}, {0xbf710000}, {0xbf712000}, {0xbf714000}, {0xbf716000}, {0xbf718000}, {0xbf71a000}, {0xbf71c000}, {0xbf71e000}, {0xbf720000}, {0xbf722000}, {0xbf724000}, {0xbf726000}, {0xbf728000}, {0xbf72a000}, {0xbf72c000}, {0xbf72e000}, {0xbf730000}, {0xbf732000}, {0xbf734000}, {0xbf736000}, {0xbf738000}, {0xbf73a000}, {0xbf73c000}, {0xbf73e000}, {0xbf740000}, {0xbf742000}, {0xbf744000}, {0xbf746000}, {0xbf748000}, {0xbf74a000}, {0xbf74c000}, {0xbf74e000}, {0xbf750000}, {0xbf752000}, {0xbf754000}, {0xbf756000}, {0xbf758000}, {0xbf75a000}, {0xbf75c000}, {0xbf75e000}, {0xbf760000}, {0xbf762000}, {0xbf764000}, {0xbf766000}, {0xbf768000}, {0xbf76a000}, {0xbf76c000}, {0xbf76e000}, {0xbf770000}, {0xbf772000}, {0xbf774000}, {0xbf776000}, {0xbf778000}, {0xbf77a000}, {0xbf77c000}, {0xbf77e000}, {0xbf780000}, {0xbf782000}, {0xbf784000}, {0xbf786000}, {0xbf788000}, {0xbf78a000}, {0xbf78c000}, {0xbf78e000}, {0xbf790000}, {0xbf792000}, {0xbf794000}, {0xbf796000}, {0xbf798000}, {0xbf79a000}, {0xbf79c000}, {0xbf79e000}, {0xbf7a0000}, {0xbf7a2000}, {0xbf7a4000}, {0xbf7a6000}, {0xbf7a8000}, {0xbf7aa000}, {0xbf7ac000}, {0xbf7ae000}, {0xbf7b0000}, {0xbf7b2000}, {0xbf7b4000}, {0xbf7b6000}, {0xbf7b8000}, {0xbf7ba000}, {0xbf7bc000}, {0xbf7be000}, {0xbf7c0000}, {0xbf7c2000}, {0xbf7c4000}, {0xbf7c6000}, {0xbf7c8000}, {0xbf7ca000}, {0xbf7cc000}, {0xbf7ce000}, {0xbf7d0000}, {0xbf7d2000}, {0xbf7d4000}, {0xbf7d6000}, {0xbf7d8000}, {0xbf7da000}, {0xbf7dc000}, {0xbf7de000}, {0xbf7e0000}, {0xbf7e2000}, {0xbf7e4000}, {0xbf7e6000}, {0xbf7e8000}, {0xbf7ea000}, {0xbf7ec000}, {0xbf7ee000}, {0xbf7f0000}, {0xbf7f2000}, {0xbf7f4000}, {0xbf7f6000}, {0xbf7f8000}, {0xbf7fa000}, {0xbf7fc000}, {0xbf7fe000}, {0xbf800000}, {0xbf802000}, {0xbf804000}, {0xbf806000}, {0xbf808000}, {0xbf80a000}, {0xbf80c000}, {0xbf80e000}, {0xbf810000}, {0xbf812000}, {0xbf814000}, {0xbf816000}, {0xbf818000}, {0xbf81a000}, {0xbf81c000}, {0xbf81e000}, {0xbf820000}, {0xbf822000}, {0xbf824000}, {0xbf826000}, {0xbf828000}, {0xbf82a000}, {0xbf82c000}, {0xbf82e000}, {0xbf830000}, {0xbf832000}, {0xbf834000}, {0xbf836000}, {0xbf838000}, {0xbf83a000}, {0xbf83c000}, {0xbf83e000}, {0xbf840000}, {0xbf842000}, {0xbf844000}, {0xbf846000}, {0xbf848000}, {0xbf84a000}, {0xbf84c000}, {0xbf84e000}, {0xbf850000}, {0xbf852000}, {0xbf854000}, {0xbf856000}, {0xbf858000}, {0xbf85a000}, {0xbf85c000}, {0xbf85e000}, {0xbf860000}, {0xbf862000}, {0xbf864000}, {0xbf866000}, {0xbf868000}, {0xbf86a000}, {0xbf86c000}, {0xbf86e000}, {0xbf870000}, {0xbf872000}, {0xbf874000}, {0xbf876000}, {0xbf878000}, {0xbf87a000}, {0xbf87c000}, {0xbf87e000}, {0xbf880000}, {0xbf882000}, {0xbf884000}, {0xbf886000}, {0xbf888000}, {0xbf88a000}, {0xbf88c000}, {0xbf88e000}, {0xbf890000}, {0xbf892000}, {0xbf894000}, {0xbf896000}, {0xbf898000}, {0xbf89a000}, {0xbf89c000}, {0xbf89e000}, {0xbf8a0000}, {0xbf8a2000}, {0xbf8a4000}, {0xbf8a6000}, {0xbf8a8000}, {0xbf8aa000}, {0xbf8ac000}, {0xbf8ae000}, {0xbf8b0000}, {0xbf8b2000}, {0xbf8b4000}, {0xbf8b6000}, {0xbf8b8000}, {0xbf8ba000}, {0xbf8bc000}, {0xbf8be000}, {0xbf8c0000}, {0xbf8c2000}, {0xbf8c4000}, {0xbf8c6000}, {0xbf8c8000}, {0xbf8ca000}, {0xbf8cc000}, {0xbf8ce000}, {0xbf8d0000}, {0xbf8d2000}, {0xbf8d4000}, {0xbf8d6000}, {0xbf8d8000}, {0xbf8da000}, {0xbf8dc000}, {0xbf8de000}, {0xbf8e0000}, {0xbf8e2000}, {0xbf8e4000}, {0xbf8e6000}, {0xbf8e8000}, {0xbf8ea000}, {0xbf8ec000}, {0xbf8ee000}, {0xbf8f0000}, {0xbf8f2000}, {0xbf8f4000}, {0xbf8f6000}, {0xbf8f8000}, {0xbf8fa000}, {0xbf8fc000}, {0xbf8fe000}, {0xbf900000}, {0xbf902000}, {0xbf904000}, {0xbf906000}, {0xbf908000}, {0xbf90a000}, {0xbf90c000}, {0xbf90e000}, {0xbf910000}, {0xbf912000}, {0xbf914000}, {0xbf916000}, {0xbf918000}, {0xbf91a000}, {0xbf91c000}, {0xbf91e000}, {0xbf920000}, {0xbf922000}, {0xbf924000}, {0xbf926000}, {0xbf928000}, {0xbf92a000}, {0xbf92c000}, {0xbf92e000}, {0xbf930000}, {0xbf932000}, {0xbf934000}, {0xbf936000}, {0xbf938000}, {0xbf93a000}, {0xbf93c000}, {0xbf93e000}, {0xbf940000}, {0xbf942000}, {0xbf944000}, {0xbf946000}, {0xbf948000}, {0xbf94a000}, {0xbf94c000}, {0xbf94e000}, {0xbf950000}, {0xbf952000}, {0xbf954000}, {0xbf956000}, {0xbf958000}, {0xbf95a000}, {0xbf95c000}, {0xbf95e000}, {0xbf960000}, {0xbf962000}, {0xbf964000}, {0xbf966000}, {0xbf968000}, {0xbf96a000}, {0xbf96c000}, {0xbf96e000}, {0xbf970000}, {0xbf972000}, {0xbf974000}, {0xbf976000}, {0xbf978000}, {0xbf97a000}, {0xbf97c000}, {0xbf97e000}, {0xbf980000}, {0xbf982000}, {0xbf984000}, {0xbf986000}, {0xbf988000}, {0xbf98a000}, {0xbf98c000}, {0xbf98e000}, {0xbf990000}, {0xbf992000}, {0xbf994000}, {0xbf996000}, {0xbf998000}, {0xbf99a000}, {0xbf99c000}, {0xbf99e000}, {0xbf9a0000}, {0xbf9a2000}, {0xbf9a4000}, {0xbf9a6000}, {0xbf9a8000}, {0xbf9aa000}, {0xbf9ac000}, {0xbf9ae000}, {0xbf9b0000}, {0xbf9b2000}, {0xbf9b4000}, {0xbf9b6000}, {0xbf9b8000}, {0xbf9ba000}, {0xbf9bc000}, {0xbf9be000}, {0xbf9c0000}, {0xbf9c2000}, {0xbf9c4000}, {0xbf9c6000}, {0xbf9c8000}, {0xbf9ca000}, {0xbf9cc000}, {0xbf9ce000}, {0xbf9d0000}, {0xbf9d2000}, {0xbf9d4000}, {0xbf9d6000}, {0xbf9d8000}, {0xbf9da000}, {0xbf9dc000}, {0xbf9de000}, {0xbf9e0000}, {0xbf9e2000}, {0xbf9e4000}, {0xbf9e6000}, {0xbf9e8000}, {0xbf9ea000}, {0xbf9ec000}, {0xbf9ee000}, {0xbf9f0000}, {0xbf9f2000}, {0xbf9f4000}, {0xbf9f6000}, {0xbf9f8000}, {0xbf9fa000}, {0xbf9fc000}, {0xbf9fe000}, {0xbfa00000}, {0xbfa02000}, {0xbfa04000}, {0xbfa06000}, {0xbfa08000}, {0xbfa0a000}, {0xbfa0c000}, {0xbfa0e000}, {0xbfa10000}, {0xbfa12000}, {0xbfa14000}, {0xbfa16000}, {0xbfa18000}, {0xbfa1a000}, {0xbfa1c000}, {0xbfa1e000}, {0xbfa20000}, {0xbfa22000}, {0xbfa24000}, {0xbfa26000}, {0xbfa28000}, {0xbfa2a000}, {0xbfa2c000}, {0xbfa2e000}, {0xbfa30000}, {0xbfa32000}, {0xbfa34000}, {0xbfa36000}, {0xbfa38000}, {0xbfa3a000}, {0xbfa3c000}, {0xbfa3e000}, {0xbfa40000}, {0xbfa42000}, {0xbfa44000}, {0xbfa46000}, {0xbfa48000}, {0xbfa4a000}, {0xbfa4c000}, {0xbfa4e000}, {0xbfa50000}, {0xbfa52000}, {0xbfa54000}, {0xbfa56000}, {0xbfa58000}, {0xbfa5a000}, {0xbfa5c000}, {0xbfa5e000}, {0xbfa60000}, {0xbfa62000}, {0xbfa64000}, {0xbfa66000}, {0xbfa68000}, {0xbfa6a000}, {0xbfa6c000}, {0xbfa6e000}, {0xbfa70000}, {0xbfa72000}, {0xbfa74000}, {0xbfa76000}, {0xbfa78000}, {0xbfa7a000}, {0xbfa7c000}, {0xbfa7e000}, {0xbfa80000}, {0xbfa82000}, {0xbfa84000}, {0xbfa86000}, {0xbfa88000}, {0xbfa8a000}, {0xbfa8c000}, {0xbfa8e000}, {0xbfa90000}, {0xbfa92000}, {0xbfa94000}, {0xbfa96000}, {0xbfa98000}, {0xbfa9a000}, {0xbfa9c000}, {0xbfa9e000}, {0xbfaa0000}, {0xbfaa2000}, {0xbfaa4000}, {0xbfaa6000}, {0xbfaa8000}, {0xbfaaa000}, {0xbfaac000}, {0xbfaae000}, {0xbfab0000}, {0xbfab2000}, {0xbfab4000}, {0xbfab6000}, {0xbfab8000}, {0xbfaba000}, {0xbfabc000}, {0xbfabe000}, {0xbfac0000}, {0xbfac2000}, {0xbfac4000}, {0xbfac6000}, {0xbfac8000}, {0xbfaca000}, {0xbfacc000}, {0xbface000}, {0xbfad0000}, {0xbfad2000}, {0xbfad4000}, {0xbfad6000}, {0xbfad8000}, {0xbfada000}, {0xbfadc000}, {0xbfade000}, {0xbfae0000}, {0xbfae2000}, {0xbfae4000}, {0xbfae6000}, {0xbfae8000}, {0xbfaea000}, {0xbfaec000}, {0xbfaee000}, {0xbfaf0000}, {0xbfaf2000}, {0xbfaf4000}, {0xbfaf6000}, {0xbfaf8000}, {0xbfafa000}, {0xbfafc000}, {0xbfafe000}, {0xbfb00000}, {0xbfb02000}, {0xbfb04000}, {0xbfb06000}, {0xbfb08000}, {0xbfb0a000}, {0xbfb0c000}, {0xbfb0e000}, {0xbfb10000}, {0xbfb12000}, {0xbfb14000}, {0xbfb16000}, {0xbfb18000}, {0xbfb1a000}, {0xbfb1c000}, {0xbfb1e000}, {0xbfb20000}, {0xbfb22000}, {0xbfb24000}, {0xbfb26000}, {0xbfb28000}, {0xbfb2a000}, {0xbfb2c000}, {0xbfb2e000}, {0xbfb30000}, {0xbfb32000}, {0xbfb34000}, {0xbfb36000}, {0xbfb38000}, {0xbfb3a000}, {0xbfb3c000}, {0xbfb3e000}, {0xbfb40000}, {0xbfb42000}, {0xbfb44000}, {0xbfb46000}, {0xbfb48000}, {0xbfb4a000}, {0xbfb4c000}, {0xbfb4e000}, {0xbfb50000}, {0xbfb52000}, {0xbfb54000}, {0xbfb56000}, {0xbfb58000}, {0xbfb5a000}, {0xbfb5c000}, {0xbfb5e000}, {0xbfb60000}, {0xbfb62000}, {0xbfb64000}, {0xbfb66000}, {0xbfb68000}, {0xbfb6a000}, {0xbfb6c000}, {0xbfb6e000}, {0xbfb70000}, {0xbfb72000}, {0xbfb74000}, {0xbfb76000}, {0xbfb78000}, {0xbfb7a000}, {0xbfb7c000}, {0xbfb7e000}, {0xbfb80000}, {0xbfb82000}, {0xbfb84000}, {0xbfb86000}, {0xbfb88000}, {0xbfb8a000}, {0xbfb8c000}, {0xbfb8e000}, {0xbfb90000}, {0xbfb92000}, {0xbfb94000}, {0xbfb96000}, {0xbfb98000}, {0xbfb9a000}, {0xbfb9c000}, {0xbfb9e000}, {0xbfba0000}, {0xbfba2000}, {0xbfba4000}, {0xbfba6000}, {0xbfba8000}, {0xbfbaa000}, {0xbfbac000}, {0xbfbae000}, {0xbfbb0000}, {0xbfbb2000}, {0xbfbb4000}, {0xbfbb6000}, {0xbfbb8000}, {0xbfbba000}, {0xbfbbc000}, {0xbfbbe000}, {0xbfbc0000}, {0xbfbc2000}, {0xbfbc4000}, {0xbfbc6000}, {0xbfbc8000}, {0xbfbca000}, {0xbfbcc000}, {0xbfbce000}, {0xbfbd0000}, {0xbfbd2000}, {0xbfbd4000}, {0xbfbd6000}, {0xbfbd8000}, {0xbfbda000}, {0xbfbdc000}, {0xbfbde000}, {0xbfbe0000}, {0xbfbe2000}, {0xbfbe4000}, {0xbfbe6000}, {0xbfbe8000}, {0xbfbea000}, {0xbfbec000}, {0xbfbee000}, {0xbfbf0000}, {0xbfbf2000}, {0xbfbf4000}, {0xbfbf6000}, {0xbfbf8000}, {0xbfbfa000}, {0xbfbfc000}, {0xbfbfe000}, {0xbfc00000}, {0xbfc02000}, {0xbfc04000}, {0xbfc06000}, {0xbfc08000}, {0xbfc0a000}, {0xbfc0c000}, {0xbfc0e000}, {0xbfc10000}, {0xbfc12000}, {0xbfc14000}, {0xbfc16000}, {0xbfc18000}, {0xbfc1a000}, {0xbfc1c000}, {0xbfc1e000}, {0xbfc20000}, {0xbfc22000}, {0xbfc24000}, {0xbfc26000}, {0xbfc28000}, {0xbfc2a000}, {0xbfc2c000}, {0xbfc2e000}, {0xbfc30000}, {0xbfc32000}, {0xbfc34000}, {0xbfc36000}, {0xbfc38000}, {0xbfc3a000}, {0xbfc3c000}, {0xbfc3e000}, {0xbfc40000}, {0xbfc42000}, {0xbfc44000}, {0xbfc46000}, {0xbfc48000}, {0xbfc4a000}, {0xbfc4c000}, {0xbfc4e000}, {0xbfc50000}, {0xbfc52000}, {0xbfc54000}, {0xbfc56000}, {0xbfc58000}, {0xbfc5a000}, {0xbfc5c000}, {0xbfc5e000}, {0xbfc60000}, {0xbfc62000}, {0xbfc64000}, {0xbfc66000}, {0xbfc68000}, {0xbfc6a000}, {0xbfc6c000}, {0xbfc6e000}, {0xbfc70000}, {0xbfc72000}, {0xbfc74000}, {0xbfc76000}, {0xbfc78000}, {0xbfc7a000}, {0xbfc7c000}, {0xbfc7e000}, {0xbfc80000}, {0xbfc82000}, {0xbfc84000}, {0xbfc86000}, {0xbfc88000}, {0xbfc8a000}, {0xbfc8c000}, {0xbfc8e000}, {0xbfc90000}, {0xbfc92000}, {0xbfc94000}, {0xbfc96000}, {0xbfc98000}, {0xbfc9a000}, {0xbfc9c000}, {0xbfc9e000}, {0xbfca0000}, {0xbfca2000}, {0xbfca4000}, {0xbfca6000}, {0xbfca8000}, {0xbfcaa000}, {0xbfcac000}, {0xbfcae000}, {0xbfcb0000}, {0xbfcb2000}, {0xbfcb4000}, {0xbfcb6000}, {0xbfcb8000}, {0xbfcba000}, {0xbfcbc000}, {0xbfcbe000}, {0xbfcc0000}, {0xbfcc2000}, {0xbfcc4000}, {0xbfcc6000}, {0xbfcc8000}, {0xbfcca000}, {0xbfccc000}, {0xbfcce000}, {0xbfcd0000}, {0xbfcd2000}, {0xbfcd4000}, {0xbfcd6000}, {0xbfcd8000}, {0xbfcda000}, {0xbfcdc000}, {0xbfcde000}, {0xbfce0000}, {0xbfce2000}, {0xbfce4000}, {0xbfce6000}, {0xbfce8000}, {0xbfcea000}, {0xbfcec000}, {0xbfcee000}, {0xbfcf0000}, {0xbfcf2000}, {0xbfcf4000}, {0xbfcf6000}, {0xbfcf8000}, {0xbfcfa000}, {0xbfcfc000}, {0xbfcfe000}, {0xbfd00000}, {0xbfd02000}, {0xbfd04000}, {0xbfd06000}, {0xbfd08000}, {0xbfd0a000}, {0xbfd0c000}, {0xbfd0e000}, {0xbfd10000}, {0xbfd12000}, {0xbfd14000}, {0xbfd16000}, {0xbfd18000}, {0xbfd1a000}, {0xbfd1c000}, {0xbfd1e000}, {0xbfd20000}, {0xbfd22000}, {0xbfd24000}, {0xbfd26000}, {0xbfd28000}, {0xbfd2a000}, {0xbfd2c000}, {0xbfd2e000}, {0xbfd30000}, {0xbfd32000}, {0xbfd34000}, {0xbfd36000}, {0xbfd38000}, {0xbfd3a000}, {0xbfd3c000}, {0xbfd3e000}, {0xbfd40000}, {0xbfd42000}, {0xbfd44000}, {0xbfd46000}, {0xbfd48000}, {0xbfd4a000}, {0xbfd4c000}, {0xbfd4e000}, {0xbfd50000}, {0xbfd52000}, {0xbfd54000}, {0xbfd56000}, {0xbfd58000}, {0xbfd5a000}, {0xbfd5c000}, {0xbfd5e000}, {0xbfd60000}, {0xbfd62000}, {0xbfd64000}, {0xbfd66000}, {0xbfd68000}, {0xbfd6a000}, {0xbfd6c000}, {0xbfd6e000}, {0xbfd70000}, {0xbfd72000}, {0xbfd74000}, {0xbfd76000}, {0xbfd78000}, {0xbfd7a000}, {0xbfd7c000}, {0xbfd7e000}, {0xbfd80000}, {0xbfd82000}, {0xbfd84000}, {0xbfd86000}, {0xbfd88000}, {0xbfd8a000}, {0xbfd8c000}, {0xbfd8e000}, {0xbfd90000}, {0xbfd92000}, {0xbfd94000}, {0xbfd96000}, {0xbfd98000}, {0xbfd9a000}, {0xbfd9c000}, {0xbfd9e000}, {0xbfda0000}, {0xbfda2000}, {0xbfda4000}, {0xbfda6000}, {0xbfda8000}, {0xbfdaa000}, {0xbfdac000}, {0xbfdae000}, {0xbfdb0000}, {0xbfdb2000}, {0xbfdb4000}, {0xbfdb6000}, {0xbfdb8000}, {0xbfdba000}, {0xbfdbc000}, {0xbfdbe000}, {0xbfdc0000}, {0xbfdc2000}, {0xbfdc4000}, {0xbfdc6000}, {0xbfdc8000}, {0xbfdca000}, {0xbfdcc000}, {0xbfdce000}, {0xbfdd0000}, {0xbfdd2000}, {0xbfdd4000}, {0xbfdd6000}, {0xbfdd8000}, {0xbfdda000}, {0xbfddc000}, {0xbfdde000}, {0xbfde0000}, {0xbfde2000}, {0xbfde4000}, {0xbfde6000}, {0xbfde8000}, {0xbfdea000}, {0xbfdec000}, {0xbfdee000}, {0xbfdf0000}, {0xbfdf2000}, {0xbfdf4000}, {0xbfdf6000}, {0xbfdf8000}, {0xbfdfa000}, {0xbfdfc000}, {0xbfdfe000}, {0xbfe00000}, {0xbfe02000}, {0xbfe04000}, {0xbfe06000}, {0xbfe08000}, {0xbfe0a000}, {0xbfe0c000}, {0xbfe0e000}, {0xbfe10000}, {0xbfe12000}, {0xbfe14000}, {0xbfe16000}, {0xbfe18000}, {0xbfe1a000}, {0xbfe1c000}, {0xbfe1e000}, {0xbfe20000}, {0xbfe22000}, {0xbfe24000}, {0xbfe26000}, {0xbfe28000}, {0xbfe2a000}, {0xbfe2c000}, {0xbfe2e000}, {0xbfe30000}, {0xbfe32000}, {0xbfe34000}, {0xbfe36000}, {0xbfe38000}, {0xbfe3a000}, {0xbfe3c000}, {0xbfe3e000}, {0xbfe40000}, {0xbfe42000}, {0xbfe44000}, {0xbfe46000}, {0xbfe48000}, {0xbfe4a000}, {0xbfe4c000}, {0xbfe4e000}, {0xbfe50000}, {0xbfe52000}, {0xbfe54000}, {0xbfe56000}, {0xbfe58000}, {0xbfe5a000}, {0xbfe5c000}, {0xbfe5e000}, {0xbfe60000}, {0xbfe62000}, {0xbfe64000}, {0xbfe66000}, {0xbfe68000}, {0xbfe6a000}, {0xbfe6c000}, {0xbfe6e000}, {0xbfe70000}, {0xbfe72000}, {0xbfe74000}, {0xbfe76000}, {0xbfe78000}, {0xbfe7a000}, {0xbfe7c000}, {0xbfe7e000}, {0xbfe80000}, {0xbfe82000}, {0xbfe84000}, {0xbfe86000}, {0xbfe88000}, {0xbfe8a000}, {0xbfe8c000}, {0xbfe8e000}, {0xbfe90000}, {0xbfe92000}, {0xbfe94000}, {0xbfe96000}, {0xbfe98000}, {0xbfe9a000}, {0xbfe9c000}, {0xbfe9e000}, {0xbfea0000}, {0xbfea2000}, {0xbfea4000}, {0xbfea6000}, {0xbfea8000}, {0xbfeaa000}, {0xbfeac000}, {0xbfeae000}, {0xbfeb0000}, {0xbfeb2000}, {0xbfeb4000}, {0xbfeb6000}, {0xbfeb8000}, {0xbfeba000}, {0xbfebc000}, {0xbfebe000}, {0xbfec0000}, {0xbfec2000}, {0xbfec4000}, {0xbfec6000}, {0xbfec8000}, {0xbfeca000}, {0xbfecc000}, {0xbfece000}, {0xbfed0000}, {0xbfed2000}, {0xbfed4000}, {0xbfed6000}, {0xbfed8000}, {0xbfeda000}, {0xbfedc000}, {0xbfede000}, {0xbfee0000}, {0xbfee2000}, {0xbfee4000}, {0xbfee6000}, {0xbfee8000}, {0xbfeea000}, {0xbfeec000}, {0xbfeee000}, {0xbfef0000}, {0xbfef2000}, {0xbfef4000}, {0xbfef6000}, {0xbfef8000}, {0xbfefa000}, {0xbfefc000}, {0xbfefe000}, {0xbff00000}, {0xbff02000}, {0xbff04000}, {0xbff06000}, {0xbff08000}, {0xbff0a000}, {0xbff0c000}, {0xbff0e000}, {0xbff10000}, {0xbff12000}, {0xbff14000}, {0xbff16000}, {0xbff18000}, {0xbff1a000}, {0xbff1c000}, {0xbff1e000}, {0xbff20000}, {0xbff22000}, {0xbff24000}, {0xbff26000}, {0xbff28000}, {0xbff2a000}, {0xbff2c000}, {0xbff2e000}, {0xbff30000}, {0xbff32000}, {0xbff34000}, {0xbff36000}, {0xbff38000}, {0xbff3a000}, {0xbff3c000}, {0xbff3e000}, {0xbff40000}, {0xbff42000}, {0xbff44000}, {0xbff46000}, {0xbff48000}, {0xbff4a000}, {0xbff4c000}, {0xbff4e000}, {0xbff50000}, {0xbff52000}, {0xbff54000}, {0xbff56000}, {0xbff58000}, {0xbff5a000}, {0xbff5c000}, {0xbff5e000}, {0xbff60000}, {0xbff62000}, {0xbff64000}, {0xbff66000}, {0xbff68000}, {0xbff6a000}, {0xbff6c000}, {0xbff6e000}, {0xbff70000}, {0xbff72000}, {0xbff74000}, {0xbff76000}, {0xbff78000}, {0xbff7a000}, {0xbff7c000}, {0xbff7e000}, {0xbff80000}, {0xbff82000}, {0xbff84000}, {0xbff86000}, {0xbff88000}, {0xbff8a000}, {0xbff8c000}, {0xbff8e000}, {0xbff90000}, {0xbff92000}, {0xbff94000}, {0xbff96000}, {0xbff98000}, {0xbff9a000}, {0xbff9c000}, {0xbff9e000}, {0xbffa0000}, {0xbffa2000}, {0xbffa4000}, {0xbffa6000}, {0xbffa8000}, {0xbffaa000}, {0xbffac000}, {0xbffae000}, {0xbffb0000}, {0xbffb2000}, {0xbffb4000}, {0xbffb6000}, {0xbffb8000}, {0xbffba000}, {0xbffbc000}, {0xbffbe000}, {0xbffc0000}, {0xbffc2000}, {0xbffc4000}, {0xbffc6000}, {0xbffc8000}, {0xbffca000}, {0xbffcc000}, {0xbffce000}, {0xbffd0000}, {0xbffd2000}, {0xbffd4000}, {0xbffd6000}, {0xbffd8000}, {0xbffda000}, {0xbffdc000}, {0xbffde000}, {0xbffe0000}, {0xbffe2000}, {0xbffe4000}, {0xbffe6000}, {0xbffe8000}, {0xbffea000}, {0xbffec000}, {0xbffee000}, {0xbfff0000}, {0xbfff2000}, {0xbfff4000}, {0xbfff6000}, {0xbfff8000}, {0xbfffa000}, {0xbfffc000}, {0xbfffe000}, {0xc0000000}, {0xc0002000}, {0xc0004000}, {0xc0006000}, {0xc0008000}, {0xc000a000}, {0xc000c000}, {0xc000e000}, {0xc0010000}, {0xc0012000}, {0xc0014000}, {0xc0016000}, {0xc0018000}, {0xc001a000}, {0xc001c000}, {0xc001e000}, {0xc0020000}, {0xc0022000}, {0xc0024000}, {0xc0026000}, {0xc0028000}, {0xc002a000}, {0xc002c000}, {0xc002e000}, {0xc0030000}, {0xc0032000}, {0xc0034000}, {0xc0036000}, {0xc0038000}, {0xc003a000}, {0xc003c000}, {0xc003e000}, {0xc0040000}, {0xc0042000}, {0xc0044000}, {0xc0046000}, {0xc0048000}, {0xc004a000}, {0xc004c000}, {0xc004e000}, {0xc0050000}, {0xc0052000}, {0xc0054000}, {0xc0056000}, {0xc0058000}, {0xc005a000}, {0xc005c000}, {0xc005e000}, {0xc0060000}, {0xc0062000}, {0xc0064000}, {0xc0066000}, {0xc0068000}, {0xc006a000}, {0xc006c000}, {0xc006e000}, {0xc0070000}, {0xc0072000}, {0xc0074000}, {0xc0076000}, {0xc0078000}, {0xc007a000}, {0xc007c000}, {0xc007e000}, {0xc0080000}, {0xc0082000}, {0xc0084000}, {0xc0086000}, {0xc0088000}, {0xc008a000}, {0xc008c000}, {0xc008e000}, {0xc0090000}, {0xc0092000}, {0xc0094000}, {0xc0096000}, {0xc0098000}, {0xc009a000}, {0xc009c000}, {0xc009e000}, {0xc00a0000}, {0xc00a2000}, {0xc00a4000}, {0xc00a6000}, {0xc00a8000}, {0xc00aa000}, {0xc00ac000}, {0xc00ae000}, {0xc00b0000}, {0xc00b2000}, {0xc00b4000}, {0xc00b6000}, {0xc00b8000}, {0xc00ba000}, {0xc00bc000}, {0xc00be000}, {0xc00c0000}, {0xc00c2000}, {0xc00c4000}, {0xc00c6000}, {0xc00c8000}, {0xc00ca000}, {0xc00cc000}, {0xc00ce000}, {0xc00d0000}, {0xc00d2000}, {0xc00d4000}, {0xc00d6000}, {0xc00d8000}, {0xc00da000}, {0xc00dc000}, {0xc00de000}, {0xc00e0000}, {0xc00e2000}, {0xc00e4000}, {0xc00e6000}, {0xc00e8000}, {0xc00ea000}, {0xc00ec000}, {0xc00ee000}, {0xc00f0000}, {0xc00f2000}, {0xc00f4000}, {0xc00f6000}, {0xc00f8000}, {0xc00fa000}, {0xc00fc000}, {0xc00fe000}, {0xc0100000}, {0xc0102000}, {0xc0104000}, {0xc0106000}, {0xc0108000}, {0xc010a000}, {0xc010c000}, {0xc010e000}, {0xc0110000}, {0xc0112000}, {0xc0114000}, {0xc0116000}, {0xc0118000}, {0xc011a000}, {0xc011c000}, {0xc011e000}, {0xc0120000}, {0xc0122000}, {0xc0124000}, {0xc0126000}, {0xc0128000}, {0xc012a000}, {0xc012c000}, {0xc012e000}, {0xc0130000}, {0xc0132000}, {0xc0134000}, {0xc0136000}, {0xc0138000}, {0xc013a000}, {0xc013c000}, {0xc013e000}, {0xc0140000}, {0xc0142000}, {0xc0144000}, {0xc0146000}, {0xc0148000}, {0xc014a000}, {0xc014c000}, {0xc014e000}, {0xc0150000}, {0xc0152000}, {0xc0154000}, {0xc0156000}, {0xc0158000}, {0xc015a000}, {0xc015c000}, {0xc015e000}, {0xc0160000}, {0xc0162000}, {0xc0164000}, {0xc0166000}, {0xc0168000}, {0xc016a000}, {0xc016c000}, {0xc016e000}, {0xc0170000}, {0xc0172000}, {0xc0174000}, {0xc0176000}, {0xc0178000}, {0xc017a000}, {0xc017c000}, {0xc017e000}, {0xc0180000}, {0xc0182000}, {0xc0184000}, {0xc0186000}, {0xc0188000}, {0xc018a000}, {0xc018c000}, {0xc018e000}, {0xc0190000}, {0xc0192000}, {0xc0194000}, {0xc0196000}, {0xc0198000}, {0xc019a000}, {0xc019c000}, {0xc019e000}, {0xc01a0000}, {0xc01a2000}, {0xc01a4000}, {0xc01a6000}, {0xc01a8000}, {0xc01aa000}, {0xc01ac000}, {0xc01ae000}, {0xc01b0000}, {0xc01b2000}, {0xc01b4000}, {0xc01b6000}, {0xc01b8000}, {0xc01ba000}, {0xc01bc000}, {0xc01be000}, {0xc01c0000}, {0xc01c2000}, {0xc01c4000}, {0xc01c6000}, {0xc01c8000}, {0xc01ca000}, {0xc01cc000}, {0xc01ce000}, {0xc01d0000}, {0xc01d2000}, {0xc01d4000}, {0xc01d6000}, {0xc01d8000}, {0xc01da000}, {0xc01dc000}, {0xc01de000}, {0xc01e0000}, {0xc01e2000}, {0xc01e4000}, {0xc01e6000}, {0xc01e8000}, {0xc01ea000}, {0xc01ec000}, {0xc01ee000}, {0xc01f0000}, {0xc01f2000}, {0xc01f4000}, {0xc01f6000}, {0xc01f8000}, {0xc01fa000}, {0xc01fc000}, {0xc01fe000}, {0xc0200000}, {0xc0202000}, {0xc0204000}, {0xc0206000}, {0xc0208000}, {0xc020a000}, {0xc020c000}, {0xc020e000}, {0xc0210000}, {0xc0212000}, {0xc0214000}, {0xc0216000}, {0xc0218000}, {0xc021a000}, {0xc021c000}, {0xc021e000}, {0xc0220000}, {0xc0222000}, {0xc0224000}, {0xc0226000}, {0xc0228000}, {0xc022a000}, {0xc022c000}, {0xc022e000}, {0xc0230000}, {0xc0232000}, {0xc0234000}, {0xc0236000}, {0xc0238000}, {0xc023a000}, {0xc023c000}, {0xc023e000}, {0xc0240000}, {0xc0242000}, {0xc0244000}, {0xc0246000}, {0xc0248000}, {0xc024a000}, {0xc024c000}, {0xc024e000}, {0xc0250000}, {0xc0252000}, {0xc0254000}, {0xc0256000}, {0xc0258000}, {0xc025a000}, {0xc025c000}, {0xc025e000}, {0xc0260000}, {0xc0262000}, {0xc0264000}, {0xc0266000}, {0xc0268000}, {0xc026a000}, {0xc026c000}, {0xc026e000}, {0xc0270000}, {0xc0272000}, {0xc0274000}, {0xc0276000}, {0xc0278000}, {0xc027a000}, {0xc027c000}, {0xc027e000}, {0xc0280000}, {0xc0282000}, {0xc0284000}, {0xc0286000}, {0xc0288000}, {0xc028a000}, {0xc028c000}, {0xc028e000}, {0xc0290000}, {0xc0292000}, {0xc0294000}, {0xc0296000}, {0xc0298000}, {0xc029a000}, {0xc029c000}, {0xc029e000}, {0xc02a0000}, {0xc02a2000}, {0xc02a4000}, {0xc02a6000}, {0xc02a8000}, {0xc02aa000}, {0xc02ac000}, {0xc02ae000}, {0xc02b0000}, {0xc02b2000}, {0xc02b4000}, {0xc02b6000}, {0xc02b8000}, {0xc02ba000}, {0xc02bc000}, {0xc02be000}, {0xc02c0000}, {0xc02c2000}, {0xc02c4000}, {0xc02c6000}, {0xc02c8000}, {0xc02ca000}, {0xc02cc000}, {0xc02ce000}, {0xc02d0000}, {0xc02d2000}, {0xc02d4000}, {0xc02d6000}, {0xc02d8000}, {0xc02da000}, {0xc02dc000}, {0xc02de000}, {0xc02e0000}, {0xc02e2000}, {0xc02e4000}, {0xc02e6000}, {0xc02e8000}, {0xc02ea000}, {0xc02ec000}, {0xc02ee000}, {0xc02f0000}, {0xc02f2000}, {0xc02f4000}, {0xc02f6000}, {0xc02f8000}, {0xc02fa000}, {0xc02fc000}, {0xc02fe000}, {0xc0300000}, {0xc0302000}, {0xc0304000}, {0xc0306000}, {0xc0308000}, {0xc030a000}, {0xc030c000}, {0xc030e000}, {0xc0310000}, {0xc0312000}, {0xc0314000}, {0xc0316000}, {0xc0318000}, {0xc031a000}, {0xc031c000}, {0xc031e000}, {0xc0320000}, {0xc0322000}, {0xc0324000}, {0xc0326000}, {0xc0328000}, {0xc032a000}, {0xc032c000}, {0xc032e000}, {0xc0330000}, {0xc0332000}, {0xc0334000}, {0xc0336000}, {0xc0338000}, {0xc033a000}, {0xc033c000}, {0xc033e000}, {0xc0340000}, {0xc0342000}, {0xc0344000}, {0xc0346000}, {0xc0348000}, {0xc034a000}, {0xc034c000}, {0xc034e000}, {0xc0350000}, {0xc0352000}, {0xc0354000}, {0xc0356000}, {0xc0358000}, {0xc035a000}, {0xc035c000}, {0xc035e000}, {0xc0360000}, {0xc0362000}, {0xc0364000}, {0xc0366000}, {0xc0368000}, {0xc036a000}, {0xc036c000}, {0xc036e000}, {0xc0370000}, {0xc0372000}, {0xc0374000}, {0xc0376000}, {0xc0378000}, {0xc037a000}, {0xc037c000}, {0xc037e000}, {0xc0380000}, {0xc0382000}, {0xc0384000}, {0xc0386000}, {0xc0388000}, {0xc038a000}, {0xc038c000}, {0xc038e000}, {0xc0390000}, {0xc0392000}, {0xc0394000}, {0xc0396000}, {0xc0398000}, {0xc039a000}, {0xc039c000}, {0xc039e000}, {0xc03a0000}, {0xc03a2000}, {0xc03a4000}, {0xc03a6000}, {0xc03a8000}, {0xc03aa000}, {0xc03ac000}, {0xc03ae000}, {0xc03b0000}, {0xc03b2000}, {0xc03b4000}, {0xc03b6000}, {0xc03b8000}, {0xc03ba000}, {0xc03bc000}, {0xc03be000}, {0xc03c0000}, {0xc03c2000}, {0xc03c4000}, {0xc03c6000}, {0xc03c8000}, {0xc03ca000}, {0xc03cc000}, {0xc03ce000}, {0xc03d0000}, {0xc03d2000}, {0xc03d4000}, {0xc03d6000}, {0xc03d8000}, {0xc03da000}, {0xc03dc000}, {0xc03de000}, {0xc03e0000}, {0xc03e2000}, {0xc03e4000}, {0xc03e6000}, {0xc03e8000}, {0xc03ea000}, {0xc03ec000}, {0xc03ee000}, {0xc03f0000}, {0xc03f2000}, {0xc03f4000}, {0xc03f6000}, {0xc03f8000}, {0xc03fa000}, {0xc03fc000}, {0xc03fe000}, {0xc0400000}, {0xc0402000}, {0xc0404000}, {0xc0406000}, {0xc0408000}, {0xc040a000}, {0xc040c000}, {0xc040e000}, {0xc0410000}, {0xc0412000}, {0xc0414000}, {0xc0416000}, {0xc0418000}, {0xc041a000}, {0xc041c000}, {0xc041e000}, {0xc0420000}, {0xc0422000}, {0xc0424000}, {0xc0426000}, {0xc0428000}, {0xc042a000}, {0xc042c000}, {0xc042e000}, {0xc0430000}, {0xc0432000}, {0xc0434000}, {0xc0436000}, {0xc0438000}, {0xc043a000}, {0xc043c000}, {0xc043e000}, {0xc0440000}, {0xc0442000}, {0xc0444000}, {0xc0446000}, {0xc0448000}, {0xc044a000}, {0xc044c000}, {0xc044e000}, {0xc0450000}, {0xc0452000}, {0xc0454000}, {0xc0456000}, {0xc0458000}, {0xc045a000}, {0xc045c000}, {0xc045e000}, {0xc0460000}, {0xc0462000}, {0xc0464000}, {0xc0466000}, {0xc0468000}, {0xc046a000}, {0xc046c000}, {0xc046e000}, {0xc0470000}, {0xc0472000}, {0xc0474000}, {0xc0476000}, {0xc0478000}, {0xc047a000}, {0xc047c000}, {0xc047e000}, {0xc0480000}, {0xc0482000}, {0xc0484000}, {0xc0486000}, {0xc0488000}, {0xc048a000}, {0xc048c000}, {0xc048e000}, {0xc0490000}, {0xc0492000}, {0xc0494000}, {0xc0496000}, {0xc0498000}, {0xc049a000}, {0xc049c000}, {0xc049e000}, {0xc04a0000}, {0xc04a2000}, {0xc04a4000}, {0xc04a6000}, {0xc04a8000}, {0xc04aa000}, {0xc04ac000}, {0xc04ae000}, {0xc04b0000}, {0xc04b2000}, {0xc04b4000}, {0xc04b6000}, {0xc04b8000}, {0xc04ba000}, {0xc04bc000}, {0xc04be000}, {0xc04c0000}, {0xc04c2000}, {0xc04c4000}, {0xc04c6000}, {0xc04c8000}, {0xc04ca000}, {0xc04cc000}, {0xc04ce000}, {0xc04d0000}, {0xc04d2000}, {0xc04d4000}, {0xc04d6000}, {0xc04d8000}, {0xc04da000}, {0xc04dc000}, {0xc04de000}, {0xc04e0000}, {0xc04e2000}, {0xc04e4000}, {0xc04e6000}, {0xc04e8000}, {0xc04ea000}, {0xc04ec000}, {0xc04ee000}, {0xc04f0000}, {0xc04f2000}, {0xc04f4000}, {0xc04f6000}, {0xc04f8000}, {0xc04fa000}, {0xc04fc000}, {0xc04fe000}, {0xc0500000}, {0xc0502000}, {0xc0504000}, {0xc0506000}, {0xc0508000}, {0xc050a000}, {0xc050c000}, {0xc050e000}, {0xc0510000}, {0xc0512000}, {0xc0514000}, {0xc0516000}, {0xc0518000}, {0xc051a000}, {0xc051c000}, {0xc051e000}, {0xc0520000}, {0xc0522000}, {0xc0524000}, {0xc0526000}, {0xc0528000}, {0xc052a000}, {0xc052c000}, {0xc052e000}, {0xc0530000}, {0xc0532000}, {0xc0534000}, {0xc0536000}, {0xc0538000}, {0xc053a000}, {0xc053c000}, {0xc053e000}, {0xc0540000}, {0xc0542000}, {0xc0544000}, {0xc0546000}, {0xc0548000}, {0xc054a000}, {0xc054c000}, {0xc054e000}, {0xc0550000}, {0xc0552000}, {0xc0554000}, {0xc0556000}, {0xc0558000}, {0xc055a000}, {0xc055c000}, {0xc055e000}, {0xc0560000}, {0xc0562000}, {0xc0564000}, {0xc0566000}, {0xc0568000}, {0xc056a000}, {0xc056c000}, {0xc056e000}, {0xc0570000}, {0xc0572000}, {0xc0574000}, {0xc0576000}, {0xc0578000}, {0xc057a000}, {0xc057c000}, {0xc057e000}, {0xc0580000}, {0xc0582000}, {0xc0584000}, {0xc0586000}, {0xc0588000}, {0xc058a000}, {0xc058c000}, {0xc058e000}, {0xc0590000}, {0xc0592000}, {0xc0594000}, {0xc0596000}, {0xc0598000}, {0xc059a000}, {0xc059c000}, {0xc059e000}, {0xc05a0000}, {0xc05a2000}, {0xc05a4000}, {0xc05a6000}, {0xc05a8000}, {0xc05aa000}, {0xc05ac000}, {0xc05ae000}, {0xc05b0000}, {0xc05b2000}, {0xc05b4000}, {0xc05b6000}, {0xc05b8000}, {0xc05ba000}, {0xc05bc000}, {0xc05be000}, {0xc05c0000}, {0xc05c2000}, {0xc05c4000}, {0xc05c6000}, {0xc05c8000}, {0xc05ca000}, {0xc05cc000}, {0xc05ce000}, {0xc05d0000}, {0xc05d2000}, {0xc05d4000}, {0xc05d6000}, {0xc05d8000}, {0xc05da000}, {0xc05dc000}, {0xc05de000}, {0xc05e0000}, {0xc05e2000}, {0xc05e4000}, {0xc05e6000}, {0xc05e8000}, {0xc05ea000}, {0xc05ec000}, {0xc05ee000}, {0xc05f0000}, {0xc05f2000}, {0xc05f4000}, {0xc05f6000}, {0xc05f8000}, {0xc05fa000}, {0xc05fc000}, {0xc05fe000}, {0xc0600000}, {0xc0602000}, {0xc0604000}, {0xc0606000}, {0xc0608000}, {0xc060a000}, {0xc060c000}, {0xc060e000}, {0xc0610000}, {0xc0612000}, {0xc0614000}, {0xc0616000}, {0xc0618000}, {0xc061a000}, {0xc061c000}, {0xc061e000}, {0xc0620000}, {0xc0622000}, {0xc0624000}, {0xc0626000}, {0xc0628000}, {0xc062a000}, {0xc062c000}, {0xc062e000}, {0xc0630000}, {0xc0632000}, {0xc0634000}, {0xc0636000}, {0xc0638000}, {0xc063a000}, {0xc063c000}, {0xc063e000}, {0xc0640000}, {0xc0642000}, {0xc0644000}, {0xc0646000}, {0xc0648000}, {0xc064a000}, {0xc064c000}, {0xc064e000}, {0xc0650000}, {0xc0652000}, {0xc0654000}, {0xc0656000}, {0xc0658000}, {0xc065a000}, {0xc065c000}, {0xc065e000}, {0xc0660000}, {0xc0662000}, {0xc0664000}, {0xc0666000}, {0xc0668000}, {0xc066a000}, {0xc066c000}, {0xc066e000}, {0xc0670000}, {0xc0672000}, {0xc0674000}, {0xc0676000}, {0xc0678000}, {0xc067a000}, {0xc067c000}, {0xc067e000}, {0xc0680000}, {0xc0682000}, {0xc0684000}, {0xc0686000}, {0xc0688000}, {0xc068a000}, {0xc068c000}, {0xc068e000}, {0xc0690000}, {0xc0692000}, {0xc0694000}, {0xc0696000}, {0xc0698000}, {0xc069a000}, {0xc069c000}, {0xc069e000}, {0xc06a0000}, {0xc06a2000}, {0xc06a4000}, {0xc06a6000}, {0xc06a8000}, {0xc06aa000}, {0xc06ac000}, {0xc06ae000}, {0xc06b0000}, {0xc06b2000}, {0xc06b4000}, {0xc06b6000}, {0xc06b8000}, {0xc06ba000}, {0xc06bc000}, {0xc06be000}, {0xc06c0000}, {0xc06c2000}, {0xc06c4000}, {0xc06c6000}, {0xc06c8000}, {0xc06ca000}, {0xc06cc000}, {0xc06ce000}, {0xc06d0000}, {0xc06d2000}, {0xc06d4000}, {0xc06d6000}, {0xc06d8000}, {0xc06da000}, {0xc06dc000}, {0xc06de000}, {0xc06e0000}, {0xc06e2000}, {0xc06e4000}, {0xc06e6000}, {0xc06e8000}, {0xc06ea000}, {0xc06ec000}, {0xc06ee000}, {0xc06f0000}, {0xc06f2000}, {0xc06f4000}, {0xc06f6000}, {0xc06f8000}, {0xc06fa000}, {0xc06fc000}, {0xc06fe000}, {0xc0700000}, {0xc0702000}, {0xc0704000}, {0xc0706000}, {0xc0708000}, {0xc070a000}, {0xc070c000}, {0xc070e000}, {0xc0710000}, {0xc0712000}, {0xc0714000}, {0xc0716000}, {0xc0718000}, {0xc071a000}, {0xc071c000}, {0xc071e000}, {0xc0720000}, {0xc0722000}, {0xc0724000}, {0xc0726000}, {0xc0728000}, {0xc072a000}, {0xc072c000}, {0xc072e000}, {0xc0730000}, {0xc0732000}, {0xc0734000}, {0xc0736000}, {0xc0738000}, {0xc073a000}, {0xc073c000}, {0xc073e000}, {0xc0740000}, {0xc0742000}, {0xc0744000}, {0xc0746000}, {0xc0748000}, {0xc074a000}, {0xc074c000}, {0xc074e000}, {0xc0750000}, {0xc0752000}, {0xc0754000}, {0xc0756000}, {0xc0758000}, {0xc075a000}, {0xc075c000}, {0xc075e000}, {0xc0760000}, {0xc0762000}, {0xc0764000}, {0xc0766000}, {0xc0768000}, {0xc076a000}, {0xc076c000}, {0xc076e000}, {0xc0770000}, {0xc0772000}, {0xc0774000}, {0xc0776000}, {0xc0778000}, {0xc077a000}, {0xc077c000}, {0xc077e000}, {0xc0780000}, {0xc0782000}, {0xc0784000}, {0xc0786000}, {0xc0788000}, {0xc078a000}, {0xc078c000}, {0xc078e000}, {0xc0790000}, {0xc0792000}, {0xc0794000}, {0xc0796000}, {0xc0798000}, {0xc079a000}, {0xc079c000}, {0xc079e000}, {0xc07a0000}, {0xc07a2000}, {0xc07a4000}, {0xc07a6000}, {0xc07a8000}, {0xc07aa000}, {0xc07ac000}, {0xc07ae000}, {0xc07b0000}, {0xc07b2000}, {0xc07b4000}, {0xc07b6000}, {0xc07b8000}, {0xc07ba000}, {0xc07bc000}, {0xc07be000}, {0xc07c0000}, {0xc07c2000}, {0xc07c4000}, {0xc07c6000}, {0xc07c8000}, {0xc07ca000}, {0xc07cc000}, {0xc07ce000}, {0xc07d0000}, {0xc07d2000}, {0xc07d4000}, {0xc07d6000}, {0xc07d8000}, {0xc07da000}, {0xc07dc000}, {0xc07de000}, {0xc07e0000}, {0xc07e2000}, {0xc07e4000}, {0xc07e6000}, {0xc07e8000}, {0xc07ea000}, {0xc07ec000}, {0xc07ee000}, {0xc07f0000}, {0xc07f2000}, {0xc07f4000}, {0xc07f6000}, {0xc07f8000}, {0xc07fa000}, {0xc07fc000}, {0xc07fe000}, {0xc0800000}, {0xc0802000}, {0xc0804000}, {0xc0806000}, {0xc0808000}, {0xc080a000}, {0xc080c000}, {0xc080e000}, {0xc0810000}, {0xc0812000}, {0xc0814000}, {0xc0816000}, {0xc0818000}, {0xc081a000}, {0xc081c000}, {0xc081e000}, {0xc0820000}, {0xc0822000}, {0xc0824000}, {0xc0826000}, {0xc0828000}, {0xc082a000}, {0xc082c000}, {0xc082e000}, {0xc0830000}, {0xc0832000}, {0xc0834000}, {0xc0836000}, {0xc0838000}, {0xc083a000}, {0xc083c000}, {0xc083e000}, {0xc0840000}, {0xc0842000}, {0xc0844000}, {0xc0846000}, {0xc0848000}, {0xc084a000}, {0xc084c000}, {0xc084e000}, {0xc0850000}, {0xc0852000}, {0xc0854000}, {0xc0856000}, {0xc0858000}, {0xc085a000}, {0xc085c000}, {0xc085e000}, {0xc0860000}, {0xc0862000}, {0xc0864000}, {0xc0866000}, {0xc0868000}, {0xc086a000}, {0xc086c000}, {0xc086e000}, {0xc0870000}, {0xc0872000}, {0xc0874000}, {0xc0876000}, {0xc0878000}, {0xc087a000}, {0xc087c000}, {0xc087e000}, {0xc0880000}, {0xc0882000}, {0xc0884000}, {0xc0886000}, {0xc0888000}, {0xc088a000}, {0xc088c000}, {0xc088e000}, {0xc0890000}, {0xc0892000}, {0xc0894000}, {0xc0896000}, {0xc0898000}, {0xc089a000}, {0xc089c000}, {0xc089e000}, {0xc08a0000}, {0xc08a2000}, {0xc08a4000}, {0xc08a6000}, {0xc08a8000}, {0xc08aa000}, {0xc08ac000}, {0xc08ae000}, {0xc08b0000}, {0xc08b2000}, {0xc08b4000}, {0xc08b6000}, {0xc08b8000}, {0xc08ba000}, {0xc08bc000}, {0xc08be000}, {0xc08c0000}, {0xc08c2000}, {0xc08c4000}, {0xc08c6000}, {0xc08c8000}, {0xc08ca000}, {0xc08cc000}, {0xc08ce000}, {0xc08d0000}, {0xc08d2000}, {0xc08d4000}, {0xc08d6000}, {0xc08d8000}, {0xc08da000}, {0xc08dc000}, {0xc08de000}, {0xc08e0000}, {0xc08e2000}, {0xc08e4000}, {0xc08e6000}, {0xc08e8000}, {0xc08ea000}, {0xc08ec000}, {0xc08ee000}, {0xc08f0000}, {0xc08f2000}, {0xc08f4000}, {0xc08f6000}, {0xc08f8000}, {0xc08fa000}, {0xc08fc000}, {0xc08fe000}, {0xc0900000}, {0xc0902000}, {0xc0904000}, {0xc0906000}, {0xc0908000}, {0xc090a000}, {0xc090c000}, {0xc090e000}, {0xc0910000}, {0xc0912000}, {0xc0914000}, {0xc0916000}, {0xc0918000}, {0xc091a000}, {0xc091c000}, {0xc091e000}, {0xc0920000}, {0xc0922000}, {0xc0924000}, {0xc0926000}, {0xc0928000}, {0xc092a000}, {0xc092c000}, {0xc092e000}, {0xc0930000}, {0xc0932000}, {0xc0934000}, {0xc0936000}, {0xc0938000}, {0xc093a000}, {0xc093c000}, {0xc093e000}, {0xc0940000}, {0xc0942000}, {0xc0944000}, {0xc0946000}, {0xc0948000}, {0xc094a000}, {0xc094c000}, {0xc094e000}, {0xc0950000}, {0xc0952000}, {0xc0954000}, {0xc0956000}, {0xc0958000}, {0xc095a000}, {0xc095c000}, {0xc095e000}, {0xc0960000}, {0xc0962000}, {0xc0964000}, {0xc0966000}, {0xc0968000}, {0xc096a000}, {0xc096c000}, {0xc096e000}, {0xc0970000}, {0xc0972000}, {0xc0974000}, {0xc0976000}, {0xc0978000}, {0xc097a000}, {0xc097c000}, {0xc097e000}, {0xc0980000}, {0xc0982000}, {0xc0984000}, {0xc0986000}, {0xc0988000}, {0xc098a000}, {0xc098c000}, {0xc098e000}, {0xc0990000}, {0xc0992000}, {0xc0994000}, {0xc0996000}, {0xc0998000}, {0xc099a000}, {0xc099c000}, {0xc099e000}, {0xc09a0000}, {0xc09a2000}, {0xc09a4000}, {0xc09a6000}, {0xc09a8000}, {0xc09aa000}, {0xc09ac000}, {0xc09ae000}, {0xc09b0000}, {0xc09b2000}, {0xc09b4000}, {0xc09b6000}, {0xc09b8000}, {0xc09ba000}, {0xc09bc000}, {0xc09be000}, {0xc09c0000}, {0xc09c2000}, {0xc09c4000}, {0xc09c6000}, {0xc09c8000}, {0xc09ca000}, {0xc09cc000}, {0xc09ce000}, {0xc09d0000}, {0xc09d2000}, {0xc09d4000}, {0xc09d6000}, {0xc09d8000}, {0xc09da000}, {0xc09dc000}, {0xc09de000}, {0xc09e0000}, {0xc09e2000}, {0xc09e4000}, {0xc09e6000}, {0xc09e8000}, {0xc09ea000}, {0xc09ec000}, {0xc09ee000}, {0xc09f0000}, {0xc09f2000}, {0xc09f4000}, {0xc09f6000}, {0xc09f8000}, {0xc09fa000}, {0xc09fc000}, {0xc09fe000}, {0xc0a00000}, {0xc0a02000}, {0xc0a04000}, {0xc0a06000}, {0xc0a08000}, {0xc0a0a000}, {0xc0a0c000}, {0xc0a0e000}, {0xc0a10000}, {0xc0a12000}, {0xc0a14000}, {0xc0a16000}, {0xc0a18000}, {0xc0a1a000}, {0xc0a1c000}, {0xc0a1e000}, {0xc0a20000}, {0xc0a22000}, {0xc0a24000}, {0xc0a26000}, {0xc0a28000}, {0xc0a2a000}, {0xc0a2c000}, {0xc0a2e000}, {0xc0a30000}, {0xc0a32000}, {0xc0a34000}, {0xc0a36000}, {0xc0a38000}, {0xc0a3a000}, {0xc0a3c000}, {0xc0a3e000}, {0xc0a40000}, {0xc0a42000}, {0xc0a44000}, {0xc0a46000}, {0xc0a48000}, {0xc0a4a000}, {0xc0a4c000}, {0xc0a4e000}, {0xc0a50000}, {0xc0a52000}, {0xc0a54000}, {0xc0a56000}, {0xc0a58000}, {0xc0a5a000}, {0xc0a5c000}, {0xc0a5e000}, {0xc0a60000}, {0xc0a62000}, {0xc0a64000}, {0xc0a66000}, {0xc0a68000}, {0xc0a6a000}, {0xc0a6c000}, {0xc0a6e000}, {0xc0a70000}, {0xc0a72000}, {0xc0a74000}, {0xc0a76000}, {0xc0a78000}, {0xc0a7a000}, {0xc0a7c000}, {0xc0a7e000}, {0xc0a80000}, {0xc0a82000}, {0xc0a84000}, {0xc0a86000}, {0xc0a88000}, {0xc0a8a000}, {0xc0a8c000}, {0xc0a8e000}, {0xc0a90000}, {0xc0a92000}, {0xc0a94000}, {0xc0a96000}, {0xc0a98000}, {0xc0a9a000}, {0xc0a9c000}, {0xc0a9e000}, {0xc0aa0000}, {0xc0aa2000}, {0xc0aa4000}, {0xc0aa6000}, {0xc0aa8000}, {0xc0aaa000}, {0xc0aac000}, {0xc0aae000}, {0xc0ab0000}, {0xc0ab2000}, {0xc0ab4000}, {0xc0ab6000}, {0xc0ab8000}, {0xc0aba000}, {0xc0abc000}, {0xc0abe000}, {0xc0ac0000}, {0xc0ac2000}, {0xc0ac4000}, {0xc0ac6000}, {0xc0ac8000}, {0xc0aca000}, {0xc0acc000}, {0xc0ace000}, {0xc0ad0000}, {0xc0ad2000}, {0xc0ad4000}, {0xc0ad6000}, {0xc0ad8000}, {0xc0ada000}, {0xc0adc000}, {0xc0ade000}, {0xc0ae0000}, {0xc0ae2000}, {0xc0ae4000}, {0xc0ae6000}, {0xc0ae8000}, {0xc0aea000}, {0xc0aec000}, {0xc0aee000}, {0xc0af0000}, {0xc0af2000}, {0xc0af4000}, {0xc0af6000}, {0xc0af8000}, {0xc0afa000}, {0xc0afc000}, {0xc0afe000}, {0xc0b00000}, {0xc0b02000}, {0xc0b04000}, {0xc0b06000}, {0xc0b08000}, {0xc0b0a000}, {0xc0b0c000}, {0xc0b0e000}, {0xc0b10000}, {0xc0b12000}, {0xc0b14000}, {0xc0b16000}, {0xc0b18000}, {0xc0b1a000}, {0xc0b1c000}, {0xc0b1e000}, {0xc0b20000}, {0xc0b22000}, {0xc0b24000}, {0xc0b26000}, {0xc0b28000}, {0xc0b2a000}, {0xc0b2c000}, {0xc0b2e000}, {0xc0b30000}, {0xc0b32000}, {0xc0b34000}, {0xc0b36000}, {0xc0b38000}, {0xc0b3a000}, {0xc0b3c000}, {0xc0b3e000}, {0xc0b40000}, {0xc0b42000}, {0xc0b44000}, {0xc0b46000}, {0xc0b48000}, {0xc0b4a000}, {0xc0b4c000}, {0xc0b4e000}, {0xc0b50000}, {0xc0b52000}, {0xc0b54000}, {0xc0b56000}, {0xc0b58000}, {0xc0b5a000}, {0xc0b5c000}, {0xc0b5e000}, {0xc0b60000}, {0xc0b62000}, {0xc0b64000}, {0xc0b66000}, {0xc0b68000}, {0xc0b6a000}, {0xc0b6c000}, {0xc0b6e000}, {0xc0b70000}, {0xc0b72000}, {0xc0b74000}, {0xc0b76000}, {0xc0b78000}, {0xc0b7a000}, {0xc0b7c000}, {0xc0b7e000}, {0xc0b80000}, {0xc0b82000}, {0xc0b84000}, {0xc0b86000}, {0xc0b88000}, {0xc0b8a000}, {0xc0b8c000}, {0xc0b8e000}, {0xc0b90000}, {0xc0b92000}, {0xc0b94000}, {0xc0b96000}, {0xc0b98000}, {0xc0b9a000}, {0xc0b9c000}, {0xc0b9e000}, {0xc0ba0000}, {0xc0ba2000}, {0xc0ba4000}, {0xc0ba6000}, {0xc0ba8000}, {0xc0baa000}, {0xc0bac000}, {0xc0bae000}, {0xc0bb0000}, {0xc0bb2000}, {0xc0bb4000}, {0xc0bb6000}, {0xc0bb8000}, {0xc0bba000}, {0xc0bbc000}, {0xc0bbe000}, {0xc0bc0000}, {0xc0bc2000}, {0xc0bc4000}, {0xc0bc6000}, {0xc0bc8000}, {0xc0bca000}, {0xc0bcc000}, {0xc0bce000}, {0xc0bd0000}, {0xc0bd2000}, {0xc0bd4000}, {0xc0bd6000}, {0xc0bd8000}, {0xc0bda000}, {0xc0bdc000}, {0xc0bde000}, {0xc0be0000}, {0xc0be2000}, {0xc0be4000}, {0xc0be6000}, {0xc0be8000}, {0xc0bea000}, {0xc0bec000}, {0xc0bee000}, {0xc0bf0000}, {0xc0bf2000}, {0xc0bf4000}, {0xc0bf6000}, {0xc0bf8000}, {0xc0bfa000}, {0xc0bfc000}, {0xc0bfe000}, {0xc0c00000}, {0xc0c02000}, {0xc0c04000}, {0xc0c06000}, {0xc0c08000}, {0xc0c0a000}, {0xc0c0c000}, {0xc0c0e000}, {0xc0c10000}, {0xc0c12000}, {0xc0c14000}, {0xc0c16000}, {0xc0c18000}, {0xc0c1a000}, {0xc0c1c000}, {0xc0c1e000}, {0xc0c20000}, {0xc0c22000}, {0xc0c24000}, {0xc0c26000}, {0xc0c28000}, {0xc0c2a000}, {0xc0c2c000}, {0xc0c2e000}, {0xc0c30000}, {0xc0c32000}, {0xc0c34000}, {0xc0c36000}, {0xc0c38000}, {0xc0c3a000}, {0xc0c3c000}, {0xc0c3e000}, {0xc0c40000}, {0xc0c42000}, {0xc0c44000}, {0xc0c46000}, {0xc0c48000}, {0xc0c4a000}, {0xc0c4c000}, {0xc0c4e000}, {0xc0c50000}, {0xc0c52000}, {0xc0c54000}, {0xc0c56000}, {0xc0c58000}, {0xc0c5a000}, {0xc0c5c000}, {0xc0c5e000}, {0xc0c60000}, {0xc0c62000}, {0xc0c64000}, {0xc0c66000}, {0xc0c68000}, {0xc0c6a000}, {0xc0c6c000}, {0xc0c6e000}, {0xc0c70000}, {0xc0c72000}, {0xc0c74000}, {0xc0c76000}, {0xc0c78000}, {0xc0c7a000}, {0xc0c7c000}, {0xc0c7e000}, {0xc0c80000}, {0xc0c82000}, {0xc0c84000}, {0xc0c86000}, {0xc0c88000}, {0xc0c8a000}, {0xc0c8c000}, {0xc0c8e000}, {0xc0c90000}, {0xc0c92000}, {0xc0c94000}, {0xc0c96000}, {0xc0c98000}, {0xc0c9a000}, {0xc0c9c000}, {0xc0c9e000}, {0xc0ca0000}, {0xc0ca2000}, {0xc0ca4000}, {0xc0ca6000}, {0xc0ca8000}, {0xc0caa000}, {0xc0cac000}, {0xc0cae000}, {0xc0cb0000}, {0xc0cb2000}, {0xc0cb4000}, {0xc0cb6000}, {0xc0cb8000}, {0xc0cba000}, {0xc0cbc000}, {0xc0cbe000}, {0xc0cc0000}, {0xc0cc2000}, {0xc0cc4000}, {0xc0cc6000}, {0xc0cc8000}, {0xc0cca000}, {0xc0ccc000}, {0xc0cce000}, {0xc0cd0000}, {0xc0cd2000}, {0xc0cd4000}, {0xc0cd6000}, {0xc0cd8000}, {0xc0cda000}, {0xc0cdc000}, {0xc0cde000}, {0xc0ce0000}, {0xc0ce2000}, {0xc0ce4000}, {0xc0ce6000}, {0xc0ce8000}, {0xc0cea000}, {0xc0cec000}, {0xc0cee000}, {0xc0cf0000}, {0xc0cf2000}, {0xc0cf4000}, {0xc0cf6000}, {0xc0cf8000}, {0xc0cfa000}, {0xc0cfc000}, {0xc0cfe000}, {0xc0d00000}, {0xc0d02000}, {0xc0d04000}, {0xc0d06000}, {0xc0d08000}, {0xc0d0a000}, {0xc0d0c000}, {0xc0d0e000}, {0xc0d10000}, {0xc0d12000}, {0xc0d14000}, {0xc0d16000}, {0xc0d18000}, {0xc0d1a000}, {0xc0d1c000}, {0xc0d1e000}, {0xc0d20000}, {0xc0d22000}, {0xc0d24000}, {0xc0d26000}, {0xc0d28000}, {0xc0d2a000}, {0xc0d2c000}, {0xc0d2e000}, {0xc0d30000}, {0xc0d32000}, {0xc0d34000}, {0xc0d36000}, {0xc0d38000}, {0xc0d3a000}, {0xc0d3c000}, {0xc0d3e000}, {0xc0d40000}, {0xc0d42000}, {0xc0d44000}, {0xc0d46000}, {0xc0d48000}, {0xc0d4a000}, {0xc0d4c000}, {0xc0d4e000}, {0xc0d50000}, {0xc0d52000}, {0xc0d54000}, {0xc0d56000}, {0xc0d58000}, {0xc0d5a000}, {0xc0d5c000}, {0xc0d5e000}, {0xc0d60000}, {0xc0d62000}, {0xc0d64000}, {0xc0d66000}, {0xc0d68000}, {0xc0d6a000}, {0xc0d6c000}, {0xc0d6e000}, {0xc0d70000}, {0xc0d72000}, {0xc0d74000}, {0xc0d76000}, {0xc0d78000}, {0xc0d7a000}, {0xc0d7c000}, {0xc0d7e000}, {0xc0d80000}, {0xc0d82000}, {0xc0d84000}, {0xc0d86000}, {0xc0d88000}, {0xc0d8a000}, {0xc0d8c000}, {0xc0d8e000}, {0xc0d90000}, {0xc0d92000}, {0xc0d94000}, {0xc0d96000}, {0xc0d98000}, {0xc0d9a000}, {0xc0d9c000}, {0xc0d9e000}, {0xc0da0000}, {0xc0da2000}, {0xc0da4000}, {0xc0da6000}, {0xc0da8000}, {0xc0daa000}, {0xc0dac000}, {0xc0dae000}, {0xc0db0000}, {0xc0db2000}, {0xc0db4000}, {0xc0db6000}, {0xc0db8000}, {0xc0dba000}, {0xc0dbc000}, {0xc0dbe000}, {0xc0dc0000}, {0xc0dc2000}, {0xc0dc4000}, {0xc0dc6000}, {0xc0dc8000}, {0xc0dca000}, {0xc0dcc000}, {0xc0dce000}, {0xc0dd0000}, {0xc0dd2000}, {0xc0dd4000}, {0xc0dd6000}, {0xc0dd8000}, {0xc0dda000}, {0xc0ddc000}, {0xc0dde000}, {0xc0de0000}, {0xc0de2000}, {0xc0de4000}, {0xc0de6000}, {0xc0de8000}, {0xc0dea000}, {0xc0dec000}, {0xc0dee000}, {0xc0df0000}, {0xc0df2000}, {0xc0df4000}, {0xc0df6000}, {0xc0df8000}, {0xc0dfa000}, {0xc0dfc000}, {0xc0dfe000}, {0xc0e00000}, {0xc0e02000}, {0xc0e04000}, {0xc0e06000}, {0xc0e08000}, {0xc0e0a000}, {0xc0e0c000}, {0xc0e0e000}, {0xc0e10000}, {0xc0e12000}, {0xc0e14000}, {0xc0e16000}, {0xc0e18000}, {0xc0e1a000}, {0xc0e1c000}, {0xc0e1e000}, {0xc0e20000}, {0xc0e22000}, {0xc0e24000}, {0xc0e26000}, {0xc0e28000}, {0xc0e2a000}, {0xc0e2c000}, {0xc0e2e000}, {0xc0e30000}, {0xc0e32000}, {0xc0e34000}, {0xc0e36000}, {0xc0e38000}, {0xc0e3a000}, {0xc0e3c000}, {0xc0e3e000}, {0xc0e40000}, {0xc0e42000}, {0xc0e44000}, {0xc0e46000}, {0xc0e48000}, {0xc0e4a000}, {0xc0e4c000}, {0xc0e4e000}, {0xc0e50000}, {0xc0e52000}, {0xc0e54000}, {0xc0e56000}, {0xc0e58000}, {0xc0e5a000}, {0xc0e5c000}, {0xc0e5e000}, {0xc0e60000}, {0xc0e62000}, {0xc0e64000}, {0xc0e66000}, {0xc0e68000}, {0xc0e6a000}, {0xc0e6c000}, {0xc0e6e000}, {0xc0e70000}, {0xc0e72000}, {0xc0e74000}, {0xc0e76000}, {0xc0e78000}, {0xc0e7a000}, {0xc0e7c000}, {0xc0e7e000}, {0xc0e80000}, {0xc0e82000}, {0xc0e84000}, {0xc0e86000}, {0xc0e88000}, {0xc0e8a000}, {0xc0e8c000}, {0xc0e8e000}, {0xc0e90000}, {0xc0e92000}, {0xc0e94000}, {0xc0e96000}, {0xc0e98000}, {0xc0e9a000}, {0xc0e9c000}, {0xc0e9e000}, {0xc0ea0000}, {0xc0ea2000}, {0xc0ea4000}, {0xc0ea6000}, {0xc0ea8000}, {0xc0eaa000}, {0xc0eac000}, {0xc0eae000}, {0xc0eb0000}, {0xc0eb2000}, {0xc0eb4000}, {0xc0eb6000}, {0xc0eb8000}, {0xc0eba000}, {0xc0ebc000}, {0xc0ebe000}, {0xc0ec0000}, {0xc0ec2000}, {0xc0ec4000}, {0xc0ec6000}, {0xc0ec8000}, {0xc0eca000}, {0xc0ecc000}, {0xc0ece000}, {0xc0ed0000}, {0xc0ed2000}, {0xc0ed4000}, {0xc0ed6000}, {0xc0ed8000}, {0xc0eda000}, {0xc0edc000}, {0xc0ede000}, {0xc0ee0000}, {0xc0ee2000}, {0xc0ee4000}, {0xc0ee6000}, {0xc0ee8000}, {0xc0eea000}, {0xc0eec000}, {0xc0eee000}, {0xc0ef0000}, {0xc0ef2000}, {0xc0ef4000}, {0xc0ef6000}, {0xc0ef8000}, {0xc0efa000}, {0xc0efc000}, {0xc0efe000}, {0xc0f00000}, {0xc0f02000}, {0xc0f04000}, {0xc0f06000}, {0xc0f08000}, {0xc0f0a000}, {0xc0f0c000}, {0xc0f0e000}, {0xc0f10000}, {0xc0f12000}, {0xc0f14000}, {0xc0f16000}, {0xc0f18000}, {0xc0f1a000}, {0xc0f1c000}, {0xc0f1e000}, {0xc0f20000}, {0xc0f22000}, {0xc0f24000}, {0xc0f26000}, {0xc0f28000}, {0xc0f2a000}, {0xc0f2c000}, {0xc0f2e000}, {0xc0f30000}, {0xc0f32000}, {0xc0f34000}, {0xc0f36000}, {0xc0f38000}, {0xc0f3a000}, {0xc0f3c000}, {0xc0f3e000}, {0xc0f40000}, {0xc0f42000}, {0xc0f44000}, {0xc0f46000}, {0xc0f48000}, {0xc0f4a000}, {0xc0f4c000}, {0xc0f4e000}, {0xc0f50000}, {0xc0f52000}, {0xc0f54000}, {0xc0f56000}, {0xc0f58000}, {0xc0f5a000}, {0xc0f5c000}, {0xc0f5e000}, {0xc0f60000}, {0xc0f62000}, {0xc0f64000}, {0xc0f66000}, {0xc0f68000}, {0xc0f6a000}, {0xc0f6c000}, {0xc0f6e000}, {0xc0f70000}, {0xc0f72000}, {0xc0f74000}, {0xc0f76000}, {0xc0f78000}, {0xc0f7a000}, {0xc0f7c000}, {0xc0f7e000}, {0xc0f80000}, {0xc0f82000}, {0xc0f84000}, {0xc0f86000}, {0xc0f88000}, {0xc0f8a000}, {0xc0f8c000}, {0xc0f8e000}, {0xc0f90000}, {0xc0f92000}, {0xc0f94000}, {0xc0f96000}, {0xc0f98000}, {0xc0f9a000}, {0xc0f9c000}, {0xc0f9e000}, {0xc0fa0000}, {0xc0fa2000}, {0xc0fa4000}, {0xc0fa6000}, {0xc0fa8000}, {0xc0faa000}, {0xc0fac000}, {0xc0fae000}, {0xc0fb0000}, {0xc0fb2000}, {0xc0fb4000}, {0xc0fb6000}, {0xc0fb8000}, {0xc0fba000}, {0xc0fbc000}, {0xc0fbe000}, {0xc0fc0000}, {0xc0fc2000}, {0xc0fc4000}, {0xc0fc6000}, {0xc0fc8000}, {0xc0fca000}, {0xc0fcc000}, {0xc0fce000}, {0xc0fd0000}, {0xc0fd2000}, {0xc0fd4000}, {0xc0fd6000}, {0xc0fd8000}, {0xc0fda000}, {0xc0fdc000}, {0xc0fde000}, {0xc0fe0000}, {0xc0fe2000}, {0xc0fe4000}, {0xc0fe6000}, {0xc0fe8000}, {0xc0fea000}, {0xc0fec000}, {0xc0fee000}, {0xc0ff0000}, {0xc0ff2000}, {0xc0ff4000}, {0xc0ff6000}, {0xc0ff8000}, {0xc0ffa000}, {0xc0ffc000}, {0xc0ffe000}, {0xc1000000}, {0xc1002000}, {0xc1004000}, {0xc1006000}, {0xc1008000}, {0xc100a000}, {0xc100c000}, {0xc100e000}, {0xc1010000}, {0xc1012000}, {0xc1014000}, {0xc1016000}, {0xc1018000}, {0xc101a000}, {0xc101c000}, {0xc101e000}, {0xc1020000}, {0xc1022000}, {0xc1024000}, {0xc1026000}, {0xc1028000}, {0xc102a000}, {0xc102c000}, {0xc102e000}, {0xc1030000}, {0xc1032000}, {0xc1034000}, {0xc1036000}, {0xc1038000}, {0xc103a000}, {0xc103c000}, {0xc103e000}, {0xc1040000}, {0xc1042000}, {0xc1044000}, {0xc1046000}, {0xc1048000}, {0xc104a000}, {0xc104c000}, {0xc104e000}, {0xc1050000}, {0xc1052000}, {0xc1054000}, {0xc1056000}, {0xc1058000}, {0xc105a000}, {0xc105c000}, {0xc105e000}, {0xc1060000}, {0xc1062000}, {0xc1064000}, {0xc1066000}, {0xc1068000}, {0xc106a000}, {0xc106c000}, {0xc106e000}, {0xc1070000}, {0xc1072000}, {0xc1074000}, {0xc1076000}, {0xc1078000}, {0xc107a000}, {0xc107c000}, {0xc107e000}, {0xc1080000}, {0xc1082000}, {0xc1084000}, {0xc1086000}, {0xc1088000}, {0xc108a000}, {0xc108c000}, {0xc108e000}, {0xc1090000}, {0xc1092000}, {0xc1094000}, {0xc1096000}, {0xc1098000}, {0xc109a000}, {0xc109c000}, {0xc109e000}, {0xc10a0000}, {0xc10a2000}, {0xc10a4000}, {0xc10a6000}, {0xc10a8000}, {0xc10aa000}, {0xc10ac000}, {0xc10ae000}, {0xc10b0000}, {0xc10b2000}, {0xc10b4000}, {0xc10b6000}, {0xc10b8000}, {0xc10ba000}, {0xc10bc000}, {0xc10be000}, {0xc10c0000}, {0xc10c2000}, {0xc10c4000}, {0xc10c6000}, {0xc10c8000}, {0xc10ca000}, {0xc10cc000}, {0xc10ce000}, {0xc10d0000}, {0xc10d2000}, {0xc10d4000}, {0xc10d6000}, {0xc10d8000}, {0xc10da000}, {0xc10dc000}, {0xc10de000}, {0xc10e0000}, {0xc10e2000}, {0xc10e4000}, {0xc10e6000}, {0xc10e8000}, {0xc10ea000}, {0xc10ec000}, {0xc10ee000}, {0xc10f0000}, {0xc10f2000}, {0xc10f4000}, {0xc10f6000}, {0xc10f8000}, {0xc10fa000}, {0xc10fc000}, {0xc10fe000}, {0xc1100000}, {0xc1102000}, {0xc1104000}, {0xc1106000}, {0xc1108000}, {0xc110a000}, {0xc110c000}, {0xc110e000}, {0xc1110000}, {0xc1112000}, {0xc1114000}, {0xc1116000}, {0xc1118000}, {0xc111a000}, {0xc111c000}, {0xc111e000}, {0xc1120000}, {0xc1122000}, {0xc1124000}, {0xc1126000}, {0xc1128000}, {0xc112a000}, {0xc112c000}, {0xc112e000}, {0xc1130000}, {0xc1132000}, {0xc1134000}, {0xc1136000}, {0xc1138000}, {0xc113a000}, {0xc113c000}, {0xc113e000}, {0xc1140000}, {0xc1142000}, {0xc1144000}, {0xc1146000}, {0xc1148000}, {0xc114a000}, {0xc114c000}, {0xc114e000}, {0xc1150000}, {0xc1152000}, {0xc1154000}, {0xc1156000}, {0xc1158000}, {0xc115a000}, {0xc115c000}, {0xc115e000}, {0xc1160000}, {0xc1162000}, {0xc1164000}, {0xc1166000}, {0xc1168000}, {0xc116a000}, {0xc116c000}, {0xc116e000}, {0xc1170000}, {0xc1172000}, {0xc1174000}, {0xc1176000}, {0xc1178000}, {0xc117a000}, {0xc117c000}, {0xc117e000}, {0xc1180000}, {0xc1182000}, {0xc1184000}, {0xc1186000}, {0xc1188000}, {0xc118a000}, {0xc118c000}, {0xc118e000}, {0xc1190000}, {0xc1192000}, {0xc1194000}, {0xc1196000}, {0xc1198000}, {0xc119a000}, {0xc119c000}, {0xc119e000}, {0xc11a0000}, {0xc11a2000}, {0xc11a4000}, {0xc11a6000}, {0xc11a8000}, {0xc11aa000}, {0xc11ac000}, {0xc11ae000}, {0xc11b0000}, {0xc11b2000}, {0xc11b4000}, {0xc11b6000}, {0xc11b8000}, {0xc11ba000}, {0xc11bc000}, {0xc11be000}, {0xc11c0000}, {0xc11c2000}, {0xc11c4000}, {0xc11c6000}, {0xc11c8000}, {0xc11ca000}, {0xc11cc000}, {0xc11ce000}, {0xc11d0000}, {0xc11d2000}, {0xc11d4000}, {0xc11d6000}, {0xc11d8000}, {0xc11da000}, {0xc11dc000}, {0xc11de000}, {0xc11e0000}, {0xc11e2000}, {0xc11e4000}, {0xc11e6000}, {0xc11e8000}, {0xc11ea000}, {0xc11ec000}, {0xc11ee000}, {0xc11f0000}, {0xc11f2000}, {0xc11f4000}, {0xc11f6000}, {0xc11f8000}, {0xc11fa000}, {0xc11fc000}, {0xc11fe000}, {0xc1200000}, {0xc1202000}, {0xc1204000}, {0xc1206000}, {0xc1208000}, {0xc120a000}, {0xc120c000}, {0xc120e000}, {0xc1210000}, {0xc1212000}, {0xc1214000}, {0xc1216000}, {0xc1218000}, {0xc121a000}, {0xc121c000}, {0xc121e000}, {0xc1220000}, {0xc1222000}, {0xc1224000}, {0xc1226000}, {0xc1228000}, {0xc122a000}, {0xc122c000}, {0xc122e000}, {0xc1230000}, {0xc1232000}, {0xc1234000}, {0xc1236000}, {0xc1238000}, {0xc123a000}, {0xc123c000}, {0xc123e000}, {0xc1240000}, {0xc1242000}, {0xc1244000}, {0xc1246000}, {0xc1248000}, {0xc124a000}, {0xc124c000}, {0xc124e000}, {0xc1250000}, {0xc1252000}, {0xc1254000}, {0xc1256000}, {0xc1258000}, {0xc125a000}, {0xc125c000}, {0xc125e000}, {0xc1260000}, {0xc1262000}, {0xc1264000}, {0xc1266000}, {0xc1268000}, {0xc126a000}, {0xc126c000}, {0xc126e000}, {0xc1270000}, {0xc1272000}, {0xc1274000}, {0xc1276000}, {0xc1278000}, {0xc127a000}, {0xc127c000}, {0xc127e000}, {0xc1280000}, {0xc1282000}, {0xc1284000}, {0xc1286000}, {0xc1288000}, {0xc128a000}, {0xc128c000}, {0xc128e000}, {0xc1290000}, {0xc1292000}, {0xc1294000}, {0xc1296000}, {0xc1298000}, {0xc129a000}, {0xc129c000}, {0xc129e000}, {0xc12a0000}, {0xc12a2000}, {0xc12a4000}, {0xc12a6000}, {0xc12a8000}, {0xc12aa000}, {0xc12ac000}, {0xc12ae000}, {0xc12b0000}, {0xc12b2000}, {0xc12b4000}, {0xc12b6000}, {0xc12b8000}, {0xc12ba000}, {0xc12bc000}, {0xc12be000}, {0xc12c0000}, {0xc12c2000}, {0xc12c4000}, {0xc12c6000}, {0xc12c8000}, {0xc12ca000}, {0xc12cc000}, {0xc12ce000}, {0xc12d0000}, {0xc12d2000}, {0xc12d4000}, {0xc12d6000}, {0xc12d8000}, {0xc12da000}, {0xc12dc000}, {0xc12de000}, {0xc12e0000}, {0xc12e2000}, {0xc12e4000}, {0xc12e6000}, {0xc12e8000}, {0xc12ea000}, {0xc12ec000}, {0xc12ee000}, {0xc12f0000}, {0xc12f2000}, {0xc12f4000}, {0xc12f6000}, {0xc12f8000}, {0xc12fa000}, {0xc12fc000}, {0xc12fe000}, {0xc1300000}, {0xc1302000}, {0xc1304000}, {0xc1306000}, {0xc1308000}, {0xc130a000}, {0xc130c000}, {0xc130e000}, {0xc1310000}, {0xc1312000}, {0xc1314000}, {0xc1316000}, {0xc1318000}, {0xc131a000}, {0xc131c000}, {0xc131e000}, {0xc1320000}, {0xc1322000}, {0xc1324000}, {0xc1326000}, {0xc1328000}, {0xc132a000}, {0xc132c000}, {0xc132e000}, {0xc1330000}, {0xc1332000}, {0xc1334000}, {0xc1336000}, {0xc1338000}, {0xc133a000}, {0xc133c000}, {0xc133e000}, {0xc1340000}, {0xc1342000}, {0xc1344000}, {0xc1346000}, {0xc1348000}, {0xc134a000}, {0xc134c000}, {0xc134e000}, {0xc1350000}, {0xc1352000}, {0xc1354000}, {0xc1356000}, {0xc1358000}, {0xc135a000}, {0xc135c000}, {0xc135e000}, {0xc1360000}, {0xc1362000}, {0xc1364000}, {0xc1366000}, {0xc1368000}, {0xc136a000}, {0xc136c000}, {0xc136e000}, {0xc1370000}, {0xc1372000}, {0xc1374000}, {0xc1376000}, {0xc1378000}, {0xc137a000}, {0xc137c000}, {0xc137e000}, {0xc1380000}, {0xc1382000}, {0xc1384000}, {0xc1386000}, {0xc1388000}, {0xc138a000}, {0xc138c000}, {0xc138e000}, {0xc1390000}, {0xc1392000}, {0xc1394000}, {0xc1396000}, {0xc1398000}, {0xc139a000}, {0xc139c000}, {0xc139e000}, {0xc13a0000}, {0xc13a2000}, {0xc13a4000}, {0xc13a6000}, {0xc13a8000}, {0xc13aa000}, {0xc13ac000}, {0xc13ae000}, {0xc13b0000}, {0xc13b2000}, {0xc13b4000}, {0xc13b6000}, {0xc13b8000}, {0xc13ba000}, {0xc13bc000}, {0xc13be000}, {0xc13c0000}, {0xc13c2000}, {0xc13c4000}, {0xc13c6000}, {0xc13c8000}, {0xc13ca000}, {0xc13cc000}, {0xc13ce000}, {0xc13d0000}, {0xc13d2000}, {0xc13d4000}, {0xc13d6000}, {0xc13d8000}, {0xc13da000}, {0xc13dc000}, {0xc13de000}, {0xc13e0000}, {0xc13e2000}, {0xc13e4000}, {0xc13e6000}, {0xc13e8000}, {0xc13ea000}, {0xc13ec000}, {0xc13ee000}, {0xc13f0000}, {0xc13f2000}, {0xc13f4000}, {0xc13f6000}, {0xc13f8000}, {0xc13fa000}, {0xc13fc000}, {0xc13fe000}, {0xc1400000}, {0xc1402000}, {0xc1404000}, {0xc1406000}, {0xc1408000}, {0xc140a000}, {0xc140c000}, {0xc140e000}, {0xc1410000}, {0xc1412000}, {0xc1414000}, {0xc1416000}, {0xc1418000}, {0xc141a000}, {0xc141c000}, {0xc141e000}, {0xc1420000}, {0xc1422000}, {0xc1424000}, {0xc1426000}, {0xc1428000}, {0xc142a000}, {0xc142c000}, {0xc142e000}, {0xc1430000}, {0xc1432000}, {0xc1434000}, {0xc1436000}, {0xc1438000}, {0xc143a000}, {0xc143c000}, {0xc143e000}, {0xc1440000}, {0xc1442000}, {0xc1444000}, {0xc1446000}, {0xc1448000}, {0xc144a000}, {0xc144c000}, {0xc144e000}, {0xc1450000}, {0xc1452000}, {0xc1454000}, {0xc1456000}, {0xc1458000}, {0xc145a000}, {0xc145c000}, {0xc145e000}, {0xc1460000}, {0xc1462000}, {0xc1464000}, {0xc1466000}, {0xc1468000}, {0xc146a000}, {0xc146c000}, {0xc146e000}, {0xc1470000}, {0xc1472000}, {0xc1474000}, {0xc1476000}, {0xc1478000}, {0xc147a000}, {0xc147c000}, {0xc147e000}, {0xc1480000}, {0xc1482000}, {0xc1484000}, {0xc1486000}, {0xc1488000}, {0xc148a000}, {0xc148c000}, {0xc148e000}, {0xc1490000}, {0xc1492000}, {0xc1494000}, {0xc1496000}, {0xc1498000}, {0xc149a000}, {0xc149c000}, {0xc149e000}, {0xc14a0000}, {0xc14a2000}, {0xc14a4000}, {0xc14a6000}, {0xc14a8000}, {0xc14aa000}, {0xc14ac000}, {0xc14ae000}, {0xc14b0000}, {0xc14b2000}, {0xc14b4000}, {0xc14b6000}, {0xc14b8000}, {0xc14ba000}, {0xc14bc000}, {0xc14be000}, {0xc14c0000}, {0xc14c2000}, {0xc14c4000}, {0xc14c6000}, {0xc14c8000}, {0xc14ca000}, {0xc14cc000}, {0xc14ce000}, {0xc14d0000}, {0xc14d2000}, {0xc14d4000}, {0xc14d6000}, {0xc14d8000}, {0xc14da000}, {0xc14dc000}, {0xc14de000}, {0xc14e0000}, {0xc14e2000}, {0xc14e4000}, {0xc14e6000}, {0xc14e8000}, {0xc14ea000}, {0xc14ec000}, {0xc14ee000}, {0xc14f0000}, {0xc14f2000}, {0xc14f4000}, {0xc14f6000}, {0xc14f8000}, {0xc14fa000}, {0xc14fc000}, {0xc14fe000}, {0xc1500000}, {0xc1502000}, {0xc1504000}, {0xc1506000}, {0xc1508000}, {0xc150a000}, {0xc150c000}, {0xc150e000}, {0xc1510000}, {0xc1512000}, {0xc1514000}, {0xc1516000}, {0xc1518000}, {0xc151a000}, {0xc151c000}, {0xc151e000}, {0xc1520000}, {0xc1522000}, {0xc1524000}, {0xc1526000}, {0xc1528000}, {0xc152a000}, {0xc152c000}, {0xc152e000}, {0xc1530000}, {0xc1532000}, {0xc1534000}, {0xc1536000}, {0xc1538000}, {0xc153a000}, {0xc153c000}, {0xc153e000}, {0xc1540000}, {0xc1542000}, {0xc1544000}, {0xc1546000}, {0xc1548000}, {0xc154a000}, {0xc154c000}, {0xc154e000}, {0xc1550000}, {0xc1552000}, {0xc1554000}, {0xc1556000}, {0xc1558000}, {0xc155a000}, {0xc155c000}, {0xc155e000}, {0xc1560000}, {0xc1562000}, {0xc1564000}, {0xc1566000}, {0xc1568000}, {0xc156a000}, {0xc156c000}, {0xc156e000}, {0xc1570000}, {0xc1572000}, {0xc1574000}, {0xc1576000}, {0xc1578000}, {0xc157a000}, {0xc157c000}, {0xc157e000}, {0xc1580000}, {0xc1582000}, {0xc1584000}, {0xc1586000}, {0xc1588000}, {0xc158a000}, {0xc158c000}, {0xc158e000}, {0xc1590000}, {0xc1592000}, {0xc1594000}, {0xc1596000}, {0xc1598000}, {0xc159a000}, {0xc159c000}, {0xc159e000}, {0xc15a0000}, {0xc15a2000}, {0xc15a4000}, {0xc15a6000}, {0xc15a8000}, {0xc15aa000}, {0xc15ac000}, {0xc15ae000}, {0xc15b0000}, {0xc15b2000}, {0xc15b4000}, {0xc15b6000}, {0xc15b8000}, {0xc15ba000}, {0xc15bc000}, {0xc15be000}, {0xc15c0000}, {0xc15c2000}, {0xc15c4000}, {0xc15c6000}, {0xc15c8000}, {0xc15ca000}, {0xc15cc000}, {0xc15ce000}, {0xc15d0000}, {0xc15d2000}, {0xc15d4000}, {0xc15d6000}, {0xc15d8000}, {0xc15da000}, {0xc15dc000}, {0xc15de000}, {0xc15e0000}, {0xc15e2000}, {0xc15e4000}, {0xc15e6000}, {0xc15e8000}, {0xc15ea000}, {0xc15ec000}, {0xc15ee000}, {0xc15f0000}, {0xc15f2000}, {0xc15f4000}, {0xc15f6000}, {0xc15f8000}, {0xc15fa000}, {0xc15fc000}, {0xc15fe000}, {0xc1600000}, {0xc1602000}, {0xc1604000}, {0xc1606000}, {0xc1608000}, {0xc160a000}, {0xc160c000}, {0xc160e000}, {0xc1610000}, {0xc1612000}, {0xc1614000}, {0xc1616000}, {0xc1618000}, {0xc161a000}, {0xc161c000}, {0xc161e000}, {0xc1620000}, {0xc1622000}, {0xc1624000}, {0xc1626000}, {0xc1628000}, {0xc162a000}, {0xc162c000}, {0xc162e000}, {0xc1630000}, {0xc1632000}, {0xc1634000}, {0xc1636000}, {0xc1638000}, {0xc163a000}, {0xc163c000}, {0xc163e000}, {0xc1640000}, {0xc1642000}, {0xc1644000}, {0xc1646000}, {0xc1648000}, {0xc164a000}, {0xc164c000}, {0xc164e000}, {0xc1650000}, {0xc1652000}, {0xc1654000}, {0xc1656000}, {0xc1658000}, {0xc165a000}, {0xc165c000}, {0xc165e000}, {0xc1660000}, {0xc1662000}, {0xc1664000}, {0xc1666000}, {0xc1668000}, {0xc166a000}, {0xc166c000}, {0xc166e000}, {0xc1670000}, {0xc1672000}, {0xc1674000}, {0xc1676000}, {0xc1678000}, {0xc167a000}, {0xc167c000}, {0xc167e000}, {0xc1680000}, {0xc1682000}, {0xc1684000}, {0xc1686000}, {0xc1688000}, {0xc168a000}, {0xc168c000}, {0xc168e000}, {0xc1690000}, {0xc1692000}, {0xc1694000}, {0xc1696000}, {0xc1698000}, {0xc169a000}, {0xc169c000}, {0xc169e000}, {0xc16a0000}, {0xc16a2000}, {0xc16a4000}, {0xc16a6000}, {0xc16a8000}, {0xc16aa000}, {0xc16ac000}, {0xc16ae000}, {0xc16b0000}, {0xc16b2000}, {0xc16b4000}, {0xc16b6000}, {0xc16b8000}, {0xc16ba000}, {0xc16bc000}, {0xc16be000}, {0xc16c0000}, {0xc16c2000}, {0xc16c4000}, {0xc16c6000}, {0xc16c8000}, {0xc16ca000}, {0xc16cc000}, {0xc16ce000}, {0xc16d0000}, {0xc16d2000}, {0xc16d4000}, {0xc16d6000}, {0xc16d8000}, {0xc16da000}, {0xc16dc000}, {0xc16de000}, {0xc16e0000}, {0xc16e2000}, {0xc16e4000}, {0xc16e6000}, {0xc16e8000}, {0xc16ea000}, {0xc16ec000}, {0xc16ee000}, {0xc16f0000}, {0xc16f2000}, {0xc16f4000}, {0xc16f6000}, {0xc16f8000}, {0xc16fa000}, {0xc16fc000}, {0xc16fe000}, {0xc1700000}, {0xc1702000}, {0xc1704000}, {0xc1706000}, {0xc1708000}, {0xc170a000}, {0xc170c000}, {0xc170e000}, {0xc1710000}, {0xc1712000}, {0xc1714000}, {0xc1716000}, {0xc1718000}, {0xc171a000}, {0xc171c000}, {0xc171e000}, {0xc1720000}, {0xc1722000}, {0xc1724000}, {0xc1726000}, {0xc1728000}, {0xc172a000}, {0xc172c000}, {0xc172e000}, {0xc1730000}, {0xc1732000}, {0xc1734000}, {0xc1736000}, {0xc1738000}, {0xc173a000}, {0xc173c000}, {0xc173e000}, {0xc1740000}, {0xc1742000}, {0xc1744000}, {0xc1746000}, {0xc1748000}, {0xc174a000}, {0xc174c000}, {0xc174e000}, {0xc1750000}, {0xc1752000}, {0xc1754000}, {0xc1756000}, {0xc1758000}, {0xc175a000}, {0xc175c000}, {0xc175e000}, {0xc1760000}, {0xc1762000}, {0xc1764000}, {0xc1766000}, {0xc1768000}, {0xc176a000}, {0xc176c000}, {0xc176e000}, {0xc1770000}, {0xc1772000}, {0xc1774000}, {0xc1776000}, {0xc1778000}, {0xc177a000}, {0xc177c000}, {0xc177e000}, {0xc1780000}, {0xc1782000}, {0xc1784000}, {0xc1786000}, {0xc1788000}, {0xc178a000}, {0xc178c000}, {0xc178e000}, {0xc1790000}, {0xc1792000}, {0xc1794000}, {0xc1796000}, {0xc1798000}, {0xc179a000}, {0xc179c000}, {0xc179e000}, {0xc17a0000}, {0xc17a2000}, {0xc17a4000}, {0xc17a6000}, {0xc17a8000}, {0xc17aa000}, {0xc17ac000}, {0xc17ae000}, {0xc17b0000}, {0xc17b2000}, {0xc17b4000}, {0xc17b6000}, {0xc17b8000}, {0xc17ba000}, {0xc17bc000}, {0xc17be000}, {0xc17c0000}, {0xc17c2000}, {0xc17c4000}, {0xc17c6000}, {0xc17c8000}, {0xc17ca000}, {0xc17cc000}, {0xc17ce000}, {0xc17d0000}, {0xc17d2000}, {0xc17d4000}, {0xc17d6000}, {0xc17d8000}, {0xc17da000}, {0xc17dc000}, {0xc17de000}, {0xc17e0000}, {0xc17e2000}, {0xc17e4000}, {0xc17e6000}, {0xc17e8000}, {0xc17ea000}, {0xc17ec000}, {0xc17ee000}, {0xc17f0000}, {0xc17f2000}, {0xc17f4000}, {0xc17f6000}, {0xc17f8000}, {0xc17fa000}, {0xc17fc000}, {0xc17fe000}, {0xc1800000}, {0xc1802000}, {0xc1804000}, {0xc1806000}, {0xc1808000}, {0xc180a000}, {0xc180c000}, {0xc180e000}, {0xc1810000}, {0xc1812000}, {0xc1814000}, {0xc1816000}, {0xc1818000}, {0xc181a000}, {0xc181c000}, {0xc181e000}, {0xc1820000}, {0xc1822000}, {0xc1824000}, {0xc1826000}, {0xc1828000}, {0xc182a000}, {0xc182c000}, {0xc182e000}, {0xc1830000}, {0xc1832000}, {0xc1834000}, {0xc1836000}, {0xc1838000}, {0xc183a000}, {0xc183c000}, {0xc183e000}, {0xc1840000}, {0xc1842000}, {0xc1844000}, {0xc1846000}, {0xc1848000}, {0xc184a000}, {0xc184c000}, {0xc184e000}, {0xc1850000}, {0xc1852000}, {0xc1854000}, {0xc1856000}, {0xc1858000}, {0xc185a000}, {0xc185c000}, {0xc185e000}, {0xc1860000}, {0xc1862000}, {0xc1864000}, {0xc1866000}, {0xc1868000}, {0xc186a000}, {0xc186c000}, {0xc186e000}, {0xc1870000}, {0xc1872000}, {0xc1874000}, {0xc1876000}, {0xc1878000}, {0xc187a000}, {0xc187c000}, {0xc187e000}, {0xc1880000}, {0xc1882000}, {0xc1884000}, {0xc1886000}, {0xc1888000}, {0xc188a000}, {0xc188c000}, {0xc188e000}, {0xc1890000}, {0xc1892000}, {0xc1894000}, {0xc1896000}, {0xc1898000}, {0xc189a000}, {0xc189c000}, {0xc189e000}, {0xc18a0000}, {0xc18a2000}, {0xc18a4000}, {0xc18a6000}, {0xc18a8000}, {0xc18aa000}, {0xc18ac000}, {0xc18ae000}, {0xc18b0000}, {0xc18b2000}, {0xc18b4000}, {0xc18b6000}, {0xc18b8000}, {0xc18ba000}, {0xc18bc000}, {0xc18be000}, {0xc18c0000}, {0xc18c2000}, {0xc18c4000}, {0xc18c6000}, {0xc18c8000}, {0xc18ca000}, {0xc18cc000}, {0xc18ce000}, {0xc18d0000}, {0xc18d2000}, {0xc18d4000}, {0xc18d6000}, {0xc18d8000}, {0xc18da000}, {0xc18dc000}, {0xc18de000}, {0xc18e0000}, {0xc18e2000}, {0xc18e4000}, {0xc18e6000}, {0xc18e8000}, {0xc18ea000}, {0xc18ec000}, {0xc18ee000}, {0xc18f0000}, {0xc18f2000}, {0xc18f4000}, {0xc18f6000}, {0xc18f8000}, {0xc18fa000}, {0xc18fc000}, {0xc18fe000}, {0xc1900000}, {0xc1902000}, {0xc1904000}, {0xc1906000}, {0xc1908000}, {0xc190a000}, {0xc190c000}, {0xc190e000}, {0xc1910000}, {0xc1912000}, {0xc1914000}, {0xc1916000}, {0xc1918000}, {0xc191a000}, {0xc191c000}, {0xc191e000}, {0xc1920000}, {0xc1922000}, {0xc1924000}, {0xc1926000}, {0xc1928000}, {0xc192a000}, {0xc192c000}, {0xc192e000}, {0xc1930000}, {0xc1932000}, {0xc1934000}, {0xc1936000}, {0xc1938000}, {0xc193a000}, {0xc193c000}, {0xc193e000}, {0xc1940000}, {0xc1942000}, {0xc1944000}, {0xc1946000}, {0xc1948000}, {0xc194a000}, {0xc194c000}, {0xc194e000}, {0xc1950000}, {0xc1952000}, {0xc1954000}, {0xc1956000}, {0xc1958000}, {0xc195a000}, {0xc195c000}, {0xc195e000}, {0xc1960000}, {0xc1962000}, {0xc1964000}, {0xc1966000}, {0xc1968000}, {0xc196a000}, {0xc196c000}, {0xc196e000}, {0xc1970000}, {0xc1972000}, {0xc1974000}, {0xc1976000}, {0xc1978000}, {0xc197a000}, {0xc197c000}, {0xc197e000}, {0xc1980000}, {0xc1982000}, {0xc1984000}, {0xc1986000}, {0xc1988000}, {0xc198a000}, {0xc198c000}, {0xc198e000}, {0xc1990000}, {0xc1992000}, {0xc1994000}, {0xc1996000}, {0xc1998000}, {0xc199a000}, {0xc199c000}, {0xc199e000}, {0xc19a0000}, {0xc19a2000}, {0xc19a4000}, {0xc19a6000}, {0xc19a8000}, {0xc19aa000}, {0xc19ac000}, {0xc19ae000}, {0xc19b0000}, {0xc19b2000}, {0xc19b4000}, {0xc19b6000}, {0xc19b8000}, {0xc19ba000}, {0xc19bc000}, {0xc19be000}, {0xc19c0000}, {0xc19c2000}, {0xc19c4000}, {0xc19c6000}, {0xc19c8000}, {0xc19ca000}, {0xc19cc000}, {0xc19ce000}, {0xc19d0000}, {0xc19d2000}, {0xc19d4000}, {0xc19d6000}, {0xc19d8000}, {0xc19da000}, {0xc19dc000}, {0xc19de000}, {0xc19e0000}, {0xc19e2000}, {0xc19e4000}, {0xc19e6000}, {0xc19e8000}, {0xc19ea000}, {0xc19ec000}, {0xc19ee000}, {0xc19f0000}, {0xc19f2000}, {0xc19f4000}, {0xc19f6000}, {0xc19f8000}, {0xc19fa000}, {0xc19fc000}, {0xc19fe000}, {0xc1a00000}, {0xc1a02000}, {0xc1a04000}, {0xc1a06000}, {0xc1a08000}, {0xc1a0a000}, {0xc1a0c000}, {0xc1a0e000}, {0xc1a10000}, {0xc1a12000}, {0xc1a14000}, {0xc1a16000}, {0xc1a18000}, {0xc1a1a000}, {0xc1a1c000}, {0xc1a1e000}, {0xc1a20000}, {0xc1a22000}, {0xc1a24000}, {0xc1a26000}, {0xc1a28000}, {0xc1a2a000}, {0xc1a2c000}, {0xc1a2e000}, {0xc1a30000}, {0xc1a32000}, {0xc1a34000}, {0xc1a36000}, {0xc1a38000}, {0xc1a3a000}, {0xc1a3c000}, {0xc1a3e000}, {0xc1a40000}, {0xc1a42000}, {0xc1a44000}, {0xc1a46000}, {0xc1a48000}, {0xc1a4a000}, {0xc1a4c000}, {0xc1a4e000}, {0xc1a50000}, {0xc1a52000}, {0xc1a54000}, {0xc1a56000}, {0xc1a58000}, {0xc1a5a000}, {0xc1a5c000}, {0xc1a5e000}, {0xc1a60000}, {0xc1a62000}, {0xc1a64000}, {0xc1a66000}, {0xc1a68000}, {0xc1a6a000}, {0xc1a6c000}, {0xc1a6e000}, {0xc1a70000}, {0xc1a72000}, {0xc1a74000}, {0xc1a76000}, {0xc1a78000}, {0xc1a7a000}, {0xc1a7c000}, {0xc1a7e000}, {0xc1a80000}, {0xc1a82000}, {0xc1a84000}, {0xc1a86000}, {0xc1a88000}, {0xc1a8a000}, {0xc1a8c000}, {0xc1a8e000}, {0xc1a90000}, {0xc1a92000}, {0xc1a94000}, {0xc1a96000}, {0xc1a98000}, {0xc1a9a000}, {0xc1a9c000}, {0xc1a9e000}, {0xc1aa0000}, {0xc1aa2000}, {0xc1aa4000}, {0xc1aa6000}, {0xc1aa8000}, {0xc1aaa000}, {0xc1aac000}, {0xc1aae000}, {0xc1ab0000}, {0xc1ab2000}, {0xc1ab4000}, {0xc1ab6000}, {0xc1ab8000}, {0xc1aba000}, {0xc1abc000}, {0xc1abe000}, {0xc1ac0000}, {0xc1ac2000}, {0xc1ac4000}, {0xc1ac6000}, {0xc1ac8000}, {0xc1aca000}, {0xc1acc000}, {0xc1ace000}, {0xc1ad0000}, {0xc1ad2000}, {0xc1ad4000}, {0xc1ad6000}, {0xc1ad8000}, {0xc1ada000}, {0xc1adc000}, {0xc1ade000}, {0xc1ae0000}, {0xc1ae2000}, {0xc1ae4000}, {0xc1ae6000}, {0xc1ae8000}, {0xc1aea000}, {0xc1aec000}, {0xc1aee000}, {0xc1af0000}, {0xc1af2000}, {0xc1af4000}, {0xc1af6000}, {0xc1af8000}, {0xc1afa000}, {0xc1afc000}, {0xc1afe000}, {0xc1b00000}, {0xc1b02000}, {0xc1b04000}, {0xc1b06000}, {0xc1b08000}, {0xc1b0a000}, {0xc1b0c000}, {0xc1b0e000}, {0xc1b10000}, {0xc1b12000}, {0xc1b14000}, {0xc1b16000}, {0xc1b18000}, {0xc1b1a000}, {0xc1b1c000}, {0xc1b1e000}, {0xc1b20000}, {0xc1b22000}, {0xc1b24000}, {0xc1b26000}, {0xc1b28000}, {0xc1b2a000}, {0xc1b2c000}, {0xc1b2e000}, {0xc1b30000}, {0xc1b32000}, {0xc1b34000}, {0xc1b36000}, {0xc1b38000}, {0xc1b3a000}, {0xc1b3c000}, {0xc1b3e000}, {0xc1b40000}, {0xc1b42000}, {0xc1b44000}, {0xc1b46000}, {0xc1b48000}, {0xc1b4a000}, {0xc1b4c000}, {0xc1b4e000}, {0xc1b50000}, {0xc1b52000}, {0xc1b54000}, {0xc1b56000}, {0xc1b58000}, {0xc1b5a000}, {0xc1b5c000}, {0xc1b5e000}, {0xc1b60000}, {0xc1b62000}, {0xc1b64000}, {0xc1b66000}, {0xc1b68000}, {0xc1b6a000}, {0xc1b6c000}, {0xc1b6e000}, {0xc1b70000}, {0xc1b72000}, {0xc1b74000}, {0xc1b76000}, {0xc1b78000}, {0xc1b7a000}, {0xc1b7c000}, {0xc1b7e000}, {0xc1b80000}, {0xc1b82000}, {0xc1b84000}, {0xc1b86000}, {0xc1b88000}, {0xc1b8a000}, {0xc1b8c000}, {0xc1b8e000}, {0xc1b90000}, {0xc1b92000}, {0xc1b94000}, {0xc1b96000}, {0xc1b98000}, {0xc1b9a000}, {0xc1b9c000}, {0xc1b9e000}, {0xc1ba0000}, {0xc1ba2000}, {0xc1ba4000}, {0xc1ba6000}, {0xc1ba8000}, {0xc1baa000}, {0xc1bac000}, {0xc1bae000}, {0xc1bb0000}, {0xc1bb2000}, {0xc1bb4000}, {0xc1bb6000}, {0xc1bb8000}, {0xc1bba000}, {0xc1bbc000}, {0xc1bbe000}, {0xc1bc0000}, {0xc1bc2000}, {0xc1bc4000}, {0xc1bc6000}, {0xc1bc8000}, {0xc1bca000}, {0xc1bcc000}, {0xc1bce000}, {0xc1bd0000}, {0xc1bd2000}, {0xc1bd4000}, {0xc1bd6000}, {0xc1bd8000}, {0xc1bda000}, {0xc1bdc000}, {0xc1bde000}, {0xc1be0000}, {0xc1be2000}, {0xc1be4000}, {0xc1be6000}, {0xc1be8000}, {0xc1bea000}, {0xc1bec000}, {0xc1bee000}, {0xc1bf0000}, {0xc1bf2000}, {0xc1bf4000}, {0xc1bf6000}, {0xc1bf8000}, {0xc1bfa000}, {0xc1bfc000}, {0xc1bfe000}, {0xc1c00000}, {0xc1c02000}, {0xc1c04000}, {0xc1c06000}, {0xc1c08000}, {0xc1c0a000}, {0xc1c0c000}, {0xc1c0e000}, {0xc1c10000}, {0xc1c12000}, {0xc1c14000}, {0xc1c16000}, {0xc1c18000}, {0xc1c1a000}, {0xc1c1c000}, {0xc1c1e000}, {0xc1c20000}, {0xc1c22000}, {0xc1c24000}, {0xc1c26000}, {0xc1c28000}, {0xc1c2a000}, {0xc1c2c000}, {0xc1c2e000}, {0xc1c30000}, {0xc1c32000}, {0xc1c34000}, {0xc1c36000}, {0xc1c38000}, {0xc1c3a000}, {0xc1c3c000}, {0xc1c3e000}, {0xc1c40000}, {0xc1c42000}, {0xc1c44000}, {0xc1c46000}, {0xc1c48000}, {0xc1c4a000}, {0xc1c4c000}, {0xc1c4e000}, {0xc1c50000}, {0xc1c52000}, {0xc1c54000}, {0xc1c56000}, {0xc1c58000}, {0xc1c5a000}, {0xc1c5c000}, {0xc1c5e000}, {0xc1c60000}, {0xc1c62000}, {0xc1c64000}, {0xc1c66000}, {0xc1c68000}, {0xc1c6a000}, {0xc1c6c000}, {0xc1c6e000}, {0xc1c70000}, {0xc1c72000}, {0xc1c74000}, {0xc1c76000}, {0xc1c78000}, {0xc1c7a000}, {0xc1c7c000}, {0xc1c7e000}, {0xc1c80000}, {0xc1c82000}, {0xc1c84000}, {0xc1c86000}, {0xc1c88000}, {0xc1c8a000}, {0xc1c8c000}, {0xc1c8e000}, {0xc1c90000}, {0xc1c92000}, {0xc1c94000}, {0xc1c96000}, {0xc1c98000}, {0xc1c9a000}, {0xc1c9c000}, {0xc1c9e000}, {0xc1ca0000}, {0xc1ca2000}, {0xc1ca4000}, {0xc1ca6000}, {0xc1ca8000}, {0xc1caa000}, {0xc1cac000}, {0xc1cae000}, {0xc1cb0000}, {0xc1cb2000}, {0xc1cb4000}, {0xc1cb6000}, {0xc1cb8000}, {0xc1cba000}, {0xc1cbc000}, {0xc1cbe000}, {0xc1cc0000}, {0xc1cc2000}, {0xc1cc4000}, {0xc1cc6000}, {0xc1cc8000}, {0xc1cca000}, {0xc1ccc000}, {0xc1cce000}, {0xc1cd0000}, {0xc1cd2000}, {0xc1cd4000}, {0xc1cd6000}, {0xc1cd8000}, {0xc1cda000}, {0xc1cdc000}, {0xc1cde000}, {0xc1ce0000}, {0xc1ce2000}, {0xc1ce4000}, {0xc1ce6000}, {0xc1ce8000}, {0xc1cea000}, {0xc1cec000}, {0xc1cee000}, {0xc1cf0000}, {0xc1cf2000}, {0xc1cf4000}, {0xc1cf6000}, {0xc1cf8000}, {0xc1cfa000}, {0xc1cfc000}, {0xc1cfe000}, {0xc1d00000}, {0xc1d02000}, {0xc1d04000}, {0xc1d06000}, {0xc1d08000}, {0xc1d0a000}, {0xc1d0c000}, {0xc1d0e000}, {0xc1d10000}, {0xc1d12000}, {0xc1d14000}, {0xc1d16000}, {0xc1d18000}, {0xc1d1a000}, {0xc1d1c000}, {0xc1d1e000}, {0xc1d20000}, {0xc1d22000}, {0xc1d24000}, {0xc1d26000}, {0xc1d28000}, {0xc1d2a000}, {0xc1d2c000}, {0xc1d2e000}, {0xc1d30000}, {0xc1d32000}, {0xc1d34000}, {0xc1d36000}, {0xc1d38000}, {0xc1d3a000}, {0xc1d3c000}, {0xc1d3e000}, {0xc1d40000}, {0xc1d42000}, {0xc1d44000}, {0xc1d46000}, {0xc1d48000}, {0xc1d4a000}, {0xc1d4c000}, {0xc1d4e000}, {0xc1d50000}, {0xc1d52000}, {0xc1d54000}, {0xc1d56000}, {0xc1d58000}, {0xc1d5a000}, {0xc1d5c000}, {0xc1d5e000}, {0xc1d60000}, {0xc1d62000}, {0xc1d64000}, {0xc1d66000}, {0xc1d68000}, {0xc1d6a000}, {0xc1d6c000}, {0xc1d6e000}, {0xc1d70000}, {0xc1d72000}, {0xc1d74000}, {0xc1d76000}, {0xc1d78000}, {0xc1d7a000}, {0xc1d7c000}, {0xc1d7e000}, {0xc1d80000}, {0xc1d82000}, {0xc1d84000}, {0xc1d86000}, {0xc1d88000}, {0xc1d8a000}, {0xc1d8c000}, {0xc1d8e000}, {0xc1d90000}, {0xc1d92000}, {0xc1d94000}, {0xc1d96000}, {0xc1d98000}, {0xc1d9a000}, {0xc1d9c000}, {0xc1d9e000}, {0xc1da0000}, {0xc1da2000}, {0xc1da4000}, {0xc1da6000}, {0xc1da8000}, {0xc1daa000}, {0xc1dac000}, {0xc1dae000}, {0xc1db0000}, {0xc1db2000}, {0xc1db4000}, {0xc1db6000}, {0xc1db8000}, {0xc1dba000}, {0xc1dbc000}, {0xc1dbe000}, {0xc1dc0000}, {0xc1dc2000}, {0xc1dc4000}, {0xc1dc6000}, {0xc1dc8000}, {0xc1dca000}, {0xc1dcc000}, {0xc1dce000}, {0xc1dd0000}, {0xc1dd2000}, {0xc1dd4000}, {0xc1dd6000}, {0xc1dd8000}, {0xc1dda000}, {0xc1ddc000}, {0xc1dde000}, {0xc1de0000}, {0xc1de2000}, {0xc1de4000}, {0xc1de6000}, {0xc1de8000}, {0xc1dea000}, {0xc1dec000}, {0xc1dee000}, {0xc1df0000}, {0xc1df2000}, {0xc1df4000}, {0xc1df6000}, {0xc1df8000}, {0xc1dfa000}, {0xc1dfc000}, {0xc1dfe000}, {0xc1e00000}, {0xc1e02000}, {0xc1e04000}, {0xc1e06000}, {0xc1e08000}, {0xc1e0a000}, {0xc1e0c000}, {0xc1e0e000}, {0xc1e10000}, {0xc1e12000}, {0xc1e14000}, {0xc1e16000}, {0xc1e18000}, {0xc1e1a000}, {0xc1e1c000}, {0xc1e1e000}, {0xc1e20000}, {0xc1e22000}, {0xc1e24000}, {0xc1e26000}, {0xc1e28000}, {0xc1e2a000}, {0xc1e2c000}, {0xc1e2e000}, {0xc1e30000}, {0xc1e32000}, {0xc1e34000}, {0xc1e36000}, {0xc1e38000}, {0xc1e3a000}, {0xc1e3c000}, {0xc1e3e000}, {0xc1e40000}, {0xc1e42000}, {0xc1e44000}, {0xc1e46000}, {0xc1e48000}, {0xc1e4a000}, {0xc1e4c000}, {0xc1e4e000}, {0xc1e50000}, {0xc1e52000}, {0xc1e54000}, {0xc1e56000}, {0xc1e58000}, {0xc1e5a000}, {0xc1e5c000}, {0xc1e5e000}, {0xc1e60000}, {0xc1e62000}, {0xc1e64000}, {0xc1e66000}, {0xc1e68000}, {0xc1e6a000}, {0xc1e6c000}, {0xc1e6e000}, {0xc1e70000}, {0xc1e72000}, {0xc1e74000}, {0xc1e76000}, {0xc1e78000}, {0xc1e7a000}, {0xc1e7c000}, {0xc1e7e000}, {0xc1e80000}, {0xc1e82000}, {0xc1e84000}, {0xc1e86000}, {0xc1e88000}, {0xc1e8a000}, {0xc1e8c000}, {0xc1e8e000}, {0xc1e90000}, {0xc1e92000}, {0xc1e94000}, {0xc1e96000}, {0xc1e98000}, {0xc1e9a000}, {0xc1e9c000}, {0xc1e9e000}, {0xc1ea0000}, {0xc1ea2000}, {0xc1ea4000}, {0xc1ea6000}, {0xc1ea8000}, {0xc1eaa000}, {0xc1eac000}, {0xc1eae000}, {0xc1eb0000}, {0xc1eb2000}, {0xc1eb4000}, {0xc1eb6000}, {0xc1eb8000}, {0xc1eba000}, {0xc1ebc000}, {0xc1ebe000}, {0xc1ec0000}, {0xc1ec2000}, {0xc1ec4000}, {0xc1ec6000}, {0xc1ec8000}, {0xc1eca000}, {0xc1ecc000}, {0xc1ece000}, {0xc1ed0000}, {0xc1ed2000}, {0xc1ed4000}, {0xc1ed6000}, {0xc1ed8000}, {0xc1eda000}, {0xc1edc000}, {0xc1ede000}, {0xc1ee0000}, {0xc1ee2000}, {0xc1ee4000}, {0xc1ee6000}, {0xc1ee8000}, {0xc1eea000}, {0xc1eec000}, {0xc1eee000}, {0xc1ef0000}, {0xc1ef2000}, {0xc1ef4000}, {0xc1ef6000}, {0xc1ef8000}, {0xc1efa000}, {0xc1efc000}, {0xc1efe000}, {0xc1f00000}, {0xc1f02000}, {0xc1f04000}, {0xc1f06000}, {0xc1f08000}, {0xc1f0a000}, {0xc1f0c000}, {0xc1f0e000}, {0xc1f10000}, {0xc1f12000}, {0xc1f14000}, {0xc1f16000}, {0xc1f18000}, {0xc1f1a000}, {0xc1f1c000}, {0xc1f1e000}, {0xc1f20000}, {0xc1f22000}, {0xc1f24000}, {0xc1f26000}, {0xc1f28000}, {0xc1f2a000}, {0xc1f2c000}, {0xc1f2e000}, {0xc1f30000}, {0xc1f32000}, {0xc1f34000}, {0xc1f36000}, {0xc1f38000}, {0xc1f3a000}, {0xc1f3c000}, {0xc1f3e000}, {0xc1f40000}, {0xc1f42000}, {0xc1f44000}, {0xc1f46000}, {0xc1f48000}, {0xc1f4a000}, {0xc1f4c000}, {0xc1f4e000}, {0xc1f50000}, {0xc1f52000}, {0xc1f54000}, {0xc1f56000}, {0xc1f58000}, {0xc1f5a000}, {0xc1f5c000}, {0xc1f5e000}, {0xc1f60000}, {0xc1f62000}, {0xc1f64000}, {0xc1f66000}, {0xc1f68000}, {0xc1f6a000}, {0xc1f6c000}, {0xc1f6e000}, {0xc1f70000}, {0xc1f72000}, {0xc1f74000}, {0xc1f76000}, {0xc1f78000}, {0xc1f7a000}, {0xc1f7c000}, {0xc1f7e000}, {0xc1f80000}, {0xc1f82000}, {0xc1f84000}, {0xc1f86000}, {0xc1f88000}, {0xc1f8a000}, {0xc1f8c000}, {0xc1f8e000}, {0xc1f90000}, {0xc1f92000}, {0xc1f94000}, {0xc1f96000}, {0xc1f98000}, {0xc1f9a000}, {0xc1f9c000}, {0xc1f9e000}, {0xc1fa0000}, {0xc1fa2000}, {0xc1fa4000}, {0xc1fa6000}, {0xc1fa8000}, {0xc1faa000}, {0xc1fac000}, {0xc1fae000}, {0xc1fb0000}, {0xc1fb2000}, {0xc1fb4000}, {0xc1fb6000}, {0xc1fb8000}, {0xc1fba000}, {0xc1fbc000}, {0xc1fbe000}, {0xc1fc0000}, {0xc1fc2000}, {0xc1fc4000}, {0xc1fc6000}, {0xc1fc8000}, {0xc1fca000}, {0xc1fcc000}, {0xc1fce000}, {0xc1fd0000}, {0xc1fd2000}, {0xc1fd4000}, {0xc1fd6000}, {0xc1fd8000}, {0xc1fda000}, {0xc1fdc000}, {0xc1fde000}, {0xc1fe0000}, {0xc1fe2000}, {0xc1fe4000}, {0xc1fe6000}, {0xc1fe8000}, {0xc1fea000}, {0xc1fec000}, {0xc1fee000}, {0xc1ff0000}, {0xc1ff2000}, {0xc1ff4000}, {0xc1ff6000}, {0xc1ff8000}, {0xc1ffa000}, {0xc1ffc000}, {0xc1ffe000}, {0xc2000000}, {0xc2002000}, {0xc2004000}, {0xc2006000}, {0xc2008000}, {0xc200a000}, {0xc200c000}, {0xc200e000}, {0xc2010000}, {0xc2012000}, {0xc2014000}, {0xc2016000}, {0xc2018000}, {0xc201a000}, {0xc201c000}, {0xc201e000}, {0xc2020000}, {0xc2022000}, {0xc2024000}, {0xc2026000}, {0xc2028000}, {0xc202a000}, {0xc202c000}, {0xc202e000}, {0xc2030000}, {0xc2032000}, {0xc2034000}, {0xc2036000}, {0xc2038000}, {0xc203a000}, {0xc203c000}, {0xc203e000}, {0xc2040000}, {0xc2042000}, {0xc2044000}, {0xc2046000}, {0xc2048000}, {0xc204a000}, {0xc204c000}, {0xc204e000}, {0xc2050000}, {0xc2052000}, {0xc2054000}, {0xc2056000}, {0xc2058000}, {0xc205a000}, {0xc205c000}, {0xc205e000}, {0xc2060000}, {0xc2062000}, {0xc2064000}, {0xc2066000}, {0xc2068000}, {0xc206a000}, {0xc206c000}, {0xc206e000}, {0xc2070000}, {0xc2072000}, {0xc2074000}, {0xc2076000}, {0xc2078000}, {0xc207a000}, {0xc207c000}, {0xc207e000}, {0xc2080000}, {0xc2082000}, {0xc2084000}, {0xc2086000}, {0xc2088000}, {0xc208a000}, {0xc208c000}, {0xc208e000}, {0xc2090000}, {0xc2092000}, {0xc2094000}, {0xc2096000}, {0xc2098000}, {0xc209a000}, {0xc209c000}, {0xc209e000}, {0xc20a0000}, {0xc20a2000}, {0xc20a4000}, {0xc20a6000}, {0xc20a8000}, {0xc20aa000}, {0xc20ac000}, {0xc20ae000}, {0xc20b0000}, {0xc20b2000}, {0xc20b4000}, {0xc20b6000}, {0xc20b8000}, {0xc20ba000}, {0xc20bc000}, {0xc20be000}, {0xc20c0000}, {0xc20c2000}, {0xc20c4000}, {0xc20c6000}, {0xc20c8000}, {0xc20ca000}, {0xc20cc000}, {0xc20ce000}, {0xc20d0000}, {0xc20d2000}, {0xc20d4000}, {0xc20d6000}, {0xc20d8000}, {0xc20da000}, {0xc20dc000}, {0xc20de000}, {0xc20e0000}, {0xc20e2000}, {0xc20e4000}, {0xc20e6000}, {0xc20e8000}, {0xc20ea000}, {0xc20ec000}, {0xc20ee000}, {0xc20f0000}, {0xc20f2000}, {0xc20f4000}, {0xc20f6000}, {0xc20f8000}, {0xc20fa000}, {0xc20fc000}, {0xc20fe000}, {0xc2100000}, {0xc2102000}, {0xc2104000}, {0xc2106000}, {0xc2108000}, {0xc210a000}, {0xc210c000}, {0xc210e000}, {0xc2110000}, {0xc2112000}, {0xc2114000}, {0xc2116000}, {0xc2118000}, {0xc211a000}, {0xc211c000}, {0xc211e000}, {0xc2120000}, {0xc2122000}, {0xc2124000}, {0xc2126000}, {0xc2128000}, {0xc212a000}, {0xc212c000}, {0xc212e000}, {0xc2130000}, {0xc2132000}, {0xc2134000}, {0xc2136000}, {0xc2138000}, {0xc213a000}, {0xc213c000}, {0xc213e000}, {0xc2140000}, {0xc2142000}, {0xc2144000}, {0xc2146000}, {0xc2148000}, {0xc214a000}, {0xc214c000}, {0xc214e000}, {0xc2150000}, {0xc2152000}, {0xc2154000}, {0xc2156000}, {0xc2158000}, {0xc215a000}, {0xc215c000}, {0xc215e000}, {0xc2160000}, {0xc2162000}, {0xc2164000}, {0xc2166000}, {0xc2168000}, {0xc216a000}, {0xc216c000}, {0xc216e000}, {0xc2170000}, {0xc2172000}, {0xc2174000}, {0xc2176000}, {0xc2178000}, {0xc217a000}, {0xc217c000}, {0xc217e000}, {0xc2180000}, {0xc2182000}, {0xc2184000}, {0xc2186000}, {0xc2188000}, {0xc218a000}, {0xc218c000}, {0xc218e000}, {0xc2190000}, {0xc2192000}, {0xc2194000}, {0xc2196000}, {0xc2198000}, {0xc219a000}, {0xc219c000}, {0xc219e000}, {0xc21a0000}, {0xc21a2000}, {0xc21a4000}, {0xc21a6000}, {0xc21a8000}, {0xc21aa000}, {0xc21ac000}, {0xc21ae000}, {0xc21b0000}, {0xc21b2000}, {0xc21b4000}, {0xc21b6000}, {0xc21b8000}, {0xc21ba000}, {0xc21bc000}, {0xc21be000}, {0xc21c0000}, {0xc21c2000}, {0xc21c4000}, {0xc21c6000}, {0xc21c8000}, {0xc21ca000}, {0xc21cc000}, {0xc21ce000}, {0xc21d0000}, {0xc21d2000}, {0xc21d4000}, {0xc21d6000}, {0xc21d8000}, {0xc21da000}, {0xc21dc000}, {0xc21de000}, {0xc21e0000}, {0xc21e2000}, {0xc21e4000}, {0xc21e6000}, {0xc21e8000}, {0xc21ea000}, {0xc21ec000}, {0xc21ee000}, {0xc21f0000}, {0xc21f2000}, {0xc21f4000}, {0xc21f6000}, {0xc21f8000}, {0xc21fa000}, {0xc21fc000}, {0xc21fe000}, {0xc2200000}, {0xc2202000}, {0xc2204000}, {0xc2206000}, {0xc2208000}, {0xc220a000}, {0xc220c000}, {0xc220e000}, {0xc2210000}, {0xc2212000}, {0xc2214000}, {0xc2216000}, {0xc2218000}, {0xc221a000}, {0xc221c000}, {0xc221e000}, {0xc2220000}, {0xc2222000}, {0xc2224000}, {0xc2226000}, {0xc2228000}, {0xc222a000}, {0xc222c000}, {0xc222e000}, {0xc2230000}, {0xc2232000}, {0xc2234000}, {0xc2236000}, {0xc2238000}, {0xc223a000}, {0xc223c000}, {0xc223e000}, {0xc2240000}, {0xc2242000}, {0xc2244000}, {0xc2246000}, {0xc2248000}, {0xc224a000}, {0xc224c000}, {0xc224e000}, {0xc2250000}, {0xc2252000}, {0xc2254000}, {0xc2256000}, {0xc2258000}, {0xc225a000}, {0xc225c000}, {0xc225e000}, {0xc2260000}, {0xc2262000}, {0xc2264000}, {0xc2266000}, {0xc2268000}, {0xc226a000}, {0xc226c000}, {0xc226e000}, {0xc2270000}, {0xc2272000}, {0xc2274000}, {0xc2276000}, {0xc2278000}, {0xc227a000}, {0xc227c000}, {0xc227e000}, {0xc2280000}, {0xc2282000}, {0xc2284000}, {0xc2286000}, {0xc2288000}, {0xc228a000}, {0xc228c000}, {0xc228e000}, {0xc2290000}, {0xc2292000}, {0xc2294000}, {0xc2296000}, {0xc2298000}, {0xc229a000}, {0xc229c000}, {0xc229e000}, {0xc22a0000}, {0xc22a2000}, {0xc22a4000}, {0xc22a6000}, {0xc22a8000}, {0xc22aa000}, {0xc22ac000}, {0xc22ae000}, {0xc22b0000}, {0xc22b2000}, {0xc22b4000}, {0xc22b6000}, {0xc22b8000}, {0xc22ba000}, {0xc22bc000}, {0xc22be000}, {0xc22c0000}, {0xc22c2000}, {0xc22c4000}, {0xc22c6000}, {0xc22c8000}, {0xc22ca000}, {0xc22cc000}, {0xc22ce000}, {0xc22d0000}, {0xc22d2000}, {0xc22d4000}, {0xc22d6000}, {0xc22d8000}, {0xc22da000}, {0xc22dc000}, {0xc22de000}, {0xc22e0000}, {0xc22e2000}, {0xc22e4000}, {0xc22e6000}, {0xc22e8000}, {0xc22ea000}, {0xc22ec000}, {0xc22ee000}, {0xc22f0000}, {0xc22f2000}, {0xc22f4000}, {0xc22f6000}, {0xc22f8000}, {0xc22fa000}, {0xc22fc000}, {0xc22fe000}, {0xc2300000}, {0xc2302000}, {0xc2304000}, {0xc2306000}, {0xc2308000}, {0xc230a000}, {0xc230c000}, {0xc230e000}, {0xc2310000}, {0xc2312000}, {0xc2314000}, {0xc2316000}, {0xc2318000}, {0xc231a000}, {0xc231c000}, {0xc231e000}, {0xc2320000}, {0xc2322000}, {0xc2324000}, {0xc2326000}, {0xc2328000}, {0xc232a000}, {0xc232c000}, {0xc232e000}, {0xc2330000}, {0xc2332000}, {0xc2334000}, {0xc2336000}, {0xc2338000}, {0xc233a000}, {0xc233c000}, {0xc233e000}, {0xc2340000}, {0xc2342000}, {0xc2344000}, {0xc2346000}, {0xc2348000}, {0xc234a000}, {0xc234c000}, {0xc234e000}, {0xc2350000}, {0xc2352000}, {0xc2354000}, {0xc2356000}, {0xc2358000}, {0xc235a000}, {0xc235c000}, {0xc235e000}, {0xc2360000}, {0xc2362000}, {0xc2364000}, {0xc2366000}, {0xc2368000}, {0xc236a000}, {0xc236c000}, {0xc236e000}, {0xc2370000}, {0xc2372000}, {0xc2374000}, {0xc2376000}, {0xc2378000}, {0xc237a000}, {0xc237c000}, {0xc237e000}, {0xc2380000}, {0xc2382000}, {0xc2384000}, {0xc2386000}, {0xc2388000}, {0xc238a000}, {0xc238c000}, {0xc238e000}, {0xc2390000}, {0xc2392000}, {0xc2394000}, {0xc2396000}, {0xc2398000}, {0xc239a000}, {0xc239c000}, {0xc239e000}, {0xc23a0000}, {0xc23a2000}, {0xc23a4000}, {0xc23a6000}, {0xc23a8000}, {0xc23aa000}, {0xc23ac000}, {0xc23ae000}, {0xc23b0000}, {0xc23b2000}, {0xc23b4000}, {0xc23b6000}, {0xc23b8000}, {0xc23ba000}, {0xc23bc000}, {0xc23be000}, {0xc23c0000}, {0xc23c2000}, {0xc23c4000}, {0xc23c6000}, {0xc23c8000}, {0xc23ca000}, {0xc23cc000}, {0xc23ce000}, {0xc23d0000}, {0xc23d2000}, {0xc23d4000}, {0xc23d6000}, {0xc23d8000}, {0xc23da000}, {0xc23dc000}, {0xc23de000}, {0xc23e0000}, {0xc23e2000}, {0xc23e4000}, {0xc23e6000}, {0xc23e8000}, {0xc23ea000}, {0xc23ec000}, {0xc23ee000}, {0xc23f0000}, {0xc23f2000}, {0xc23f4000}, {0xc23f6000}, {0xc23f8000}, {0xc23fa000}, {0xc23fc000}, {0xc23fe000}, {0xc2400000}, {0xc2402000}, {0xc2404000}, {0xc2406000}, {0xc2408000}, {0xc240a000}, {0xc240c000}, {0xc240e000}, {0xc2410000}, {0xc2412000}, {0xc2414000}, {0xc2416000}, {0xc2418000}, {0xc241a000}, {0xc241c000}, {0xc241e000}, {0xc2420000}, {0xc2422000}, {0xc2424000}, {0xc2426000}, {0xc2428000}, {0xc242a000}, {0xc242c000}, {0xc242e000}, {0xc2430000}, {0xc2432000}, {0xc2434000}, {0xc2436000}, {0xc2438000}, {0xc243a000}, {0xc243c000}, {0xc243e000}, {0xc2440000}, {0xc2442000}, {0xc2444000}, {0xc2446000}, {0xc2448000}, {0xc244a000}, {0xc244c000}, {0xc244e000}, {0xc2450000}, {0xc2452000}, {0xc2454000}, {0xc2456000}, {0xc2458000}, {0xc245a000}, {0xc245c000}, {0xc245e000}, {0xc2460000}, {0xc2462000}, {0xc2464000}, {0xc2466000}, {0xc2468000}, {0xc246a000}, {0xc246c000}, {0xc246e000}, {0xc2470000}, {0xc2472000}, {0xc2474000}, {0xc2476000}, {0xc2478000}, {0xc247a000}, {0xc247c000}, {0xc247e000}, {0xc2480000}, {0xc2482000}, {0xc2484000}, {0xc2486000}, {0xc2488000}, {0xc248a000}, {0xc248c000}, {0xc248e000}, {0xc2490000}, {0xc2492000}, {0xc2494000}, {0xc2496000}, {0xc2498000}, {0xc249a000}, {0xc249c000}, {0xc249e000}, {0xc24a0000}, {0xc24a2000}, {0xc24a4000}, {0xc24a6000}, {0xc24a8000}, {0xc24aa000}, {0xc24ac000}, {0xc24ae000}, {0xc24b0000}, {0xc24b2000}, {0xc24b4000}, {0xc24b6000}, {0xc24b8000}, {0xc24ba000}, {0xc24bc000}, {0xc24be000}, {0xc24c0000}, {0xc24c2000}, {0xc24c4000}, {0xc24c6000}, {0xc24c8000}, {0xc24ca000}, {0xc24cc000}, {0xc24ce000}, {0xc24d0000}, {0xc24d2000}, {0xc24d4000}, {0xc24d6000}, {0xc24d8000}, {0xc24da000}, {0xc24dc000}, {0xc24de000}, {0xc24e0000}, {0xc24e2000}, {0xc24e4000}, {0xc24e6000}, {0xc24e8000}, {0xc24ea000}, {0xc24ec000}, {0xc24ee000}, {0xc24f0000}, {0xc24f2000}, {0xc24f4000}, {0xc24f6000}, {0xc24f8000}, {0xc24fa000}, {0xc24fc000}, {0xc24fe000}, {0xc2500000}, {0xc2502000}, {0xc2504000}, {0xc2506000}, {0xc2508000}, {0xc250a000}, {0xc250c000}, {0xc250e000}, {0xc2510000}, {0xc2512000}, {0xc2514000}, {0xc2516000}, {0xc2518000}, {0xc251a000}, {0xc251c000}, {0xc251e000}, {0xc2520000}, {0xc2522000}, {0xc2524000}, {0xc2526000}, {0xc2528000}, {0xc252a000}, {0xc252c000}, {0xc252e000}, {0xc2530000}, {0xc2532000}, {0xc2534000}, {0xc2536000}, {0xc2538000}, {0xc253a000}, {0xc253c000}, {0xc253e000}, {0xc2540000}, {0xc2542000}, {0xc2544000}, {0xc2546000}, {0xc2548000}, {0xc254a000}, {0xc254c000}, {0xc254e000}, {0xc2550000}, {0xc2552000}, {0xc2554000}, {0xc2556000}, {0xc2558000}, {0xc255a000}, {0xc255c000}, {0xc255e000}, {0xc2560000}, {0xc2562000}, {0xc2564000}, {0xc2566000}, {0xc2568000}, {0xc256a000}, {0xc256c000}, {0xc256e000}, {0xc2570000}, {0xc2572000}, {0xc2574000}, {0xc2576000}, {0xc2578000}, {0xc257a000}, {0xc257c000}, {0xc257e000}, {0xc2580000}, {0xc2582000}, {0xc2584000}, {0xc2586000}, {0xc2588000}, {0xc258a000}, {0xc258c000}, {0xc258e000}, {0xc2590000}, {0xc2592000}, {0xc2594000}, {0xc2596000}, {0xc2598000}, {0xc259a000}, {0xc259c000}, {0xc259e000}, {0xc25a0000}, {0xc25a2000}, {0xc25a4000}, {0xc25a6000}, {0xc25a8000}, {0xc25aa000}, {0xc25ac000}, {0xc25ae000}, {0xc25b0000}, {0xc25b2000}, {0xc25b4000}, {0xc25b6000}, {0xc25b8000}, {0xc25ba000}, {0xc25bc000}, {0xc25be000}, {0xc25c0000}, {0xc25c2000}, {0xc25c4000}, {0xc25c6000}, {0xc25c8000}, {0xc25ca000}, {0xc25cc000}, {0xc25ce000}, {0xc25d0000}, {0xc25d2000}, {0xc25d4000}, {0xc25d6000}, {0xc25d8000}, {0xc25da000}, {0xc25dc000}, {0xc25de000}, {0xc25e0000}, {0xc25e2000}, {0xc25e4000}, {0xc25e6000}, {0xc25e8000}, {0xc25ea000}, {0xc25ec000}, {0xc25ee000}, {0xc25f0000}, {0xc25f2000}, {0xc25f4000}, {0xc25f6000}, {0xc25f8000}, {0xc25fa000}, {0xc25fc000}, {0xc25fe000}, {0xc2600000}, {0xc2602000}, {0xc2604000}, {0xc2606000}, {0xc2608000}, {0xc260a000}, {0xc260c000}, {0xc260e000}, {0xc2610000}, {0xc2612000}, {0xc2614000}, {0xc2616000}, {0xc2618000}, {0xc261a000}, {0xc261c000}, {0xc261e000}, {0xc2620000}, {0xc2622000}, {0xc2624000}, {0xc2626000}, {0xc2628000}, {0xc262a000}, {0xc262c000}, {0xc262e000}, {0xc2630000}, {0xc2632000}, {0xc2634000}, {0xc2636000}, {0xc2638000}, {0xc263a000}, {0xc263c000}, {0xc263e000}, {0xc2640000}, {0xc2642000}, {0xc2644000}, {0xc2646000}, {0xc2648000}, {0xc264a000}, {0xc264c000}, {0xc264e000}, {0xc2650000}, {0xc2652000}, {0xc2654000}, {0xc2656000}, {0xc2658000}, {0xc265a000}, {0xc265c000}, {0xc265e000}, {0xc2660000}, {0xc2662000}, {0xc2664000}, {0xc2666000}, {0xc2668000}, {0xc266a000}, {0xc266c000}, {0xc266e000}, {0xc2670000}, {0xc2672000}, {0xc2674000}, {0xc2676000}, {0xc2678000}, {0xc267a000}, {0xc267c000}, {0xc267e000}, {0xc2680000}, {0xc2682000}, {0xc2684000}, {0xc2686000}, {0xc2688000}, {0xc268a000}, {0xc268c000}, {0xc268e000}, {0xc2690000}, {0xc2692000}, {0xc2694000}, {0xc2696000}, {0xc2698000}, {0xc269a000}, {0xc269c000}, {0xc269e000}, {0xc26a0000}, {0xc26a2000}, {0xc26a4000}, {0xc26a6000}, {0xc26a8000}, {0xc26aa000}, {0xc26ac000}, {0xc26ae000}, {0xc26b0000}, {0xc26b2000}, {0xc26b4000}, {0xc26b6000}, {0xc26b8000}, {0xc26ba000}, {0xc26bc000}, {0xc26be000}, {0xc26c0000}, {0xc26c2000}, {0xc26c4000}, {0xc26c6000}, {0xc26c8000}, {0xc26ca000}, {0xc26cc000}, {0xc26ce000}, {0xc26d0000}, {0xc26d2000}, {0xc26d4000}, {0xc26d6000}, {0xc26d8000}, {0xc26da000}, {0xc26dc000}, {0xc26de000}, {0xc26e0000}, {0xc26e2000}, {0xc26e4000}, {0xc26e6000}, {0xc26e8000}, {0xc26ea000}, {0xc26ec000}, {0xc26ee000}, {0xc26f0000}, {0xc26f2000}, {0xc26f4000}, {0xc26f6000}, {0xc26f8000}, {0xc26fa000}, {0xc26fc000}, {0xc26fe000}, {0xc2700000}, {0xc2702000}, {0xc2704000}, {0xc2706000}, {0xc2708000}, {0xc270a000}, {0xc270c000}, {0xc270e000}, {0xc2710000}, {0xc2712000}, {0xc2714000}, {0xc2716000}, {0xc2718000}, {0xc271a000}, {0xc271c000}, {0xc271e000}, {0xc2720000}, {0xc2722000}, {0xc2724000}, {0xc2726000}, {0xc2728000}, {0xc272a000}, {0xc272c000}, {0xc272e000}, {0xc2730000}, {0xc2732000}, {0xc2734000}, {0xc2736000}, {0xc2738000}, {0xc273a000}, {0xc273c000}, {0xc273e000}, {0xc2740000}, {0xc2742000}, {0xc2744000}, {0xc2746000}, {0xc2748000}, {0xc274a000}, {0xc274c000}, {0xc274e000}, {0xc2750000}, {0xc2752000}, {0xc2754000}, {0xc2756000}, {0xc2758000}, {0xc275a000}, {0xc275c000}, {0xc275e000}, {0xc2760000}, {0xc2762000}, {0xc2764000}, {0xc2766000}, {0xc2768000}, {0xc276a000}, {0xc276c000}, {0xc276e000}, {0xc2770000}, {0xc2772000}, {0xc2774000}, {0xc2776000}, {0xc2778000}, {0xc277a000}, {0xc277c000}, {0xc277e000}, {0xc2780000}, {0xc2782000}, {0xc2784000}, {0xc2786000}, {0xc2788000}, {0xc278a000}, {0xc278c000}, {0xc278e000}, {0xc2790000}, {0xc2792000}, {0xc2794000}, {0xc2796000}, {0xc2798000}, {0xc279a000}, {0xc279c000}, {0xc279e000}, {0xc27a0000}, {0xc27a2000}, {0xc27a4000}, {0xc27a6000}, {0xc27a8000}, {0xc27aa000}, {0xc27ac000}, {0xc27ae000}, {0xc27b0000}, {0xc27b2000}, {0xc27b4000}, {0xc27b6000}, {0xc27b8000}, {0xc27ba000}, {0xc27bc000}, {0xc27be000}, {0xc27c0000}, {0xc27c2000}, {0xc27c4000}, {0xc27c6000}, {0xc27c8000}, {0xc27ca000}, {0xc27cc000}, {0xc27ce000}, {0xc27d0000}, {0xc27d2000}, {0xc27d4000}, {0xc27d6000}, {0xc27d8000}, {0xc27da000}, {0xc27dc000}, {0xc27de000}, {0xc27e0000}, {0xc27e2000}, {0xc27e4000}, {0xc27e6000}, {0xc27e8000}, {0xc27ea000}, {0xc27ec000}, {0xc27ee000}, {0xc27f0000}, {0xc27f2000}, {0xc27f4000}, {0xc27f6000}, {0xc27f8000}, {0xc27fa000}, {0xc27fc000}, {0xc27fe000}, {0xc2800000}, {0xc2802000}, {0xc2804000}, {0xc2806000}, {0xc2808000}, {0xc280a000}, {0xc280c000}, {0xc280e000}, {0xc2810000}, {0xc2812000}, {0xc2814000}, {0xc2816000}, {0xc2818000}, {0xc281a000}, {0xc281c000}, {0xc281e000}, {0xc2820000}, {0xc2822000}, {0xc2824000}, {0xc2826000}, {0xc2828000}, {0xc282a000}, {0xc282c000}, {0xc282e000}, {0xc2830000}, {0xc2832000}, {0xc2834000}, {0xc2836000}, {0xc2838000}, {0xc283a000}, {0xc283c000}, {0xc283e000}, {0xc2840000}, {0xc2842000}, {0xc2844000}, {0xc2846000}, {0xc2848000}, {0xc284a000}, {0xc284c000}, {0xc284e000}, {0xc2850000}, {0xc2852000}, {0xc2854000}, {0xc2856000}, {0xc2858000}, {0xc285a000}, {0xc285c000}, {0xc285e000}, {0xc2860000}, {0xc2862000}, {0xc2864000}, {0xc2866000}, {0xc2868000}, {0xc286a000}, {0xc286c000}, {0xc286e000}, {0xc2870000}, {0xc2872000}, {0xc2874000}, {0xc2876000}, {0xc2878000}, {0xc287a000}, {0xc287c000}, {0xc287e000}, {0xc2880000}, {0xc2882000}, {0xc2884000}, {0xc2886000}, {0xc2888000}, {0xc288a000}, {0xc288c000}, {0xc288e000}, {0xc2890000}, {0xc2892000}, {0xc2894000}, {0xc2896000}, {0xc2898000}, {0xc289a000}, {0xc289c000}, {0xc289e000}, {0xc28a0000}, {0xc28a2000}, {0xc28a4000}, {0xc28a6000}, {0xc28a8000}, {0xc28aa000}, {0xc28ac000}, {0xc28ae000}, {0xc28b0000}, {0xc28b2000}, {0xc28b4000}, {0xc28b6000}, {0xc28b8000}, {0xc28ba000}, {0xc28bc000}, {0xc28be000}, {0xc28c0000}, {0xc28c2000}, {0xc28c4000}, {0xc28c6000}, {0xc28c8000}, {0xc28ca000}, {0xc28cc000}, {0xc28ce000}, {0xc28d0000}, {0xc28d2000}, {0xc28d4000}, {0xc28d6000}, {0xc28d8000}, {0xc28da000}, {0xc28dc000}, {0xc28de000}, {0xc28e0000}, {0xc28e2000}, {0xc28e4000}, {0xc28e6000}, {0xc28e8000}, {0xc28ea000}, {0xc28ec000}, {0xc28ee000}, {0xc28f0000}, {0xc28f2000}, {0xc28f4000}, {0xc28f6000}, {0xc28f8000}, {0xc28fa000}, {0xc28fc000}, {0xc28fe000}, {0xc2900000}, {0xc2902000}, {0xc2904000}, {0xc2906000}, {0xc2908000}, {0xc290a000}, {0xc290c000}, {0xc290e000}, {0xc2910000}, {0xc2912000}, {0xc2914000}, {0xc2916000}, {0xc2918000}, {0xc291a000}, {0xc291c000}, {0xc291e000}, {0xc2920000}, {0xc2922000}, {0xc2924000}, {0xc2926000}, {0xc2928000}, {0xc292a000}, {0xc292c000}, {0xc292e000}, {0xc2930000}, {0xc2932000}, {0xc2934000}, {0xc2936000}, {0xc2938000}, {0xc293a000}, {0xc293c000}, {0xc293e000}, {0xc2940000}, {0xc2942000}, {0xc2944000}, {0xc2946000}, {0xc2948000}, {0xc294a000}, {0xc294c000}, {0xc294e000}, {0xc2950000}, {0xc2952000}, {0xc2954000}, {0xc2956000}, {0xc2958000}, {0xc295a000}, {0xc295c000}, {0xc295e000}, {0xc2960000}, {0xc2962000}, {0xc2964000}, {0xc2966000}, {0xc2968000}, {0xc296a000}, {0xc296c000}, {0xc296e000}, {0xc2970000}, {0xc2972000}, {0xc2974000}, {0xc2976000}, {0xc2978000}, {0xc297a000}, {0xc297c000}, {0xc297e000}, {0xc2980000}, {0xc2982000}, {0xc2984000}, {0xc2986000}, {0xc2988000}, {0xc298a000}, {0xc298c000}, {0xc298e000}, {0xc2990000}, {0xc2992000}, {0xc2994000}, {0xc2996000}, {0xc2998000}, {0xc299a000}, {0xc299c000}, {0xc299e000}, {0xc29a0000}, {0xc29a2000}, {0xc29a4000}, {0xc29a6000}, {0xc29a8000}, {0xc29aa000}, {0xc29ac000}, {0xc29ae000}, {0xc29b0000}, {0xc29b2000}, {0xc29b4000}, {0xc29b6000}, {0xc29b8000}, {0xc29ba000}, {0xc29bc000}, {0xc29be000}, {0xc29c0000}, {0xc29c2000}, {0xc29c4000}, {0xc29c6000}, {0xc29c8000}, {0xc29ca000}, {0xc29cc000}, {0xc29ce000}, {0xc29d0000}, {0xc29d2000}, {0xc29d4000}, {0xc29d6000}, {0xc29d8000}, {0xc29da000}, {0xc29dc000}, {0xc29de000}, {0xc29e0000}, {0xc29e2000}, {0xc29e4000}, {0xc29e6000}, {0xc29e8000}, {0xc29ea000}, {0xc29ec000}, {0xc29ee000}, {0xc29f0000}, {0xc29f2000}, {0xc29f4000}, {0xc29f6000}, {0xc29f8000}, {0xc29fa000}, {0xc29fc000}, {0xc29fe000}, {0xc2a00000}, {0xc2a02000}, {0xc2a04000}, {0xc2a06000}, {0xc2a08000}, {0xc2a0a000}, {0xc2a0c000}, {0xc2a0e000}, {0xc2a10000}, {0xc2a12000}, {0xc2a14000}, {0xc2a16000}, {0xc2a18000}, {0xc2a1a000}, {0xc2a1c000}, {0xc2a1e000}, {0xc2a20000}, {0xc2a22000}, {0xc2a24000}, {0xc2a26000}, {0xc2a28000}, {0xc2a2a000}, {0xc2a2c000}, {0xc2a2e000}, {0xc2a30000}, {0xc2a32000}, {0xc2a34000}, {0xc2a36000}, {0xc2a38000}, {0xc2a3a000}, {0xc2a3c000}, {0xc2a3e000}, {0xc2a40000}, {0xc2a42000}, {0xc2a44000}, {0xc2a46000}, {0xc2a48000}, {0xc2a4a000}, {0xc2a4c000}, {0xc2a4e000}, {0xc2a50000}, {0xc2a52000}, {0xc2a54000}, {0xc2a56000}, {0xc2a58000}, {0xc2a5a000}, {0xc2a5c000}, {0xc2a5e000}, {0xc2a60000}, {0xc2a62000}, {0xc2a64000}, {0xc2a66000}, {0xc2a68000}, {0xc2a6a000}, {0xc2a6c000}, {0xc2a6e000}, {0xc2a70000}, {0xc2a72000}, {0xc2a74000}, {0xc2a76000}, {0xc2a78000}, {0xc2a7a000}, {0xc2a7c000}, {0xc2a7e000}, {0xc2a80000}, {0xc2a82000}, {0xc2a84000}, {0xc2a86000}, {0xc2a88000}, {0xc2a8a000}, {0xc2a8c000}, {0xc2a8e000}, {0xc2a90000}, {0xc2a92000}, {0xc2a94000}, {0xc2a96000}, {0xc2a98000}, {0xc2a9a000}, {0xc2a9c000}, {0xc2a9e000}, {0xc2aa0000}, {0xc2aa2000}, {0xc2aa4000}, {0xc2aa6000}, {0xc2aa8000}, {0xc2aaa000}, {0xc2aac000}, {0xc2aae000}, {0xc2ab0000}, {0xc2ab2000}, {0xc2ab4000}, {0xc2ab6000}, {0xc2ab8000}, {0xc2aba000}, {0xc2abc000}, {0xc2abe000}, {0xc2ac0000}, {0xc2ac2000}, {0xc2ac4000}, {0xc2ac6000}, {0xc2ac8000}, {0xc2aca000}, {0xc2acc000}, {0xc2ace000}, {0xc2ad0000}, {0xc2ad2000}, {0xc2ad4000}, {0xc2ad6000}, {0xc2ad8000}, {0xc2ada000}, {0xc2adc000}, {0xc2ade000}, {0xc2ae0000}, {0xc2ae2000}, {0xc2ae4000}, {0xc2ae6000}, {0xc2ae8000}, {0xc2aea000}, {0xc2aec000}, {0xc2aee000}, {0xc2af0000}, {0xc2af2000}, {0xc2af4000}, {0xc2af6000}, {0xc2af8000}, {0xc2afa000}, {0xc2afc000}, {0xc2afe000}, {0xc2b00000}, {0xc2b02000}, {0xc2b04000}, {0xc2b06000}, {0xc2b08000}, {0xc2b0a000}, {0xc2b0c000}, {0xc2b0e000}, {0xc2b10000}, {0xc2b12000}, {0xc2b14000}, {0xc2b16000}, {0xc2b18000}, {0xc2b1a000}, {0xc2b1c000}, {0xc2b1e000}, {0xc2b20000}, {0xc2b22000}, {0xc2b24000}, {0xc2b26000}, {0xc2b28000}, {0xc2b2a000}, {0xc2b2c000}, {0xc2b2e000}, {0xc2b30000}, {0xc2b32000}, {0xc2b34000}, {0xc2b36000}, {0xc2b38000}, {0xc2b3a000}, {0xc2b3c000}, {0xc2b3e000}, {0xc2b40000}, {0xc2b42000}, {0xc2b44000}, {0xc2b46000}, {0xc2b48000}, {0xc2b4a000}, {0xc2b4c000}, {0xc2b4e000}, {0xc2b50000}, {0xc2b52000}, {0xc2b54000}, {0xc2b56000}, {0xc2b58000}, {0xc2b5a000}, {0xc2b5c000}, {0xc2b5e000}, {0xc2b60000}, {0xc2b62000}, {0xc2b64000}, {0xc2b66000}, {0xc2b68000}, {0xc2b6a000}, {0xc2b6c000}, {0xc2b6e000}, {0xc2b70000}, {0xc2b72000}, {0xc2b74000}, {0xc2b76000}, {0xc2b78000}, {0xc2b7a000}, {0xc2b7c000}, {0xc2b7e000}, {0xc2b80000}, {0xc2b82000}, {0xc2b84000}, {0xc2b86000}, {0xc2b88000}, {0xc2b8a000}, {0xc2b8c000}, {0xc2b8e000}, {0xc2b90000}, {0xc2b92000}, {0xc2b94000}, {0xc2b96000}, {0xc2b98000}, {0xc2b9a000}, {0xc2b9c000}, {0xc2b9e000}, {0xc2ba0000}, {0xc2ba2000}, {0xc2ba4000}, {0xc2ba6000}, {0xc2ba8000}, {0xc2baa000}, {0xc2bac000}, {0xc2bae000}, {0xc2bb0000}, {0xc2bb2000}, {0xc2bb4000}, {0xc2bb6000}, {0xc2bb8000}, {0xc2bba000}, {0xc2bbc000}, {0xc2bbe000}, {0xc2bc0000}, {0xc2bc2000}, {0xc2bc4000}, {0xc2bc6000}, {0xc2bc8000}, {0xc2bca000}, {0xc2bcc000}, {0xc2bce000}, {0xc2bd0000}, {0xc2bd2000}, {0xc2bd4000}, {0xc2bd6000}, {0xc2bd8000}, {0xc2bda000}, {0xc2bdc000}, {0xc2bde000}, {0xc2be0000}, {0xc2be2000}, {0xc2be4000}, {0xc2be6000}, {0xc2be8000}, {0xc2bea000}, {0xc2bec000}, {0xc2bee000}, {0xc2bf0000}, {0xc2bf2000}, {0xc2bf4000}, {0xc2bf6000}, {0xc2bf8000}, {0xc2bfa000}, {0xc2bfc000}, {0xc2bfe000}, {0xc2c00000}, {0xc2c02000}, {0xc2c04000}, {0xc2c06000}, {0xc2c08000}, {0xc2c0a000}, {0xc2c0c000}, {0xc2c0e000}, {0xc2c10000}, {0xc2c12000}, {0xc2c14000}, {0xc2c16000}, {0xc2c18000}, {0xc2c1a000}, {0xc2c1c000}, {0xc2c1e000}, {0xc2c20000}, {0xc2c22000}, {0xc2c24000}, {0xc2c26000}, {0xc2c28000}, {0xc2c2a000}, {0xc2c2c000}, {0xc2c2e000}, {0xc2c30000}, {0xc2c32000}, {0xc2c34000}, {0xc2c36000}, {0xc2c38000}, {0xc2c3a000}, {0xc2c3c000}, {0xc2c3e000}, {0xc2c40000}, {0xc2c42000}, {0xc2c44000}, {0xc2c46000}, {0xc2c48000}, {0xc2c4a000}, {0xc2c4c000}, {0xc2c4e000}, {0xc2c50000}, {0xc2c52000}, {0xc2c54000}, {0xc2c56000}, {0xc2c58000}, {0xc2c5a000}, {0xc2c5c000}, {0xc2c5e000}, {0xc2c60000}, {0xc2c62000}, {0xc2c64000}, {0xc2c66000}, {0xc2c68000}, {0xc2c6a000}, {0xc2c6c000}, {0xc2c6e000}, {0xc2c70000}, {0xc2c72000}, {0xc2c74000}, {0xc2c76000}, {0xc2c78000}, {0xc2c7a000}, {0xc2c7c000}, {0xc2c7e000}, {0xc2c80000}, {0xc2c82000}, {0xc2c84000}, {0xc2c86000}, {0xc2c88000}, {0xc2c8a000}, {0xc2c8c000}, {0xc2c8e000}, {0xc2c90000}, {0xc2c92000}, {0xc2c94000}, {0xc2c96000}, {0xc2c98000}, {0xc2c9a000}, {0xc2c9c000}, {0xc2c9e000}, {0xc2ca0000}, {0xc2ca2000}, {0xc2ca4000}, {0xc2ca6000}, {0xc2ca8000}, {0xc2caa000}, {0xc2cac000}, {0xc2cae000}, {0xc2cb0000}, {0xc2cb2000}, {0xc2cb4000}, {0xc2cb6000}, {0xc2cb8000}, {0xc2cba000}, {0xc2cbc000}, {0xc2cbe000}, {0xc2cc0000}, {0xc2cc2000}, {0xc2cc4000}, {0xc2cc6000}, {0xc2cc8000}, {0xc2cca000}, {0xc2ccc000}, {0xc2cce000}, {0xc2cd0000}, {0xc2cd2000}, {0xc2cd4000}, {0xc2cd6000}, {0xc2cd8000}, {0xc2cda000}, {0xc2cdc000}, {0xc2cde000}, {0xc2ce0000}, {0xc2ce2000}, {0xc2ce4000}, {0xc2ce6000}, {0xc2ce8000}, {0xc2cea000}, {0xc2cec000}, {0xc2cee000}, {0xc2cf0000}, {0xc2cf2000}, {0xc2cf4000}, {0xc2cf6000}, {0xc2cf8000}, {0xc2cfa000}, {0xc2cfc000}, {0xc2cfe000}, {0xc2d00000}, {0xc2d02000}, {0xc2d04000}, {0xc2d06000}, {0xc2d08000}, {0xc2d0a000}, {0xc2d0c000}, {0xc2d0e000}, {0xc2d10000}, {0xc2d12000}, {0xc2d14000}, {0xc2d16000}, {0xc2d18000}, {0xc2d1a000}, {0xc2d1c000}, {0xc2d1e000}, {0xc2d20000}, {0xc2d22000}, {0xc2d24000}, {0xc2d26000}, {0xc2d28000}, {0xc2d2a000}, {0xc2d2c000}, {0xc2d2e000}, {0xc2d30000}, {0xc2d32000}, {0xc2d34000}, {0xc2d36000}, {0xc2d38000}, {0xc2d3a000}, {0xc2d3c000}, {0xc2d3e000}, {0xc2d40000}, {0xc2d42000}, {0xc2d44000}, {0xc2d46000}, {0xc2d48000}, {0xc2d4a000}, {0xc2d4c000}, {0xc2d4e000}, {0xc2d50000}, {0xc2d52000}, {0xc2d54000}, {0xc2d56000}, {0xc2d58000}, {0xc2d5a000}, {0xc2d5c000}, {0xc2d5e000}, {0xc2d60000}, {0xc2d62000}, {0xc2d64000}, {0xc2d66000}, {0xc2d68000}, {0xc2d6a000}, {0xc2d6c000}, {0xc2d6e000}, {0xc2d70000}, {0xc2d72000}, {0xc2d74000}, {0xc2d76000}, {0xc2d78000}, {0xc2d7a000}, {0xc2d7c000}, {0xc2d7e000}, {0xc2d80000}, {0xc2d82000}, {0xc2d84000}, {0xc2d86000}, {0xc2d88000}, {0xc2d8a000}, {0xc2d8c000}, {0xc2d8e000}, {0xc2d90000}, {0xc2d92000}, {0xc2d94000}, {0xc2d96000}, {0xc2d98000}, {0xc2d9a000}, {0xc2d9c000}, {0xc2d9e000}, {0xc2da0000}, {0xc2da2000}, {0xc2da4000}, {0xc2da6000}, {0xc2da8000}, {0xc2daa000}, {0xc2dac000}, {0xc2dae000}, {0xc2db0000}, {0xc2db2000}, {0xc2db4000}, {0xc2db6000}, {0xc2db8000}, {0xc2dba000}, {0xc2dbc000}, {0xc2dbe000}, {0xc2dc0000}, {0xc2dc2000}, {0xc2dc4000}, {0xc2dc6000}, {0xc2dc8000}, {0xc2dca000}, {0xc2dcc000}, {0xc2dce000}, {0xc2dd0000}, {0xc2dd2000}, {0xc2dd4000}, {0xc2dd6000}, {0xc2dd8000}, {0xc2dda000}, {0xc2ddc000}, {0xc2dde000}, {0xc2de0000}, {0xc2de2000}, {0xc2de4000}, {0xc2de6000}, {0xc2de8000}, {0xc2dea000}, {0xc2dec000}, {0xc2dee000}, {0xc2df0000}, {0xc2df2000}, {0xc2df4000}, {0xc2df6000}, {0xc2df8000}, {0xc2dfa000}, {0xc2dfc000}, {0xc2dfe000}, {0xc2e00000}, {0xc2e02000}, {0xc2e04000}, {0xc2e06000}, {0xc2e08000}, {0xc2e0a000}, {0xc2e0c000}, {0xc2e0e000}, {0xc2e10000}, {0xc2e12000}, {0xc2e14000}, {0xc2e16000}, {0xc2e18000}, {0xc2e1a000}, {0xc2e1c000}, {0xc2e1e000}, {0xc2e20000}, {0xc2e22000}, {0xc2e24000}, {0xc2e26000}, {0xc2e28000}, {0xc2e2a000}, {0xc2e2c000}, {0xc2e2e000}, {0xc2e30000}, {0xc2e32000}, {0xc2e34000}, {0xc2e36000}, {0xc2e38000}, {0xc2e3a000}, {0xc2e3c000}, {0xc2e3e000}, {0xc2e40000}, {0xc2e42000}, {0xc2e44000}, {0xc2e46000}, {0xc2e48000}, {0xc2e4a000}, {0xc2e4c000}, {0xc2e4e000}, {0xc2e50000}, {0xc2e52000}, {0xc2e54000}, {0xc2e56000}, {0xc2e58000}, {0xc2e5a000}, {0xc2e5c000}, {0xc2e5e000}, {0xc2e60000}, {0xc2e62000}, {0xc2e64000}, {0xc2e66000}, {0xc2e68000}, {0xc2e6a000}, {0xc2e6c000}, {0xc2e6e000}, {0xc2e70000}, {0xc2e72000}, {0xc2e74000}, {0xc2e76000}, {0xc2e78000}, {0xc2e7a000}, {0xc2e7c000}, {0xc2e7e000}, {0xc2e80000}, {0xc2e82000}, {0xc2e84000}, {0xc2e86000}, {0xc2e88000}, {0xc2e8a000}, {0xc2e8c000}, {0xc2e8e000}, {0xc2e90000}, {0xc2e92000}, {0xc2e94000}, {0xc2e96000}, {0xc2e98000}, {0xc2e9a000}, {0xc2e9c000}, {0xc2e9e000}, {0xc2ea0000}, {0xc2ea2000}, {0xc2ea4000}, {0xc2ea6000}, {0xc2ea8000}, {0xc2eaa000}, {0xc2eac000}, {0xc2eae000}, {0xc2eb0000}, {0xc2eb2000}, {0xc2eb4000}, {0xc2eb6000}, {0xc2eb8000}, {0xc2eba000}, {0xc2ebc000}, {0xc2ebe000}, {0xc2ec0000}, {0xc2ec2000}, {0xc2ec4000}, {0xc2ec6000}, {0xc2ec8000}, {0xc2eca000}, {0xc2ecc000}, {0xc2ece000}, {0xc2ed0000}, {0xc2ed2000}, {0xc2ed4000}, {0xc2ed6000}, {0xc2ed8000}, {0xc2eda000}, {0xc2edc000}, {0xc2ede000}, {0xc2ee0000}, {0xc2ee2000}, {0xc2ee4000}, {0xc2ee6000}, {0xc2ee8000}, {0xc2eea000}, {0xc2eec000}, {0xc2eee000}, {0xc2ef0000}, {0xc2ef2000}, {0xc2ef4000}, {0xc2ef6000}, {0xc2ef8000}, {0xc2efa000}, {0xc2efc000}, {0xc2efe000}, {0xc2f00000}, {0xc2f02000}, {0xc2f04000}, {0xc2f06000}, {0xc2f08000}, {0xc2f0a000}, {0xc2f0c000}, {0xc2f0e000}, {0xc2f10000}, {0xc2f12000}, {0xc2f14000}, {0xc2f16000}, {0xc2f18000}, {0xc2f1a000}, {0xc2f1c000}, {0xc2f1e000}, {0xc2f20000}, {0xc2f22000}, {0xc2f24000}, {0xc2f26000}, {0xc2f28000}, {0xc2f2a000}, {0xc2f2c000}, {0xc2f2e000}, {0xc2f30000}, {0xc2f32000}, {0xc2f34000}, {0xc2f36000}, {0xc2f38000}, {0xc2f3a000}, {0xc2f3c000}, {0xc2f3e000}, {0xc2f40000}, {0xc2f42000}, {0xc2f44000}, {0xc2f46000}, {0xc2f48000}, {0xc2f4a000}, {0xc2f4c000}, {0xc2f4e000}, {0xc2f50000}, {0xc2f52000}, {0xc2f54000}, {0xc2f56000}, {0xc2f58000}, {0xc2f5a000}, {0xc2f5c000}, {0xc2f5e000}, {0xc2f60000}, {0xc2f62000}, {0xc2f64000}, {0xc2f66000}, {0xc2f68000}, {0xc2f6a000}, {0xc2f6c000}, {0xc2f6e000}, {0xc2f70000}, {0xc2f72000}, {0xc2f74000}, {0xc2f76000}, {0xc2f78000}, {0xc2f7a000}, {0xc2f7c000}, {0xc2f7e000}, {0xc2f80000}, {0xc2f82000}, {0xc2f84000}, {0xc2f86000}, {0xc2f88000}, {0xc2f8a000}, {0xc2f8c000}, {0xc2f8e000}, {0xc2f90000}, {0xc2f92000}, {0xc2f94000}, {0xc2f96000}, {0xc2f98000}, {0xc2f9a000}, {0xc2f9c000}, {0xc2f9e000}, {0xc2fa0000}, {0xc2fa2000}, {0xc2fa4000}, {0xc2fa6000}, {0xc2fa8000}, {0xc2faa000}, {0xc2fac000}, {0xc2fae000}, {0xc2fb0000}, {0xc2fb2000}, {0xc2fb4000}, {0xc2fb6000}, {0xc2fb8000}, {0xc2fba000}, {0xc2fbc000}, {0xc2fbe000}, {0xc2fc0000}, {0xc2fc2000}, {0xc2fc4000}, {0xc2fc6000}, {0xc2fc8000}, {0xc2fca000}, {0xc2fcc000}, {0xc2fce000}, {0xc2fd0000}, {0xc2fd2000}, {0xc2fd4000}, {0xc2fd6000}, {0xc2fd8000}, {0xc2fda000}, {0xc2fdc000}, {0xc2fde000}, {0xc2fe0000}, {0xc2fe2000}, {0xc2fe4000}, {0xc2fe6000}, {0xc2fe8000}, {0xc2fea000}, {0xc2fec000}, {0xc2fee000}, {0xc2ff0000}, {0xc2ff2000}, {0xc2ff4000}, {0xc2ff6000}, {0xc2ff8000}, {0xc2ffa000}, {0xc2ffc000}, {0xc2ffe000}, {0xc3000000}, {0xc3002000}, {0xc3004000}, {0xc3006000}, {0xc3008000}, {0xc300a000}, {0xc300c000}, {0xc300e000}, {0xc3010000}, {0xc3012000}, {0xc3014000}, {0xc3016000}, {0xc3018000}, {0xc301a000}, {0xc301c000}, {0xc301e000}, {0xc3020000}, {0xc3022000}, {0xc3024000}, {0xc3026000}, {0xc3028000}, {0xc302a000}, {0xc302c000}, {0xc302e000}, {0xc3030000}, {0xc3032000}, {0xc3034000}, {0xc3036000}, {0xc3038000}, {0xc303a000}, {0xc303c000}, {0xc303e000}, {0xc3040000}, {0xc3042000}, {0xc3044000}, {0xc3046000}, {0xc3048000}, {0xc304a000}, {0xc304c000}, {0xc304e000}, {0xc3050000}, {0xc3052000}, {0xc3054000}, {0xc3056000}, {0xc3058000}, {0xc305a000}, {0xc305c000}, {0xc305e000}, {0xc3060000}, {0xc3062000}, {0xc3064000}, {0xc3066000}, {0xc3068000}, {0xc306a000}, {0xc306c000}, {0xc306e000}, {0xc3070000}, {0xc3072000}, {0xc3074000}, {0xc3076000}, {0xc3078000}, {0xc307a000}, {0xc307c000}, {0xc307e000}, {0xc3080000}, {0xc3082000}, {0xc3084000}, {0xc3086000}, {0xc3088000}, {0xc308a000}, {0xc308c000}, {0xc308e000}, {0xc3090000}, {0xc3092000}, {0xc3094000}, {0xc3096000}, {0xc3098000}, {0xc309a000}, {0xc309c000}, {0xc309e000}, {0xc30a0000}, {0xc30a2000}, {0xc30a4000}, {0xc30a6000}, {0xc30a8000}, {0xc30aa000}, {0xc30ac000}, {0xc30ae000}, {0xc30b0000}, {0xc30b2000}, {0xc30b4000}, {0xc30b6000}, {0xc30b8000}, {0xc30ba000}, {0xc30bc000}, {0xc30be000}, {0xc30c0000}, {0xc30c2000}, {0xc30c4000}, {0xc30c6000}, {0xc30c8000}, {0xc30ca000}, {0xc30cc000}, {0xc30ce000}, {0xc30d0000}, {0xc30d2000}, {0xc30d4000}, {0xc30d6000}, {0xc30d8000}, {0xc30da000}, {0xc30dc000}, {0xc30de000}, {0xc30e0000}, {0xc30e2000}, {0xc30e4000}, {0xc30e6000}, {0xc30e8000}, {0xc30ea000}, {0xc30ec000}, {0xc30ee000}, {0xc30f0000}, {0xc30f2000}, {0xc30f4000}, {0xc30f6000}, {0xc30f8000}, {0xc30fa000}, {0xc30fc000}, {0xc30fe000}, {0xc3100000}, {0xc3102000}, {0xc3104000}, {0xc3106000}, {0xc3108000}, {0xc310a000}, {0xc310c000}, {0xc310e000}, {0xc3110000}, {0xc3112000}, {0xc3114000}, {0xc3116000}, {0xc3118000}, {0xc311a000}, {0xc311c000}, {0xc311e000}, {0xc3120000}, {0xc3122000}, {0xc3124000}, {0xc3126000}, {0xc3128000}, {0xc312a000}, {0xc312c000}, {0xc312e000}, {0xc3130000}, {0xc3132000}, {0xc3134000}, {0xc3136000}, {0xc3138000}, {0xc313a000}, {0xc313c000}, {0xc313e000}, {0xc3140000}, {0xc3142000}, {0xc3144000}, {0xc3146000}, {0xc3148000}, {0xc314a000}, {0xc314c000}, {0xc314e000}, {0xc3150000}, {0xc3152000}, {0xc3154000}, {0xc3156000}, {0xc3158000}, {0xc315a000}, {0xc315c000}, {0xc315e000}, {0xc3160000}, {0xc3162000}, {0xc3164000}, {0xc3166000}, {0xc3168000}, {0xc316a000}, {0xc316c000}, {0xc316e000}, {0xc3170000}, {0xc3172000}, {0xc3174000}, {0xc3176000}, {0xc3178000}, {0xc317a000}, {0xc317c000}, {0xc317e000}, {0xc3180000}, {0xc3182000}, {0xc3184000}, {0xc3186000}, {0xc3188000}, {0xc318a000}, {0xc318c000}, {0xc318e000}, {0xc3190000}, {0xc3192000}, {0xc3194000}, {0xc3196000}, {0xc3198000}, {0xc319a000}, {0xc319c000}, {0xc319e000}, {0xc31a0000}, {0xc31a2000}, {0xc31a4000}, {0xc31a6000}, {0xc31a8000}, {0xc31aa000}, {0xc31ac000}, {0xc31ae000}, {0xc31b0000}, {0xc31b2000}, {0xc31b4000}, {0xc31b6000}, {0xc31b8000}, {0xc31ba000}, {0xc31bc000}, {0xc31be000}, {0xc31c0000}, {0xc31c2000}, {0xc31c4000}, {0xc31c6000}, {0xc31c8000}, {0xc31ca000}, {0xc31cc000}, {0xc31ce000}, {0xc31d0000}, {0xc31d2000}, {0xc31d4000}, {0xc31d6000}, {0xc31d8000}, {0xc31da000}, {0xc31dc000}, {0xc31de000}, {0xc31e0000}, {0xc31e2000}, {0xc31e4000}, {0xc31e6000}, {0xc31e8000}, {0xc31ea000}, {0xc31ec000}, {0xc31ee000}, {0xc31f0000}, {0xc31f2000}, {0xc31f4000}, {0xc31f6000}, {0xc31f8000}, {0xc31fa000}, {0xc31fc000}, {0xc31fe000}, {0xc3200000}, {0xc3202000}, {0xc3204000}, {0xc3206000}, {0xc3208000}, {0xc320a000}, {0xc320c000}, {0xc320e000}, {0xc3210000}, {0xc3212000}, {0xc3214000}, {0xc3216000}, {0xc3218000}, {0xc321a000}, {0xc321c000}, {0xc321e000}, {0xc3220000}, {0xc3222000}, {0xc3224000}, {0xc3226000}, {0xc3228000}, {0xc322a000}, {0xc322c000}, {0xc322e000}, {0xc3230000}, {0xc3232000}, {0xc3234000}, {0xc3236000}, {0xc3238000}, {0xc323a000}, {0xc323c000}, {0xc323e000}, {0xc3240000}, {0xc3242000}, {0xc3244000}, {0xc3246000}, {0xc3248000}, {0xc324a000}, {0xc324c000}, {0xc324e000}, {0xc3250000}, {0xc3252000}, {0xc3254000}, {0xc3256000}, {0xc3258000}, {0xc325a000}, {0xc325c000}, {0xc325e000}, {0xc3260000}, {0xc3262000}, {0xc3264000}, {0xc3266000}, {0xc3268000}, {0xc326a000}, {0xc326c000}, {0xc326e000}, {0xc3270000}, {0xc3272000}, {0xc3274000}, {0xc3276000}, {0xc3278000}, {0xc327a000}, {0xc327c000}, {0xc327e000}, {0xc3280000}, {0xc3282000}, {0xc3284000}, {0xc3286000}, {0xc3288000}, {0xc328a000}, {0xc328c000}, {0xc328e000}, {0xc3290000}, {0xc3292000}, {0xc3294000}, {0xc3296000}, {0xc3298000}, {0xc329a000}, {0xc329c000}, {0xc329e000}, {0xc32a0000}, {0xc32a2000}, {0xc32a4000}, {0xc32a6000}, {0xc32a8000}, {0xc32aa000}, {0xc32ac000}, {0xc32ae000}, {0xc32b0000}, {0xc32b2000}, {0xc32b4000}, {0xc32b6000}, {0xc32b8000}, {0xc32ba000}, {0xc32bc000}, {0xc32be000}, {0xc32c0000}, {0xc32c2000}, {0xc32c4000}, {0xc32c6000}, {0xc32c8000}, {0xc32ca000}, {0xc32cc000}, {0xc32ce000}, {0xc32d0000}, {0xc32d2000}, {0xc32d4000}, {0xc32d6000}, {0xc32d8000}, {0xc32da000}, {0xc32dc000}, {0xc32de000}, {0xc32e0000}, {0xc32e2000}, {0xc32e4000}, {0xc32e6000}, {0xc32e8000}, {0xc32ea000}, {0xc32ec000}, {0xc32ee000}, {0xc32f0000}, {0xc32f2000}, {0xc32f4000}, {0xc32f6000}, {0xc32f8000}, {0xc32fa000}, {0xc32fc000}, {0xc32fe000}, {0xc3300000}, {0xc3302000}, {0xc3304000}, {0xc3306000}, {0xc3308000}, {0xc330a000}, {0xc330c000}, {0xc330e000}, {0xc3310000}, {0xc3312000}, {0xc3314000}, {0xc3316000}, {0xc3318000}, {0xc331a000}, {0xc331c000}, {0xc331e000}, {0xc3320000}, {0xc3322000}, {0xc3324000}, {0xc3326000}, {0xc3328000}, {0xc332a000}, {0xc332c000}, {0xc332e000}, {0xc3330000}, {0xc3332000}, {0xc3334000}, {0xc3336000}, {0xc3338000}, {0xc333a000}, {0xc333c000}, {0xc333e000}, {0xc3340000}, {0xc3342000}, {0xc3344000}, {0xc3346000}, {0xc3348000}, {0xc334a000}, {0xc334c000}, {0xc334e000}, {0xc3350000}, {0xc3352000}, {0xc3354000}, {0xc3356000}, {0xc3358000}, {0xc335a000}, {0xc335c000}, {0xc335e000}, {0xc3360000}, {0xc3362000}, {0xc3364000}, {0xc3366000}, {0xc3368000}, {0xc336a000}, {0xc336c000}, {0xc336e000}, {0xc3370000}, {0xc3372000}, {0xc3374000}, {0xc3376000}, {0xc3378000}, {0xc337a000}, {0xc337c000}, {0xc337e000}, {0xc3380000}, {0xc3382000}, {0xc3384000}, {0xc3386000}, {0xc3388000}, {0xc338a000}, {0xc338c000}, {0xc338e000}, {0xc3390000}, {0xc3392000}, {0xc3394000}, {0xc3396000}, {0xc3398000}, {0xc339a000}, {0xc339c000}, {0xc339e000}, {0xc33a0000}, {0xc33a2000}, {0xc33a4000}, {0xc33a6000}, {0xc33a8000}, {0xc33aa000}, {0xc33ac000}, {0xc33ae000}, {0xc33b0000}, {0xc33b2000}, {0xc33b4000}, {0xc33b6000}, {0xc33b8000}, {0xc33ba000}, {0xc33bc000}, {0xc33be000}, {0xc33c0000}, {0xc33c2000}, {0xc33c4000}, {0xc33c6000}, {0xc33c8000}, {0xc33ca000}, {0xc33cc000}, {0xc33ce000}, {0xc33d0000}, {0xc33d2000}, {0xc33d4000}, {0xc33d6000}, {0xc33d8000}, {0xc33da000}, {0xc33dc000}, {0xc33de000}, {0xc33e0000}, {0xc33e2000}, {0xc33e4000}, {0xc33e6000}, {0xc33e8000}, {0xc33ea000}, {0xc33ec000}, {0xc33ee000}, {0xc33f0000}, {0xc33f2000}, {0xc33f4000}, {0xc33f6000}, {0xc33f8000}, {0xc33fa000}, {0xc33fc000}, {0xc33fe000}, {0xc3400000}, {0xc3402000}, {0xc3404000}, {0xc3406000}, {0xc3408000}, {0xc340a000}, {0xc340c000}, {0xc340e000}, {0xc3410000}, {0xc3412000}, {0xc3414000}, {0xc3416000}, {0xc3418000}, {0xc341a000}, {0xc341c000}, {0xc341e000}, {0xc3420000}, {0xc3422000}, {0xc3424000}, {0xc3426000}, {0xc3428000}, {0xc342a000}, {0xc342c000}, {0xc342e000}, {0xc3430000}, {0xc3432000}, {0xc3434000}, {0xc3436000}, {0xc3438000}, {0xc343a000}, {0xc343c000}, {0xc343e000}, {0xc3440000}, {0xc3442000}, {0xc3444000}, {0xc3446000}, {0xc3448000}, {0xc344a000}, {0xc344c000}, {0xc344e000}, {0xc3450000}, {0xc3452000}, {0xc3454000}, {0xc3456000}, {0xc3458000}, {0xc345a000}, {0xc345c000}, {0xc345e000}, {0xc3460000}, {0xc3462000}, {0xc3464000}, {0xc3466000}, {0xc3468000}, {0xc346a000}, {0xc346c000}, {0xc346e000}, {0xc3470000}, {0xc3472000}, {0xc3474000}, {0xc3476000}, {0xc3478000}, {0xc347a000}, {0xc347c000}, {0xc347e000}, {0xc3480000}, {0xc3482000}, {0xc3484000}, {0xc3486000}, {0xc3488000}, {0xc348a000}, {0xc348c000}, {0xc348e000}, {0xc3490000}, {0xc3492000}, {0xc3494000}, {0xc3496000}, {0xc3498000}, {0xc349a000}, {0xc349c000}, {0xc349e000}, {0xc34a0000}, {0xc34a2000}, {0xc34a4000}, {0xc34a6000}, {0xc34a8000}, {0xc34aa000}, {0xc34ac000}, {0xc34ae000}, {0xc34b0000}, {0xc34b2000}, {0xc34b4000}, {0xc34b6000}, {0xc34b8000}, {0xc34ba000}, {0xc34bc000}, {0xc34be000}, {0xc34c0000}, {0xc34c2000}, {0xc34c4000}, {0xc34c6000}, {0xc34c8000}, {0xc34ca000}, {0xc34cc000}, {0xc34ce000}, {0xc34d0000}, {0xc34d2000}, {0xc34d4000}, {0xc34d6000}, {0xc34d8000}, {0xc34da000}, {0xc34dc000}, {0xc34de000}, {0xc34e0000}, {0xc34e2000}, {0xc34e4000}, {0xc34e6000}, {0xc34e8000}, {0xc34ea000}, {0xc34ec000}, {0xc34ee000}, {0xc34f0000}, {0xc34f2000}, {0xc34f4000}, {0xc34f6000}, {0xc34f8000}, {0xc34fa000}, {0xc34fc000}, {0xc34fe000}, {0xc3500000}, {0xc3502000}, {0xc3504000}, {0xc3506000}, {0xc3508000}, {0xc350a000}, {0xc350c000}, {0xc350e000}, {0xc3510000}, {0xc3512000}, {0xc3514000}, {0xc3516000}, {0xc3518000}, {0xc351a000}, {0xc351c000}, {0xc351e000}, {0xc3520000}, {0xc3522000}, {0xc3524000}, {0xc3526000}, {0xc3528000}, {0xc352a000}, {0xc352c000}, {0xc352e000}, {0xc3530000}, {0xc3532000}, {0xc3534000}, {0xc3536000}, {0xc3538000}, {0xc353a000}, {0xc353c000}, {0xc353e000}, {0xc3540000}, {0xc3542000}, {0xc3544000}, {0xc3546000}, {0xc3548000}, {0xc354a000}, {0xc354c000}, {0xc354e000}, {0xc3550000}, {0xc3552000}, {0xc3554000}, {0xc3556000}, {0xc3558000}, {0xc355a000}, {0xc355c000}, {0xc355e000}, {0xc3560000}, {0xc3562000}, {0xc3564000}, {0xc3566000}, {0xc3568000}, {0xc356a000}, {0xc356c000}, {0xc356e000}, {0xc3570000}, {0xc3572000}, {0xc3574000}, {0xc3576000}, {0xc3578000}, {0xc357a000}, {0xc357c000}, {0xc357e000}, {0xc3580000}, {0xc3582000}, {0xc3584000}, {0xc3586000}, {0xc3588000}, {0xc358a000}, {0xc358c000}, {0xc358e000}, {0xc3590000}, {0xc3592000}, {0xc3594000}, {0xc3596000}, {0xc3598000}, {0xc359a000}, {0xc359c000}, {0xc359e000}, {0xc35a0000}, {0xc35a2000}, {0xc35a4000}, {0xc35a6000}, {0xc35a8000}, {0xc35aa000}, {0xc35ac000}, {0xc35ae000}, {0xc35b0000}, {0xc35b2000}, {0xc35b4000}, {0xc35b6000}, {0xc35b8000}, {0xc35ba000}, {0xc35bc000}, {0xc35be000}, {0xc35c0000}, {0xc35c2000}, {0xc35c4000}, {0xc35c6000}, {0xc35c8000}, {0xc35ca000}, {0xc35cc000}, {0xc35ce000}, {0xc35d0000}, {0xc35d2000}, {0xc35d4000}, {0xc35d6000}, {0xc35d8000}, {0xc35da000}, {0xc35dc000}, {0xc35de000}, {0xc35e0000}, {0xc35e2000}, {0xc35e4000}, {0xc35e6000}, {0xc35e8000}, {0xc35ea000}, {0xc35ec000}, {0xc35ee000}, {0xc35f0000}, {0xc35f2000}, {0xc35f4000}, {0xc35f6000}, {0xc35f8000}, {0xc35fa000}, {0xc35fc000}, {0xc35fe000}, {0xc3600000}, {0xc3602000}, {0xc3604000}, {0xc3606000}, {0xc3608000}, {0xc360a000}, {0xc360c000}, {0xc360e000}, {0xc3610000}, {0xc3612000}, {0xc3614000}, {0xc3616000}, {0xc3618000}, {0xc361a000}, {0xc361c000}, {0xc361e000}, {0xc3620000}, {0xc3622000}, {0xc3624000}, {0xc3626000}, {0xc3628000}, {0xc362a000}, {0xc362c000}, {0xc362e000}, {0xc3630000}, {0xc3632000}, {0xc3634000}, {0xc3636000}, {0xc3638000}, {0xc363a000}, {0xc363c000}, {0xc363e000}, {0xc3640000}, {0xc3642000}, {0xc3644000}, {0xc3646000}, {0xc3648000}, {0xc364a000}, {0xc364c000}, {0xc364e000}, {0xc3650000}, {0xc3652000}, {0xc3654000}, {0xc3656000}, {0xc3658000}, {0xc365a000}, {0xc365c000}, {0xc365e000}, {0xc3660000}, {0xc3662000}, {0xc3664000}, {0xc3666000}, {0xc3668000}, {0xc366a000}, {0xc366c000}, {0xc366e000}, {0xc3670000}, {0xc3672000}, {0xc3674000}, {0xc3676000}, {0xc3678000}, {0xc367a000}, {0xc367c000}, {0xc367e000}, {0xc3680000}, {0xc3682000}, {0xc3684000}, {0xc3686000}, {0xc3688000}, {0xc368a000}, {0xc368c000}, {0xc368e000}, {0xc3690000}, {0xc3692000}, {0xc3694000}, {0xc3696000}, {0xc3698000}, {0xc369a000}, {0xc369c000}, {0xc369e000}, {0xc36a0000}, {0xc36a2000}, {0xc36a4000}, {0xc36a6000}, {0xc36a8000}, {0xc36aa000}, {0xc36ac000}, {0xc36ae000}, {0xc36b0000}, {0xc36b2000}, {0xc36b4000}, {0xc36b6000}, {0xc36b8000}, {0xc36ba000}, {0xc36bc000}, {0xc36be000}, {0xc36c0000}, {0xc36c2000}, {0xc36c4000}, {0xc36c6000}, {0xc36c8000}, {0xc36ca000}, {0xc36cc000}, {0xc36ce000}, {0xc36d0000}, {0xc36d2000}, {0xc36d4000}, {0xc36d6000}, {0xc36d8000}, {0xc36da000}, {0xc36dc000}, {0xc36de000}, {0xc36e0000}, {0xc36e2000}, {0xc36e4000}, {0xc36e6000}, {0xc36e8000}, {0xc36ea000}, {0xc36ec000}, {0xc36ee000}, {0xc36f0000}, {0xc36f2000}, {0xc36f4000}, {0xc36f6000}, {0xc36f8000}, {0xc36fa000}, {0xc36fc000}, {0xc36fe000}, {0xc3700000}, {0xc3702000}, {0xc3704000}, {0xc3706000}, {0xc3708000}, {0xc370a000}, {0xc370c000}, {0xc370e000}, {0xc3710000}, {0xc3712000}, {0xc3714000}, {0xc3716000}, {0xc3718000}, {0xc371a000}, {0xc371c000}, {0xc371e000}, {0xc3720000}, {0xc3722000}, {0xc3724000}, {0xc3726000}, {0xc3728000}, {0xc372a000}, {0xc372c000}, {0xc372e000}, {0xc3730000}, {0xc3732000}, {0xc3734000}, {0xc3736000}, {0xc3738000}, {0xc373a000}, {0xc373c000}, {0xc373e000}, {0xc3740000}, {0xc3742000}, {0xc3744000}, {0xc3746000}, {0xc3748000}, {0xc374a000}, {0xc374c000}, {0xc374e000}, {0xc3750000}, {0xc3752000}, {0xc3754000}, {0xc3756000}, {0xc3758000}, {0xc375a000}, {0xc375c000}, {0xc375e000}, {0xc3760000}, {0xc3762000}, {0xc3764000}, {0xc3766000}, {0xc3768000}, {0xc376a000}, {0xc376c000}, {0xc376e000}, {0xc3770000}, {0xc3772000}, {0xc3774000}, {0xc3776000}, {0xc3778000}, {0xc377a000}, {0xc377c000}, {0xc377e000}, {0xc3780000}, {0xc3782000}, {0xc3784000}, {0xc3786000}, {0xc3788000}, {0xc378a000}, {0xc378c000}, {0xc378e000}, {0xc3790000}, {0xc3792000}, {0xc3794000}, {0xc3796000}, {0xc3798000}, {0xc379a000}, {0xc379c000}, {0xc379e000}, {0xc37a0000}, {0xc37a2000}, {0xc37a4000}, {0xc37a6000}, {0xc37a8000}, {0xc37aa000}, {0xc37ac000}, {0xc37ae000}, {0xc37b0000}, {0xc37b2000}, {0xc37b4000}, {0xc37b6000}, {0xc37b8000}, {0xc37ba000}, {0xc37bc000}, {0xc37be000}, {0xc37c0000}, {0xc37c2000}, {0xc37c4000}, {0xc37c6000}, {0xc37c8000}, {0xc37ca000}, {0xc37cc000}, {0xc37ce000}, {0xc37d0000}, {0xc37d2000}, {0xc37d4000}, {0xc37d6000}, {0xc37d8000}, {0xc37da000}, {0xc37dc000}, {0xc37de000}, {0xc37e0000}, {0xc37e2000}, {0xc37e4000}, {0xc37e6000}, {0xc37e8000}, {0xc37ea000}, {0xc37ec000}, {0xc37ee000}, {0xc37f0000}, {0xc37f2000}, {0xc37f4000}, {0xc37f6000}, {0xc37f8000}, {0xc37fa000}, {0xc37fc000}, {0xc37fe000}, {0xc3800000}, {0xc3802000}, {0xc3804000}, {0xc3806000}, {0xc3808000}, {0xc380a000}, {0xc380c000}, {0xc380e000}, {0xc3810000}, {0xc3812000}, {0xc3814000}, {0xc3816000}, {0xc3818000}, {0xc381a000}, {0xc381c000}, {0xc381e000}, {0xc3820000}, {0xc3822000}, {0xc3824000}, {0xc3826000}, {0xc3828000}, {0xc382a000}, {0xc382c000}, {0xc382e000}, {0xc3830000}, {0xc3832000}, {0xc3834000}, {0xc3836000}, {0xc3838000}, {0xc383a000}, {0xc383c000}, {0xc383e000}, {0xc3840000}, {0xc3842000}, {0xc3844000}, {0xc3846000}, {0xc3848000}, {0xc384a000}, {0xc384c000}, {0xc384e000}, {0xc3850000}, {0xc3852000}, {0xc3854000}, {0xc3856000}, {0xc3858000}, {0xc385a000}, {0xc385c000}, {0xc385e000}, {0xc3860000}, {0xc3862000}, {0xc3864000}, {0xc3866000}, {0xc3868000}, {0xc386a000}, {0xc386c000}, {0xc386e000}, {0xc3870000}, {0xc3872000}, {0xc3874000}, {0xc3876000}, {0xc3878000}, {0xc387a000}, {0xc387c000}, {0xc387e000}, {0xc3880000}, {0xc3882000}, {0xc3884000}, {0xc3886000}, {0xc3888000}, {0xc388a000}, {0xc388c000}, {0xc388e000}, {0xc3890000}, {0xc3892000}, {0xc3894000}, {0xc3896000}, {0xc3898000}, {0xc389a000}, {0xc389c000}, {0xc389e000}, {0xc38a0000}, {0xc38a2000}, {0xc38a4000}, {0xc38a6000}, {0xc38a8000}, {0xc38aa000}, {0xc38ac000}, {0xc38ae000}, {0xc38b0000}, {0xc38b2000}, {0xc38b4000}, {0xc38b6000}, {0xc38b8000}, {0xc38ba000}, {0xc38bc000}, {0xc38be000}, {0xc38c0000}, {0xc38c2000}, {0xc38c4000}, {0xc38c6000}, {0xc38c8000}, {0xc38ca000}, {0xc38cc000}, {0xc38ce000}, {0xc38d0000}, {0xc38d2000}, {0xc38d4000}, {0xc38d6000}, {0xc38d8000}, {0xc38da000}, {0xc38dc000}, {0xc38de000}, {0xc38e0000}, {0xc38e2000}, {0xc38e4000}, {0xc38e6000}, {0xc38e8000}, {0xc38ea000}, {0xc38ec000}, {0xc38ee000}, {0xc38f0000}, {0xc38f2000}, {0xc38f4000}, {0xc38f6000}, {0xc38f8000}, {0xc38fa000}, {0xc38fc000}, {0xc38fe000}, {0xc3900000}, {0xc3902000}, {0xc3904000}, {0xc3906000}, {0xc3908000}, {0xc390a000}, {0xc390c000}, {0xc390e000}, {0xc3910000}, {0xc3912000}, {0xc3914000}, {0xc3916000}, {0xc3918000}, {0xc391a000}, {0xc391c000}, {0xc391e000}, {0xc3920000}, {0xc3922000}, {0xc3924000}, {0xc3926000}, {0xc3928000}, {0xc392a000}, {0xc392c000}, {0xc392e000}, {0xc3930000}, {0xc3932000}, {0xc3934000}, {0xc3936000}, {0xc3938000}, {0xc393a000}, {0xc393c000}, {0xc393e000}, {0xc3940000}, {0xc3942000}, {0xc3944000}, {0xc3946000}, {0xc3948000}, {0xc394a000}, {0xc394c000}, {0xc394e000}, {0xc3950000}, {0xc3952000}, {0xc3954000}, {0xc3956000}, {0xc3958000}, {0xc395a000}, {0xc395c000}, {0xc395e000}, {0xc3960000}, {0xc3962000}, {0xc3964000}, {0xc3966000}, {0xc3968000}, {0xc396a000}, {0xc396c000}, {0xc396e000}, {0xc3970000}, {0xc3972000}, {0xc3974000}, {0xc3976000}, {0xc3978000}, {0xc397a000}, {0xc397c000}, {0xc397e000}, {0xc3980000}, {0xc3982000}, {0xc3984000}, {0xc3986000}, {0xc3988000}, {0xc398a000}, {0xc398c000}, {0xc398e000}, {0xc3990000}, {0xc3992000}, {0xc3994000}, {0xc3996000}, {0xc3998000}, {0xc399a000}, {0xc399c000}, {0xc399e000}, {0xc39a0000}, {0xc39a2000}, {0xc39a4000}, {0xc39a6000}, {0xc39a8000}, {0xc39aa000}, {0xc39ac000}, {0xc39ae000}, {0xc39b0000}, {0xc39b2000}, {0xc39b4000}, {0xc39b6000}, {0xc39b8000}, {0xc39ba000}, {0xc39bc000}, {0xc39be000}, {0xc39c0000}, {0xc39c2000}, {0xc39c4000}, {0xc39c6000}, {0xc39c8000}, {0xc39ca000}, {0xc39cc000}, {0xc39ce000}, {0xc39d0000}, {0xc39d2000}, {0xc39d4000}, {0xc39d6000}, {0xc39d8000}, {0xc39da000}, {0xc39dc000}, {0xc39de000}, {0xc39e0000}, {0xc39e2000}, {0xc39e4000}, {0xc39e6000}, {0xc39e8000}, {0xc39ea000}, {0xc39ec000}, {0xc39ee000}, {0xc39f0000}, {0xc39f2000}, {0xc39f4000}, {0xc39f6000}, {0xc39f8000}, {0xc39fa000}, {0xc39fc000}, {0xc39fe000}, {0xc3a00000}, {0xc3a02000}, {0xc3a04000}, {0xc3a06000}, {0xc3a08000}, {0xc3a0a000}, {0xc3a0c000}, {0xc3a0e000}, {0xc3a10000}, {0xc3a12000}, {0xc3a14000}, {0xc3a16000}, {0xc3a18000}, {0xc3a1a000}, {0xc3a1c000}, {0xc3a1e000}, {0xc3a20000}, {0xc3a22000}, {0xc3a24000}, {0xc3a26000}, {0xc3a28000}, {0xc3a2a000}, {0xc3a2c000}, {0xc3a2e000}, {0xc3a30000}, {0xc3a32000}, {0xc3a34000}, {0xc3a36000}, {0xc3a38000}, {0xc3a3a000}, {0xc3a3c000}, {0xc3a3e000}, {0xc3a40000}, {0xc3a42000}, {0xc3a44000}, {0xc3a46000}, {0xc3a48000}, {0xc3a4a000}, {0xc3a4c000}, {0xc3a4e000}, {0xc3a50000}, {0xc3a52000}, {0xc3a54000}, {0xc3a56000}, {0xc3a58000}, {0xc3a5a000}, {0xc3a5c000}, {0xc3a5e000}, {0xc3a60000}, {0xc3a62000}, {0xc3a64000}, {0xc3a66000}, {0xc3a68000}, {0xc3a6a000}, {0xc3a6c000}, {0xc3a6e000}, {0xc3a70000}, {0xc3a72000}, {0xc3a74000}, {0xc3a76000}, {0xc3a78000}, {0xc3a7a000}, {0xc3a7c000}, {0xc3a7e000}, {0xc3a80000}, {0xc3a82000}, {0xc3a84000}, {0xc3a86000}, {0xc3a88000}, {0xc3a8a000}, {0xc3a8c000}, {0xc3a8e000}, {0xc3a90000}, {0xc3a92000}, {0xc3a94000}, {0xc3a96000}, {0xc3a98000}, {0xc3a9a000}, {0xc3a9c000}, {0xc3a9e000}, {0xc3aa0000}, {0xc3aa2000}, {0xc3aa4000}, {0xc3aa6000}, {0xc3aa8000}, {0xc3aaa000}, {0xc3aac000}, {0xc3aae000}, {0xc3ab0000}, {0xc3ab2000}, {0xc3ab4000}, {0xc3ab6000}, {0xc3ab8000}, {0xc3aba000}, {0xc3abc000}, {0xc3abe000}, {0xc3ac0000}, {0xc3ac2000}, {0xc3ac4000}, {0xc3ac6000}, {0xc3ac8000}, {0xc3aca000}, {0xc3acc000}, {0xc3ace000}, {0xc3ad0000}, {0xc3ad2000}, {0xc3ad4000}, {0xc3ad6000}, {0xc3ad8000}, {0xc3ada000}, {0xc3adc000}, {0xc3ade000}, {0xc3ae0000}, {0xc3ae2000}, {0xc3ae4000}, {0xc3ae6000}, {0xc3ae8000}, {0xc3aea000}, {0xc3aec000}, {0xc3aee000}, {0xc3af0000}, {0xc3af2000}, {0xc3af4000}, {0xc3af6000}, {0xc3af8000}, {0xc3afa000}, {0xc3afc000}, {0xc3afe000}, {0xc3b00000}, {0xc3b02000}, {0xc3b04000}, {0xc3b06000}, {0xc3b08000}, {0xc3b0a000}, {0xc3b0c000}, {0xc3b0e000}, {0xc3b10000}, {0xc3b12000}, {0xc3b14000}, {0xc3b16000}, {0xc3b18000}, {0xc3b1a000}, {0xc3b1c000}, {0xc3b1e000}, {0xc3b20000}, {0xc3b22000}, {0xc3b24000}, {0xc3b26000}, {0xc3b28000}, {0xc3b2a000}, {0xc3b2c000}, {0xc3b2e000}, {0xc3b30000}, {0xc3b32000}, {0xc3b34000}, {0xc3b36000}, {0xc3b38000}, {0xc3b3a000}, {0xc3b3c000}, {0xc3b3e000}, {0xc3b40000}, {0xc3b42000}, {0xc3b44000}, {0xc3b46000}, {0xc3b48000}, {0xc3b4a000}, {0xc3b4c000}, {0xc3b4e000}, {0xc3b50000}, {0xc3b52000}, {0xc3b54000}, {0xc3b56000}, {0xc3b58000}, {0xc3b5a000}, {0xc3b5c000}, {0xc3b5e000}, {0xc3b60000}, {0xc3b62000}, {0xc3b64000}, {0xc3b66000}, {0xc3b68000}, {0xc3b6a000}, {0xc3b6c000}, {0xc3b6e000}, {0xc3b70000}, {0xc3b72000}, {0xc3b74000}, {0xc3b76000}, {0xc3b78000}, {0xc3b7a000}, {0xc3b7c000}, {0xc3b7e000}, {0xc3b80000}, {0xc3b82000}, {0xc3b84000}, {0xc3b86000}, {0xc3b88000}, {0xc3b8a000}, {0xc3b8c000}, {0xc3b8e000}, {0xc3b90000}, {0xc3b92000}, {0xc3b94000}, {0xc3b96000}, {0xc3b98000}, {0xc3b9a000}, {0xc3b9c000}, {0xc3b9e000}, {0xc3ba0000}, {0xc3ba2000}, {0xc3ba4000}, {0xc3ba6000}, {0xc3ba8000}, {0xc3baa000}, {0xc3bac000}, {0xc3bae000}, {0xc3bb0000}, {0xc3bb2000}, {0xc3bb4000}, {0xc3bb6000}, {0xc3bb8000}, {0xc3bba000}, {0xc3bbc000}, {0xc3bbe000}, {0xc3bc0000}, {0xc3bc2000}, {0xc3bc4000}, {0xc3bc6000}, {0xc3bc8000}, {0xc3bca000}, {0xc3bcc000}, {0xc3bce000}, {0xc3bd0000}, {0xc3bd2000}, {0xc3bd4000}, {0xc3bd6000}, {0xc3bd8000}, {0xc3bda000}, {0xc3bdc000}, {0xc3bde000}, {0xc3be0000}, {0xc3be2000}, {0xc3be4000}, {0xc3be6000}, {0xc3be8000}, {0xc3bea000}, {0xc3bec000}, {0xc3bee000}, {0xc3bf0000}, {0xc3bf2000}, {0xc3bf4000}, {0xc3bf6000}, {0xc3bf8000}, {0xc3bfa000}, {0xc3bfc000}, {0xc3bfe000}, {0xc3c00000}, {0xc3c02000}, {0xc3c04000}, {0xc3c06000}, {0xc3c08000}, {0xc3c0a000}, {0xc3c0c000}, {0xc3c0e000}, {0xc3c10000}, {0xc3c12000}, {0xc3c14000}, {0xc3c16000}, {0xc3c18000}, {0xc3c1a000}, {0xc3c1c000}, {0xc3c1e000}, {0xc3c20000}, {0xc3c22000}, {0xc3c24000}, {0xc3c26000}, {0xc3c28000}, {0xc3c2a000}, {0xc3c2c000}, {0xc3c2e000}, {0xc3c30000}, {0xc3c32000}, {0xc3c34000}, {0xc3c36000}, {0xc3c38000}, {0xc3c3a000}, {0xc3c3c000}, {0xc3c3e000}, {0xc3c40000}, {0xc3c42000}, {0xc3c44000}, {0xc3c46000}, {0xc3c48000}, {0xc3c4a000}, {0xc3c4c000}, {0xc3c4e000}, {0xc3c50000}, {0xc3c52000}, {0xc3c54000}, {0xc3c56000}, {0xc3c58000}, {0xc3c5a000}, {0xc3c5c000}, {0xc3c5e000}, {0xc3c60000}, {0xc3c62000}, {0xc3c64000}, {0xc3c66000}, {0xc3c68000}, {0xc3c6a000}, {0xc3c6c000}, {0xc3c6e000}, {0xc3c70000}, {0xc3c72000}, {0xc3c74000}, {0xc3c76000}, {0xc3c78000}, {0xc3c7a000}, {0xc3c7c000}, {0xc3c7e000}, {0xc3c80000}, {0xc3c82000}, {0xc3c84000}, {0xc3c86000}, {0xc3c88000}, {0xc3c8a000}, {0xc3c8c000}, {0xc3c8e000}, {0xc3c90000}, {0xc3c92000}, {0xc3c94000}, {0xc3c96000}, {0xc3c98000}, {0xc3c9a000}, {0xc3c9c000}, {0xc3c9e000}, {0xc3ca0000}, {0xc3ca2000}, {0xc3ca4000}, {0xc3ca6000}, {0xc3ca8000}, {0xc3caa000}, {0xc3cac000}, {0xc3cae000}, {0xc3cb0000}, {0xc3cb2000}, {0xc3cb4000}, {0xc3cb6000}, {0xc3cb8000}, {0xc3cba000}, {0xc3cbc000}, {0xc3cbe000}, {0xc3cc0000}, {0xc3cc2000}, {0xc3cc4000}, {0xc3cc6000}, {0xc3cc8000}, {0xc3cca000}, {0xc3ccc000}, {0xc3cce000}, {0xc3cd0000}, {0xc3cd2000}, {0xc3cd4000}, {0xc3cd6000}, {0xc3cd8000}, {0xc3cda000}, {0xc3cdc000}, {0xc3cde000}, {0xc3ce0000}, {0xc3ce2000}, {0xc3ce4000}, {0xc3ce6000}, {0xc3ce8000}, {0xc3cea000}, {0xc3cec000}, {0xc3cee000}, {0xc3cf0000}, {0xc3cf2000}, {0xc3cf4000}, {0xc3cf6000}, {0xc3cf8000}, {0xc3cfa000}, {0xc3cfc000}, {0xc3cfe000}, {0xc3d00000}, {0xc3d02000}, {0xc3d04000}, {0xc3d06000}, {0xc3d08000}, {0xc3d0a000}, {0xc3d0c000}, {0xc3d0e000}, {0xc3d10000}, {0xc3d12000}, {0xc3d14000}, {0xc3d16000}, {0xc3d18000}, {0xc3d1a000}, {0xc3d1c000}, {0xc3d1e000}, {0xc3d20000}, {0xc3d22000}, {0xc3d24000}, {0xc3d26000}, {0xc3d28000}, {0xc3d2a000}, {0xc3d2c000}, {0xc3d2e000}, {0xc3d30000}, {0xc3d32000}, {0xc3d34000}, {0xc3d36000}, {0xc3d38000}, {0xc3d3a000}, {0xc3d3c000}, {0xc3d3e000}, {0xc3d40000}, {0xc3d42000}, {0xc3d44000}, {0xc3d46000}, {0xc3d48000}, {0xc3d4a000}, {0xc3d4c000}, {0xc3d4e000}, {0xc3d50000}, {0xc3d52000}, {0xc3d54000}, {0xc3d56000}, {0xc3d58000}, {0xc3d5a000}, {0xc3d5c000}, {0xc3d5e000}, {0xc3d60000}, {0xc3d62000}, {0xc3d64000}, {0xc3d66000}, {0xc3d68000}, {0xc3d6a000}, {0xc3d6c000}, {0xc3d6e000}, {0xc3d70000}, {0xc3d72000}, {0xc3d74000}, {0xc3d76000}, {0xc3d78000}, {0xc3d7a000}, {0xc3d7c000}, {0xc3d7e000}, {0xc3d80000}, {0xc3d82000}, {0xc3d84000}, {0xc3d86000}, {0xc3d88000}, {0xc3d8a000}, {0xc3d8c000}, {0xc3d8e000}, {0xc3d90000}, {0xc3d92000}, {0xc3d94000}, {0xc3d96000}, {0xc3d98000}, {0xc3d9a000}, {0xc3d9c000}, {0xc3d9e000}, {0xc3da0000}, {0xc3da2000}, {0xc3da4000}, {0xc3da6000}, {0xc3da8000}, {0xc3daa000}, {0xc3dac000}, {0xc3dae000}, {0xc3db0000}, {0xc3db2000}, {0xc3db4000}, {0xc3db6000}, {0xc3db8000}, {0xc3dba000}, {0xc3dbc000}, {0xc3dbe000}, {0xc3dc0000}, {0xc3dc2000}, {0xc3dc4000}, {0xc3dc6000}, {0xc3dc8000}, {0xc3dca000}, {0xc3dcc000}, {0xc3dce000}, {0xc3dd0000}, {0xc3dd2000}, {0xc3dd4000}, {0xc3dd6000}, {0xc3dd8000}, {0xc3dda000}, {0xc3ddc000}, {0xc3dde000}, {0xc3de0000}, {0xc3de2000}, {0xc3de4000}, {0xc3de6000}, {0xc3de8000}, {0xc3dea000}, {0xc3dec000}, {0xc3dee000}, {0xc3df0000}, {0xc3df2000}, {0xc3df4000}, {0xc3df6000}, {0xc3df8000}, {0xc3dfa000}, {0xc3dfc000}, {0xc3dfe000}, {0xc3e00000}, {0xc3e02000}, {0xc3e04000}, {0xc3e06000}, {0xc3e08000}, {0xc3e0a000}, {0xc3e0c000}, {0xc3e0e000}, {0xc3e10000}, {0xc3e12000}, {0xc3e14000}, {0xc3e16000}, {0xc3e18000}, {0xc3e1a000}, {0xc3e1c000}, {0xc3e1e000}, {0xc3e20000}, {0xc3e22000}, {0xc3e24000}, {0xc3e26000}, {0xc3e28000}, {0xc3e2a000}, {0xc3e2c000}, {0xc3e2e000}, {0xc3e30000}, {0xc3e32000}, {0xc3e34000}, {0xc3e36000}, {0xc3e38000}, {0xc3e3a000}, {0xc3e3c000}, {0xc3e3e000}, {0xc3e40000}, {0xc3e42000}, {0xc3e44000}, {0xc3e46000}, {0xc3e48000}, {0xc3e4a000}, {0xc3e4c000}, {0xc3e4e000}, {0xc3e50000}, {0xc3e52000}, {0xc3e54000}, {0xc3e56000}, {0xc3e58000}, {0xc3e5a000}, {0xc3e5c000}, {0xc3e5e000}, {0xc3e60000}, {0xc3e62000}, {0xc3e64000}, {0xc3e66000}, {0xc3e68000}, {0xc3e6a000}, {0xc3e6c000}, {0xc3e6e000}, {0xc3e70000}, {0xc3e72000}, {0xc3e74000}, {0xc3e76000}, {0xc3e78000}, {0xc3e7a000}, {0xc3e7c000}, {0xc3e7e000}, {0xc3e80000}, {0xc3e82000}, {0xc3e84000}, {0xc3e86000}, {0xc3e88000}, {0xc3e8a000}, {0xc3e8c000}, {0xc3e8e000}, {0xc3e90000}, {0xc3e92000}, {0xc3e94000}, {0xc3e96000}, {0xc3e98000}, {0xc3e9a000}, {0xc3e9c000}, {0xc3e9e000}, {0xc3ea0000}, {0xc3ea2000}, {0xc3ea4000}, {0xc3ea6000}, {0xc3ea8000}, {0xc3eaa000}, {0xc3eac000}, {0xc3eae000}, {0xc3eb0000}, {0xc3eb2000}, {0xc3eb4000}, {0xc3eb6000}, {0xc3eb8000}, {0xc3eba000}, {0xc3ebc000}, {0xc3ebe000}, {0xc3ec0000}, {0xc3ec2000}, {0xc3ec4000}, {0xc3ec6000}, {0xc3ec8000}, {0xc3eca000}, {0xc3ecc000}, {0xc3ece000}, {0xc3ed0000}, {0xc3ed2000}, {0xc3ed4000}, {0xc3ed6000}, {0xc3ed8000}, {0xc3eda000}, {0xc3edc000}, {0xc3ede000}, {0xc3ee0000}, {0xc3ee2000}, {0xc3ee4000}, {0xc3ee6000}, {0xc3ee8000}, {0xc3eea000}, {0xc3eec000}, {0xc3eee000}, {0xc3ef0000}, {0xc3ef2000}, {0xc3ef4000}, {0xc3ef6000}, {0xc3ef8000}, {0xc3efa000}, {0xc3efc000}, {0xc3efe000}, {0xc3f00000}, {0xc3f02000}, {0xc3f04000}, {0xc3f06000}, {0xc3f08000}, {0xc3f0a000}, {0xc3f0c000}, {0xc3f0e000}, {0xc3f10000}, {0xc3f12000}, {0xc3f14000}, {0xc3f16000}, {0xc3f18000}, {0xc3f1a000}, {0xc3f1c000}, {0xc3f1e000}, {0xc3f20000}, {0xc3f22000}, {0xc3f24000}, {0xc3f26000}, {0xc3f28000}, {0xc3f2a000}, {0xc3f2c000}, {0xc3f2e000}, {0xc3f30000}, {0xc3f32000}, {0xc3f34000}, {0xc3f36000}, {0xc3f38000}, {0xc3f3a000}, {0xc3f3c000}, {0xc3f3e000}, {0xc3f40000}, {0xc3f42000}, {0xc3f44000}, {0xc3f46000}, {0xc3f48000}, {0xc3f4a000}, {0xc3f4c000}, {0xc3f4e000}, {0xc3f50000}, {0xc3f52000}, {0xc3f54000}, {0xc3f56000}, {0xc3f58000}, {0xc3f5a000}, {0xc3f5c000}, {0xc3f5e000}, {0xc3f60000}, {0xc3f62000}, {0xc3f64000}, {0xc3f66000}, {0xc3f68000}, {0xc3f6a000}, {0xc3f6c000}, {0xc3f6e000}, {0xc3f70000}, {0xc3f72000}, {0xc3f74000}, {0xc3f76000}, {0xc3f78000}, {0xc3f7a000}, {0xc3f7c000}, {0xc3f7e000}, {0xc3f80000}, {0xc3f82000}, {0xc3f84000}, {0xc3f86000}, {0xc3f88000}, {0xc3f8a000}, {0xc3f8c000}, {0xc3f8e000}, {0xc3f90000}, {0xc3f92000}, {0xc3f94000}, {0xc3f96000}, {0xc3f98000}, {0xc3f9a000}, {0xc3f9c000}, {0xc3f9e000}, {0xc3fa0000}, {0xc3fa2000}, {0xc3fa4000}, {0xc3fa6000}, {0xc3fa8000}, {0xc3faa000}, {0xc3fac000}, {0xc3fae000}, {0xc3fb0000}, {0xc3fb2000}, {0xc3fb4000}, {0xc3fb6000}, {0xc3fb8000}, {0xc3fba000}, {0xc3fbc000}, {0xc3fbe000}, {0xc3fc0000}, {0xc3fc2000}, {0xc3fc4000}, {0xc3fc6000}, {0xc3fc8000}, {0xc3fca000}, {0xc3fcc000}, {0xc3fce000}, {0xc3fd0000}, {0xc3fd2000}, {0xc3fd4000}, {0xc3fd6000}, {0xc3fd8000}, {0xc3fda000}, {0xc3fdc000}, {0xc3fde000}, {0xc3fe0000}, {0xc3fe2000}, {0xc3fe4000}, {0xc3fe6000}, {0xc3fe8000}, {0xc3fea000}, {0xc3fec000}, {0xc3fee000}, {0xc3ff0000}, {0xc3ff2000}, {0xc3ff4000}, {0xc3ff6000}, {0xc3ff8000}, {0xc3ffa000}, {0xc3ffc000}, {0xc3ffe000}, {0xc4000000}, {0xc4002000}, {0xc4004000}, {0xc4006000}, {0xc4008000}, {0xc400a000}, {0xc400c000}, {0xc400e000}, {0xc4010000}, {0xc4012000}, {0xc4014000}, {0xc4016000}, {0xc4018000}, {0xc401a000}, {0xc401c000}, {0xc401e000}, {0xc4020000}, {0xc4022000}, {0xc4024000}, {0xc4026000}, {0xc4028000}, {0xc402a000}, {0xc402c000}, {0xc402e000}, {0xc4030000}, {0xc4032000}, {0xc4034000}, {0xc4036000}, {0xc4038000}, {0xc403a000}, {0xc403c000}, {0xc403e000}, {0xc4040000}, {0xc4042000}, {0xc4044000}, {0xc4046000}, {0xc4048000}, {0xc404a000}, {0xc404c000}, {0xc404e000}, {0xc4050000}, {0xc4052000}, {0xc4054000}, {0xc4056000}, {0xc4058000}, {0xc405a000}, {0xc405c000}, {0xc405e000}, {0xc4060000}, {0xc4062000}, {0xc4064000}, {0xc4066000}, {0xc4068000}, {0xc406a000}, {0xc406c000}, {0xc406e000}, {0xc4070000}, {0xc4072000}, {0xc4074000}, {0xc4076000}, {0xc4078000}, {0xc407a000}, {0xc407c000}, {0xc407e000}, {0xc4080000}, {0xc4082000}, {0xc4084000}, {0xc4086000}, {0xc4088000}, {0xc408a000}, {0xc408c000}, {0xc408e000}, {0xc4090000}, {0xc4092000}, {0xc4094000}, {0xc4096000}, {0xc4098000}, {0xc409a000}, {0xc409c000}, {0xc409e000}, {0xc40a0000}, {0xc40a2000}, {0xc40a4000}, {0xc40a6000}, {0xc40a8000}, {0xc40aa000}, {0xc40ac000}, {0xc40ae000}, {0xc40b0000}, {0xc40b2000}, {0xc40b4000}, {0xc40b6000}, {0xc40b8000}, {0xc40ba000}, {0xc40bc000}, {0xc40be000}, {0xc40c0000}, {0xc40c2000}, {0xc40c4000}, {0xc40c6000}, {0xc40c8000}, {0xc40ca000}, {0xc40cc000}, {0xc40ce000}, {0xc40d0000}, {0xc40d2000}, {0xc40d4000}, {0xc40d6000}, {0xc40d8000}, {0xc40da000}, {0xc40dc000}, {0xc40de000}, {0xc40e0000}, {0xc40e2000}, {0xc40e4000}, {0xc40e6000}, {0xc40e8000}, {0xc40ea000}, {0xc40ec000}, {0xc40ee000}, {0xc40f0000}, {0xc40f2000}, {0xc40f4000}, {0xc40f6000}, {0xc40f8000}, {0xc40fa000}, {0xc40fc000}, {0xc40fe000}, {0xc4100000}, {0xc4102000}, {0xc4104000}, {0xc4106000}, {0xc4108000}, {0xc410a000}, {0xc410c000}, {0xc410e000}, {0xc4110000}, {0xc4112000}, {0xc4114000}, {0xc4116000}, {0xc4118000}, {0xc411a000}, {0xc411c000}, {0xc411e000}, {0xc4120000}, {0xc4122000}, {0xc4124000}, {0xc4126000}, {0xc4128000}, {0xc412a000}, {0xc412c000}, {0xc412e000}, {0xc4130000}, {0xc4132000}, {0xc4134000}, {0xc4136000}, {0xc4138000}, {0xc413a000}, {0xc413c000}, {0xc413e000}, {0xc4140000}, {0xc4142000}, {0xc4144000}, {0xc4146000}, {0xc4148000}, {0xc414a000}, {0xc414c000}, {0xc414e000}, {0xc4150000}, {0xc4152000}, {0xc4154000}, {0xc4156000}, {0xc4158000}, {0xc415a000}, {0xc415c000}, {0xc415e000}, {0xc4160000}, {0xc4162000}, {0xc4164000}, {0xc4166000}, {0xc4168000}, {0xc416a000}, {0xc416c000}, {0xc416e000}, {0xc4170000}, {0xc4172000}, {0xc4174000}, {0xc4176000}, {0xc4178000}, {0xc417a000}, {0xc417c000}, {0xc417e000}, {0xc4180000}, {0xc4182000}, {0xc4184000}, {0xc4186000}, {0xc4188000}, {0xc418a000}, {0xc418c000}, {0xc418e000}, {0xc4190000}, {0xc4192000}, {0xc4194000}, {0xc4196000}, {0xc4198000}, {0xc419a000}, {0xc419c000}, {0xc419e000}, {0xc41a0000}, {0xc41a2000}, {0xc41a4000}, {0xc41a6000}, {0xc41a8000}, {0xc41aa000}, {0xc41ac000}, {0xc41ae000}, {0xc41b0000}, {0xc41b2000}, {0xc41b4000}, {0xc41b6000}, {0xc41b8000}, {0xc41ba000}, {0xc41bc000}, {0xc41be000}, {0xc41c0000}, {0xc41c2000}, {0xc41c4000}, {0xc41c6000}, {0xc41c8000}, {0xc41ca000}, {0xc41cc000}, {0xc41ce000}, {0xc41d0000}, {0xc41d2000}, {0xc41d4000}, {0xc41d6000}, {0xc41d8000}, {0xc41da000}, {0xc41dc000}, {0xc41de000}, {0xc41e0000}, {0xc41e2000}, {0xc41e4000}, {0xc41e6000}, {0xc41e8000}, {0xc41ea000}, {0xc41ec000}, {0xc41ee000}, {0xc41f0000}, {0xc41f2000}, {0xc41f4000}, {0xc41f6000}, {0xc41f8000}, {0xc41fa000}, {0xc41fc000}, {0xc41fe000}, {0xc4200000}, {0xc4202000}, {0xc4204000}, {0xc4206000}, {0xc4208000}, {0xc420a000}, {0xc420c000}, {0xc420e000}, {0xc4210000}, {0xc4212000}, {0xc4214000}, {0xc4216000}, {0xc4218000}, {0xc421a000}, {0xc421c000}, {0xc421e000}, {0xc4220000}, {0xc4222000}, {0xc4224000}, {0xc4226000}, {0xc4228000}, {0xc422a000}, {0xc422c000}, {0xc422e000}, {0xc4230000}, {0xc4232000}, {0xc4234000}, {0xc4236000}, {0xc4238000}, {0xc423a000}, {0xc423c000}, {0xc423e000}, {0xc4240000}, {0xc4242000}, {0xc4244000}, {0xc4246000}, {0xc4248000}, {0xc424a000}, {0xc424c000}, {0xc424e000}, {0xc4250000}, {0xc4252000}, {0xc4254000}, {0xc4256000}, {0xc4258000}, {0xc425a000}, {0xc425c000}, {0xc425e000}, {0xc4260000}, {0xc4262000}, {0xc4264000}, {0xc4266000}, {0xc4268000}, {0xc426a000}, {0xc426c000}, {0xc426e000}, {0xc4270000}, {0xc4272000}, {0xc4274000}, {0xc4276000}, {0xc4278000}, {0xc427a000}, {0xc427c000}, {0xc427e000}, {0xc4280000}, {0xc4282000}, {0xc4284000}, {0xc4286000}, {0xc4288000}, {0xc428a000}, {0xc428c000}, {0xc428e000}, {0xc4290000}, {0xc4292000}, {0xc4294000}, {0xc4296000}, {0xc4298000}, {0xc429a000}, {0xc429c000}, {0xc429e000}, {0xc42a0000}, {0xc42a2000}, {0xc42a4000}, {0xc42a6000}, {0xc42a8000}, {0xc42aa000}, {0xc42ac000}, {0xc42ae000}, {0xc42b0000}, {0xc42b2000}, {0xc42b4000}, {0xc42b6000}, {0xc42b8000}, {0xc42ba000}, {0xc42bc000}, {0xc42be000}, {0xc42c0000}, {0xc42c2000}, {0xc42c4000}, {0xc42c6000}, {0xc42c8000}, {0xc42ca000}, {0xc42cc000}, {0xc42ce000}, {0xc42d0000}, {0xc42d2000}, {0xc42d4000}, {0xc42d6000}, {0xc42d8000}, {0xc42da000}, {0xc42dc000}, {0xc42de000}, {0xc42e0000}, {0xc42e2000}, {0xc42e4000}, {0xc42e6000}, {0xc42e8000}, {0xc42ea000}, {0xc42ec000}, {0xc42ee000}, {0xc42f0000}, {0xc42f2000}, {0xc42f4000}, {0xc42f6000}, {0xc42f8000}, {0xc42fa000}, {0xc42fc000}, {0xc42fe000}, {0xc4300000}, {0xc4302000}, {0xc4304000}, {0xc4306000}, {0xc4308000}, {0xc430a000}, {0xc430c000}, {0xc430e000}, {0xc4310000}, {0xc4312000}, {0xc4314000}, {0xc4316000}, {0xc4318000}, {0xc431a000}, {0xc431c000}, {0xc431e000}, {0xc4320000}, {0xc4322000}, {0xc4324000}, {0xc4326000}, {0xc4328000}, {0xc432a000}, {0xc432c000}, {0xc432e000}, {0xc4330000}, {0xc4332000}, {0xc4334000}, {0xc4336000}, {0xc4338000}, {0xc433a000}, {0xc433c000}, {0xc433e000}, {0xc4340000}, {0xc4342000}, {0xc4344000}, {0xc4346000}, {0xc4348000}, {0xc434a000}, {0xc434c000}, {0xc434e000}, {0xc4350000}, {0xc4352000}, {0xc4354000}, {0xc4356000}, {0xc4358000}, {0xc435a000}, {0xc435c000}, {0xc435e000}, {0xc4360000}, {0xc4362000}, {0xc4364000}, {0xc4366000}, {0xc4368000}, {0xc436a000}, {0xc436c000}, {0xc436e000}, {0xc4370000}, {0xc4372000}, {0xc4374000}, {0xc4376000}, {0xc4378000}, {0xc437a000}, {0xc437c000}, {0xc437e000}, {0xc4380000}, {0xc4382000}, {0xc4384000}, {0xc4386000}, {0xc4388000}, {0xc438a000}, {0xc438c000}, {0xc438e000}, {0xc4390000}, {0xc4392000}, {0xc4394000}, {0xc4396000}, {0xc4398000}, {0xc439a000}, {0xc439c000}, {0xc439e000}, {0xc43a0000}, {0xc43a2000}, {0xc43a4000}, {0xc43a6000}, {0xc43a8000}, {0xc43aa000}, {0xc43ac000}, {0xc43ae000}, {0xc43b0000}, {0xc43b2000}, {0xc43b4000}, {0xc43b6000}, {0xc43b8000}, {0xc43ba000}, {0xc43bc000}, {0xc43be000}, {0xc43c0000}, {0xc43c2000}, {0xc43c4000}, {0xc43c6000}, {0xc43c8000}, {0xc43ca000}, {0xc43cc000}, {0xc43ce000}, {0xc43d0000}, {0xc43d2000}, {0xc43d4000}, {0xc43d6000}, {0xc43d8000}, {0xc43da000}, {0xc43dc000}, {0xc43de000}, {0xc43e0000}, {0xc43e2000}, {0xc43e4000}, {0xc43e6000}, {0xc43e8000}, {0xc43ea000}, {0xc43ec000}, {0xc43ee000}, {0xc43f0000}, {0xc43f2000}, {0xc43f4000}, {0xc43f6000}, {0xc43f8000}, {0xc43fa000}, {0xc43fc000}, {0xc43fe000}, {0xc4400000}, {0xc4402000}, {0xc4404000}, {0xc4406000}, {0xc4408000}, {0xc440a000}, {0xc440c000}, {0xc440e000}, {0xc4410000}, {0xc4412000}, {0xc4414000}, {0xc4416000}, {0xc4418000}, {0xc441a000}, {0xc441c000}, {0xc441e000}, {0xc4420000}, {0xc4422000}, {0xc4424000}, {0xc4426000}, {0xc4428000}, {0xc442a000}, {0xc442c000}, {0xc442e000}, {0xc4430000}, {0xc4432000}, {0xc4434000}, {0xc4436000}, {0xc4438000}, {0xc443a000}, {0xc443c000}, {0xc443e000}, {0xc4440000}, {0xc4442000}, {0xc4444000}, {0xc4446000}, {0xc4448000}, {0xc444a000}, {0xc444c000}, {0xc444e000}, {0xc4450000}, {0xc4452000}, {0xc4454000}, {0xc4456000}, {0xc4458000}, {0xc445a000}, {0xc445c000}, {0xc445e000}, {0xc4460000}, {0xc4462000}, {0xc4464000}, {0xc4466000}, {0xc4468000}, {0xc446a000}, {0xc446c000}, {0xc446e000}, {0xc4470000}, {0xc4472000}, {0xc4474000}, {0xc4476000}, {0xc4478000}, {0xc447a000}, {0xc447c000}, {0xc447e000}, {0xc4480000}, {0xc4482000}, {0xc4484000}, {0xc4486000}, {0xc4488000}, {0xc448a000}, {0xc448c000}, {0xc448e000}, {0xc4490000}, {0xc4492000}, {0xc4494000}, {0xc4496000}, {0xc4498000}, {0xc449a000}, {0xc449c000}, {0xc449e000}, {0xc44a0000}, {0xc44a2000}, {0xc44a4000}, {0xc44a6000}, {0xc44a8000}, {0xc44aa000}, {0xc44ac000}, {0xc44ae000}, {0xc44b0000}, {0xc44b2000}, {0xc44b4000}, {0xc44b6000}, {0xc44b8000}, {0xc44ba000}, {0xc44bc000}, {0xc44be000}, {0xc44c0000}, {0xc44c2000}, {0xc44c4000}, {0xc44c6000}, {0xc44c8000}, {0xc44ca000}, {0xc44cc000}, {0xc44ce000}, {0xc44d0000}, {0xc44d2000}, {0xc44d4000}, {0xc44d6000}, {0xc44d8000}, {0xc44da000}, {0xc44dc000}, {0xc44de000}, {0xc44e0000}, {0xc44e2000}, {0xc44e4000}, {0xc44e6000}, {0xc44e8000}, {0xc44ea000}, {0xc44ec000}, {0xc44ee000}, {0xc44f0000}, {0xc44f2000}, {0xc44f4000}, {0xc44f6000}, {0xc44f8000}, {0xc44fa000}, {0xc44fc000}, {0xc44fe000}, {0xc4500000}, {0xc4502000}, {0xc4504000}, {0xc4506000}, {0xc4508000}, {0xc450a000}, {0xc450c000}, {0xc450e000}, {0xc4510000}, {0xc4512000}, {0xc4514000}, {0xc4516000}, {0xc4518000}, {0xc451a000}, {0xc451c000}, {0xc451e000}, {0xc4520000}, {0xc4522000}, {0xc4524000}, {0xc4526000}, {0xc4528000}, {0xc452a000}, {0xc452c000}, {0xc452e000}, {0xc4530000}, {0xc4532000}, {0xc4534000}, {0xc4536000}, {0xc4538000}, {0xc453a000}, {0xc453c000}, {0xc453e000}, {0xc4540000}, {0xc4542000}, {0xc4544000}, {0xc4546000}, {0xc4548000}, {0xc454a000}, {0xc454c000}, {0xc454e000}, {0xc4550000}, {0xc4552000}, {0xc4554000}, {0xc4556000}, {0xc4558000}, {0xc455a000}, {0xc455c000}, {0xc455e000}, {0xc4560000}, {0xc4562000}, {0xc4564000}, {0xc4566000}, {0xc4568000}, {0xc456a000}, {0xc456c000}, {0xc456e000}, {0xc4570000}, {0xc4572000}, {0xc4574000}, {0xc4576000}, {0xc4578000}, {0xc457a000}, {0xc457c000}, {0xc457e000}, {0xc4580000}, {0xc4582000}, {0xc4584000}, {0xc4586000}, {0xc4588000}, {0xc458a000}, {0xc458c000}, {0xc458e000}, {0xc4590000}, {0xc4592000}, {0xc4594000}, {0xc4596000}, {0xc4598000}, {0xc459a000}, {0xc459c000}, {0xc459e000}, {0xc45a0000}, {0xc45a2000}, {0xc45a4000}, {0xc45a6000}, {0xc45a8000}, {0xc45aa000}, {0xc45ac000}, {0xc45ae000}, {0xc45b0000}, {0xc45b2000}, {0xc45b4000}, {0xc45b6000}, {0xc45b8000}, {0xc45ba000}, {0xc45bc000}, {0xc45be000}, {0xc45c0000}, {0xc45c2000}, {0xc45c4000}, {0xc45c6000}, {0xc45c8000}, {0xc45ca000}, {0xc45cc000}, {0xc45ce000}, {0xc45d0000}, {0xc45d2000}, {0xc45d4000}, {0xc45d6000}, {0xc45d8000}, {0xc45da000}, {0xc45dc000}, {0xc45de000}, {0xc45e0000}, {0xc45e2000}, {0xc45e4000}, {0xc45e6000}, {0xc45e8000}, {0xc45ea000}, {0xc45ec000}, {0xc45ee000}, {0xc45f0000}, {0xc45f2000}, {0xc45f4000}, {0xc45f6000}, {0xc45f8000}, {0xc45fa000}, {0xc45fc000}, {0xc45fe000}, {0xc4600000}, {0xc4602000}, {0xc4604000}, {0xc4606000}, {0xc4608000}, {0xc460a000}, {0xc460c000}, {0xc460e000}, {0xc4610000}, {0xc4612000}, {0xc4614000}, {0xc4616000}, {0xc4618000}, {0xc461a000}, {0xc461c000}, {0xc461e000}, {0xc4620000}, {0xc4622000}, {0xc4624000}, {0xc4626000}, {0xc4628000}, {0xc462a000}, {0xc462c000}, {0xc462e000}, {0xc4630000}, {0xc4632000}, {0xc4634000}, {0xc4636000}, {0xc4638000}, {0xc463a000}, {0xc463c000}, {0xc463e000}, {0xc4640000}, {0xc4642000}, {0xc4644000}, {0xc4646000}, {0xc4648000}, {0xc464a000}, {0xc464c000}, {0xc464e000}, {0xc4650000}, {0xc4652000}, {0xc4654000}, {0xc4656000}, {0xc4658000}, {0xc465a000}, {0xc465c000}, {0xc465e000}, {0xc4660000}, {0xc4662000}, {0xc4664000}, {0xc4666000}, {0xc4668000}, {0xc466a000}, {0xc466c000}, {0xc466e000}, {0xc4670000}, {0xc4672000}, {0xc4674000}, {0xc4676000}, {0xc4678000}, {0xc467a000}, {0xc467c000}, {0xc467e000}, {0xc4680000}, {0xc4682000}, {0xc4684000}, {0xc4686000}, {0xc4688000}, {0xc468a000}, {0xc468c000}, {0xc468e000}, {0xc4690000}, {0xc4692000}, {0xc4694000}, {0xc4696000}, {0xc4698000}, {0xc469a000}, {0xc469c000}, {0xc469e000}, {0xc46a0000}, {0xc46a2000}, {0xc46a4000}, {0xc46a6000}, {0xc46a8000}, {0xc46aa000}, {0xc46ac000}, {0xc46ae000}, {0xc46b0000}, {0xc46b2000}, {0xc46b4000}, {0xc46b6000}, {0xc46b8000}, {0xc46ba000}, {0xc46bc000}, {0xc46be000}, {0xc46c0000}, {0xc46c2000}, {0xc46c4000}, {0xc46c6000}, {0xc46c8000}, {0xc46ca000}, {0xc46cc000}, {0xc46ce000}, {0xc46d0000}, {0xc46d2000}, {0xc46d4000}, {0xc46d6000}, {0xc46d8000}, {0xc46da000}, {0xc46dc000}, {0xc46de000}, {0xc46e0000}, {0xc46e2000}, {0xc46e4000}, {0xc46e6000}, {0xc46e8000}, {0xc46ea000}, {0xc46ec000}, {0xc46ee000}, {0xc46f0000}, {0xc46f2000}, {0xc46f4000}, {0xc46f6000}, {0xc46f8000}, {0xc46fa000}, {0xc46fc000}, {0xc46fe000}, {0xc4700000}, {0xc4702000}, {0xc4704000}, {0xc4706000}, {0xc4708000}, {0xc470a000}, {0xc470c000}, {0xc470e000}, {0xc4710000}, {0xc4712000}, {0xc4714000}, {0xc4716000}, {0xc4718000}, {0xc471a000}, {0xc471c000}, {0xc471e000}, {0xc4720000}, {0xc4722000}, {0xc4724000}, {0xc4726000}, {0xc4728000}, {0xc472a000}, {0xc472c000}, {0xc472e000}, {0xc4730000}, {0xc4732000}, {0xc4734000}, {0xc4736000}, {0xc4738000}, {0xc473a000}, {0xc473c000}, {0xc473e000}, {0xc4740000}, {0xc4742000}, {0xc4744000}, {0xc4746000}, {0xc4748000}, {0xc474a000}, {0xc474c000}, {0xc474e000}, {0xc4750000}, {0xc4752000}, {0xc4754000}, {0xc4756000}, {0xc4758000}, {0xc475a000}, {0xc475c000}, {0xc475e000}, {0xc4760000}, {0xc4762000}, {0xc4764000}, {0xc4766000}, {0xc4768000}, {0xc476a000}, {0xc476c000}, {0xc476e000}, {0xc4770000}, {0xc4772000}, {0xc4774000}, {0xc4776000}, {0xc4778000}, {0xc477a000}, {0xc477c000}, {0xc477e000}, {0xc4780000}, {0xc4782000}, {0xc4784000}, {0xc4786000}, {0xc4788000}, {0xc478a000}, {0xc478c000}, {0xc478e000}, {0xc4790000}, {0xc4792000}, {0xc4794000}, {0xc4796000}, {0xc4798000}, {0xc479a000}, {0xc479c000}, {0xc479e000}, {0xc47a0000}, {0xc47a2000}, {0xc47a4000}, {0xc47a6000}, {0xc47a8000}, {0xc47aa000}, {0xc47ac000}, {0xc47ae000}, {0xc47b0000}, {0xc47b2000}, {0xc47b4000}, {0xc47b6000}, {0xc47b8000}, {0xc47ba000}, {0xc47bc000}, {0xc47be000}, {0xc47c0000}, {0xc47c2000}, {0xc47c4000}, {0xc47c6000}, {0xc47c8000}, {0xc47ca000}, {0xc47cc000}, {0xc47ce000}, {0xc47d0000}, {0xc47d2000}, {0xc47d4000}, {0xc47d6000}, {0xc47d8000}, {0xc47da000}, {0xc47dc000}, {0xc47de000}, {0xc47e0000}, {0xc47e2000}, {0xc47e4000}, {0xc47e6000}, {0xc47e8000}, {0xc47ea000}, {0xc47ec000}, {0xc47ee000}, {0xc47f0000}, {0xc47f2000}, {0xc47f4000}, {0xc47f6000}, {0xc47f8000}, {0xc47fa000}, {0xc47fc000}, {0xc47fe000}, {0xc4800000}, {0xc4802000}, {0xc4804000}, {0xc4806000}, {0xc4808000}, {0xc480a000}, {0xc480c000}, {0xc480e000}, {0xc4810000}, {0xc4812000}, {0xc4814000}, {0xc4816000}, {0xc4818000}, {0xc481a000}, {0xc481c000}, {0xc481e000}, {0xc4820000}, {0xc4822000}, {0xc4824000}, {0xc4826000}, {0xc4828000}, {0xc482a000}, {0xc482c000}, {0xc482e000}, {0xc4830000}, {0xc4832000}, {0xc4834000}, {0xc4836000}, {0xc4838000}, {0xc483a000}, {0xc483c000}, {0xc483e000}, {0xc4840000}, {0xc4842000}, {0xc4844000}, {0xc4846000}, {0xc4848000}, {0xc484a000}, {0xc484c000}, {0xc484e000}, {0xc4850000}, {0xc4852000}, {0xc4854000}, {0xc4856000}, {0xc4858000}, {0xc485a000}, {0xc485c000}, {0xc485e000}, {0xc4860000}, {0xc4862000}, {0xc4864000}, {0xc4866000}, {0xc4868000}, {0xc486a000}, {0xc486c000}, {0xc486e000}, {0xc4870000}, {0xc4872000}, {0xc4874000}, {0xc4876000}, {0xc4878000}, {0xc487a000}, {0xc487c000}, {0xc487e000}, {0xc4880000}, {0xc4882000}, {0xc4884000}, {0xc4886000}, {0xc4888000}, {0xc488a000}, {0xc488c000}, {0xc488e000}, {0xc4890000}, {0xc4892000}, {0xc4894000}, {0xc4896000}, {0xc4898000}, {0xc489a000}, {0xc489c000}, {0xc489e000}, {0xc48a0000}, {0xc48a2000}, {0xc48a4000}, {0xc48a6000}, {0xc48a8000}, {0xc48aa000}, {0xc48ac000}, {0xc48ae000}, {0xc48b0000}, {0xc48b2000}, {0xc48b4000}, {0xc48b6000}, {0xc48b8000}, {0xc48ba000}, {0xc48bc000}, {0xc48be000}, {0xc48c0000}, {0xc48c2000}, {0xc48c4000}, {0xc48c6000}, {0xc48c8000}, {0xc48ca000}, {0xc48cc000}, {0xc48ce000}, {0xc48d0000}, {0xc48d2000}, {0xc48d4000}, {0xc48d6000}, {0xc48d8000}, {0xc48da000}, {0xc48dc000}, {0xc48de000}, {0xc48e0000}, {0xc48e2000}, {0xc48e4000}, {0xc48e6000}, {0xc48e8000}, {0xc48ea000}, {0xc48ec000}, {0xc48ee000}, {0xc48f0000}, {0xc48f2000}, {0xc48f4000}, {0xc48f6000}, {0xc48f8000}, {0xc48fa000}, {0xc48fc000}, {0xc48fe000}, {0xc4900000}, {0xc4902000}, {0xc4904000}, {0xc4906000}, {0xc4908000}, {0xc490a000}, {0xc490c000}, {0xc490e000}, {0xc4910000}, {0xc4912000}, {0xc4914000}, {0xc4916000}, {0xc4918000}, {0xc491a000}, {0xc491c000}, {0xc491e000}, {0xc4920000}, {0xc4922000}, {0xc4924000}, {0xc4926000}, {0xc4928000}, {0xc492a000}, {0xc492c000}, {0xc492e000}, {0xc4930000}, {0xc4932000}, {0xc4934000}, {0xc4936000}, {0xc4938000}, {0xc493a000}, {0xc493c000}, {0xc493e000}, {0xc4940000}, {0xc4942000}, {0xc4944000}, {0xc4946000}, {0xc4948000}, {0xc494a000}, {0xc494c000}, {0xc494e000}, {0xc4950000}, {0xc4952000}, {0xc4954000}, {0xc4956000}, {0xc4958000}, {0xc495a000}, {0xc495c000}, {0xc495e000}, {0xc4960000}, {0xc4962000}, {0xc4964000}, {0xc4966000}, {0xc4968000}, {0xc496a000}, {0xc496c000}, {0xc496e000}, {0xc4970000}, {0xc4972000}, {0xc4974000}, {0xc4976000}, {0xc4978000}, {0xc497a000}, {0xc497c000}, {0xc497e000}, {0xc4980000}, {0xc4982000}, {0xc4984000}, {0xc4986000}, {0xc4988000}, {0xc498a000}, {0xc498c000}, {0xc498e000}, {0xc4990000}, {0xc4992000}, {0xc4994000}, {0xc4996000}, {0xc4998000}, {0xc499a000}, {0xc499c000}, {0xc499e000}, {0xc49a0000}, {0xc49a2000}, {0xc49a4000}, {0xc49a6000}, {0xc49a8000}, {0xc49aa000}, {0xc49ac000}, {0xc49ae000}, {0xc49b0000}, {0xc49b2000}, {0xc49b4000}, {0xc49b6000}, {0xc49b8000}, {0xc49ba000}, {0xc49bc000}, {0xc49be000}, {0xc49c0000}, {0xc49c2000}, {0xc49c4000}, {0xc49c6000}, {0xc49c8000}, {0xc49ca000}, {0xc49cc000}, {0xc49ce000}, {0xc49d0000}, {0xc49d2000}, {0xc49d4000}, {0xc49d6000}, {0xc49d8000}, {0xc49da000}, {0xc49dc000}, {0xc49de000}, {0xc49e0000}, {0xc49e2000}, {0xc49e4000}, {0xc49e6000}, {0xc49e8000}, {0xc49ea000}, {0xc49ec000}, {0xc49ee000}, {0xc49f0000}, {0xc49f2000}, {0xc49f4000}, {0xc49f6000}, {0xc49f8000}, {0xc49fa000}, {0xc49fc000}, {0xc49fe000}, {0xc4a00000}, {0xc4a02000}, {0xc4a04000}, {0xc4a06000}, {0xc4a08000}, {0xc4a0a000}, {0xc4a0c000}, {0xc4a0e000}, {0xc4a10000}, {0xc4a12000}, {0xc4a14000}, {0xc4a16000}, {0xc4a18000}, {0xc4a1a000}, {0xc4a1c000}, {0xc4a1e000}, {0xc4a20000}, {0xc4a22000}, {0xc4a24000}, {0xc4a26000}, {0xc4a28000}, {0xc4a2a000}, {0xc4a2c000}, {0xc4a2e000}, {0xc4a30000}, {0xc4a32000}, {0xc4a34000}, {0xc4a36000}, {0xc4a38000}, {0xc4a3a000}, {0xc4a3c000}, {0xc4a3e000}, {0xc4a40000}, {0xc4a42000}, {0xc4a44000}, {0xc4a46000}, {0xc4a48000}, {0xc4a4a000}, {0xc4a4c000}, {0xc4a4e000}, {0xc4a50000}, {0xc4a52000}, {0xc4a54000}, {0xc4a56000}, {0xc4a58000}, {0xc4a5a000}, {0xc4a5c000}, {0xc4a5e000}, {0xc4a60000}, {0xc4a62000}, {0xc4a64000}, {0xc4a66000}, {0xc4a68000}, {0xc4a6a000}, {0xc4a6c000}, {0xc4a6e000}, {0xc4a70000}, {0xc4a72000}, {0xc4a74000}, {0xc4a76000}, {0xc4a78000}, {0xc4a7a000}, {0xc4a7c000}, {0xc4a7e000}, {0xc4a80000}, {0xc4a82000}, {0xc4a84000}, {0xc4a86000}, {0xc4a88000}, {0xc4a8a000}, {0xc4a8c000}, {0xc4a8e000}, {0xc4a90000}, {0xc4a92000}, {0xc4a94000}, {0xc4a96000}, {0xc4a98000}, {0xc4a9a000}, {0xc4a9c000}, {0xc4a9e000}, {0xc4aa0000}, {0xc4aa2000}, {0xc4aa4000}, {0xc4aa6000}, {0xc4aa8000}, {0xc4aaa000}, {0xc4aac000}, {0xc4aae000}, {0xc4ab0000}, {0xc4ab2000}, {0xc4ab4000}, {0xc4ab6000}, {0xc4ab8000}, {0xc4aba000}, {0xc4abc000}, {0xc4abe000}, {0xc4ac0000}, {0xc4ac2000}, {0xc4ac4000}, {0xc4ac6000}, {0xc4ac8000}, {0xc4aca000}, {0xc4acc000}, {0xc4ace000}, {0xc4ad0000}, {0xc4ad2000}, {0xc4ad4000}, {0xc4ad6000}, {0xc4ad8000}, {0xc4ada000}, {0xc4adc000}, {0xc4ade000}, {0xc4ae0000}, {0xc4ae2000}, {0xc4ae4000}, {0xc4ae6000}, {0xc4ae8000}, {0xc4aea000}, {0xc4aec000}, {0xc4aee000}, {0xc4af0000}, {0xc4af2000}, {0xc4af4000}, {0xc4af6000}, {0xc4af8000}, {0xc4afa000}, {0xc4afc000}, {0xc4afe000}, {0xc4b00000}, {0xc4b02000}, {0xc4b04000}, {0xc4b06000}, {0xc4b08000}, {0xc4b0a000}, {0xc4b0c000}, {0xc4b0e000}, {0xc4b10000}, {0xc4b12000}, {0xc4b14000}, {0xc4b16000}, {0xc4b18000}, {0xc4b1a000}, {0xc4b1c000}, {0xc4b1e000}, {0xc4b20000}, {0xc4b22000}, {0xc4b24000}, {0xc4b26000}, {0xc4b28000}, {0xc4b2a000}, {0xc4b2c000}, {0xc4b2e000}, {0xc4b30000}, {0xc4b32000}, {0xc4b34000}, {0xc4b36000}, {0xc4b38000}, {0xc4b3a000}, {0xc4b3c000}, {0xc4b3e000}, {0xc4b40000}, {0xc4b42000}, {0xc4b44000}, {0xc4b46000}, {0xc4b48000}, {0xc4b4a000}, {0xc4b4c000}, {0xc4b4e000}, {0xc4b50000}, {0xc4b52000}, {0xc4b54000}, {0xc4b56000}, {0xc4b58000}, {0xc4b5a000}, {0xc4b5c000}, {0xc4b5e000}, {0xc4b60000}, {0xc4b62000}, {0xc4b64000}, {0xc4b66000}, {0xc4b68000}, {0xc4b6a000}, {0xc4b6c000}, {0xc4b6e000}, {0xc4b70000}, {0xc4b72000}, {0xc4b74000}, {0xc4b76000}, {0xc4b78000}, {0xc4b7a000}, {0xc4b7c000}, {0xc4b7e000}, {0xc4b80000}, {0xc4b82000}, {0xc4b84000}, {0xc4b86000}, {0xc4b88000}, {0xc4b8a000}, {0xc4b8c000}, {0xc4b8e000}, {0xc4b90000}, {0xc4b92000}, {0xc4b94000}, {0xc4b96000}, {0xc4b98000}, {0xc4b9a000}, {0xc4b9c000}, {0xc4b9e000}, {0xc4ba0000}, {0xc4ba2000}, {0xc4ba4000}, {0xc4ba6000}, {0xc4ba8000}, {0xc4baa000}, {0xc4bac000}, {0xc4bae000}, {0xc4bb0000}, {0xc4bb2000}, {0xc4bb4000}, {0xc4bb6000}, {0xc4bb8000}, {0xc4bba000}, {0xc4bbc000}, {0xc4bbe000}, {0xc4bc0000}, {0xc4bc2000}, {0xc4bc4000}, {0xc4bc6000}, {0xc4bc8000}, {0xc4bca000}, {0xc4bcc000}, {0xc4bce000}, {0xc4bd0000}, {0xc4bd2000}, {0xc4bd4000}, {0xc4bd6000}, {0xc4bd8000}, {0xc4bda000}, {0xc4bdc000}, {0xc4bde000}, {0xc4be0000}, {0xc4be2000}, {0xc4be4000}, {0xc4be6000}, {0xc4be8000}, {0xc4bea000}, {0xc4bec000}, {0xc4bee000}, {0xc4bf0000}, {0xc4bf2000}, {0xc4bf4000}, {0xc4bf6000}, {0xc4bf8000}, {0xc4bfa000}, {0xc4bfc000}, {0xc4bfe000}, {0xc4c00000}, {0xc4c02000}, {0xc4c04000}, {0xc4c06000}, {0xc4c08000}, {0xc4c0a000}, {0xc4c0c000}, {0xc4c0e000}, {0xc4c10000}, {0xc4c12000}, {0xc4c14000}, {0xc4c16000}, {0xc4c18000}, {0xc4c1a000}, {0xc4c1c000}, {0xc4c1e000}, {0xc4c20000}, {0xc4c22000}, {0xc4c24000}, {0xc4c26000}, {0xc4c28000}, {0xc4c2a000}, {0xc4c2c000}, {0xc4c2e000}, {0xc4c30000}, {0xc4c32000}, {0xc4c34000}, {0xc4c36000}, {0xc4c38000}, {0xc4c3a000}, {0xc4c3c000}, {0xc4c3e000}, {0xc4c40000}, {0xc4c42000}, {0xc4c44000}, {0xc4c46000}, {0xc4c48000}, {0xc4c4a000}, {0xc4c4c000}, {0xc4c4e000}, {0xc4c50000}, {0xc4c52000}, {0xc4c54000}, {0xc4c56000}, {0xc4c58000}, {0xc4c5a000}, {0xc4c5c000}, {0xc4c5e000}, {0xc4c60000}, {0xc4c62000}, {0xc4c64000}, {0xc4c66000}, {0xc4c68000}, {0xc4c6a000}, {0xc4c6c000}, {0xc4c6e000}, {0xc4c70000}, {0xc4c72000}, {0xc4c74000}, {0xc4c76000}, {0xc4c78000}, {0xc4c7a000}, {0xc4c7c000}, {0xc4c7e000}, {0xc4c80000}, {0xc4c82000}, {0xc4c84000}, {0xc4c86000}, {0xc4c88000}, {0xc4c8a000}, {0xc4c8c000}, {0xc4c8e000}, {0xc4c90000}, {0xc4c92000}, {0xc4c94000}, {0xc4c96000}, {0xc4c98000}, {0xc4c9a000}, {0xc4c9c000}, {0xc4c9e000}, {0xc4ca0000}, {0xc4ca2000}, {0xc4ca4000}, {0xc4ca6000}, {0xc4ca8000}, {0xc4caa000}, {0xc4cac000}, {0xc4cae000}, {0xc4cb0000}, {0xc4cb2000}, {0xc4cb4000}, {0xc4cb6000}, {0xc4cb8000}, {0xc4cba000}, {0xc4cbc000}, {0xc4cbe000}, {0xc4cc0000}, {0xc4cc2000}, {0xc4cc4000}, {0xc4cc6000}, {0xc4cc8000}, {0xc4cca000}, {0xc4ccc000}, {0xc4cce000}, {0xc4cd0000}, {0xc4cd2000}, {0xc4cd4000}, {0xc4cd6000}, {0xc4cd8000}, {0xc4cda000}, {0xc4cdc000}, {0xc4cde000}, {0xc4ce0000}, {0xc4ce2000}, {0xc4ce4000}, {0xc4ce6000}, {0xc4ce8000}, {0xc4cea000}, {0xc4cec000}, {0xc4cee000}, {0xc4cf0000}, {0xc4cf2000}, {0xc4cf4000}, {0xc4cf6000}, {0xc4cf8000}, {0xc4cfa000}, {0xc4cfc000}, {0xc4cfe000}, {0xc4d00000}, {0xc4d02000}, {0xc4d04000}, {0xc4d06000}, {0xc4d08000}, {0xc4d0a000}, {0xc4d0c000}, {0xc4d0e000}, {0xc4d10000}, {0xc4d12000}, {0xc4d14000}, {0xc4d16000}, {0xc4d18000}, {0xc4d1a000}, {0xc4d1c000}, {0xc4d1e000}, {0xc4d20000}, {0xc4d22000}, {0xc4d24000}, {0xc4d26000}, {0xc4d28000}, {0xc4d2a000}, {0xc4d2c000}, {0xc4d2e000}, {0xc4d30000}, {0xc4d32000}, {0xc4d34000}, {0xc4d36000}, {0xc4d38000}, {0xc4d3a000}, {0xc4d3c000}, {0xc4d3e000}, {0xc4d40000}, {0xc4d42000}, {0xc4d44000}, {0xc4d46000}, {0xc4d48000}, {0xc4d4a000}, {0xc4d4c000}, {0xc4d4e000}, {0xc4d50000}, {0xc4d52000}, {0xc4d54000}, {0xc4d56000}, {0xc4d58000}, {0xc4d5a000}, {0xc4d5c000}, {0xc4d5e000}, {0xc4d60000}, {0xc4d62000}, {0xc4d64000}, {0xc4d66000}, {0xc4d68000}, {0xc4d6a000}, {0xc4d6c000}, {0xc4d6e000}, {0xc4d70000}, {0xc4d72000}, {0xc4d74000}, {0xc4d76000}, {0xc4d78000}, {0xc4d7a000}, {0xc4d7c000}, {0xc4d7e000}, {0xc4d80000}, {0xc4d82000}, {0xc4d84000}, {0xc4d86000}, {0xc4d88000}, {0xc4d8a000}, {0xc4d8c000}, {0xc4d8e000}, {0xc4d90000}, {0xc4d92000}, {0xc4d94000}, {0xc4d96000}, {0xc4d98000}, {0xc4d9a000}, {0xc4d9c000}, {0xc4d9e000}, {0xc4da0000}, {0xc4da2000}, {0xc4da4000}, {0xc4da6000}, {0xc4da8000}, {0xc4daa000}, {0xc4dac000}, {0xc4dae000}, {0xc4db0000}, {0xc4db2000}, {0xc4db4000}, {0xc4db6000}, {0xc4db8000}, {0xc4dba000}, {0xc4dbc000}, {0xc4dbe000}, {0xc4dc0000}, {0xc4dc2000}, {0xc4dc4000}, {0xc4dc6000}, {0xc4dc8000}, {0xc4dca000}, {0xc4dcc000}, {0xc4dce000}, {0xc4dd0000}, {0xc4dd2000}, {0xc4dd4000}, {0xc4dd6000}, {0xc4dd8000}, {0xc4dda000}, {0xc4ddc000}, {0xc4dde000}, {0xc4de0000}, {0xc4de2000}, {0xc4de4000}, {0xc4de6000}, {0xc4de8000}, {0xc4dea000}, {0xc4dec000}, {0xc4dee000}, {0xc4df0000}, {0xc4df2000}, {0xc4df4000}, {0xc4df6000}, {0xc4df8000}, {0xc4dfa000}, {0xc4dfc000}, {0xc4dfe000}, {0xc4e00000}, {0xc4e02000}, {0xc4e04000}, {0xc4e06000}, {0xc4e08000}, {0xc4e0a000}, {0xc4e0c000}, {0xc4e0e000}, {0xc4e10000}, {0xc4e12000}, {0xc4e14000}, {0xc4e16000}, {0xc4e18000}, {0xc4e1a000}, {0xc4e1c000}, {0xc4e1e000}, {0xc4e20000}, {0xc4e22000}, {0xc4e24000}, {0xc4e26000}, {0xc4e28000}, {0xc4e2a000}, {0xc4e2c000}, {0xc4e2e000}, {0xc4e30000}, {0xc4e32000}, {0xc4e34000}, {0xc4e36000}, {0xc4e38000}, {0xc4e3a000}, {0xc4e3c000}, {0xc4e3e000}, {0xc4e40000}, {0xc4e42000}, {0xc4e44000}, {0xc4e46000}, {0xc4e48000}, {0xc4e4a000}, {0xc4e4c000}, {0xc4e4e000}, {0xc4e50000}, {0xc4e52000}, {0xc4e54000}, {0xc4e56000}, {0xc4e58000}, {0xc4e5a000}, {0xc4e5c000}, {0xc4e5e000}, {0xc4e60000}, {0xc4e62000}, {0xc4e64000}, {0xc4e66000}, {0xc4e68000}, {0xc4e6a000}, {0xc4e6c000}, {0xc4e6e000}, {0xc4e70000}, {0xc4e72000}, {0xc4e74000}, {0xc4e76000}, {0xc4e78000}, {0xc4e7a000}, {0xc4e7c000}, {0xc4e7e000}, {0xc4e80000}, {0xc4e82000}, {0xc4e84000}, {0xc4e86000}, {0xc4e88000}, {0xc4e8a000}, {0xc4e8c000}, {0xc4e8e000}, {0xc4e90000}, {0xc4e92000}, {0xc4e94000}, {0xc4e96000}, {0xc4e98000}, {0xc4e9a000}, {0xc4e9c000}, {0xc4e9e000}, {0xc4ea0000}, {0xc4ea2000}, {0xc4ea4000}, {0xc4ea6000}, {0xc4ea8000}, {0xc4eaa000}, {0xc4eac000}, {0xc4eae000}, {0xc4eb0000}, {0xc4eb2000}, {0xc4eb4000}, {0xc4eb6000}, {0xc4eb8000}, {0xc4eba000}, {0xc4ebc000}, {0xc4ebe000}, {0xc4ec0000}, {0xc4ec2000}, {0xc4ec4000}, {0xc4ec6000}, {0xc4ec8000}, {0xc4eca000}, {0xc4ecc000}, {0xc4ece000}, {0xc4ed0000}, {0xc4ed2000}, {0xc4ed4000}, {0xc4ed6000}, {0xc4ed8000}, {0xc4eda000}, {0xc4edc000}, {0xc4ede000}, {0xc4ee0000}, {0xc4ee2000}, {0xc4ee4000}, {0xc4ee6000}, {0xc4ee8000}, {0xc4eea000}, {0xc4eec000}, {0xc4eee000}, {0xc4ef0000}, {0xc4ef2000}, {0xc4ef4000}, {0xc4ef6000}, {0xc4ef8000}, {0xc4efa000}, {0xc4efc000}, {0xc4efe000}, {0xc4f00000}, {0xc4f02000}, {0xc4f04000}, {0xc4f06000}, {0xc4f08000}, {0xc4f0a000}, {0xc4f0c000}, {0xc4f0e000}, {0xc4f10000}, {0xc4f12000}, {0xc4f14000}, {0xc4f16000}, {0xc4f18000}, {0xc4f1a000}, {0xc4f1c000}, {0xc4f1e000}, {0xc4f20000}, {0xc4f22000}, {0xc4f24000}, {0xc4f26000}, {0xc4f28000}, {0xc4f2a000}, {0xc4f2c000}, {0xc4f2e000}, {0xc4f30000}, {0xc4f32000}, {0xc4f34000}, {0xc4f36000}, {0xc4f38000}, {0xc4f3a000}, {0xc4f3c000}, {0xc4f3e000}, {0xc4f40000}, {0xc4f42000}, {0xc4f44000}, {0xc4f46000}, {0xc4f48000}, {0xc4f4a000}, {0xc4f4c000}, {0xc4f4e000}, {0xc4f50000}, {0xc4f52000}, {0xc4f54000}, {0xc4f56000}, {0xc4f58000}, {0xc4f5a000}, {0xc4f5c000}, {0xc4f5e000}, {0xc4f60000}, {0xc4f62000}, {0xc4f64000}, {0xc4f66000}, {0xc4f68000}, {0xc4f6a000}, {0xc4f6c000}, {0xc4f6e000}, {0xc4f70000}, {0xc4f72000}, {0xc4f74000}, {0xc4f76000}, {0xc4f78000}, {0xc4f7a000}, {0xc4f7c000}, {0xc4f7e000}, {0xc4f80000}, {0xc4f82000}, {0xc4f84000}, {0xc4f86000}, {0xc4f88000}, {0xc4f8a000}, {0xc4f8c000}, {0xc4f8e000}, {0xc4f90000}, {0xc4f92000}, {0xc4f94000}, {0xc4f96000}, {0xc4f98000}, {0xc4f9a000}, {0xc4f9c000}, {0xc4f9e000}, {0xc4fa0000}, {0xc4fa2000}, {0xc4fa4000}, {0xc4fa6000}, {0xc4fa8000}, {0xc4faa000}, {0xc4fac000}, {0xc4fae000}, {0xc4fb0000}, {0xc4fb2000}, {0xc4fb4000}, {0xc4fb6000}, {0xc4fb8000}, {0xc4fba000}, {0xc4fbc000}, {0xc4fbe000}, {0xc4fc0000}, {0xc4fc2000}, {0xc4fc4000}, {0xc4fc6000}, {0xc4fc8000}, {0xc4fca000}, {0xc4fcc000}, {0xc4fce000}, {0xc4fd0000}, {0xc4fd2000}, {0xc4fd4000}, {0xc4fd6000}, {0xc4fd8000}, {0xc4fda000}, {0xc4fdc000}, {0xc4fde000}, {0xc4fe0000}, {0xc4fe2000}, {0xc4fe4000}, {0xc4fe6000}, {0xc4fe8000}, {0xc4fea000}, {0xc4fec000}, {0xc4fee000}, {0xc4ff0000}, {0xc4ff2000}, {0xc4ff4000}, {0xc4ff6000}, {0xc4ff8000}, {0xc4ffa000}, {0xc4ffc000}, {0xc4ffe000}, {0xc5000000}, {0xc5002000}, {0xc5004000}, {0xc5006000}, {0xc5008000}, {0xc500a000}, {0xc500c000}, {0xc500e000}, {0xc5010000}, {0xc5012000}, {0xc5014000}, {0xc5016000}, {0xc5018000}, {0xc501a000}, {0xc501c000}, {0xc501e000}, {0xc5020000}, {0xc5022000}, {0xc5024000}, {0xc5026000}, {0xc5028000}, {0xc502a000}, {0xc502c000}, {0xc502e000}, {0xc5030000}, {0xc5032000}, {0xc5034000}, {0xc5036000}, {0xc5038000}, {0xc503a000}, {0xc503c000}, {0xc503e000}, {0xc5040000}, {0xc5042000}, {0xc5044000}, {0xc5046000}, {0xc5048000}, {0xc504a000}, {0xc504c000}, {0xc504e000}, {0xc5050000}, {0xc5052000}, {0xc5054000}, {0xc5056000}, {0xc5058000}, {0xc505a000}, {0xc505c000}, {0xc505e000}, {0xc5060000}, {0xc5062000}, {0xc5064000}, {0xc5066000}, {0xc5068000}, {0xc506a000}, {0xc506c000}, {0xc506e000}, {0xc5070000}, {0xc5072000}, {0xc5074000}, {0xc5076000}, {0xc5078000}, {0xc507a000}, {0xc507c000}, {0xc507e000}, {0xc5080000}, {0xc5082000}, {0xc5084000}, {0xc5086000}, {0xc5088000}, {0xc508a000}, {0xc508c000}, {0xc508e000}, {0xc5090000}, {0xc5092000}, {0xc5094000}, {0xc5096000}, {0xc5098000}, {0xc509a000}, {0xc509c000}, {0xc509e000}, {0xc50a0000}, {0xc50a2000}, {0xc50a4000}, {0xc50a6000}, {0xc50a8000}, {0xc50aa000}, {0xc50ac000}, {0xc50ae000}, {0xc50b0000}, {0xc50b2000}, {0xc50b4000}, {0xc50b6000}, {0xc50b8000}, {0xc50ba000}, {0xc50bc000}, {0xc50be000}, {0xc50c0000}, {0xc50c2000}, {0xc50c4000}, {0xc50c6000}, {0xc50c8000}, {0xc50ca000}, {0xc50cc000}, {0xc50ce000}, {0xc50d0000}, {0xc50d2000}, {0xc50d4000}, {0xc50d6000}, {0xc50d8000}, {0xc50da000}, {0xc50dc000}, {0xc50de000}, {0xc50e0000}, {0xc50e2000}, {0xc50e4000}, {0xc50e6000}, {0xc50e8000}, {0xc50ea000}, {0xc50ec000}, {0xc50ee000}, {0xc50f0000}, {0xc50f2000}, {0xc50f4000}, {0xc50f6000}, {0xc50f8000}, {0xc50fa000}, {0xc50fc000}, {0xc50fe000}, {0xc5100000}, {0xc5102000}, {0xc5104000}, {0xc5106000}, {0xc5108000}, {0xc510a000}, {0xc510c000}, {0xc510e000}, {0xc5110000}, {0xc5112000}, {0xc5114000}, {0xc5116000}, {0xc5118000}, {0xc511a000}, {0xc511c000}, {0xc511e000}, {0xc5120000}, {0xc5122000}, {0xc5124000}, {0xc5126000}, {0xc5128000}, {0xc512a000}, {0xc512c000}, {0xc512e000}, {0xc5130000}, {0xc5132000}, {0xc5134000}, {0xc5136000}, {0xc5138000}, {0xc513a000}, {0xc513c000}, {0xc513e000}, {0xc5140000}, {0xc5142000}, {0xc5144000}, {0xc5146000}, {0xc5148000}, {0xc514a000}, {0xc514c000}, {0xc514e000}, {0xc5150000}, {0xc5152000}, {0xc5154000}, {0xc5156000}, {0xc5158000}, {0xc515a000}, {0xc515c000}, {0xc515e000}, {0xc5160000}, {0xc5162000}, {0xc5164000}, {0xc5166000}, {0xc5168000}, {0xc516a000}, {0xc516c000}, {0xc516e000}, {0xc5170000}, {0xc5172000}, {0xc5174000}, {0xc5176000}, {0xc5178000}, {0xc517a000}, {0xc517c000}, {0xc517e000}, {0xc5180000}, {0xc5182000}, {0xc5184000}, {0xc5186000}, {0xc5188000}, {0xc518a000}, {0xc518c000}, {0xc518e000}, {0xc5190000}, {0xc5192000}, {0xc5194000}, {0xc5196000}, {0xc5198000}, {0xc519a000}, {0xc519c000}, {0xc519e000}, {0xc51a0000}, {0xc51a2000}, {0xc51a4000}, {0xc51a6000}, {0xc51a8000}, {0xc51aa000}, {0xc51ac000}, {0xc51ae000}, {0xc51b0000}, {0xc51b2000}, {0xc51b4000}, {0xc51b6000}, {0xc51b8000}, {0xc51ba000}, {0xc51bc000}, {0xc51be000}, {0xc51c0000}, {0xc51c2000}, {0xc51c4000}, {0xc51c6000}, {0xc51c8000}, {0xc51ca000}, {0xc51cc000}, {0xc51ce000}, {0xc51d0000}, {0xc51d2000}, {0xc51d4000}, {0xc51d6000}, {0xc51d8000}, {0xc51da000}, {0xc51dc000}, {0xc51de000}, {0xc51e0000}, {0xc51e2000}, {0xc51e4000}, {0xc51e6000}, {0xc51e8000}, {0xc51ea000}, {0xc51ec000}, {0xc51ee000}, {0xc51f0000}, {0xc51f2000}, {0xc51f4000}, {0xc51f6000}, {0xc51f8000}, {0xc51fa000}, {0xc51fc000}, {0xc51fe000}, {0xc5200000}, {0xc5202000}, {0xc5204000}, {0xc5206000}, {0xc5208000}, {0xc520a000}, {0xc520c000}, {0xc520e000}, {0xc5210000}, {0xc5212000}, {0xc5214000}, {0xc5216000}, {0xc5218000}, {0xc521a000}, {0xc521c000}, {0xc521e000}, {0xc5220000}, {0xc5222000}, {0xc5224000}, {0xc5226000}, {0xc5228000}, {0xc522a000}, {0xc522c000}, {0xc522e000}, {0xc5230000}, {0xc5232000}, {0xc5234000}, {0xc5236000}, {0xc5238000}, {0xc523a000}, {0xc523c000}, {0xc523e000}, {0xc5240000}, {0xc5242000}, {0xc5244000}, {0xc5246000}, {0xc5248000}, {0xc524a000}, {0xc524c000}, {0xc524e000}, {0xc5250000}, {0xc5252000}, {0xc5254000}, {0xc5256000}, {0xc5258000}, {0xc525a000}, {0xc525c000}, {0xc525e000}, {0xc5260000}, {0xc5262000}, {0xc5264000}, {0xc5266000}, {0xc5268000}, {0xc526a000}, {0xc526c000}, {0xc526e000}, {0xc5270000}, {0xc5272000}, {0xc5274000}, {0xc5276000}, {0xc5278000}, {0xc527a000}, {0xc527c000}, {0xc527e000}, {0xc5280000}, {0xc5282000}, {0xc5284000}, {0xc5286000}, {0xc5288000}, {0xc528a000}, {0xc528c000}, {0xc528e000}, {0xc5290000}, {0xc5292000}, {0xc5294000}, {0xc5296000}, {0xc5298000}, {0xc529a000}, {0xc529c000}, {0xc529e000}, {0xc52a0000}, {0xc52a2000}, {0xc52a4000}, {0xc52a6000}, {0xc52a8000}, {0xc52aa000}, {0xc52ac000}, {0xc52ae000}, {0xc52b0000}, {0xc52b2000}, {0xc52b4000}, {0xc52b6000}, {0xc52b8000}, {0xc52ba000}, {0xc52bc000}, {0xc52be000}, {0xc52c0000}, {0xc52c2000}, {0xc52c4000}, {0xc52c6000}, {0xc52c8000}, {0xc52ca000}, {0xc52cc000}, {0xc52ce000}, {0xc52d0000}, {0xc52d2000}, {0xc52d4000}, {0xc52d6000}, {0xc52d8000}, {0xc52da000}, {0xc52dc000}, {0xc52de000}, {0xc52e0000}, {0xc52e2000}, {0xc52e4000}, {0xc52e6000}, {0xc52e8000}, {0xc52ea000}, {0xc52ec000}, {0xc52ee000}, {0xc52f0000}, {0xc52f2000}, {0xc52f4000}, {0xc52f6000}, {0xc52f8000}, {0xc52fa000}, {0xc52fc000}, {0xc52fe000}, {0xc5300000}, {0xc5302000}, {0xc5304000}, {0xc5306000}, {0xc5308000}, {0xc530a000}, {0xc530c000}, {0xc530e000}, {0xc5310000}, {0xc5312000}, {0xc5314000}, {0xc5316000}, {0xc5318000}, {0xc531a000}, {0xc531c000}, {0xc531e000}, {0xc5320000}, {0xc5322000}, {0xc5324000}, {0xc5326000}, {0xc5328000}, {0xc532a000}, {0xc532c000}, {0xc532e000}, {0xc5330000}, {0xc5332000}, {0xc5334000}, {0xc5336000}, {0xc5338000}, {0xc533a000}, {0xc533c000}, {0xc533e000}, {0xc5340000}, {0xc5342000}, {0xc5344000}, {0xc5346000}, {0xc5348000}, {0xc534a000}, {0xc534c000}, {0xc534e000}, {0xc5350000}, {0xc5352000}, {0xc5354000}, {0xc5356000}, {0xc5358000}, {0xc535a000}, {0xc535c000}, {0xc535e000}, {0xc5360000}, {0xc5362000}, {0xc5364000}, {0xc5366000}, {0xc5368000}, {0xc536a000}, {0xc536c000}, {0xc536e000}, {0xc5370000}, {0xc5372000}, {0xc5374000}, {0xc5376000}, {0xc5378000}, {0xc537a000}, {0xc537c000}, {0xc537e000}, {0xc5380000}, {0xc5382000}, {0xc5384000}, {0xc5386000}, {0xc5388000}, {0xc538a000}, {0xc538c000}, {0xc538e000}, {0xc5390000}, {0xc5392000}, {0xc5394000}, {0xc5396000}, {0xc5398000}, {0xc539a000}, {0xc539c000}, {0xc539e000}, {0xc53a0000}, {0xc53a2000}, {0xc53a4000}, {0xc53a6000}, {0xc53a8000}, {0xc53aa000}, {0xc53ac000}, {0xc53ae000}, {0xc53b0000}, {0xc53b2000}, {0xc53b4000}, {0xc53b6000}, {0xc53b8000}, {0xc53ba000}, {0xc53bc000}, {0xc53be000}, {0xc53c0000}, {0xc53c2000}, {0xc53c4000}, {0xc53c6000}, {0xc53c8000}, {0xc53ca000}, {0xc53cc000}, {0xc53ce000}, {0xc53d0000}, {0xc53d2000}, {0xc53d4000}, {0xc53d6000}, {0xc53d8000}, {0xc53da000}, {0xc53dc000}, {0xc53de000}, {0xc53e0000}, {0xc53e2000}, {0xc53e4000}, {0xc53e6000}, {0xc53e8000}, {0xc53ea000}, {0xc53ec000}, {0xc53ee000}, {0xc53f0000}, {0xc53f2000}, {0xc53f4000}, {0xc53f6000}, {0xc53f8000}, {0xc53fa000}, {0xc53fc000}, {0xc53fe000}, {0xc5400000}, {0xc5402000}, {0xc5404000}, {0xc5406000}, {0xc5408000}, {0xc540a000}, {0xc540c000}, {0xc540e000}, {0xc5410000}, {0xc5412000}, {0xc5414000}, {0xc5416000}, {0xc5418000}, {0xc541a000}, {0xc541c000}, {0xc541e000}, {0xc5420000}, {0xc5422000}, {0xc5424000}, {0xc5426000}, {0xc5428000}, {0xc542a000}, {0xc542c000}, {0xc542e000}, {0xc5430000}, {0xc5432000}, {0xc5434000}, {0xc5436000}, {0xc5438000}, {0xc543a000}, {0xc543c000}, {0xc543e000}, {0xc5440000}, {0xc5442000}, {0xc5444000}, {0xc5446000}, {0xc5448000}, {0xc544a000}, {0xc544c000}, {0xc544e000}, {0xc5450000}, {0xc5452000}, {0xc5454000}, {0xc5456000}, {0xc5458000}, {0xc545a000}, {0xc545c000}, {0xc545e000}, {0xc5460000}, {0xc5462000}, {0xc5464000}, {0xc5466000}, {0xc5468000}, {0xc546a000}, {0xc546c000}, {0xc546e000}, {0xc5470000}, {0xc5472000}, {0xc5474000}, {0xc5476000}, {0xc5478000}, {0xc547a000}, {0xc547c000}, {0xc547e000}, {0xc5480000}, {0xc5482000}, {0xc5484000}, {0xc5486000}, {0xc5488000}, {0xc548a000}, {0xc548c000}, {0xc548e000}, {0xc5490000}, {0xc5492000}, {0xc5494000}, {0xc5496000}, {0xc5498000}, {0xc549a000}, {0xc549c000}, {0xc549e000}, {0xc54a0000}, {0xc54a2000}, {0xc54a4000}, {0xc54a6000}, {0xc54a8000}, {0xc54aa000}, {0xc54ac000}, {0xc54ae000}, {0xc54b0000}, {0xc54b2000}, {0xc54b4000}, {0xc54b6000}, {0xc54b8000}, {0xc54ba000}, {0xc54bc000}, {0xc54be000}, {0xc54c0000}, {0xc54c2000}, {0xc54c4000}, {0xc54c6000}, {0xc54c8000}, {0xc54ca000}, {0xc54cc000}, {0xc54ce000}, {0xc54d0000}, {0xc54d2000}, {0xc54d4000}, {0xc54d6000}, {0xc54d8000}, {0xc54da000}, {0xc54dc000}, {0xc54de000}, {0xc54e0000}, {0xc54e2000}, {0xc54e4000}, {0xc54e6000}, {0xc54e8000}, {0xc54ea000}, {0xc54ec000}, {0xc54ee000}, {0xc54f0000}, {0xc54f2000}, {0xc54f4000}, {0xc54f6000}, {0xc54f8000}, {0xc54fa000}, {0xc54fc000}, {0xc54fe000}, {0xc5500000}, {0xc5502000}, {0xc5504000}, {0xc5506000}, {0xc5508000}, {0xc550a000}, {0xc550c000}, {0xc550e000}, {0xc5510000}, {0xc5512000}, {0xc5514000}, {0xc5516000}, {0xc5518000}, {0xc551a000}, {0xc551c000}, {0xc551e000}, {0xc5520000}, {0xc5522000}, {0xc5524000}, {0xc5526000}, {0xc5528000}, {0xc552a000}, {0xc552c000}, {0xc552e000}, {0xc5530000}, {0xc5532000}, {0xc5534000}, {0xc5536000}, {0xc5538000}, {0xc553a000}, {0xc553c000}, {0xc553e000}, {0xc5540000}, {0xc5542000}, {0xc5544000}, {0xc5546000}, {0xc5548000}, {0xc554a000}, {0xc554c000}, {0xc554e000}, {0xc5550000}, {0xc5552000}, {0xc5554000}, {0xc5556000}, {0xc5558000}, {0xc555a000}, {0xc555c000}, {0xc555e000}, {0xc5560000}, {0xc5562000}, {0xc5564000}, {0xc5566000}, {0xc5568000}, {0xc556a000}, {0xc556c000}, {0xc556e000}, {0xc5570000}, {0xc5572000}, {0xc5574000}, {0xc5576000}, {0xc5578000}, {0xc557a000}, {0xc557c000}, {0xc557e000}, {0xc5580000}, {0xc5582000}, {0xc5584000}, {0xc5586000}, {0xc5588000}, {0xc558a000}, {0xc558c000}, {0xc558e000}, {0xc5590000}, {0xc5592000}, {0xc5594000}, {0xc5596000}, {0xc5598000}, {0xc559a000}, {0xc559c000}, {0xc559e000}, {0xc55a0000}, {0xc55a2000}, {0xc55a4000}, {0xc55a6000}, {0xc55a8000}, {0xc55aa000}, {0xc55ac000}, {0xc55ae000}, {0xc55b0000}, {0xc55b2000}, {0xc55b4000}, {0xc55b6000}, {0xc55b8000}, {0xc55ba000}, {0xc55bc000}, {0xc55be000}, {0xc55c0000}, {0xc55c2000}, {0xc55c4000}, {0xc55c6000}, {0xc55c8000}, {0xc55ca000}, {0xc55cc000}, {0xc55ce000}, {0xc55d0000}, {0xc55d2000}, {0xc55d4000}, {0xc55d6000}, {0xc55d8000}, {0xc55da000}, {0xc55dc000}, {0xc55de000}, {0xc55e0000}, {0xc55e2000}, {0xc55e4000}, {0xc55e6000}, {0xc55e8000}, {0xc55ea000}, {0xc55ec000}, {0xc55ee000}, {0xc55f0000}, {0xc55f2000}, {0xc55f4000}, {0xc55f6000}, {0xc55f8000}, {0xc55fa000}, {0xc55fc000}, {0xc55fe000}, {0xc5600000}, {0xc5602000}, {0xc5604000}, {0xc5606000}, {0xc5608000}, {0xc560a000}, {0xc560c000}, {0xc560e000}, {0xc5610000}, {0xc5612000}, {0xc5614000}, {0xc5616000}, {0xc5618000}, {0xc561a000}, {0xc561c000}, {0xc561e000}, {0xc5620000}, {0xc5622000}, {0xc5624000}, {0xc5626000}, {0xc5628000}, {0xc562a000}, {0xc562c000}, {0xc562e000}, {0xc5630000}, {0xc5632000}, {0xc5634000}, {0xc5636000}, {0xc5638000}, {0xc563a000}, {0xc563c000}, {0xc563e000}, {0xc5640000}, {0xc5642000}, {0xc5644000}, {0xc5646000}, {0xc5648000}, {0xc564a000}, {0xc564c000}, {0xc564e000}, {0xc5650000}, {0xc5652000}, {0xc5654000}, {0xc5656000}, {0xc5658000}, {0xc565a000}, {0xc565c000}, {0xc565e000}, {0xc5660000}, {0xc5662000}, {0xc5664000}, {0xc5666000}, {0xc5668000}, {0xc566a000}, {0xc566c000}, {0xc566e000}, {0xc5670000}, {0xc5672000}, {0xc5674000}, {0xc5676000}, {0xc5678000}, {0xc567a000}, {0xc567c000}, {0xc567e000}, {0xc5680000}, {0xc5682000}, {0xc5684000}, {0xc5686000}, {0xc5688000}, {0xc568a000}, {0xc568c000}, {0xc568e000}, {0xc5690000}, {0xc5692000}, {0xc5694000}, {0xc5696000}, {0xc5698000}, {0xc569a000}, {0xc569c000}, {0xc569e000}, {0xc56a0000}, {0xc56a2000}, {0xc56a4000}, {0xc56a6000}, {0xc56a8000}, {0xc56aa000}, {0xc56ac000}, {0xc56ae000}, {0xc56b0000}, {0xc56b2000}, {0xc56b4000}, {0xc56b6000}, {0xc56b8000}, {0xc56ba000}, {0xc56bc000}, {0xc56be000}, {0xc56c0000}, {0xc56c2000}, {0xc56c4000}, {0xc56c6000}, {0xc56c8000}, {0xc56ca000}, {0xc56cc000}, {0xc56ce000}, {0xc56d0000}, {0xc56d2000}, {0xc56d4000}, {0xc56d6000}, {0xc56d8000}, {0xc56da000}, {0xc56dc000}, {0xc56de000}, {0xc56e0000}, {0xc56e2000}, {0xc56e4000}, {0xc56e6000}, {0xc56e8000}, {0xc56ea000}, {0xc56ec000}, {0xc56ee000}, {0xc56f0000}, {0xc56f2000}, {0xc56f4000}, {0xc56f6000}, {0xc56f8000}, {0xc56fa000}, {0xc56fc000}, {0xc56fe000}, {0xc5700000}, {0xc5702000}, {0xc5704000}, {0xc5706000}, {0xc5708000}, {0xc570a000}, {0xc570c000}, {0xc570e000}, {0xc5710000}, {0xc5712000}, {0xc5714000}, {0xc5716000}, {0xc5718000}, {0xc571a000}, {0xc571c000}, {0xc571e000}, {0xc5720000}, {0xc5722000}, {0xc5724000}, {0xc5726000}, {0xc5728000}, {0xc572a000}, {0xc572c000}, {0xc572e000}, {0xc5730000}, {0xc5732000}, {0xc5734000}, {0xc5736000}, {0xc5738000}, {0xc573a000}, {0xc573c000}, {0xc573e000}, {0xc5740000}, {0xc5742000}, {0xc5744000}, {0xc5746000}, {0xc5748000}, {0xc574a000}, {0xc574c000}, {0xc574e000}, {0xc5750000}, {0xc5752000}, {0xc5754000}, {0xc5756000}, {0xc5758000}, {0xc575a000}, {0xc575c000}, {0xc575e000}, {0xc5760000}, {0xc5762000}, {0xc5764000}, {0xc5766000}, {0xc5768000}, {0xc576a000}, {0xc576c000}, {0xc576e000}, {0xc5770000}, {0xc5772000}, {0xc5774000}, {0xc5776000}, {0xc5778000}, {0xc577a000}, {0xc577c000}, {0xc577e000}, {0xc5780000}, {0xc5782000}, {0xc5784000}, {0xc5786000}, {0xc5788000}, {0xc578a000}, {0xc578c000}, {0xc578e000}, {0xc5790000}, {0xc5792000}, {0xc5794000}, {0xc5796000}, {0xc5798000}, {0xc579a000}, {0xc579c000}, {0xc579e000}, {0xc57a0000}, {0xc57a2000}, {0xc57a4000}, {0xc57a6000}, {0xc57a8000}, {0xc57aa000}, {0xc57ac000}, {0xc57ae000}, {0xc57b0000}, {0xc57b2000}, {0xc57b4000}, {0xc57b6000}, {0xc57b8000}, {0xc57ba000}, {0xc57bc000}, {0xc57be000}, {0xc57c0000}, {0xc57c2000}, {0xc57c4000}, {0xc57c6000}, {0xc57c8000}, {0xc57ca000}, {0xc57cc000}, {0xc57ce000}, {0xc57d0000}, {0xc57d2000}, {0xc57d4000}, {0xc57d6000}, {0xc57d8000}, {0xc57da000}, {0xc57dc000}, {0xc57de000}, {0xc57e0000}, {0xc57e2000}, {0xc57e4000}, {0xc57e6000}, {0xc57e8000}, {0xc57ea000}, {0xc57ec000}, {0xc57ee000}, {0xc57f0000}, {0xc57f2000}, {0xc57f4000}, {0xc57f6000}, {0xc57f8000}, {0xc57fa000}, {0xc57fc000}, {0xc57fe000}, {0xc5800000}, {0xc5802000}, {0xc5804000}, {0xc5806000}, {0xc5808000}, {0xc580a000}, {0xc580c000}, {0xc580e000}, {0xc5810000}, {0xc5812000}, {0xc5814000}, {0xc5816000}, {0xc5818000}, {0xc581a000}, {0xc581c000}, {0xc581e000}, {0xc5820000}, {0xc5822000}, {0xc5824000}, {0xc5826000}, {0xc5828000}, {0xc582a000}, {0xc582c000}, {0xc582e000}, {0xc5830000}, {0xc5832000}, {0xc5834000}, {0xc5836000}, {0xc5838000}, {0xc583a000}, {0xc583c000}, {0xc583e000}, {0xc5840000}, {0xc5842000}, {0xc5844000}, {0xc5846000}, {0xc5848000}, {0xc584a000}, {0xc584c000}, {0xc584e000}, {0xc5850000}, {0xc5852000}, {0xc5854000}, {0xc5856000}, {0xc5858000}, {0xc585a000}, {0xc585c000}, {0xc585e000}, {0xc5860000}, {0xc5862000}, {0xc5864000}, {0xc5866000}, {0xc5868000}, {0xc586a000}, {0xc586c000}, {0xc586e000}, {0xc5870000}, {0xc5872000}, {0xc5874000}, {0xc5876000}, {0xc5878000}, {0xc587a000}, {0xc587c000}, {0xc587e000}, {0xc5880000}, {0xc5882000}, {0xc5884000}, {0xc5886000}, {0xc5888000}, {0xc588a000}, {0xc588c000}, {0xc588e000}, {0xc5890000}, {0xc5892000}, {0xc5894000}, {0xc5896000}, {0xc5898000}, {0xc589a000}, {0xc589c000}, {0xc589e000}, {0xc58a0000}, {0xc58a2000}, {0xc58a4000}, {0xc58a6000}, {0xc58a8000}, {0xc58aa000}, {0xc58ac000}, {0xc58ae000}, {0xc58b0000}, {0xc58b2000}, {0xc58b4000}, {0xc58b6000}, {0xc58b8000}, {0xc58ba000}, {0xc58bc000}, {0xc58be000}, {0xc58c0000}, {0xc58c2000}, {0xc58c4000}, {0xc58c6000}, {0xc58c8000}, {0xc58ca000}, {0xc58cc000}, {0xc58ce000}, {0xc58d0000}, {0xc58d2000}, {0xc58d4000}, {0xc58d6000}, {0xc58d8000}, {0xc58da000}, {0xc58dc000}, {0xc58de000}, {0xc58e0000}, {0xc58e2000}, {0xc58e4000}, {0xc58e6000}, {0xc58e8000}, {0xc58ea000}, {0xc58ec000}, {0xc58ee000}, {0xc58f0000}, {0xc58f2000}, {0xc58f4000}, {0xc58f6000}, {0xc58f8000}, {0xc58fa000}, {0xc58fc000}, {0xc58fe000}, {0xc5900000}, {0xc5902000}, {0xc5904000}, {0xc5906000}, {0xc5908000}, {0xc590a000}, {0xc590c000}, {0xc590e000}, {0xc5910000}, {0xc5912000}, {0xc5914000}, {0xc5916000}, {0xc5918000}, {0xc591a000}, {0xc591c000}, {0xc591e000}, {0xc5920000}, {0xc5922000}, {0xc5924000}, {0xc5926000}, {0xc5928000}, {0xc592a000}, {0xc592c000}, {0xc592e000}, {0xc5930000}, {0xc5932000}, {0xc5934000}, {0xc5936000}, {0xc5938000}, {0xc593a000}, {0xc593c000}, {0xc593e000}, {0xc5940000}, {0xc5942000}, {0xc5944000}, {0xc5946000}, {0xc5948000}, {0xc594a000}, {0xc594c000}, {0xc594e000}, {0xc5950000}, {0xc5952000}, {0xc5954000}, {0xc5956000}, {0xc5958000}, {0xc595a000}, {0xc595c000}, {0xc595e000}, {0xc5960000}, {0xc5962000}, {0xc5964000}, {0xc5966000}, {0xc5968000}, {0xc596a000}, {0xc596c000}, {0xc596e000}, {0xc5970000}, {0xc5972000}, {0xc5974000}, {0xc5976000}, {0xc5978000}, {0xc597a000}, {0xc597c000}, {0xc597e000}, {0xc5980000}, {0xc5982000}, {0xc5984000}, {0xc5986000}, {0xc5988000}, {0xc598a000}, {0xc598c000}, {0xc598e000}, {0xc5990000}, {0xc5992000}, {0xc5994000}, {0xc5996000}, {0xc5998000}, {0xc599a000}, {0xc599c000}, {0xc599e000}, {0xc59a0000}, {0xc59a2000}, {0xc59a4000}, {0xc59a6000}, {0xc59a8000}, {0xc59aa000}, {0xc59ac000}, {0xc59ae000}, {0xc59b0000}, {0xc59b2000}, {0xc59b4000}, {0xc59b6000}, {0xc59b8000}, {0xc59ba000}, {0xc59bc000}, {0xc59be000}, {0xc59c0000}, {0xc59c2000}, {0xc59c4000}, {0xc59c6000}, {0xc59c8000}, {0xc59ca000}, {0xc59cc000}, {0xc59ce000}, {0xc59d0000}, {0xc59d2000}, {0xc59d4000}, {0xc59d6000}, {0xc59d8000}, {0xc59da000}, {0xc59dc000}, {0xc59de000}, {0xc59e0000}, {0xc59e2000}, {0xc59e4000}, {0xc59e6000}, {0xc59e8000}, {0xc59ea000}, {0xc59ec000}, {0xc59ee000}, {0xc59f0000}, {0xc59f2000}, {0xc59f4000}, {0xc59f6000}, {0xc59f8000}, {0xc59fa000}, {0xc59fc000}, {0xc59fe000}, {0xc5a00000}, {0xc5a02000}, {0xc5a04000}, {0xc5a06000}, {0xc5a08000}, {0xc5a0a000}, {0xc5a0c000}, {0xc5a0e000}, {0xc5a10000}, {0xc5a12000}, {0xc5a14000}, {0xc5a16000}, {0xc5a18000}, {0xc5a1a000}, {0xc5a1c000}, {0xc5a1e000}, {0xc5a20000}, {0xc5a22000}, {0xc5a24000}, {0xc5a26000}, {0xc5a28000}, {0xc5a2a000}, {0xc5a2c000}, {0xc5a2e000}, {0xc5a30000}, {0xc5a32000}, {0xc5a34000}, {0xc5a36000}, {0xc5a38000}, {0xc5a3a000}, {0xc5a3c000}, {0xc5a3e000}, {0xc5a40000}, {0xc5a42000}, {0xc5a44000}, {0xc5a46000}, {0xc5a48000}, {0xc5a4a000}, {0xc5a4c000}, {0xc5a4e000}, {0xc5a50000}, {0xc5a52000}, {0xc5a54000}, {0xc5a56000}, {0xc5a58000}, {0xc5a5a000}, {0xc5a5c000}, {0xc5a5e000}, {0xc5a60000}, {0xc5a62000}, {0xc5a64000}, {0xc5a66000}, {0xc5a68000}, {0xc5a6a000}, {0xc5a6c000}, {0xc5a6e000}, {0xc5a70000}, {0xc5a72000}, {0xc5a74000}, {0xc5a76000}, {0xc5a78000}, {0xc5a7a000}, {0xc5a7c000}, {0xc5a7e000}, {0xc5a80000}, {0xc5a82000}, {0xc5a84000}, {0xc5a86000}, {0xc5a88000}, {0xc5a8a000}, {0xc5a8c000}, {0xc5a8e000}, {0xc5a90000}, {0xc5a92000}, {0xc5a94000}, {0xc5a96000}, {0xc5a98000}, {0xc5a9a000}, {0xc5a9c000}, {0xc5a9e000}, {0xc5aa0000}, {0xc5aa2000}, {0xc5aa4000}, {0xc5aa6000}, {0xc5aa8000}, {0xc5aaa000}, {0xc5aac000}, {0xc5aae000}, {0xc5ab0000}, {0xc5ab2000}, {0xc5ab4000}, {0xc5ab6000}, {0xc5ab8000}, {0xc5aba000}, {0xc5abc000}, {0xc5abe000}, {0xc5ac0000}, {0xc5ac2000}, {0xc5ac4000}, {0xc5ac6000}, {0xc5ac8000}, {0xc5aca000}, {0xc5acc000}, {0xc5ace000}, {0xc5ad0000}, {0xc5ad2000}, {0xc5ad4000}, {0xc5ad6000}, {0xc5ad8000}, {0xc5ada000}, {0xc5adc000}, {0xc5ade000}, {0xc5ae0000}, {0xc5ae2000}, {0xc5ae4000}, {0xc5ae6000}, {0xc5ae8000}, {0xc5aea000}, {0xc5aec000}, {0xc5aee000}, {0xc5af0000}, {0xc5af2000}, {0xc5af4000}, {0xc5af6000}, {0xc5af8000}, {0xc5afa000}, {0xc5afc000}, {0xc5afe000}, {0xc5b00000}, {0xc5b02000}, {0xc5b04000}, {0xc5b06000}, {0xc5b08000}, {0xc5b0a000}, {0xc5b0c000}, {0xc5b0e000}, {0xc5b10000}, {0xc5b12000}, {0xc5b14000}, {0xc5b16000}, {0xc5b18000}, {0xc5b1a000}, {0xc5b1c000}, {0xc5b1e000}, {0xc5b20000}, {0xc5b22000}, {0xc5b24000}, {0xc5b26000}, {0xc5b28000}, {0xc5b2a000}, {0xc5b2c000}, {0xc5b2e000}, {0xc5b30000}, {0xc5b32000}, {0xc5b34000}, {0xc5b36000}, {0xc5b38000}, {0xc5b3a000}, {0xc5b3c000}, {0xc5b3e000}, {0xc5b40000}, {0xc5b42000}, {0xc5b44000}, {0xc5b46000}, {0xc5b48000}, {0xc5b4a000}, {0xc5b4c000}, {0xc5b4e000}, {0xc5b50000}, {0xc5b52000}, {0xc5b54000}, {0xc5b56000}, {0xc5b58000}, {0xc5b5a000}, {0xc5b5c000}, {0xc5b5e000}, {0xc5b60000}, {0xc5b62000}, {0xc5b64000}, {0xc5b66000}, {0xc5b68000}, {0xc5b6a000}, {0xc5b6c000}, {0xc5b6e000}, {0xc5b70000}, {0xc5b72000}, {0xc5b74000}, {0xc5b76000}, {0xc5b78000}, {0xc5b7a000}, {0xc5b7c000}, {0xc5b7e000}, {0xc5b80000}, {0xc5b82000}, {0xc5b84000}, {0xc5b86000}, {0xc5b88000}, {0xc5b8a000}, {0xc5b8c000}, {0xc5b8e000}, {0xc5b90000}, {0xc5b92000}, {0xc5b94000}, {0xc5b96000}, {0xc5b98000}, {0xc5b9a000}, {0xc5b9c000}, {0xc5b9e000}, {0xc5ba0000}, {0xc5ba2000}, {0xc5ba4000}, {0xc5ba6000}, {0xc5ba8000}, {0xc5baa000}, {0xc5bac000}, {0xc5bae000}, {0xc5bb0000}, {0xc5bb2000}, {0xc5bb4000}, {0xc5bb6000}, {0xc5bb8000}, {0xc5bba000}, {0xc5bbc000}, {0xc5bbe000}, {0xc5bc0000}, {0xc5bc2000}, {0xc5bc4000}, {0xc5bc6000}, {0xc5bc8000}, {0xc5bca000}, {0xc5bcc000}, {0xc5bce000}, {0xc5bd0000}, {0xc5bd2000}, {0xc5bd4000}, {0xc5bd6000}, {0xc5bd8000}, {0xc5bda000}, {0xc5bdc000}, {0xc5bde000}, {0xc5be0000}, {0xc5be2000}, {0xc5be4000}, {0xc5be6000}, {0xc5be8000}, {0xc5bea000}, {0xc5bec000}, {0xc5bee000}, {0xc5bf0000}, {0xc5bf2000}, {0xc5bf4000}, {0xc5bf6000}, {0xc5bf8000}, {0xc5bfa000}, {0xc5bfc000}, {0xc5bfe000}, {0xc5c00000}, {0xc5c02000}, {0xc5c04000}, {0xc5c06000}, {0xc5c08000}, {0xc5c0a000}, {0xc5c0c000}, {0xc5c0e000}, {0xc5c10000}, {0xc5c12000}, {0xc5c14000}, {0xc5c16000}, {0xc5c18000}, {0xc5c1a000}, {0xc5c1c000}, {0xc5c1e000}, {0xc5c20000}, {0xc5c22000}, {0xc5c24000}, {0xc5c26000}, {0xc5c28000}, {0xc5c2a000}, {0xc5c2c000}, {0xc5c2e000}, {0xc5c30000}, {0xc5c32000}, {0xc5c34000}, {0xc5c36000}, {0xc5c38000}, {0xc5c3a000}, {0xc5c3c000}, {0xc5c3e000}, {0xc5c40000}, {0xc5c42000}, {0xc5c44000}, {0xc5c46000}, {0xc5c48000}, {0xc5c4a000}, {0xc5c4c000}, {0xc5c4e000}, {0xc5c50000}, {0xc5c52000}, {0xc5c54000}, {0xc5c56000}, {0xc5c58000}, {0xc5c5a000}, {0xc5c5c000}, {0xc5c5e000}, {0xc5c60000}, {0xc5c62000}, {0xc5c64000}, {0xc5c66000}, {0xc5c68000}, {0xc5c6a000}, {0xc5c6c000}, {0xc5c6e000}, {0xc5c70000}, {0xc5c72000}, {0xc5c74000}, {0xc5c76000}, {0xc5c78000}, {0xc5c7a000}, {0xc5c7c000}, {0xc5c7e000}, {0xc5c80000}, {0xc5c82000}, {0xc5c84000}, {0xc5c86000}, {0xc5c88000}, {0xc5c8a000}, {0xc5c8c000}, {0xc5c8e000}, {0xc5c90000}, {0xc5c92000}, {0xc5c94000}, {0xc5c96000}, {0xc5c98000}, {0xc5c9a000}, {0xc5c9c000}, {0xc5c9e000}, {0xc5ca0000}, {0xc5ca2000}, {0xc5ca4000}, {0xc5ca6000}, {0xc5ca8000}, {0xc5caa000}, {0xc5cac000}, {0xc5cae000}, {0xc5cb0000}, {0xc5cb2000}, {0xc5cb4000}, {0xc5cb6000}, {0xc5cb8000}, {0xc5cba000}, {0xc5cbc000}, {0xc5cbe000}, {0xc5cc0000}, {0xc5cc2000}, {0xc5cc4000}, {0xc5cc6000}, {0xc5cc8000}, {0xc5cca000}, {0xc5ccc000}, {0xc5cce000}, {0xc5cd0000}, {0xc5cd2000}, {0xc5cd4000}, {0xc5cd6000}, {0xc5cd8000}, {0xc5cda000}, {0xc5cdc000}, {0xc5cde000}, {0xc5ce0000}, {0xc5ce2000}, {0xc5ce4000}, {0xc5ce6000}, {0xc5ce8000}, {0xc5cea000}, {0xc5cec000}, {0xc5cee000}, {0xc5cf0000}, {0xc5cf2000}, {0xc5cf4000}, {0xc5cf6000}, {0xc5cf8000}, {0xc5cfa000}, {0xc5cfc000}, {0xc5cfe000}, {0xc5d00000}, {0xc5d02000}, {0xc5d04000}, {0xc5d06000}, {0xc5d08000}, {0xc5d0a000}, {0xc5d0c000}, {0xc5d0e000}, {0xc5d10000}, {0xc5d12000}, {0xc5d14000}, {0xc5d16000}, {0xc5d18000}, {0xc5d1a000}, {0xc5d1c000}, {0xc5d1e000}, {0xc5d20000}, {0xc5d22000}, {0xc5d24000}, {0xc5d26000}, {0xc5d28000}, {0xc5d2a000}, {0xc5d2c000}, {0xc5d2e000}, {0xc5d30000}, {0xc5d32000}, {0xc5d34000}, {0xc5d36000}, {0xc5d38000}, {0xc5d3a000}, {0xc5d3c000}, {0xc5d3e000}, {0xc5d40000}, {0xc5d42000}, {0xc5d44000}, {0xc5d46000}, {0xc5d48000}, {0xc5d4a000}, {0xc5d4c000}, {0xc5d4e000}, {0xc5d50000}, {0xc5d52000}, {0xc5d54000}, {0xc5d56000}, {0xc5d58000}, {0xc5d5a000}, {0xc5d5c000}, {0xc5d5e000}, {0xc5d60000}, {0xc5d62000}, {0xc5d64000}, {0xc5d66000}, {0xc5d68000}, {0xc5d6a000}, {0xc5d6c000}, {0xc5d6e000}, {0xc5d70000}, {0xc5d72000}, {0xc5d74000}, {0xc5d76000}, {0xc5d78000}, {0xc5d7a000}, {0xc5d7c000}, {0xc5d7e000}, {0xc5d80000}, {0xc5d82000}, {0xc5d84000}, {0xc5d86000}, {0xc5d88000}, {0xc5d8a000}, {0xc5d8c000}, {0xc5d8e000}, {0xc5d90000}, {0xc5d92000}, {0xc5d94000}, {0xc5d96000}, {0xc5d98000}, {0xc5d9a000}, {0xc5d9c000}, {0xc5d9e000}, {0xc5da0000}, {0xc5da2000}, {0xc5da4000}, {0xc5da6000}, {0xc5da8000}, {0xc5daa000}, {0xc5dac000}, {0xc5dae000}, {0xc5db0000}, {0xc5db2000}, {0xc5db4000}, {0xc5db6000}, {0xc5db8000}, {0xc5dba000}, {0xc5dbc000}, {0xc5dbe000}, {0xc5dc0000}, {0xc5dc2000}, {0xc5dc4000}, {0xc5dc6000}, {0xc5dc8000}, {0xc5dca000}, {0xc5dcc000}, {0xc5dce000}, {0xc5dd0000}, {0xc5dd2000}, {0xc5dd4000}, {0xc5dd6000}, {0xc5dd8000}, {0xc5dda000}, {0xc5ddc000}, {0xc5dde000}, {0xc5de0000}, {0xc5de2000}, {0xc5de4000}, {0xc5de6000}, {0xc5de8000}, {0xc5dea000}, {0xc5dec000}, {0xc5dee000}, {0xc5df0000}, {0xc5df2000}, {0xc5df4000}, {0xc5df6000}, {0xc5df8000}, {0xc5dfa000}, {0xc5dfc000}, {0xc5dfe000}, {0xc5e00000}, {0xc5e02000}, {0xc5e04000}, {0xc5e06000}, {0xc5e08000}, {0xc5e0a000}, {0xc5e0c000}, {0xc5e0e000}, {0xc5e10000}, {0xc5e12000}, {0xc5e14000}, {0xc5e16000}, {0xc5e18000}, {0xc5e1a000}, {0xc5e1c000}, {0xc5e1e000}, {0xc5e20000}, {0xc5e22000}, {0xc5e24000}, {0xc5e26000}, {0xc5e28000}, {0xc5e2a000}, {0xc5e2c000}, {0xc5e2e000}, {0xc5e30000}, {0xc5e32000}, {0xc5e34000}, {0xc5e36000}, {0xc5e38000}, {0xc5e3a000}, {0xc5e3c000}, {0xc5e3e000}, {0xc5e40000}, {0xc5e42000}, {0xc5e44000}, {0xc5e46000}, {0xc5e48000}, {0xc5e4a000}, {0xc5e4c000}, {0xc5e4e000}, {0xc5e50000}, {0xc5e52000}, {0xc5e54000}, {0xc5e56000}, {0xc5e58000}, {0xc5e5a000}, {0xc5e5c000}, {0xc5e5e000}, {0xc5e60000}, {0xc5e62000}, {0xc5e64000}, {0xc5e66000}, {0xc5e68000}, {0xc5e6a000}, {0xc5e6c000}, {0xc5e6e000}, {0xc5e70000}, {0xc5e72000}, {0xc5e74000}, {0xc5e76000}, {0xc5e78000}, {0xc5e7a000}, {0xc5e7c000}, {0xc5e7e000}, {0xc5e80000}, {0xc5e82000}, {0xc5e84000}, {0xc5e86000}, {0xc5e88000}, {0xc5e8a000}, {0xc5e8c000}, {0xc5e8e000}, {0xc5e90000}, {0xc5e92000}, {0xc5e94000}, {0xc5e96000}, {0xc5e98000}, {0xc5e9a000}, {0xc5e9c000}, {0xc5e9e000}, {0xc5ea0000}, {0xc5ea2000}, {0xc5ea4000}, {0xc5ea6000}, {0xc5ea8000}, {0xc5eaa000}, {0xc5eac000}, {0xc5eae000}, {0xc5eb0000}, {0xc5eb2000}, {0xc5eb4000}, {0xc5eb6000}, {0xc5eb8000}, {0xc5eba000}, {0xc5ebc000}, {0xc5ebe000}, {0xc5ec0000}, {0xc5ec2000}, {0xc5ec4000}, {0xc5ec6000}, {0xc5ec8000}, {0xc5eca000}, {0xc5ecc000}, {0xc5ece000}, {0xc5ed0000}, {0xc5ed2000}, {0xc5ed4000}, {0xc5ed6000}, {0xc5ed8000}, {0xc5eda000}, {0xc5edc000}, {0xc5ede000}, {0xc5ee0000}, {0xc5ee2000}, {0xc5ee4000}, {0xc5ee6000}, {0xc5ee8000}, {0xc5eea000}, {0xc5eec000}, {0xc5eee000}, {0xc5ef0000}, {0xc5ef2000}, {0xc5ef4000}, {0xc5ef6000}, {0xc5ef8000}, {0xc5efa000}, {0xc5efc000}, {0xc5efe000}, {0xc5f00000}, {0xc5f02000}, {0xc5f04000}, {0xc5f06000}, {0xc5f08000}, {0xc5f0a000}, {0xc5f0c000}, {0xc5f0e000}, {0xc5f10000}, {0xc5f12000}, {0xc5f14000}, {0xc5f16000}, {0xc5f18000}, {0xc5f1a000}, {0xc5f1c000}, {0xc5f1e000}, {0xc5f20000}, {0xc5f22000}, {0xc5f24000}, {0xc5f26000}, {0xc5f28000}, {0xc5f2a000}, {0xc5f2c000}, {0xc5f2e000}, {0xc5f30000}, {0xc5f32000}, {0xc5f34000}, {0xc5f36000}, {0xc5f38000}, {0xc5f3a000}, {0xc5f3c000}, {0xc5f3e000}, {0xc5f40000}, {0xc5f42000}, {0xc5f44000}, {0xc5f46000}, {0xc5f48000}, {0xc5f4a000}, {0xc5f4c000}, {0xc5f4e000}, {0xc5f50000}, {0xc5f52000}, {0xc5f54000}, {0xc5f56000}, {0xc5f58000}, {0xc5f5a000}, {0xc5f5c000}, {0xc5f5e000}, {0xc5f60000}, {0xc5f62000}, {0xc5f64000}, {0xc5f66000}, {0xc5f68000}, {0xc5f6a000}, {0xc5f6c000}, {0xc5f6e000}, {0xc5f70000}, {0xc5f72000}, {0xc5f74000}, {0xc5f76000}, {0xc5f78000}, {0xc5f7a000}, {0xc5f7c000}, {0xc5f7e000}, {0xc5f80000}, {0xc5f82000}, {0xc5f84000}, {0xc5f86000}, {0xc5f88000}, {0xc5f8a000}, {0xc5f8c000}, {0xc5f8e000}, {0xc5f90000}, {0xc5f92000}, {0xc5f94000}, {0xc5f96000}, {0xc5f98000}, {0xc5f9a000}, {0xc5f9c000}, {0xc5f9e000}, {0xc5fa0000}, {0xc5fa2000}, {0xc5fa4000}, {0xc5fa6000}, {0xc5fa8000}, {0xc5faa000}, {0xc5fac000}, {0xc5fae000}, {0xc5fb0000}, {0xc5fb2000}, {0xc5fb4000}, {0xc5fb6000}, {0xc5fb8000}, {0xc5fba000}, {0xc5fbc000}, {0xc5fbe000}, {0xc5fc0000}, {0xc5fc2000}, {0xc5fc4000}, {0xc5fc6000}, {0xc5fc8000}, {0xc5fca000}, {0xc5fcc000}, {0xc5fce000}, {0xc5fd0000}, {0xc5fd2000}, {0xc5fd4000}, {0xc5fd6000}, {0xc5fd8000}, {0xc5fda000}, {0xc5fdc000}, {0xc5fde000}, {0xc5fe0000}, {0xc5fe2000}, {0xc5fe4000}, {0xc5fe6000}, {0xc5fe8000}, {0xc5fea000}, {0xc5fec000}, {0xc5fee000}, {0xc5ff0000}, {0xc5ff2000}, {0xc5ff4000}, {0xc5ff6000}, {0xc5ff8000}, {0xc5ffa000}, {0xc5ffc000}, {0xc5ffe000}, {0xc6000000}, {0xc6002000}, {0xc6004000}, {0xc6006000}, {0xc6008000}, {0xc600a000}, {0xc600c000}, {0xc600e000}, {0xc6010000}, {0xc6012000}, {0xc6014000}, {0xc6016000}, {0xc6018000}, {0xc601a000}, {0xc601c000}, {0xc601e000}, {0xc6020000}, {0xc6022000}, {0xc6024000}, {0xc6026000}, {0xc6028000}, {0xc602a000}, {0xc602c000}, {0xc602e000}, {0xc6030000}, {0xc6032000}, {0xc6034000}, {0xc6036000}, {0xc6038000}, {0xc603a000}, {0xc603c000}, {0xc603e000}, {0xc6040000}, {0xc6042000}, {0xc6044000}, {0xc6046000}, {0xc6048000}, {0xc604a000}, {0xc604c000}, {0xc604e000}, {0xc6050000}, {0xc6052000}, {0xc6054000}, {0xc6056000}, {0xc6058000}, {0xc605a000}, {0xc605c000}, {0xc605e000}, {0xc6060000}, {0xc6062000}, {0xc6064000}, {0xc6066000}, {0xc6068000}, {0xc606a000}, {0xc606c000}, {0xc606e000}, {0xc6070000}, {0xc6072000}, {0xc6074000}, {0xc6076000}, {0xc6078000}, {0xc607a000}, {0xc607c000}, {0xc607e000}, {0xc6080000}, {0xc6082000}, {0xc6084000}, {0xc6086000}, {0xc6088000}, {0xc608a000}, {0xc608c000}, {0xc608e000}, {0xc6090000}, {0xc6092000}, {0xc6094000}, {0xc6096000}, {0xc6098000}, {0xc609a000}, {0xc609c000}, {0xc609e000}, {0xc60a0000}, {0xc60a2000}, {0xc60a4000}, {0xc60a6000}, {0xc60a8000}, {0xc60aa000}, {0xc60ac000}, {0xc60ae000}, {0xc60b0000}, {0xc60b2000}, {0xc60b4000}, {0xc60b6000}, {0xc60b8000}, {0xc60ba000}, {0xc60bc000}, {0xc60be000}, {0xc60c0000}, {0xc60c2000}, {0xc60c4000}, {0xc60c6000}, {0xc60c8000}, {0xc60ca000}, {0xc60cc000}, {0xc60ce000}, {0xc60d0000}, {0xc60d2000}, {0xc60d4000}, {0xc60d6000}, {0xc60d8000}, {0xc60da000}, {0xc60dc000}, {0xc60de000}, {0xc60e0000}, {0xc60e2000}, {0xc60e4000}, {0xc60e6000}, {0xc60e8000}, {0xc60ea000}, {0xc60ec000}, {0xc60ee000}, {0xc60f0000}, {0xc60f2000}, {0xc60f4000}, {0xc60f6000}, {0xc60f8000}, {0xc60fa000}, {0xc60fc000}, {0xc60fe000}, {0xc6100000}, {0xc6102000}, {0xc6104000}, {0xc6106000}, {0xc6108000}, {0xc610a000}, {0xc610c000}, {0xc610e000}, {0xc6110000}, {0xc6112000}, {0xc6114000}, {0xc6116000}, {0xc6118000}, {0xc611a000}, {0xc611c000}, {0xc611e000}, {0xc6120000}, {0xc6122000}, {0xc6124000}, {0xc6126000}, {0xc6128000}, {0xc612a000}, {0xc612c000}, {0xc612e000}, {0xc6130000}, {0xc6132000}, {0xc6134000}, {0xc6136000}, {0xc6138000}, {0xc613a000}, {0xc613c000}, {0xc613e000}, {0xc6140000}, {0xc6142000}, {0xc6144000}, {0xc6146000}, {0xc6148000}, {0xc614a000}, {0xc614c000}, {0xc614e000}, {0xc6150000}, {0xc6152000}, {0xc6154000}, {0xc6156000}, {0xc6158000}, {0xc615a000}, {0xc615c000}, {0xc615e000}, {0xc6160000}, {0xc6162000}, {0xc6164000}, {0xc6166000}, {0xc6168000}, {0xc616a000}, {0xc616c000}, {0xc616e000}, {0xc6170000}, {0xc6172000}, {0xc6174000}, {0xc6176000}, {0xc6178000}, {0xc617a000}, {0xc617c000}, {0xc617e000}, {0xc6180000}, {0xc6182000}, {0xc6184000}, {0xc6186000}, {0xc6188000}, {0xc618a000}, {0xc618c000}, {0xc618e000}, {0xc6190000}, {0xc6192000}, {0xc6194000}, {0xc6196000}, {0xc6198000}, {0xc619a000}, {0xc619c000}, {0xc619e000}, {0xc61a0000}, {0xc61a2000}, {0xc61a4000}, {0xc61a6000}, {0xc61a8000}, {0xc61aa000}, {0xc61ac000}, {0xc61ae000}, {0xc61b0000}, {0xc61b2000}, {0xc61b4000}, {0xc61b6000}, {0xc61b8000}, {0xc61ba000}, {0xc61bc000}, {0xc61be000}, {0xc61c0000}, {0xc61c2000}, {0xc61c4000}, {0xc61c6000}, {0xc61c8000}, {0xc61ca000}, {0xc61cc000}, {0xc61ce000}, {0xc61d0000}, {0xc61d2000}, {0xc61d4000}, {0xc61d6000}, {0xc61d8000}, {0xc61da000}, {0xc61dc000}, {0xc61de000}, {0xc61e0000}, {0xc61e2000}, {0xc61e4000}, {0xc61e6000}, {0xc61e8000}, {0xc61ea000}, {0xc61ec000}, {0xc61ee000}, {0xc61f0000}, {0xc61f2000}, {0xc61f4000}, {0xc61f6000}, {0xc61f8000}, {0xc61fa000}, {0xc61fc000}, {0xc61fe000}, {0xc6200000}, {0xc6202000}, {0xc6204000}, {0xc6206000}, {0xc6208000}, {0xc620a000}, {0xc620c000}, {0xc620e000}, {0xc6210000}, {0xc6212000}, {0xc6214000}, {0xc6216000}, {0xc6218000}, {0xc621a000}, {0xc621c000}, {0xc621e000}, {0xc6220000}, {0xc6222000}, {0xc6224000}, {0xc6226000}, {0xc6228000}, {0xc622a000}, {0xc622c000}, {0xc622e000}, {0xc6230000}, {0xc6232000}, {0xc6234000}, {0xc6236000}, {0xc6238000}, {0xc623a000}, {0xc623c000}, {0xc623e000}, {0xc6240000}, {0xc6242000}, {0xc6244000}, {0xc6246000}, {0xc6248000}, {0xc624a000}, {0xc624c000}, {0xc624e000}, {0xc6250000}, {0xc6252000}, {0xc6254000}, {0xc6256000}, {0xc6258000}, {0xc625a000}, {0xc625c000}, {0xc625e000}, {0xc6260000}, {0xc6262000}, {0xc6264000}, {0xc6266000}, {0xc6268000}, {0xc626a000}, {0xc626c000}, {0xc626e000}, {0xc6270000}, {0xc6272000}, {0xc6274000}, {0xc6276000}, {0xc6278000}, {0xc627a000}, {0xc627c000}, {0xc627e000}, {0xc6280000}, {0xc6282000}, {0xc6284000}, {0xc6286000}, {0xc6288000}, {0xc628a000}, {0xc628c000}, {0xc628e000}, {0xc6290000}, {0xc6292000}, {0xc6294000}, {0xc6296000}, {0xc6298000}, {0xc629a000}, {0xc629c000}, {0xc629e000}, {0xc62a0000}, {0xc62a2000}, {0xc62a4000}, {0xc62a6000}, {0xc62a8000}, {0xc62aa000}, {0xc62ac000}, {0xc62ae000}, {0xc62b0000}, {0xc62b2000}, {0xc62b4000}, {0xc62b6000}, {0xc62b8000}, {0xc62ba000}, {0xc62bc000}, {0xc62be000}, {0xc62c0000}, {0xc62c2000}, {0xc62c4000}, {0xc62c6000}, {0xc62c8000}, {0xc62ca000}, {0xc62cc000}, {0xc62ce000}, {0xc62d0000}, {0xc62d2000}, {0xc62d4000}, {0xc62d6000}, {0xc62d8000}, {0xc62da000}, {0xc62dc000}, {0xc62de000}, {0xc62e0000}, {0xc62e2000}, {0xc62e4000}, {0xc62e6000}, {0xc62e8000}, {0xc62ea000}, {0xc62ec000}, {0xc62ee000}, {0xc62f0000}, {0xc62f2000}, {0xc62f4000}, {0xc62f6000}, {0xc62f8000}, {0xc62fa000}, {0xc62fc000}, {0xc62fe000}, {0xc6300000}, {0xc6302000}, {0xc6304000}, {0xc6306000}, {0xc6308000}, {0xc630a000}, {0xc630c000}, {0xc630e000}, {0xc6310000}, {0xc6312000}, {0xc6314000}, {0xc6316000}, {0xc6318000}, {0xc631a000}, {0xc631c000}, {0xc631e000}, {0xc6320000}, {0xc6322000}, {0xc6324000}, {0xc6326000}, {0xc6328000}, {0xc632a000}, {0xc632c000}, {0xc632e000}, {0xc6330000}, {0xc6332000}, {0xc6334000}, {0xc6336000}, {0xc6338000}, {0xc633a000}, {0xc633c000}, {0xc633e000}, {0xc6340000}, {0xc6342000}, {0xc6344000}, {0xc6346000}, {0xc6348000}, {0xc634a000}, {0xc634c000}, {0xc634e000}, {0xc6350000}, {0xc6352000}, {0xc6354000}, {0xc6356000}, {0xc6358000}, {0xc635a000}, {0xc635c000}, {0xc635e000}, {0xc6360000}, {0xc6362000}, {0xc6364000}, {0xc6366000}, {0xc6368000}, {0xc636a000}, {0xc636c000}, {0xc636e000}, {0xc6370000}, {0xc6372000}, {0xc6374000}, {0xc6376000}, {0xc6378000}, {0xc637a000}, {0xc637c000}, {0xc637e000}, {0xc6380000}, {0xc6382000}, {0xc6384000}, {0xc6386000}, {0xc6388000}, {0xc638a000}, {0xc638c000}, {0xc638e000}, {0xc6390000}, {0xc6392000}, {0xc6394000}, {0xc6396000}, {0xc6398000}, {0xc639a000}, {0xc639c000}, {0xc639e000}, {0xc63a0000}, {0xc63a2000}, {0xc63a4000}, {0xc63a6000}, {0xc63a8000}, {0xc63aa000}, {0xc63ac000}, {0xc63ae000}, {0xc63b0000}, {0xc63b2000}, {0xc63b4000}, {0xc63b6000}, {0xc63b8000}, {0xc63ba000}, {0xc63bc000}, {0xc63be000}, {0xc63c0000}, {0xc63c2000}, {0xc63c4000}, {0xc63c6000}, {0xc63c8000}, {0xc63ca000}, {0xc63cc000}, {0xc63ce000}, {0xc63d0000}, {0xc63d2000}, {0xc63d4000}, {0xc63d6000}, {0xc63d8000}, {0xc63da000}, {0xc63dc000}, {0xc63de000}, {0xc63e0000}, {0xc63e2000}, {0xc63e4000}, {0xc63e6000}, {0xc63e8000}, {0xc63ea000}, {0xc63ec000}, {0xc63ee000}, {0xc63f0000}, {0xc63f2000}, {0xc63f4000}, {0xc63f6000}, {0xc63f8000}, {0xc63fa000}, {0xc63fc000}, {0xc63fe000}, {0xc6400000}, {0xc6402000}, {0xc6404000}, {0xc6406000}, {0xc6408000}, {0xc640a000}, {0xc640c000}, {0xc640e000}, {0xc6410000}, {0xc6412000}, {0xc6414000}, {0xc6416000}, {0xc6418000}, {0xc641a000}, {0xc641c000}, {0xc641e000}, {0xc6420000}, {0xc6422000}, {0xc6424000}, {0xc6426000}, {0xc6428000}, {0xc642a000}, {0xc642c000}, {0xc642e000}, {0xc6430000}, {0xc6432000}, {0xc6434000}, {0xc6436000}, {0xc6438000}, {0xc643a000}, {0xc643c000}, {0xc643e000}, {0xc6440000}, {0xc6442000}, {0xc6444000}, {0xc6446000}, {0xc6448000}, {0xc644a000}, {0xc644c000}, {0xc644e000}, {0xc6450000}, {0xc6452000}, {0xc6454000}, {0xc6456000}, {0xc6458000}, {0xc645a000}, {0xc645c000}, {0xc645e000}, {0xc6460000}, {0xc6462000}, {0xc6464000}, {0xc6466000}, {0xc6468000}, {0xc646a000}, {0xc646c000}, {0xc646e000}, {0xc6470000}, {0xc6472000}, {0xc6474000}, {0xc6476000}, {0xc6478000}, {0xc647a000}, {0xc647c000}, {0xc647e000}, {0xc6480000}, {0xc6482000}, {0xc6484000}, {0xc6486000}, {0xc6488000}, {0xc648a000}, {0xc648c000}, {0xc648e000}, {0xc6490000}, {0xc6492000}, {0xc6494000}, {0xc6496000}, {0xc6498000}, {0xc649a000}, {0xc649c000}, {0xc649e000}, {0xc64a0000}, {0xc64a2000}, {0xc64a4000}, {0xc64a6000}, {0xc64a8000}, {0xc64aa000}, {0xc64ac000}, {0xc64ae000}, {0xc64b0000}, {0xc64b2000}, {0xc64b4000}, {0xc64b6000}, {0xc64b8000}, {0xc64ba000}, {0xc64bc000}, {0xc64be000}, {0xc64c0000}, {0xc64c2000}, {0xc64c4000}, {0xc64c6000}, {0xc64c8000}, {0xc64ca000}, {0xc64cc000}, {0xc64ce000}, {0xc64d0000}, {0xc64d2000}, {0xc64d4000}, {0xc64d6000}, {0xc64d8000}, {0xc64da000}, {0xc64dc000}, {0xc64de000}, {0xc64e0000}, {0xc64e2000}, {0xc64e4000}, {0xc64e6000}, {0xc64e8000}, {0xc64ea000}, {0xc64ec000}, {0xc64ee000}, {0xc64f0000}, {0xc64f2000}, {0xc64f4000}, {0xc64f6000}, {0xc64f8000}, {0xc64fa000}, {0xc64fc000}, {0xc64fe000}, {0xc6500000}, {0xc6502000}, {0xc6504000}, {0xc6506000}, {0xc6508000}, {0xc650a000}, {0xc650c000}, {0xc650e000}, {0xc6510000}, {0xc6512000}, {0xc6514000}, {0xc6516000}, {0xc6518000}, {0xc651a000}, {0xc651c000}, {0xc651e000}, {0xc6520000}, {0xc6522000}, {0xc6524000}, {0xc6526000}, {0xc6528000}, {0xc652a000}, {0xc652c000}, {0xc652e000}, {0xc6530000}, {0xc6532000}, {0xc6534000}, {0xc6536000}, {0xc6538000}, {0xc653a000}, {0xc653c000}, {0xc653e000}, {0xc6540000}, {0xc6542000}, {0xc6544000}, {0xc6546000}, {0xc6548000}, {0xc654a000}, {0xc654c000}, {0xc654e000}, {0xc6550000}, {0xc6552000}, {0xc6554000}, {0xc6556000}, {0xc6558000}, {0xc655a000}, {0xc655c000}, {0xc655e000}, {0xc6560000}, {0xc6562000}, {0xc6564000}, {0xc6566000}, {0xc6568000}, {0xc656a000}, {0xc656c000}, {0xc656e000}, {0xc6570000}, {0xc6572000}, {0xc6574000}, {0xc6576000}, {0xc6578000}, {0xc657a000}, {0xc657c000}, {0xc657e000}, {0xc6580000}, {0xc6582000}, {0xc6584000}, {0xc6586000}, {0xc6588000}, {0xc658a000}, {0xc658c000}, {0xc658e000}, {0xc6590000}, {0xc6592000}, {0xc6594000}, {0xc6596000}, {0xc6598000}, {0xc659a000}, {0xc659c000}, {0xc659e000}, {0xc65a0000}, {0xc65a2000}, {0xc65a4000}, {0xc65a6000}, {0xc65a8000}, {0xc65aa000}, {0xc65ac000}, {0xc65ae000}, {0xc65b0000}, {0xc65b2000}, {0xc65b4000}, {0xc65b6000}, {0xc65b8000}, {0xc65ba000}, {0xc65bc000}, {0xc65be000}, {0xc65c0000}, {0xc65c2000}, {0xc65c4000}, {0xc65c6000}, {0xc65c8000}, {0xc65ca000}, {0xc65cc000}, {0xc65ce000}, {0xc65d0000}, {0xc65d2000}, {0xc65d4000}, {0xc65d6000}, {0xc65d8000}, {0xc65da000}, {0xc65dc000}, {0xc65de000}, {0xc65e0000}, {0xc65e2000}, {0xc65e4000}, {0xc65e6000}, {0xc65e8000}, {0xc65ea000}, {0xc65ec000}, {0xc65ee000}, {0xc65f0000}, {0xc65f2000}, {0xc65f4000}, {0xc65f6000}, {0xc65f8000}, {0xc65fa000}, {0xc65fc000}, {0xc65fe000}, {0xc6600000}, {0xc6602000}, {0xc6604000}, {0xc6606000}, {0xc6608000}, {0xc660a000}, {0xc660c000}, {0xc660e000}, {0xc6610000}, {0xc6612000}, {0xc6614000}, {0xc6616000}, {0xc6618000}, {0xc661a000}, {0xc661c000}, {0xc661e000}, {0xc6620000}, {0xc6622000}, {0xc6624000}, {0xc6626000}, {0xc6628000}, {0xc662a000}, {0xc662c000}, {0xc662e000}, {0xc6630000}, {0xc6632000}, {0xc6634000}, {0xc6636000}, {0xc6638000}, {0xc663a000}, {0xc663c000}, {0xc663e000}, {0xc6640000}, {0xc6642000}, {0xc6644000}, {0xc6646000}, {0xc6648000}, {0xc664a000}, {0xc664c000}, {0xc664e000}, {0xc6650000}, {0xc6652000}, {0xc6654000}, {0xc6656000}, {0xc6658000}, {0xc665a000}, {0xc665c000}, {0xc665e000}, {0xc6660000}, {0xc6662000}, {0xc6664000}, {0xc6666000}, {0xc6668000}, {0xc666a000}, {0xc666c000}, {0xc666e000}, {0xc6670000}, {0xc6672000}, {0xc6674000}, {0xc6676000}, {0xc6678000}, {0xc667a000}, {0xc667c000}, {0xc667e000}, {0xc6680000}, {0xc6682000}, {0xc6684000}, {0xc6686000}, {0xc6688000}, {0xc668a000}, {0xc668c000}, {0xc668e000}, {0xc6690000}, {0xc6692000}, {0xc6694000}, {0xc6696000}, {0xc6698000}, {0xc669a000}, {0xc669c000}, {0xc669e000}, {0xc66a0000}, {0xc66a2000}, {0xc66a4000}, {0xc66a6000}, {0xc66a8000}, {0xc66aa000}, {0xc66ac000}, {0xc66ae000}, {0xc66b0000}, {0xc66b2000}, {0xc66b4000}, {0xc66b6000}, {0xc66b8000}, {0xc66ba000}, {0xc66bc000}, {0xc66be000}, {0xc66c0000}, {0xc66c2000}, {0xc66c4000}, {0xc66c6000}, {0xc66c8000}, {0xc66ca000}, {0xc66cc000}, {0xc66ce000}, {0xc66d0000}, {0xc66d2000}, {0xc66d4000}, {0xc66d6000}, {0xc66d8000}, {0xc66da000}, {0xc66dc000}, {0xc66de000}, {0xc66e0000}, {0xc66e2000}, {0xc66e4000}, {0xc66e6000}, {0xc66e8000}, {0xc66ea000}, {0xc66ec000}, {0xc66ee000}, {0xc66f0000}, {0xc66f2000}, {0xc66f4000}, {0xc66f6000}, {0xc66f8000}, {0xc66fa000}, {0xc66fc000}, {0xc66fe000}, {0xc6700000}, {0xc6702000}, {0xc6704000}, {0xc6706000}, {0xc6708000}, {0xc670a000}, {0xc670c000}, {0xc670e000}, {0xc6710000}, {0xc6712000}, {0xc6714000}, {0xc6716000}, {0xc6718000}, {0xc671a000}, {0xc671c000}, {0xc671e000}, {0xc6720000}, {0xc6722000}, {0xc6724000}, {0xc6726000}, {0xc6728000}, {0xc672a000}, {0xc672c000}, {0xc672e000}, {0xc6730000}, {0xc6732000}, {0xc6734000}, {0xc6736000}, {0xc6738000}, {0xc673a000}, {0xc673c000}, {0xc673e000}, {0xc6740000}, {0xc6742000}, {0xc6744000}, {0xc6746000}, {0xc6748000}, {0xc674a000}, {0xc674c000}, {0xc674e000}, {0xc6750000}, {0xc6752000}, {0xc6754000}, {0xc6756000}, {0xc6758000}, {0xc675a000}, {0xc675c000}, {0xc675e000}, {0xc6760000}, {0xc6762000}, {0xc6764000}, {0xc6766000}, {0xc6768000}, {0xc676a000}, {0xc676c000}, {0xc676e000}, {0xc6770000}, {0xc6772000}, {0xc6774000}, {0xc6776000}, {0xc6778000}, {0xc677a000}, {0xc677c000}, {0xc677e000}, {0xc6780000}, {0xc6782000}, {0xc6784000}, {0xc6786000}, {0xc6788000}, {0xc678a000}, {0xc678c000}, {0xc678e000}, {0xc6790000}, {0xc6792000}, {0xc6794000}, {0xc6796000}, {0xc6798000}, {0xc679a000}, {0xc679c000}, {0xc679e000}, {0xc67a0000}, {0xc67a2000}, {0xc67a4000}, {0xc67a6000}, {0xc67a8000}, {0xc67aa000}, {0xc67ac000}, {0xc67ae000}, {0xc67b0000}, {0xc67b2000}, {0xc67b4000}, {0xc67b6000}, {0xc67b8000}, {0xc67ba000}, {0xc67bc000}, {0xc67be000}, {0xc67c0000}, {0xc67c2000}, {0xc67c4000}, {0xc67c6000}, {0xc67c8000}, {0xc67ca000}, {0xc67cc000}, {0xc67ce000}, {0xc67d0000}, {0xc67d2000}, {0xc67d4000}, {0xc67d6000}, {0xc67d8000}, {0xc67da000}, {0xc67dc000}, {0xc67de000}, {0xc67e0000}, {0xc67e2000}, {0xc67e4000}, {0xc67e6000}, {0xc67e8000}, {0xc67ea000}, {0xc67ec000}, {0xc67ee000}, {0xc67f0000}, {0xc67f2000}, {0xc67f4000}, {0xc67f6000}, {0xc67f8000}, {0xc67fa000}, {0xc67fc000}, {0xc67fe000}, {0xc6800000}, {0xc6802000}, {0xc6804000}, {0xc6806000}, {0xc6808000}, {0xc680a000}, {0xc680c000}, {0xc680e000}, {0xc6810000}, {0xc6812000}, {0xc6814000}, {0xc6816000}, {0xc6818000}, {0xc681a000}, {0xc681c000}, {0xc681e000}, {0xc6820000}, {0xc6822000}, {0xc6824000}, {0xc6826000}, {0xc6828000}, {0xc682a000}, {0xc682c000}, {0xc682e000}, {0xc6830000}, {0xc6832000}, {0xc6834000}, {0xc6836000}, {0xc6838000}, {0xc683a000}, {0xc683c000}, {0xc683e000}, {0xc6840000}, {0xc6842000}, {0xc6844000}, {0xc6846000}, {0xc6848000}, {0xc684a000}, {0xc684c000}, {0xc684e000}, {0xc6850000}, {0xc6852000}, {0xc6854000}, {0xc6856000}, {0xc6858000}, {0xc685a000}, {0xc685c000}, {0xc685e000}, {0xc6860000}, {0xc6862000}, {0xc6864000}, {0xc6866000}, {0xc6868000}, {0xc686a000}, {0xc686c000}, {0xc686e000}, {0xc6870000}, {0xc6872000}, {0xc6874000}, {0xc6876000}, {0xc6878000}, {0xc687a000}, {0xc687c000}, {0xc687e000}, {0xc6880000}, {0xc6882000}, {0xc6884000}, {0xc6886000}, {0xc6888000}, {0xc688a000}, {0xc688c000}, {0xc688e000}, {0xc6890000}, {0xc6892000}, {0xc6894000}, {0xc6896000}, {0xc6898000}, {0xc689a000}, {0xc689c000}, {0xc689e000}, {0xc68a0000}, {0xc68a2000}, {0xc68a4000}, {0xc68a6000}, {0xc68a8000}, {0xc68aa000}, {0xc68ac000}, {0xc68ae000}, {0xc68b0000}, {0xc68b2000}, {0xc68b4000}, {0xc68b6000}, {0xc68b8000}, {0xc68ba000}, {0xc68bc000}, {0xc68be000}, {0xc68c0000}, {0xc68c2000}, {0xc68c4000}, {0xc68c6000}, {0xc68c8000}, {0xc68ca000}, {0xc68cc000}, {0xc68ce000}, {0xc68d0000}, {0xc68d2000}, {0xc68d4000}, {0xc68d6000}, {0xc68d8000}, {0xc68da000}, {0xc68dc000}, {0xc68de000}, {0xc68e0000}, {0xc68e2000}, {0xc68e4000}, {0xc68e6000}, {0xc68e8000}, {0xc68ea000}, {0xc68ec000}, {0xc68ee000}, {0xc68f0000}, {0xc68f2000}, {0xc68f4000}, {0xc68f6000}, {0xc68f8000}, {0xc68fa000}, {0xc68fc000}, {0xc68fe000}, {0xc6900000}, {0xc6902000}, {0xc6904000}, {0xc6906000}, {0xc6908000}, {0xc690a000}, {0xc690c000}, {0xc690e000}, {0xc6910000}, {0xc6912000}, {0xc6914000}, {0xc6916000}, {0xc6918000}, {0xc691a000}, {0xc691c000}, {0xc691e000}, {0xc6920000}, {0xc6922000}, {0xc6924000}, {0xc6926000}, {0xc6928000}, {0xc692a000}, {0xc692c000}, {0xc692e000}, {0xc6930000}, {0xc6932000}, {0xc6934000}, {0xc6936000}, {0xc6938000}, {0xc693a000}, {0xc693c000}, {0xc693e000}, {0xc6940000}, {0xc6942000}, {0xc6944000}, {0xc6946000}, {0xc6948000}, {0xc694a000}, {0xc694c000}, {0xc694e000}, {0xc6950000}, {0xc6952000}, {0xc6954000}, {0xc6956000}, {0xc6958000}, {0xc695a000}, {0xc695c000}, {0xc695e000}, {0xc6960000}, {0xc6962000}, {0xc6964000}, {0xc6966000}, {0xc6968000}, {0xc696a000}, {0xc696c000}, {0xc696e000}, {0xc6970000}, {0xc6972000}, {0xc6974000}, {0xc6976000}, {0xc6978000}, {0xc697a000}, {0xc697c000}, {0xc697e000}, {0xc6980000}, {0xc6982000}, {0xc6984000}, {0xc6986000}, {0xc6988000}, {0xc698a000}, {0xc698c000}, {0xc698e000}, {0xc6990000}, {0xc6992000}, {0xc6994000}, {0xc6996000}, {0xc6998000}, {0xc699a000}, {0xc699c000}, {0xc699e000}, {0xc69a0000}, {0xc69a2000}, {0xc69a4000}, {0xc69a6000}, {0xc69a8000}, {0xc69aa000}, {0xc69ac000}, {0xc69ae000}, {0xc69b0000}, {0xc69b2000}, {0xc69b4000}, {0xc69b6000}, {0xc69b8000}, {0xc69ba000}, {0xc69bc000}, {0xc69be000}, {0xc69c0000}, {0xc69c2000}, {0xc69c4000}, {0xc69c6000}, {0xc69c8000}, {0xc69ca000}, {0xc69cc000}, {0xc69ce000}, {0xc69d0000}, {0xc69d2000}, {0xc69d4000}, {0xc69d6000}, {0xc69d8000}, {0xc69da000}, {0xc69dc000}, {0xc69de000}, {0xc69e0000}, {0xc69e2000}, {0xc69e4000}, {0xc69e6000}, {0xc69e8000}, {0xc69ea000}, {0xc69ec000}, {0xc69ee000}, {0xc69f0000}, {0xc69f2000}, {0xc69f4000}, {0xc69f6000}, {0xc69f8000}, {0xc69fa000}, {0xc69fc000}, {0xc69fe000}, {0xc6a00000}, {0xc6a02000}, {0xc6a04000}, {0xc6a06000}, {0xc6a08000}, {0xc6a0a000}, {0xc6a0c000}, {0xc6a0e000}, {0xc6a10000}, {0xc6a12000}, {0xc6a14000}, {0xc6a16000}, {0xc6a18000}, {0xc6a1a000}, {0xc6a1c000}, {0xc6a1e000}, {0xc6a20000}, {0xc6a22000}, {0xc6a24000}, {0xc6a26000}, {0xc6a28000}, {0xc6a2a000}, {0xc6a2c000}, {0xc6a2e000}, {0xc6a30000}, {0xc6a32000}, {0xc6a34000}, {0xc6a36000}, {0xc6a38000}, {0xc6a3a000}, {0xc6a3c000}, {0xc6a3e000}, {0xc6a40000}, {0xc6a42000}, {0xc6a44000}, {0xc6a46000}, {0xc6a48000}, {0xc6a4a000}, {0xc6a4c000}, {0xc6a4e000}, {0xc6a50000}, {0xc6a52000}, {0xc6a54000}, {0xc6a56000}, {0xc6a58000}, {0xc6a5a000}, {0xc6a5c000}, {0xc6a5e000}, {0xc6a60000}, {0xc6a62000}, {0xc6a64000}, {0xc6a66000}, {0xc6a68000}, {0xc6a6a000}, {0xc6a6c000}, {0xc6a6e000}, {0xc6a70000}, {0xc6a72000}, {0xc6a74000}, {0xc6a76000}, {0xc6a78000}, {0xc6a7a000}, {0xc6a7c000}, {0xc6a7e000}, {0xc6a80000}, {0xc6a82000}, {0xc6a84000}, {0xc6a86000}, {0xc6a88000}, {0xc6a8a000}, {0xc6a8c000}, {0xc6a8e000}, {0xc6a90000}, {0xc6a92000}, {0xc6a94000}, {0xc6a96000}, {0xc6a98000}, {0xc6a9a000}, {0xc6a9c000}, {0xc6a9e000}, {0xc6aa0000}, {0xc6aa2000}, {0xc6aa4000}, {0xc6aa6000}, {0xc6aa8000}, {0xc6aaa000}, {0xc6aac000}, {0xc6aae000}, {0xc6ab0000}, {0xc6ab2000}, {0xc6ab4000}, {0xc6ab6000}, {0xc6ab8000}, {0xc6aba000}, {0xc6abc000}, {0xc6abe000}, {0xc6ac0000}, {0xc6ac2000}, {0xc6ac4000}, {0xc6ac6000}, {0xc6ac8000}, {0xc6aca000}, {0xc6acc000}, {0xc6ace000}, {0xc6ad0000}, {0xc6ad2000}, {0xc6ad4000}, {0xc6ad6000}, {0xc6ad8000}, {0xc6ada000}, {0xc6adc000}, {0xc6ade000}, {0xc6ae0000}, {0xc6ae2000}, {0xc6ae4000}, {0xc6ae6000}, {0xc6ae8000}, {0xc6aea000}, {0xc6aec000}, {0xc6aee000}, {0xc6af0000}, {0xc6af2000}, {0xc6af4000}, {0xc6af6000}, {0xc6af8000}, {0xc6afa000}, {0xc6afc000}, {0xc6afe000}, {0xc6b00000}, {0xc6b02000}, {0xc6b04000}, {0xc6b06000}, {0xc6b08000}, {0xc6b0a000}, {0xc6b0c000}, {0xc6b0e000}, {0xc6b10000}, {0xc6b12000}, {0xc6b14000}, {0xc6b16000}, {0xc6b18000}, {0xc6b1a000}, {0xc6b1c000}, {0xc6b1e000}, {0xc6b20000}, {0xc6b22000}, {0xc6b24000}, {0xc6b26000}, {0xc6b28000}, {0xc6b2a000}, {0xc6b2c000}, {0xc6b2e000}, {0xc6b30000}, {0xc6b32000}, {0xc6b34000}, {0xc6b36000}, {0xc6b38000}, {0xc6b3a000}, {0xc6b3c000}, {0xc6b3e000}, {0xc6b40000}, {0xc6b42000}, {0xc6b44000}, {0xc6b46000}, {0xc6b48000}, {0xc6b4a000}, {0xc6b4c000}, {0xc6b4e000}, {0xc6b50000}, {0xc6b52000}, {0xc6b54000}, {0xc6b56000}, {0xc6b58000}, {0xc6b5a000}, {0xc6b5c000}, {0xc6b5e000}, {0xc6b60000}, {0xc6b62000}, {0xc6b64000}, {0xc6b66000}, {0xc6b68000}, {0xc6b6a000}, {0xc6b6c000}, {0xc6b6e000}, {0xc6b70000}, {0xc6b72000}, {0xc6b74000}, {0xc6b76000}, {0xc6b78000}, {0xc6b7a000}, {0xc6b7c000}, {0xc6b7e000}, {0xc6b80000}, {0xc6b82000}, {0xc6b84000}, {0xc6b86000}, {0xc6b88000}, {0xc6b8a000}, {0xc6b8c000}, {0xc6b8e000}, {0xc6b90000}, {0xc6b92000}, {0xc6b94000}, {0xc6b96000}, {0xc6b98000}, {0xc6b9a000}, {0xc6b9c000}, {0xc6b9e000}, {0xc6ba0000}, {0xc6ba2000}, {0xc6ba4000}, {0xc6ba6000}, {0xc6ba8000}, {0xc6baa000}, {0xc6bac000}, {0xc6bae000}, {0xc6bb0000}, {0xc6bb2000}, {0xc6bb4000}, {0xc6bb6000}, {0xc6bb8000}, {0xc6bba000}, {0xc6bbc000}, {0xc6bbe000}, {0xc6bc0000}, {0xc6bc2000}, {0xc6bc4000}, {0xc6bc6000}, {0xc6bc8000}, {0xc6bca000}, {0xc6bcc000}, {0xc6bce000}, {0xc6bd0000}, {0xc6bd2000}, {0xc6bd4000}, {0xc6bd6000}, {0xc6bd8000}, {0xc6bda000}, {0xc6bdc000}, {0xc6bde000}, {0xc6be0000}, {0xc6be2000}, {0xc6be4000}, {0xc6be6000}, {0xc6be8000}, {0xc6bea000}, {0xc6bec000}, {0xc6bee000}, {0xc6bf0000}, {0xc6bf2000}, {0xc6bf4000}, {0xc6bf6000}, {0xc6bf8000}, {0xc6bfa000}, {0xc6bfc000}, {0xc6bfe000}, {0xc6c00000}, {0xc6c02000}, {0xc6c04000}, {0xc6c06000}, {0xc6c08000}, {0xc6c0a000}, {0xc6c0c000}, {0xc6c0e000}, {0xc6c10000}, {0xc6c12000}, {0xc6c14000}, {0xc6c16000}, {0xc6c18000}, {0xc6c1a000}, {0xc6c1c000}, {0xc6c1e000}, {0xc6c20000}, {0xc6c22000}, {0xc6c24000}, {0xc6c26000}, {0xc6c28000}, {0xc6c2a000}, {0xc6c2c000}, {0xc6c2e000}, {0xc6c30000}, {0xc6c32000}, {0xc6c34000}, {0xc6c36000}, {0xc6c38000}, {0xc6c3a000}, {0xc6c3c000}, {0xc6c3e000}, {0xc6c40000}, {0xc6c42000}, {0xc6c44000}, {0xc6c46000}, {0xc6c48000}, {0xc6c4a000}, {0xc6c4c000}, {0xc6c4e000}, {0xc6c50000}, {0xc6c52000}, {0xc6c54000}, {0xc6c56000}, {0xc6c58000}, {0xc6c5a000}, {0xc6c5c000}, {0xc6c5e000}, {0xc6c60000}, {0xc6c62000}, {0xc6c64000}, {0xc6c66000}, {0xc6c68000}, {0xc6c6a000}, {0xc6c6c000}, {0xc6c6e000}, {0xc6c70000}, {0xc6c72000}, {0xc6c74000}, {0xc6c76000}, {0xc6c78000}, {0xc6c7a000}, {0xc6c7c000}, {0xc6c7e000}, {0xc6c80000}, {0xc6c82000}, {0xc6c84000}, {0xc6c86000}, {0xc6c88000}, {0xc6c8a000}, {0xc6c8c000}, {0xc6c8e000}, {0xc6c90000}, {0xc6c92000}, {0xc6c94000}, {0xc6c96000}, {0xc6c98000}, {0xc6c9a000}, {0xc6c9c000}, {0xc6c9e000}, {0xc6ca0000}, {0xc6ca2000}, {0xc6ca4000}, {0xc6ca6000}, {0xc6ca8000}, {0xc6caa000}, {0xc6cac000}, {0xc6cae000}, {0xc6cb0000}, {0xc6cb2000}, {0xc6cb4000}, {0xc6cb6000}, {0xc6cb8000}, {0xc6cba000}, {0xc6cbc000}, {0xc6cbe000}, {0xc6cc0000}, {0xc6cc2000}, {0xc6cc4000}, {0xc6cc6000}, {0xc6cc8000}, {0xc6cca000}, {0xc6ccc000}, {0xc6cce000}, {0xc6cd0000}, {0xc6cd2000}, {0xc6cd4000}, {0xc6cd6000}, {0xc6cd8000}, {0xc6cda000}, {0xc6cdc000}, {0xc6cde000}, {0xc6ce0000}, {0xc6ce2000}, {0xc6ce4000}, {0xc6ce6000}, {0xc6ce8000}, {0xc6cea000}, {0xc6cec000}, {0xc6cee000}, {0xc6cf0000}, {0xc6cf2000}, {0xc6cf4000}, {0xc6cf6000}, {0xc6cf8000}, {0xc6cfa000}, {0xc6cfc000}, {0xc6cfe000}, {0xc6d00000}, {0xc6d02000}, {0xc6d04000}, {0xc6d06000}, {0xc6d08000}, {0xc6d0a000}, {0xc6d0c000}, {0xc6d0e000}, {0xc6d10000}, {0xc6d12000}, {0xc6d14000}, {0xc6d16000}, {0xc6d18000}, {0xc6d1a000}, {0xc6d1c000}, {0xc6d1e000}, {0xc6d20000}, {0xc6d22000}, {0xc6d24000}, {0xc6d26000}, {0xc6d28000}, {0xc6d2a000}, {0xc6d2c000}, {0xc6d2e000}, {0xc6d30000}, {0xc6d32000}, {0xc6d34000}, {0xc6d36000}, {0xc6d38000}, {0xc6d3a000}, {0xc6d3c000}, {0xc6d3e000}, {0xc6d40000}, {0xc6d42000}, {0xc6d44000}, {0xc6d46000}, {0xc6d48000}, {0xc6d4a000}, {0xc6d4c000}, {0xc6d4e000}, {0xc6d50000}, {0xc6d52000}, {0xc6d54000}, {0xc6d56000}, {0xc6d58000}, {0xc6d5a000}, {0xc6d5c000}, {0xc6d5e000}, {0xc6d60000}, {0xc6d62000}, {0xc6d64000}, {0xc6d66000}, {0xc6d68000}, {0xc6d6a000}, {0xc6d6c000}, {0xc6d6e000}, {0xc6d70000}, {0xc6d72000}, {0xc6d74000}, {0xc6d76000}, {0xc6d78000}, {0xc6d7a000}, {0xc6d7c000}, {0xc6d7e000}, {0xc6d80000}, {0xc6d82000}, {0xc6d84000}, {0xc6d86000}, {0xc6d88000}, {0xc6d8a000}, {0xc6d8c000}, {0xc6d8e000}, {0xc6d90000}, {0xc6d92000}, {0xc6d94000}, {0xc6d96000}, {0xc6d98000}, {0xc6d9a000}, {0xc6d9c000}, {0xc6d9e000}, {0xc6da0000}, {0xc6da2000}, {0xc6da4000}, {0xc6da6000}, {0xc6da8000}, {0xc6daa000}, {0xc6dac000}, {0xc6dae000}, {0xc6db0000}, {0xc6db2000}, {0xc6db4000}, {0xc6db6000}, {0xc6db8000}, {0xc6dba000}, {0xc6dbc000}, {0xc6dbe000}, {0xc6dc0000}, {0xc6dc2000}, {0xc6dc4000}, {0xc6dc6000}, {0xc6dc8000}, {0xc6dca000}, {0xc6dcc000}, {0xc6dce000}, {0xc6dd0000}, {0xc6dd2000}, {0xc6dd4000}, {0xc6dd6000}, {0xc6dd8000}, {0xc6dda000}, {0xc6ddc000}, {0xc6dde000}, {0xc6de0000}, {0xc6de2000}, {0xc6de4000}, {0xc6de6000}, {0xc6de8000}, {0xc6dea000}, {0xc6dec000}, {0xc6dee000}, {0xc6df0000}, {0xc6df2000}, {0xc6df4000}, {0xc6df6000}, {0xc6df8000}, {0xc6dfa000}, {0xc6dfc000}, {0xc6dfe000}, {0xc6e00000}, {0xc6e02000}, {0xc6e04000}, {0xc6e06000}, {0xc6e08000}, {0xc6e0a000}, {0xc6e0c000}, {0xc6e0e000}, {0xc6e10000}, {0xc6e12000}, {0xc6e14000}, {0xc6e16000}, {0xc6e18000}, {0xc6e1a000}, {0xc6e1c000}, {0xc6e1e000}, {0xc6e20000}, {0xc6e22000}, {0xc6e24000}, {0xc6e26000}, {0xc6e28000}, {0xc6e2a000}, {0xc6e2c000}, {0xc6e2e000}, {0xc6e30000}, {0xc6e32000}, {0xc6e34000}, {0xc6e36000}, {0xc6e38000}, {0xc6e3a000}, {0xc6e3c000}, {0xc6e3e000}, {0xc6e40000}, {0xc6e42000}, {0xc6e44000}, {0xc6e46000}, {0xc6e48000}, {0xc6e4a000}, {0xc6e4c000}, {0xc6e4e000}, {0xc6e50000}, {0xc6e52000}, {0xc6e54000}, {0xc6e56000}, {0xc6e58000}, {0xc6e5a000}, {0xc6e5c000}, {0xc6e5e000}, {0xc6e60000}, {0xc6e62000}, {0xc6e64000}, {0xc6e66000}, {0xc6e68000}, {0xc6e6a000}, {0xc6e6c000}, {0xc6e6e000}, {0xc6e70000}, {0xc6e72000}, {0xc6e74000}, {0xc6e76000}, {0xc6e78000}, {0xc6e7a000}, {0xc6e7c000}, {0xc6e7e000}, {0xc6e80000}, {0xc6e82000}, {0xc6e84000}, {0xc6e86000}, {0xc6e88000}, {0xc6e8a000}, {0xc6e8c000}, {0xc6e8e000}, {0xc6e90000}, {0xc6e92000}, {0xc6e94000}, {0xc6e96000}, {0xc6e98000}, {0xc6e9a000}, {0xc6e9c000}, {0xc6e9e000}, {0xc6ea0000}, {0xc6ea2000}, {0xc6ea4000}, {0xc6ea6000}, {0xc6ea8000}, {0xc6eaa000}, {0xc6eac000}, {0xc6eae000}, {0xc6eb0000}, {0xc6eb2000}, {0xc6eb4000}, {0xc6eb6000}, {0xc6eb8000}, {0xc6eba000}, {0xc6ebc000}, {0xc6ebe000}, {0xc6ec0000}, {0xc6ec2000}, {0xc6ec4000}, {0xc6ec6000}, {0xc6ec8000}, {0xc6eca000}, {0xc6ecc000}, {0xc6ece000}, {0xc6ed0000}, {0xc6ed2000}, {0xc6ed4000}, {0xc6ed6000}, {0xc6ed8000}, {0xc6eda000}, {0xc6edc000}, {0xc6ede000}, {0xc6ee0000}, {0xc6ee2000}, {0xc6ee4000}, {0xc6ee6000}, {0xc6ee8000}, {0xc6eea000}, {0xc6eec000}, {0xc6eee000}, {0xc6ef0000}, {0xc6ef2000}, {0xc6ef4000}, {0xc6ef6000}, {0xc6ef8000}, {0xc6efa000}, {0xc6efc000}, {0xc6efe000}, {0xc6f00000}, {0xc6f02000}, {0xc6f04000}, {0xc6f06000}, {0xc6f08000}, {0xc6f0a000}, {0xc6f0c000}, {0xc6f0e000}, {0xc6f10000}, {0xc6f12000}, {0xc6f14000}, {0xc6f16000}, {0xc6f18000}, {0xc6f1a000}, {0xc6f1c000}, {0xc6f1e000}, {0xc6f20000}, {0xc6f22000}, {0xc6f24000}, {0xc6f26000}, {0xc6f28000}, {0xc6f2a000}, {0xc6f2c000}, {0xc6f2e000}, {0xc6f30000}, {0xc6f32000}, {0xc6f34000}, {0xc6f36000}, {0xc6f38000}, {0xc6f3a000}, {0xc6f3c000}, {0xc6f3e000}, {0xc6f40000}, {0xc6f42000}, {0xc6f44000}, {0xc6f46000}, {0xc6f48000}, {0xc6f4a000}, {0xc6f4c000}, {0xc6f4e000}, {0xc6f50000}, {0xc6f52000}, {0xc6f54000}, {0xc6f56000}, {0xc6f58000}, {0xc6f5a000}, {0xc6f5c000}, {0xc6f5e000}, {0xc6f60000}, {0xc6f62000}, {0xc6f64000}, {0xc6f66000}, {0xc6f68000}, {0xc6f6a000}, {0xc6f6c000}, {0xc6f6e000}, {0xc6f70000}, {0xc6f72000}, {0xc6f74000}, {0xc6f76000}, {0xc6f78000}, {0xc6f7a000}, {0xc6f7c000}, {0xc6f7e000}, {0xc6f80000}, {0xc6f82000}, {0xc6f84000}, {0xc6f86000}, {0xc6f88000}, {0xc6f8a000}, {0xc6f8c000}, {0xc6f8e000}, {0xc6f90000}, {0xc6f92000}, {0xc6f94000}, {0xc6f96000}, {0xc6f98000}, {0xc6f9a000}, {0xc6f9c000}, {0xc6f9e000}, {0xc6fa0000}, {0xc6fa2000}, {0xc6fa4000}, {0xc6fa6000}, {0xc6fa8000}, {0xc6faa000}, {0xc6fac000}, {0xc6fae000}, {0xc6fb0000}, {0xc6fb2000}, {0xc6fb4000}, {0xc6fb6000}, {0xc6fb8000}, {0xc6fba000}, {0xc6fbc000}, {0xc6fbe000}, {0xc6fc0000}, {0xc6fc2000}, {0xc6fc4000}, {0xc6fc6000}, {0xc6fc8000}, {0xc6fca000}, {0xc6fcc000}, {0xc6fce000}, {0xc6fd0000}, {0xc6fd2000}, {0xc6fd4000}, {0xc6fd6000}, {0xc6fd8000}, {0xc6fda000}, {0xc6fdc000}, {0xc6fde000}, {0xc6fe0000}, {0xc6fe2000}, {0xc6fe4000}, {0xc6fe6000}, {0xc6fe8000}, {0xc6fea000}, {0xc6fec000}, {0xc6fee000}, {0xc6ff0000}, {0xc6ff2000}, {0xc6ff4000}, {0xc6ff6000}, {0xc6ff8000}, {0xc6ffa000}, {0xc6ffc000}, {0xc6ffe000}, {0xc7000000}, {0xc7002000}, {0xc7004000}, {0xc7006000}, {0xc7008000}, {0xc700a000}, {0xc700c000}, {0xc700e000}, {0xc7010000}, {0xc7012000}, {0xc7014000}, {0xc7016000}, {0xc7018000}, {0xc701a000}, {0xc701c000}, {0xc701e000}, {0xc7020000}, {0xc7022000}, {0xc7024000}, {0xc7026000}, {0xc7028000}, {0xc702a000}, {0xc702c000}, {0xc702e000}, {0xc7030000}, {0xc7032000}, {0xc7034000}, {0xc7036000}, {0xc7038000}, {0xc703a000}, {0xc703c000}, {0xc703e000}, {0xc7040000}, {0xc7042000}, {0xc7044000}, {0xc7046000}, {0xc7048000}, {0xc704a000}, {0xc704c000}, {0xc704e000}, {0xc7050000}, {0xc7052000}, {0xc7054000}, {0xc7056000}, {0xc7058000}, {0xc705a000}, {0xc705c000}, {0xc705e000}, {0xc7060000}, {0xc7062000}, {0xc7064000}, {0xc7066000}, {0xc7068000}, {0xc706a000}, {0xc706c000}, {0xc706e000}, {0xc7070000}, {0xc7072000}, {0xc7074000}, {0xc7076000}, {0xc7078000}, {0xc707a000}, {0xc707c000}, {0xc707e000}, {0xc7080000}, {0xc7082000}, {0xc7084000}, {0xc7086000}, {0xc7088000}, {0xc708a000}, {0xc708c000}, {0xc708e000}, {0xc7090000}, {0xc7092000}, {0xc7094000}, {0xc7096000}, {0xc7098000}, {0xc709a000}, {0xc709c000}, {0xc709e000}, {0xc70a0000}, {0xc70a2000}, {0xc70a4000}, {0xc70a6000}, {0xc70a8000}, {0xc70aa000}, {0xc70ac000}, {0xc70ae000}, {0xc70b0000}, {0xc70b2000}, {0xc70b4000}, {0xc70b6000}, {0xc70b8000}, {0xc70ba000}, {0xc70bc000}, {0xc70be000}, {0xc70c0000}, {0xc70c2000}, {0xc70c4000}, {0xc70c6000}, {0xc70c8000}, {0xc70ca000}, {0xc70cc000}, {0xc70ce000}, {0xc70d0000}, {0xc70d2000}, {0xc70d4000}, {0xc70d6000}, {0xc70d8000}, {0xc70da000}, {0xc70dc000}, {0xc70de000}, {0xc70e0000}, {0xc70e2000}, {0xc70e4000}, {0xc70e6000}, {0xc70e8000}, {0xc70ea000}, {0xc70ec000}, {0xc70ee000}, {0xc70f0000}, {0xc70f2000}, {0xc70f4000}, {0xc70f6000}, {0xc70f8000}, {0xc70fa000}, {0xc70fc000}, {0xc70fe000}, {0xc7100000}, {0xc7102000}, {0xc7104000}, {0xc7106000}, {0xc7108000}, {0xc710a000}, {0xc710c000}, {0xc710e000}, {0xc7110000}, {0xc7112000}, {0xc7114000}, {0xc7116000}, {0xc7118000}, {0xc711a000}, {0xc711c000}, {0xc711e000}, {0xc7120000}, {0xc7122000}, {0xc7124000}, {0xc7126000}, {0xc7128000}, {0xc712a000}, {0xc712c000}, {0xc712e000}, {0xc7130000}, {0xc7132000}, {0xc7134000}, {0xc7136000}, {0xc7138000}, {0xc713a000}, {0xc713c000}, {0xc713e000}, {0xc7140000}, {0xc7142000}, {0xc7144000}, {0xc7146000}, {0xc7148000}, {0xc714a000}, {0xc714c000}, {0xc714e000}, {0xc7150000}, {0xc7152000}, {0xc7154000}, {0xc7156000}, {0xc7158000}, {0xc715a000}, {0xc715c000}, {0xc715e000}, {0xc7160000}, {0xc7162000}, {0xc7164000}, {0xc7166000}, {0xc7168000}, {0xc716a000}, {0xc716c000}, {0xc716e000}, {0xc7170000}, {0xc7172000}, {0xc7174000}, {0xc7176000}, {0xc7178000}, {0xc717a000}, {0xc717c000}, {0xc717e000}, {0xc7180000}, {0xc7182000}, {0xc7184000}, {0xc7186000}, {0xc7188000}, {0xc718a000}, {0xc718c000}, {0xc718e000}, {0xc7190000}, {0xc7192000}, {0xc7194000}, {0xc7196000}, {0xc7198000}, {0xc719a000}, {0xc719c000}, {0xc719e000}, {0xc71a0000}, {0xc71a2000}, {0xc71a4000}, {0xc71a6000}, {0xc71a8000}, {0xc71aa000}, {0xc71ac000}, {0xc71ae000}, {0xc71b0000}, {0xc71b2000}, {0xc71b4000}, {0xc71b6000}, {0xc71b8000}, {0xc71ba000}, {0xc71bc000}, {0xc71be000}, {0xc71c0000}, {0xc71c2000}, {0xc71c4000}, {0xc71c6000}, {0xc71c8000}, {0xc71ca000}, {0xc71cc000}, {0xc71ce000}, {0xc71d0000}, {0xc71d2000}, {0xc71d4000}, {0xc71d6000}, {0xc71d8000}, {0xc71da000}, {0xc71dc000}, {0xc71de000}, {0xc71e0000}, {0xc71e2000}, {0xc71e4000}, {0xc71e6000}, {0xc71e8000}, {0xc71ea000}, {0xc71ec000}, {0xc71ee000}, {0xc71f0000}, {0xc71f2000}, {0xc71f4000}, {0xc71f6000}, {0xc71f8000}, {0xc71fa000}, {0xc71fc000}, {0xc71fe000}, {0xc7200000}, {0xc7202000}, {0xc7204000}, {0xc7206000}, {0xc7208000}, {0xc720a000}, {0xc720c000}, {0xc720e000}, {0xc7210000}, {0xc7212000}, {0xc7214000}, {0xc7216000}, {0xc7218000}, {0xc721a000}, {0xc721c000}, {0xc721e000}, {0xc7220000}, {0xc7222000}, {0xc7224000}, {0xc7226000}, {0xc7228000}, {0xc722a000}, {0xc722c000}, {0xc722e000}, {0xc7230000}, {0xc7232000}, {0xc7234000}, {0xc7236000}, {0xc7238000}, {0xc723a000}, {0xc723c000}, {0xc723e000}, {0xc7240000}, {0xc7242000}, {0xc7244000}, {0xc7246000}, {0xc7248000}, {0xc724a000}, {0xc724c000}, {0xc724e000}, {0xc7250000}, {0xc7252000}, {0xc7254000}, {0xc7256000}, {0xc7258000}, {0xc725a000}, {0xc725c000}, {0xc725e000}, {0xc7260000}, {0xc7262000}, {0xc7264000}, {0xc7266000}, {0xc7268000}, {0xc726a000}, {0xc726c000}, {0xc726e000}, {0xc7270000}, {0xc7272000}, {0xc7274000}, {0xc7276000}, {0xc7278000}, {0xc727a000}, {0xc727c000}, {0xc727e000}, {0xc7280000}, {0xc7282000}, {0xc7284000}, {0xc7286000}, {0xc7288000}, {0xc728a000}, {0xc728c000}, {0xc728e000}, {0xc7290000}, {0xc7292000}, {0xc7294000}, {0xc7296000}, {0xc7298000}, {0xc729a000}, {0xc729c000}, {0xc729e000}, {0xc72a0000}, {0xc72a2000}, {0xc72a4000}, {0xc72a6000}, {0xc72a8000}, {0xc72aa000}, {0xc72ac000}, {0xc72ae000}, {0xc72b0000}, {0xc72b2000}, {0xc72b4000}, {0xc72b6000}, {0xc72b8000}, {0xc72ba000}, {0xc72bc000}, {0xc72be000}, {0xc72c0000}, {0xc72c2000}, {0xc72c4000}, {0xc72c6000}, {0xc72c8000}, {0xc72ca000}, {0xc72cc000}, {0xc72ce000}, {0xc72d0000}, {0xc72d2000}, {0xc72d4000}, {0xc72d6000}, {0xc72d8000}, {0xc72da000}, {0xc72dc000}, {0xc72de000}, {0xc72e0000}, {0xc72e2000}, {0xc72e4000}, {0xc72e6000}, {0xc72e8000}, {0xc72ea000}, {0xc72ec000}, {0xc72ee000}, {0xc72f0000}, {0xc72f2000}, {0xc72f4000}, {0xc72f6000}, {0xc72f8000}, {0xc72fa000}, {0xc72fc000}, {0xc72fe000}, {0xc7300000}, {0xc7302000}, {0xc7304000}, {0xc7306000}, {0xc7308000}, {0xc730a000}, {0xc730c000}, {0xc730e000}, {0xc7310000}, {0xc7312000}, {0xc7314000}, {0xc7316000}, {0xc7318000}, {0xc731a000}, {0xc731c000}, {0xc731e000}, {0xc7320000}, {0xc7322000}, {0xc7324000}, {0xc7326000}, {0xc7328000}, {0xc732a000}, {0xc732c000}, {0xc732e000}, {0xc7330000}, {0xc7332000}, {0xc7334000}, {0xc7336000}, {0xc7338000}, {0xc733a000}, {0xc733c000}, {0xc733e000}, {0xc7340000}, {0xc7342000}, {0xc7344000}, {0xc7346000}, {0xc7348000}, {0xc734a000}, {0xc734c000}, {0xc734e000}, {0xc7350000}, {0xc7352000}, {0xc7354000}, {0xc7356000}, {0xc7358000}, {0xc735a000}, {0xc735c000}, {0xc735e000}, {0xc7360000}, {0xc7362000}, {0xc7364000}, {0xc7366000}, {0xc7368000}, {0xc736a000}, {0xc736c000}, {0xc736e000}, {0xc7370000}, {0xc7372000}, {0xc7374000}, {0xc7376000}, {0xc7378000}, {0xc737a000}, {0xc737c000}, {0xc737e000}, {0xc7380000}, {0xc7382000}, {0xc7384000}, {0xc7386000}, {0xc7388000}, {0xc738a000}, {0xc738c000}, {0xc738e000}, {0xc7390000}, {0xc7392000}, {0xc7394000}, {0xc7396000}, {0xc7398000}, {0xc739a000}, {0xc739c000}, {0xc739e000}, {0xc73a0000}, {0xc73a2000}, {0xc73a4000}, {0xc73a6000}, {0xc73a8000}, {0xc73aa000}, {0xc73ac000}, {0xc73ae000}, {0xc73b0000}, {0xc73b2000}, {0xc73b4000}, {0xc73b6000}, {0xc73b8000}, {0xc73ba000}, {0xc73bc000}, {0xc73be000}, {0xc73c0000}, {0xc73c2000}, {0xc73c4000}, {0xc73c6000}, {0xc73c8000}, {0xc73ca000}, {0xc73cc000}, {0xc73ce000}, {0xc73d0000}, {0xc73d2000}, {0xc73d4000}, {0xc73d6000}, {0xc73d8000}, {0xc73da000}, {0xc73dc000}, {0xc73de000}, {0xc73e0000}, {0xc73e2000}, {0xc73e4000}, {0xc73e6000}, {0xc73e8000}, {0xc73ea000}, {0xc73ec000}, {0xc73ee000}, {0xc73f0000}, {0xc73f2000}, {0xc73f4000}, {0xc73f6000}, {0xc73f8000}, {0xc73fa000}, {0xc73fc000}, {0xc73fe000}, {0xc7400000}, {0xc7402000}, {0xc7404000}, {0xc7406000}, {0xc7408000}, {0xc740a000}, {0xc740c000}, {0xc740e000}, {0xc7410000}, {0xc7412000}, {0xc7414000}, {0xc7416000}, {0xc7418000}, {0xc741a000}, {0xc741c000}, {0xc741e000}, {0xc7420000}, {0xc7422000}, {0xc7424000}, {0xc7426000}, {0xc7428000}, {0xc742a000}, {0xc742c000}, {0xc742e000}, {0xc7430000}, {0xc7432000}, {0xc7434000}, {0xc7436000}, {0xc7438000}, {0xc743a000}, {0xc743c000}, {0xc743e000}, {0xc7440000}, {0xc7442000}, {0xc7444000}, {0xc7446000}, {0xc7448000}, {0xc744a000}, {0xc744c000}, {0xc744e000}, {0xc7450000}, {0xc7452000}, {0xc7454000}, {0xc7456000}, {0xc7458000}, {0xc745a000}, {0xc745c000}, {0xc745e000}, {0xc7460000}, {0xc7462000}, {0xc7464000}, {0xc7466000}, {0xc7468000}, {0xc746a000}, {0xc746c000}, {0xc746e000}, {0xc7470000}, {0xc7472000}, {0xc7474000}, {0xc7476000}, {0xc7478000}, {0xc747a000}, {0xc747c000}, {0xc747e000}, {0xc7480000}, {0xc7482000}, {0xc7484000}, {0xc7486000}, {0xc7488000}, {0xc748a000}, {0xc748c000}, {0xc748e000}, {0xc7490000}, {0xc7492000}, {0xc7494000}, {0xc7496000}, {0xc7498000}, {0xc749a000}, {0xc749c000}, {0xc749e000}, {0xc74a0000}, {0xc74a2000}, {0xc74a4000}, {0xc74a6000}, {0xc74a8000}, {0xc74aa000}, {0xc74ac000}, {0xc74ae000}, {0xc74b0000}, {0xc74b2000}, {0xc74b4000}, {0xc74b6000}, {0xc74b8000}, {0xc74ba000}, {0xc74bc000}, {0xc74be000}, {0xc74c0000}, {0xc74c2000}, {0xc74c4000}, {0xc74c6000}, {0xc74c8000}, {0xc74ca000}, {0xc74cc000}, {0xc74ce000}, {0xc74d0000}, {0xc74d2000}, {0xc74d4000}, {0xc74d6000}, {0xc74d8000}, {0xc74da000}, {0xc74dc000}, {0xc74de000}, {0xc74e0000}, {0xc74e2000}, {0xc74e4000}, {0xc74e6000}, {0xc74e8000}, {0xc74ea000}, {0xc74ec000}, {0xc74ee000}, {0xc74f0000}, {0xc74f2000}, {0xc74f4000}, {0xc74f6000}, {0xc74f8000}, {0xc74fa000}, {0xc74fc000}, {0xc74fe000}, {0xc7500000}, {0xc7502000}, {0xc7504000}, {0xc7506000}, {0xc7508000}, {0xc750a000}, {0xc750c000}, {0xc750e000}, {0xc7510000}, {0xc7512000}, {0xc7514000}, {0xc7516000}, {0xc7518000}, {0xc751a000}, {0xc751c000}, {0xc751e000}, {0xc7520000}, {0xc7522000}, {0xc7524000}, {0xc7526000}, {0xc7528000}, {0xc752a000}, {0xc752c000}, {0xc752e000}, {0xc7530000}, {0xc7532000}, {0xc7534000}, {0xc7536000}, {0xc7538000}, {0xc753a000}, {0xc753c000}, {0xc753e000}, {0xc7540000}, {0xc7542000}, {0xc7544000}, {0xc7546000}, {0xc7548000}, {0xc754a000}, {0xc754c000}, {0xc754e000}, {0xc7550000}, {0xc7552000}, {0xc7554000}, {0xc7556000}, {0xc7558000}, {0xc755a000}, {0xc755c000}, {0xc755e000}, {0xc7560000}, {0xc7562000}, {0xc7564000}, {0xc7566000}, {0xc7568000}, {0xc756a000}, {0xc756c000}, {0xc756e000}, {0xc7570000}, {0xc7572000}, {0xc7574000}, {0xc7576000}, {0xc7578000}, {0xc757a000}, {0xc757c000}, {0xc757e000}, {0xc7580000}, {0xc7582000}, {0xc7584000}, {0xc7586000}, {0xc7588000}, {0xc758a000}, {0xc758c000}, {0xc758e000}, {0xc7590000}, {0xc7592000}, {0xc7594000}, {0xc7596000}, {0xc7598000}, {0xc759a000}, {0xc759c000}, {0xc759e000}, {0xc75a0000}, {0xc75a2000}, {0xc75a4000}, {0xc75a6000}, {0xc75a8000}, {0xc75aa000}, {0xc75ac000}, {0xc75ae000}, {0xc75b0000}, {0xc75b2000}, {0xc75b4000}, {0xc75b6000}, {0xc75b8000}, {0xc75ba000}, {0xc75bc000}, {0xc75be000}, {0xc75c0000}, {0xc75c2000}, {0xc75c4000}, {0xc75c6000}, {0xc75c8000}, {0xc75ca000}, {0xc75cc000}, {0xc75ce000}, {0xc75d0000}, {0xc75d2000}, {0xc75d4000}, {0xc75d6000}, {0xc75d8000}, {0xc75da000}, {0xc75dc000}, {0xc75de000}, {0xc75e0000}, {0xc75e2000}, {0xc75e4000}, {0xc75e6000}, {0xc75e8000}, {0xc75ea000}, {0xc75ec000}, {0xc75ee000}, {0xc75f0000}, {0xc75f2000}, {0xc75f4000}, {0xc75f6000}, {0xc75f8000}, {0xc75fa000}, {0xc75fc000}, {0xc75fe000}, {0xc7600000}, {0xc7602000}, {0xc7604000}, {0xc7606000}, {0xc7608000}, {0xc760a000}, {0xc760c000}, {0xc760e000}, {0xc7610000}, {0xc7612000}, {0xc7614000}, {0xc7616000}, {0xc7618000}, {0xc761a000}, {0xc761c000}, {0xc761e000}, {0xc7620000}, {0xc7622000}, {0xc7624000}, {0xc7626000}, {0xc7628000}, {0xc762a000}, {0xc762c000}, {0xc762e000}, {0xc7630000}, {0xc7632000}, {0xc7634000}, {0xc7636000}, {0xc7638000}, {0xc763a000}, {0xc763c000}, {0xc763e000}, {0xc7640000}, {0xc7642000}, {0xc7644000}, {0xc7646000}, {0xc7648000}, {0xc764a000}, {0xc764c000}, {0xc764e000}, {0xc7650000}, {0xc7652000}, {0xc7654000}, {0xc7656000}, {0xc7658000}, {0xc765a000}, {0xc765c000}, {0xc765e000}, {0xc7660000}, {0xc7662000}, {0xc7664000}, {0xc7666000}, {0xc7668000}, {0xc766a000}, {0xc766c000}, {0xc766e000}, {0xc7670000}, {0xc7672000}, {0xc7674000}, {0xc7676000}, {0xc7678000}, {0xc767a000}, {0xc767c000}, {0xc767e000}, {0xc7680000}, {0xc7682000}, {0xc7684000}, {0xc7686000}, {0xc7688000}, {0xc768a000}, {0xc768c000}, {0xc768e000}, {0xc7690000}, {0xc7692000}, {0xc7694000}, {0xc7696000}, {0xc7698000}, {0xc769a000}, {0xc769c000}, {0xc769e000}, {0xc76a0000}, {0xc76a2000}, {0xc76a4000}, {0xc76a6000}, {0xc76a8000}, {0xc76aa000}, {0xc76ac000}, {0xc76ae000}, {0xc76b0000}, {0xc76b2000}, {0xc76b4000}, {0xc76b6000}, {0xc76b8000}, {0xc76ba000}, {0xc76bc000}, {0xc76be000}, {0xc76c0000}, {0xc76c2000}, {0xc76c4000}, {0xc76c6000}, {0xc76c8000}, {0xc76ca000}, {0xc76cc000}, {0xc76ce000}, {0xc76d0000}, {0xc76d2000}, {0xc76d4000}, {0xc76d6000}, {0xc76d8000}, {0xc76da000}, {0xc76dc000}, {0xc76de000}, {0xc76e0000}, {0xc76e2000}, {0xc76e4000}, {0xc76e6000}, {0xc76e8000}, {0xc76ea000}, {0xc76ec000}, {0xc76ee000}, {0xc76f0000}, {0xc76f2000}, {0xc76f4000}, {0xc76f6000}, {0xc76f8000}, {0xc76fa000}, {0xc76fc000}, {0xc76fe000}, {0xc7700000}, {0xc7702000}, {0xc7704000}, {0xc7706000}, {0xc7708000}, {0xc770a000}, {0xc770c000}, {0xc770e000}, {0xc7710000}, {0xc7712000}, {0xc7714000}, {0xc7716000}, {0xc7718000}, {0xc771a000}, {0xc771c000}, {0xc771e000}, {0xc7720000}, {0xc7722000}, {0xc7724000}, {0xc7726000}, {0xc7728000}, {0xc772a000}, {0xc772c000}, {0xc772e000}, {0xc7730000}, {0xc7732000}, {0xc7734000}, {0xc7736000}, {0xc7738000}, {0xc773a000}, {0xc773c000}, {0xc773e000}, {0xc7740000}, {0xc7742000}, {0xc7744000}, {0xc7746000}, {0xc7748000}, {0xc774a000}, {0xc774c000}, {0xc774e000}, {0xc7750000}, {0xc7752000}, {0xc7754000}, {0xc7756000}, {0xc7758000}, {0xc775a000}, {0xc775c000}, {0xc775e000}, {0xc7760000}, {0xc7762000}, {0xc7764000}, {0xc7766000}, {0xc7768000}, {0xc776a000}, {0xc776c000}, {0xc776e000}, {0xc7770000}, {0xc7772000}, {0xc7774000}, {0xc7776000}, {0xc7778000}, {0xc777a000}, {0xc777c000}, {0xc777e000}, {0xc7780000}, {0xc7782000}, {0xc7784000}, {0xc7786000}, {0xc7788000}, {0xc778a000}, {0xc778c000}, {0xc778e000}, {0xc7790000}, {0xc7792000}, {0xc7794000}, {0xc7796000}, {0xc7798000}, {0xc779a000}, {0xc779c000}, {0xc779e000}, {0xc77a0000}, {0xc77a2000}, {0xc77a4000}, {0xc77a6000}, {0xc77a8000}, {0xc77aa000}, {0xc77ac000}, {0xc77ae000}, {0xc77b0000}, {0xc77b2000}, {0xc77b4000}, {0xc77b6000}, {0xc77b8000}, {0xc77ba000}, {0xc77bc000}, {0xc77be000}, {0xc77c0000}, {0xc77c2000}, {0xc77c4000}, {0xc77c6000}, {0xc77c8000}, {0xc77ca000}, {0xc77cc000}, {0xc77ce000}, {0xc77d0000}, {0xc77d2000}, {0xc77d4000}, {0xc77d6000}, {0xc77d8000}, {0xc77da000}, {0xc77dc000}, {0xc77de000}, {0xc77e0000}, {0xc77e2000}, {0xc77e4000}, {0xc77e6000}, {0xc77e8000}, {0xc77ea000}, {0xc77ec000}, {0xc77ee000}, {0xc77f0000}, {0xc77f2000}, {0xc77f4000}, {0xc77f6000}, {0xc77f8000}, {0xc77fa000}, {0xc77fc000}, {0xc77fe000}, {0xff800000}, {0xff802000}, {0xff804000}, {0xff806000}, {0xff808000}, {0xff80a000}, {0xff80c000}, {0xff80e000}, {0xff810000}, {0xff812000}, {0xff814000}, {0xff816000}, {0xff818000}, {0xff81a000}, {0xff81c000}, {0xff81e000}, {0xff820000}, {0xff822000}, {0xff824000}, {0xff826000}, {0xff828000}, {0xff82a000}, {0xff82c000}, {0xff82e000}, {0xff830000}, {0xff832000}, {0xff834000}, {0xff836000}, {0xff838000}, {0xff83a000}, {0xff83c000}, {0xff83e000}, {0xff840000}, {0xff842000}, {0xff844000}, {0xff846000}, {0xff848000}, {0xff84a000}, {0xff84c000}, {0xff84e000}, {0xff850000}, {0xff852000}, {0xff854000}, {0xff856000}, {0xff858000}, {0xff85a000}, {0xff85c000}, {0xff85e000}, {0xff860000}, {0xff862000}, {0xff864000}, {0xff866000}, {0xff868000}, {0xff86a000}, {0xff86c000}, {0xff86e000}, {0xff870000}, {0xff872000}, {0xff874000}, {0xff876000}, {0xff878000}, {0xff87a000}, {0xff87c000}, {0xff87e000}, {0xff880000}, {0xff882000}, {0xff884000}, {0xff886000}, {0xff888000}, {0xff88a000}, {0xff88c000}, {0xff88e000}, {0xff890000}, {0xff892000}, {0xff894000}, {0xff896000}, {0xff898000}, {0xff89a000}, {0xff89c000}, {0xff89e000}, {0xff8a0000}, {0xff8a2000}, {0xff8a4000}, {0xff8a6000}, {0xff8a8000}, {0xff8aa000}, {0xff8ac000}, {0xff8ae000}, {0xff8b0000}, {0xff8b2000}, {0xff8b4000}, {0xff8b6000}, {0xff8b8000}, {0xff8ba000}, {0xff8bc000}, {0xff8be000}, {0xff8c0000}, {0xff8c2000}, {0xff8c4000}, {0xff8c6000}, {0xff8c8000}, {0xff8ca000}, {0xff8cc000}, {0xff8ce000}, {0xff8d0000}, {0xff8d2000}, {0xff8d4000}, {0xff8d6000}, {0xff8d8000}, {0xff8da000}, {0xff8dc000}, {0xff8de000}, {0xff8e0000}, {0xff8e2000}, {0xff8e4000}, {0xff8e6000}, {0xff8e8000}, {0xff8ea000}, {0xff8ec000}, {0xff8ee000}, {0xff8f0000}, {0xff8f2000}, {0xff8f4000}, {0xff8f6000}, {0xff8f8000}, {0xff8fa000}, {0xff8fc000}, {0xff8fe000}, {0xff900000}, {0xff902000}, {0xff904000}, {0xff906000}, {0xff908000}, {0xff90a000}, {0xff90c000}, {0xff90e000}, {0xff910000}, {0xff912000}, {0xff914000}, {0xff916000}, {0xff918000}, {0xff91a000}, {0xff91c000}, {0xff91e000}, {0xff920000}, {0xff922000}, {0xff924000}, {0xff926000}, {0xff928000}, {0xff92a000}, {0xff92c000}, {0xff92e000}, {0xff930000}, {0xff932000}, {0xff934000}, {0xff936000}, {0xff938000}, {0xff93a000}, {0xff93c000}, {0xff93e000}, {0xff940000}, {0xff942000}, {0xff944000}, {0xff946000}, {0xff948000}, {0xff94a000}, {0xff94c000}, {0xff94e000}, {0xff950000}, {0xff952000}, {0xff954000}, {0xff956000}, {0xff958000}, {0xff95a000}, {0xff95c000}, {0xff95e000}, {0xff960000}, {0xff962000}, {0xff964000}, {0xff966000}, {0xff968000}, {0xff96a000}, {0xff96c000}, {0xff96e000}, {0xff970000}, {0xff972000}, {0xff974000}, {0xff976000}, {0xff978000}, {0xff97a000}, {0xff97c000}, {0xff97e000}, {0xff980000}, {0xff982000}, {0xff984000}, {0xff986000}, {0xff988000}, {0xff98a000}, {0xff98c000}, {0xff98e000}, {0xff990000}, {0xff992000}, {0xff994000}, {0xff996000}, {0xff998000}, {0xff99a000}, {0xff99c000}, {0xff99e000}, {0xff9a0000}, {0xff9a2000}, {0xff9a4000}, {0xff9a6000}, {0xff9a8000}, {0xff9aa000}, {0xff9ac000}, {0xff9ae000}, {0xff9b0000}, {0xff9b2000}, {0xff9b4000}, {0xff9b6000}, {0xff9b8000}, {0xff9ba000}, {0xff9bc000}, {0xff9be000}, {0xff9c0000}, {0xff9c2000}, {0xff9c4000}, {0xff9c6000}, {0xff9c8000}, {0xff9ca000}, {0xff9cc000}, {0xff9ce000}, {0xff9d0000}, {0xff9d2000}, {0xff9d4000}, {0xff9d6000}, {0xff9d8000}, {0xff9da000}, {0xff9dc000}, {0xff9de000}, {0xff9e0000}, {0xff9e2000}, {0xff9e4000}, {0xff9e6000}, {0xff9e8000}, {0xff9ea000}, {0xff9ec000}, {0xff9ee000}, {0xff9f0000}, {0xff9f2000}, {0xff9f4000}, {0xff9f6000}, {0xff9f8000}, {0xff9fa000}, {0xff9fc000}, {0xff9fe000}, {0xffa00000}, {0xffa02000}, {0xffa04000}, {0xffa06000}, {0xffa08000}, {0xffa0a000}, {0xffa0c000}, {0xffa0e000}, {0xffa10000}, {0xffa12000}, {0xffa14000}, {0xffa16000}, {0xffa18000}, {0xffa1a000}, {0xffa1c000}, {0xffa1e000}, {0xffa20000}, {0xffa22000}, {0xffa24000}, {0xffa26000}, {0xffa28000}, {0xffa2a000}, {0xffa2c000}, {0xffa2e000}, {0xffa30000}, {0xffa32000}, {0xffa34000}, {0xffa36000}, {0xffa38000}, {0xffa3a000}, {0xffa3c000}, {0xffa3e000}, {0xffa40000}, {0xffa42000}, {0xffa44000}, {0xffa46000}, {0xffa48000}, {0xffa4a000}, {0xffa4c000}, {0xffa4e000}, {0xffa50000}, {0xffa52000}, {0xffa54000}, {0xffa56000}, {0xffa58000}, {0xffa5a000}, {0xffa5c000}, {0xffa5e000}, {0xffa60000}, {0xffa62000}, {0xffa64000}, {0xffa66000}, {0xffa68000}, {0xffa6a000}, {0xffa6c000}, {0xffa6e000}, {0xffa70000}, {0xffa72000}, {0xffa74000}, {0xffa76000}, {0xffa78000}, {0xffa7a000}, {0xffa7c000}, {0xffa7e000}, {0xffa80000}, {0xffa82000}, {0xffa84000}, {0xffa86000}, {0xffa88000}, {0xffa8a000}, {0xffa8c000}, {0xffa8e000}, {0xffa90000}, {0xffa92000}, {0xffa94000}, {0xffa96000}, {0xffa98000}, {0xffa9a000}, {0xffa9c000}, {0xffa9e000}, {0xffaa0000}, {0xffaa2000}, {0xffaa4000}, {0xffaa6000}, {0xffaa8000}, {0xffaaa000}, {0xffaac000}, {0xffaae000}, {0xffab0000}, {0xffab2000}, {0xffab4000}, {0xffab6000}, {0xffab8000}, {0xffaba000}, {0xffabc000}, {0xffabe000}, {0xffac0000}, {0xffac2000}, {0xffac4000}, {0xffac6000}, {0xffac8000}, {0xffaca000}, {0xffacc000}, {0xfface000}, {0xffad0000}, {0xffad2000}, {0xffad4000}, {0xffad6000}, {0xffad8000}, {0xffada000}, {0xffadc000}, {0xffade000}, {0xffae0000}, {0xffae2000}, {0xffae4000}, {0xffae6000}, {0xffae8000}, {0xffaea000}, {0xffaec000}, {0xffaee000}, {0xffaf0000}, {0xffaf2000}, {0xffaf4000}, {0xffaf6000}, {0xffaf8000}, {0xffafa000}, {0xffafc000}, {0xffafe000}, {0xffb00000}, {0xffb02000}, {0xffb04000}, {0xffb06000}, {0xffb08000}, {0xffb0a000}, {0xffb0c000}, {0xffb0e000}, {0xffb10000}, {0xffb12000}, {0xffb14000}, {0xffb16000}, {0xffb18000}, {0xffb1a000}, {0xffb1c000}, {0xffb1e000}, {0xffb20000}, {0xffb22000}, {0xffb24000}, {0xffb26000}, {0xffb28000}, {0xffb2a000}, {0xffb2c000}, {0xffb2e000}, {0xffb30000}, {0xffb32000}, {0xffb34000}, {0xffb36000}, {0xffb38000}, {0xffb3a000}, {0xffb3c000}, {0xffb3e000}, {0xffb40000}, {0xffb42000}, {0xffb44000}, {0xffb46000}, {0xffb48000}, {0xffb4a000}, {0xffb4c000}, {0xffb4e000}, {0xffb50000}, {0xffb52000}, {0xffb54000}, {0xffb56000}, {0xffb58000}, {0xffb5a000}, {0xffb5c000}, {0xffb5e000}, {0xffb60000}, {0xffb62000}, {0xffb64000}, {0xffb66000}, {0xffb68000}, {0xffb6a000}, {0xffb6c000}, {0xffb6e000}, {0xffb70000}, {0xffb72000}, {0xffb74000}, {0xffb76000}, {0xffb78000}, {0xffb7a000}, {0xffb7c000}, {0xffb7e000}, {0xffb80000}, {0xffb82000}, {0xffb84000}, {0xffb86000}, {0xffb88000}, {0xffb8a000}, {0xffb8c000}, {0xffb8e000}, {0xffb90000}, {0xffb92000}, {0xffb94000}, {0xffb96000}, {0xffb98000}, {0xffb9a000}, {0xffb9c000}, {0xffb9e000}, {0xffba0000}, {0xffba2000}, {0xffba4000}, {0xffba6000}, {0xffba8000}, {0xffbaa000}, {0xffbac000}, {0xffbae000}, {0xffbb0000}, {0xffbb2000}, {0xffbb4000}, {0xffbb6000}, {0xffbb8000}, {0xffbba000}, {0xffbbc000}, {0xffbbe000}, {0xffbc0000}, {0xffbc2000}, {0xffbc4000}, {0xffbc6000}, {0xffbc8000}, {0xffbca000}, {0xffbcc000}, {0xffbce000}, {0xffbd0000}, {0xffbd2000}, {0xffbd4000}, {0xffbd6000}, {0xffbd8000}, {0xffbda000}, {0xffbdc000}, {0xffbde000}, {0xffbe0000}, {0xffbe2000}, {0xffbe4000}, {0xffbe6000}, {0xffbe8000}, {0xffbea000}, {0xffbec000}, {0xffbee000}, {0xffbf0000}, {0xffbf2000}, {0xffbf4000}, {0xffbf6000}, {0xffbf8000}, {0xffbfa000}, {0xffbfc000}, {0xffbfe000}, {0xffc00000}, {0xffc02000}, {0xffc04000}, {0xffc06000}, {0xffc08000}, {0xffc0a000}, {0xffc0c000}, {0xffc0e000}, {0xffc10000}, {0xffc12000}, {0xffc14000}, {0xffc16000}, {0xffc18000}, {0xffc1a000}, {0xffc1c000}, {0xffc1e000}, {0xffc20000}, {0xffc22000}, {0xffc24000}, {0xffc26000}, {0xffc28000}, {0xffc2a000}, {0xffc2c000}, {0xffc2e000}, {0xffc30000}, {0xffc32000}, {0xffc34000}, {0xffc36000}, {0xffc38000}, {0xffc3a000}, {0xffc3c000}, {0xffc3e000}, {0xffc40000}, {0xffc42000}, {0xffc44000}, {0xffc46000}, {0xffc48000}, {0xffc4a000}, {0xffc4c000}, {0xffc4e000}, {0xffc50000}, {0xffc52000}, {0xffc54000}, {0xffc56000}, {0xffc58000}, {0xffc5a000}, {0xffc5c000}, {0xffc5e000}, {0xffc60000}, {0xffc62000}, {0xffc64000}, {0xffc66000}, {0xffc68000}, {0xffc6a000}, {0xffc6c000}, {0xffc6e000}, {0xffc70000}, {0xffc72000}, {0xffc74000}, {0xffc76000}, {0xffc78000}, {0xffc7a000}, {0xffc7c000}, {0xffc7e000}, {0xffc80000}, {0xffc82000}, {0xffc84000}, {0xffc86000}, {0xffc88000}, {0xffc8a000}, {0xffc8c000}, {0xffc8e000}, {0xffc90000}, {0xffc92000}, {0xffc94000}, {0xffc96000}, {0xffc98000}, {0xffc9a000}, {0xffc9c000}, {0xffc9e000}, {0xffca0000}, {0xffca2000}, {0xffca4000}, {0xffca6000}, {0xffca8000}, {0xffcaa000}, {0xffcac000}, {0xffcae000}, {0xffcb0000}, {0xffcb2000}, {0xffcb4000}, {0xffcb6000}, {0xffcb8000}, {0xffcba000}, {0xffcbc000}, {0xffcbe000}, {0xffcc0000}, {0xffcc2000}, {0xffcc4000}, {0xffcc6000}, {0xffcc8000}, {0xffcca000}, {0xffccc000}, {0xffcce000}, {0xffcd0000}, {0xffcd2000}, {0xffcd4000}, {0xffcd6000}, {0xffcd8000}, {0xffcda000}, {0xffcdc000}, {0xffcde000}, {0xffce0000}, {0xffce2000}, {0xffce4000}, {0xffce6000}, {0xffce8000}, {0xffcea000}, {0xffcec000}, {0xffcee000}, {0xffcf0000}, {0xffcf2000}, {0xffcf4000}, {0xffcf6000}, {0xffcf8000}, {0xffcfa000}, {0xffcfc000}, {0xffcfe000}, {0xffd00000}, {0xffd02000}, {0xffd04000}, {0xffd06000}, {0xffd08000}, {0xffd0a000}, {0xffd0c000}, {0xffd0e000}, {0xffd10000}, {0xffd12000}, {0xffd14000}, {0xffd16000}, {0xffd18000}, {0xffd1a000}, {0xffd1c000}, {0xffd1e000}, {0xffd20000}, {0xffd22000}, {0xffd24000}, {0xffd26000}, {0xffd28000}, {0xffd2a000}, {0xffd2c000}, {0xffd2e000}, {0xffd30000}, {0xffd32000}, {0xffd34000}, {0xffd36000}, {0xffd38000}, {0xffd3a000}, {0xffd3c000}, {0xffd3e000}, {0xffd40000}, {0xffd42000}, {0xffd44000}, {0xffd46000}, {0xffd48000}, {0xffd4a000}, {0xffd4c000}, {0xffd4e000}, {0xffd50000}, {0xffd52000}, {0xffd54000}, {0xffd56000}, {0xffd58000}, {0xffd5a000}, {0xffd5c000}, {0xffd5e000}, {0xffd60000}, {0xffd62000}, {0xffd64000}, {0xffd66000}, {0xffd68000}, {0xffd6a000}, {0xffd6c000}, {0xffd6e000}, {0xffd70000}, {0xffd72000}, {0xffd74000}, {0xffd76000}, {0xffd78000}, {0xffd7a000}, {0xffd7c000}, {0xffd7e000}, {0xffd80000}, {0xffd82000}, {0xffd84000}, {0xffd86000}, {0xffd88000}, {0xffd8a000}, {0xffd8c000}, {0xffd8e000}, {0xffd90000}, {0xffd92000}, {0xffd94000}, {0xffd96000}, {0xffd98000}, {0xffd9a000}, {0xffd9c000}, {0xffd9e000}, {0xffda0000}, {0xffda2000}, {0xffda4000}, {0xffda6000}, {0xffda8000}, {0xffdaa000}, {0xffdac000}, {0xffdae000}, {0xffdb0000}, {0xffdb2000}, {0xffdb4000}, {0xffdb6000}, {0xffdb8000}, {0xffdba000}, {0xffdbc000}, {0xffdbe000}, {0xffdc0000}, {0xffdc2000}, {0xffdc4000}, {0xffdc6000}, {0xffdc8000}, {0xffdca000}, {0xffdcc000}, {0xffdce000}, {0xffdd0000}, {0xffdd2000}, {0xffdd4000}, {0xffdd6000}, {0xffdd8000}, {0xffdda000}, {0xffddc000}, {0xffdde000}, {0xffde0000}, {0xffde2000}, {0xffde4000}, {0xffde6000}, {0xffde8000}, {0xffdea000}, {0xffdec000}, {0xffdee000}, {0xffdf0000}, {0xffdf2000}, {0xffdf4000}, {0xffdf6000}, {0xffdf8000}, {0xffdfa000}, {0xffdfc000}, {0xffdfe000}, {0xffe00000}, {0xffe02000}, {0xffe04000}, {0xffe06000}, {0xffe08000}, {0xffe0a000}, {0xffe0c000}, {0xffe0e000}, {0xffe10000}, {0xffe12000}, {0xffe14000}, {0xffe16000}, {0xffe18000}, {0xffe1a000}, {0xffe1c000}, {0xffe1e000}, {0xffe20000}, {0xffe22000}, {0xffe24000}, {0xffe26000}, {0xffe28000}, {0xffe2a000}, {0xffe2c000}, {0xffe2e000}, {0xffe30000}, {0xffe32000}, {0xffe34000}, {0xffe36000}, {0xffe38000}, {0xffe3a000}, {0xffe3c000}, {0xffe3e000}, {0xffe40000}, {0xffe42000}, {0xffe44000}, {0xffe46000}, {0xffe48000}, {0xffe4a000}, {0xffe4c000}, {0xffe4e000}, {0xffe50000}, {0xffe52000}, {0xffe54000}, {0xffe56000}, {0xffe58000}, {0xffe5a000}, {0xffe5c000}, {0xffe5e000}, {0xffe60000}, {0xffe62000}, {0xffe64000}, {0xffe66000}, {0xffe68000}, {0xffe6a000}, {0xffe6c000}, {0xffe6e000}, {0xffe70000}, {0xffe72000}, {0xffe74000}, {0xffe76000}, {0xffe78000}, {0xffe7a000}, {0xffe7c000}, {0xffe7e000}, {0xffe80000}, {0xffe82000}, {0xffe84000}, {0xffe86000}, {0xffe88000}, {0xffe8a000}, {0xffe8c000}, {0xffe8e000}, {0xffe90000}, {0xffe92000}, {0xffe94000}, {0xffe96000}, {0xffe98000}, {0xffe9a000}, {0xffe9c000}, {0xffe9e000}, {0xffea0000}, {0xffea2000}, {0xffea4000}, {0xffea6000}, {0xffea8000}, {0xffeaa000}, {0xffeac000}, {0xffeae000}, {0xffeb0000}, {0xffeb2000}, {0xffeb4000}, {0xffeb6000}, {0xffeb8000}, {0xffeba000}, {0xffebc000}, {0xffebe000}, {0xffec0000}, {0xffec2000}, {0xffec4000}, {0xffec6000}, {0xffec8000}, {0xffeca000}, {0xffecc000}, {0xffece000}, {0xffed0000}, {0xffed2000}, {0xffed4000}, {0xffed6000}, {0xffed8000}, {0xffeda000}, {0xffedc000}, {0xffede000}, {0xffee0000}, {0xffee2000}, {0xffee4000}, {0xffee6000}, {0xffee8000}, {0xffeea000}, {0xffeec000}, {0xffeee000}, {0xffef0000}, {0xffef2000}, {0xffef4000}, {0xffef6000}, {0xffef8000}, {0xffefa000}, {0xffefc000}, {0xffefe000}, {0xfff00000}, {0xfff02000}, {0xfff04000}, {0xfff06000}, {0xfff08000}, {0xfff0a000}, {0xfff0c000}, {0xfff0e000}, {0xfff10000}, {0xfff12000}, {0xfff14000}, {0xfff16000}, {0xfff18000}, {0xfff1a000}, {0xfff1c000}, {0xfff1e000}, {0xfff20000}, {0xfff22000}, {0xfff24000}, {0xfff26000}, {0xfff28000}, {0xfff2a000}, {0xfff2c000}, {0xfff2e000}, {0xfff30000}, {0xfff32000}, {0xfff34000}, {0xfff36000}, {0xfff38000}, {0xfff3a000}, {0xfff3c000}, {0xfff3e000}, {0xfff40000}, {0xfff42000}, {0xfff44000}, {0xfff46000}, {0xfff48000}, {0xfff4a000}, {0xfff4c000}, {0xfff4e000}, {0xfff50000}, {0xfff52000}, {0xfff54000}, {0xfff56000}, {0xfff58000}, {0xfff5a000}, {0xfff5c000}, {0xfff5e000}, {0xfff60000}, {0xfff62000}, {0xfff64000}, {0xfff66000}, {0xfff68000}, {0xfff6a000}, {0xfff6c000}, {0xfff6e000}, {0xfff70000}, {0xfff72000}, {0xfff74000}, {0xfff76000}, {0xfff78000}, {0xfff7a000}, {0xfff7c000}, {0xfff7e000}, {0xfff80000}, {0xfff82000}, {0xfff84000}, {0xfff86000}, {0xfff88000}, {0xfff8a000}, {0xfff8c000}, {0xfff8e000}, {0xfff90000}, {0xfff92000}, {0xfff94000}, {0xfff96000}, {0xfff98000}, {0xfff9a000}, {0xfff9c000}, {0xfff9e000}, {0xfffa0000}, {0xfffa2000}, {0xfffa4000}, {0xfffa6000}, {0xfffa8000}, {0xfffaa000}, {0xfffac000}, {0xfffae000}, {0xfffb0000}, {0xfffb2000}, {0xfffb4000}, {0xfffb6000}, {0xfffb8000}, {0xfffba000}, {0xfffbc000}, {0xfffbe000}, {0xfffc0000}, {0xfffc2000}, {0xfffc4000}, {0xfffc6000}, {0xfffc8000}, {0xfffca000}, {0xfffcc000}, {0xfffce000}, {0xfffd0000}, {0xfffd2000}, {0xfffd4000}, {0xfffd6000}, {0xfffd8000}, {0xfffda000}, {0xfffdc000}, {0xfffde000}, {0xfffe0000}, {0xfffe2000}, {0xfffe4000}, {0xfffe6000}, {0xfffe8000}, {0xfffea000}, {0xfffec000}, {0xfffee000}, {0xffff0000}, {0xffff2000}, {0xffff4000}, {0xffff6000}, {0xffff8000}, {0xffffa000}, {0xffffc000}, {0xffffe000}, }; // clang-format on Imath-3.1.4/src/ImathTest/000077500000000000000000000000001417213455000152545ustar00rootroot00000000000000Imath-3.1.4/src/ImathTest/.cvsignore000066400000000000000000000002451417213455000172550ustar00rootroot00000000000000Makefile Makefile.in config.h.in config.h config.log config.status configure libtool stamp-h aclocal.m4 OpenEXR.pc autom4te.cache ltmain.sh stamp-h.in depcomp .deps Imath-3.1.4/src/ImathTest/CMakeLists.txt000066400000000000000000000053421417213455000200200ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. if("${CMAKE_PROJECT_NAME}" STREQUAL "") # If the project name is set, this is being configured as a part of # Imath. If there is no project name, it's being configured as a # standalone program linking against an already-installed Imath # library. cmake_minimum_required(VERSION 3.12) project(ImathTest) find_package(Imath) endif() add_executable(ImathTest main.cpp testBox.cpp testBoxAlgo.cpp testColor.cpp testExtractEuler.cpp testExtractSHRT.cpp testFrustum.cpp testFrustumTest.cpp testFun.cpp testInterval.cpp testInvert.cpp testJacobiEigenSolver.cpp testLineAlgo.cpp testMatrix.cpp testMiscMatrixAlgo.cpp testProcrustes.cpp testQuat.cpp testQuatSetRotation.cpp testQuatSlerp.cpp testRandom.cpp testRoots.cpp testShear.cpp testTinySVD.cpp testVec.cpp testArithmetic.cpp testBitPatterns.cpp testClassification.cpp testError.cpp testFunction.cpp testLimits.cpp testSize.cpp testToFloat.cpp testInterop.cpp ) target_link_libraries(ImathTest Imath::Imath) set_target_properties(ImathTest PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" ) if(NOT "${CMAKE_PROJECT_NAME}" STREQUAL "ImathTest") add_executable(ImathHalfCTest half_c_main.c) target_link_libraries(ImathHalfCTest Imath::Config) target_include_directories(ImathHalfCTest PRIVATE "../Imath") #target_compile_options(ImathHalfCTest PRIVATE -mavx2 -mf16c) if (IMATH_USE_HALF_LOOKUP_TABLE) target_link_libraries(ImathHalfCTest Imath::Imath) endif() set_target_properties(ImathHalfCTest PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" ) add_test(NAME Imath.half_c_only COMMAND $) endif() add_executable(ImathHalfPerfTest half_perf_test.cpp) set_target_properties(ImathHalfPerfTest PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" ) target_link_libraries(ImathHalfPerfTest Imath::Imath) function(DEFINE_IMATH_TESTS) foreach(curtest IN LISTS ARGN) add_test(NAME Imath.${curtest} COMMAND $ ${curtest}) endforeach() endfunction() define_imath_tests( testToFloat testSize testArithmetic testNormalizedConversionError testDenormalizedConversionError testRoundingError testBitPatterns testClassification testLimits testHalfLimits testFunction testVec testColor testShear testMatrix testMiscMatrixAlgo testRoots testFun testInvert testInterval testFrustum testRandom testExtractEuler testExtractSHRT testQuat testQuatSetRotation testQuatSlerp testLineAlgo testBoxAlgo testBox testProcrustes testTinySVD testJacobiEigenSolver testFrustumTest testInterop ) Imath-3.1.4/src/ImathTest/eLut.h000066400000000000000000000100211417213455000163300ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // // This is an automatically generated file. // Do not edit. // // clang-format off { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1024, 2048, 3072, 4096, 5120, 6144, 7168, 8192, 9216, 10240, 11264, 12288, 13312, 14336, 15360, 16384, 17408, 18432, 19456, 20480, 21504, 22528, 23552, 24576, 25600, 26624, 27648, 28672, 29696, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 33792, 34816, 35840, 36864, 37888, 38912, 39936, 40960, 41984, 43008, 44032, 45056, 46080, 47104, 48128, 49152, 50176, 51200, 52224, 53248, 54272, 55296, 56320, 57344, 58368, 59392, 60416, 61440, 62464, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; // clang-format on Imath-3.1.4/src/ImathTest/half_c_main.c000066400000000000000000000135331417213455000176450ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // For the C version test, omit the lookup table, which validates that // ``half.h`` works as a "header-only" implementation not requiring // the compiled library. Note that the C-language support for half // only includes conversion to and from float. #define IMATH_HALF_NO_LOOKUP_TABLE #include #include #include #include typedef union { uint32_t i; float f; } c_half_uif; static const c_half_uif half_to_float[1 << 16] = #include "../Imath/toFloat.h" static const unsigned short half_eLut[1 << 9] = #include "eLut.h" static short exp_long_convert (int i) { int s = (i >> 16) & 0x00008000; int e = ((i >> 23) & 0x000000ff) - (127 - 15); int m = i & 0x007fffff; //fprintf( stderr, "old_convert: s %d e = %d, m = %d\n", s, e, m ); if (e <= 0) { if (e < -10) { return s; } m = m | 0x00800000; int t = 14 - e; int a = (1 << (t - 1)) - 1; int b = (m >> t) & 1; m = (m + a + b) >> t; //fprintf( stderr, " e %d, m: 0x%08X, t %d, a: %d 0x%08X, b: %d 0x%08X\n", e, m, t, a, a, b, b ); return s | m; } else if (e == 0xff - (127 - 15)) { if (m == 0) { return s | 0x7c00; } else { m >>= 13; return s | 0x7c00 | m | (m == 0); } } else { m = m + 0x00000fff + ((m >> 13) & 1); if (m & 0x00800000) { m = 0; // overflow in significand, e += 1; // adjust exponent } if (e > 30) { return s | 0x7c00; // if this returns, the half becomes an } // infinity with the same sign as f. return s | (e << 10) | (m >> 13); } } static uint16_t exptable_method (float f) { c_half_uif x; uint16_t _h = 0; x.f = f; if (f == 0) { // // Common special case - zero. // Preserve the zero's sign bit. // _h = (x.i >> 16); } else { // // We extract the combined sign and exponent, e, from our // floating-point number, f. Then we convert e to the sign // and exponent of the half number via a table lookup. // // For the most common case, where a normalized half is produced, // the table lookup returns a non-zero value; in this case, all // we have to do is round f's significand to 10 bits and combine // the result with e. // // For all other cases (overflow, zeroes, denormalized numbers // resulting from underflow, infinities and NANs), the table // lookup returns zero, and we call a longer, non-inline function // to do the float-to-half conversion. // int e = (x.i >> 23) & 0x000001ff; e = half_eLut[e]; if (e) { // // Simple case - round the significand, m, to 10 // bits and combine it with the sign and exponent. // int m = x.i & 0x007fffff; _h = e + ((m + 0x00000fff + ((m >> 13) & 1)) >> 13); } else { // // Difficult case - call a function. // _h = exp_long_convert (x.i); } } return _h; } int main (int argc, char* argv[]) { int ret = 0; c_half_uif conv; half test, test2; conv.f = HALF_DENORM_MIN + HALF_DENORM_MIN * 0.5f; test = imath_float_to_half (conv.f); test2 = exptable_method (conv.f); if (test != test2) { fprintf (stderr, "Invalid conversion of %.10g 0x%08X 0x%08X downconvert 0x%04X vs 0x%04X\n", conv.f, (conv.i >> 13) & 0x3ff, (conv.i >> 13) & 0x3ff, test, test2); ret = 1; } int diffcount = 0; for (int i = 0; i < (1 << 16); ++i) { conv.f = imath_half_to_float ((half) i); if (conv.i != half_to_float[i].i) { uint16_t h = (uint16_t) i; uint16_t he = (h >> 10) & 0x1f; uint16_t hm = (h & 0x3ff); #ifdef __F16C__ // the intel instructions do something different w/ NaN values than the original half library if (he == 0x1f && isnan (conv.f)) { ++diffcount; continue; } #endif fprintf ( stderr, "half to float %d: C gives %.10f (0x%08X) vs %.10f (0x%08X) [h 0x%04X he 0x%04X hm 0x%04X]\n", i, conv.f, conv.i, half_to_float[i].f, half_to_float[i].i, h, he, hm); ret = 1; } } if (diffcount != 0) fprintf ( stderr, "WARNING: Seems safe, but %d NaN values were different between hardware implementation and library implementation\n", diffcount); for (int i = 0; i < (1 << 16); ++i) { conv = half_to_float[i]; test = imath_float_to_half (conv.f); if (test != i) { // well, we ensure that nan stays nan after conversion by // adding a low bit, so it won't always align int e = (conv.i >> 23) & 0xff; int m = (conv.i & 0x007fffff); if (e == 255 && m != 0) continue; fprintf (stderr, "float to half %d: %.10f (0x%08X) gives %d 0x%04X (e is %d)\n", i, conv.f, conv.i, (int) test, test, e); ret = 1; } } return ret; } Imath-3.1.4/src/ImathTest/half_perf_test.cpp000066400000000000000000000242731417213455000207550ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef _MSC_VER # define _CRT_RAND_S #endif #include #include #include #include #include #include #ifdef _MSC_VER # include #else # include #endif #include static const unsigned short imath_float_half_exp_table[1 << 9] = #include "eLut.h" using namespace IMATH_NAMESPACE; #ifdef IMATH_USE_HALF_LOOKUP_TABLE static inline float table_half_cast(const half &h) { return imath_half_to_float_table[h.bits()].f; } //----------------------------------------------- // Overflow handler for float-to-half conversion; // generates a hardware floating-point overflow, // which may be trapped by the operating system. //----------------------------------------------- static float half_overflow() { float f = 1e10; for (int i = 0; i < 10; i++) f *= f; // this will overflow before the for loop terminates return f; } //----------------------------------------------------- // Float-to-half conversion -- general case, including // zeroes, denormalized numbers and exponent overflows. //----------------------------------------------------- static uint16_t long_convert (int i) { // // Our floating point number, f, is represented by the bit // pattern in integer i. Disassemble that bit pattern into // the sign, s, the exponent, e, and the significand, m. // Shift s into the position where it will go in in the // resulting half number. // Adjust e, accounting for the different exponent bias // of float and half (127 versus 15). // int s = (i >> 16) & 0x00008000; int e = ((i >> 23) & 0x000000ff) - (127 - 15); int m = i & 0x007fffff; // // Now reassemble s, e and m into a half: // if (e <= 0) { if (e < -10) { // // E is less than -10. The absolute value of f is // less than HALF_DENORM_MIN (f may be a small normalized // float, a denormalized float or a zero). // // We convert f to a half zero with the same sign as f. // return s; } // // E is between -10 and 0. F is a normalized float // whose magnitude is less than HALF_NRM_MIN. // // We convert f to a denormalized half. // // // Add an explicit leading 1 to the significand. // m = m | 0x00800000; // // Round to m to the nearest (10+e)-bit value (with e between // -10 and 0); in case of a tie, round to the nearest even value. // // Rounding may cause the significand to overflow and make // our number normalized. Because of the way a half's bits // are laid out, we don't have to treat this case separately; // the code below will handle it correctly. // int t = 14 - e; int a = (1 << (t - 1)) - 1; int b = (m >> t) & 1; m = (m + a + b) >> t; // // Assemble the half from s, e (zero) and m. // return s | m; } else if (e == 0xff - (127 - 15)) { if (m == 0) { // // F is an infinity; convert f to a half // infinity with the same sign as f. // return s | 0x7c00; } else { // // F is a NAN; we produce a half NAN that preserves // the sign bit and the 10 leftmost bits of the // significand of f, with one exception: If the 10 // leftmost bits are all zero, the NAN would turn // into an infinity, so we have to set at least one // bit in the significand. // m >>= 13; return s | 0x7c00 | m | (m == 0); } } else { // // E is greater than zero. F is a normalized float. // We try to convert f to a normalized half. // // // Round to m to the nearest 10-bit value. In case of // a tie, round to the nearest even value. // m = m + 0x00000fff + ((m >> 13) & 1); if (m & 0x00800000) { m = 0; // overflow in significand, e += 1; // adjust exponent } // // Handle exponent overflow // if (e > 30) { half_overflow (); // Cause a hardware floating point overflow; return s | 0x7c00; // if this returns, the half becomes an } // infinity with the same sign as f. // // Assemble the half from s, e and m. // return s | (e << 10) | (m >> 13); } } static inline half exptable_half_constructor(float f) { half ret; imath_half_uif x; x.f = f; if (f == 0) { // // Common special case - zero. // Preserve the zero's sign bit. // ret.setBits( (x.i >> 16) ); } else { // // We extract the combined sign and exponent, e, from our // floating-point number, f. Then we convert e to the sign // and exponent of the half number via a table lookup. // // For the most common case, where a normalized half is produced, // the table lookup returns a non-zero value; in this case, all // we have to do is round f's significand to 10 bits and combine // the result with e. // // For all other cases (overflow, zeroes, denormalized numbers // resulting from underflow, infinities and NANs), the table // lookup returns zero, and we call a longer, non-inline function // to do the float-to-half conversion. // int e = (x.i >> 23) & 0x000001ff; e = imath_float_half_exp_table[e]; if (e) { // // Simple case - round the significand, m, to 10 // bits and combine it with the sign and exponent. // int m = x.i & 0x007fffff; ret.setBits (e + ((m + 0x00000fff + ((m >> 13) & 1)) >> 13)); } else { // // Difficult case - call a function. // ret.setBits (long_convert (x.i)); } } return ret; } #else // provide a wrapping function for consistency/readability static inline float table_half_cast(const half &h) { return static_cast( h ); } static inline half exptable_half_constructor(float f) { return half {f}; } #endif int64_t get_ticks (void) { #ifdef _MSC_VER static uint64_t scale = 0; if (scale == 0) { LARGE_INTEGER freq; QueryPerformanceFrequency (&freq); scale = (1000000000 / freq.QuadPart); } LARGE_INTEGER ticks; QueryPerformanceCounter (&ticks); return ticks.QuadPart * scale; #else struct timespec t; uint64_t nsecs; static uint64_t start = 0; if (start == 0) { clock_gettime (CLOCK_MONOTONIC, &t); start = t.tv_sec; } clock_gettime (CLOCK_MONOTONIC, &t); nsecs = (t.tv_sec - start) * 1000000000; nsecs += t.tv_nsec; return nsecs; #endif } void perf_test_half_to_float (float* floats, const uint16_t* halfs, int numentries) { const half* halfvals = reinterpret_cast (halfs); int64_t st = get_ticks(); for (int i = 0; i < numentries; ++i) floats[i] = imath_half_to_float (halfs[i]); int64_t et = get_ticks(); int64_t ost = get_ticks(); for (int i = 0; i < numentries; ++i) floats[i] = table_half_cast (halfvals[i]); int64_t oet = get_ticks(); int64_t onanos = (oet - ost); int64_t nnanos = (et - st); fprintf (stderr, "half -> float Old: %10lld (%g ns) New: %10lld (%g ns) (%10lld)\n", (long long) onanos, (double) onanos / ((double) numentries), (long long) nnanos, (double) nnanos / ((double) numentries), ((long long) (onanos - nnanos))); } void perf_test_float_to_half (uint16_t* halfs, const float* floats, int numentries) { half* halfvals = reinterpret_cast (halfs); int64_t st = get_ticks(); for (int i = 0; i < numentries; ++i) halfs[i] = imath_float_to_half (floats[i]); int64_t et = get_ticks(); int64_t ost = get_ticks(); for (int i = 0; i < numentries; ++i) halfvals[i] = exptable_half_constructor (floats[i]); int64_t oet = get_ticks(); int64_t onanos = (oet - ost); int64_t nnanos = (et - st); fprintf (stderr, "float -> half Old: %10lld (%g ns) New: %10lld (%g ns) (%10lld)\n", (long long) onanos, (double) onanos / ((double) numentries), (long long) nnanos, (double) nnanos / ((double) numentries), ((long long) (onanos - nnanos))); } int main (int argc, char* argv[]) { int ret = 0; int numentries = 1920 * 1080 * 3; if (argc > 1) { numentries = atoi (argv[1]); if (numentries <= 0) { fprintf (stderr, "Bad entry count '%s'\n", argv[1]); ret = 1; } } if (numentries > 0) { uint16_t* halfs = new uint16_t[numentries]; float* floats = new float[numentries]; if (halfs && floats) { srand (numentries); for (int i = 0; i < numentries; ++i) { halfs[i] = (uint16_t) (rand()); floats[i] = imath_half_to_float (halfs[i]); } perf_test_half_to_float (floats, halfs, numentries); // test float -> half with real-world values #ifdef _MSC_VER unsigned int rv; for (int i = 0; i < numentries; ++i) { rand_s( &rv ); floats[i] = 65504.0 * (((double) rand() / (double) UINT_MAX) * 2.0 - 1.0); } #else for (int i = 0; i < numentries; ++i) floats[i] = 65504.0 * (drand48() * 2.0 - 1.0); #endif perf_test_float_to_half (halfs, floats, numentries); } delete[] halfs; delete[] floats; } return ret; } Imath-3.1.4/src/ImathTest/main.cpp000066400000000000000000000046241417213455000167120ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include "testArithmetic.h" #include "testBitPatterns.h" #include "testClassification.h" #include "testError.h" #include "testFunction.h" #include "testLimits.h" #include "testSize.h" #include "testToFloat.h" #include "testBox.h" #include "testBoxAlgo.h" #include "testColor.h" #include "testExtractEuler.h" #include "testExtractSHRT.h" #include "testFrustum.h" #include "testFrustumTest.h" #include "testFun.h" #include "testInterop.h" #include "testInterval.h" #include "testInvert.h" #include "testJacobiEigenSolver.h" #include "testLineAlgo.h" #include "testMatrix.h" #include "testMiscMatrixAlgo.h" #include "testProcrustes.h" #include "testQuat.h" #include "testQuatSetRotation.h" #include "testQuatSlerp.h" #include "testRandom.h" #include "testRoots.h" #include "testShear.h" #include "testTinySVD.h" #include "testVec.h" #include #include #define TEST(x) \ if (argc < 2 || !strcmp (argv[1], #x)) \ x(); int main (int argc, char* argv[]) { // NB: If you add a test here, make sure to enumerate it in the // CMakeLists.txt so it runs as part of the test suite TEST (testToFloat); TEST (testSize); TEST (testArithmetic); TEST (testNormalizedConversionError); TEST (testDenormalizedConversionError); TEST (testRoundingError); TEST (testBitPatterns); TEST (testClassification); TEST (testLimits); TEST (testHalfLimits); TEST (testFunction); TEST (testVec); TEST (testColor); TEST (testShear); TEST (testMatrix); TEST (testMiscMatrixAlgo); TEST (testRoots); TEST (testFun); TEST (testInvert); TEST (testInterval); TEST (testFrustum); TEST (testRandom); TEST (testExtractEuler); TEST (testExtractSHRT); TEST (testQuat); TEST (testQuatSetRotation); TEST (testQuatSlerp); TEST (testLineAlgo); TEST (testBoxAlgo); TEST (testBox); TEST (testProcrustes); TEST (testTinySVD); TEST (testJacobiEigenSolver); TEST (testFrustumTest); TEST (testInterop); // NB: If you add a test here, make sure to enumerate it in the // CMakeLists.txt so it runs as part of the test suite return 0; } Imath-3.1.4/src/ImathTest/testArithmetic.cpp000066400000000000000000000021141417213455000207470ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include "testArithmetic.h" using namespace std; void testArithmetic() { cout << "basic arithmetic operations:\n"; float f1 (1); float f2 (2); half h1 (3); half h2 (4); cout << "f1 = " << f1 << ", " "f2 = " << f2 << ", " "h1 = " << h1 << ", " "h2 = " << h2 << endl; h1 = f1 + f2; assert (h1 == 3); cout << "h1 = f1 + f2: " << h1 << endl; h2 += f1; assert (h2 == 5); cout << "h2 += f1: " << h2 << endl; h2 = h1 + h2; assert (h2 == 8); cout << "h2 = h1 + h2: " << h2 << endl; h2 += h1; assert (h2 == 11); cout << "h2 += h1: " << h2 << endl; h1 = h2; assert (h1 == 11); cout << "h1 = h2: " << h1 << endl; h2 = -h1; assert (h2 == -11); cout << "h2 = -h1: " << h2 << endl; cout << "ok\n\n" << flush; } Imath-3.1.4/src/ImathTest/testArithmetic.h000066400000000000000000000001711417213455000204150ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testArithmetic(); Imath-3.1.4/src/ImathTest/testBitPatterns.cpp000066400000000000000000000364761417213455000211370ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include "testBitPatterns.h" using namespace std; namespace { bool equalBitPatterns (const char* b1, const char* b2) { // // Returns true if the characters in zero-terminated string b1 // are the same as the charaters in string b2, except for places // where b1 or b2 contains an 'X'. For example: // // equalBitPatterns ("100", "100") returns true // equalBitPatterns ("100", "101") returns false // equalBitPatterns ("10X", "101") returns true // equalBitPatterns ("10X", "100") returns true // while (*b1 && *b2) { if (*b1 != *b2 && *b1 != 'X' && *b2 != 'X') return false; ++b1; ++b2; } return !(*b1 || *b2); } void testBits (float f, const char bh[19], const char bg[35]) { half h (f); float g (h); cout.width (15); cout.precision (8); cout << f << " "; printBits (cout, f); cout << " "; printBits (cout, h); cout << '\n'; cout.width (15); cout << g << " "; printBits (cout, g); cout << "\n\n"; if (bh || bg) { char ch[19], cg[35]; printBits (ch, h); printBits (cg, g); if (!equalBitPatterns (ch, bh)) { cout << "error: expected " << bh << ", got " << ch << endl; assert (false); } if (!equalBitPatterns (cg, bg)) { cout << "error: expected " << bg << ", got " << cg << endl; assert (false); } } } float floatPosInfinity() { half::uif x; x.i = 0x7f800000; return x.f; } float floatNegInfinity() { half::uif x; x.i = 0xff800000; return x.f; } float floatPosQNan1() { half::uif x; x.i = 0x7fffffff; return x.f; } float floatNegQNan1() { half::uif x; x.i = 0xffffffff; return x.f; } float floatPosQNan2() { half::uif x; x.i = 0x7fd55555; return x.f; } float floatNegQNan2() { half::uif x; x.i = 0xffd55555; return x.f; } } // namespace void testBitPatterns() { cout << "specific bit patterns\n\n"; // // Numbers close to 1.0 // testBits (1.0f, "0 01111 0000000000", "0 01111111 00000000000000000000000"); testBits (1.0f + HALF_EPSILON, "0 01111 0000000001", "0 01111111 00000000010000000000000"); testBits (1.0f + HALF_EPSILON * 0.5f, "0 01111 0000000000", "0 01111111 00000000000000000000000"); testBits (1.0f + HALF_EPSILON * 0.4999f, "0 01111 0000000000", "0 01111111 00000000000000000000000"); testBits (1.0f + HALF_EPSILON * 0.5001f, "0 01111 0000000001", "0 01111111 00000000010000000000000"); testBits (1.0f + HALF_EPSILON + HALF_EPSILON, "0 01111 0000000010", "0 01111111 00000000100000000000000"); testBits (1.0f + HALF_EPSILON + HALF_EPSILON * 0.5f, "0 01111 0000000010", "0 01111111 00000000100000000000000"); testBits (1.0f + HALF_EPSILON + HALF_EPSILON * 0.4999f, "0 01111 0000000001", "0 01111111 00000000010000000000000"); testBits (1.0f + HALF_EPSILON + HALF_EPSILON * 0.5001f, "0 01111 0000000010", "0 01111111 00000000100000000000000"); testBits (1.0f - HALF_EPSILON * 0.5f, "0 01110 1111111111", "0 01111110 11111111110000000000000"); testBits (1.0f - HALF_EPSILON * 0.5f * 0.5f, "0 01111 0000000000", "0 01111111 00000000000000000000000"); testBits (1.0f - HALF_EPSILON * 0.5f * 0.4999f, "0 01111 0000000000", "0 01111111 00000000000000000000000"); testBits (1.0f - HALF_EPSILON * 0.5f * 0.5001f, "0 01110 1111111111", "0 01111110 11111111110000000000000"); // // Numbers close to HALF_DENORM_MIN // testBits (HALF_DENORM_MIN, "0 00000 0000000001", "0 01100111 00000000000000000000000"); testBits (HALF_DENORM_MIN + HALF_DENORM_MIN, "0 00000 0000000010", "0 01101000 00000000000000000000000"); testBits (HALF_DENORM_MIN + HALF_DENORM_MIN * 0.5f, "0 00000 0000000010", "0 01101000 00000000000000000000000"); testBits (HALF_DENORM_MIN + HALF_DENORM_MIN * 0.4999f, "0 00000 0000000001", "0 01100111 00000000000000000000000"); testBits (HALF_DENORM_MIN + HALF_DENORM_MIN * 0.5001f, "0 00000 0000000010", "0 01101000 00000000000000000000000"); testBits (HALF_DENORM_MIN - HALF_DENORM_MIN, // NOSONAR - suppress SonarCloud bug report. "0 00000 0000000000", "0 00000000 00000000000000000000000"); testBits (HALF_DENORM_MIN - HALF_DENORM_MIN * 0.5f, "0 00000 0000000000", "0 00000000 00000000000000000000000"); testBits (HALF_DENORM_MIN - HALF_DENORM_MIN * 0.4999f, "0 00000 0000000001", "0 01100111 00000000000000000000000"); testBits (HALF_DENORM_MIN - HALF_DENORM_MIN * 0.5001f, "0 00000 0000000000", "0 00000000 00000000000000000000000"); // // Numbers close to HALF_NRM_MIN // testBits (HALF_NRM_MIN, "0 00001 0000000000", "0 01110001 00000000000000000000000"); testBits (HALF_NRM_MIN + HALF_DENORM_MIN, "0 00001 0000000001", "0 01110001 00000000010000000000000"); testBits (HALF_NRM_MIN + HALF_DENORM_MIN * 0.5f, "0 00001 0000000000", "0 01110001 00000000000000000000000"); testBits (HALF_NRM_MIN + HALF_DENORM_MIN * 0.4999f, "0 00001 0000000000", "0 01110001 00000000000000000000000"); testBits (HALF_NRM_MIN + HALF_DENORM_MIN * 0.5001f, "0 00001 0000000001", "0 01110001 00000000010000000000000"); testBits (HALF_NRM_MIN - HALF_DENORM_MIN, "0 00000 1111111111", "0 01110000 11111111100000000000000"); testBits (HALF_NRM_MIN - HALF_DENORM_MIN * 0.5f, "0 00001 0000000000", "0 01110001 00000000000000000000000"); testBits (HALF_NRM_MIN - HALF_DENORM_MIN * 0.49995f, "0 00001 0000000000", "0 01110001 00000000000000000000000"); testBits (HALF_NRM_MIN - HALF_DENORM_MIN * 0.50005f, "0 00000 1111111111", "0 01110000 11111111100000000000000"); // // Small positive integers and simple decimal fractions // testBits (2, "0 10000 0000000000", "0 10000000 00000000000000000000000"); testBits (3, "0 10000 1000000000", "0 10000000 10000000000000000000000"); testBits (10, "0 10010 0100000000", "0 10000010 01000000000000000000000"); testBits (0.1f, "0 01011 1001100110", "0 01111011 10011001100000000000000"); testBits (0.2f, "0 01100 1001100110", "0 01111100 10011001100000000000000"); testBits (0.3f, "0 01101 0011001101", "0 01111101 00110011010000000000000"); // // Numbers close to HALF_MAX // testBits (HALF_MAX, "0 11110 1111111111", "0 10001110 11111111110000000000000"); testBits ((1 << HALF_MAX_EXP) * 1.0, "0 11111 0000000000", // +infinity "0 11111111 00000000000000000000000"); // +infinity testBits ((1 << HALF_MAX_EXP) * (1.0f - HALF_EPSILON * 0.25f), "0 11111 0000000000", // +infinity "0 11111111 00000000000000000000000"); // +infinity testBits ((1 << HALF_MAX_EXP) * (1.0f - HALF_EPSILON * 0.25005f), "0 11110 1111111111", "0 10001110 11111111110000000000000"); testBits ((1 << HALF_MAX_EXP) * (1.0f - HALF_EPSILON * 0.24995f), "0 11111 0000000000", // +infinity "0 11111111 00000000000000000000000"); // +infinity // // Large positive numbers, positive infinity and NANs // testBits (HALF_MAX * HALF_MAX, "0 11111 0000000000", // +infinity "0 11111111 00000000000000000000000"); // +infinity testBits (FLT_MAX, "0 11111 0000000000", // +infinity "0 11111111 00000000000000000000000"); // +infinity testBits (floatPosInfinity(), "0 11111 0000000000", // +infinity "0 11111111 00000000000000000000000"); // +infinity testBits (floatPosQNan1(), "0 11111 1111111111", // nan "0 11111111 11111111110000000000000"); // nan testBits (floatPosQNan2(), "0 11111 1010101010", // nan "0 11111111 10101010100000000000000"); // nan // // Numbers close to -1.0 // testBits (-1.0, "1 01111 0000000000", "1 01111111 00000000000000000000000"); testBits (-(1.0f + HALF_EPSILON), "1 01111 0000000001", "1 01111111 00000000010000000000000"); testBits (-(1.0f + HALF_EPSILON * 0.5f), "1 01111 0000000000", "1 01111111 00000000000000000000000"); testBits (-(1.0f + HALF_EPSILON * 0.4999f), "1 01111 0000000000", "1 01111111 00000000000000000000000"); testBits (-(1.0f + HALF_EPSILON * 0.5001f), "1 01111 0000000001", "1 01111111 00000000010000000000000"); testBits (-(1.0f + HALF_EPSILON + HALF_EPSILON), "1 01111 0000000010", "1 01111111 00000000100000000000000"); testBits (-(1.0f + HALF_EPSILON + HALF_EPSILON * 0.5f), "1 01111 0000000010", "1 01111111 00000000100000000000000"); testBits (-(1.0f + HALF_EPSILON + HALF_EPSILON * 0.4999f), "1 01111 0000000001", "1 01111111 00000000010000000000000"); testBits (-(1.0f + HALF_EPSILON + HALF_EPSILON * 0.5001f), "1 01111 0000000010", "1 01111111 00000000100000000000000"); testBits (-(1.0f - HALF_EPSILON * 0.5f), "1 01110 1111111111", "1 01111110 11111111110000000000000"); testBits (-(1.0f - HALF_EPSILON * 0.5f * 0.5f), "1 01111 0000000000", "1 01111111 00000000000000000000000"); testBits (-(1.0f - HALF_EPSILON * 0.5f * 0.4999f), "1 01111 0000000000", "1 01111111 00000000000000000000000"); testBits (-(1.0f - HALF_EPSILON * 0.5f * 0.5001f), "1 01110 1111111111", "1 01111110 11111111110000000000000"); // // Numbers close to -HALF_DENORM_MIN // testBits (-HALF_DENORM_MIN, "1 00000 0000000001", "1 01100111 00000000000000000000000"); testBits (-(HALF_DENORM_MIN + HALF_DENORM_MIN), "1 00000 0000000010", "1 01101000 00000000000000000000000"); testBits (-(HALF_DENORM_MIN + HALF_DENORM_MIN * 0.5f), "1 00000 0000000010", "1 01101000 00000000000000000000000"); testBits (-(HALF_DENORM_MIN + HALF_DENORM_MIN * 0.4999f), "1 00000 0000000001", "1 01100111 00000000000000000000000"); testBits (-(HALF_DENORM_MIN + HALF_DENORM_MIN * 0.5001f), "1 00000 0000000010", "1 01101000 00000000000000000000000"); testBits (-(HALF_DENORM_MIN - HALF_DENORM_MIN), // NOSONAR - suppress SonarCloud bug report. "X 00000 0000000000", "X 00000000 00000000000000000000000"); testBits (-(HALF_DENORM_MIN - HALF_DENORM_MIN * 0.5f), "1 00000 0000000000", "1 00000000 00000000000000000000000"); testBits (-(HALF_DENORM_MIN - HALF_DENORM_MIN * 0.4999f), "1 00000 0000000001", "1 01100111 00000000000000000000000"); testBits (-(HALF_DENORM_MIN - HALF_DENORM_MIN * 0.5001f), "1 00000 0000000000", "1 00000000 00000000000000000000000"); // // Numbers close to -HALF_NRM_MIN // testBits (-HALF_NRM_MIN, "1 00001 0000000000", "1 01110001 00000000000000000000000"); testBits (-(HALF_NRM_MIN + HALF_DENORM_MIN), "1 00001 0000000001", "1 01110001 00000000010000000000000"); testBits (-(HALF_NRM_MIN + HALF_DENORM_MIN * 0.5f), "1 00001 0000000000", "1 01110001 00000000000000000000000"); testBits (-(HALF_NRM_MIN + HALF_DENORM_MIN * 0.4999f), "1 00001 0000000000", "1 01110001 00000000000000000000000"); testBits (-(HALF_NRM_MIN + HALF_DENORM_MIN * 0.5001f), "1 00001 0000000001", "1 01110001 00000000010000000000000"); testBits (-(HALF_NRM_MIN - HALF_DENORM_MIN), "1 00000 1111111111", "1 01110000 11111111100000000000000"); testBits (-(HALF_NRM_MIN - HALF_DENORM_MIN * 0.5f), "1 00001 0000000000", "1 01110001 00000000000000000000000"); testBits (-(HALF_NRM_MIN - HALF_DENORM_MIN * 0.49995f), "1 00001 0000000000", "1 01110001 00000000000000000000000"); testBits (-(HALF_NRM_MIN - HALF_DENORM_MIN * 0.50005f), "1 00000 1111111111", "1 01110000 11111111100000000000000"); // // Small negative integers and simple decimal fractions // testBits (-2, "1 10000 0000000000", "1 10000000 00000000000000000000000"); testBits (-3, "1 10000 1000000000", "1 10000000 10000000000000000000000"); testBits (-10, "1 10010 0100000000", "1 10000010 01000000000000000000000"); testBits (-0.1f, "1 01011 1001100110", "1 01111011 10011001100000000000000"); testBits (-0.2f, "1 01100 1001100110", "1 01111100 10011001100000000000000"); testBits (-0.3f, "1 01101 0011001101", "1 01111101 00110011010000000000000"); // // Numbers close to -HALF_MAX // testBits (-HALF_MAX, "1 11110 1111111111", "1 10001110 11111111110000000000000"); testBits (-(1 << HALF_MAX_EXP) * 1.0f, "1 11111 0000000000", // +infinity "1 11111111 00000000000000000000000"); // +infinity testBits (-(1 << HALF_MAX_EXP) * (1.0f - HALF_EPSILON * 0.25f), "1 11111 0000000000", // +infinity "1 11111111 00000000000000000000000"); // +infinity testBits (-(1 << HALF_MAX_EXP) * (1.0f - HALF_EPSILON * 0.25005f), "1 11110 1111111111", "1 10001110 11111111110000000000000"); testBits (-(1 << HALF_MAX_EXP) * (1.0f - HALF_EPSILON * 0.24995f), "1 11111 0000000000", // +infinity "1 11111111 00000000000000000000000"); // +infinity // // Large negative numbers, negative infinity and NANs // testBits (-HALF_MAX * HALF_MAX, "1 11111 0000000000", // +infinity "1 11111111 00000000000000000000000"); // +infinity testBits (-FLT_MAX, "1 11111 0000000000", // +infinity "1 11111111 00000000000000000000000"); // +infinity testBits (floatNegInfinity(), "1 11111 0000000000", // +infinity "1 11111111 00000000000000000000000"); // +infinity testBits (floatNegQNan1(), "1 11111 1111111111", // nan "1 11111111 11111111110000000000000"); // nan testBits (floatNegQNan2(), "1 11111 1010101010", // nan "1 11111111 10101010100000000000000"); // nan cout << "ok\n\n" << flush; } Imath-3.1.4/src/ImathTest/testBitPatterns.h000066400000000000000000000001721417213455000205640ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testBitPatterns(); Imath-3.1.4/src/ImathTest/testBox.cpp000066400000000000000000001013141417213455000174100ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include "testBoxAlgo.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { // // Test case generation utility - create a vector of IMATH_INTERNAL_NAMESPACE::Vec{2,3,4} // with all permutations of integers 1..T::dimensions(). // // Algorithm from www.bearcave.com/random_hacks/permute.html // template static void addItem (const std::vector& value, std::vector& perms) { T p; for (unsigned int i = 0; i < value.size(); i++) { p[i] = value[i]; } perms.push_back (p); } template static void visit (int& level, int n, int k, std::vector& value, std::vector& perms) { level = level + 1; value[k] = level; if (level == n) addItem (value, perms); else for (int i = 0; i < n; i++) if (value[i] == 0) visit (level, n, i, value, perms); level = level - 1; value[k] = 0; } template static void permutations (std::vector& perms) { std::vector value (T::dimensions()); int level = -1; int n = T::dimensions(); visit (level, n, 0, value, perms); } template static void testConstructors (const char* type) { cout << " constructors for type " << type << endl; // // Empty // { IMATH_INTERNAL_NAMESPACE::Box b; assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest())); } // // Single point // { T p; for (unsigned int i = 0; i < T::dimensions(); i++) p[i] = i; IMATH_INTERNAL_NAMESPACE::Box b (p); assert (b.min == p && b.max == p); } // // Min and max // { T p0; T p1; for (unsigned int i = 0; i < T::dimensions(); i++) { p0[i] = i; p1[i] = 10 * T::dimensions() - i - 1; } IMATH_INTERNAL_NAMESPACE::Box b (p0, p1); assert (b.min == p0 && b.max == p1); } } template void testMakeEmpty (const char* type) { cout << " makeEmpty() for type " << type << endl; // // Empty box // { IMATH_INTERNAL_NAMESPACE::Box b; b.makeEmpty(); assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest())); } // // Non-empty, has volume // { IMATH_INTERNAL_NAMESPACE::Box b (T (-1), T (1)); b.makeEmpty(); assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest())); } // // Non-empty, no volume // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { T min (0); T max (0); max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Box b (min, max); b.makeEmpty(); assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest())); } } template void testMakeInfinite (const char* type) { cout << " makeInfinite() for type " << type << endl; // // Infinite box // { IMATH_INTERNAL_NAMESPACE::Box b; b.makeInfinite(); assert (b.min == T (T::baseTypeLowest()) && b.max == T (T::baseTypeMax())); } // // Non-empty, has volume // { IMATH_INTERNAL_NAMESPACE::Box b (T (-1), T (1)); b.makeInfinite(); assert (b.min == T (T::baseTypeLowest()) && b.max == T (T::baseTypeMax())); } // // Non-empty, no volume // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { T min (0); T max (0); max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Box b (min, max); b.makeInfinite(); assert (b.min == T (T::baseTypeLowest()) && b.max == T (T::baseTypeMax())); } } template void testExtendByPoint (const char* type) { cout << " extendBy() point for type " << type << endl; IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); const unsigned int iters = 10; // // Extend empty box with a single point. // for (unsigned int i = 0; i < iters; i++) { T p; for (unsigned int j = 0; j < T::dimensions(); j++) p[j] = typename T::BaseType (rand.nextf (-12345, 12345)); IMATH_INTERNAL_NAMESPACE::Box b; b.extendBy (p); assert (b.min == p && b.max == p); } // // Extend empty box with a number of random points. Note that // this also covers extending a non-empty box. // for (unsigned int i = 0; i < iters; i++) { IMATH_INTERNAL_NAMESPACE::Box b; T min; T max; for (unsigned int j = 0; j < i; j++) { T p; for (unsigned int k = 0; k < T::dimensions(); k++) p[k] = typename T::BaseType (rand.nextf (-12345, 12345)); if (j == 0) { min = p; max = p; } for (unsigned int k = 0; k < T::dimensions(); k++) { min[k] = std::min (min[k], p[k]); max[k] = std::max (max[k], p[k]); } b.extendBy (p); assert (b.min == min && b.max == max); } } } template void testExtendByBox (const char* type) { cout << " extendBy() box for type " << type << endl; // // Extend empty box with an empty box; // { IMATH_INTERNAL_NAMESPACE::Box b; b.extendBy (IMATH_INTERNAL_NAMESPACE::Box()); assert (b.min == T (T::baseTypeMax()) && b.max == T (T::baseTypeLowest())); } // // Extend empty box with a non-empty box and vice versa. // { std::vector perms; permutations (perms); for (unsigned int i = 0; i < perms.size(); i++) { for (unsigned int j = 0; j < perms.size(); j++) { T p0 = -perms[i]; T p1 = perms[j]; IMATH_INTERNAL_NAMESPACE::Box b0; b0.extendBy (IMATH_INTERNAL_NAMESPACE::Box (p0, p1)); assert (b0.min == p0 && b0.max == p1); IMATH_INTERNAL_NAMESPACE::Box b1 (p0, p1); b1.extendBy (IMATH_INTERNAL_NAMESPACE::Box()); assert (b1.min == p0 && b1.max == p1); } } } // // Extend non-empty box with non-empty box. Starts with empty, then builds. // IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); const unsigned int iters = 10; { IMATH_INTERNAL_NAMESPACE::Box b; T min, max; for (unsigned int i = 1; i < iters; i++) { T p0; T p1; for (unsigned int k = 0; k < T::dimensions(); k++) { p0[k] = typename T::BaseType (rand.nextf (0, 999)); p1[k] = typename T::BaseType (rand.nextf (1000, 1999)); } min = b.min; max = b.max; for (unsigned int k = 0; k < T::dimensions(); k++) { min[k] = std::min (min[k], p0[k]); max[k] = std::max (max[k], p1[k]); } b.extendBy (IMATH_INTERNAL_NAMESPACE::Box (p0, p1)); assert (b.min == min && b.max == max); } } } template void testComparators (const char* type) { cout << " comparators for type " << type << endl; IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); // // Compare empty. // { IMATH_INTERNAL_NAMESPACE::Box b0; IMATH_INTERNAL_NAMESPACE::Box b1; assert (b0 == b1); assert (!(b0 != b1)); } // // Compare empty to non-empty. // { std::vector perms; permutations (perms); for (unsigned int i = 0; i < perms.size(); i++) { for (unsigned int j = 0; j < perms.size(); j++) { T p0 = -perms[i]; T p1 = perms[j]; IMATH_INTERNAL_NAMESPACE::Box b0; IMATH_INTERNAL_NAMESPACE::Box b1 (p0, p1); assert (!(b0 == b1)); assert (b0 != b1); } } } // // Compare two non-empty // { std::vector perms; permutations (perms); for (unsigned int i = 0; i < perms.size(); i++) { for (unsigned int j = 0; j < perms.size(); j++) { T p0 = -perms[i]; T p1 = perms[j]; T p2 = -perms[j]; T p3 = perms[i]; IMATH_INTERNAL_NAMESPACE::Box b0 (p0, p1); IMATH_INTERNAL_NAMESPACE::Box b1 (p2, p3); IMATH_INTERNAL_NAMESPACE::Box b2 (p0, p1); if (i == j) { assert (b0 == b1); assert (!(b0 != b1)); } else { assert (b0 != b1); assert (!(b0 == b1)); } assert (b0 == b2); assert (!(b0 != b2)); } } } } template void testIntersects (const char* type) { cout << " intersects() for type " << type << endl; IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); // // Intersect point with empty box. // { IMATH_INTERNAL_NAMESPACE::Box b; T p (1); assert (!b.intersects (p)); } // // Intersect point with non-empty, has-volume box. // { IMATH_INTERNAL_NAMESPACE::Box b (T (-1), T (1)); T p0 (0); T p1 (5); T p2 (-5); assert (b.intersects (p0)); assert (!b.intersects (p1)); assert (!b.intersects (p2)); } // // Intersect point with non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { T min (0); T max = min; max[T::dimensions() - 1] = 1; T p0 (0); T p1 (5); IMATH_INTERNAL_NAMESPACE::Box b (min, max); assert (b.intersects (p0)); assert (!b.intersects (p1)); } // // Intersect empty box with empty box. // { IMATH_INTERNAL_NAMESPACE::Box b0; IMATH_INTERNAL_NAMESPACE::Box b1; assert (!b0.intersects (b1)); assert (!b1.intersects (b0)); } // // Intersect empty box with non-empty has-volume boxes. // { IMATH_INTERNAL_NAMESPACE::Box b0; IMATH_INTERNAL_NAMESPACE::Box b1 (T (-1), T (1)); IMATH_INTERNAL_NAMESPACE::Box b2 (T (1), T (2)); assert (!b0.intersects (b1)); assert (!b0.intersects (b2)); assert (!b1.intersects (b0)); assert (!b2.intersects (b0)); } // // Intersect empty box with non-empty no-volume box. // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { T min (0); T max = min; max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Box b0; IMATH_INTERNAL_NAMESPACE::Box b1 (min, max); assert (!b0.intersects (b1)); assert (!b1.intersects (b0)); } // // Intersect non-empty has-volume box with non-empty has-volume box. // { IMATH_INTERNAL_NAMESPACE::Box b1 (T (-1), T (1)); IMATH_INTERNAL_NAMESPACE::Box b2 (T (-1), T (1)); IMATH_INTERNAL_NAMESPACE::Box b3 (T (1), T (2)); IMATH_INTERNAL_NAMESPACE::Box b4 (T (2), T (3)); assert (b1.intersects (b1)); assert (b1.intersects (b3)); assert (!b1.intersects (b4)); assert (b3.intersects (b1)); assert (!b4.intersects (b1)); } // // Intersect non-empty has-volume box with non-empty no-volume box. // // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { IMATH_INTERNAL_NAMESPACE::Box b0 (T (-1), T (1)); T min (0); T max = min; max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Box b1 (min, max); IMATH_INTERNAL_NAMESPACE::Box b2 (min + T (2), max + T (2)); assert (b0.intersects (b1)); assert (b1.intersects (b0)); assert (!b0.intersects (b2)); assert (!b2.intersects (b1)); } // // Intersect non-empty no-volume box with non-empty no-volume box. // // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { T min (0); T max = min; max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Box b0 (min, max); IMATH_INTERNAL_NAMESPACE::Box b1 (min, max + T (2)); IMATH_INTERNAL_NAMESPACE::Box b2 (min + T (2), max + T (2)); assert (b0.intersects (b1)); assert (b1.intersects (b0)); assert (!b0.intersects (b2)); assert (!b2.intersects (b0)); } } template void testSize (const char* type) { cout << " size() for type " << type << endl; // // Size of empty box. // { IMATH_INTERNAL_NAMESPACE::Box b; assert (b.size() == T (0)); } // // Size of non-empty, has-volume box. // Boxes are: // 2D: [(-1, -1), (1, 1) ] // 3D: [(-1, -1, -1), (1, 1, 1) ] // 4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ] // // and // // 2D: [(-1, -2), (1, 2) ] // 3D: [(-1, -2, -3), (1, 2, 3) ] // 4D: [(-1, -2, -3, -4), (1, 2, 3, 4) ] // { IMATH_INTERNAL_NAMESPACE::Box b0 (T (-1), T (1)); assert (b0.size() == T (2)); T p; for (unsigned int i = 0; i < T::dimensions(); i++) { p[i] = i; } IMATH_INTERNAL_NAMESPACE::Box b1 (-p, p); assert (b1.size() == p * T (2)); } // // Size of non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (0, 1) ] // 3D: [(0, 0, 0), (0, 0, 1) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 1)] // { T min (0); T max = min; max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Box b (min, max); assert (b.size() == max); } } template void testCenter (const char* type) { cout << " center() for type " << type << endl; // // Center of empty box. // { IMATH_INTERNAL_NAMESPACE::Box b; assert (b.center() == T (0)); } // // Center of non-empty, has-volume box. // Boxes are: // 2D: [(-1, -1), (1, 1) ] // 3D: [(-1, -1, -1), (1, 1, 1) ] // 4D: [(-1, -1, -1, -1), (1, 1, 1, 1) ] // // and // // 2D: [(-2, -4), ( 8, 2) ] // 3D: [(-2, -4, -6), (12, 8, 2) ] // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ] // { IMATH_INTERNAL_NAMESPACE::Box b0 (T (-1), T (1)); assert (b0.center() == T (0)); T p0; T p1; for (unsigned int i = 0; i < T::dimensions(); i++) { p0[i] = -typename T::BaseType (1 << (i + 1)); p1[i] = typename T::BaseType (1 << (T::dimensions() - i)); } IMATH_INTERNAL_NAMESPACE::Box b1 (p0, p1); assert (b1.center() == (p1 + p0) / 2); } // // Center of non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (0, 2) ] // 3D: [(0, 0, 0), (0, 0, 2) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)] // { T min (0); T max = min; max[T::dimensions() - 1] = 2; IMATH_INTERNAL_NAMESPACE::Box b (min, max); assert (b.center() == max / 2); } } template void testIsEmpty (const char* type) { cout << " isEmpty() for type " << type << endl; // // Empty box. // { IMATH_INTERNAL_NAMESPACE::Box b; assert (b.isEmpty()); } // // Non-empty, has-volume box. // 2D: [(-2, -4), ( 8, 2) ] // 3D: [(-2, -4, -6), (12, 8, 2) ] // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ] // { IMATH_INTERNAL_NAMESPACE::Box b0 (T (-1), T (1)); assert (!b0.isEmpty()); T p0; T p1; for (unsigned int i = 0; i < T::dimensions(); i++) { p0[i] = -typename T::BaseType (1 << (i + 1)); p1[i] = typename T::BaseType (1 << (T::dimensions() - i)); } IMATH_INTERNAL_NAMESPACE::Box b1 (p0, p1); assert (!b1.isEmpty()); } // // Non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (0, 2) ] // 3D: [(0, 0, 0), (0, 0, 2) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)] // { T min (0); T max = min; max[T::dimensions() - 1] = 2; IMATH_INTERNAL_NAMESPACE::Box b (min, max); assert (!b.isEmpty()); } } template void testIsInfinite (const char* type) { cout << " isInfinite() for type " << type << endl; // // Infinite box. // { IMATH_INTERNAL_NAMESPACE::Box b; b.makeInfinite(); assert (b.isInfinite()); } // // Non-empty, has-volume box. // 2D: [(-2, -4), ( 8, 2) ] // 3D: [(-2, -4, -6), (12, 8, 2) ] // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ] // { IMATH_INTERNAL_NAMESPACE::Box b0 (T (-1), T (1)); assert (!b0.isInfinite()); T p0; T p1; for (unsigned int i = 0; i < T::dimensions(); i++) { p0[i] = -typename T::BaseType (1 << (i + 1)); p1[i] = typename T::BaseType (1 << (T::dimensions() - i)); } IMATH_INTERNAL_NAMESPACE::Box b1 (p0, p1); assert (!b1.isInfinite()); } // // Non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (0, 2) ] // 3D: [(0, 0, 0), (0, 0, 2) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)] // { T min (0); T max = min; max[T::dimensions() - 1] = 2; IMATH_INTERNAL_NAMESPACE::Box b (min, max); assert (!b.isInfinite()); } } template void testHasVolume (const char* type) { cout << " hasVolume() for type " << type << endl; // // Empty box. // { IMATH_INTERNAL_NAMESPACE::Box b; assert (!b.hasVolume()); } // // Infinite box. // { IMATH_INTERNAL_NAMESPACE::Box b; b.makeInfinite(); assert (b.hasVolume()); } // // Non-empty, has-volume box. // 2D: [(-2, -4), ( 8, 2) ] // 3D: [(-2, -4, -6), (12, 8, 2) ] // 4D: [(-2, -4, -6, -8), (16, 12, 8, 4) ] // { IMATH_INTERNAL_NAMESPACE::Box b0 (T (-1), T (1)); assert (b0.hasVolume()); T p0; T p1; for (unsigned int i = 0; i < T::dimensions(); i++) { p0[i] = -typename T::BaseType (1 << (i + 1)); p1[i] = typename T::BaseType (1 << (T::dimensions() - i)); } IMATH_INTERNAL_NAMESPACE::Box b1 (p0, p1); assert (b1.hasVolume()); } // // Non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (0, 2) ] // 3D: [(0, 0, 0), (0, 0, 2) ] // 4D: [(0, 0, 0, 0), (0, 0, 0, 2)] // { T min (0); T max = min; max[T::dimensions() - 1] = 2; IMATH_INTERNAL_NAMESPACE::Box b (min, max); assert (!b.hasVolume()); } } template void testMajorAxis (const char* type) { cout << " majorAxis() for type " << type << endl; // // Empty box. // { IMATH_INTERNAL_NAMESPACE::Box b; assert (b.majorAxis() == 0); } // // Non-empty, has-volume box. // Boxes are [ (0, 0, ...), () ] // { std::vector perms; permutations (perms); for (unsigned int i = 0; i < perms.size(); i++) { IMATH_INTERNAL_NAMESPACE::Box b (T (0), perms[i]); unsigned int major = 0; T size = perms[i] - T (0); for (unsigned int j = 1; j < T::dimensions(); j++) if (size[j] > size[major]) major = j; assert (b.majorAxis() == major); } } // // Non-empty, no-volume box. // Boxes are: // 2D: [(0, 0), (1, 0) ] // 2D: [(0, 0), (0, 1) ] // // 3D: [(0, 0), (1, 0, 0) ] // 3D: [(0, 0), (0, 1, 0) ] // 3D: [(0, 0), (0, 0, 1) ] // // and similarly for 4D // { for (unsigned int i = 0; i < T::dimensions(); i++) { for (unsigned int j = 0; j < T::dimensions(); j++) { T max (0); max[j] = 1; IMATH_INTERNAL_NAMESPACE::Box b (T (0), max); assert (b.majorAxis() == j); } } } } } // anonymous namespace void testBox() { cout << "Testing box methods" << endl; // // Constructors // testConstructors ("V2s"); testConstructors ("V2i"); testConstructors ("V2i64"); testConstructors ("V2f"); testConstructors ("V2d"); testConstructors ("V3s"); testConstructors ("V3i"); testConstructors ("V3i64"); testConstructors ("V3f"); testConstructors ("V3d"); testConstructors ("V4s"); testConstructors ("V4i"); testConstructors ("V4i64"); testConstructors ("V4f"); testConstructors ("V4d"); // // makeEmpty() // testMakeEmpty ("V2s"); testMakeEmpty ("V2i"); testMakeEmpty ("V2i64"); testMakeEmpty ("V2f"); testMakeEmpty ("V2d"); testMakeEmpty ("V3s"); testMakeEmpty ("V3i"); testMakeEmpty ("V3i64"); testMakeEmpty ("V3f"); testMakeEmpty ("V3d"); testMakeEmpty ("V4s"); testMakeEmpty ("V4i"); testMakeEmpty ("V4i64"); testMakeEmpty ("V4f"); testMakeEmpty ("V4d"); // // makeInfinite() // testMakeInfinite ("V2s"); testMakeInfinite ("V2i"); testMakeInfinite ("V2i64"); testMakeInfinite ("V2f"); testMakeInfinite ("V2d"); testMakeInfinite ("V3s"); testMakeInfinite ("V3i"); testMakeInfinite ("V3i64"); testMakeInfinite ("V3f"); testMakeInfinite ("V3d"); testMakeInfinite ("V4s"); testMakeInfinite ("V4i"); testMakeInfinite ("V4i64"); testMakeInfinite ("V4f"); testMakeInfinite ("V4d"); // // extendBy() (point) // testExtendByPoint ("V2s"); testExtendByPoint ("V2i"); testExtendByPoint ("V2i64"); testExtendByPoint ("V2f"); testExtendByPoint ("V2d"); testExtendByPoint ("V3s"); testExtendByPoint ("V3i"); testExtendByPoint ("V3i64"); testExtendByPoint ("V3f"); testExtendByPoint ("V3d"); testExtendByPoint ("V4s"); testExtendByPoint ("V4i"); testExtendByPoint ("V4i64"); testExtendByPoint ("V4f"); testExtendByPoint ("V4d"); // // extendBy() box // testExtendByBox ("V2s"); testExtendByBox ("V2i"); testExtendByBox ("V2i64"); testExtendByBox ("V2f"); testExtendByBox ("V2d"); testExtendByBox ("V3s"); testExtendByBox ("V3i"); testExtendByBox ("V3i64"); testExtendByBox ("V3f"); testExtendByBox ("V3d"); testExtendByBox ("V4s"); testExtendByBox ("V4i"); testExtendByBox ("V4i64"); testExtendByBox ("V4f"); testExtendByBox ("V4d"); // // == and !== // testComparators ("V2s"); testComparators ("V2i"); testComparators ("V2i64"); testComparators ("V2f"); testComparators ("V2d"); testComparators ("V3s"); testComparators ("V3i"); testComparators ("V3i64"); testComparators ("V3f"); testComparators ("V3d"); testComparators ("V4s"); testComparators ("V4i"); testComparators ("V4i64"); testComparators ("V4f"); testComparators ("V4d"); // // size() // testSize ("V2s"); testSize ("V2i"); testSize ("V2i64"); testSize ("V2f"); testSize ("V2d"); testSize ("V3s"); testSize ("V3i"); testSize ("V3i64"); testSize ("V3f"); testSize ("V3d"); testSize ("V4s"); testSize ("V4i"); testSize ("V4i64"); testSize ("V4f"); testSize ("V4d"); // // center() // testCenter ("V2s"); testCenter ("V2i"); testCenter ("V2i64"); testCenter ("V2f"); testCenter ("V2d"); testCenter ("V3s"); testCenter ("V3i"); testCenter ("V3i64"); testCenter ("V3f"); testCenter ("V3d"); testCenter ("V4s"); testCenter ("V4i"); testCenter ("V4i64"); testCenter ("V4f"); testCenter ("V4d"); // // isEmpty() // testIsEmpty ("V2s"); testIsEmpty ("V2i"); testIsEmpty ("V2i64"); testIsEmpty ("V2f"); testIsEmpty ("V2d"); testIsEmpty ("V3s"); testIsEmpty ("V3i"); testIsEmpty ("V3i64"); testIsEmpty ("V3f"); testIsEmpty ("V3d"); testIsEmpty ("V4s"); testIsEmpty ("V4i"); testIsEmpty ("V4i64"); testIsEmpty ("V4f"); testIsEmpty ("V4d"); // // isInfinite() // testIsInfinite ("V2s"); testIsInfinite ("V2i"); testIsInfinite ("V2i64"); testIsInfinite ("V2f"); testIsInfinite ("V2d"); testIsInfinite ("V3s"); testIsInfinite ("V3i"); testIsInfinite ("V3i64"); testIsInfinite ("V3f"); testIsInfinite ("V3d"); testIsInfinite ("V4s"); testIsInfinite ("V4i"); testIsInfinite ("V4i64"); testIsInfinite ("V4f"); testIsInfinite ("V4d"); // // hasVolume() // testHasVolume ("V2s"); testHasVolume ("V2i"); testHasVolume ("V2i64"); testHasVolume ("V2f"); testHasVolume ("V2d"); testHasVolume ("V3s"); testHasVolume ("V3i"); testHasVolume ("V3i64"); testHasVolume ("V3f"); testHasVolume ("V3d"); testHasVolume ("V4s"); testHasVolume ("V4i"); testHasVolume ("V4i64"); testHasVolume ("V4f"); testHasVolume ("V4d"); // // majorAxis() // testMajorAxis ("V2s"); testMajorAxis ("V2i"); testMajorAxis ("V2i64"); testMajorAxis ("V2f"); testMajorAxis ("V2d"); testMajorAxis ("V3s"); testMajorAxis ("V3i"); testMajorAxis ("V3i64"); testMajorAxis ("V3f"); testMajorAxis ("V3d"); testMajorAxis ("V4s"); testMajorAxis ("V4i"); testMajorAxis ("V4i64"); testMajorAxis ("V4f"); testMajorAxis ("V4d"); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testBox.h000066400000000000000000000001621417213455000170540ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testBox(); Imath-3.1.4/src/ImathTest/testBoxAlgo.cpp000066400000000000000000000633701417213455000202240ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include "testBoxAlgo.h" using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { bool approximatelyEqual (const V3f& p1, const V3f& p2, float e) { float m = 0; for (int i = 0; i < 3; ++i) { m = max (m, abs (p1[i])); m = max (m, abs (p2[i])); } for (int i = 0; i < 3; ++i) if (!equalWithAbsError (p1[i], p2[i], m * e)) return false; return true; } void testEntryAndExitPoints (const Box3f& box) { Rand48 random (2007); float e = 50 * std::numeric_limits::epsilon(); if (box.isEmpty()) { cout << " empty box, no rays intersect" << endl; for (int i = 0; i < 100000; ++i) { V3f p1 (random.nextf (box.max.x, box.min.x), random.nextf (box.max.y, box.min.y), random.nextf (box.max.z, box.min.z)); V3f p2 (p1 + hollowSphereRand (random)); V3f r, s; assert (!findEntryAndExitPoints (Line3f (p1, p2), box, r, s)); } return; } cout << " box = (" << box.min << " " << box.max << ")" << endl; if (box.max == box.min) { cout << " single-point box, ray intersects" << endl; static const float off[6][3] = { { -1, 0, 0 }, { 1, 0, 0 }, { 0, -1, 0 }, { 0, 1, 0 }, { 0, 0, -1 }, { 0, 0, 1 } }; for (int i = 0; i < 6; ++i) { V3f p1 (box.min.x + off[i][0], box.min.y + off[i][1], box.min.z + off[i][2]); V3f r, s; assert (findEntryAndExitPoints (Line3f (p1, box.min), box, r, s)); assert (r == box.min && s == box.min); } cout << " single-point box, ray does not intersect" << endl; for (int i = 0; i < 100000; ++i) { // // The ray starts at a distance of r2 from the of the // box, and it passes the box at a minimum distance of r1. // const float r1 = 0.00001; const float r2 = 1.0; V3f p1 = box.min + r2 * hollowSphereRand (random); V3f p2; float r3; do { do { p2 = box.min + r2 * hollowSphereRand (random); } while (approximatelyEqual (p1, p2, e)); V3f d1 = (p2 - p1).normalized(); V3f d2 = (box.min - p1); r3 = (d2 - d1 * (d1 ^ d2)).length(); } while (r3 < r1); Line3f ray (p1, p2); V3f r, s; assert (!findEntryAndExitPoints (ray, box, r, s)); } return; } cout << " ray starts outside box, intersects" << endl; Box3f bigBox (box.min - (box.max - box.min), box.max + (box.max - box.min)); for (int i = 0; i < 100000; ++i) { // // Find starting point outside the box, end point inside the box // V3f p1; do { p1 = V3f (random.nextf (bigBox.min.x, bigBox.max.x), random.nextf (bigBox.min.y, bigBox.max.y), random.nextf (bigBox.min.z, bigBox.max.z)); } while (box.intersects (p1)); V3f p2; do { p2 = V3f (random.nextf (box.min.x, box.max.x), random.nextf (box.min.y, box.max.y), random.nextf (box.min.z, box.max.z)); } while (approximatelyEqual (p1, p2, e)); Line3f ray (p1, p2); V3f r, s; bool b = findEntryAndExitPoints (ray, box, r, s); // // Ray and box must intersect, entry and exit points // must be on the surface of the box. // assert (b); assert (r.x == box.min.x || r.x == box.max.x || r.y == box.min.y || r.y == box.max.y || r.z == box.min.z || r.z == box.max.z); assert (s.x == box.min.x || s.x == box.max.x || s.y == box.min.y || s.y == box.max.y || s.z == box.min.z || s.z == box.max.z); // // Entry and exit points must be consistent // with the direction of the ray // if (r.x == box.min.x) assert (ray.dir.x >= 0); if (r.x == box.max.x) assert (ray.dir.x <= 0); if (r.y == box.min.y) assert (ray.dir.y >= 0); if (r.y == box.max.y) assert (ray.dir.y <= 0); if (r.z == box.min.z) assert (ray.dir.z >= 0); if (r.z == box.max.z) assert (ray.dir.z <= 0); if (s.x == box.max.x) assert (ray.dir.x >= 0); if (s.x == box.min.x) assert (ray.dir.x <= 0); if (s.y == box.max.y) assert (ray.dir.y >= 0); if (s.y == box.min.y) assert (ray.dir.y <= 0); if (s.z == box.max.z) assert (ray.dir.z >= 0); if (s.z == box.min.z) assert (ray.dir.z <= 0); // // Entry and exit points must be approximately on the ray // How far they can be off depends on how far p1 and the // entry and exit points are are from the origin. // { V3f p3 = p1 + ray.dir * (ray.dir ^ (r - p1)); float m = 0; for (int j = 0; j < 3; ++j) { m = max (abs (p1[j]), m); m = max (abs (r[j]), m); } float err = 30 * m * std::numeric_limits::epsilon(); assert (p3.equalWithAbsError (r, err)); } { V3f p3 = p1 + ray.dir * (ray.dir ^ (s - p1)); float m = 0; for (int j = 0; j < 3; ++j) { m = max (abs (p1[j]), m); m = max (abs (s[j]), m); } float err = 30 * m * std::numeric_limits::epsilon(); assert (p3.equalWithAbsError (s, err)); } } cout << " ray starts outside box, does not intersect" << endl; V3f center = (box.min + box.max) * 0.5f; float r1 = (box.max - box.min).length() * 0.51f; float r2 = 2 * r1; for (int i = 0; i < 100000; ++i) { // // The ray starts at a distance of r2 from the center // of the box, and it passes the center at a minimum // distance of r1. (r1 and r2 are both greater than // the distance between the center and the corners // of the box.) // V3f p1 = center + r2 * hollowSphereRand (random); V3f p2; float r3; do { do { p2 = center + r2 * hollowSphereRand (random); } while (approximatelyEqual (p1, p2, e)); V3f d1 = (p2 - p1).normalized(); V3f d2 = (center - p1); r3 = (d2 - d1 * (d1 ^ d2)).length(); } while (r3 < r1); Line3f ray (p1, p2); V3f r, s; assert (!findEntryAndExitPoints (ray, box, r, s)); } } void entryAndExitPoints1() { cout << " ray-box entry and exit, random rays" << endl; Box3f boxes[] = { // Boxes with a positive volume Box3f (V3f (-1, -1, -1), V3f (1, 1, 1)), Box3f (V3f (10, 20, 30), V3f (1010, 21, 31)), Box3f (V3f (10, 20, 30), V3f (11, 1020, 31)), Box3f (V3f (10, 20, 30), V3f (11, 21, 1030)), Box3f (V3f (-1e10f, -2e10f, -3e10f), V3f (5e15f, 6e15f, 7e15f)), // Non-empty, zero-volume boxes Box3f (V3f (1, 1, 1), V3f (2, 1, 1)), Box3f (V3f (1, 1, 1), V3f (1, 2, 1)), Box3f (V3f (1, 1, 1), V3f (1, 1, 2)), Box3f (V3f (1, 1, 1), V3f (1, 2, 3)), Box3f (V3f (1, 1, 1), V3f (2, 3, 1)), Box3f (V3f (1, 1, 1), V3f (2, 1, 3)), Box3f (V3f (-1, -2, 1), V3f (-1, -2, 1)), Box3f (V3f (1, 1, 1), V3f (1, 1, 1)), Box3f (V3f (0, 0, 0), V3f (0, 0, 0)), // empty box Box3f() }; for (size_t i = 0; i < sizeof (boxes) / sizeof (boxes[0]); ++i) testEntryAndExitPoints (boxes[i]); } void testPerturbedRayBoxEntryExit (const Box3f& box, const Line3f& ray, bool result) { cout << " dir ~ " << ray.dir << ", result = " << result << endl; { V3f r, s; assert (result == findEntryAndExitPoints (ray, box, r, s)); } Rand48 random (19); const float e = 1e-25f; for (int i = 0; i < 10000; ++i) { Line3f ray1 (ray); ray1.dir += e * solidSphereRand (random); V3f r, s; assert (result == findEntryAndExitPoints (ray1, box, r, s)); } } void entryAndExitPoints2() { cout << " ray-box entry and exit, nearly axis-parallel rays" << endl; Box3f box (V3f (-1e15f, -1e15f, -1e15f), V3f (1e15f, 1e15f, 1e15f)); Line3f ray; V3f r, s; bool b; ray = Line3f (V3f (-2e15f, 0, 0), V3f (2e15f, 0, 0)); b = findEntryAndExitPoints (ray, box, r, s); assert (b && r == V3f (-1e15f, 0, 0) && s == V3f (1e15f, 0, 0)); testPerturbedRayBoxEntryExit (box, ray, true); ray = Line3f (V3f (2e15f, 0, 0), V3f (-2e15f, 0, 0)); b = findEntryAndExitPoints (ray, box, r, s); assert (b && r == V3f (1e15f, 0, 0) && s == V3f (-1e15f, 0, 0)); testPerturbedRayBoxEntryExit (box, ray, true); ray = Line3f (V3f (-2e15f, 2e15f, 0), V3f (2e15f, 2e15f, 0)); b = findEntryAndExitPoints (ray, box, r, s); assert (!b); testPerturbedRayBoxEntryExit (box, ray, false); ray = Line3f (V3f (2e15f, 2e15f, 0), V3f (-2e15f, 2e15f, 0)); b = findEntryAndExitPoints (ray, box, r, s); assert (!b); testPerturbedRayBoxEntryExit (box, ray, false); ray = Line3f (V3f (0, -2e15f, 0), V3f (0, 2e15f, 0)); b = findEntryAndExitPoints (ray, box, r, s); assert (b && r == V3f (0, -1e15f, 0) && s == V3f (0, 1e15f, 0)); testPerturbedRayBoxEntryExit (box, ray, true); ray = Line3f (V3f (0, 2e15f, 0), V3f (0, -2e15f, 0)); b = findEntryAndExitPoints (ray, box, r, s); assert (b && r == V3f (0, 1e15f, 0) && s == V3f (0, -1e15f, 0)); testPerturbedRayBoxEntryExit (box, ray, true); ray = Line3f (V3f (0, -2e15f, 2e15f), V3f (0, 2e15f, 2e15f)); b = findEntryAndExitPoints (ray, box, r, s); assert (!b); testPerturbedRayBoxEntryExit (box, ray, false); ray = Line3f (V3f (0, 2e15f, 2e15f), V3f (0, -2e15f, 2e15f)); b = findEntryAndExitPoints (ray, box, r, s); assert (!b); testPerturbedRayBoxEntryExit (box, ray, false); ray = Line3f (V3f (0, 0, -2e15f), V3f (0, 0, 2e15f)); b = findEntryAndExitPoints (ray, box, r, s); assert (b && r == V3f (0, 0, -1e15f) && s == V3f (0, 0, 1e15f)); testPerturbedRayBoxEntryExit (box, ray, true); ray = Line3f (V3f (0, 0, 2e15f), V3f (0, 0, -2e15f)); b = findEntryAndExitPoints (ray, box, r, s); assert (b && r == V3f (0, 0, 1e15f) && s == V3f (0, 0, -1e15f)); testPerturbedRayBoxEntryExit (box, ray, true); ray = Line3f (V3f (2e15f, 0, -2e15f), V3f (2e15f, 0, 2e15f)); b = findEntryAndExitPoints (ray, box, r, s); assert (!b); testPerturbedRayBoxEntryExit (box, ray, false); ray = Line3f (V3f (2e15f, 0, 2e15f), V3f (2e15f, 0, -2e15f)); b = findEntryAndExitPoints (ray, box, r, s); assert (!b); testPerturbedRayBoxEntryExit (box, ray, false); } void testRayBoxIntersection (const Box3f& box) { Rand48 random (2007); float e = 50 * std::numeric_limits::epsilon(); if (box.isEmpty()) { cout << " empty box, no rays intersect" << endl; for (int i = 0; i < 100000; ++i) { V3f p1 (random.nextf (box.max.x, box.min.x), random.nextf (box.max.y, box.min.y), random.nextf (box.max.z, box.min.z)); V3f p2 (p1 + hollowSphereRand (random)); V3f ip; assert (!intersects (box, Line3f (p1, p2), ip)); } return; } cout << " box = (" << box.min << " " << box.max << ")" << endl; if (box.max == box.min) { cout << " single-point box, ray intersects" << endl; static const float off[6][3] = { { -1, 0, 0 }, { 1, 0, 0 }, { 0, -1, 0 }, { 0, 1, 0 }, { 0, 0, -1 }, { 0, 0, 1 } }; for (int i = 0; i < 6; ++i) { V3f p1 (box.min.x + off[i][0], box.min.y + off[i][1], box.min.z + off[i][2]); V3f ip; assert (intersects (box, Line3f (p1, box.min), ip)); assert (ip == box.min); } cout << " single-point box, ray does not intersect" << endl; for (int i = 0; i < 100000; ++i) { // // The ray starts at a distance of r2 from the of the // box, and it passes the box at a minimum distance of r1. // const float r1 = 0.00001; const float r2 = 1.0; V3f p1 = box.min + r2 * hollowSphereRand (random); V3f p2; float r3; do { do { p2 = box.min + r2 * hollowSphereRand (random); } while (approximatelyEqual (p1, p2, e)); V3f d1 = (p2 - p1).normalized(); V3f d2 = (box.min - p1); r3 = (d2 - d1 * (d1 ^ d2)).length(); } while (r3 < r1); Line3f ray (p1, p2); V3f ip; assert (!intersects (box, ray, ip)); } return; } cout << " ray starts inside box" << endl; for (int i = 0; i < 1000; ++i) { V3f p1 (random.nextf (box.min.x, box.max.x), random.nextf (box.min.y, box.max.y), random.nextf (box.min.z, box.max.z)); V3f p2 (p1 + hollowSphereRand (random)); V3f ip; bool b = intersects (box, Line3f (p1, p2), ip); assert (b && ip == p1); } cout << " ray starts outside box, intersects" << endl; Box3f bigBox (box.min - (box.max - box.min), box.max + (box.max - box.min)); for (int i = 0; i < 100000; ++i) { // // Find starting point outside the box, end point inside the box // V3f p1; do { p1 = V3f (random.nextf (bigBox.min.x, bigBox.max.x), random.nextf (bigBox.min.y, bigBox.max.y), random.nextf (bigBox.min.z, bigBox.max.z)); } while (box.intersects (p1)); V3f p2; do { p2 = V3f (random.nextf (box.min.x, box.max.x), random.nextf (box.min.y, box.max.y), random.nextf (box.min.z, box.max.z)); } while (approximatelyEqual (p1, p2, e)); Line3f ray (p1, p2); V3f ip; bool b = intersects (box, ray, ip); // // Ray and box must intersect, intersection point // must be on the surface of the box. // assert (b); assert (ip.x == box.min.x || ip.x == box.max.x || ip.y == box.min.y || ip.y == box.max.y || ip.z == box.min.z || ip.z == box.max.z); // // Intersection point must be consistent with the origin // and direction of the ray // if (ip.x == box.min.x) assert (ray.pos.x <= box.min.x && ray.dir.x >= 0); if (ip.x == box.max.x) assert (ray.pos.x >= box.max.x && ray.dir.x <= 0); if (ip.y == box.min.y) assert (ray.pos.y <= box.min.y && ray.dir.y >= 0); if (ip.y == box.max.y) assert (ray.pos.y >= box.max.y && ray.dir.y <= 0); if (ip.z == box.min.z) assert (ray.pos.z <= box.min.z && ray.dir.z >= 0); if (ip.z == box.max.z) assert (ray.pos.z >= box.max.z && ray.dir.z <= 0); // // Intersection point must be approximately on the ray // How far it can be off depends on how far p1 and ip // are from the origin. // V3f p3 = p1 + ray.dir * (ray.dir ^ (ip - p1)); float m = 0; for (int j = 0; j < 3; ++j) { m = max (abs (p1[j]), m); m = max (abs (ip[j]), m); } float err = 30 * m * std::numeric_limits::epsilon(); assert (p3.equalWithAbsError (ip, err)); // // Try same starting point, opposite direction // ray.dir *= -1; V3f ip2; assert (!intersects (box, ray, ip2)); } cout << " ray starts outside box, does not intersect" << endl; V3f center = (box.min + box.max) * 0.5f; float r1 = (box.max - box.min).length() * 0.51f; float r2 = 2 * r1; for (int i = 0; i < 100000; ++i) { // // The ray starts at a distance of r2 from the center // of the box, and it passes the center at a minimum // distance of r1. (r1 and r2 are both greater than // the distance between the center and the corners // of the box.) // V3f p1 = center + r2 * hollowSphereRand (random); V3f p2; float r3; do { do { p2 = center + r2 * hollowSphereRand (random); } while (approximatelyEqual (p1, p2, e)); V3f d1 = (p2 - p1).normalized(); V3f d2 = (center - p1); r3 = (d2 - d1 * (d1 ^ d2)).length(); } while (r3 < r1); Line3f ray (p1, p2); V3f ip; assert (!intersects (box, ray, ip)); } } void rayBoxIntersection1() { cout << " ray-box intersection, random rays" << endl; Box3f boxes[] = { // Boxes with a positive volume Box3f (V3f (-1, -1, -1), V3f (1, 1, 1)), Box3f (V3f (10, 20, 30), V3f (1010, 21, 31)), Box3f (V3f (10, 20, 30), V3f (11, 1020, 31)), Box3f (V3f (10, 20, 30), V3f (11, 21, 1030)), Box3f (V3f (-1e10f, -2e10f, -3e10f), V3f (5e15f, 6e15f, 7e15f)), // Non-empty, zero-volume boxes Box3f (V3f (1, 1, 1), V3f (2, 1, 1)), Box3f (V3f (1, 1, 1), V3f (1, 2, 1)), Box3f (V3f (1, 1, 1), V3f (1, 1, 2)), Box3f (V3f (1, 1, 1), V3f (1, 2, 3)), Box3f (V3f (1, 1, 1), V3f (2, 3, 1)), Box3f (V3f (1, 1, 1), V3f (2, 1, 3)), Box3f (V3f (-1, -2, 1), V3f (-1, -2, 1)), Box3f (V3f (1, 1, 1), V3f (1, 1, 1)), Box3f (V3f (0, 0, 0), V3f (0, 0, 0)), // empty box Box3f() }; for (size_t i = 0; i < sizeof (boxes) / sizeof (boxes[0]); ++i) testRayBoxIntersection (boxes[i]); } void testPerturbedRayBox (const Box3f& box, const Line3f& ray, bool result) { cout << " dir ~ " << ray.dir << ", result = " << result << endl; { V3f ip; assert (result == intersects (box, ray, ip)); } Rand48 random (19); const float e = 1e-25f; for (int i = 0; i < 10000; ++i) { Line3f ray1 (ray); ray1.dir += e * solidSphereRand (random); V3f ip; assert (result == intersects (box, ray1, ip)); } } void rayBoxIntersection2() { cout << " ray-box intersection, nearly axis-parallel rays" << endl; Box3f box (V3f (-1e15f, -1e15f, -1e15f), V3f (1e15f, 1e15f, 1e15f)); Line3f ray; V3f ip; bool b; ray = Line3f (V3f (-2e15f, 0, 0), V3f (2e15f, 0, 0)); b = intersects (box, ray, ip); assert (b && ip == V3f (-1e15f, 0, 0)); testPerturbedRayBox (box, ray, true); ray = Line3f (V3f (2e15f, 0, 0), V3f (-2e15f, 0, 0)); b = intersects (box, ray, ip); assert (b && ip == V3f (1e15f, 0, 0)); testPerturbedRayBox (box, ray, true); ray = Line3f (V3f (-2e15f, 2e15f, 0), V3f (2e15f, 2e15f, 0)); b = intersects (box, ray, ip); assert (!b); testPerturbedRayBox (box, ray, false); ray = Line3f (V3f (2e15f, 2e15f, 0), V3f (-2e15f, 2e15f, 0)); b = intersects (box, ray, ip); assert (!b); testPerturbedRayBox (box, ray, false); ray = Line3f (V3f (0, -2e15f, 0), V3f (0, 2e15f, 0)); b = intersects (box, ray, ip); assert (b && ip == V3f (0, -1e15f, 0)); testPerturbedRayBox (box, ray, true); ray = Line3f (V3f (0, 2e15f, 0), V3f (0, -2e15f, 0)); b = intersects (box, ray, ip); assert (b && ip == V3f (0, 1e15f, 0)); testPerturbedRayBox (box, ray, true); ray = Line3f (V3f (0, -2e15f, 2e15f), V3f (0, 2e15f, 2e15f)); b = intersects (box, ray, ip); assert (!b); testPerturbedRayBox (box, ray, false); ray = Line3f (V3f (0, 2e15f, 2e15f), V3f (0, -2e15f, 2e15f)); b = intersects (box, ray, ip); assert (!b); testPerturbedRayBox (box, ray, false); ray = Line3f (V3f (0, 0, -2e15f), V3f (0, 0, 2e15f)); b = intersects (box, ray, ip); assert (b && ip == V3f (0, 0, -1e15f)); testPerturbedRayBox (box, ray, true); ray = Line3f (V3f (0, 0, 2e15f), V3f (0, 0, -2e15f)); b = intersects (box, ray, ip); assert (b && ip == V3f (0, 0, 1e15f)); testPerturbedRayBox (box, ray, true); ray = Line3f (V3f (2e15f, 0, -2e15f), V3f (2e15f, 0, 2e15f)); b = intersects (box, ray, ip); assert (!b); testPerturbedRayBox (box, ray, false); ray = Line3f (V3f (2e15f, 0, 2e15f), V3f (2e15f, 0, -2e15f)); b = intersects (box, ray, ip); assert (!b); testPerturbedRayBox (box, ray, false); } Box3f transformSimple (const Box3f& b, const M44f& M) { Box3f b1; for (int i = 0; i < 8; ++i) { V3f p; for (int j = 0; j < 3; ++j) p[j] = ((i >> j) & 1) ? b.max[j] : b.min[j]; b1.extendBy (p * M); } return b1; } void boxMatrixTransform() { cout << " transform box by matrix" << endl; const float e = 5 * std::numeric_limits::epsilon(); Box3f b1 (V3f (4, 5, 6), V3f (7, 8, 9)); M44f M; M.setEulerAngles (V3f (1, 2, 3)); M.translate (V3f (20, -15, 2)); Box3f b2 = transform (b1, M); Box3f b3 = affineTransform (b1, M); Box3f b4 = transformSimple (b1, M); Box3f b21; Box3f b31; transform (b1, M, b21); affineTransform (b1, M, b31); assert (approximatelyEqual (b2.min, b4.min, e)); assert (approximatelyEqual (b2.max, b4.max, e)); assert (approximatelyEqual (b3.max, b4.max, e)); assert (approximatelyEqual (b3.max, b4.max, e)); assert (b21 == b2); assert (b31 == b3); M[0][3] = 1; M[1][3] = 2; M[2][3] = 3; M[3][3] = 4; Box3f b5 = transform (b1, M); Box3f b6 = transformSimple (b1, M); Box3f b51; transform (b1, M, b51); assert (approximatelyEqual (b5.min, b6.min, e)); assert (approximatelyEqual (b5.max, b6.max, e)); assert (b51 == b5); } void pointInAndOnBox() { cout << " closest points in and on box" << endl; Box3f box (V3f (1, 2, 3), V3f (5, 4, 6)); // // Points outside the box // assert (closestPointOnBox (V3f (0, 0, 0), box) == V3f (1, 2, 3)); assert (closestPointInBox (V3f (0, 0, 0), box) == V3f (1, 2, 3)); assert (closestPointOnBox (V3f (7, 7, 7), box) == V3f (5, 4, 6)); assert (closestPointInBox (V3f (7, 7, 7), box) == V3f (5, 4, 6)); assert (closestPointOnBox (V3f (2, 3, 0), box) == V3f (2, 3, 3)); assert (closestPointInBox (V3f (2, 3, 0), box) == V3f (2, 3, 3)); assert (closestPointOnBox (V3f (2, 3, 7), box) == V3f (2, 3, 6)); assert (closestPointInBox (V3f (2, 3, 7), box) == V3f (2, 3, 6)); assert (closestPointOnBox (V3f (2, 0, 4), box) == V3f (2, 2, 4)); assert (closestPointInBox (V3f (2, 0, 4), box) == V3f (2, 2, 4)); assert (closestPointOnBox (V3f (2, 7, 4), box) == V3f (2, 4, 4)); assert (closestPointInBox (V3f (2, 7, 4), box) == V3f (2, 4, 4)); assert (closestPointOnBox (V3f (0, 3, 4), box) == V3f (1, 3, 4)); assert (closestPointInBox (V3f (0, 3, 4), box) == V3f (1, 3, 4)); assert (closestPointOnBox (V3f (7, 3, 4), box) == V3f (5, 3, 4)); assert (closestPointInBox (V3f (7, 3, 4), box) == V3f (5, 3, 4)); // // Points inside the box // assert (closestPointOnBox (V3f (1.5, 3, 5), box) == V3f (1, 3, 5)); assert (closestPointInBox (V3f (1.5, 3, 5), box) == V3f (1.5, 3, 5)); assert (closestPointOnBox (V3f (4.5, 3, 5), box) == V3f (5, 3, 5)); assert (closestPointInBox (V3f (4.5, 3, 5), box) == V3f (4.5, 3, 5)); assert (closestPointOnBox (V3f (2, 2.5, 4), box) == V3f (2, 2, 4)); assert (closestPointInBox (V3f (2, 2.5, 4), box) == V3f (2, 2.5, 4)); assert (closestPointOnBox (V3f (2, 3.5, 4), box) == V3f (2, 4, 4)); assert (closestPointInBox (V3f (2, 3.5, 4), box) == V3f (2, 3.5, 4)); assert (closestPointOnBox (V3f (2, 3, 3.5), box) == V3f (2, 3, 3)); assert (closestPointInBox (V3f (2, 3, 3.5), box) == V3f (2, 3, 3.5)); assert (closestPointOnBox (V3f (2, 3, 5.5), box) == V3f (2, 3, 6)); assert (closestPointInBox (V3f (2, 3, 5.5), box) == V3f (2, 3, 5.5)); // // Point at the center of the box. "Closest point on box" is // in at the center of +Y side // assert (closestPointOnBox (V3f (3, 3, 4.5), box) == V3f (3, 4, 4.5)); assert (closestPointInBox (V3f (3, 3, 4.5), box) == V3f (3, 3, 4.5)); } } // namespace void testBoxAlgo() { cout << "Testing box algorithms" << endl; entryAndExitPoints1(); entryAndExitPoints2(); rayBoxIntersection1(); rayBoxIntersection2(); boxMatrixTransform(); pointInAndOnBox(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testBoxAlgo.h000066400000000000000000000001661417213455000176630ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testBoxAlgo(); Imath-3.1.4/src/ImathTest/testClassification.cpp000066400000000000000000000100001417213455000216020ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include "testClassification.h" using namespace std; namespace { #if __cplusplus >= 201402L static_assert (std::is_trivially_default_constructible::value, "half is trivial and default constructible"); #endif void testClass (half h, bool finite, bool normalized, bool denormalized, bool zero, bool nan, bool infinity, bool negative) { cout.width (15); cout.precision (8); cout << h << " "; printBits (cout, h); cout << " "; if (h.isFinite()) cout << "finite "; if (h.isNormalized()) cout << "normalized "; if (h.isDenormalized()) cout << "denormalized "; if (h.isZero()) cout << "zero "; if (h.isNan()) cout << "nan "; if (h.isInfinity()) cout << "infinity "; if (h.isNegative()) cout << "negative "; cout << endl; assert (h.isFinite() == finite); assert (h.isNormalized() == normalized); assert (h.isDenormalized() == denormalized); assert (h.isZero() == zero); assert (h.isNan() == nan); assert (h.isInfinity() == infinity); assert (h.isNegative() == negative); } float floatPosInfinity() { half::uif x; x.i = 0x7f800000; return x.f; } float floatNegInfinity() { half::uif x; x.i = 0xff800000; return x.f; } float floatPosQNan1() { half::uif x; x.i = 0x7fffffff; return x.f; } float floatNegQNan1() { half::uif x; x.i = 0xffffffff; return x.f; } float floatPosQNan2() { half::uif x; x.i = 0x7fd55555; return x.f; } float floatNegQNan2() { half::uif x; x.i = 0xffd55555; return x.f; } } // namespace void testClassification() { cout << "classification of bit patterns\n\n"; // // fini norm deno zero nan inf neg // testClass (0.0, 1, 0, 0, 1, 0, 0, 0); testClass (1.0, 1, 1, 0, 0, 0, 0, 0); testClass (1.0f + HALF_EPSILON, 1, 1, 0, 0, 0, 0, 0); testClass (HALF_DENORM_MIN, 1, 0, 1, 0, 0, 0, 0); testClass (HALF_DENORM_MIN + HALF_DENORM_MIN, 1, 0, 1, 0, 0, 0, 0); testClass (HALF_NRM_MIN, 1, 1, 0, 0, 0, 0, 0); testClass (HALF_NRM_MIN + HALF_DENORM_MIN, 1, 1, 0, 0, 0, 0, 0); testClass (HALF_NRM_MIN - HALF_DENORM_MIN, 1, 0, 1, 0, 0, 0, 0); testClass (2.0f, 1, 1, 0, 0, 0, 0, 0); testClass (3.0f, 1, 1, 0, 0, 0, 0, 0); testClass (0.1f, 1, 1, 0, 0, 0, 0, 0); testClass (0.2f, 1, 1, 0, 0, 0, 0, 0); testClass (0.3f, 1, 1, 0, 0, 0, 0, 0); testClass (HALF_MAX, 1, 1, 0, 0, 0, 0, 0); testClass (floatPosInfinity(), 0, 0, 0, 0, 0, 1, 0); testClass (floatPosQNan1(), 0, 0, 0, 0, 1, 0, 0); testClass (floatPosQNan2(), 0, 0, 0, 0, 1, 0, 0); testClass (-1.0f, 1, 1, 0, 0, 0, 0, 1); testClass (-1.0f - HALF_EPSILON, 1, 1, 0, 0, 0, 0, 1); testClass (-HALF_DENORM_MIN, 1, 0, 1, 0, 0, 0, 1); testClass (-HALF_DENORM_MIN - HALF_DENORM_MIN, 1, 0, 1, 0, 0, 0, 1); testClass (-HALF_NRM_MIN, 1, 1, 0, 0, 0, 0, 1); testClass (-HALF_NRM_MIN - HALF_DENORM_MIN, 1, 1, 0, 0, 0, 0, 1); testClass (-HALF_NRM_MIN + HALF_DENORM_MIN, 1, 0, 1, 0, 0, 0, 1); testClass (-2.0f, 1, 1, 0, 0, 0, 0, 1); testClass (-3.0f, 1, 1, 0, 0, 0, 0, 1); testClass (-0.1f, 1, 1, 0, 0, 0, 0, 1); testClass (-0.2f, 1, 1, 0, 0, 0, 0, 1); testClass (-0.3f, 1, 1, 0, 0, 0, 0, 1); testClass (-HALF_MAX, 1, 1, 0, 0, 0, 0, 1); testClass (floatNegInfinity(), 0, 0, 0, 0, 0, 1, 1); testClass (floatNegQNan1(), 0, 0, 0, 0, 1, 0, 1); testClass (floatNegQNan2(), 0, 0, 0, 0, 1, 0, 1); cout << "\n"; testClass (half::posInf(), 0, 0, 0, 0, 0, 1, 0); testClass (half::negInf(), 0, 0, 0, 0, 0, 1, 1); testClass (half::qNan(), 0, 0, 0, 0, 1, 0, 0); testClass (half::sNan(), 0, 0, 0, 0, 1, 0, 0); cout << "ok\n\n" << flush; } Imath-3.1.4/src/ImathTest/testClassification.h000066400000000000000000000001751417213455000212630ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testClassification(); Imath-3.1.4/src/ImathTest/testColor.cpp000066400000000000000000000123421417213455000177400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include "testColor.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; void testColor() { cout << "Testing functions in ImathColor.h & ImathColorAlgo.h" << endl; cout << "rgb2packed -> packed2rgb" << endl; const float epsilon = std::numeric_limits::epsilon(); IMATH_INTERNAL_NAMESPACE::PackedColor packed; IMATH_INTERNAL_NAMESPACE::C3c in3 (52, 128, 254); IMATH_INTERNAL_NAMESPACE::C3c out3; packed = IMATH_INTERNAL_NAMESPACE::rgb2packed (in3); IMATH_INTERNAL_NAMESPACE::packed2rgb (packed, out3); assert (in3 == out3); IMATH_INTERNAL_NAMESPACE::C4c testConstructor1; IMATH_INTERNAL_NAMESPACE::C4c testConstructor1i (0.f); IMATH_INTERNAL_NAMESPACE::C4c testConstructor2 (testConstructor1i); testConstructor1 = testConstructor2; // use these so the compiler doesn't emit a warning IMATH_INTERNAL_NAMESPACE::C4c testConstructor3 (52, 128, 254, 127); IMATH_INTERNAL_NAMESPACE::C4c A (testConstructor3); IMATH_INTERNAL_NAMESPACE::C4c B; IMATH_INTERNAL_NAMESPACE::C4f X, Y, tmp; packed = IMATH_INTERNAL_NAMESPACE::rgb2packed (A); IMATH_INTERNAL_NAMESPACE::packed2rgb (packed, B); assert (A == B); cout << "Imath::Color4 * f" << endl; assert ((IMATH_INTERNAL_NAMESPACE::C4f (0.330f, 0.710f, 0.010f, 0.999f) * 0.999f) == IMATH_INTERNAL_NAMESPACE::C4f (0.330f * 0.999f, 0.710f * 0.999f, 0.010f * 0.999f, 0.999f * 0.999f)); cout << "Imath::Color4 / f" << endl; assert ((IMATH_INTERNAL_NAMESPACE::C4f (0.330f, 0.710f, 0.010f, 0.999f) / 0.999f) == IMATH_INTERNAL_NAMESPACE::C4f (0.330f / 0.999f, 0.710f / 0.999f, 0.010f / 0.999f, 0.999f / 0.999f)); cout << "Assignment and comparison" << endl; B = A; assert (B == A); assert (!(B != A)); X = Y = IMATH_INTERNAL_NAMESPACE::C4f (0.123f, -0.420f, 0.501f, 0.998f); X *= 0.001f; assert (std::fabs ((Y.r * 0.001f) - X.r) <= epsilon && std::fabs ((Y.g * 0.001f) - X.g) <= epsilon && std::fabs ((Y.b * 0.001f) - X.b) <= epsilon && std::fabs ((Y.a * 0.001f) - X.a) <= epsilon); X = Y = IMATH_INTERNAL_NAMESPACE::C4f (0.123f, -0.420f, 0.501f, 0.998f); X /= -1.001f; assert (std::fabs ((Y.r / -1.001f) - X.r) <= epsilon && std::fabs ((Y.g / -1.001f) - X.g) <= epsilon && std::fabs ((Y.b / -1.001f) - X.b) <= epsilon && std::fabs ((Y.a / -1.001f) - X.a) <= epsilon); Y = IMATH_INTERNAL_NAMESPACE::C4f (0.998f, -0.001f, 0.501f, 1.001f); X = IMATH_INTERNAL_NAMESPACE::C4f (0.011f, -0.420f, -0.501f, 0.998f); tmp = X + Y; assert (std::fabs ((X.r + Y.r) - tmp.r) <= epsilon && std::fabs ((X.g + Y.g) - tmp.g) <= epsilon && std::fabs ((X.b + Y.b) - tmp.b) <= epsilon && std::fabs ((X.a + Y.a) - tmp.a) <= epsilon); tmp = X - Y; assert (std::fabs ((X.r - Y.r) - tmp.r) <= epsilon && std::fabs ((X.g - Y.g) - tmp.g) <= epsilon && std::fabs ((X.b - Y.b) - tmp.b) <= epsilon && std::fabs ((X.a - Y.a) - tmp.a) <= epsilon); tmp = X * Y; assert (std::fabs ((X.r * Y.r) - tmp.r) <= epsilon && std::fabs ((X.g * Y.g) - tmp.g) <= epsilon && std::fabs ((X.b * Y.b) - tmp.b) <= epsilon && std::fabs ((X.a * Y.a) - tmp.a) <= epsilon); tmp = X / Y; // // epsilon doesn't work here. // assert (std::fabs ((X.r / Y.r) - tmp.r) <= 1e-5f && std::fabs ((X.g / Y.g) - tmp.g) <= 1e-5f && std::fabs ((X.b / Y.b) - tmp.b) <= 1e-5f && std::fabs ((X.a / Y.a) - tmp.a) <= 1e-5f); tmp = X; tmp += Y; assert (std::fabs ((X.r + Y.r) - tmp.r) <= epsilon && std::fabs ((X.g + Y.g) - tmp.g) <= epsilon && std::fabs ((X.b + Y.b) - tmp.b) <= epsilon && std::fabs ((X.a + Y.a) - tmp.a) <= epsilon); tmp = X; tmp -= Y; assert (std::fabs ((X.r - Y.r) - tmp.r) <= epsilon && std::fabs ((X.g - Y.g) - tmp.g) <= epsilon && std::fabs ((X.b - Y.b) - tmp.b) <= epsilon && std::fabs ((X.a - Y.a) - tmp.a) <= epsilon); tmp = X; tmp *= Y; assert (std::fabs ((X.r * Y.r) - tmp.r) <= epsilon && std::fabs ((X.g * Y.g) - tmp.g) <= epsilon && std::fabs ((X.b * Y.b) - tmp.b) <= epsilon && std::fabs ((X.a * Y.a) - tmp.a) <= epsilon); tmp = X; tmp /= Y; // // epsilon doesn't work here. // assert (std::fabs ((X.r / Y.r) - tmp.r) <= 1e-5f && std::fabs ((X.g / Y.g) - tmp.g) <= 1e-5f && std::fabs ((X.b / Y.b) - tmp.b) <= 1e-5f && std::fabs ((X.a / Y.a) - tmp.a) <= 1e-5f); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testColor.h000066400000000000000000000001641417213455000174040ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testColor(); Imath-3.1.4/src/ImathTest/testError.cpp000066400000000000000000000104561417213455000177570ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include "half.h" #include #include #include #include #include "testError.h" using namespace std; namespace { float drand() { static std::default_random_engine generator; static std::uniform_real_distribution distribution (0.0f, 1.0f); float r = distribution (generator); return r; } } // namespace void testNormalizedConversionError() { cout << "float-to-half conversion error for normalized half numbers\n"; float eMax = 0; for (int i = 0; i < 20000000; i++) { float f (drand() * HALF_MAX); if (f < HALF_NRM_MIN) continue; if (i & 1) f = -f; half h (f); float e = 1.0f - h / f; if (e < 0) e = -e; if (e > HALF_EPSILON * 0.5) { cout << "float = " << f << ", half = " << h << ", error = " << e << endl; assert (false); } if (e > eMax) eMax = e; } cout << "max error = " << eMax << endl; cout << "max expected error = " << HALF_EPSILON * 0.5 << endl; cout << "ok\n\n" << flush; } void testDenormalizedConversionError() { cout << "float-to-half conversion error for denormalized half numbers\n"; float eMax = 0; for (int i = 0; i < 20000000; i++) { float f (drand() * (HALF_NRM_MIN - HALF_DENORM_MIN)); if (i & 1) f = -f; half h (f); float e = h - f; if (e < 0) e = -e; if (e > HALF_DENORM_MIN * 0.5) { cout << "float = " << f << ", half = " << h << ", error = " << e << endl; assert (false); } if (e > eMax) eMax = e; } cout << "max error = " << eMax << endl; cout << "max expected error = " << HALF_DENORM_MIN * 0.5 << endl; cout << "ok\n\n" << flush; } namespace { void testNormalizedRounding (int n) { cout << "rounding normalized numbers to " << n << "-bit precision\n"; float eExpected = (n < 10) ? HALF_EPSILON * 0.5f * (1 << (10 - n)) : 0; float eMax = 0; for (int i = 0; i < 200000; i++) { half h (drand() * HALF_MAX); if (h < HALF_NRM_MIN) continue; if (i & 1) h = -h; half r (h.round (n)); float e = 1.0f - r / h; if (e < 0) e = -e; if (e > eExpected) { cout << "half = " << h << ", rounded = " << r << ", error = " << e << ", expected error = " << eExpected << endl; printBits (cout, h); cout << endl; printBits (cout, r); cout << endl; assert (false); } if (e > eMax) eMax = e; } cout << "max error = " << eMax << endl; cout << "max expected error = " << eExpected << endl; cout << "ok\n\n" << flush; } void testDenormalizedRounding (int n) { cout << "rounding denormalized numbers to " << n << "-bit precision\n"; float eExpected = (n < 10) ? HALF_DENORM_MIN * 0.5f * (1 << (10 - n)) : 0; float eMax = 0; for (int i = 0; i < 200000; i++) { half h (drand() * (HALF_NRM_MIN - HALF_DENORM_MIN)); if (i & 1) h = -h; half r (h.round (n)); float e = r - h; if (e < 0) e = -e; if (e > eExpected) { cout << "half = " << h << ", rounded = " << r << ", error = " << e << ", expected error = " << eExpected << endl; printBits (cout, h); cout << endl; printBits (cout, r); cout << endl; assert (false); } if (e > eMax) eMax = e; } cout << "max error = " << eMax << endl; cout << "max expected error = " << eExpected << endl; cout << "ok\n\n" << flush; } } // namespace void testRoundingError() { testNormalizedRounding (10); testDenormalizedRounding (10); testNormalizedRounding (9); testDenormalizedRounding (9); testNormalizedRounding (1); testDenormalizedRounding (1); testNormalizedRounding (0); testDenormalizedRounding (0); } Imath-3.1.4/src/ImathTest/testError.h000066400000000000000000000003121417213455000174120ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testNormalizedConversionError(); void testDenormalizedConversionError(); void testRoundingError(); Imath-3.1.4/src/ImathTest/testExtractEuler.cpp000066400000000000000000000132471417213455000212760ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include "testExtractEuler.h" using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { float rad (float deg) { return deg * (M_PI / 180); } M44f matrixEulerMatrix_1 (const M44f& M, Eulerf::Order order) { V3f f; if (order == Eulerf::XYZ) extractEulerXYZ (M, f); else extractEulerZYX (M, f); return Eulerf (f, order).toMatrix44(); } M44f matrixEulerMatrix_2 (const M44f& M, Eulerf::Order order) { Eulerf f (order); f.extract (M); return f.toMatrix44(); } void testMatrix (const M44f M, M44f (*matrixEulerMatrix) (const M44f&, Eulerf::Order), Eulerf::Order order) { // // Extract Euler angles from M, and convert the // Euler angles back to a matrix, N. // M44f N = matrixEulerMatrix (M, order); // // Verify that the entries in M and N do not // differ too much. // M44f D (M - N); for (int j = 0; j < 3; ++j) { for (int k = 0; k < 3; ++k) { if (abs (D[j][k]) > 0.000002) { cout << "unexpectedly large matrix to " "euler angles conversion error: " << D[j][k] << endl; cout << j << " " << k << endl; cout << "M\n" << M << endl; cout << "N\n" << N << endl; cout << "D\n" << D << endl; assert (false); } } } } void testRandomAngles (M44f (*matrixEulerMatrix) (const M44f&, Eulerf::Order), Eulerf::Order order) { Rand48 r (0); for (int i = 0; i < 100000; ++i) { // // Create a rotation matrix, M // Eulerf e (rad (r.nextf (-180, 180)), rad (r.nextf (-180, 180)), rad (r.nextf (-180, 180)), Eulerf::XYZ); M44f M (e.toMatrix44()); // // Add a small random error to the elements of M // for (int j = 0; j < 3; ++j) for (int k = 0; k < 3; ++k) M[j][k] += r.nextf (-1e-7, 1e-7); // // Extract Euler angles from M, convert the Euler angles // back to a matrix, N, and verify that the entries in M // and N do not differ too much. // testMatrix (M, matrixEulerMatrix, order); } } void testAngles (V3f angles, M44f (*matrixEulerMatrix) (const M44f&, Eulerf::Order), Eulerf::Order order) { Eulerf e (rad (angles.x), rad (angles.y), rad (angles.z), order); M44f M (e.toMatrix44()); // // With rounding errors from e.toMatrix. // testMatrix (M, matrixEulerMatrix, order); // // Without rounding errors (assuming that // all angles are multiples of 90 degrees). // for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) if (M[i][j] < -0.5) M[i][j] = -1; else if (M[i][j] > 0.5) M[i][j] = 1; else M[i][j] = 0; testMatrix (M, matrixEulerMatrix, order); } void test (M44f (*matrixEulerMatrix) (const M44f&, Eulerf::Order), Eulerf::Order order) { cout << "order = " << setbase (16) << int (order) << setbase (10) << endl; // cout << "random angles" << endl; testRandomAngles (matrixEulerMatrix, order); // cout << "special angles" << endl; for (int i = 0; i < 360; i += 90) for (int j = 0; j < 360; j += 90) for (int k = 0; k < 360; k += 90) testAngles (V3f (i, j, k), matrixEulerMatrix, order); } void testRandomAngles33() { Rand48 r (0); float eps = 8.0 * std::numeric_limits::epsilon(); for (int i = 0; i < 100000; ++i) { float angle = rad (r.nextf (-180, 180)); M33f M; M.setRotation (angle); float angleEx; extractEuler (M, angleEx); assert (IMATH_INTERNAL_NAMESPACE::equal (angle, angleEx, eps)); } } } // namespace void testExtractEuler() { cout << "Testing extraction of rotation angle from 3x3 matrices" << endl; testRandomAngles33(); cout << "Testing extraction of Euler angles from matrices" << endl; cout << "extractEulerXYZ()" << endl; test (matrixEulerMatrix_1, Eulerf::XYZ); cout << "extractEulerZYX()" << endl; test (matrixEulerMatrix_1, Eulerf::ZYX); cout << "Eulerf::extract()" << endl; test (matrixEulerMatrix_2, Eulerf::XYZ); test (matrixEulerMatrix_2, Eulerf::XZY); test (matrixEulerMatrix_2, Eulerf::YZX); test (matrixEulerMatrix_2, Eulerf::YXZ); test (matrixEulerMatrix_2, Eulerf::ZXY); test (matrixEulerMatrix_2, Eulerf::ZYX); test (matrixEulerMatrix_2, Eulerf::XZX); test (matrixEulerMatrix_2, Eulerf::XYX); test (matrixEulerMatrix_2, Eulerf::YXY); test (matrixEulerMatrix_2, Eulerf::YZY); test (matrixEulerMatrix_2, Eulerf::ZYZ); test (matrixEulerMatrix_2, Eulerf::ZXZ); test (matrixEulerMatrix_2, Eulerf::XYZr); test (matrixEulerMatrix_2, Eulerf::XZYr); test (matrixEulerMatrix_2, Eulerf::YZXr); test (matrixEulerMatrix_2, Eulerf::YXZr); test (matrixEulerMatrix_2, Eulerf::ZXYr); test (matrixEulerMatrix_2, Eulerf::ZYXr); test (matrixEulerMatrix_2, Eulerf::XZXr); test (matrixEulerMatrix_2, Eulerf::XYXr); test (matrixEulerMatrix_2, Eulerf::YXYr); test (matrixEulerMatrix_2, Eulerf::YZYr); test (matrixEulerMatrix_2, Eulerf::ZYZr); test (matrixEulerMatrix_2, Eulerf::ZXZr); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testExtractEuler.h000066400000000000000000000001731417213455000207350ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testExtractEuler(); Imath-3.1.4/src/ImathTest/testExtractSHRT.cpp000066400000000000000000000204241417213455000207750ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include #include "testExtractSHRT.h" #if 0 # define debug(x) (printf x, fflush (stdout)) #else # define debug(x) #endif using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { float rad (float deg) { return deg * (M_PI / 180); } void testMatrix (const M33f M) { // // Extract the rotation angle from M, and convert the // angle back to a matrix, N. // V2f s (0.f), t (0.f); float h, r = 0.f; if (!extractSHRT (M, s, h, r, t, true)) { cout << "Unable to extractSHRT" << std::endl; assert (false); } M33f N; N *= M33f().setScale (s); N *= M33f().setShear (h); N *= M33f().setRotation (r); N *= M33f().setTranslation (t); debug (("Re-scale: %f %f\n", s[0], s[1])); debug (("Re-shear: %f\n", h)); debug (("Re-rot : %f\n", r)); debug (("Re-trans: %f %f\n", t[0], t[1])); // // Verify that the entries in M and N do not // differ too much. // M33f D (M - N); for (int j = 0; j < 3; ++j) { for (int k = 0; k < 3; ++k) { if (abs (D[j][k]) > 0.00001) { cout << "unexpectedly large matrix to " "euler angles conversion error: " << D[j][k] << endl; cout << j << " " << k << endl; cout << "M\n" << M << endl; cout << "N\n" << N << endl; cout << "D\n" << D << endl; assert (false); } } } } void testRandomAngles33() { Rand48 random (0); for (int i = 0; i < 100000; ++i) { debug (("iteration: %d\n", i)); M33f M; // // Scale M. // V2f s (random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0)); for (int j = 0; j < 2; j++) if (random.nextf (0.0, 1.0) >= 0.5) s[j] *= -1; M *= M33f().setScale (s); // // Shear M. // float h = random.nextf (0.000001, 2.); if (random.nextf (0.0, 1.0) >= 0.5) h *= -1; M *= M33f().setShear (h); // // Rotate M. // float r = rad (random.nextf (-180, 180)); M *= M33f().setRotation (r); // // Translate M. // V2f t (random.nextf (-10, 10), random.nextf (-10, 10)); M *= M33f().setTranslation (t); // // Add a small random error to the elements of M // for (int j = 0; j < 3; ++j) for (int k = 0; k < 2; ++k) M[j][k] += random.nextf (-1e-7, 1e-7); debug (("Scale : %f %f\n", s[0], s[1])); debug (("Shear : %f\n", h)); debug (("Rot : %f\n", r)); debug (("Trans : %f %f\n", t[0], t[1])); // // Extract Euler angles from M, convert the Euler angles // back to a matrix, N, and verify that the entries in M // and N do not differ too much. // testMatrix (M); debug (("\n")); } } void testAngles33 (float angle) { M33f M; M.setRotation (rad (angle)); // // With rounding errors from e.toMatrix. // testMatrix (M); // // Without rounding errors (assuming that // all angles are multiples of 90 degrees). // for (int i = 0; i < 2; ++i) for (int j = 0; j < 2; ++j) if (M[i][j] < -0.5) M[i][j] = -1; else if (M[i][j] > 0.5) M[i][j] = 1; else M[i][j] = 0; testMatrix (M); } void testMatrix (const M44f M) { // // Extract Euler angles from M, and convert the // Euler angles back to a matrix, N. // V3f s, h, r, t; extractSHRT (M, s, h, r, t, true); M44f N; N.translate (t); // ... matrix compositions N.rotate (r); N.shear (h); N.scale (s); debug (("Re-scale: %f %f %f\n", s[0], s[1], s[2])); debug (("Re-shear: %f %f %f\n", h[0], h[1], h[2])); debug (("Re-rot : %f %f %f\n", r[0], r[1], r[2])); debug (("Re-trans: %f %f %f\n", t[0], t[1], t[2])); // // Verify that the entries in M and N do not // differ too much. // M44f D (M - N); for (int j = 0; j < 4; ++j) { for (int k = 0; k < 4; ++k) { if (abs (D[j][k]) > 0.00001) { cout << "unexpectedly large matrix to " "euler angles conversion error: " << D[j][k] << endl; cout << j << " " << k << endl; cout << "M\n" << M << endl; cout << "N\n" << N << endl; cout << "D\n" << D << endl; assert (false); } } } } void testRandomAngles44() { Rand48 random (0); for (int i = 0; i < 100000; ++i) { debug (("iteration: %d\n", i)); M44f M; // // Translate M. // V3f t (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10)); M.translate (t); // // Rotate M. // V3f r (rad (random.nextf (-180, 180)), rad (random.nextf (-180, 180)), rad (random.nextf (-180, 180))); M.rotate (r); // // Shear M. // V3f h (random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0)); for (int j = 0; j < 3; j++) if (random.nextf (0.0, 1.0) >= 0.5) h[j] *= -1; M.shear (h); // // Scale M. // V3f s (random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0)); for (int j = 0; j < 3; j++) if (random.nextf (0.0, 1.0) >= 0.5) s[j] *= -1; M.scale (s); // // Add a small random error to the elements of M // for (int j = 0; j < 4; ++j) for (int k = 0; k < 3; ++k) M[j][k] += random.nextf (-1e-7, 1e-7); debug (("Scale : %f %f %f\n", s[0], s[1], s[2])); debug (("Shear : %f %f %f\n", h[0], h[1], h[2])); debug (("Rot : %f %f %f\n", r[0], r[1], r[2])); debug (("Trans : %f %f %f\n", t[0], t[1], t[2])); // // Extract Euler angles from M, convert the Euler angles // back to a matrix, N, and verify that the entries in M // and N do not differ too much. // testMatrix (M); debug (("\n")); } } void testAngles44 (V3f angles) { Eulerf e (rad (angles.x), rad (angles.y), rad (angles.z)); M44f M (e.toMatrix44()); // // With rounding errors from e.toMatrix. // testMatrix (M); // // Without rounding errors (assuming that // all angles are multiples of 90 degrees). // for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) if (M[i][j] < -0.5) M[i][j] = -1; else if (M[i][j] > 0.5) M[i][j] = 1; else M[i][j] = 0; testMatrix (M); } void test() { cout << " random angles" << endl; cout << " 3x3" << endl; testRandomAngles33(); cout << " 4x4" << endl; testRandomAngles44(); cout << " special angles" << endl; cout << " 3x3" << endl; for (int i = 0; i < 360; i += 90) testAngles33 (float (i)); cout << " 4x4" << endl; for (int i = 0; i < 360; i += 90) for (int j = 0; j < 360; j += 90) for (int k = 0; k < 360; k += 90) testAngles44 (V3f (i, j, k)); } } // namespace void testExtractSHRT() { try { cout << "Testing extraction of scale, shear, rotation, translation " << "from matrices" << endl; cout << "Imath::extractSHRT()" << endl; test(); cout << "ok\n" << endl; } catch (std::exception& e) { cerr << " Caught exception: " << e.what() << endl; } } Imath-3.1.4/src/ImathTest/testExtractSHRT.h000066400000000000000000000001721417213455000204400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testExtractSHRT(); Imath-3.1.4/src/ImathTest/testFrustum.cpp000066400000000000000000000344171417213455000203360ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include "testFrustum.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; namespace { void testFrustumPlanes (IMATH_INTERNAL_NAMESPACE::Frustumf& frustum) { bool ortho = frustum.orthographic(); IMATH_INTERNAL_NAMESPACE::V3f o (0.0f, 0.0f, 0.0f); float eps = 5.0e-4; for (auto xRo : { 0.0f, 100.0f, 200.0f }) { for (auto yRo : { 0.0f, 105.0f, 210.0f, 315.0f }) { for (auto zRo : { 0.0f, 110.0f, 220.0f, 330.0f }) { for (auto xTr : { -10.0f, -8.0f, -6.0f, -4.0f, -2.0f, 0.0f, 2.0f, 4.0f, 6.0f, 8.0f }) { for (auto yTr : { -10.0f, -7.0f, -4.0f, -1.0f, 2.0f, 5.0f, 8.0f }) { for (auto zTr : { -10.0f, -6.0f, -2.0f, 2.0f, 6.0f }) { float xRoRad = xRo * (2.0f * float (M_PI) / 360.0f); float yRoRad = yRo * (2.0f * float (M_PI) / 360.0f); float zRoRad = zRo * (2.0f * float (M_PI) / 360.0f); IMATH_INTERNAL_NAMESPACE::Eulerf e (xRoRad, yRoRad, zRoRad); IMATH_INTERNAL_NAMESPACE::M44f mView = e.toMatrix44(); mView.translate (IMATH_INTERNAL_NAMESPACE::V3f (xTr, yTr, zTr)); IMATH_INTERNAL_NAMESPACE::Plane3f planes0[6]; frustum.planes (planes0); IMATH_INTERNAL_NAMESPACE::Plane3f planes[6]; frustum.planes (planes, mView); IMATH_INTERNAL_NAMESPACE::V3f up = IMATH_INTERNAL_NAMESPACE::V3f (0, 1, 0); assert ((up ^ planes0[0].normal) > 0.0); mView.multDirMatrix (up, up); assert ((up ^ planes[0].normal) > 0.0); IMATH_INTERNAL_NAMESPACE::V3f pt = (!ortho) ? o : IMATH_INTERNAL_NAMESPACE::V3f (0.0f, frustum.top(), 0.0f); float d = planes0[0].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); pt = pt * mView; d = planes[0].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); IMATH_INTERNAL_NAMESPACE::V3f right = IMATH_INTERNAL_NAMESPACE::V3f (1, 0, 0); assert ((right ^ planes0[1].normal) > 0.0); mView.multDirMatrix (right, right); assert ((right ^ planes[1].normal) > 0.0); pt = (!ortho) ? o : IMATH_INTERNAL_NAMESPACE::V3f (frustum.right(), 0.0f, 0.0f); d = planes0[1].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); pt = pt * mView; d = planes[1].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); IMATH_INTERNAL_NAMESPACE::V3f down = IMATH_INTERNAL_NAMESPACE::V3f (0, -1, 0); assert ((down ^ planes0[2].normal) > 0.0); mView.multDirMatrix (down, down); assert ((down ^ planes[2].normal) > 0.0); pt = (!ortho) ? o : IMATH_INTERNAL_NAMESPACE::V3f (0.0f, frustum.bottom(), 0.0f); d = planes0[2].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); pt = pt * mView; d = planes[2].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); IMATH_INTERNAL_NAMESPACE::V3f left = IMATH_INTERNAL_NAMESPACE::V3f (-1, 0, 0); assert ((left ^ planes0[3].normal) > 0.0); mView.multDirMatrix (left, left); assert ((left ^ planes[3].normal) > 0.0); pt = (!ortho) ? o : IMATH_INTERNAL_NAMESPACE::V3f (frustum.left(), 0.0f, 0.0f); d = planes0[3].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); pt = pt * mView; d = planes[3].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); IMATH_INTERNAL_NAMESPACE::V3f front = IMATH_INTERNAL_NAMESPACE::V3f (0, 0, 1); assert ((front ^ planes0[4].normal) > 0.0); mView.multDirMatrix (front, front); assert ((front ^ planes[4].normal) > 0.0); pt = IMATH_INTERNAL_NAMESPACE::V3f (0.0f, 0.0f, -frustum.nearPlane()); d = planes0[4].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); pt = pt * mView; d = planes[4].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); IMATH_INTERNAL_NAMESPACE::V3f back = IMATH_INTERNAL_NAMESPACE::V3f (0, 0, -1); assert ((back ^ planes0[5].normal) > 0.0); mView.multDirMatrix (back, back); assert ((back ^ planes[5].normal) > 0.0); pt = IMATH_INTERNAL_NAMESPACE::V3f (0.0f, 0.0f, -frustum.farPlane()); d = planes0[5].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); pt = pt * mView; d = planes[5].distanceTo (pt); assert (IMATH_INTERNAL_NAMESPACE::iszero (d, eps)); } } } } } } } } // namespace void testFrustum() { cout << "Testing functions in ImathFrustum.h"; cout << "\nperspective "; float n = 1.7; float f = 567.0; float l = -3.5; float r = 2.0; float b = -1.3; float t = 0.9; IMATH_INTERNAL_NAMESPACE::Frustum frustum (n, f, l, r, t, b, false); assert (IMATH_INTERNAL_NAMESPACE::abs (frustum.fovx() - (atan2 (r, n) - atan2 (l, n))) < 1e-6); assert (IMATH_INTERNAL_NAMESPACE::abs (frustum.fovy() - (atan2 (t, n) - atan2 (b, n))) < 1e-6); cout << "1"; assert (IMATH_INTERNAL_NAMESPACE::abs (frustum.aspectExc() - ((r - l) / (t - b))) < 1e-6); assert (IMATH_INTERNAL_NAMESPACE::abs (frustum.aspect() - ((r - l) / (t - b))) < 1e-6); cout << "2"; IMATH_INTERNAL_NAMESPACE::M44f m = frustum.projectionMatrixExc(); assert (IMATH_INTERNAL_NAMESPACE::abs (m[0][0] - ((2 * n) / (r - l))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][1]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][2]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][0]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][1] - ((2 * n) / (t - b))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][2]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][0] - ((r + l) / (r - l))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][1] - ((t + b) / (t - b))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][2] - (-(f + n) / (f - n))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][3] - -1.0) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][0]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][1]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][2] - ((-2 * f * n) / (f - n))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][3]) < 1e-6); m = frustum.projectionMatrix(); assert (IMATH_INTERNAL_NAMESPACE::abs (m[0][0] - ((2 * n) / (r - l))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][1]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][2]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][0]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][1] - ((2 * n) / (t - b))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][2]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][0] - ((r + l) / (r - l))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][1] - ((t + b) / (t - b))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][2] - (-(f + n) / (f - n))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][3] - -1.0) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][0]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][1]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][2] - ((-2 * f * n) / (f - n))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][3]) < 1e-6); cout << "3"; cout << "\nplanes "; testFrustumPlanes (frustum); cout << "\nexceptions "; IMATH_INTERNAL_NAMESPACE::Frustum badFrustum; bool caught; badFrustum.set (n, n, l, r, t, b, false); caught = false; try { (void) badFrustum.projectionMatrixExc(); assert (!"near == far didn't throw an exception"); } catch (std::domain_error&) { caught = true; } assert (caught); cout << "1"; badFrustum.set (n, f, l, l, t, b, false); caught = false; try { (void) badFrustum.projectionMatrixExc(); assert (!"left == right didn't throw an exception"); } catch (std::domain_error&) { caught = true; } assert (caught); cout << "2"; badFrustum.set (n, f, l, r, t, t, false); caught = false; try { (void) badFrustum.projectionMatrixExc(); assert (!"top == bottom didn't throw an exception"); } catch (std::domain_error&) { caught = true; } assert (caught); cout << "3"; cout << "\northographic "; frustum.setOrthographic (true); m = frustum.projectionMatrix(); assert (IMATH_INTERNAL_NAMESPACE::abs (m[0][0] - (2 / (r - l))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][1]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][2]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[0][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][0]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][1] - (2 / (t - b))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][2]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[1][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][0]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][1]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][2] - (-2 / (f - n))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[2][3]) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][0] - (-(r + l) / (r - l))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][1] - (-(t + b) / (t - b))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][2] - (-(f + n) / (f - n))) < 1e-6 && IMATH_INTERNAL_NAMESPACE::abs (m[3][3] - 1.0) < 1e-6); cout << "1"; cout << "\nplanes "; testFrustumPlanes (frustum); // TODO - There are many little functions in IMATH_INTERNAL_NAMESPACE::Frustum which // aren't tested here. Those test should be added. But this is // a start. IMATH_INTERNAL_NAMESPACE::Frustum f1 (n, f, l, r, t, b, false); IMATH_INTERNAL_NAMESPACE::Frustum f2 (n, f, l, r, t, b, true); assert (f1 != f2); f2.set (n + 0.1, f, l, r, t, b, false); assert (f1 != f2); f2.set (n, f + 0.1, l, r, t, b, false); assert (f1 != f2); f2.set (n, f, l + 0.1, r, t, b, false); assert (f1 != f2); f2.set (n, f, l, r + 0.1, t, b, false); assert (f1 != f2); f2.set (n, f, l, r, t + 0.1, b, false); assert (f1 != f2); f2.set (n, f, l, r, t, b + 0.1, false); assert (f1 != f2); cout << "\npassed inequality test"; f1 = f2; assert (f1 == f2); cout << "\npassed equality test"; long zMax = 100; long zMin = 1; float zero = 0; float one = 1; IMATH_INTERNAL_NAMESPACE::Vec3 v3 (zero, zero, one); f1.set (n, f, one, zero, one); f2.setExc (n, f, one, zero, one); assert (f1 == f2); assert (f1.ZToDepth (zMin, zMin, zMax) == f1.ZToDepthExc (zMin, zMin, zMax)); assert (f1.normalizedZToDepth (zMin) == f1.normalizedZToDepthExc (zMin)); assert (f1.DepthToZ (n, zMin, zMax) == f1.DepthToZExc (n, zMin, zMax)); assert (f1.worldRadius (v3, one) == f1.worldRadiusExc (v3, one)); assert (f1.screenRadius (v3, one) == f1.screenRadiusExc (v3, one)); assert (f1.projectPointToScreen (v3) == f1.projectPointToScreenExc (v3)); cout << "\npassed noexcept equality verification"; cout << "\nok\n\n"; } Imath-3.1.4/src/ImathTest/testFrustum.h000066400000000000000000000001661417213455000177750ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testFrustum(); Imath-3.1.4/src/ImathTest/testFrustumTest.cpp000066400000000000000000000134451417213455000211740ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include "testFrustumTest.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; void testFrustumTest() { cout << "Testing functions in ImathFrustumTest.h"; cout << "\nisVisible(Vec3) "; float n = 1.7; float f = 567.0; float l = -3.5; float r = 2.0; float b = -1.3; float t = 0.9; IMATH_INTERNAL_NAMESPACE::Frustum frustum (n, f, l, r, t, b, false); IMATH_INTERNAL_NAMESPACE::Matrix44 cameraMat; IMATH_INTERNAL_NAMESPACE::Vec3 cameraPos (100.0f, 200.0f, 300.0f); cameraMat.makeIdentity(); cameraMat.translate (cameraPos); IMATH_INTERNAL_NAMESPACE::FrustumTest frustumTest (frustum, cameraMat); ///////////////////////////////////////////////////// // Test Vec3's IMATH_INTERNAL_NAMESPACE::Vec3 insideVec (100.0f, 200.0f, 300 - 2.0f); IMATH_INTERNAL_NAMESPACE::Vec3 outsideVec_near (100.0f, 200.0f, 300 - 1.5f); IMATH_INTERNAL_NAMESPACE::Vec3 outsideVec_far (100.0f, 200.0f, 300 - 568.0f); IMATH_INTERNAL_NAMESPACE::Vec3 outsideVec_side (100.0f, 200.0f + 100.0f, 300 - 2.0f); IMATH_INTERNAL_NAMESPACE::Vec3 outsideVec_up (100.0f + 100.0f, 200.0f, 300 - 2.0f); assert (frustumTest.isVisible (insideVec)); assert (!frustumTest.isVisible (outsideVec_near)); assert (!frustumTest.isVisible (outsideVec_far)); assert (!frustumTest.isVisible (outsideVec_side)); assert (!frustumTest.isVisible (outsideVec_up)); cout << "passed Vec3\n"; ///////////////////////////////////////////////////// // Test Boxes IMATH_INTERNAL_NAMESPACE::Vec3 tinySize (0.0001f, 0.0001f, 0.0001f); IMATH_INTERNAL_NAMESPACE::Vec3 hugeSize (1000.0f, 1000.0f, 1000.0f); // Empty box should NOT be visible assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box>())); // Tiny box inside the frust should be visible assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( insideVec + tinySize, insideVec + tinySize))); // Huge boxes inside and outside should be visible assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( insideVec - hugeSize, insideVec + hugeSize))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_near - hugeSize, outsideVec_near + hugeSize))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_far - hugeSize, outsideVec_far + hugeSize))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_side - hugeSize, outsideVec_side + hugeSize))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_up - hugeSize, outsideVec_up + hugeSize))); // Tiny boxes outside should NOT be visible assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_near - tinySize, outsideVec_near + tinySize))); assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_far - tinySize, outsideVec_far + tinySize))); assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_side - tinySize, outsideVec_side + tinySize))); assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Box> ( outsideVec_up - tinySize, outsideVec_up + tinySize))); cout << "passed Box\n"; ///////////////////////////////////////////////////// // Test Spheres float tinyRadius = 0.0001f; float hugeRadius = 1000.0f; // Tiny sphere inside the frust should be visible assert ( frustumTest.isVisible (IMATH_INTERNAL_NAMESPACE::Sphere3 (insideVec, tinyRadius))); // Huge spheres inside and outside should be visible assert ( frustumTest.isVisible (IMATH_INTERNAL_NAMESPACE::Sphere3 (insideVec, hugeRadius))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_near, hugeRadius))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_far, hugeRadius))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_side, hugeRadius))); assert (frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_up, hugeRadius))); // Tiny spheres outside should NOT be visible assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_near, tinyRadius))); assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_far, tinyRadius))); assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_side, tinyRadius))); assert (!frustumTest.isVisible ( IMATH_INTERNAL_NAMESPACE::Sphere3 (outsideVec_up, tinyRadius))); cout << "passed Sphere\n"; cout << "\nok\n\n"; } Imath-3.1.4/src/ImathTest/testFrustumTest.h000066400000000000000000000001721417213455000206320ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testFrustumTest(); Imath-3.1.4/src/ImathTest/testFun.cpp000066400000000000000000000250561417213455000174200ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #if __cplusplus >= 202002L # include #endif #include #include #include #include #include #include "testFun.h" using namespace std; #if __cplusplus < 202002L template static inline To bit_cast (From from) { static_assert (sizeof (From) == sizeof (To), "Type sizes do not match"); union { From f; To t; } u; u.f = from; return u.t; } #endif void testf (float f, bool changeExpected = true) { printf ("\n"); float sf = IMATH_INTERNAL_NAMESPACE::succf (f); float pf = IMATH_INTERNAL_NAMESPACE::predf (f); float spf = IMATH_INTERNAL_NAMESPACE::succf (IMATH_INTERNAL_NAMESPACE::predf (f)); float psf = IMATH_INTERNAL_NAMESPACE::predf (IMATH_INTERNAL_NAMESPACE::succf (f)); printf ("f %.9g %x\n", f, bit_cast(f)); printf ("sf %.9g %x\n", sf, bit_cast(sf)); printf ("pf %.9g %x\n", pf, bit_cast(pf)); printf ("spf %.9g %x\n", spf, bit_cast(spf)); printf ("psf %.9g %x\n", psf, bit_cast(psf)); fflush (stdout); if (changeExpected) { assert (pf < f); assert (f < sf); } else { if (isnan(f)) { // If f is nan, pf and sf may be converted from signaling // to quiet nan, but they'll still be nan's. assert (isnan(pf)); assert (isnan(sf)); } else { // No bit change expected if input was inf. assert (bit_cast (pf) == bit_cast (f)); assert (bit_cast (sf) == bit_cast (f)); } } } void testd (double d, bool changeExpected = true) { printf ("\n"); double sd = IMATH_INTERNAL_NAMESPACE::succd (d); double pd = IMATH_INTERNAL_NAMESPACE::predd (d); double spd = IMATH_INTERNAL_NAMESPACE::succd (IMATH_INTERNAL_NAMESPACE::predd (d)); double psd = IMATH_INTERNAL_NAMESPACE::predd (IMATH_INTERNAL_NAMESPACE::succd (d)); printf ("d %0.18lg %lx\n", d, bit_cast(d)); printf ("sd %0.18lg %lx\n", sd, bit_cast(sd)); printf ("pd %0.18lg %lx\n", pd, bit_cast(pd)); printf ("spd %0.18lg %lx\n", spd, bit_cast(spd)); printf ("psd %0.18lg %lx\n", psd, bit_cast(psd)); fflush (stdout); if (changeExpected) { assert (pd < d); assert (d < sd); } else { if (isnan(d)) { // If f is nan, pf and sf may be converted from signaling // to quiet nan, but they'll still be nan's. assert (isnan(pd)); assert (isnan(sd)); } else { // No bit change expected if input was inf. assert (bit_cast (pd) == bit_cast (d)); assert (bit_cast (sd) == bit_cast (d)); } } } void testFun() { cout << "Testing functions in ImathFun.h" << endl; cout << "floor" << endl; assert (IMATH_INTERNAL_NAMESPACE::floor (0.0f) == 0); assert (IMATH_INTERNAL_NAMESPACE::floor (0.5f) == 0); assert (IMATH_INTERNAL_NAMESPACE::floor (-0.5f) == -1); assert (IMATH_INTERNAL_NAMESPACE::floor (1.0f) == 1); assert (IMATH_INTERNAL_NAMESPACE::floor (-1.0f) == -1); assert (IMATH_INTERNAL_NAMESPACE::floor (1.5f) == 1); assert (IMATH_INTERNAL_NAMESPACE::floor (-1.5f) == -2); cout << "ceil" << endl; assert (IMATH_INTERNAL_NAMESPACE::ceil (0.0f) == 0); assert (IMATH_INTERNAL_NAMESPACE::ceil (0.5f) == 1); assert (IMATH_INTERNAL_NAMESPACE::ceil (-0.5f) == 0); assert (IMATH_INTERNAL_NAMESPACE::ceil (1.0f) == 1); assert (IMATH_INTERNAL_NAMESPACE::ceil (-1.0f) == -1); assert (IMATH_INTERNAL_NAMESPACE::ceil (1.5f) == 2); assert (IMATH_INTERNAL_NAMESPACE::ceil (-1.5f) == -1); cout << "trunc" << endl; assert (IMATH_INTERNAL_NAMESPACE::trunc (0.0f) == 0); assert (IMATH_INTERNAL_NAMESPACE::trunc (0.5f) == 0); assert (IMATH_INTERNAL_NAMESPACE::trunc (-0.5f) == 0); assert (IMATH_INTERNAL_NAMESPACE::trunc (1.0f) == 1); assert (IMATH_INTERNAL_NAMESPACE::trunc (-1.0f) == -1); assert (IMATH_INTERNAL_NAMESPACE::trunc (1.5f) == 1); assert (IMATH_INTERNAL_NAMESPACE::trunc (-1.5f) == -1); cout << "divs / mods" << endl; assert (IMATH_INTERNAL_NAMESPACE::divs (5, 2) == 2 && IMATH_INTERNAL_NAMESPACE::mods (5, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divs (4, 2) == 2 && IMATH_INTERNAL_NAMESPACE::mods (4, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (3, 2) == 1 && IMATH_INTERNAL_NAMESPACE::mods (3, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divs (2, 2) == 1 && IMATH_INTERNAL_NAMESPACE::mods (2, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (1, 2) == 0 && IMATH_INTERNAL_NAMESPACE::mods (1, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divs (0, 2) == 0 && IMATH_INTERNAL_NAMESPACE::mods (0, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (-1, 2) == 0 && IMATH_INTERNAL_NAMESPACE::mods (-1, 2) == -1); assert (IMATH_INTERNAL_NAMESPACE::divs (-2, 2) == -1 && IMATH_INTERNAL_NAMESPACE::mods (-2, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (-3, 2) == -1 && IMATH_INTERNAL_NAMESPACE::mods (-3, 2) == -1); assert (IMATH_INTERNAL_NAMESPACE::divs (-4, 2) == -2 && IMATH_INTERNAL_NAMESPACE::mods (-4, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (-5, 2) == -2 && IMATH_INTERNAL_NAMESPACE::mods (-5, 2) == -1); assert (IMATH_INTERNAL_NAMESPACE::divs (5, -2) == -2 && IMATH_INTERNAL_NAMESPACE::mods (5, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divs (4, -2) == -2 && IMATH_INTERNAL_NAMESPACE::mods (4, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (3, -2) == -1 && IMATH_INTERNAL_NAMESPACE::mods (3, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divs (2, -2) == -1 && IMATH_INTERNAL_NAMESPACE::mods (2, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (1, -2) == 0 && IMATH_INTERNAL_NAMESPACE::mods (1, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divs (0, -2) == 0 && IMATH_INTERNAL_NAMESPACE::mods (0, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (-1, -2) == 0 && IMATH_INTERNAL_NAMESPACE::mods (-1, -2) == -1); assert (IMATH_INTERNAL_NAMESPACE::divs (-2, -2) == 1 && IMATH_INTERNAL_NAMESPACE::mods (-2, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (-3, -2) == 1 && IMATH_INTERNAL_NAMESPACE::mods (-3, -2) == -1); assert (IMATH_INTERNAL_NAMESPACE::divs (-4, -2) == 2 && IMATH_INTERNAL_NAMESPACE::mods (-4, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divs (-5, -2) == 2 && IMATH_INTERNAL_NAMESPACE::mods (-5, -2) == -1); cout << "divp / modp" << endl; assert (IMATH_INTERNAL_NAMESPACE::divp (5, 2) == 2 && IMATH_INTERNAL_NAMESPACE::modp (5, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (4, 2) == 2 && IMATH_INTERNAL_NAMESPACE::modp (4, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (3, 2) == 1 && IMATH_INTERNAL_NAMESPACE::modp (3, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (2, 2) == 1 && IMATH_INTERNAL_NAMESPACE::modp (2, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (1, 2) == 0 && IMATH_INTERNAL_NAMESPACE::modp (1, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (0, 2) == 0 && IMATH_INTERNAL_NAMESPACE::modp (0, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (-1, 2) == -1 && IMATH_INTERNAL_NAMESPACE::modp (-1, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (-2, 2) == -1 && IMATH_INTERNAL_NAMESPACE::modp (-2, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (-3, 2) == -2 && IMATH_INTERNAL_NAMESPACE::modp (-3, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (-4, 2) == -2 && IMATH_INTERNAL_NAMESPACE::modp (-4, 2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (-5, 2) == -3 && IMATH_INTERNAL_NAMESPACE::modp (-5, 2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (5, -2) == -2 && IMATH_INTERNAL_NAMESPACE::modp (5, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (4, -2) == -2 && IMATH_INTERNAL_NAMESPACE::modp (4, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (3, -2) == -1 && IMATH_INTERNAL_NAMESPACE::modp (3, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (2, -2) == -1 && IMATH_INTERNAL_NAMESPACE::modp (2, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (1, -2) == 0 && IMATH_INTERNAL_NAMESPACE::modp (1, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (0, -2) == 0 && IMATH_INTERNAL_NAMESPACE::modp (0, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (-1, -2) == 1 && IMATH_INTERNAL_NAMESPACE::modp (-1, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (-2, -2) == 1 && IMATH_INTERNAL_NAMESPACE::modp (-2, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (-3, -2) == 2 && IMATH_INTERNAL_NAMESPACE::modp (-3, -2) == 1); assert (IMATH_INTERNAL_NAMESPACE::divp (-4, -2) == 2 && IMATH_INTERNAL_NAMESPACE::modp (-4, -2) == 0); assert (IMATH_INTERNAL_NAMESPACE::divp (-5, -2) == 3 && IMATH_INTERNAL_NAMESPACE::modp (-5, -2) == 1); cout << "successor, predecessor" << endl; testf (0); testf (0.0 * -1.0); testf (1); testf (-1); testf (16); testf (7); testf (0.7); union {float f; uint32_t i;} u; u.i = 0x7f800000; // inf testf (u.f, false); u.i = 0xff800000; // -inf testf (u.f, false); u.i = 0x7f800001; // nan testf (u.f, false); u.i = 0x7f7fffff; // FLT_MAX testf (u.f); u.i = 0xff7fffff; // -FLT_MAX testf (u.f); testd (0); testd (0.0 * -1.0); testd (1); testd (-1); testd (16); testd (7); testd (0.7); union {double d; uint64_t i;} v; v.i = 0x7ff0000000000000ULL; // inf testd (v.d, false); v.i = 0xfff0000000000000ULL; // -inf testd (v.d, false); v.i = 0x7ff0000000000001ULL; // NAN testd (v.d, false); v.i = 0x7fefffffffffffffULL; // FLT_MAX testd (v.d); v.i = 0xffefffffffffffffULL; // -FLT_MAX testd (v.d); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testFun.h000066400000000000000000000001621417213455000170540ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testFun(); Imath-3.1.4/src/ImathTest/testFunction.cpp000066400000000000000000000031161417213455000204460ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include "halfFunction.h" #include #include #include "testFunction.h" using namespace std; namespace { float divideByTwo (float x) { return x / 2; } struct timesN { timesN (float n) : n (n) {} float operator() (float x) { return x * n; } float n; }; } // namespace void testFunction() { cout << "halfFunction\n"; halfFunction d2 (divideByTwo); assert (d2 (0) == 0); assert (d2 (2) == 1); assert (d2 (-2) == -1); assert (d2 (HALF_MAX) == HALF_MAX / 2); assert (d2 (-HALF_MAX) == -HALF_MAX / 2); assert (d2 (half::posInf()) == 0); assert (d2 (half::negInf()) == 0); assert (d2 (half::qNan()) == 0); halfFunction t5 (timesN (5), // function 0, HALF_MAX / 8, // domain -1, // default value half::posInf(), // posInfValue half::negInf(), // negInfValue half::qNan()); // nanValue assert (t5 (0) == 0); assert (t5 (2) == 10); assert (t5 (-2) == -1); assert (t5 (HALF_MAX) == -1); assert (t5 (-HALF_MAX) == -1); assert (t5 (half::posInf()).isInfinity()); assert (!t5 (half::posInf()).isNegative()); assert (t5 (half::negInf()).isInfinity()); assert (t5 (half::negInf()).isNegative()); assert (t5 (half::qNan()).isNan()); cout << "ok\n\n" << flush; } Imath-3.1.4/src/ImathTest/testFunction.h000066400000000000000000000001671417213455000201160ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testFunction(); Imath-3.1.4/src/ImathTest/testInterop.cpp000066400000000000000000000655151417213455000203140ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include #include "testVec.h" using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; // Imath::has_subscript fails for std::vector because its length does not // appear to be the length of N elements. Carve out an exception here that // allows this to work. IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER template struct has_subscript, T, N> : public std::true_type { }; IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT #if IMATH_FOREIGN_VECTOR_INTEROP namespace { // Extra simple vector that does nothing but allow element access, as an // example of a vector type that an app might use and want interop with // our vectors. template struct SimpleVec { T elements[N]; SimpleVec(T val = T(0)) { for (int i = 0; i < N; ++i) elements[i] = val; } ~SimpleVec() = default; constexpr T operator[](int i) const { return elements[i]; } T& operator[](int i) { return elements[i]; } }; // Extra simple matrix that does nothing but allow element access, as an // example of a matrix type that an app might use and want interop with // our vectors. template struct SimpleMx { T elements[N][N]; SimpleMx(T val = T(0)) { for (int j = 0; j < N; ++j) for (int i = 0; i < N; ++i) elements[j][i] = val; } ~SimpleMx() = default; const T* operator[](int i) const { return elements[i]; } T* operator[](int i) { return elements[i]; } }; // Small structs containing just x,y,z,w elements. template struct xy { T x, y; }; template struct xyz { T x, y, z; }; template struct xyzw { T x, y, z, w; }; template struct xyz_wrong { T x() { return 0; } T y() { return 1; } T z() { return 2; } }; // A class that has *both* subscripting and named members template struct ComboVec2 { union { T elements[2]; struct { T x, y; }; }; ComboVec2(T val = T(0)) : x(val), y(val) { } ~ComboVec2() = default; constexpr T operator[](int i) const { return elements[i]; } T& operator[](int i) { return elements[i]; } }; // A class that has *both* subscripting and named members template struct ComboVec3 { union { T elements[3]; struct { T x, y, z; }; }; ComboVec3(T val = T(0)) : x(val), y(val), z(val) { } ~ComboVec3() = default; constexpr T operator[](int i) const { return elements[i]; } T& operator[](int i) { return elements[i]; } }; // A class that has *both* subscripting and named members template struct ComboVec4 { union { T elements[4]; struct { T x, y, z, w; }; }; ComboVec4(T val = T(0)) : x(val), y(val), z(val), w(val) { } ~ComboVec4() = default; constexpr T operator[](int i) const { return elements[i]; } T& operator[](int i) { return elements[i]; } }; // Test whether a Vec contains the given elements. void testVecVal2f(const V2f& v, float a, float b) { assert(v[0] == a && v[1] == b); } void testVecVal3f(const V3f& v, float a, float b, float c) { assert(v[0] == a && v[1] == b && v[2] == c); } void testVecVal4f(const V4f& v, float a, float b, float c, float d) { assert(v[0] == a && v[1] == b && v[2] == c && v[3] == d); } void testInteropVec2() { std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "has_xy, float>::value = " << has_xy, float>::value << "\n"; std::cout << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "\n"; std::cout << "has_xy, float, 2>::value = " << has_xy, float>::value << "\n"; std::cout << "has_subscript, float, 2>::value = " << has_subscript, float, 2>::value << "\n"; std::cout << "\n"; assert((!has_xy, float>::value)); assert((has_xy, float>::value)); assert((!has_xy, float>::value)); assert((has_subscript, float, 2>::value)); assert((!has_subscript, float, 2>::value)); assert((!has_subscript, int, 2>::value)); assert((!has_subscript, float, 2>::value)); assert((!has_subscript, float, 2>::value)); // Test construction/assignment/paramater pass of a vector type with // subscripting to access components. { SimpleVec s; s[0] = 1; s[1] = 2; Vec2 v(s); assert(v[0] == 1 && v[1] == 2); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42); testVecVal2f(V2f(s), 1.0f, 42.0f); } // Test construction/assignment/paramater pass of a vector type with // explicit .y, .y, .z components but no subscripting. { xy s { 1, 2 }; Vec2 v(s); assert(v[0] == 1 && v[1] == 2); s.y = 42; v = s; assert(v[0] == 1 && v[1] == 42); testVecVal2f(V2f(s), 1.0f, 42.0f); } // Test construction/assignment/paramater pass of a std::vector of length 3 { std::vector s { 1, 2 }; Vec2 v(s); assert(v[0] == 1 && v[1] == 2); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42); testVecVal2f(V2f(s), 1.0f, 42.0f); } // Test construction/assignment/paramater pass of a std::array of length 3 { std::array s { 1, 2 }; Vec2 v(s); assert(v[0] == 1 && v[1] == 2); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42); testVecVal2f(V2f(s), 1.0f, 42.0f); } // Test construction/assignment/paramater pass of initializer lists. { Vec2 v({ 1.0f, 2.0f }); assert(v[0] == 1 && v[1] == 2); v = { 1.0f, 42.0f }; assert(v[0] == 1 && v[1] == 42); testVecVal2f({ 1.0f, 42.0f}, 1.0f, 42.0f); } // Test construction/assignment/paramater pass of a C array { float s[2] = { 1, 2 }; Vec2 v(s); assert(v[0] == 1 && v[1] == 2); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42); testVecVal2f(V2f(s), 1.0f, 42.0f); } } //--------- void testInteropVec3() { std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_xyz, float>::value = " << has_xyz, float>::value << "\n"; std::cout << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "\n"; std::cout << "has_xyz, float, 3>::value = " << has_xyz, float>::value << "\n"; std::cout << "has_subscript, float, 3>::value = " << has_subscript, float, 3>::value << "\n"; std::cout << "\n"; assert((!has_xyz, float>::value)); assert((has_xyz, float>::value)); assert((!has_xyz, float>::value)); assert((has_subscript, float, 3>::value)); assert((!has_subscript, float, 3>::value)); assert((!has_subscript, int, 3>::value)); assert((!has_subscript, float, 3>::value)); assert((!has_subscript, float, 3>::value)); // Test construction/assignment/paramater pass of a vector type with // subscripting to access components. { SimpleVec s; s[0] = 1; s[1] = 2; s[2] = 3; Vec3 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3); testVecVal3f(V3f(s), 1.0f, 42.0f, 3.0f); } // Test construction/assignment/paramater pass of a vector type with // explicit .y, .y, .z components but no subscripting. { xyz s { 1, 2, 3 }; Vec3 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3); s.y = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3); testVecVal3f(V3f(s), 1.0f, 42.0f, 3.0f); } // Test construction/assignment/paramater pass of a std::vector of length 3 { std::vector s { 1, 2, 3 }; Vec3 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3); testVecVal3f(V3f(s), 1.0f, 42.0f, 3.0f); } // Test construction/assignment/paramater pass of a std::array of length 3 { std::array s { 1, 2, 3 }; Vec3 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3); testVecVal3f(V3f(s), 1.0f, 42.0f, 3.0f); } // Test construction/assignment/paramater pass of initializer lists. { Vec3 v({ 1.0f, 2.0f, 3.0f }); assert(v[0] == 1 && v[1] == 2 && v[2] == 3); v = { 1.0f, 42.0f, 3.0f }; assert(v[0] == 1 && v[1] == 42 && v[2] == 3); testVecVal3f({ 1.0f, 42.0f, 3.0f }, 1, 42, 3); } // Test construction/assignment/paramater pass of a C array { float s[3] = { 1, 2, 3 }; Vec3 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3); testVecVal3f(V3f(s), 1.0f, 42.0f, 3.0f); } } //--------- void testInteropVec4() { std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_xyzw, float>::value = " << has_xyzw, float>::value << "\n"; std::cout << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "\n"; std::cout << "has_xyzw, float, 4>::value = " << has_xyzw, float>::value << "\n"; std::cout << "has_subscript, float, 4>::value = " << has_subscript, float, 4>::value << "\n"; std::cout << "\n"; assert((!has_xyzw, float>::value)); assert((has_xyzw, float>::value)); assert((!has_xyzw, float>::value)); assert((has_subscript, float, 4>::value)); assert((!has_subscript, float, 3>::value)); assert((!has_subscript, int, 4>::value)); assert((!has_subscript, float, 4>::value)); assert((!has_subscript, float, 4>::value)); // Test construction/assignment/paramater pass of a vector type with // subscripting to access components. { SimpleVec s; s[0] = 1; s[1] = 2; s[2] = 3; s[3] = 4; Vec4 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3 && v[3] == 4); testVecVal4f(V4f(s), 1.0f, 42.0f, 3.0f, 4.0f); } // Test construction/assignment/paramater pass of a vector type with // explicit .y, .y, .z components but no subscripting. { xyzw s { 1, 2, 3, 4 }; Vec4 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); s.y = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3 && v[3] == 4); testVecVal4f(V4f(s), 1.0f, 42.0f, 3.0f, 4.0f); } // Test construction/assignment/paramater pass of a std::vector of length 3 { std::vector s { 1, 2, 3, 4 }; Vec4 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3 && v[3] == 4); testVecVal4f(V4f(s), 1.0f, 42.0f, 3.0f, 4.0f); } // Test construction/assignment/paramater pass of a std::array of length 3 { std::array s { 1, 2, 3, 4 }; Vec4 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3 && v[3] == 4); testVecVal4f(V4f(s), 1.0f, 42.0f, 3.0f, 4.0f); } // Test construction/assignment/paramater pass of initializer lists. { Vec4 v({ 1.0f, 2.0f, 3.0f, 4.0f }); assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); v = { 1.0f, 42.0f, 3.0f, 4.0f }; assert(v[0] == 1 && v[1] == 42 && v[2] == 3 && v[3] == 4); testVecVal4f({ 1.0f, 42.0f, 3.0f, 4.0f }, 1, 42, 3, 4); } // Test construction/assignment/paramater pass of a C array { float s[4] = { 1, 2, 3, 4 }; Vec4 v(s); assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); s[1] = 42; v = s; assert(v[0] == 1 && v[1] == 42 && v[2] == 3 && v[3] == 4); testVecVal4f(V4f(s), 1.0f, 42.0f, 3.0f, 4.0f); } } //--------- void testInteropMx2() { std::cout << "has_double_subscript, float, 2, 2>::value = " << has_double_subscript, float, 2, 2>::value << "\n"; std::cout << "has_double_subscript, float, 2, 2>::value = " << has_double_subscript, float, 2, 2>::value << "\n"; std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "has_double_subscript, float, 2, 2>::value = " << has_double_subscript, float, 2, 2>::value << "\n"; std::cout << "has_double_subscript, float, 2, 2>::value = " << has_double_subscript, float, 2, 2>::value << "\n"; std::cout << "\n"; assert((has_double_subscript, float, 2, 2>::value)); assert((!has_double_subscript, float, 4, 4>::value)); assert((!has_double_subscript, int, 2, 2>::value)); assert((!has_double_subscript, float, 2, 2>::value)); assert((!has_double_subscript, float, 2, 2>::value)); // Test construction/assignment/paramater pass of a vector type with // subscripting to access components. { Matrix22 ref; SimpleMx s; for (int j = 0; j < 2; ++j) for (int i = 0; i < 2; ++i) { s[j][i] = i + j * 2; ref[j][i] = i + j * 2; } Matrix22 v(s); assert(v[0][0] == 0 && v[0][1] == 1 && v[1][0] == 2 && v[1][1] == 3); s[1][1] = 42; v = s; assert(v[0][0] == 0 && v[0][1] == 1 && v[1][0] == 2 && v[1][1] == 42); } } void testInteropMx3() { std::cout << "has_double_subscript, float, 3, 3>::value = " << has_double_subscript, float, 3, 3>::value << "\n"; std::cout << "has_double_subscript, float, 3, 3>::value = " << has_double_subscript, float, 3, 3>::value << "\n"; std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "has_double_subscript, float, 3, 3>::value = " << has_double_subscript, float, 3, 3>::value << "\n"; std::cout << "has_double_subscript, float, 3, 3>::value = " << has_double_subscript, float, 3, 3>::value << "\n"; std::cout << "\n"; assert((has_double_subscript, float, 3, 3>::value)); assert((!has_double_subscript, float, 4, 4>::value)); assert((!has_double_subscript, int, 3, 3>::value)); assert((!has_double_subscript, float, 3, 3>::value)); assert((!has_double_subscript, float, 3, 3>::value)); // Test construction/assignment/paramater pass of a vector type with // subscripting to access components. { Matrix33 ref; SimpleMx s; for (int j = 0; j < 3; ++j) for (int i = 0; i < 3; ++i) { s[j][i] = i + j * 3; ref[j][i] = i + j * 3; } Matrix33 v(s); assert(v[0][0] == 0 && v[0][1] == 1 && v[0][2] == 2 && v[1][0] == 3 && v[1][1] == 4 && v[1][2] == 5 && v[2][0] == 6 && v[2][1] == 7 && v[2][2] == 8); s[1][1] = 42; v = s; assert(v[0][0] == 0 && v[0][1] == 1 && v[0][2] == 2 && v[1][0] == 3 && v[1][1] == 42 && v[1][2] == 5 && v[2][0] == 6 && v[2][1] == 7 && v[2][2] == 8); } } void testInteropMx4() { std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "has_double_subscript, float, 4, 4>::value = " << has_double_subscript, float, 4, 4>::value << "\n"; std::cout << "\n"; assert((has_double_subscript, float, 4, 4>::value)); assert((!has_double_subscript, float, 3, 3>::value)); assert((!has_double_subscript, int, 4, 4>::value)); assert((!has_double_subscript, float, 4, 4>::value)); assert((!has_double_subscript, float, 4, 4>::value)); // Test construction/assignment/paramater pass of a vector type with // subscripting to access components. { Matrix44 ref; SimpleMx s; for (int j = 0; j < 4; ++j) for (int i = 0; i < 4; ++i) { s[j][i] = i + j * 4; ref[j][i] = i + j * 4; } Matrix44 v(s); assert(v[0][0] == 0 && v[0][1] == 1 && v[0][2] == 2 && v[0][3] == 3 && v[1][0] == 4 && v[1][1] == 5 && v[1][2] == 6 && v[1][3] == 7 && v[2][0] == 8 && v[2][1] == 9 && v[2][2] == 10 && v[2][3] == 11 && v[3][0] == 12 && v[3][1] == 13 && v[3][2] == 14 && v[3][3] == 15); s[1][1] = 42; v = s; assert(v[0][0] == 0 && v[0][1] == 1 && v[0][2] == 2 && v[0][3] == 3 && v[1][0] == 4 && v[1][1] == 42 && v[1][2] == 6 && v[1][3] == 7 && v[2][0] == 8 && v[2][1] == 9 && v[2][2] == 10 && v[2][3] == 11 && v[3][0] == 12 && v[3][1] == 13 && v[3][2] == 14 && v[3][3] == 15); } } } // namespace #endif void testInterop() { cout << "Testing interoperability with foreign types" << endl; #if IMATH_FOREIGN_VECTOR_INTEROP testInteropVec2(); testInteropVec3(); testInteropVec4(); testInteropMx2(); testInteropMx3(); testInteropMx4(); cout << "ok\n" << endl; #else cout << "Foreign vector type interopability is disabled.\n"; #endif } Imath-3.1.4/src/ImathTest/testInterop.h000066400000000000000000000001661417213455000177500ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testInterop(); Imath-3.1.4/src/ImathTest/testInterval.cpp000066400000000000000000000413641417213455000204540ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { template static void testConstructors (const char* type) { cout << " constructors for type " << type << endl; // // Empty // { IMATH_INTERNAL_NAMESPACE::Interval b; assert (b.min == T (std::numeric_limits::max()) && b.max == T (std::numeric_limits::lowest())); } // // Single point // { T p (42); IMATH_INTERNAL_NAMESPACE::Interval b (p); assert (b.min == p && b.max == p); } // // Min and max // { T p0 (42); T p1 (666); IMATH_INTERNAL_NAMESPACE::Interval b (p0, p1); assert (b.min == p0 && b.max == p1); } { T p0 (666); T p1 (42); IMATH_INTERNAL_NAMESPACE::Interval b (p0, p1); assert (b.min == p0 && b.max == p1); } } template void testMakeEmpty (const char* type) { cout << " makeEmpty() for type " << type << endl; // // Empty interval // { IMATH_INTERNAL_NAMESPACE::Interval b; b.makeEmpty(); assert (b.min == T (std::numeric_limits::max()) && b.max == T (std::numeric_limits::lowest())); } // // Non-empty, has volume // { IMATH_INTERNAL_NAMESPACE::Interval b (T (-1), T (1)); b.makeEmpty(); assert (b.min == T (std::numeric_limits::max()) && b.max == T (std::numeric_limits::lowest())); } // // Non-empty, no volume // { T min (0); T max (10); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); b.makeEmpty(); assert (b.min == T (std::numeric_limits::max()) && b.max == T (std::numeric_limits::lowest())); } } template void testMakeInfinite (const char* type) { cout << " makeInfinite() for type " << type << endl; // // Infinite interval // { IMATH_INTERNAL_NAMESPACE::Interval b; b.makeInfinite(); assert (b.min == T (std::numeric_limits::lowest()) && b.max == T (std::numeric_limits::max())); } // // Non-empty, has volume // { IMATH_INTERNAL_NAMESPACE::Interval b (T (-1), T (1)); b.makeInfinite(); assert (b.min == T (std::numeric_limits::lowest()) && b.max == T (std::numeric_limits::max())); } // // Non-empty, no volume // { T min (0); T max (1); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); b.makeInfinite(); assert (b.min == T (std::numeric_limits::lowest()) && b.max == T (std::numeric_limits::max())); } } template void testExtendByPoint (const char* type) { cout << " extendBy() point for type " << type << endl; IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); const unsigned int iters = 10; // // Extend empty interval with a single point. // for (unsigned int i = 0; i < iters; i++) { T p (rand.nextf (-12345, 12345)); IMATH_INTERNAL_NAMESPACE::Interval b; b.extendBy (p); assert (b.min == p && b.max == p); } // // Extend empty interval with a number of random points. Note that // this also covers extending a non-empty interval. // for (unsigned int i = 0; i < iters; i++) { IMATH_INTERNAL_NAMESPACE::Interval b; T min; T max; for (unsigned int j = 0; j < i; j++) { T p (rand.nextf (-12345, 12345)); if (j == 0) { min = p; max = p; } min = std::min (min, p); max = std::max (max, p); b.extendBy (p); assert (b.min == min && b.max == max); } } } template void testExtendByInterval (const char* type) { cout << " extendBy() interval for type " << type << endl; // // Extend empty interval with an empty interval // { IMATH_INTERNAL_NAMESPACE::Interval b; b.extendBy (IMATH_INTERNAL_NAMESPACE::Interval()); assert (b.min == T (std::numeric_limits::max()) && b.max == T (std::numeric_limits::lowest())); } // // Extend empty interval with a non-empty interval and vice versa. // { T p0 (-1); T p1 (1); IMATH_INTERNAL_NAMESPACE::Interval b0; b0.extendBy (IMATH_INTERNAL_NAMESPACE::Interval (p0, p1)); assert (b0.min == p0 && b0.max == p1); IMATH_INTERNAL_NAMESPACE::Interval b1 (p0, p1); b1.extendBy (IMATH_INTERNAL_NAMESPACE::Interval()); assert (b1.min == p0 && b1.max == p1); } // // Extend non-empty interval with non-empty interval. Starts with empty, then builds. // IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); const unsigned int iters = 10; { IMATH_INTERNAL_NAMESPACE::Interval b; T min, max; for (unsigned int i = 1; i < iters; i++) { T p0 (rand.nextf (0, 999)); T p1 (rand.nextf (1000, 1999)); min = b.min; max = b.max; min = std::min (min, p0); max = std::max (max, p1); b.extendBy (IMATH_INTERNAL_NAMESPACE::Interval (p0, p1)); assert (b.min == min && b.max == max); } } } template void testComparators (const char* type) { cout << " comparators for type " << type << endl; IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); // // Compare empty. // { IMATH_INTERNAL_NAMESPACE::Interval b0; IMATH_INTERNAL_NAMESPACE::Interval b1; assert (b0 == b1); assert (!(b0 != b1)); } // // Compare empty to non-empty. // { T p0 (-1); T p1 (1); IMATH_INTERNAL_NAMESPACE::Interval b0; IMATH_INTERNAL_NAMESPACE::Interval b1 (p0, p1); assert (!(b0 == b1)); assert (b0 != b1); } // // Compare two non-empty // { T p0 (-1); T p1 (1); T p2 (-2); T p3 (2); IMATH_INTERNAL_NAMESPACE::Interval b0 (p0, p1); IMATH_INTERNAL_NAMESPACE::Interval b1 (p2, p3); IMATH_INTERNAL_NAMESPACE::Interval b2 (p0, p1); assert (b0 != b1); assert (!(b0 == b1)); assert (b0 == b2); assert (!(b0 != b2)); } } template void testIntersects (const char* type) { cout << " intersects() for type " << type << endl; IMATH_INTERNAL_NAMESPACE::Rand32 rand (0); // // Intersect point with empty interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; T p (1); assert (!b.intersects (p)); } // // Intersect point with non-empty, has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b (T (-1), T (1)); T p0 (0); T p1 (5); T p2 (-5); assert (b.intersects (p0)); assert (!b.intersects (p1)); assert (!b.intersects (p2)); } // // Intersect point with non-empty, no-volume interval. // { T min (0); T max (1); T p0 (0); T p1 (5); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); assert (b.intersects (p0)); assert (!b.intersects (p1)); } // // Intersect empty interval with empty interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0; IMATH_INTERNAL_NAMESPACE::Interval b1; assert (!b0.intersects (b1)); assert (!b1.intersects (b0)); } // // Intersect empty interval with non-empty has-volume intervales. // { IMATH_INTERNAL_NAMESPACE::Interval b0; IMATH_INTERNAL_NAMESPACE::Interval b1 (T (-1), T (1)); IMATH_INTERNAL_NAMESPACE::Interval b2 (T (1), T (2)); assert (!b0.intersects (b1)); assert (!b0.intersects (b2)); assert (!b1.intersects (b0)); assert (!b2.intersects (b0)); } // // Intersect empty interval with non-empty no-volume interval. // { T min (0); T max = min; max[T::dimensions() - 1] = 1; IMATH_INTERNAL_NAMESPACE::Interval b0; IMATH_INTERNAL_NAMESPACE::Interval b1 (min, max); assert (!b0.intersects (b1)); assert (!b1.intersects (b0)); } // // Intersect non-empty has-volume interval with non-empty has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b1 (T (-1), T (1)); IMATH_INTERNAL_NAMESPACE::Interval b2 (T (-1), T (1)); IMATH_INTERNAL_NAMESPACE::Interval b3 (T (1), T (2)); IMATH_INTERNAL_NAMESPACE::Interval b4 (T (2), T (3)); assert (b1.intersects (b1)); assert (b1.intersects (b3)); assert (!b1.intersects (b4)); assert (b3.intersects (b1)); assert (!b4.intersects (b1)); } // // Intersect non-empty has-volume interval with non-empty no-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0 (T (-1), T (1)); T min (0); T max (1); IMATH_INTERNAL_NAMESPACE::Interval b1 (min, max); IMATH_INTERNAL_NAMESPACE::Interval b2 (min + T (2), max + T (2)); assert (b0.intersects (b1)); assert (b1.intersects (b0)); assert (!b0.intersects (b2)); assert (!b2.intersects (b1)); } // // Intersect non-empty no-volume interval with non-empty no-volume interval. // { T min (0); T max (1); IMATH_INTERNAL_NAMESPACE::Interval b0 (min, max); IMATH_INTERNAL_NAMESPACE::Interval b1 (min, max + T (2)); IMATH_INTERNAL_NAMESPACE::Interval b2 (min + T (2), max + T (2)); assert (b0.intersects (b1)); assert (b1.intersects (b0)); assert (!b0.intersects (b2)); assert (!b2.intersects (b0)); } } template void testSize (const char* type) { cout << " size() for type " << type << endl; // // Size of empty interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; assert (b.size() == T (0)); } // // Size of non-empty, has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0 (T (-1), T (1)); assert (b0.size() == T (2)); T p (42); IMATH_INTERNAL_NAMESPACE::Interval b1 (-p, p); assert (b1.size() == p * T (2)); } // // Size of non-empty, no-volume interval. // { T min (0); T max (1); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); assert (b.size() == max); } } template void testCenter (const char* type) { cout << " center() for type " << type << endl; // // Center of empty interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; assert (b.center() == T (0)); } // // Center of non-empty, has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0 (T (-1), T (1)); assert (b0.center() == T (0)); T p0 (1); T p1 (2); IMATH_INTERNAL_NAMESPACE::Interval b1 (p0, p1); assert (b1.center() == (p1 + p0) / 2); } // // Center of non-empty, no-volume interval. // { T min (0); T max (2); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); assert (b.center() == max / 2); } } template void testIsEmpty (const char* type) { cout << " isEmpty() for type " << type << endl; // // Empty interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; assert (b.isEmpty()); } // // Non-empty, has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0 (T (-1), T (1)); assert (!b0.isEmpty()); T p0 (2); T p1 (4); IMATH_INTERNAL_NAMESPACE::Interval b1 (p0, p1); assert (!b1.isEmpty()); } // // Non-empty, no-volume interval. // { T min (0); T max (2); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); assert (!b.isEmpty()); } } template void testIsInfinite (const char* type) { cout << " isInfinite() for type " << type << endl; // // Infinite interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; b.makeInfinite(); assert (b.isInfinite()); } // // Non-empty, has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0 (T (-1), T (1)); assert (!b0.isInfinite()); T p0 (2); T p1 (4); IMATH_INTERNAL_NAMESPACE::Interval b1 (p0, p1); assert (!b1.isInfinite()); } // // Non-empty, no-volume interval. // { T min (0); T max (2); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); assert (!b.isInfinite()); } } template void testHasVolume (const char* type) { cout << " hasVolume() for type " << type << endl; // // Empty interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; assert (!b.hasVolume()); } // // Infinite interval. // { IMATH_INTERNAL_NAMESPACE::Interval b; b.makeInfinite(); assert (b.hasVolume()); } // // Non-empty, has-volume interval. // { IMATH_INTERNAL_NAMESPACE::Interval b0 (T (-1), T (1)); assert (b0.hasVolume()); T p0 (2); T p1 (4); IMATH_INTERNAL_NAMESPACE::Interval b1 (p0, p1); assert (b1.hasVolume()); } // // Non-empty, no-volume interval. // { T min (0); T max (2); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); b.makeEmpty(); assert (!b.hasVolume()); } } template void testStream (const char* type) { cout << " hasVolume() for type " << type << endl; T min (0); T max (1); IMATH_INTERNAL_NAMESPACE::Interval b (min, max); std::stringstream s1; s1 << '(' << min << ' ' << max << ')'; std::stringstream s2; s2 << b; assert (s1.str() == s2.str()); } } // anonymous namespace void testInterval() { cout << "Testing interval methods" << endl; // // Constructors // testConstructors ("short"); testConstructors ("int"); testConstructors ("float"); testConstructors ("double"); // // makeEmpty() // testMakeEmpty ("short"); testMakeEmpty ("int"); testMakeEmpty ("float"); testMakeEmpty ("double"); // // makeInfinite() // testMakeInfinite ("short"); testMakeInfinite ("int"); testMakeInfinite ("float"); testMakeInfinite ("double"); // // extendBy() (point) // testExtendByPoint ("short"); testExtendByPoint ("int"); testExtendByPoint ("float"); testExtendByPoint ("double"); // // extendBy() interval // testExtendByInterval ("short"); testExtendByInterval ("int"); testExtendByInterval ("float"); testExtendByInterval ("double"); // // == and !== // testComparators ("short"); testComparators ("int"); testComparators ("float"); testComparators ("double"); // // size() // testSize ("short"); testSize ("int"); testSize ("float"); testSize ("double"); // // center() // testCenter ("short"); testCenter ("int"); testCenter ("float"); testCenter ("double"); // // isEmpty() // testIsEmpty ("short"); testIsEmpty ("int"); testIsEmpty ("float"); testIsEmpty ("double"); // // isInfinite() // testIsInfinite ("short"); testIsInfinite ("int"); testIsInfinite ("float"); testIsInfinite ("double"); // // hasVolume() // testHasVolume ("short"); testHasVolume ("int"); testHasVolume ("float"); testHasVolume ("double"); // // stream // testStream ("short"); testStream ("int"); testStream ("float"); testStream ("double"); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testInterval.h000066400000000000000000000001661417213455000201140ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testInterval(); Imath-3.1.4/src/ImathTest/testInvert.cpp000066400000000000000000000056711417213455000201400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include "testInvert.h" using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { void invertM44f (const M44f &m, float e) { M44f inv1 = m.inverse(); M44f inv2 = m.gjInverse(); M44f ident1 = m * inv1; M44f ident2 = m * inv2; //cout << "m\n" << m << endl; //cout << "inv1\n" << inv1 << "ident1\n" << ident1 << endl; //cout << "inv2\n" << inv2 << "ident2\n" << ident2 << endl; assert (ident1.equalWithAbsError (identity44f, e)); assert (ident2.equalWithAbsError (identity44f, e)); } void invertM33f (const M33f &m, float e) { M33f inv1 = m.inverse(); M33f inv2 = m.gjInverse(); M33f ident1 = m * inv1; M33f ident2 = m * inv2; //cout << "m\n" << m << endl; //cout << "inv1\n" << inv1 << "ident1\n" << ident1 << endl; //cout << "inv2\n" << inv2 << "ident2\n" << ident2 << endl; assert (ident1.equalWithAbsError (identity33f, e)); assert (ident2.equalWithAbsError (identity33f, e)); } } // namespace void testInvert () { cout << "Testing 4x4 and 3x3 matrix inversion:" << endl; { cout << "M44f" << endl; // clang-format off M44f m1 ( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); M44f m2 ( 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); M44f m3 ( 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0); M44f m4 ( 4.683281e-01, -8.749647e-01, 1.229049e-01, 0.000000e+00, 1.251189e-02, 1.456563e-01, 9.892561e-01, 0.000000e+00, -8.834660e-01, -4.617587e-01, 7.916244e-02, 0.000000e+00, -4.726541e+00, 3.044795e+00, -6.737138e+00, 1.000000e+00); M44f m5 ( 4.683281e-01, -8.749647e-01, 1.229049e-01, 1.000000e+00, 1.251189e-02, 1.456563e-01, 9.892561e-01, 2.000000e+00, -8.834660e-01, -4.617587e-01, 7.916244e-02, 3.000000e+00, -4.726541e+00, 3.044795e+00, -6.737138e+00, 4.000000e+00); // clang-format on invertM44f (m1, 0); invertM44f (m2, 0); invertM44f (m3, 0); invertM44f (m4, 1e-6); invertM44f (m5, 1e-6); } { cout << "M33f" << endl; // clang-format off M33f m1 ( 1, 0, 0, 0, 1, 0, 0, 0, 1); M33f m2 ( 0, 1, 0, -1, 0, 0, 0, 0, 1); M33f m3 ( 2, 0, 0, 0, 0, -1, 0, 1, 0); M33f m4 ( 4.683281e-01, -8.749647e-01, 0.000000e+00, 1.251189e-02, 1.456563e-01, 0.000000e+00, 0.000000e+00, 0.000000e+00, 1.000000e+00); M33f m5 ( 4.683281e-01, -8.749647e-01, 1.229049e-01, 1.251189e-02, 1.456563e-01, 9.892561e-01, -8.834660e-01, -4.617587e-01, 7.916244e-02); // clang-format on invertM33f (m1, 0); invertM33f (m2, 0); invertM33f (m3, 0); invertM33f (m4, 1e-6); invertM33f (m5, 1e-6); } cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testInvert.h000066400000000000000000000001651417213455000175760ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testInvert(); Imath-3.1.4/src/ImathTest/testJacobiEigenSolver.cpp000066400000000000000000000203331417213455000222130ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include #include using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; // clang-format off const Matrix33 A33_1 ( 1, 0, 0, 0, 1, 0, 0, 0, 1 ); const Matrix33 A33_2 ( 1, 0, 0, 0,-1, 0, 0, 0, 1 ); const Matrix33 A33_3 ( 1, 0, 0, 0, 1, 0, 0, 0, 0 ); const Matrix33 A33_4 ( 1, 0, 0, 0, 0, 0, 0, 0, 0 ); const Matrix33 A33_5 ( 0, 0, 0, 0, 0, 0, 0, 0, 0 ); const Matrix33 A33_6 ( 1, 0, 0, 0, 1e-10, 0, 0, 0, 0 ); const Matrix33 A33_7 ( 1, 0, 0, 0, 1e-10, 0, 0, 0, 1e+10 ); const Matrix33 A33_8 ( 0.25058694044821, 0.49427229444416, 0.81415724537748, 0.49427229444416, 0.80192384710853, -0.61674948224910, 0.81415724537748, -0.61674948224910, -1.28486154645285); const Matrix33 A33_9 ( 4, -30, 60, -30, 300, -675, 60, -675, 1620); const Matrix44 A44_1 ( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ); const Matrix44 A44_2 ( 1, 0, 0, 0, 0,-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ); const Matrix44 A44_3 ( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); const Matrix44 A44_4 ( 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); const Matrix44 A44_5 ( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); const Matrix44 A44_6 ( 1, 0, 0, 0, 0, 1e-20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); const Matrix44 A44_7 ( 1, 0, 0, 0, 0, 1e-20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1e+20 ); const Matrix44 A44_8 ( 4.05747631538951, 0.16358123075600, 0.11541756047409, -1.65369223465270, 0.16358123075600, 0.57629829390780, 3.88542912704029, 0.92016316185369, 0.11541756047409, 3.88542912704029, 0.65367032943707, -0.21971103270410, -1.65369223465270, 0.92016316185369, -0.21971103270410, -0.28108876552761); const Matrix44 A44_9 ( 4, -30, 60, -35, -30, 300, -675, 420, 60, -675, 1620, -1050, -35, 420, -1050, 700); // clang-format on template void verifyOrthonormal (const TM& A, const typename TM::BaseType threshold) { const TM prod = A * A.transposed(); for (size_t i = 0; i < TM::dimensions(); ++i) for (size_t j = 0; j < TM::dimensions(); ++j) if (i == j) assert (std::abs (prod[i][j] - 1) < threshold); else assert (std::abs (prod[i][j]) < threshold); } template typename TM::BaseType computeThreshold(const TM& A) { typedef typename TM::BaseType T; T maxAbsEntry(0); for (size_t i = 0; i < TM::dimensions(); ++i) for (size_t j = 0; j < TM::dimensions(); ++j) maxAbsEntry = std::max (maxAbsEntry, std::abs(A[i][j])); const T eps = std::numeric_limits::epsilon(); maxAbsEntry = std::max(maxAbsEntry, eps); return maxAbsEntry * T(100) * eps; } template void testJacobiEigenSolver(const TM& A) { using std::abs; typedef typename TM::BaseType T; typedef typename TM::BaseVecType TV; const T threshold = computeThreshold(A); TM AA(A); TV S; TM V; jacobiEigenSolver(AA, S, V); // Orthogonality of V verifyOrthonormal(V, threshold); // Determinant of V assert(abs(V.determinant()) - 1 < threshold); // Determinant of A and S TM MS; for (size_t i = 0; i < TM::dimensions(); ++i) for (size_t j = 0; j < TM::dimensions(); ++j) if(i == j) MS[i][j] = S[i]; else MS[i][j] = 0; assert (abs (A.determinant()) - abs (MS.determinant()) < threshold); // A = V * S * V^T TM MA = V * MS * V.transposed(); for (size_t i = 0; i < TM::dimensions(); ++i) for (size_t j =0; j < TM::dimensions(); ++j) assert(abs(A[i][j]-MA[i][j]) < threshold); } template void testMinMaxEigenValue(const TM& A) { typedef typename TM::BaseVecType TV; typedef typename TM::BaseType T; TV minV, maxV, S; TM U, V; const T threshold = computeThreshold(A); { TM A1(A); minEigenVector(A1, minV); TM A2(A); maxEigenVector(A2, maxV); } { TM A3(A); jacobiSVD(A3, U, S, V); } const int dim = TM::dimensions(); for (int i = 0; i < dim; ++i) { assert(abs(minV[i]-V[i][dim - 1]) < threshold); assert(abs(maxV[i]-V[i][0]) < threshold); } } template void testJacobiTiming() { int rounds(100000); clock_t tJacobi,tSVD, t; { Matrix33 A,V,U; Vec3 S; t = clock(); for (int i = 0; i < rounds; ++i) { A = Matrix33(A33_7); jacobiEigenSolver(A, S, V); A = Matrix33(A33_8); jacobiEigenSolver(A, S, V); } tJacobi = clock() - t; cout << "Jacobi EigenSolver of 3x3 matrices took " << tJacobi << " clocks." << endl; t = clock(); for (int i = 0; i < rounds; ++i) { A = Matrix33(A33_7); jacobiSVD(A, U, S, V); A = Matrix33(A33_8); jacobiSVD(A, U, S, V); } tSVD = clock() - t; cout << "TinySVD of 3x3 matrices took " << tSVD << " clocks." << endl; cout << (float)(tSVD-tJacobi)*100.0f/(float)(tSVD) << "% speed up." << endl; } { Matrix44 A,V,U; Vec4 S; t = clock(); for (int i = 0; i < rounds; ++i) { A = Matrix44(A44_7); jacobiEigenSolver(A, S, V); A = Matrix44(A44_8); jacobiEigenSolver(A, S, V); } tJacobi = clock() - t; cout << "Jacobi EigenSolver of 4x4 matrices took " << tJacobi << " clocks" << endl; t = clock(); for (int i = 0; i < rounds; ++i) { A = Matrix44(A44_7); jacobiSVD(A, U, S, V); A = Matrix44(A44_8); jacobiSVD(A, U, S, V); } tSVD = clock() - t; cout << "TinySVD of 4x4 matrices took " << tSVD << " clocks" << endl; cout << (float)(tSVD-tJacobi)*100.0f/(float)(tSVD) << "% speed up." << endl; } } template void testJacobiEigenSolverImp() { testJacobiEigenSolver(Matrix33(A33_1)); testJacobiEigenSolver(Matrix33(A33_2)); testJacobiEigenSolver(Matrix33(A33_3)); testJacobiEigenSolver(Matrix33(A33_4)); testJacobiEigenSolver(Matrix33(A33_5)); testJacobiEigenSolver(Matrix33(A33_6)); testJacobiEigenSolver(Matrix33(A33_7)); testJacobiEigenSolver(Matrix33(A33_8)); testJacobiEigenSolver(Matrix44(A44_1)); testJacobiEigenSolver(Matrix44(A44_2)); testJacobiEigenSolver(Matrix44(A44_3)); testJacobiEigenSolver(Matrix44(A44_4)); testJacobiEigenSolver(Matrix44(A44_5)); testJacobiEigenSolver(Matrix44(A44_6)); testJacobiEigenSolver(Matrix44(A44_7)); testJacobiEigenSolver(Matrix44(A44_8)); } template void testMinMaxEigenValueImp() { testMinMaxEigenValue(Matrix33(A33_7)); testMinMaxEigenValue(Matrix33(A33_8)); testMinMaxEigenValue(Matrix44(A44_7)); testMinMaxEigenValue(Matrix44(A44_8)); } void testJacobiEigenSolver() { cout << endl; cout << "************ Testing IMATH_INTERNAL_NAMESPACE::ImathJacobiEigenSolver ************" << endl; cout << "Jacobi EigenSolver in single precision..."; testJacobiEigenSolverImp(); cout << "PASS" << endl; cout << "Jacobi EigenSolver in double precision..."; testJacobiEigenSolverImp(); cout << "PASS" << endl; cout << "Min/Max EigenValue in single precision..."; testMinMaxEigenValueImp(); cout << "PASS" << endl; cout << "Min/Max EigenValue in double precision..."; testMinMaxEigenValueImp(); cout << "PASS" << endl; cout << "Timing Jacobi EigenSolver in single precision...\n"; testJacobiTiming(); cout << "Timing Jacobi EigenSolver in double precision...\n"; testJacobiTiming(); cout << "************ ALL PASS ************" << endl; } Imath-3.1.4/src/ImathTest/testJacobiEigenSolver.h000066400000000000000000000002001417213455000216470ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testJacobiEigenSolver(); Imath-3.1.4/src/ImathTest/testLimits.cpp000066400000000000000000000116461417213455000201310ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include "halfLimits.h" #include #include #include #include "testLimits.h" using namespace std; namespace { float mypow (int x, int y) { bool negative = false; if (y < 0) { negative = true; y = -y; } float z = 1; while (y > 0) { z *= x; y -= 1; } if (negative) z = 1 / z; return z; } } // namespace void testLimits() { cout << "values in std::numeric_limits\n"; cout << "min_exponent\n"; { half h (mypow (2, numeric_limits::min_exponent - 1)); assert (h.isNormalized()); } { half h (mypow (2, numeric_limits::min_exponent - 2)); assert (h.isDenormalized()); } cout << "max_exponent\n"; { half h (mypow (2, numeric_limits::max_exponent - 1)); assert (h.isNormalized()); } { half h (mypow (2, numeric_limits::max_exponent)); assert (h.isInfinity()); } cout << "min_exponent10\n"; { half h (mypow (10, numeric_limits::min_exponent10)); assert (h.isNormalized()); } { half h (mypow (10, numeric_limits::min_exponent10 - 1)); assert (h.isDenormalized()); } cout << "max_exponent10\n"; { half h (mypow (10, numeric_limits::max_exponent10)); assert (h.isNormalized()); } { half h (mypow (10, numeric_limits::max_exponent10 + 1)); assert (h.isInfinity()); } #if __cplusplus >= 201103L cout << "max_digits10\n"; assert (numeric_limits::max_digits10 == std::ceil (numeric_limits::digits * std::log10 (2) + 1)); cout << "lowest\n"; assert (numeric_limits::lowest() == -HALF_MAX); #endif cout << "ok\n\n" << flush; } void testHalfLimits() { cout << "values in std::numeric_limits\n"; // For reference: printf("HALF_DENORM_MIN %g -> 0x%04x\n", (float)HALF_DENORM_MIN, half(HALF_DENORM_MIN).bits()); printf("HALF_NRM_MIN %g -> 0x%04x\n", (float)HALF_NRM_MIN, half(HALF_NRM_MIN).bits()); printf("HALF_MIN %g -> 0x%04x\n", (float)HALF_MIN, half(HALF_MIN).bits()); printf("HALF_MAX %g -> 0x%04x\n", (float)HALF_MAX, half(HALF_MAX).bits()); printf("HALF_LOWEST %g -> 0x%04x\n", (float)-HALF_MAX, half(-HALF_MAX).bits()); printf("HALF_EPSILON %g -> 0x%04x\n", (float)HALF_EPSILON, half(HALF_EPSILON).bits()); printf("half posInf %g -> 0x%04x\n", (float)half::posInf(), half::posInf().bits()); printf("half negInf %g -> 0x%04x\n", (float)half::negInf(), half::negInf().bits()); printf("half qNan %g -> 0x%04x\n", (float)half::qNan(), half::qNan().bits()); printf("half sNan %g -> 0x%04x\n", (float)half::sNan(), half::sNan().bits()); printf("numeric_limits min %g -> 0x%04x\n", (float)std::numeric_limits::min(), std::numeric_limits::min().bits()); printf("numeric_limits max %g -> 0x%04x\n", (float)std::numeric_limits::max(), std::numeric_limits::max().bits()); printf("numeric_limits lowest %g -> 0x%04x\n", (float)std::numeric_limits::lowest(), std::numeric_limits::lowest().bits()); printf("numeric_limits epsilon %g -> 0x%04x\n", (float)std::numeric_limits::epsilon(), std::numeric_limits::epsilon().bits()); printf("numeric_limits round_error %g -> 0x%04x\n", (float)std::numeric_limits::round_error(), std::numeric_limits::round_error().bits()); printf("numeric_limits infinity %g -> 0x%04x\n", (float)std::numeric_limits::infinity(), std::numeric_limits::infinity().bits()); printf("numeric_limits quiet_NaN %g -> 0x%04x\n", (float)std::numeric_limits::quiet_NaN(), std::numeric_limits::quiet_NaN().bits()); printf("numeric_limits signaling_NaN %g -> 0x%04x\n", (float)std::numeric_limits::signaling_NaN(), std::numeric_limits::signaling_NaN().bits()); printf("numeric_limits denorm_min %g -> 0x%04x\n", (float)std::numeric_limits::denorm_min(), std::numeric_limits::denorm_min().bits()); assert (std::numeric_limits::max() == half(HALF_MAX)); assert (std::numeric_limits::min() == half(HALF_NRM_MIN)); assert (std::numeric_limits::denorm_min() == half(HALF_DENORM_MIN)); assert (std::numeric_limits::lowest() == half(-HALF_MAX)); assert (std::numeric_limits::epsilon() == half(HALF_EPSILON)); assert (std::numeric_limits::infinity() == half::posInf()); assert (std::numeric_limits::quiet_NaN().bits() == half::qNan().bits()); assert (std::numeric_limits::signaling_NaN().bits() == half::sNan().bits()); assert (std::numeric_limits::infinity() == half::posInf()); cout << "ok\n\n" << flush; } Imath-3.1.4/src/ImathTest/testLimits.h000066400000000000000000000002141417213455000175630ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testLimits(); void testHalfLimits(); Imath-3.1.4/src/ImathTest/testLineAlgo.cpp000066400000000000000000000271731417213455000203640ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include "testLineAlgo.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { void testClosestPoints (const Line3f& line1, const Line3f& line2, bool returnValue, const V3f& point1, const V3f& point2) { V3f p1; V3f p2; bool rv = closestPoints (line1, line2, p1, p2); assert (rv == returnValue); if (rv) { float e = 10 * std::numeric_limits::epsilon(); assert (point1.equalWithAbsError (p1, e)); assert (point2.equalWithAbsError (p2, e)); } } void testClosestPoints() { cout << "closest points on two lines" << endl; cout << " non-intersecting, non-parallel lines" << endl; testClosestPoints (Line3f (V3f (0, -1, -1), V3f (0, 1, -1)), Line3f (V3f (-1, 0, 1), V3f (1, 0, 1)), true, V3f (0, 0, -1), V3f (0, 0, 1)); testClosestPoints (Line3f (V3f (2, -1, -1), V3f (2, 1, -1)), Line3f (V3f (-1, 3, 1), V3f (1, 3, 1)), true, V3f (2, 3, -1), V3f (2, 3, 1)); cout << " intersecting, non-parallel lines" << endl; testClosestPoints (Line3f (V3f (2, -1, 0), V3f (2, 1, 0)), Line3f (V3f (-1, 3, 0), V3f (1, 3, 0)), true, V3f (2, 3, 0), V3f (2, 3, 0)); cout << " parallel lines" << endl; testClosestPoints (Line3f (V3f (2, -1, 0), V3f (2, 1, 0)), Line3f (V3f (2, -1, 1), V3f (2, 1, 1)), false, V3f (0, 0, 0), V3f (0, 0, 0)); testClosestPoints (Line3f (V3f (2, -1, 0), V3f (2, 1, 0)), Line3f (V3f (2, 1, 1), V3f (2, -1, 1)), false, V3f (0, 0, 0), V3f (0, 0, 0)); cout << " coincident lines" << endl; testClosestPoints (Line3f (V3f (2, -1, 0), V3f (2, -1, 1)), Line3f (V3f (2, -1, 0), V3f (2, -1, 1)), false, V3f (0, 0, 0), V3f (0, 0, 0)); cout << " random lines" << endl; Rand48 rand (7); for (int i = 0; i < 10000; ++i) { Line3f line1 (solidSphereRand (rand) * 100.f, solidSphereRand (rand) * 100.f); Line3f line2 (solidSphereRand (rand) * 100.f, solidSphereRand (rand) * 100.f); V3f point1; V3f point2; bool rv = closestPoints (line1, line2, point1, point2); if (rv) { // // We test if the line that connects point1 and point2 // is perpendicular to line1 and line2. The numerical // accuracy of point1 and point2 depends strongly on // the relative directions of line1 and line2; accuracy // degrades rather quickly if line1 and line2 become // close to parallel. // float e = 2000 * std::numeric_limits::epsilon(); float d = 1 - (line1.dir ^ line2.dir) * (line1.dir ^ line2.dir); V3f n = point1 - point2; assert (equalWithAbsError (0.0f, (line1.dir ^ n) * d, e)); assert (equalWithAbsError (0.0f, (line2.dir ^ n) * d, e)); } } } void testIntersect (const Line3f& line, const V3f& v0, const V3f& v1, const V3f& v2, const V3f& point, bool front, bool returnValue) { V3f pt; V3f bary; bool fr; bool rv = intersect (line, v0, v1, v2, pt, bary, fr); assert (rv == returnValue); float e = 10 * std::numeric_limits::epsilon(); if (rv) { assert (front == fr); assert (pt.equalWithAbsError (point, e)); V3f pt2 = v0 * bary.x + v1 * bary.y + v2 * bary.z; assert (pt.equalWithAbsError (pt2, e)); } } void testIntersect() { cout << "line-triangle intersection" << endl; cout << " line-plane intersection inside triangle" << endl; testIntersect (Line3f (V3f (0, 0, -1), V3f (0, 0, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 7), true, true); testIntersect (Line3f (V3f (0, 0, -1), V3f (-1, -2, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (-1, -2, 7), true, true); testIntersect (Line3f (V3f (0, 0, -1), V3f (-1, 1, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (-1, 1, 7), true, true); testIntersect (Line3f (V3f (0, 0, -1), V3f (-1, 1, 7)), V3f (4, -4, 7), V3f (-4, -4, 7), V3f (0, 6, 7), V3f (-1, 1, 7), false, true); testIntersect (Line3f (V3f (1, 1, 2), V3f (0, 0, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 7), true, true); testIntersect (Line3f (V3f (2, 3, -5), V3f (-1, -2, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (-1, -2, 7), true, true); testIntersect (Line3f (V3f (2, 8, -10), V3f (-1, 1, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (-1, 1, 7), true, true); testIntersect (Line3f (V3f (-10, 2, -1), V3f (-1, 1, 7)), V3f (4, -4, 7), V3f (-4, -4, 7), V3f (0, 6, 7), V3f (-1, 1, 7), false, true); cout << " line-plane intersection outside triangle" << endl; testIntersect (Line3f (V3f (0, 0, -1), V3f (4, 0, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (0, 0, -1), V3f (-4, 1, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (0, 0, -1), V3f (0, -5, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (0, 0, -1), V3f (0, -7, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); cout << " line parallel to triangle" << endl; testIntersect (Line3f (V3f (0, 0, -1), V3f (4, 0, -1)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (0, 4, 7), V3f (4, 0, 7)), V3f (-4, -4, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); cout << " zero-area triangle" << endl; testIntersect (Line3f (V3f (2, 3, -5), V3f (-1, -2, 7)), V3f (0, 6, 7), V3f (4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (2, 3, -5), V3f (-1, -2, 7)), V3f (-4, -4, 7), V3f (-4, -4, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (2, 3, -5), V3f (-1, -2, 7)), V3f (-4, -4, 7), V3f (0, 6, 7), V3f (0, 6, 7), V3f (0, 0, 0), false, false); testIntersect (Line3f (V3f (2, 3, -5), V3f (-1, -2, 7)), V3f (-4, -4, 7), V3f (-4, -4, 7), V3f (-4, -4, 7), V3f (0, 0, 0), false, false); cout << " random lines and triangles" << endl; Rand48 rand (8); for (int i = 0; i < 10000; ++i) { // // Generate a random triangle with non-zero area // V3f v0, v1, v2; V3f normal; do { v0 = solidSphereRand (rand); v1 = solidSphereRand (rand); v2 = solidSphereRand (rand); normal = (v2 - v1) % (v1 - v0); } while (normal.length() < 0.01); { // // Generate a line that intersects inside the triangle // V3f b; do { b.x = rand.nextf (0.001, 0.999); b.y = rand.nextf (0.001, 0.999); b.z = 1 - b.x - b.y; } while (b.x + b.y > 0.999); V3f p1 = v0 * b.x + v1 * b.y + v2 * b.z; V3f p0; do { p0 = solidSphereRand (rand); } while (abs (normal.normalized() ^ (p1 - p0).normalized()) < 0.1); // // Test for intersection // V3f point; V3f bary; bool front; bool rv = intersect (Line3f (p0, p1), v0, v1, v2, point, bary, front); assert (rv == true); float nd = abs (normal.normalized() ^ (p1 - p0).normalized()); float ep = 20 * std::numeric_limits::epsilon() / nd; assert (point.equalWithAbsError (p1, ep)); } { // // Generate a line that intersects the triangle's plane // but outside the triangle // V3f b; do { b.x = rand.nextf (-3, 3); b.y = rand.nextf (-3, 3); b.z = 1 - b.x - b.y; } while (b.x > -0.001 && b.y > -0.001 && b.z > -0.001); V3f p1 = v0 * b.x + v1 * b.y + v2 * b.z; V3f p0; do { p0 = solidSphereRand (rand) * 10; } while (abs (normal.normalized() ^ (p1 - p0).normalized()) < 0.1); // // Test for intersection // V3f point; V3f bary; bool front; bool rv = intersect (Line3f (p0, p1), v0, v1, v2, point, bary, front); assert (rv == false); } } } } // namespace void testLineAlgo() { cout << "Testing line algorithms" << endl; testClosestPoints(); testIntersect(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testLineAlgo.h000066400000000000000000000001671417213455000200230ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testLineAlgo(); Imath-3.1.4/src/ImathTest/testMatrix.cpp000066400000000000000000000571141417213455000201340ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include #include "testMatrix.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using IMATH_INTERNAL_NAMESPACE::Int64; // // This file is not currently intended to exhaustively test // the Imath Matrix33 and Matrix44 classes. We leave // that to PyImathTest. // // Instead, in this file we test only those aspects of the // Imath Matrix33 and Matrix44 classes that must be // or are more convenient to test from C++. // void testMatrix() { cout << "Testing functions in ImathMatrix.h" << endl; union { float f; int i; } nanf; nanf.i = 0x7f800001; // NAN union { double d; uint64_t i; } nand; nand.i = 0x7ff0000000000001ULL; // NAN { cout << "Imath::M22f constructors and equality operators" << endl; IMATH_INTERNAL_NAMESPACE::M22f m1; m1[0][0] = 99.0f; m1[1][1] = 101.0f; IMATH_INTERNAL_NAMESPACE::M22f test (m1); assert (test == m1); IMATH_INTERNAL_NAMESPACE::M22f test2; assert (test != test2); IMATH_INTERNAL_NAMESPACE::M22f test3; test3.makeIdentity(); assert (test2 == test3); } { cout << "M22d constructors and equality operators" << endl; IMATH_INTERNAL_NAMESPACE::M22d m2; m2[0][0] = 99.0f; m2[1][1] = 101.0f; IMATH_INTERNAL_NAMESPACE::M22d test (m2); assert (test == m2); IMATH_INTERNAL_NAMESPACE::M22d test2; assert (test != test2); IMATH_INTERNAL_NAMESPACE::M22d test3; test3.makeIdentity(); assert (test2 == test3); IMATH_INTERNAL_NAMESPACE::M22f test4 (1.0f, 2.0f, 3.0f, 4.0f); IMATH_INTERNAL_NAMESPACE::M22d test5 = IMATH_INTERNAL_NAMESPACE::M22d (test4); assert (test5[0][0] == 1.0); assert (test5[0][1] == 2.0); assert (test5[1][0] == 3.0); assert (test5[1][1] == 4.0); } { cout << "M22f inversion operators" << endl; IMATH_INTERNAL_NAMESPACE::M22f m1 (3.0f, 3.0f, 5.0f, 5.0f); IMATH_INTERNAL_NAMESPACE::M22f m2 = m1; assert(m1.inverse(false) == m1.inverse()); m2.invert(false); m1.invert(); assert(m1 == m2); IMATH_INTERNAL_NAMESPACE::M22f m3 (4.0f, 7.0f, 2.0f, 6.0f); m2 = m3; assert(m2.inverse(true) == m2.inverse()); m3.invert(true); m2.invert(); assert(m3 == m2); } { cout << "Imath::M33f shear functions" << endl; IMATH_INTERNAL_NAMESPACE::M33f m1, m2; m1.setShear (2.0f); assert (m1[0][0] == 1.0f && m1[0][1] == 0.0f && m1[0][2] == 0.0f && m1[1][0] == 2.0f && m1[1][1] == 1.0f && m1[1][2] == 0.0f && m1[2][0] == 0.0f && m1[2][1] == 0.0f && m1[2][2] == 1.0f); m2.setShear (IMATH_INTERNAL_NAMESPACE::V2f (3.0f, 4.0f)); assert (m2[0][0] == 1.0f && m2[0][1] == 4.0f && m2[0][2] == 0.0f && m2[1][0] == 3.0f && m2[1][1] == 1.0f && m2[1][2] == 0.0f && m2[2][0] == 0.0f && m2[2][1] == 0.0f && m2[2][2] == 1.0f); m1.shear (IMATH_INTERNAL_NAMESPACE::V2f (5.0f, 6.0f)); assert (m1[0][0] == 13.0f && m1[0][1] == 6.0f && m1[0][2] == 0.0f && m1[1][0] == 7.0f && m1[1][1] == 1.0f && m1[1][2] == 0.0f && m1[2][0] == 0.0f && m1[2][1] == 0.0f && m1[2][2] == 1.0f); m2.shear (7.0f); assert (m2[0][0] == 1.0f && m2[0][1] == 4.0f && m2[0][2] == 0.0f && m2[1][0] == 10.0f && m2[1][1] == 29.0f && m2[1][2] == 0.0f && m2[2][0] == 0.0f && m2[2][1] == 0.0f && m2[2][2] == 1.0f); cout << "M33f constructors and equality operators" << endl; IMATH_INTERNAL_NAMESPACE::M33f test (m2); assert (test == m2); IMATH_INTERNAL_NAMESPACE::M33f test2; assert (test != test2); IMATH_INTERNAL_NAMESPACE::M33f test3; test3.makeIdentity(); assert (test2 == test3); } { cout << "M33f inversion operators" << endl; IMATH_INTERNAL_NAMESPACE::M33f m1 (0.0f, 2.0f, -1.0f, 3.0f, -2.0f, 1.0f, 3.0f, 2.0f, -1.0f); IMATH_INTERNAL_NAMESPACE::M33f m2 = m1; assert(m1.inverse(false) == m1.inverse()); m2.invert(false); m1.invert(); assert(m1 == m2); IMATH_INTERNAL_NAMESPACE::M33f m3 (1.0f, 0.0f, 5.0f, 2.0f, 1.0f, 6.0f, 3.0f, 4.0f, 0.0f); m2 = m3; assert(m3.inverse(true) == m3.inverse()); m3.invert(true); m2.invert(); assert(m3 == m2); IMATH_INTERNAL_NAMESPACE::M33f m4 (0.0f, 2.0f, -1.0f, 3.0f, -2.0f, 1.0f, 3.0f, 2.0f, -1.0f); m2 = m4; assert(m4.gjInverse(false) == m4.gjInverse()); m2.gjInvert(false); m4.gjInvert(); assert(m4 == m2); IMATH_INTERNAL_NAMESPACE::M33f m5 (1.0f, 0.0f, 5.0f, 2.0f, 1.0f, 6.0f, 3.0f, 4.0f, 0.0f); m2 = m5; assert(m5.gjInverse(true) == m5.gjInverse()); m5.gjInvert(true); m2.gjInvert(); assert(m5 == m2); } { cout << "M33d constructors and equality operators" << endl; IMATH_INTERNAL_NAMESPACE::M33d m2; m2[0][0] = 99.0f; m2[1][2] = 101.0f; IMATH_INTERNAL_NAMESPACE::M33d test (m2); assert (test == m2); IMATH_INTERNAL_NAMESPACE::M33d test2; assert (test != test2); IMATH_INTERNAL_NAMESPACE::M33d test3; test3.makeIdentity(); assert (test2 == test3); IMATH_INTERNAL_NAMESPACE::M33f test4 (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f); IMATH_INTERNAL_NAMESPACE::M33d test5 = IMATH_INTERNAL_NAMESPACE::M33d (test4); assert (test5[0][0] == 1.0); assert (test5[0][1] == 2.0); assert (test5[0][2] == 3.0); assert (test5[1][0] == 4.0); assert (test5[1][1] == 5.0); assert (test5[1][2] == 6.0); assert (test5[2][0] == 7.0); assert (test5[2][1] == 8.0); assert (test5[2][2] == 9.0); } { IMATH_INTERNAL_NAMESPACE::M44f m2; m2[0][0] = 99.0f; m2[1][2] = 101.0f; cout << "M44f constructors and equality operators" << endl; IMATH_INTERNAL_NAMESPACE::M44f test (m2); assert (test == m2); IMATH_INTERNAL_NAMESPACE::M44f test2; assert (test != test2); IMATH_INTERNAL_NAMESPACE::M44f test3; test3.makeIdentity(); assert (test2 == test3); // // Test non-equality when a NAN is in the same // place in two identical matrices // test2[0][0] = nanf.f; test3 = test2; assert (test2 != test3); } { IMATH_INTERNAL_NAMESPACE::M44d m2; m2[0][0] = 99.0f; m2[1][2] = 101.0f; cout << "M44d constructors and equality operators" << endl; IMATH_INTERNAL_NAMESPACE::M44d test (m2); assert (test == m2); IMATH_INTERNAL_NAMESPACE::M44d test2; assert (test != test2); IMATH_INTERNAL_NAMESPACE::M44d test3; test3.makeIdentity(); assert (test2 == test3); // // Test non-equality when a NAN is in the same // place in two identical matrices // test2[0][0] = nand.d; test3 = test2; assert (test2 != test3); IMATH_INTERNAL_NAMESPACE::M44f test4 (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f); IMATH_INTERNAL_NAMESPACE::M44d test5 = IMATH_INTERNAL_NAMESPACE::M44d (test4); assert (test5[0][0] == 1.0); assert (test5[0][1] == 2.0); assert (test5[0][2] == 3.0); assert (test5[0][3] == 4.0); assert (test5[1][0] == 5.0); assert (test5[1][1] == 6.0); assert (test5[1][2] == 7.0); assert (test5[1][3] == 8.0); assert (test5[2][0] == 9.0); assert (test5[2][1] == 10.0); assert (test5[2][2] == 11.0); assert (test5[2][3] == 12.0); assert (test5[3][0] == 13.0); assert (test5[3][1] == 14.0); assert (test5[3][2] == 15.0); assert (test5[3][3] == 16.0); } { cout << "M44f inversion operators" << endl; IMATH_INTERNAL_NAMESPACE::M44f m1 (1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); IMATH_INTERNAL_NAMESPACE::M44f m2 = m1; assert(m1.inverse(false) == m1.inverse()); m2.invert(false); m1.invert(); assert(m1 == m2); IMATH_INTERNAL_NAMESPACE::M44f m3 (5.0f, 6.0f, 6.0f, 8.0f, 2.0f, 2.0f, 2.0f, 8.0f, 6.0f, 6.0f, 2.0f, 8.0f, 2.0f, 3.0f, 6.0f, 7.0f); m2 = m3; assert(m3.inverse(true) == m3.inverse()); m3.invert(true); m2.invert(); assert(m3 == m2); IMATH_INTERNAL_NAMESPACE::M44f m4 (1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); m2 = m4; assert(m4.gjInverse(false) == m4.gjInverse()); m2.gjInvert(false); m4.gjInvert(); assert(m4 == m2); IMATH_INTERNAL_NAMESPACE::M44f m5 (5.0f, 6.0f, 6.0f, 8.0f, 2.0f, 2.0f, 2.0f, 8.0f, 6.0f, 6.0f, 2.0f, 8.0f, 2.0f, 3.0f, 6.0f, 7.0f); m2 = m5; assert(m5.gjInverse(true) == m5.gjInverse()); m5.gjInvert(true); m2.gjInvert(); assert(m5 == m2); } { cout << "Converting between M33 and M44" << endl; IMATH_INTERNAL_NAMESPACE::M44d m1; m1[0][0] = 99; IMATH_INTERNAL_NAMESPACE::M44f m2; m2.setValue (m1); assert (m2[0][0] == (float) m1[0][0]); m1[0][0] = 101; m1.setValue (m2); assert (m2[0][0] == (float) m1[0][0]); } // Matrix minors { cout << "3x3 Matrix minors" << endl; IMATH_INTERNAL_NAMESPACE::M33f a (1, 2, 3, 4, 5, 6, 7, 8, 9); assert (a.minorOf (0, 0) == a.fastMinor (1, 2, 1, 2)); assert (a.minorOf (0, 1) == a.fastMinor (1, 2, 0, 2)); assert (a.minorOf (0, 2) == a.fastMinor (1, 2, 0, 1)); assert (a.minorOf (1, 0) == a.fastMinor (0, 2, 1, 2)); assert (a.minorOf (1, 1) == a.fastMinor (0, 2, 0, 2)); assert (a.minorOf (1, 2) == a.fastMinor (0, 2, 0, 1)); assert (a.minorOf (2, 0) == a.fastMinor (0, 1, 1, 2)); assert (a.minorOf (2, 1) == a.fastMinor (0, 1, 0, 2)); assert (a.minorOf (2, 2) == a.fastMinor (0, 1, 0, 1)); } { IMATH_INTERNAL_NAMESPACE::M33d a (1, 2, 3, 4, 5, 6, 7, 8, 9); assert (a.minorOf (0, 0) == a.fastMinor (1, 2, 1, 2)); assert (a.minorOf (0, 1) == a.fastMinor (1, 2, 0, 2)); assert (a.minorOf (0, 2) == a.fastMinor (1, 2, 0, 1)); assert (a.minorOf (1, 0) == a.fastMinor (0, 2, 1, 2)); assert (a.minorOf (1, 1) == a.fastMinor (0, 2, 0, 2)); assert (a.minorOf (1, 2) == a.fastMinor (0, 2, 0, 1)); assert (a.minorOf (2, 0) == a.fastMinor (0, 1, 1, 2)); assert (a.minorOf (2, 1) == a.fastMinor (0, 1, 0, 2)); assert (a.minorOf (2, 2) == a.fastMinor (0, 1, 0, 1)); } // Determinants (by building a random singular value decomposition) { cout << "2x2 determinant" << endl; IMATH_INTERNAL_NAMESPACE::Rand32 random; IMATH_INTERNAL_NAMESPACE::M22f u; IMATH_INTERNAL_NAMESPACE::M22f v; IMATH_INTERNAL_NAMESPACE::M22f s; u.setRotation (random.nextf()); v.setRotation (random.nextf()); s[0][0] = random.nextf(); s[1][1] = random.nextf(); IMATH_INTERNAL_NAMESPACE::M22f c = u * s * v.transpose(); assert (fabsf (c.determinant() - s[0][0] * s[1][1]) <= u.baseTypeEpsilon()); } { IMATH_INTERNAL_NAMESPACE::Rand32 random; IMATH_INTERNAL_NAMESPACE::M22d u; IMATH_INTERNAL_NAMESPACE::M22d v; IMATH_INTERNAL_NAMESPACE::M22d s; u.setRotation ((double) random.nextf()); v.setRotation ((double) random.nextf()); s[0][0] = (double) random.nextf(); s[1][1] = (double) random.nextf(); IMATH_INTERNAL_NAMESPACE::M22d c = u * s * v.transpose(); assert (fabs (c.determinant() - s[0][0] * s[1][1]) <= u.baseTypeEpsilon()); } { cout << "3x3 determinant" << endl; IMATH_INTERNAL_NAMESPACE::Rand32 random; IMATH_INTERNAL_NAMESPACE::M33f u; IMATH_INTERNAL_NAMESPACE::M33f v; IMATH_INTERNAL_NAMESPACE::M33f s; u.setRotation (random.nextf()); v.setRotation (random.nextf()); s[0][0] = random.nextf(); s[1][1] = random.nextf(); s[2][2] = random.nextf(); IMATH_INTERNAL_NAMESPACE::M33f c = u * s * v.transpose(); assert (fabsf (c.determinant() - s[0][0] * s[1][1] * s[2][2]) <= u.baseTypeEpsilon()); } { IMATH_INTERNAL_NAMESPACE::Rand32 random; IMATH_INTERNAL_NAMESPACE::M33d u; IMATH_INTERNAL_NAMESPACE::M33d v; IMATH_INTERNAL_NAMESPACE::M33d s; u.setRotation ((double) random.nextf()); v.setRotation ((double) random.nextf()); s[0][0] = (double) random.nextf(); s[1][1] = (double) random.nextf(); s[2][2] = (double) random.nextf(); IMATH_INTERNAL_NAMESPACE::M33d c = u * s * v.transpose(); assert (fabs (c.determinant() - s[0][0] * s[1][1] * s[2][2]) <= u.baseTypeEpsilon()); } // Outer product of two 3D vectors { cout << "Outer product of two 3D vectors" << endl; IMATH_INTERNAL_NAMESPACE::V3f a (1, 2, 3); IMATH_INTERNAL_NAMESPACE::V3f b (4, 5, 6); IMATH_INTERNAL_NAMESPACE::M33f p = IMATH_INTERNAL_NAMESPACE::outerProduct (a, b); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { assert (p[i][j] == a[i] * b[j]); } } } { IMATH_INTERNAL_NAMESPACE::V3d a (1, 2, 3); IMATH_INTERNAL_NAMESPACE::V3d b (4, 5, 6); IMATH_INTERNAL_NAMESPACE::M33d p = IMATH_INTERNAL_NAMESPACE::outerProduct (a, b); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { assert (p[i][j] == a[i] * b[j]); } } } // Determinants (by building a random singular value decomposition) { cout << "4x4 determinants" << endl; IMATH_INTERNAL_NAMESPACE::Rand32 random; IMATH_INTERNAL_NAMESPACE::M44f u = IMATH_INTERNAL_NAMESPACE::rotationMatrix ( IMATH_INTERNAL_NAMESPACE::V3f (random.nextf(), random.nextf(), random.nextf()) .normalize(), IMATH_INTERNAL_NAMESPACE::V3f (random.nextf(), random.nextf(), random.nextf()) .normalize()); IMATH_INTERNAL_NAMESPACE::M44f v = IMATH_INTERNAL_NAMESPACE::rotationMatrix ( IMATH_INTERNAL_NAMESPACE::V3f (random.nextf(), random.nextf(), random.nextf()) .normalize(), IMATH_INTERNAL_NAMESPACE::V3f (random.nextf(), random.nextf(), random.nextf()) .normalize()); IMATH_INTERNAL_NAMESPACE::M44f s; s[0][0] = random.nextf(); s[1][1] = random.nextf(); s[2][2] = random.nextf(); s[3][3] = random.nextf(); IMATH_INTERNAL_NAMESPACE::M44f c = u * s * v.transpose(); assert (fabsf (c.determinant() - s[0][0] * s[1][1] * s[2][2] * s[3][3]) <= u.baseTypeEpsilon()); } { IMATH_INTERNAL_NAMESPACE::Rand32 random; IMATH_INTERNAL_NAMESPACE::M44d u = IMATH_INTERNAL_NAMESPACE::rotationMatrix ( IMATH_INTERNAL_NAMESPACE::V3d (random.nextf(), random.nextf(), random.nextf()) .normalize(), IMATH_INTERNAL_NAMESPACE::V3d (random.nextf(), random.nextf(), random.nextf()) .normalize()); IMATH_INTERNAL_NAMESPACE::M44d v = IMATH_INTERNAL_NAMESPACE::rotationMatrix ( IMATH_INTERNAL_NAMESPACE::V3d (random.nextf(), random.nextf(), random.nextf()) .normalize(), IMATH_INTERNAL_NAMESPACE::V3d (random.nextf(), random.nextf(), random.nextf()) .normalize()); IMATH_INTERNAL_NAMESPACE::M44d s; s[0][0] = random.nextf(); s[1][1] = random.nextf(); s[2][2] = random.nextf(); s[3][3] = random.nextf(); IMATH_INTERNAL_NAMESPACE::M44d c = u * s * v.transpose(); assert (fabs (c.determinant() - s[0][0] * s[1][1] * s[2][2] * s[3][3]) <= u.baseTypeEpsilon()); } // Matrix minors { cout << "4x4 matrix minors" << endl; IMATH_INTERNAL_NAMESPACE::M44d a (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); assert (a.minorOf (0, 0) == a.fastMinor (1, 2, 3, 1, 2, 3)); assert (a.minorOf (0, 1) == a.fastMinor (1, 2, 3, 0, 2, 3)); assert (a.minorOf (0, 2) == a.fastMinor (1, 2, 3, 0, 1, 3)); assert (a.minorOf (0, 3) == a.fastMinor (1, 2, 3, 0, 1, 2)); assert (a.minorOf (1, 0) == a.fastMinor (0, 2, 3, 1, 2, 3)); assert (a.minorOf (1, 1) == a.fastMinor (0, 2, 3, 0, 2, 3)); assert (a.minorOf (1, 2) == a.fastMinor (0, 2, 3, 0, 1, 3)); assert (a.minorOf (1, 3) == a.fastMinor (0, 2, 3, 0, 1, 2)); assert (a.minorOf (2, 0) == a.fastMinor (0, 1, 3, 1, 2, 3)); assert (a.minorOf (2, 1) == a.fastMinor (0, 1, 3, 0, 2, 3)); assert (a.minorOf (2, 2) == a.fastMinor (0, 1, 3, 0, 1, 3)); assert (a.minorOf (2, 3) == a.fastMinor (0, 1, 3, 0, 1, 2)); assert (a.minorOf (3, 0) == a.fastMinor (0, 1, 2, 1, 2, 3)); assert (a.minorOf (3, 1) == a.fastMinor (0, 1, 2, 0, 2, 3)); assert (a.minorOf (3, 2) == a.fastMinor (0, 1, 2, 0, 1, 3)); assert (a.minorOf (3, 3) == a.fastMinor (0, 1, 2, 0, 1, 2)); } { IMATH_INTERNAL_NAMESPACE::M44f a (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); assert (a.minorOf (0, 0) == a.fastMinor (1, 2, 3, 1, 2, 3)); assert (a.minorOf (0, 1) == a.fastMinor (1, 2, 3, 0, 2, 3)); assert (a.minorOf (0, 2) == a.fastMinor (1, 2, 3, 0, 1, 3)); assert (a.minorOf (0, 3) == a.fastMinor (1, 2, 3, 0, 1, 2)); assert (a.minorOf (1, 0) == a.fastMinor (0, 2, 3, 1, 2, 3)); assert (a.minorOf (1, 1) == a.fastMinor (0, 2, 3, 0, 2, 3)); assert (a.minorOf (1, 2) == a.fastMinor (0, 2, 3, 0, 1, 3)); assert (a.minorOf (1, 3) == a.fastMinor (0, 2, 3, 0, 1, 2)); assert (a.minorOf (2, 0) == a.fastMinor (0, 1, 3, 1, 2, 3)); assert (a.minorOf (2, 1) == a.fastMinor (0, 1, 3, 0, 2, 3)); assert (a.minorOf (2, 2) == a.fastMinor (0, 1, 3, 0, 1, 3)); assert (a.minorOf (2, 3) == a.fastMinor (0, 1, 3, 0, 1, 2)); assert (a.minorOf (3, 0) == a.fastMinor (0, 1, 2, 1, 2, 3)); assert (a.minorOf (3, 1) == a.fastMinor (0, 1, 2, 0, 2, 3)); assert (a.minorOf (3, 2) == a.fastMinor (0, 1, 2, 0, 1, 3)); assert (a.minorOf (3, 3) == a.fastMinor (0, 1, 2, 0, 1, 2)); } // VC 2005 64 bits compiler has a bug with __restrict keword. // Pointers with __restrict should not alias the same symbol. // But, with optimization on, VC removes intermediate temp variable // and ignores __restrict. { cout << "M44 multiplicaftion test" << endl; IMATH_INTERNAL_NAMESPACE::M44f M (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f); IMATH_INTERNAL_NAMESPACE::M44f N; N.makeIdentity(); // N should be equal to M // This typical test fails // when __restrict is used for pointers in "multiply" function. N = N * M; assert (N == M); if (N != M) { cout << "M44 multiplication test has failed, error." << endl << "M" << endl << M << endl << "N" << endl << N << endl; } } cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testMatrix.h000066400000000000000000000001651417213455000175730ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testMatrix(); Imath-3.1.4/src/ImathTest/testMiscMatrixAlgo.cpp000066400000000000000000000172441417213455000215530ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include "testMiscMatrixAlgo.h" #if 0 # define debug(x) (printf x, fflush (stdout)) #else # define debug(x) #endif using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { float rad (float deg) { return deg * (M_PI / 180); } void testComputeLocalFrame() { float eps = 0.00005; Rand48 random (0); for (int i = 0; i < 100000; ++i) { debug (("iteration: %d\n", i)); // Random pos V3f p (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10)); // Random xDir V3f xDir (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10)); // Random normalDir V3f normalDir (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10)); // Run computeLocalFrame we want to test M44f L = computeLocalFrame (p, xDir, normalDir); // test position for (int j = 0; j < 3; j++) { if (abs (L[3][j] - p[j]) > eps) assert (false); } if (abs (L[3][3] - 1.0) > eps) assert (false); // check that xAxis has the same dir as xDir and that is is normalized V3f x (L[0][0], L[0][1], L[0][2]); assert ((x % xDir).length() < eps); if (abs (L[0][3]) > eps) assert (false); assert ((abs (x.length() - 1.f) < eps)); // Check that y is normal to x and to normalDir, and is normalized V3f y (L[1][0], L[1][1], L[1][2]); if (abs (L[1][3]) > eps) assert (false); assert (abs (x ^ y) < eps); /*std::cout< eps) assert (false); assert ((abs (z.length() - 1.f) < eps)); assert (abs (x ^ z) < eps); assert (abs (y ^ z) < eps); assert (((x % y) ^ z) > 0); } } void getRandTRS (Rand48& random, V3f& trans, V3f& rot, V3f& scale) { // Translate trans = V3f (random.nextf (-10, 10), random.nextf (-10, 10), random.nextf (-10, 10)); // Rotate rot = V3f (rad (random.nextf (-180, 180)), rad (random.nextf (-180, 180)), rad (random.nextf (-180, 180))); // Scale V3f s (random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0)); for (int j = 0; j < 3; j++) if (random.nextf (0.0, 1.0) >= 0.5) s[j] *= -1; scale = s; } M44f createRandomMat (Rand48& random, V3f& trans, V3f& rot, V3f& scale) { M44f M; V3f t, r, s; getRandTRS (random, t, r, s); M.translate (t); M.rotate (r); // Shear M. V3f h (random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0), random.nextf (0.000001, 2.0)); for (int j = 0; j < 3; j++) if (random.nextf (0.0, 1.0) >= 0.5) h[j] *= -1; M.shear (h); M.scale (s); // // Add a small random error to the elements of M // for (int j = 0; j < 4; ++j) for (int k = 0; k < 3; ++k) M[j][k] += random.nextf (-1e-7, 1e-7); V3f sh; extractSHRT (M, scale, sh, rot, trans); debug (("Scale : %f %f %f\n", s[0], s[1], s[2])); debug (("Shear : %f %f %f\n", h[0], h[1], h[2])); debug (("Rot : %f %f %f\n", r[0], r[1], r[2])); debug (("Trans : %f %f %f\n", t[0], t[1], t[2])); return M; } void compareMat (M44f& M, M44f& N) { float eps = 0.0001; /// Verify that the entries in M and N do not // differ too much. M44f D (M - N); for (int j = 0; j < 4; ++j) { for (int k = 0; k < 4; ++k) { //cout << "diff="< eps) { cout << "unexpectedly diff " << D[j][k] << endl; cout << j << " " << k << endl; cout << "M\n" << M << endl; cout << "N\n" << N << endl; cout << "D\n" << D << endl; assert (false); } } } } void testAddOffset() { Rand48 random (0); for (int i = 0; i < 100000; ++i) { debug (("iteration: %d\n", i)); V3f transA, transB, rotA, rotB, scaleA, scaleB; V3f tOffset, rOffset, sOffset; M44f inMat = createRandomMat (random, transA, rotA, scaleA); M44f refMat = createRandomMat (random, transB, rotB, scaleB); getRandTRS (random, tOffset, rOffset, sOffset); // addOffset : function to test M44f outMat = addOffset (inMat, tOffset, rOffset, sOffset, refMat); // add the inverse offset M44f invO; invO.rotate (V3f (rad (rOffset[0]), rad (rOffset[1]), rad (rOffset[2]))); invO[3][0] = tOffset[0]; invO[3][1] = tOffset[1]; invO[3][2] = tOffset[2]; invO.invert(); M44f invS; invS.scale (sOffset); invS.invert(); // zero scale is avoided in getRandTRS // in ref mat from the function result M44f outInRefMat = invO * invS * outMat; // in ref mat from the inputs M44f inRefMat = inMat * refMat; // compare the mat compareMat (outInRefMat, inRefMat); } } void testRSMatrix (M44f& M, V3f& t, V3f& r, V3f& s) { M44f N; N.makeIdentity(); N.translate (t); // ... matrix compositions N.rotate (r); N.scale (s); compareMat (M, N); } void testComputeRSMatrix() { Rand48 random (0); for (int i = 0; i < 100000; ++i) { debug (("iteration: %d\n", i)); V3f transA, transB, rotA, rotB, scaleA, scaleB; M44f A = createRandomMat (random, transA, rotA, scaleA); M44f B = createRandomMat (random, transB, rotB, scaleB); M44f ArAsA = computeRSMatrix (true, true, A, B); M44f ArBsB = computeRSMatrix (false, false, A, B); M44f ArAsB = computeRSMatrix (true, false, A, B); M44f ArBsA = computeRSMatrix (false, true, A, B); testRSMatrix (ArAsA, transA, rotA, scaleA); testRSMatrix (ArBsB, transA, rotB, scaleB); testRSMatrix (ArAsB, transA, rotA, scaleB); testRSMatrix (ArBsA, transA, rotB, scaleA); debug (("\n")); } } } // namespace void testMiscMatrixAlgo() { try { cout << "Testing misc functions in ImathMatrixAlgo.h" << endl; cout << "Testing the building of an orthonormal direct frame from : a position, " << "an x axis direction and a normal to the y axis" << endl; cout << "IMATH_INTERNAL_NAMESPACE::computeLocalFrame()" << endl; testComputeLocalFrame(); cout << "ok\n" << endl; cout << "Add a translate/rotate/scale offset to an input frame " << "and put it in another frame of reference" << endl; cout << "IMATH_INTERNAL_NAMESPACE::addOffset()" << endl; testAddOffset(); cout << "ok\n" << endl; cout << "Compute Translate/Rotate/Scale matrix from matrix A " << endl; cout << "with the Rotate/Scale of Matrix B" << endl; cout << "IMATH_INTERNAL_NAMESPACE::computeRSMatrix()" << endl; testComputeRSMatrix(); cout << "ok\n" << endl; } catch (std::exception& e) { cerr << " Caught exception: " << e.what() << endl; } } Imath-3.1.4/src/ImathTest/testMiscMatrixAlgo.h000066400000000000000000000001751417213455000212130ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testMiscMatrixAlgo(); Imath-3.1.4/src/ImathTest/testProcrustes.cpp000066400000000000000000000352001417213455000210310ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include // Verify that if our transformation is already orthogonal, procrustes doesn't // change that: template void testTranslationRotationMatrix (const IMATH_INTERNAL_NAMESPACE::M44d& mat) { std::cout << "Testing known translate/rotate matrix:\n " << mat; typedef IMATH_INTERNAL_NAMESPACE::Vec3 Vec; static IMATH_INTERNAL_NAMESPACE::Rand48 rand (2047); size_t numPoints = 7; std::vector from; from.reserve (numPoints); std::vector to; to.reserve (numPoints); for (size_t i = 0; i < numPoints; ++i) { IMATH_INTERNAL_NAMESPACE::V3d a (rand.nextf(), rand.nextf(), rand.nextf()); IMATH_INTERNAL_NAMESPACE::V3d b = a * mat; from.push_back (Vec (a)); to.push_back (Vec (b)); } std::vector weights (numPoints, T (1)); const IMATH_INTERNAL_NAMESPACE::M44d m1 = procrustesRotationAndTranslation (&from[0], &to[0], &weights[0], numPoints); const IMATH_INTERNAL_NAMESPACE::M44d m2 = procrustesRotationAndTranslation (&from[0], &to[0], numPoints); const T eps = sizeof (T) == 8 ? 1e-8 : 1e-4; for (size_t i = 0; i < numPoints; ++i) { const IMATH_INTERNAL_NAMESPACE::V3d a = from[i]; const IMATH_INTERNAL_NAMESPACE::V3d b = to[i]; const IMATH_INTERNAL_NAMESPACE::V3d b1 = a * m1; const IMATH_INTERNAL_NAMESPACE::V3d b2 = a * m2; assert ((b - b1).length() < eps); assert ((b - b2).length() < eps); } std::cout << " OK\n"; } // Test that if we pass in a matrix that we know consists only of translates, // rotates, and uniform scale that we get an exact match. template void testWithTranslateRotateAndScale (const IMATH_INTERNAL_NAMESPACE::M44d& m) { std::cout << "Testing with known translate/rotate/scale matrix\n" << m; IMATH_INTERNAL_NAMESPACE::Rand48 rand (5376); typedef IMATH_INTERNAL_NAMESPACE::Vec3 V3; std::vector from; std::vector weights; const float eps = 1e-4; std::cout << "numPoints: " << std::flush; for (size_t numPoints = 1; numPoints < 10; ++numPoints) { from.push_back (V3 (rand.nextf(), rand.nextf(), rand.nextf())); weights.push_back (rand.nextf()); std::cout << from.size() << " "; std::vector to; for (size_t i = 0; i < from.size(); ++i) to.push_back (from[i] * m); // weighted: IMATH_INTERNAL_NAMESPACE::M44d res = IMATH_INTERNAL_NAMESPACE::procrustesRotationAndTranslation (&from[0], &to[0], &weights[0], from.size(), true); for (size_t i = 0; i < from.size(); ++i) assert ((from[i] * res - to[i]).length() < eps); // unweighted: res = IMATH_INTERNAL_NAMESPACE::procrustesRotationAndTranslation (&from[0], &to[0], from.size(), true); for (size_t i = 0; i < from.size(); ++i) assert ((from[i] * res - to[i]).length() < eps); } std::cout << " OK\n"; } template double procrustesError (const IMATH_INTERNAL_NAMESPACE::Vec3* from, const IMATH_INTERNAL_NAMESPACE::Vec3* to, const T* weights, const size_t n, const IMATH_INTERNAL_NAMESPACE::M44d& xform) { double result = 0.0; double residual = 0.0; for (size_t i = 0; i < n; ++i) { IMATH_INTERNAL_NAMESPACE::V3d xformed = IMATH_INTERNAL_NAMESPACE::V3d (from[i]) * xform; IMATH_INTERNAL_NAMESPACE::V3d diff = xformed - IMATH_INTERNAL_NAMESPACE::V3d (to[i]); const double w = weights[i]; const double mag = w * diff.length2(); // Use Kahan summation for the heck of it: const double y = mag - residual; const double t = result + y; residual = (t - result) - y; result = t; } return result; } template void verifyProcrustes (const std::vector>& from, const std::vector>& to) { const T eps = std::sqrt (std::numeric_limits::epsilon()); const size_t n = from.size(); // Validate that passing in uniform weights gives the same answer as // passing in no weights: std::vector weights (from.size()); for (size_t i = 0; i < weights.size(); ++i) weights[i] = 1; IMATH_INTERNAL_NAMESPACE::M44d m1 = procrustesRotationAndTranslation (&from[0], &to[0], n); IMATH_INTERNAL_NAMESPACE::M44d m2 = procrustesRotationAndTranslation (&from[0], &to[0], &weights[0], n); for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) assert (std::abs (m1[i][j] - m2[i][j]) < eps); // Now try the weighted version: for (size_t i = 0; i < weights.size(); ++i) weights[i] = i + 1; IMATH_INTERNAL_NAMESPACE::M44d m = procrustesRotationAndTranslation (&from[0], &to[0], &weights[0], n); // with scale: IMATH_INTERNAL_NAMESPACE::M44d ms = procrustesRotationAndTranslation (&from[0], &to[0], &weights[0], n, true); // Verify that it's orthonormal w/ positive determinant. const T det = m.determinant(); assert (std::abs (det - T (1)) < eps); // Verify orthonormal: IMATH_INTERNAL_NAMESPACE::M33d upperLeft; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) upperLeft[i][j] = m[i][j]; IMATH_INTERNAL_NAMESPACE::M33d product = upperLeft * upperLeft.transposed(); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { const double expected = (i == j ? 1.0 : 0.0); assert (std::abs (product[i][j] - expected) < eps); } } // Verify that nearby transforms are worse: const size_t numTries = 10; IMATH_INTERNAL_NAMESPACE::Rand48 rand (1056); const double delta = 1e-3; for (size_t i = 0; i < numTries; ++i) { // Construct an orthogonal rotation matrix using Euler angles: IMATH_INTERNAL_NAMESPACE::Eulerd diffRot (delta * rand.nextf(), delta * rand.nextf(), delta * rand.nextf()); assert (procrustesError (&from[0], &to[0], &weights[0], n, m * diffRot.toMatrix44()) > procrustesError (&from[0], &to[0], &weights[0], n, m)); // Try a small translation: IMATH_INTERNAL_NAMESPACE::V3d diffTrans (delta * rand.nextf(), delta * rand.nextf(), delta * rand.nextf()); IMATH_INTERNAL_NAMESPACE::M44d translateMatrix; translateMatrix.translate (diffTrans); assert (procrustesError (&from[0], &to[0], &weights[0], n, m * translateMatrix) > procrustesError (&from[0], &to[0], &weights[0], n, m)); } // Try a small scale: IMATH_INTERNAL_NAMESPACE::M44d newMat = ms; const double scaleDiff = delta; for (size_t i = 0; i < 3; ++i) for (size_t j = 0; j < 3; ++j) newMat[i][j] = ms[i][j] * (1.0 + scaleDiff); assert (procrustesError (&from[0], &to[0], &weights[0], n, newMat) > procrustesError (&from[0], &to[0], &weights[0], n, ms)); for (size_t i = 0; i < 3; ++i) for (size_t j = 0; j < 3; ++j) newMat[i][j] = ms[i][j] * (1.0 - scaleDiff); assert (procrustesError (&from[0], &to[0], &weights[0], n, newMat) > procrustesError (&from[0], &to[0], &weights[0], n, ms)); // // Verify the magical property that makes shape springs work: // when the displacements Q*A-B, times the weights, // are applied as forces at B, // there is zero net force and zero net torque. // { IMATH_INTERNAL_NAMESPACE::V3d center (0, 0, 0); IMATH_INTERNAL_NAMESPACE::V3d netForce (0); IMATH_INTERNAL_NAMESPACE::V3d netTorque (0); for (size_t iPoint = 0; iPoint < n; ++iPoint) { const IMATH_INTERNAL_NAMESPACE::V3d force = weights[iPoint] * (from[iPoint] * m - to[iPoint]); netForce += force; netTorque += to[iPoint].cross (force); } assert (netForce.length2() < eps); assert (netTorque.length2() < eps); } } template void testProcrustesWithMatrix (const IMATH_INTERNAL_NAMESPACE::M44d& m) { std::cout << "Testing Procrustes algorithm with arbitrary matrix: \n" << m; std::vector> fromPoints; std::vector> toPoints; IMATH_INTERNAL_NAMESPACE::Rand48 random (1209); std::cout << " numPoints: "; for (size_t numPoints = 1; numPoints < 10; ++numPoints) { std::cout << numPoints << " " << std::flush; fromPoints.clear(); toPoints.clear(); for (size_t i = 0; i < numPoints; ++i) { const IMATH_INTERNAL_NAMESPACE::V3d fromPt (random.nextf(), random.nextf(), random.nextf()); const IMATH_INTERNAL_NAMESPACE::V3d toPt = fromPt * m; fromPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3 (fromPt)); toPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3 (toPt)); } verifyProcrustes (fromPoints, toPoints); } std::cout << "OK\n"; } template void testProcrustesImp() { // Test the empty case: IMATH_INTERNAL_NAMESPACE::M44d id = procrustesRotationAndTranslation ((IMATH_INTERNAL_NAMESPACE::Vec3*) 0, (IMATH_INTERNAL_NAMESPACE::Vec3*) 0, (T*) 0, 0); assert (id == IMATH_INTERNAL_NAMESPACE::M44d()); id = procrustesRotationAndTranslation ((IMATH_INTERNAL_NAMESPACE::Vec3*) 0, (IMATH_INTERNAL_NAMESPACE::Vec3*) 0, 0); assert (id == IMATH_INTERNAL_NAMESPACE::M44d()); // First we'll test with a bunch of known translation/rotation matrices // to make sure we get back exactly the same points: IMATH_INTERNAL_NAMESPACE::M44d m; m.makeIdentity(); testTranslationRotationMatrix (m); m.translate (IMATH_INTERNAL_NAMESPACE::V3d (3.0, 5.0, -0.2)); testTranslationRotationMatrix (m); m.rotate (IMATH_INTERNAL_NAMESPACE::V3d (M_PI, 0, 0)); testTranslationRotationMatrix (m); m.rotate (IMATH_INTERNAL_NAMESPACE::V3d (0, M_PI / 4.0, 0)); testTranslationRotationMatrix (m); m.rotate (IMATH_INTERNAL_NAMESPACE::V3d (0, 0, -3.0 / 4.0 * M_PI)); testTranslationRotationMatrix (m); m.makeIdentity(); testWithTranslateRotateAndScale (m); m.translate (IMATH_INTERNAL_NAMESPACE::V3d (0.4, 6.0, 10.0)); testWithTranslateRotateAndScale (m); m.rotate (IMATH_INTERNAL_NAMESPACE::V3d (M_PI, 0, 0)); testWithTranslateRotateAndScale (m); m.rotate (IMATH_INTERNAL_NAMESPACE::V3d (0, M_PI / 4.0, 0)); testWithTranslateRotateAndScale (m); m.rotate (IMATH_INTERNAL_NAMESPACE::V3d (0, 0, -3.0 / 4.0 * M_PI)); testWithTranslateRotateAndScale (m); m.scale (IMATH_INTERNAL_NAMESPACE::V3d (2.0, 2.0, 2.0)); testWithTranslateRotateAndScale (m); m.scale (IMATH_INTERNAL_NAMESPACE::V3d (0.01, 0.01, 0.01)); testWithTranslateRotateAndScale (m); // Now we'll test with some random point sets and verify // the various Procrustes properties: std::vector> fromPoints; std::vector> toPoints; fromPoints.clear(); toPoints.clear(); for (size_t i = 0; i < 4; ++i) { const T theta = T (2 * i) / T (M_PI); fromPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3 (cos (theta), sin (theta), 0)); toPoints.push_back (IMATH_INTERNAL_NAMESPACE::Vec3 (cos (theta + M_PI / 3.0), sin (theta + M_PI / 3.0), 0)); } verifyProcrustes (fromPoints, toPoints); IMATH_INTERNAL_NAMESPACE::Rand48 random (1209); for (size_t numPoints = 1; numPoints < 10; ++numPoints) { fromPoints.clear(); toPoints.clear(); for (size_t i = 0; i < numPoints; ++i) { fromPoints.push_back ( IMATH_INTERNAL_NAMESPACE::Vec3 (random.nextf(), random.nextf(), random.nextf())); toPoints.push_back ( IMATH_INTERNAL_NAMESPACE::Vec3 (random.nextf(), random.nextf(), random.nextf())); } } verifyProcrustes (fromPoints, toPoints); // Test with some known matrices of varying degrees of quality: testProcrustesWithMatrix (m); m.translate (IMATH_INTERNAL_NAMESPACE::Vec3 (3, 4, 1)); testProcrustesWithMatrix (m); m.translate (IMATH_INTERNAL_NAMESPACE::Vec3 (-10, 2, 1)); testProcrustesWithMatrix (m); IMATH_INTERNAL_NAMESPACE::Eulerd rot (M_PI / 3.0, 3.0 * M_PI / 4.0, 0); m = m * rot.toMatrix44(); testProcrustesWithMatrix (m); m.scale (IMATH_INTERNAL_NAMESPACE::Vec3 (1.5, 6.4, 2.0)); testProcrustesWithMatrix (m); IMATH_INTERNAL_NAMESPACE::Eulerd rot2 (1.0, M_PI, M_PI / 3.0); m = m * rot.toMatrix44(); m.scale (IMATH_INTERNAL_NAMESPACE::Vec3 (-1, 1, 1)); testProcrustesWithMatrix (m); m.scale (IMATH_INTERNAL_NAMESPACE::Vec3 (1, 0.001, 1)); testProcrustesWithMatrix (m); m.scale (IMATH_INTERNAL_NAMESPACE::Vec3 (1, 1, 0)); testProcrustesWithMatrix (m); } void testProcrustes() { std::cout << "Testing Procrustes algorithms in single precision..." << std::endl; testProcrustesImp(); std::cout << "Testing Procrustes algorithms in double precision..." << std::endl; testProcrustesImp(); } Imath-3.1.4/src/ImathTest/testProcrustes.h000066400000000000000000000001711417213455000204750ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testProcrustes(); Imath-3.1.4/src/ImathTest/testQuat.cpp000066400000000000000000000116521417213455000175770ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include #include "testQuat.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { template void testQuatT () { const T s = std::numeric_limits::min(); const T e = 4 * std::numeric_limits::epsilon(); // // constructors, r(), v() // { Quat q = Quat(); assert (q.r == 1 && q.v == Vec3 (0, 0, 0)); q = Quat (2, 3, 4, 5); assert (q.r == 2 && q.v == Vec3 (3, 4, 5)); q = Quat (6, Vec3 (7, 8, 9)); assert (q.r == 6 && q.v == Vec3 (7, 8, 9)); Quat q1 = Quat (q); assert (q1.r == 6 && q1.v == Vec3 (7, 8, 9)); } // // invert(), inverse() // { Quat q = Quat (1, 0, 0, 1); assert (q.inverse() == Quat (0.5, 0, 0, -0.5)); q.invert(); assert (q == Quat (0.5, 0, 0, -0.5)); } // // normalize(), normalized() // { Quat q = Quat (2, Vec3 (0, 0, 0)); assert (q.normalized() == Quat (1, 0, 0, 0)); q.normalize(); assert (q == Quat (1, 0, 0, 0)); q = Quat (0, Vec3 (0, 2, 0)); assert (q.normalized() == Quat (0, 0, 1, 0)); q.normalize(); assert (q == Quat (0, 0, 1, 0)); } // // length() // { Quat q = Quat (3, 0, 4, 0); assert (q.length() == 5); } // // setAxisAngle(), angle(), axis() // { Quat q; q.setAxisAngle (Vec3 (0, 0, 1), M_PI_2); Vec3 v = q.axis(); T a = q.angle(); assert (v.equalWithAbsError (Vec3 (0, 0, 1), e)); assert (IMATH_INTERNAL_NAMESPACE::equal (a, T (M_PI_2), e)); } // // Accuracy of angle() for very small angles // and when real part is slightly greater than 1. // { T t = 10 * std::sqrt (s); Quat q; q.setAxisAngle (Vec3 (0, 0, 1), t); Vec3 v = q.axis(); T a = q.angle(); assert (v.equalWithAbsError (Vec3 (0, 0, 1), e)); assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e)); q.r *= 1.1; q.v *= 1.1; v = q.axis(); a = q.angle(); assert (v.equalWithAbsError (Vec3 (0, 0, 1), e)); assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e)); } { T t = 0.001 * std::sqrt (s); Quat q; q.setAxisAngle (Vec3 (0, 0, 1), t); Vec3 v = q.axis(); T a = q.angle(); assert (v.equalWithAbsError (Vec3 (0, 0, 1), e)); assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e)); q.r *= 1.1; q.v *= 1.1; v = q.axis(); a = q.angle(); assert (v.equalWithAbsError (Vec3 (0, 0, 1), e)); assert (IMATH_INTERNAL_NAMESPACE::equal (a, t, t * e)); } // // toMatrix33(), toMatrix44() // { Quat q; q.setRotation (Vec3 (1, 0, 0), Vec3 (0, 1, 0)); Matrix33 m1 = q.toMatrix33(); // clang-format off assert (m1.equalWithAbsError (Matrix33 (0, 1, 0, -1, 0, 0, 0, 0, 1), e)); Matrix44 m2 = q.toMatrix44(); assert (m2.equalWithAbsError (Matrix44 (0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1), e)); // clang-format on } // // +, - (unary and binary), ~ *, /, ^ // assert (Quat (1, 2, 3, 4) + Quat (5, 6, 7, 8) == Quat (6, 8, 10, 12)); assert (Quat (-1, -2, -3, -4) - Quat (5, 6, 7, 8) == Quat (-6, -8, -10, -12)); assert (-Quat (1, 2, 3, 4) == Quat (-1, -2, -3, -4)); assert (~Quat (1, 2, 3, 4) == Quat (1, -2, -3, -4)); assert (T (2) * Quat (1, 2, 3, 4) == Quat (2, 4, 6, 8)); assert (Quat (1, 2, 3, 4) * T (2 )== Quat (2, 4, 6, 8)); assert (Quat (1, 0, 0, 1) * Quat (1, 1, 0, 0) == Quat (1, 1, 1, 1)); assert (Quat (1, 1, 0, 0) * Quat (1, 0, 0, 1) == Quat (1, 1, -1, 1)); assert (Quat (1, 0, 0, 1) / Quat (0.5, -0.5, 0, 0) == Quat (1, 1, 1, 1)); assert (Quat (2, 4, 6, 8) / T (2) == Quat (1, 2, 3, 4)); assert ((Quat (1, 2, 3, 4) ^ Quat (2, 2, 2, 2)) == 20); // // extract() // { Vec3 vFrom (1, 0, 0); Vec3 vTo (0, 1, 1); Matrix44 m1 = rotationMatrix (vFrom, vTo); Quat q = extractQuat (m1); ; Matrix44 m2 = q.toMatrix44(); assert (m2.equalWithAbsError (m1, 2 * e)); } } void testQuatConversions () { { Quatf q (1, V3f (2, 3, 4)); Quatd q1 = Quatd (q); assert (q1.r == 1 && q1.v == V3d (2, 3, 4)); } { Quatd q (1, V3d (2, 3, 4)); Quatf q1 = Quatf (q); assert (q1.r == 1 && q1.v == V3f (2, 3, 4)); } } } // namespace void testQuat () { cout << "Testing basic quaternion operations" << endl; testQuatT(); testQuatT(); testQuatConversions(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testQuat.h000066400000000000000000000001631417213455000172370ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testQuat(); Imath-3.1.4/src/ImathTest/testQuatSetRotation.cpp000066400000000000000000000102451417213455000217700ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include "testQuatSetRotation.h" using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { void testRotation (const V3f& from, const V3f& to) { // // Build a quaternion. // Quatf Q; Q.setRotation (from, to); M44f M = Q.toMatrix44(); // // Verify that the quaternion rotates vector from into vector to. // float e = 20 * std::numeric_limits::epsilon(); V3f fromM = from * M; V3f fromQ = from * Q; V3f t0 = to.normalized(); V3f fM0 = fromM.normalized(); V3f fQ0 = fromQ.normalized(); assert (t0.equalWithAbsError (fM0, e)); assert (t0.equalWithAbsError (fQ0, e)); // // Verify that the rotation axis is the cross product of from and to. // V3f f0 = from.normalized(); if (abs (f0 ^ t0) < 0.9) { V3f n0 = (from % to).normalized(); V3f n0M = n0 * M; assert (n0.equalWithAbsError (n0M, e)); } } void specificVectors() { cout << " exact 90-degree rotations" << endl; testRotation (V3f (1, 0, 0), V3f (0, 1, 0)); testRotation (V3f (1, 0, 0), V3f (0, 0, 1)); testRotation (V3f (0, 1, 0), V3f (1, 0, 0)); testRotation (V3f (0, 1, 0), V3f (0, 0, 1)); testRotation (V3f (0, 0, 1), V3f (1, 0, 0)); testRotation (V3f (0, 0, 1), V3f (0, 1, 0)); cout << " exact zero-degree rotations" << endl; testRotation (V3f (1, 0, 0), V3f (1, 0, 0)); testRotation (V3f (0, 1, 0), V3f (0, 1, 0)); testRotation (V3f (0, 0, 1), V3f (0, 0, 1)); testRotation (V3f (1, 2, 3), V3f (2, 4, 6)); cout << " exact 180-degree rotations" << endl; testRotation (V3f (1, 0, 0), V3f (-1, 0, 0)); testRotation (V3f (0, 1, 0), V3f (0, -1, 0)); testRotation (V3f (0, 0, 1), V3f (0, 0, -1)); testRotation (V3f (1, 2, 3), V3f (-2, -4, -6)); testRotation (V3f (1, 3, 2), V3f (-2, -6, -4)); testRotation (V3f (2, 1, 3), V3f (-4, -2, -6)); testRotation (V3f (3, 1, 2), V3f (-6, -2, -4)); testRotation (V3f (2, 3, 1), V3f (-4, -6, -2)); testRotation (V3f (3, 2, 1), V3f (-6, -4, -2)); cout << " other angles" << endl; testRotation (V3f (1, 2, 3), V3f (4, 5, 6)); testRotation (V3f (1, 2, 3), V3f (4, 6, 5)); testRotation (V3f (1, 2, 3), V3f (5, 4, 6)); testRotation (V3f (1, 2, 3), V3f (6, 4, 5)); testRotation (V3f (1, 2, 3), V3f (5, 6, 4)); testRotation (V3f (1, 2, 3), V3f (6, 5, 4)); testRotation (V3f (1, 2, 3), V3f (-4, -5, -6)); testRotation (V3f (1, 2, 3), V3f (-4, -6, -5)); testRotation (V3f (1, 2, 3), V3f (-5, -4, -6)); testRotation (V3f (1, 2, 3), V3f (-6, -4, -5)); testRotation (V3f (1, 2, 3), V3f (-5, -6, -4)); testRotation (V3f (1, 2, 3), V3f (-6, -5, -4)); } void randomVectors() { cout << " random from and to vectors" << endl; Rand48 rand (17); for (int i = 0; i < 500000; ++i) { V3f from = hollowSphereRand (rand) * rand.nextf (0.1, 10.0); V3f to = hollowSphereRand (rand) * rand.nextf (0.1, 10.0); testRotation (from, to); } } void nearlyEqualVectors() { cout << " nearly equal from and to vectors" << endl; Rand48 rand (19); float e = 100 * std::numeric_limits::epsilon(); for (int i = 0; i < 500000; ++i) { V3f from = hollowSphereRand (rand); V3f to = from + e * hollowSphereRand (rand); testRotation (from, to); } } void nearlyOppositeVectors() { cout << " nearly opposite from and to vectors" << endl; Rand48 rand (19); float e = 100 * std::numeric_limits::epsilon(); for (int i = 0; i < 500000; ++i) { V3f from = hollowSphereRand (rand); V3f to = -from + e * hollowSphereRand (rand); testRotation (from, to); } } } // namespace void testQuatSetRotation() { cout << "Testing quaternion rotations" << endl; specificVectors(); randomVectors(); nearlyEqualVectors(); nearlyOppositeVectors(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testQuatSetRotation.h000066400000000000000000000001761417213455000214370ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testQuatSetRotation(); Imath-3.1.4/src/ImathTest/testQuatSlerp.cpp000066400000000000000000000074151417213455000206070ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include "testQuatSlerp.h" using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { void compareQuats (const Quatf& q1, const Quatf& q2, float e) { assert (equalWithAbsError (q1.v.x, q2.v.x, e)); assert (equalWithAbsError (q1.v.y, q2.v.y, e)); assert (equalWithAbsError (q1.v.z, q2.v.z, e)); assert (equalWithAbsError (q1.r, q2.r, e)); } Quatd pow (const Quatd q, int n) { Quatd result; for (int i = 0; i < n; ++i) result *= q; return result; } void testSlerp (const Quatf q1, const Quatf q2, int m, int n) { // // For two quaternions, q1 and q2, and the identity quaternion, qi, // // slerp (q1, q2, f) == q1 * slerp (qi, q1.inverse() * q2, f); (1) // // In addition, for integers m and n, with m >= 0, n > 0, // // pow (slerp (qi, q3, m/n), n) == pow (q3, m) (2) // // This allows us to test if slerp (q1, q2, m/n) works correctly. // Thanks to Dan Piponi for pointing this out. // // Note that e2, our upper bound for the numerical error in (2) is // fairly large. The reason for this is that testSlerp() will be // called with m and n up to 16. Taking quaternions to the 16th // power amplifies any inaccuracies. // Quatf qi; Quatf q3 = q1.inverse() * q2; Quatf q1q2 = slerp (q1, q2, float (m) / float (n)); Quatf qiq3 = slerp (qi, q3, float (m) / float (n)); float e1 = 60 * std::numeric_limits::epsilon(); float e2 = 600 * std::numeric_limits::epsilon(); compareQuats (q1q2, q1 * qiq3, e1); compareQuats (pow (qiq3, n), pow (q3, m), e2); } void testSlerp (const Quatf q1, const Quatf q2) { const int n = 16; for (int m = 0; m <= n; ++m) testSlerp (q1, q2, m, n); } void specificRotations() { cout << " combinations of 90-degree rotations around x, y and z" << endl; for (int x1 = 0; x1 < 3; ++x1) { V3f axis1 (0, 0, 0); axis1[x1] = 1; for (int n1 = 0; n1 < 4; ++n1) { float angle1 = n1 * M_PI / 2; Quatf q1; q1.setAxisAngle (axis1, angle1); for (int x2 = 0; x2 < 3; ++x2) { V3f axis2 (0, 0, 0); axis2[x2] = 1; for (int n2 = 0; n2 < 4; ++n2) { float angle2 = n2 * M_PI / 2; Quatf q2; q2.setAxisAngle (axis2, angle2); testSlerp (q1, q2); testSlerp (-q1, -q2); if ((q1 ^ q2) < 0.99) { testSlerp (q1, -q2); testSlerp (-q1, q2); } } } } } } void randomRotations() { cout << " random rotations" << endl; Rand48 rand (53); for (int i = 0; i < 10000; ++i) { V3f axis1 = hollowSphereRand (rand); V3f axis2 = hollowSphereRand (rand); float angle1 = rand.nextf (0, M_PI); float angle2 = rand.nextf (0, M_PI); Quatf q1, q2; q1.setAxisAngle (axis1, angle1); q2.setAxisAngle (axis2, angle2); testSlerp (q1, q2); testSlerp (-q1, -q2); if ((q1 ^ q2) < 0.99) { testSlerp (q1, -q2); testSlerp (-q1, q2); } } } } // namespace void testQuatSlerp() { cout << "Testing quaternion spherical linear interpolation" << endl; specificRotations(); randomRotations(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testQuatSlerp.h000066400000000000000000000001701417213455000202430ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testQuatSlerp(); Imath-3.1.4/src/ImathTest/testRandom.cpp000066400000000000000000000123031417213455000200770ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include "testRandom.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using IMATH_INTERNAL_NAMESPACE::abs; namespace { void testErand48() { // // Our implementation of erand48(), nrand48(), etc. // assumes that sizeof (unsigned short) == 2. // assert (sizeof (unsigned short) == 2); // // starting with a given seed, erand48() and nrand48() // must generate the same sequence as the standard // Unix/Linux functions. // unsigned short state[3]; state[0] = 0; state[1] = 1; state[2] = 2; assert (abs (IMATH_INTERNAL_NAMESPACE::erand48 (state) - 0.671004) < 0.00001); assert (abs (IMATH_INTERNAL_NAMESPACE::erand48 (state) - 0.786905) < 0.00001); assert (abs (IMATH_INTERNAL_NAMESPACE::erand48 (state) - 0.316850) < 0.00001); assert (abs (IMATH_INTERNAL_NAMESPACE::erand48 (state) - 0.384870) < 0.00001); assert (abs (IMATH_INTERNAL_NAMESPACE::erand48 (state) - 0.854650) < 0.00001); assert (IMATH_INTERNAL_NAMESPACE::nrand48 (state) == 0x4f4e8cb0); assert (IMATH_INTERNAL_NAMESPACE::nrand48 (state) == 0x063e864b); assert (IMATH_INTERNAL_NAMESPACE::nrand48 (state) == 0x2d10f1dd); assert (IMATH_INTERNAL_NAMESPACE::nrand48 (state) == 0x1aadc122); assert (IMATH_INTERNAL_NAMESPACE::nrand48 (state) == 0x1836a71f); assert (state[0] == 0x2a42); assert (state[1] == 0x4e3e); assert (state[2] == 0x306d); } template void testGenerator() { // // Test if the values, and the differences between // successive values, are evenly distributed. // const int N = 10; const int M = 100000; int values[N + 1]; int diffs[2 * N + 3]; int* v = &values[0]; int* d = &diffs[N + 2]; for (int i = 0; i <= N; ++i) v[i] = 0; for (int i = -N; i <= N; ++i) d[i] = 0; Rand rand (0); float previous = 0; for (int i = 0; i < M * N; ++i) { float r = rand.nextf (0.0, 1.0); float diff = r - previous; previous = r; v[int (r * N)] += 1; d[IMATH_INTERNAL_NAMESPACE::floor (diff * N + 0.5)] += 1; } cout << " values" << endl; for (int i = 0; i < N; ++i) { // cout << setw (4) << i << ' ' << setw(6) << v[i] << ' '; assert (abs (v[i] - M) < 0.01 * M); // for (int j = 0; j < v[i] * 60 / M; ++j) // cout << '*'; // cout << endl; } assert (v[N] == 0); cout << " differences between successive values" << endl; for (int i = -N; i <= N; ++i) { // cout << setw (4) << i << ' ' << setw (6) << d[i] << ' '; assert (abs ((N - abs (i)) * M / N - d[i]) < 0.05 * M); // for (int j = 0; j < d[i] * 60 / M; ++j) // cout << '*'; // cout << endl; } cout << " range" << endl; double rMin = 1.0; double rMax = 0.0; for (int i = 0; i <= 10000000; ++i) { double r = rand.nextf (0.0, 1.0); if (rMin > r) rMin = r; if (rMax < r) rMax = r; } assert (rMin < 0.0001 && rMax > 0.9999); const double pow_2_60 = double (1073741824) * double (1073741824); for (int i = 0; i <= 10000000; ++i) { double r0 = rand.nextf (-2.0, 3.0); assert (r0 >= -2.0 && r0 <= 3.0); double r1 = rand.nextf (-pow_2_60, 1); assert (r1 >= -pow_2_60 && r1 <= 1); double r2 = rand.nextf (-1, pow_2_60); assert (r2 >= -1 && r2 <= pow_2_60); } } template void testSolidSphere() { const int N = 10; const int M = 10000; int v[N + 1]; for (int i = 0; i <= N; ++i) v[i] = 0; Rand rand (0); for (int i = 0; i < M * N; ++i) { IMATH_INTERNAL_NAMESPACE::V3f p = IMATH_INTERNAL_NAMESPACE::solidSphereRand (rand); float l = p.length(); v[IMATH_INTERNAL_NAMESPACE::floor (l * N)] += 1; assert (l < 1.00001); } for (int i = 0; i < N; ++i) assert (v[i] > 0); } template void testHollowSphere() { const int M = 100000; Rand rand (0); for (int i = 0; i < M; ++i) { IMATH_INTERNAL_NAMESPACE::V3f p = IMATH_INTERNAL_NAMESPACE::hollowSphereRand (rand); float l = p.length(); assert (abs (l - 1) < 0.00001); } } } // namespace void testRandom() { cout << "Testing random number generators" << endl; cout << "erand48(), nrand48()" << endl; testErand48(); cout << "Rand32" << endl; testGenerator(); cout << "Rand48" << endl; testGenerator(); cout << "solidSphereRand()" << endl; testSolidSphere(); cout << "hollowSphereRand()" << endl; testHollowSphere(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testRandom.h000066400000000000000000000001651417213455000175470ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testRandom(); Imath-3.1.4/src/ImathTest/testRoots.cpp000066400000000000000000000135301417213455000177700ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include #include "testRoots.h" using namespace std; void sort (int nx, double& x0, double& x1, double& x2) { if (nx == 2) { if (x0 > x1) swap (x0, x1); } if (nx == 3) { if (x0 > x1) swap (x0, x1); if (x1 > x2) swap (x1, x2); if (x0 > x1) swap (x0, x1); } } void sort (int nx, double x[]) { if (nx == 2) { if (x[0] > x[1]) swap (x[0], x[1]); } if (nx == 3) { if (x[0] > x[1]) swap (x[0], x[1]); if (x[1] > x[2]) swap (x[1], x[2]); if (x[0] > x[1]) swap (x[0], x[1]); } } void solve (double a, double b, double c, double d, // coefficients int nx, // number of expected solutions double x0, double x1, double x2) // expected solutions { cout << "coefficients: " << setw (3) << a << ' ' << setw (3) << b << ' ' << setw (3) << c << ' ' << setw (3) << d << ' '; // // Solve the equation a*x^3 + b*x^2 + c*x +d // double x[3]; int n = IMATH_INTERNAL_NAMESPACE::solveCubic (a, b, c, d, x); // // Sort the numerical solutions. // Sorte the expected solutions. // sort (nx, x0, x1, x2); sort (n, x); // // Compare the numerical and the expected solutions. // assert (n == nx); cout << " solutions: "; if (n == -1) cout << "[-inf, inf]"; if (n == 0) cout << "none"; const double e = 0.0000001; // maximum expected error for // the test cases listed below if (n >= 1) { cout << x[0]; assert (IMATH_INTERNAL_NAMESPACE::equal (x[0], x0, e)); } if (n >= 2) { cout << ' ' << x[1]; assert (IMATH_INTERNAL_NAMESPACE::equal (x[1], x1, e)); } if (n >= 3) { cout << ' ' << x[2]; assert (IMATH_INTERNAL_NAMESPACE::equal (x[2], x2, e)); } cout << endl; } void solve (double a, double b, double c, // coefficients int nx, // number of expected solutions double x0, double x1) // expected solutions { cout << "coefficients: " << setw (3) << a << ' ' << setw (3) << b << ' ' << setw (3) << c << ' '; // // Solve the equation a*x^2 + b*x^1 + c*x // double x[2] = { 0.0, 0.0 }; int n = IMATH_INTERNAL_NAMESPACE::solveQuadratic (a, b, c, x); // // Sort the numerical solutions. // Sort the expected solutions. // // Dummy variable for sort double x2 = 0; sort (nx, x0, x1, x2); sort (n, x); // // Compare the numerical and the expected solutions. // assert (n == nx); cout << " solutions: "; if (n == -1) cout << "[-inf, inf]"; if (n == 0) cout << "none"; const double e = 0.0000001; // maximum expected error for // the test cases listed below if (n >= 1) { cout << x[0]; assert (IMATH_INTERNAL_NAMESPACE::equal (x[0], x0, e)); } if (n >= 2) { cout << ' ' << x[1]; assert (IMATH_INTERNAL_NAMESPACE::equal (x[1], x1, e)); } cout << endl; } void testRoots() { cout << "Testing functions in ImathRoots.h" << endl; cout << endl << "solveCubic" << endl; // Solve cubiec equations // // coefficients number of expected solutions // | | // | | expected solutions // | | | // +-------+--------+ | +------+-----+ // | | | | | solve (1, 6, 11, 6, 3, -1, -2, -3); // real solutions: -1, -2, -3 solve (2, 2, -20, 16, 3, 1, -4, 2); // real solutions: 1, -4, 2 solve (3, -3, 1, -1, 1, 1, 0, 0); // real solutions: 1 solve (2, 0, -24, -32, 2, 4, -2, 0); // real solutions: 4, -2 solve (1, 0, 0, 0, 1, 0, 0, 0); // real solutions: 0 solve (8, -24, 24, -8, 1, 1, 0, 0); // real solutions: 1 solve (0, 2, -10, 12, 2, 2, 3, 0); // real solutions: 2, 3 solve (0, 1, -1, -20, 2, 5, -4, 0); // real solutions: 5, -4 solve (0, 3, -12, 12, 1, 2, 0, 0); // real solutions: 2 solve (0, 1, 0, 0, 1, 0, 0, 0); // real solutions: 0 solve (0, 1, 0, 1, 0, 0, 0, 0); // real solutions: none solve (0, 0, 3, -6, 1, 2, 0, 0); // real solutions: 2 solve (0, 0, 5, 15, 1, -3, 0, 0); // real solutions: -3 solve (0, 0, 1, 0, 1, 0, 0, 0); // real solutions: 0 solve (0, 0, 0, 1, 0, 0, 0, 0); // real solutions: none solve (0, 0, 0, 0, -1, 0, 0, 0); // real solutions: [-inf, inf] solve (36, -37, 0, 12, 1, -0.4715155, 0, 0); cout << endl << "solveQuadratic" << endl; // Solve quadratic equations // // coefficients number of expected solutions // | | // | | expected solutions // | | | // +-----+-----+ | +---+---+ // | | | | | solve (1, 3, 2, 2, -1, -2); // real solutions: -1, -2 solve (1, 0, -9, 2, -3, 3); // real solutions: -3, 3 solve (1, -4, 0, 2, 4, 0); // real solutions: 0, 4 solve (2, -4, 2, 1, 1, 0); // real solutions: 1 solve (0, -4, 8, 1, 2, 0); // real solutions: 2 solve (0, 7, 0, 1, 0, 0); // real solutions: 0 solve (10, 0, 0, 1, 0, 0); // real solutions: 0 solve (0, 0, 0, -1, 0, 0); // real solutions: [-inf, inf] solve (0, 0, 1, 0, 0, 0); // real solutions: none solve (3, -6, 30, 0, 0, 0); // real solutions: none cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testRoots.h000066400000000000000000000001641417213455000174340ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testRoots(); Imath-3.1.4/src/ImathTest/testShear.cpp000066400000000000000000000150551417213455000177300ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include "testShear.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; void testShear() { cout << "Testing functions in ImathShear.h" << endl; cout << "Imath::Shear6 constructors" << endl; const float epsilon = std::numeric_limits::epsilon(); IMATH_INTERNAL_NAMESPACE::Shear6f testConstructor1; IMATH_INTERNAL_NAMESPACE::Shear6f testConstructor2 (testConstructor1); testConstructor1 = testConstructor2; IMATH_INTERNAL_NAMESPACE::Shear6f testConstructor3 (52, 128, 254, 127, 12, -20); IMATH_INTERNAL_NAMESPACE::Shear6f A (testConstructor3); IMATH_INTERNAL_NAMESPACE::Shear6f B = A; IMATH_INTERNAL_NAMESPACE::Shear6f X, Y, tmp; assert (A == B); cout << "Imath::Shear6 * f" << endl; assert ((IMATH_INTERNAL_NAMESPACE::Shear6f (0.330f, 0.710f, 0.010f, 0.999f, -0.531f, -0.012f) * 0.999f) == IMATH_INTERNAL_NAMESPACE::Shear6f (0.330f * 0.999f, 0.710f * 0.999f, 0.010f * 0.999f, 0.999f * 0.999f, -0.531f * 0.999f, -0.012f * 0.999f)); cout << "Imath::Shear6 / f" << endl; assert ((IMATH_INTERNAL_NAMESPACE::Shear6f (0.330f, 0.710f, 0.010f, 0.999f, -0.531f, -0.012f) / 0.999f) == IMATH_INTERNAL_NAMESPACE::Shear6f (0.330f / 0.999f, 0.710f / 0.999f, 0.010f / 0.999f, 0.999f / 0.999f, -0.531f / 0.999f, -0.012f / 0.999f)); cout << "Assignment and comparison" << endl; B = A; assert (B == A); assert (!(B != A)); X = Y = IMATH_INTERNAL_NAMESPACE::Shear6f (0.123f, -0.420f, 0.501f, 0.998f, -0.231f, -0.034f); X *= 0.001f; assert (std::fabs ((Y.xy * 0.001f) - X.xy) <= epsilon && std::fabs ((Y.xz * 0.001f) - X.xz) <= epsilon && std::fabs ((Y.yz * 0.001f) - X.yz) <= epsilon && std::fabs ((Y.yx * 0.001f) - X.yx) <= epsilon && std::fabs ((Y.zx * 0.001f) - X.zx) <= epsilon && std::fabs ((Y.zy * 0.001f) - X.zy) <= epsilon); X = Y = IMATH_INTERNAL_NAMESPACE::Shear6f (0.123f, -0.420f, 0.501f, 0.998f, -0.231f, -0.034f); X /= -1.001f; assert (std::fabs ((Y.xy / -1.001f) - X.xy) <= epsilon && std::fabs ((Y.xz / -1.001f) - X.xz) <= epsilon && std::fabs ((Y.yz / -1.001f) - X.yz) <= epsilon && std::fabs ((Y.yx / -1.001f) - X.yx) <= epsilon && std::fabs ((Y.zx / -1.001f) - X.zx) <= epsilon && std::fabs ((Y.zy / -1.001f) - X.zy) <= epsilon); Y = IMATH_INTERNAL_NAMESPACE::Shear6f (0.998f, -0.001f, 0.501f, 1.001f, -0.231f, -0.034f); X = IMATH_INTERNAL_NAMESPACE::Shear6f (0.011f, -0.420f, -0.501f, 0.998f, -0.231f, -0.034f); tmp = X + Y; assert (std::fabs ((X.xy + Y.xy) - tmp.xy) <= epsilon && std::fabs ((X.xz + Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz + Y.yz) - tmp.yz) <= epsilon && std::fabs ((X.yx + Y.yx) - tmp.yx) <= epsilon && std::fabs ((X.zx + Y.zx) - tmp.zx) <= epsilon && std::fabs ((X.zy + Y.zy) - tmp.zy) <= epsilon); tmp = X - Y; assert (std::fabs ((X.xy - Y.xy) - tmp.xy) <= epsilon && std::fabs ((X.xz - Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz - Y.yz) - tmp.yz) <= epsilon && std::fabs ((X.yx - Y.yx) - tmp.yx) <= epsilon && std::fabs ((X.zx - Y.zx) - tmp.zx) <= epsilon && std::fabs ((X.zy - Y.zy) - tmp.zy) <= epsilon); tmp = X * Y; assert (std::fabs ((X.xy * Y.xy) - tmp.xy) <= epsilon && std::fabs ((X.xz * Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz * Y.yz) - tmp.yz) <= epsilon && std::fabs ((X.yx * Y.yx) - tmp.yx) <= epsilon && std::fabs ((X.zx * Y.zx) - tmp.zx) <= epsilon && std::fabs ((X.zy * Y.zy) - tmp.zy) <= epsilon); tmp = X / Y; // // epsilon doesn't work here. // assert (std::fabs ((X.xy / Y.xy) - tmp.xy) <= 1e-5f && std::fabs ((X.xz / Y.xz) - tmp.xz) <= 1e-5f && std::fabs ((X.yz / Y.yz) - tmp.yz) <= 1e-5f && std::fabs ((X.yx / Y.yx) - tmp.yx) <= 1e-5f && std::fabs ((X.zx / Y.zx) - tmp.zx) <= 1e-5f && std::fabs ((X.zy / Y.zy) - tmp.zy) <= 1e-5f); tmp = X; tmp += Y; assert (std::fabs ((X.xy + Y.xy) - tmp.xy) <= epsilon && std::fabs ((X.xz + Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz + Y.yz) - tmp.yz) <= epsilon && std::fabs ((X.yx + Y.yx) - tmp.yx) <= epsilon && std::fabs ((X.zx + Y.zx) - tmp.zx) <= epsilon && std::fabs ((X.zy + Y.zy) - tmp.zy) <= epsilon); tmp = X; tmp -= Y; assert (std::fabs ((X.xy - Y.xy) - tmp.xy) <= epsilon && std::fabs ((X.xz - Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz - Y.yz) - tmp.yz) <= epsilon && std::fabs ((X.yx - Y.yx) - tmp.yx) <= epsilon && std::fabs ((X.xz - Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz - Y.yz) - tmp.yz) <= epsilon); tmp = X; tmp *= Y; assert (std::fabs ((X.xy * Y.xy) - tmp.xy) <= epsilon && std::fabs ((X.xz * Y.xz) - tmp.xz) <= epsilon && std::fabs ((X.yz * Y.yz) - tmp.yz) <= epsilon && std::fabs ((X.yx * Y.yx) - tmp.yx) <= epsilon && std::fabs ((X.zx * Y.zx) - tmp.zx) <= epsilon && std::fabs ((X.zy * Y.zy) - tmp.zy) <= epsilon); tmp = X; tmp /= Y; // // epsilon doesn't work here. // assert (std::fabs ((X.xy / Y.xy) - tmp.xy) <= 1e-5f && std::fabs ((X.xz / Y.xz) - tmp.xz) <= 1e-5f && std::fabs ((X.yz / Y.yz) - tmp.yz) <= 1e-5f && std::fabs ((X.yx / Y.yx) - tmp.yx) <= 1e-5f && std::fabs ((X.zx / Y.zx) - tmp.zx) <= 1e-5f && std::fabs ((X.zy / Y.zy) - tmp.zy) <= 1e-5f); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testShear.h000066400000000000000000000001641417213455000173700ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testShear(); Imath-3.1.4/src/ImathTest/testSize.cpp000066400000000000000000000011251417213455000175710ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include "half.h" #include #include #include #include "testSize.h" using namespace std; void testSize() { cout << "size and alignment\n"; half h[2]; int size = sizeof (half); ptrdiff_t algn = (char*) &h[1] - (char*) &h[0]; cout << "sizeof (half) = " << size << endl; cout << "alignof (half) = " << (int) algn << endl; assert (size == 2 && algn == 2); cout << "ok\n\n" << flush; } Imath-3.1.4/src/ImathTest/testSize.h000066400000000000000000000001631417213455000172370ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testSize(); Imath-3.1.4/src/ImathTest/testTinySVD.cpp000066400000000000000000000314361417213455000201670ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include template void verifyOrthonormal (const IMATH_INTERNAL_NAMESPACE::Matrix33& A) { const T valueEps = T (100) * std::numeric_limits::epsilon(); const IMATH_INTERNAL_NAMESPACE::Matrix33 prod = A * A.transposed(); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) { if (i == j) assert (std::abs (prod[i][j] - 1) < valueEps); else assert (std::abs (prod[i][j]) < valueEps); } } } template void verifyOrthonormal (const IMATH_INTERNAL_NAMESPACE::Matrix44& A) { const T valueEps = T (100) * std::numeric_limits::epsilon(); const IMATH_INTERNAL_NAMESPACE::Matrix44 prod = A * A.transposed(); for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) { if (i == j) assert (std::abs (prod[i][j] - 1) <= valueEps); else assert (std::abs (prod[i][j]) <= valueEps); } } } template void verifyTinySVD_3x3 (const IMATH_INTERNAL_NAMESPACE::Matrix33& A) { T maxEntry = 0; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) maxEntry = std::max (maxEntry, std::abs (A[i][j])); const T eps = std::numeric_limits::epsilon(); const T valueEps = maxEntry * T (10) * eps; for (int i = 0; i < 2; ++i) { const bool posDet = (i == 0); IMATH_INTERNAL_NAMESPACE::Matrix33 U, V; IMATH_INTERNAL_NAMESPACE::Vec3 S; IMATH_INTERNAL_NAMESPACE::jacobiSVD (A, U, S, V, eps, posDet); IMATH_INTERNAL_NAMESPACE::Matrix33 S_times_Vt; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) S_times_Vt[i][j] = S[j] * V[i][j]; S_times_Vt.transpose(); // Verify that the product of the matrices is A: const IMATH_INTERNAL_NAMESPACE::Matrix33 product = U * S_times_Vt; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) assert (std::abs (product[i][j] - A[i][j]) <= valueEps); // Verify that U and V are orthogonal: if (posDet) { assert (U.determinant() > 0.9); assert (V.determinant() > 0.9); } // Verify that the singular values are sorted: for (int i = 0; i < 2; ++i) assert (S[i] >= S[i + 1]); // Verify that all the SVs except maybe the last one are positive: for (int i = 0; i < 2; ++i) assert (S[i] >= T (0)); if (!posDet) assert (S[2] >= T (0)); verifyOrthonormal (U); verifyOrthonormal (V); } } template void verifyTinySVD_4x4 (const IMATH_INTERNAL_NAMESPACE::Matrix44& A) { T maxEntry = 0; for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) maxEntry = std::max (maxEntry, std::abs (A[i][j])); const T eps = std::numeric_limits::epsilon(); const T valueEps = maxEntry * T (100) * eps; for (int i = 0; i < 2; ++i) { const bool posDet = (i == 0); IMATH_INTERNAL_NAMESPACE::Matrix44 U, V; IMATH_INTERNAL_NAMESPACE::Vec4 S; IMATH_INTERNAL_NAMESPACE::jacobiSVD (A, U, S, V, eps, posDet); IMATH_INTERNAL_NAMESPACE::Matrix44 S_times_Vt; for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) S_times_Vt[i][j] = S[j] * V[i][j]; S_times_Vt.transpose(); // Verify that the product of the matrices is A: const IMATH_INTERNAL_NAMESPACE::Matrix44 product = U * S_times_Vt; for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) assert (std::abs (product[i][j] - A[i][j]) <= valueEps); // Verify that U and V have positive determinant if requested: if (posDet) { assert (U.determinant() > 0.99); assert (V.determinant() > 0.99); } // Verify that the singular values are sorted: for (int i = 0; i < 3; ++i) assert (S[i] >= S[i + 1]); // Verify that all the SVs except maybe the last one are positive: for (int i = 0; i < 3; ++i) assert (S[i] >= T (0)); if (!posDet) assert (S[3] >= T (0)); verifyOrthonormal (U); verifyOrthonormal (V); } } template void testTinySVD_3x3 (const IMATH_INTERNAL_NAMESPACE::Matrix33& A) { std::cout << "Verifying SVD for [[" << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << "], " << "[" << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << "], " << "[" << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << "]]\n"; verifyTinySVD_3x3 (A); verifyTinySVD_3x3 (A.transposed()); // Try all different orderings of the columns of A: int cols[3] = { 0, 1, 2 }; do { IMATH_INTERNAL_NAMESPACE::Matrix33 B; for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) B[i][j] = A[i][cols[j]]; verifyTinySVD_3x3 (B); } while (std::next_permutation (cols, cols + 3)); } template void testTinySVD_3x3 (const T a, const T b, const T c, const T d, const T e, const T f, const T g, const T h, const T i) { const IMATH_INTERNAL_NAMESPACE::Matrix33 A (a, b, c, d, e, f, g, h, i); testTinySVD_3x3 (A); } template void testTinySVD_4x4 (const IMATH_INTERNAL_NAMESPACE::Matrix44& A) { std::cout << "Verifying SVD for [[" << A[0][0] << ", " << A[0][1] << ", " << A[0][2] << ", " << A[0][3] << "], " << "[" << A[1][0] << ", " << A[1][1] << ", " << A[1][2] << ", " << A[1][3] << "], " << "[" << A[2][0] << ", " << A[2][1] << ", " << A[2][2] << ", " << A[2][3] << "], " << "[" << A[3][0] << ", " << A[3][1] << ", " << A[3][2] << ", " << A[3][3] << "]]\n"; verifyTinySVD_4x4 (A); verifyTinySVD_4x4 (A.transposed()); // Try all different orderings of the columns of A: int cols[4] = { 0, 1, 2, 3 }; do { IMATH_INTERNAL_NAMESPACE::Matrix44 B; for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) B[i][j] = A[i][cols[j]]; verifyTinySVD_4x4 (B); } while (std::next_permutation (cols, cols + 4)); } template void testTinySVD_4x4 (const T a, const T b, const T c, const T d, const T e, const T f, const T g, const T h, const T i, const T j, const T k, const T l, const T m, const T n, const T o, const T p) { const IMATH_INTERNAL_NAMESPACE::Matrix44 A (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p); testTinySVD_4x4 (A); } template void testTinySVDImp() { // Try a bunch of 3x3 matrices: testTinySVD_3x3 (1, 0, 0, 0, 1, 0, 0, 0, 1); testTinySVD_3x3 (1, 0, 0, 0, -1, 0, 0, 0, 1); testTinySVD_3x3 (0, 0, 0, 0, 0, 0, 0, 0, 0); testTinySVD_3x3 (0, 0, 0, 0, 0, 0, 0, 0, 1); testTinySVD_3x3 (1, 0, 0, 0, 1, 0, 0, 0, 0); testTinySVD_3x3 (1, 0, 0, 0, 0, 0, 0, 0, 0); testTinySVD_3x3 (1, 0, 0, 1e-10, 0, 0, 0, 0, 0); testTinySVD_3x3 (1, 0, 0, 1e-10, 0, 0, 0, 0, 100000); testTinySVD_3x3 (1, 2, 3, 4, 5, 6, 7, 8, 9); testTinySVD_3x3 (1, 2, 3, 4, 5, 6, 7, 8, 9); testTinySVD_3x3 (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3 (100, 1e-5, 0), IMATH_INTERNAL_NAMESPACE::Vec3 (100, 1e-5, 0))); testTinySVD_3x3 (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3 (245, 20, 1), IMATH_INTERNAL_NAMESPACE::Vec3 (256, 300, 20))); testTinySVD_3x3 (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3 (245, 20, 1), IMATH_INTERNAL_NAMESPACE::Vec3 (245, 20, 1)) + outerProduct (IMATH_INTERNAL_NAMESPACE::Vec3 (1, 2, 3), IMATH_INTERNAL_NAMESPACE::Vec3 (1, 2, 3))); // Some problematic matrices from SVDTest: testTinySVD_3x3 (0.0023588321752040036, -0.0096558131480729038, 0.0010959850449366493, 0.0088671829608044754, 0.0016771794267033666, -0.0043081475729438235, 0.003976050440932701, 0.0019880497026345716, 0.0089576046614601966); testTinySVD_3x3 (2.3588321752040035e-09, -9.6558131480729038e-09, 1.0959850449366498e-09, 8.8671829608044748e-09, 1.6771794267033661e-09, -4.3081475729438225e-09, 3.9760504409327016e-09, 1.9880497026345722e-09, 8.9576046614601957e-09); testTinySVD_3x3 (-0.46673855799602715, 0.67466260360310948, 0.97646986796448998, -0.032460753747103721, 0.046584527749418278, 0.067431228641151142, -0.088885055229687815, 0.1280389179308779, 0.18532617511453064); testTinySVD_3x3 (1e-8, 0, 0, 0, 1e-8, 0, 0, 0, 1e-8); testTinySVD_3x3 (1, 0, 0, 0, .00036, 0, 1e-18, 0, .00018); testTinySVD_3x3 (1.3, 0, 0, 0, .0003, 0, 1e-17, 0, 0); testTinySVD_3x3 (1, 0, 0, 0, 1e-2, 0, 0, 0, 1e-2); testTinySVD_3x3 (1, 0, 0, 0, 1, 0, 0, 0, 0); testTinySVD_3x3 (1, 0, 0, 0, 1e-3, 0, 0, 0, 1e-6); testTinySVD_3x3 (0.59588638570136332, -0.79761234126107794, -1, 0.39194500425202045, 0.91763115383440363, -0.341818175044664, -0.45056075218951946, -0.71259057727425101, 0.47125008216720271); testTinySVD_3x3 (4.38805348e-09, -2.53189691e-09, -4.65678607e-09, -3.23000099e-10, 1.86370294e-10, 3.42781192e-10, -4.61572824e-09, 2.6632645e-09, 4.89840346e-09); // problematic 2x2 one for lapack on suse (see below), padded with 0's testTinySVD_3x3 (0, -1.00000003e-22, 0, 1.00000001e-07, 0, 0, 0, 0, 0); // problematic 2x2 one for lapack on suse (see below), padded with 0's and 1 testTinySVD_3x3 (0, -1.00000003e-22, 0, 1.00000001e-07, 0, 0, 0, 0, 1); // Now, 4x4 matrices: testTinySVD_4x4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); testTinySVD_4x4 (1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); testTinySVD_4x4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0); testTinySVD_4x4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); testTinySVD_4x4 (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); testTinySVD_4x4 (1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); testTinySVD_4x4 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); testTinySVD_4x4 (0, -1.00000003e-22, 0, 0, 00000001e-07, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); testTinySVD_4x4 (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4 (100, 1e-5, 0, 0), IMATH_INTERNAL_NAMESPACE::Vec4 (100, 1e-5, 0, 0))); testTinySVD_4x4 (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4 (245, 20, 1, 0.5), IMATH_INTERNAL_NAMESPACE::Vec4 (256, 300, 20, 10))); testTinySVD_4x4 (outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4 (245, 20, 1, 0.5), IMATH_INTERNAL_NAMESPACE::Vec4 (256, 300, 20, 10)) + outerProduct (IMATH_INTERNAL_NAMESPACE::Vec4 (30, 10, 10, 10), IMATH_INTERNAL_NAMESPACE::Vec4 (1, 2, 3, 3))); } void testTinySVD() { std::cout << "Testing TinySVD algorithms in single precision..." << std::endl; testTinySVDImp(); std::cout << "Testing TinySVD algorithms in double precision..." << std::endl; testTinySVDImp(); } Imath-3.1.4/src/ImathTest/testTinySVD.h000066400000000000000000000001661417213455000176300ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testTinySVD(); Imath-3.1.4/src/ImathTest/testToFloat.cpp000066400000000000000000000056701417213455000202400ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include using namespace std; // // This test uses the code that generates the toFLoat.h header to // validate the the tabel values are correct. // //--------------------------------------------------- // Interpret an unsigned short bit pattern as a half, // and convert that half to the corresponding float's // bit pattern. //--------------------------------------------------- unsigned int halfToFloat (unsigned short y) { int s = (y >> 15) & 0x00000001; int e = (y >> 10) & 0x0000001f; int m = y & 0x000003ff; if (e == 0) { if (m == 0) { // // Plus or minus zero // return s << 31; } else { // // Denormalized number -- renormalize it // while (!(m & 0x00000400)) { m <<= 1; e -= 1; } e += 1; m &= ~0x00000400; } } else if (e == 31) { if (m == 0) { // // Positive or negative infinity // return (s << 31) | 0x7f800000; } else { // // Nan -- preserve sign and significand bits // return (s << 31) | 0x7f800000 | (m << 13); } } // // Normalized number // e = e + (127 - 15); m = m << 13; // // Assemble s, e and m. // return (s << 31) | (e << 23) | m; } void testToFloat() { std::cout << "running testToFloat" << std::endl; constexpr int iMax = (1 << 16); // // for each 16-bit bit pattern... // for (unsigned int s = 0; s < iMax; s++) { half hs(half::FromBits, static_cast(s)); assert (hs.bits() == s); // // cast these bits to a float, using the cast-to-float // operator. // float f = float (hs); // = _toFloat[s] // // Cast that float back to a half. // half h = half (f); // // halfToFloat() above is what generated the _toFloat table. // The i value return is the integer bit pattern of the corresponding // float. // half::uif uif; uif.i = halfToFloat (s); // // Equality operators fail for inf and nan, so handle them // specially. // if (isnan (f)) { assert (h.isNan()); assert (isnan (uif.f)); } else if (isinf (f)) { assert (h.isInfinity()); assert (isinf (uif.f)); } else { assert (f == uif.f); } } std::cout << "ok" << std::endl; } Imath-3.1.4/src/ImathTest/testToFloat.h000066400000000000000000000001661417213455000177000ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testToFloat(); Imath-3.1.4/src/ImathTest/testVec.cpp000066400000000000000000000231221417213455000173750ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // #ifdef NDEBUG # undef NDEBUG #endif #include #include #include #include #include #include "testVec.h" // Include ImathForward *after* other headers to validate forward declarations #include using namespace std; using namespace IMATH_INTERNAL_NAMESPACE; namespace { template void testLength2T() { const T s = std::sqrt (std::numeric_limits::min()); const T e = 4 * std::numeric_limits::epsilon(); Vec2 v; v = Vec2 (0, 0); assert (v.length() == 0); assert (v.normalized().length() == 0); v = Vec2 (3, 4); assert (v.length() == 5); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (3000, 4000); assert (v.length() == 5000); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); T t = s * (1 << 4); v = Vec2 (t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (-t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * std::sqrt (2), t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); t = s / (1 << 4); v = Vec2 (t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (-t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * std::sqrt (2), t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); t = s / (1 << 20); v = Vec2 (t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec2 (-t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * std::sqrt (2), t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); } template void testLength3T() { const T s = std::sqrt (std::numeric_limits::min()); const T e = 4 * std::numeric_limits::epsilon(); Vec3 v; v = Vec3 (0, 0, 0); assert (v.length() == 0); assert (v.normalized().length() == 0); v = Vec3 (3, 4, 0); assert (v.length() == 5); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (3000, 4000, 0); assert (v.length() == 5000); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (1, -1, 1); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), 1 * std::sqrt (3), e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (1000, -1000, 1000); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), 1000 * std::sqrt (3), 1000 * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); T t = s * (1 << 4); v = Vec3 (t, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (0, t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (0, 0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (-t, -t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * std::sqrt (3), t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); t = s / (1 << 4); v = Vec3 (t, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (0, t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (0, 0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (-t, -t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * std::sqrt (3), t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); t = s / (1 << 20); v = Vec3 (t, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (0, t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (0, 0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec3 (-t, -t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * std::sqrt (3), t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); } template void testLength4T() { const T s = std::sqrt (std::numeric_limits::min()); const T e = 4 * std::numeric_limits::epsilon(); Vec4 v; v = Vec4 (0, 0, 0, 0); assert (v.length() == 0); assert (v.normalized().length() == 0); v = Vec4 (3, 4, 0, 0); assert (v.length() == 5); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (3000, 4000, 0, 0); assert (v.length() == 5000); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (1, -1, 1, 1); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), 2, e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (1000, -1000, 1000, 1000); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), 2000, 1000 * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); T t = s * (1 << 4); v = Vec4 (t, 0, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, t, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, 0, t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, 0, 0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (-t, -t, -t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * 2, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); t = s / (1 << 4); v = Vec4 (t, 0, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, t, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, 0, t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, 0, 0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (-t, -t, -t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * 2, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); t = s / (1 << 20); v = Vec4 (t, 0, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, t, 0, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, 0, t, 0); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (0, 0, 0, t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); v = Vec4 (-t, -t, -t, -t); assert (IMATH_INTERNAL_NAMESPACE::equal (v.length(), t * 2, t * e)); assert (IMATH_INTERNAL_NAMESPACE::equal (v.normalized().length(), 1, e)); } } // namespace void testVec() { cout << "Testing some basic vector operations" << endl; testLength2T(); testLength2T(); testLength3T(); testLength3T(); testLength4T(); testLength4T(); cout << "ok\n" << endl; } Imath-3.1.4/src/ImathTest/testVec.h000066400000000000000000000001621417213455000170410ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // void testVec(); Imath-3.1.4/src/python/000077500000000000000000000000001417213455000146735ustar00rootroot00000000000000Imath-3.1.4/src/python/CMakeLists.txt000066400000000000000000000223221417213455000174340ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. ####################################### ####################################### # This declares all the configuration variables visible # in cmake-gui or similar and the rest of the global # project setup # # Please look at this file to see what is configurable ####################################### ####################################### include(config/PyImathSetup.cmake) # we are building a python extension, so of course we depend on # python as well. Except we don't know which version... # cmake 3.14 can also search for numpy, but we only depend on 3.12 # in the rest of OpenEXR right now... # first make sure we find *some* python find_package(Python COMPONENTS Interpreter Development) if(NOT TARGET Python::Interpreter AND NOT TARGET Python::Python) message(WARNING "Unable to find any python interpreter or libraries, disabling PyImath") return() endif() # we don't need cmake_dependant_option here, because the file is # included only if -DPYTHON=ON option(USE_PYTHON2 "Whether to use Python 2.x or 3.x" OFF) # now determine which (or both), and compile for both if(USE_PYTHON2) find_package(Python2 COMPONENTS Interpreter Development) if(Python2_FOUND) message(STATUS "Found Python ${Python2_VERSION}") elseif(Python2::Python) message(WARNING "Found Python ${Python2_VERSION} development libraries, but no interpreter") elseif(Python2::Interpreter) message(WARNING "Found Python ${Python2_VERSION} interpreter, but no development libraries") else() message(WARNING "Unable to find Python2 interpreter or development libraries") endif() set(PY_MAJOR_VERSION ${Python2_VERSION_MAJOR}) set(Python_VERSION_MAJOR ${Python2_VERSION_MAJOR}) set(Python_VERSION_MINOR ${Python2_VERSION_MINOR}) set(Python_EXECUTABLE ${Python2_EXECUTABLE}) set(Python_SITEARCH ${Python2_SITEARCH}) else() find_package(Python3 COMPONENTS Interpreter Development) if(Python3_FOUND) message(STATUS "Found Python ${Python3_VERSION}") elseif(Python3::Python) message(WARNING "Found Python ${Python3_VERSION} development libraries, but no interpreter") elseif(Python3::Interpreter) message(WARNING "Found Python ${Python3_VERSION} interpreter, but no development libraries") else() message(WARNING "Unable to find Python3 interpreter or development libraries") endif() set(PY_MAJOR_VERSION ${Python3_VERSION_MAJOR}) set(Python_VERSION_MAJOR ${Python3_VERSION_MAJOR}) set(Python_VERSION_MINOR ${Python3_VERSION_MINOR}) set(Python_EXECUTABLE ${Python3_EXECUTABLE}) set(Python_SITEARCH ${Python3_SITEARCH}) endif() if (NOT Python2_FOUND AND NOT Python3_FOUND) message(WARNING "Disabling PyImath") return() endif() # Now that we know what versions of python we have, let's look # for our other dependency - boost. # Boost Python has some .. annoyances in that the python module # has version names attached to it function(PYIMATH_EXTRACT_REL_SITEARCH varname pyver pyexe pysitearch) if(PYIMATH_OVERRIDE_PYTHON_INSTALL_DIR) set(${varname} ${PYIMATH_OVERRIDE_PYTHON_INSTALL_DIR} CACHE STRING "Destination sub-folder (relative) for the python ${pyver} modules") message(STATUS "Will install to: ${PYIMATH_OVERRIDE_PYTHON_INSTALL_DIR}") else() get_filename_component(_exedir ${pyexe} DIRECTORY) # we do this such that cmake will canonicalize the slashes # so the directory search will work under windows and unix # consistently get_filename_component(_basedir ${pysitearch} DIRECTORY) get_filename_component(_basename ${pysitearch} NAME) set(_basedir "${_basedir}/${_basename}") string(FIND ${_basedir} ${_exedir} _findloc) string(LENGTH ${_exedir} _elen) while(_findloc EQUAL -1 AND _elen GREATER 0) get_filename_component(_nexedir ${_exedir} DIRECTORY) string(FIND ${_basedir} ${_nexedir} _findloc) if (_nexedir STREQUAL _exedir) message(WARNING "Unable to get parent directory for ${_exedir}, using absolute python site arch folder ${pysitearch}") set(_elen -1) break() else() set(_exedir ${_nexedir}) endif() string(LENGTH ${_exedir} _elen) endwhile() math(EXPR _elen "${_elen}+1") string(SUBSTRING ${_basedir} ${_elen} -1 _reldir) if(APPLE) # on macOS, set install path to user's python package directory # so that elevated privileges are not necessary execute_process( COMMAND "${pyexe}" -c "if True: import sysconfig print(sysconfig.get_path('platlib', 'posix_user'))" OUTPUT_VARIABLE _reldir OUTPUT_STRIP_TRAILING_WHITESPACE) endif() set(${varname} ${_reldir} CACHE STRING "Destination sub-folder (relative) for the python ${pyver} modules") message(STATUS "Will install to: ${_reldir}") endif() endfunction() set(PYIMATH_BOOST_PY_COMPONENT "python${Python_VERSION_MAJOR}${Python_VERSION_MINOR}") message(STATUS "Found Python${Python_VERSION_MAJOR} libraries: ${Python_VERSION_MAJOR}${Python_VERSION_MINOR}") # we can't just use the Python2_SITEARCH variable as that then will # ignore CMAKE_INSTALL_PREFIX. Could extract this to a function somewhere # if it is generally useful pyimath_extract_rel_sitearch(PyImath_Python${Python_VERSION_MAJOR}_SITEARCH_REL ${Python_VERSION_MAJOR} ${Python_EXECUTABLE} ${Python_SITEARCH}) # different flavors of O.S. have multiple versions of python # some of them have both. Then for boost, some versions of boost # have just a python component, some it's by major version (python2/python3) # and still others have maj/min (python27) # let's run a search and see what we get instead of making it # an explicit required. The older names are not portable, but # we'll do the best we can ### NB: We are turning this on globally by default as the boost ### generated cmake config files seem to be broken and they ### cross-wire python 2 with 3 in the same variables option(Boost_NO_BOOST_CMAKE "Disable boost-provided cmake config" ON) if(Boost_NO_BOOST_CMAKE) message(STATUS "Disabling boost-provided cmake config. If this causes problems, consider setting Boost_NO_BOOST_CMAKE variable to OFF") endif() find_package(Boost OPTIONAL_COMPONENTS python python${Python_VERSION_MAJOR} ${PYIMATH_BOOST_PY_COMPONENT}) set(_pyimath_have_perver_boost) if(PYIMATH_BOOST_PY_COMPONENT) string(TOUPPER ${PYIMATH_BOOST_PY_COMPONENT} PYIMATH_PY_UPPER) else() set(PYIMATH_BOOST_PY_COMPONENT python${Python_VERSION_MAJOR}x_NOTFOUND) set(PYIMATH_PY_UPPER PYTHON${Python_VERSION_MAJOR}X_NOTFOUND) endif() if(Boost_PYTHON${Python_VERSION_MAJOR}_FOUND OR Boost_${PYIMATH_PY_UPPER}_FOUND) set(_pyimath_have_perver_boost TRUE) if(NOT Boost_${PYIMATH_PY_UPPER}_FOUND) message(WARNING "Legacy Boost python${Python_VERSION_MAJOR} found, but does not include minor version, this is an old configuration and may not be portable") set(PYIMATH_BOOST_PY_COMPONENT python${Python_VERSION_MAJOR}) endif() endif() if(Boost_PYTHON_FOUND AND NOT _pyimath_have_perver_boost) # old boost case, I guess we just warn and assume it is python2 (likely) message(WARNING "Ambiguous boost python module found, assuming python ${Python_VERSION_MAJOR}. If you have a new boost library, try cleaning the cmake cache and reconfigure with -DBoost_NO_BOOST_CMAKE=ON") set(PYIMATH_BOOST_PY_COMPONENT python) # set it to a bogus string but not empty so later we don't test against a namespace only target # set(PYIMATH_BOOST_PY3_COMPONENT pythonIgnore) elseif(NOT _pyimath_have_perver_boost) message(WARNING "Unable to find boost::python library, disabling PyImath. If you believe this is wrong, check the cmake documentation and see if you need to set Boost_ROOT or Boost_NO_BOOST_CMAKE") return() else() if(TARGET Boost::${PYIMATH_BOOST_PY_COMPONENT}) message(STATUS "Found Python ${Python_VERSION_MAJOR} boost: Boost::${PYIMATH_BOOST_PY_COMPONENT}") elseif(Boost_PYTHON_FOUND OR Boost_${PYIMATH_PY_UPPER}_FOUND) message(WARNING "Found boost for python ${Python_VERSION_MAJOR}, but FindBoost did not create an import library. If you believe this is wrong, check the cmake documentation and see if you need to set Boost_ROOT or Boost_NO_BOOST_CMAKE") return() endif() endif() unset(PYIMATH_PY_UPPER) unset(_pyimath_have_perver_boost) # unfortunately, we can't use the boost numpy stuff, as that requires a # version of boost that is newer than is mandated by many active versions # of the VFX reference platform (numpy became active in 1.63 of boost). # rather than make this an "official" find package thing include(config/NumPyLocate.cmake) # utility function for the repeated boilerplate of defining # the libraries and/or python modules include(config/ModuleDefine.cmake) ########################## add_subdirectory(config) if(NOT BUILD_SHARED_LIBS) message(WARNING "Forcing python bindings to be built with dynamic libraries") endif() add_subdirectory( PyImath ) if(TARGET Python2::ImathNumPy OR TARGET Python3::ImathNumPy) add_subdirectory( PyImathNumpy ) endif() ########################## # Tests ########################## include(CTest) if(BUILD_TESTING) enable_testing() add_subdirectory( PyImathTest ) add_subdirectory( PyImathSpeedTest ) if(TARGET Python2::ImathNumPy OR TARGET Python3::ImathNumPy) add_subdirectory( PyImathNumpyTest ) endif() endif() Imath-3.1.4/src/python/PyImath.pc.in000066400000000000000000000007401417213455000172000ustar00rootroot00000000000000## ## SPDX-License-Identifier: BSD-3-Clause ## Copyright Contributors to the OpenEXR Project. ## prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ libsuffix=@LIB_SUFFIX_DASH@ Name: PyImath Description: Python bindings for the Imath libraries Version: @IMATH_VERSION@ Libs: -L${libdir} -lImath${libsuffix} -lPyImath@PYIMATH_LIB_PYTHONVER_ROOT@@Python_VERSION_MAJOR@_@Python_VERSION_MINOR@${libsuffix} Cflags: -I${includedir} -I${includedir}/Imath Imath-3.1.4/src/python/PyImath/000077500000000000000000000000001417213455000162465ustar00rootroot00000000000000Imath-3.1.4/src/python/PyImath/CMakeLists.txt000066400000000000000000000037551417213455000210200ustar00rootroot00000000000000# SPDX-License-Identifier: BSD-3-Clause # Copyright Contributors to the OpenEXR Project. pyimath_define_module(imath LIBNAME PyImath PRIV_EXPORT PYIMATH_BUILD CURDIR ${CMAKE_CURRENT_SOURCE_DIR} LIBSOURCE PyImath.cpp PyImathAutovectorize.cpp PyImathBox2Array.cpp PyImathBox3Array.cpp PyImathBox.cpp PyImathBufferProtocol.cpp PyImathColor3.cpp PyImathColor4.cpp PyImathEuler.cpp PyImathFixedArray.cpp PyImathFrustum.cpp PyImathLine.cpp PyImathMatrix22.cpp PyImathMatrix33.cpp PyImathMatrix44.cpp PyImathPlane.cpp PyImathQuat.cpp PyImathRandom.cpp PyImathShear.cpp PyImathStringArray.cpp PyImathStringTable.cpp PyImathTask.cpp PyImathUtil.cpp PyImathFixedVArray.cpp PyImathVec2fd.cpp PyImathVec2si.cpp PyImathVec3fd.cpp PyImathVec3siArray.cpp PyImathVec3si.cpp PyImathVec4fd.cpp PyImathVec4siArray.cpp PyImathVec4si.cpp MODSOURCE imathmodule.cpp PyImathFun.cpp PyImathBasicTypes.cpp HEADERS PyImath.h PyImathAPI.h PyImathAutovectorize.h PyImathBasicTypes.h PyImathBox.h PyImathBoxArrayImpl.h PyImathBufferProtocol.h PyImathColor.h PyImathColor3ArrayImpl.h PyImathColor4Array2DImpl.h PyImathColor4ArrayImpl.h PyImathDecorators.h PyImathEuler.h PyImathExport.h PyImathFixedArray.h PyImathFixedArray2D.h PyImathFixedArrayTraits.h PyImathFixedMatrix.h PyImathFixedVArray.h PyImathFrustum.h PyImathFun.h PyImathLine.h PyImathMathExc.h PyImathMatrix.h PyImathOperators.h PyImathPlane.h PyImathQuat.h PyImathQuatOperators.h PyImathRandom.h PyImathShear.h PyImathStringArray.h PyImathStringArrayRegister.h PyImathStringTable.h PyImathTask.h PyImathUtil.h PyImathVec.h PyImathVec2Impl.h PyImathVec3ArrayImpl.h PyImathVec3Impl.h PyImathVec4ArrayImpl.h PyImathVec4Impl.h PyImathVecOperators.h DEPENDENCIES Imath ) Imath-3.1.4/src/python/PyImath/PyImath.cpp000066400000000000000000000025651417213455000203350ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include "PyImath.h" #include "PyImathExport.h" namespace PyImath { template <> PYIMATH_EXPORT const char * BoolArray::name() { return "BoolArray"; } template <> PYIMATH_EXPORT const char * SignedCharArray::name() { return "SignedCharArray"; } template <> PYIMATH_EXPORT const char * UnsignedCharArray::name() { return "UnsignedCharArray"; } template <> PYIMATH_EXPORT const char * ShortArray::name() { return "ShortArray"; } template <> PYIMATH_EXPORT const char * UnsignedShortArray::name(){ return "UnsignedShortArray"; } template <> PYIMATH_EXPORT const char * IntArray::name() { return "IntArray"; } template <> PYIMATH_EXPORT const char * UnsignedIntArray::name() { return "UnsignedIntArray"; } template <> PYIMATH_EXPORT const char * FloatArray::name() { return "FloatArray"; } template <> PYIMATH_EXPORT const char * DoubleArray::name() { return "DoubleArray"; } template <> PYIMATH_EXPORT const char * VIntArray::name() { return "VIntArray"; } template <> PYIMATH_EXPORT const char * VFloatArray::name() { return "VFloatArray"; } template <> PYIMATH_EXPORT const char * VV2iArray::name() { return "VV2iArray"; } template <> PYIMATH_EXPORT const char * VV2fArray::name() { return "VV2fArray"; } } Imath-3.1.4/src/python/PyImath/PyImath.h000066400000000000000000000024461417213455000200000ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImath_h_ #define _PyImath_h_ #include #include #include #include "PyImathFixedArray.h" #include "PyImathFixedMatrix.h" #include "PyImathFixedArray2D.h" #include "PyImathFixedVArray.h" namespace PyImath { typedef FixedArray BoolArray; typedef FixedArray SignedCharArray; typedef FixedArray UnsignedCharArray; typedef FixedArray ShortArray; typedef FixedArray UnsignedShortArray; typedef FixedArray IntArray; typedef FixedArray UnsignedIntArray; typedef FixedArray FloatArray; typedef FixedArray DoubleArray; typedef FixedArray QuatfArray; typedef FixedArray QuatdArray; typedef FixedMatrix IntMatrix; typedef FixedMatrix FloatMatrix; typedef FixedMatrix DoubleMatrix; typedef FixedArray2D FloatArray2D; typedef FixedArray2D IntArray2D; typedef FixedArray2D DoubleArray2D; typedef FixedVArray VIntArray; typedef FixedVArray VFloatArray; typedef FixedVArray > VV2iArray; typedef FixedVArray > VV2fArray; } #endif Imath-3.1.4/src/python/PyImath/PyImathAPI.h000066400000000000000000000046201417213455000203260ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathAPI_h_ #define _PyImathAPI_h_ #include #if PY_MAJOR_VERSION >= 3 // Big changes in Python3 with regard to PyClass. Most of these functions // are gone so the equivalent functionality is done this way... #define PyClass_Check(object) \ PyObject_IsInstance (object, reinterpret_cast (&PyType_Type)) // Py_FindMethod is gone and so you must search for functions by searching // through an object's attributes. #define Py_FindMethod(methods, self, name) \ PyObject_GenericGetAttr(self, PyBytes_FromString(name)) // One of the biggest differences between 2&3 is use support for Unicode. // Working with strings at the C API level one has be careful that the // returned object will not be Unicode and thus need to be decoded before // being interpreted. These macros will return the PyBytes type of PyObject // pointer that replaces PyString. #define PyString_Check(str) PyBytes_Check(str) #define PyString_FromString(str) PyBytes_FromString(str) #define PyString_AsString(obj) PyBytes_AsString(obj) #define PyString_AsStringAndSize(obj, str, len) PyBytes_AsStringAndSize(obj, str, len) // Python3 interprets all integers as long types and has deprecated PyInt. #define PyInt_Check(x) PyLong_Check(x) #define PyInt_AsLong(x) PyLong_AsLong(x) #define PyInt_AS_LONG(x) PyLong_AsLong(x) #define PyInt_AsSsize_t(x) PyLong_AsSsize_t(x) #define PyInt_FromLong(x) PyLong_FromLong(x) // These flags are not present in Python3 and must be replaced with the // default set of flags so that OR'ing them together doesn't alter the // flags. #define Py_TPFLAGS_CHECKTYPES Py_TPFLAGS_DEFAULT #define Py_TPFLAGS_HAVE_RICHCOMPARE Py_TPFLAGS_DEFAULT // The __repr__ for a TypeObject will be encoded and needs to be // processed as a PyBytes object before it can be return as a string. #define PYUTIL_OBJECT_REPR(obj) PyObject_Str (PyObject_Repr (obj)) #else // Python2 code will need to access PyObject_Repr() via this macro so // that both 2&3 can compile without modification. #define PYUTIL_OBJECT_REPR(obj) PyObject_Repr (obj) #endif #endif // _PyImathAPI_h_ Imath-3.1.4/src/python/PyImath/PyImathAutovectorize.cpp000066400000000000000000000137341417213455000231210ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include "PyImathAutovectorize.h" namespace PyImath { namespace detail { // // cheek possible vectorizations to ensure correctness // // single argument should be ((false),(true)) // BOOST_STATIC_ASSERT(( size::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( size::type,0>::type>::type::value == 1 )); BOOST_STATIC_ASSERT(( at_c::type,0>::type,0>::type::value == false )); BOOST_STATIC_ASSERT(( size::type,1>::type>::type::value == 1 )); BOOST_STATIC_ASSERT(( at_c::type,1>::type,0>::type::value == true )); // // two argument should be ((false,false),(false,true),(true,false),(true,true)) // BOOST_STATIC_ASSERT(( size::type>::type::value == 4 )); BOOST_STATIC_ASSERT(( size::type,0>::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,0>::type,0>::type::value == false )); BOOST_STATIC_ASSERT(( at_c::type,0>::type,1>::type::value == false )); BOOST_STATIC_ASSERT(( size::type,1>::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,1>::type,0>::type::value == false )); BOOST_STATIC_ASSERT(( at_c::type,1>::type,1>::type::value == true )); BOOST_STATIC_ASSERT(( size::type,2>::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,2>::type,0>::type::value == true )); BOOST_STATIC_ASSERT(( at_c::type,2>::type,1>::type::value == false )); BOOST_STATIC_ASSERT(( size::type,3>::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,3>::type,0>::type::value == true )); BOOST_STATIC_ASSERT(( at_c::type,3>::type,1>::type::value == true )); BOOST_STATIC_ASSERT(( size::type>::type::value == 8 )); // // Check disallow_vectorization for given vectorizable flags // BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == true )); BOOST_STATIC_ASSERT(( disallow_vectorization >::apply >::type::value == false )); // // Check allowable_vectorizations, single argument not vectorizable, and two argument second argument vectorizable. // typedef allowable_vectorizations > AV1f; BOOST_STATIC_ASSERT(( size::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,0>::type::value == false )); BOOST_STATIC_ASSERT(( at_c::type,0>::type::value == true )); BOOST_STATIC_ASSERT(( size::type::value == 1 )); BOOST_STATIC_ASSERT(( size::type>::type::value == 1 )); BOOST_STATIC_ASSERT(( at_c::type,0>::type::value == false )); typedef allowable_vectorizations > AV2ft; BOOST_STATIC_ASSERT(( size::type::value == 2 )); BOOST_STATIC_ASSERT(( size::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,0>::type::value == false )); BOOST_STATIC_ASSERT(( at_c::type,1>::type::value == false )); BOOST_STATIC_ASSERT(( size::type>::type::value == 2 )); BOOST_STATIC_ASSERT(( at_c::type,0>::type::value == false )); BOOST_STATIC_ASSERT(( at_c::type,1>::type::value == true )); } // namespace detail } // namespace PyImath Imath-3.1.4/src/python/PyImath/PyImathAutovectorize.h000066400000000000000000003602041417213455000225630ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathAutovectorize_h_ #define _PyImathAutovectorize_h_ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "PyImathFixedArray.h" #include "PyImathTask.h" #include "PyImathUtil.h" namespace PyImath { struct op_with_precomputation {}; namespace detail { using boost::is_base_of; using boost::is_same; using boost::is_const; using boost::remove_const; using boost::remove_reference; using boost::function_traits; using boost::mpl::at; using boost::mpl::at_c; using boost::mpl::push_front; using boost::mpl::vector; using boost::mpl::push_back; using boost::mpl::transform; using boost::mpl::fold; using boost::mpl::_; using boost::mpl::_1; using boost::mpl::_2; using boost::mpl::long_; using boost::mpl::false_; using boost::mpl::true_; using boost::mpl::not_; using boost::mpl::or_; using boost::mpl::and_; using boost::mpl::size; using boost::mpl::remove_if; using boost::mpl::if_; using boost::mpl::for_each; struct null_precomputation { static void precompute(size_t len) { return; } }; template struct op_precompute { static void apply(size_t len) { if_, T, null_precomputation>::type::precompute(len); } }; template struct possible_vectorizations { typedef typename fold< typename possible_vectorizations::type, vector<>, push_back >,push_back<_2,true_> > >::type type; }; template <> struct possible_vectorizations<0> { typedef vector > type; }; template struct disallow_vectorization { template struct apply { // Valid = !Vectorize || Vectorizable typedef typename transform >::type DontVectorize; typedef typename transform >::type Valid; typedef typename not_ > >::type type; }; }; template struct allowable_vectorizations { typedef typename possible_vectorizations::value>::type possible; typedef typename remove_if >::type type; }; template bool any_masked(const T &value) { return false; }; template bool any_masked(const PyImath::FixedArray &value) { return value.isMaskedReference(); }; template bool any_masked(const T1 &a, const T2 &b) { return any_masked(a) || any_masked(b); } template bool any_masked(const T1 &a, const T2 &b, const T3 &c) { return any_masked(a,b) || any_masked(c); } template bool any_masked(const T1 &a, const T2 &b, const T3 &c, const T4 &d) { return any_masked(a,b) || any_masked(c,d); } //----------------------------------------------------------------------------------------- // // measure_argument returns a pair indicating the integral length of the argument // (scalar arguments have implicit length 1), and a bool indicating whether the argument // is a vectorized argument. // template struct measure_argument { static inline std::pair apply(T arg) { return std::make_pair(1,false); } }; template struct measure_argument > { static inline std::pair apply(const PyImath::FixedArray &arg) { return std::make_pair(arg.len(),true); } }; // // match_lengths returns the compatible length given two argument lengths // static inline std::pair match_lengths(const std::pair &len1, const std::pair &len2) { // scalar arguemnts are always compatible with other arguments if (len1.second == false) return len2; if (len2.second == false) return len1; // now both arguments are vectorized, check for dimension match if (len1.first != len2.first) throw std::invalid_argument("Array dimensions passed into function do not match"); return len1; } // // measure_arguments finds the length that a return value from a given // set of arguments should have, throwing an exception if the lengths // are incompatible. If all arguments are scalar, length 1 is returned. // template size_t measure_arguments(const arg1_type &arg1) { std::pair len = measure_argument::apply(arg1); return len.first; } template size_t measure_arguments(const arg1_type &arg1, const arg2_type &arg2) { std::pair len = measure_argument::apply(arg1); len = match_lengths(len,measure_argument::apply(arg2)); return len.first; } template size_t measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3) { std::pair len = measure_argument::apply(arg1); len = match_lengths(len,measure_argument::apply(arg2)); len = match_lengths(len,measure_argument::apply(arg3)); return len.first; } template size_t measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3, const arg4_type &arg4) { std::pair len = measure_argument::apply(arg1); len = match_lengths(len,measure_argument::apply(arg2)); len = match_lengths(len,measure_argument::apply(arg3)); len = match_lengths(len,measure_argument::apply(arg4)); return len.first; } template size_t measure_arguments(const arg1_type &arg1, const arg2_type &arg2, const arg3_type &arg3, const arg4_type &arg4, const arg5_type &arg5) { std::pair len = measure_argument::apply(arg1); len = match_lengths(len,measure_argument::apply(arg2)); len = match_lengths(len,measure_argument::apply(arg3)); len = match_lengths(len,measure_argument::apply(arg4)); len = match_lengths(len,measure_argument::apply(arg5)); return len.first; } //----------------------------------------------------------------------------------------- template struct create_uninitalized_return_value { static T apply(size_t length) { return T(); } }; template struct create_uninitalized_return_value > { static PyImath::FixedArray apply(size_t length) { return PyImath::FixedArray(Py_ssize_t(length),PyImath::UNINITIALIZED); } }; template struct vectorized_result_type { typedef typename if_,T>::type type; }; template struct SimpleNonArrayWrapper { struct ReadOnlyDirectAccess { ReadOnlyDirectAccess (const T& arg) : _arg (arg) {} ReadOnlyDirectAccess (const ReadOnlyDirectAccess& other) : _arg (other._arg) {} const T& operator[] (size_t) const { return _arg; } private: const T& _arg; }; struct WritableDirectAccess : public ReadOnlyDirectAccess { WritableDirectAccess (T& arg) : ReadOnlyDirectAccess (arg), _arg (arg) {} WritableDirectAccess (const WritableDirectAccess& other) : ReadOnlyDirectAccess (other), _arg (other._arg) {} T& operator[] (size_t) { return _arg; } private: T& _arg; }; typedef ReadOnlyDirectAccess ReadOnlyMaskedAccess; typedef WritableDirectAccess WritableMaskedAccess; }; template struct access_type { typedef typename remove_reference::type prim_type; typedef typename remove_const::type base_type; typedef typename if_, const PyImath::FixedArray &, PyImath::FixedArray &>::type reference_type; typedef typename remove_reference::type class_type; typedef typename if_, typename class_type::ReadOnlyMaskedAccess, typename class_type::WritableMaskedAccess>::type masked; typedef typename if_, typename class_type::ReadOnlyDirectAccess, typename class_type::WritableDirectAccess>::type direct; }; template struct argument_access_type { typedef typename remove_const::type>::type base_type; typedef typename if_ &,T>::type type; typedef typename if_::type, SimpleNonArrayWrapper >::type _class_type; typedef typename _class_type::ReadOnlyMaskedAccess masked; typedef typename _class_type::ReadOnlyDirectAccess direct; }; template struct result_access_type { typedef typename remove_const::type>::type base_type; typedef typename if_,T>::type type; typedef typename if_ >::type _class_type; typedef typename _class_type::WritableMaskedAccess masked; typedef typename _class_type::WritableDirectAccess direct; }; template AccessType getArrayAccess (T& value) { return AccessType (value); } template AccessType getArrayAccess (const PyImath::FixedArray& array) { return AccessType (array); } template AccessType getArrayAccess (PyImath::FixedArray& array) { return AccessType (array); } // template struct VectorizedOperation1 : public Task { result_access_type retAccess; access_type access; VectorizedOperation1 (result_access_type r, access_type a1) : retAccess (r), access (a1) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { retAccess[i] = Op::apply (access[i]); } } }; template struct VectorizedOperation2 : public Task { result_access_type retAccess; access_type access; arg1_access_type argAccess; VectorizedOperation2(result_access_type r, access_type a1, arg1_access_type a2) : retAccess (r), access (a1), argAccess (a2) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { retAccess[i] = Op::apply (access[i], argAccess[i]); } } }; template struct VectorizedOperation3 : public Task { result_access_type retAccess; access_type access; arg1_access_type arg1Access; arg2_access_type arg2Access; VectorizedOperation3(result_access_type r, access_type a, arg1_access_type a1, arg2_access_type a2) : retAccess(r), access(a), arg1Access(a1), arg2Access(a2) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i]); } } }; template struct VectorizedOperation4 : public Task { result_access_type retAccess; access_type access; arg1_access_type arg1Access; arg2_access_type arg2Access; arg3_access_type arg3Access; VectorizedOperation4(result_access_type r, access_type a, arg1_access_type a1, arg2_access_type a2, arg3_access_type a3) : retAccess(r), access(a), arg1Access(a1), arg2Access(a2), arg3Access(a3) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i], arg3Access[i]); } } }; template struct VectorizedOperation5 : public Task { result_access_type retAccess; access_type access; arg1_access_type arg1Access; arg2_access_type arg2Access; arg3_access_type arg3Access; arg4_access_type arg4Access; VectorizedOperation5(result_access_type r, access_type a, arg1_access_type a1, arg2_access_type a2, arg3_access_type a3, arg4_access_type a4) : retAccess(r), access(a), arg1Access(a1), arg2Access(a2), arg3Access(a3), arg4Access(a4) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { retAccess[i] = Op::apply(access[i], arg1Access[i], arg2Access[i], arg3Access[i], arg4Access[i]); } } }; template struct VectorizedFunction1 { BOOST_STATIC_ASSERT((size::value == function_traits::arity)); typedef function_traits traits; typedef typename fold >::type any_vectorized; typedef typename result_access_type::type result_type; typedef typename result_access_type::direct result_access_type; // Result array is created here 'from scratch', so is always 'direct' access. typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; static result_type apply(arg1_type arg1) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(arg1); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type resultAccess = getArrayAccess (retval); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedOperation1 vop (resultAccess, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedOperation1 vop (resultAccess, argAccess); dispatchTask(vop,len); } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<1> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+") - "; } }; template struct VectorizedFunction2 { BOOST_STATIC_ASSERT((size::value == function_traits::arity)); typedef function_traits traits; typedef typename fold >::type any_vectorized; typedef typename result_access_type::type result_type; typedef typename result_access_type::direct result_access_type; // Result array is created here 'from scratch', so is always 'direct' access. typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; typedef typename argument_access_type >::type>::type arg2_type; typedef typename argument_access_type >::type>::direct arg2_direct_access_type; typedef typename argument_access_type >::type>::masked arg2_masked_access_type; static result_type apply(arg1_type arg1, arg2_type arg2) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(arg1,arg2); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type resultAccess = getArrayAccess (retval); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation2 vop (resultAccess, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation2 vop (resultAccess, arg1Access, arg2Access); dispatchTask(vop,len); } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation2 vop (resultAccess, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation2 vop (resultAccess, arg1Access, arg2Access); dispatchTask(vop,len); } } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<2> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - "; } }; template struct VectorizedFunction3 { BOOST_STATIC_ASSERT((size::value == function_traits::arity)); typedef function_traits traits; typedef typename fold >::type any_vectorized; typedef typename result_access_type::type result_type; typedef typename result_access_type::direct result_access_type; // Result array is created here 'from scratch', so is always 'direct' access. typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; typedef typename argument_access_type >::type>::type arg2_type; typedef typename argument_access_type >::type>::direct arg2_direct_access_type; typedef typename argument_access_type >::type>::masked arg2_masked_access_type; typedef typename argument_access_type >::type>::type arg3_type; typedef typename argument_access_type >::type>::direct arg3_direct_access_type; typedef typename argument_access_type >::type>::masked arg3_masked_access_type; static result_type apply(arg1_type arg1, arg2_type arg2, arg3_type arg3) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(arg1,arg2,arg3); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type resultAccess = getArrayAccess (retval); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); VectorizedOperation3 vop (resultAccess, arg1Access, arg2Access, arg3Access); dispatchTask(vop,len); } } } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<3> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+") - "; } }; template struct VectorizedFunction4 { BOOST_STATIC_ASSERT((size::value == function_traits::arity)); typedef function_traits traits; typedef typename fold >::type any_vectorized; typedef typename result_access_type::type result_type; typedef typename result_access_type::direct result_access_type; // Result array is created here 'from scratch', so is always 'direct' access. typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; typedef typename argument_access_type >::type>::type arg2_type; typedef typename argument_access_type >::type>::direct arg2_direct_access_type; typedef typename argument_access_type >::type>::masked arg2_masked_access_type; typedef typename argument_access_type >::type>::type arg3_type; typedef typename argument_access_type >::type>::direct arg3_direct_access_type; typedef typename argument_access_type >::type>::masked arg3_masked_access_type; typedef typename argument_access_type >::type>::type arg4_type; typedef typename argument_access_type >::type>::direct arg4_direct_access_type; typedef typename argument_access_type >::type>::masked arg4_masked_access_type; static result_type apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(arg1,arg2,arg3,arg4); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type resultAccess = getArrayAccess (retval); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); VectorizedOperation4 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access); dispatchTask(vop,len); } } } } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<4> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+","+args.elements[3].name+") - "; } }; template struct VectorizedFunction5 { BOOST_STATIC_ASSERT((size::value == function_traits::arity)); typedef function_traits traits; typedef typename fold >::type any_vectorized; typedef typename result_access_type::type result_type; typedef typename result_access_type::direct result_access_type; // Result array is created here 'from scratch', so is always 'direct' access. typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; typedef typename argument_access_type >::type>::type arg2_type; typedef typename argument_access_type >::type>::direct arg2_direct_access_type; typedef typename argument_access_type >::type>::masked arg2_masked_access_type; typedef typename argument_access_type >::type>::type arg3_type; typedef typename argument_access_type >::type>::direct arg3_direct_access_type; typedef typename argument_access_type >::type>::masked arg3_masked_access_type; typedef typename argument_access_type >::type>::type arg4_type; typedef typename argument_access_type >::type>::direct arg4_direct_access_type; typedef typename argument_access_type >::type>::masked arg4_masked_access_type; typedef typename argument_access_type >::type>::type arg5_type; typedef typename argument_access_type >::type>::direct arg5_direct_access_type; typedef typename argument_access_type >::type>::masked arg5_masked_access_type; static result_type apply(arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, arg5_type arg5) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(arg1,arg2,arg3,arg4,arg5); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type resultAccess = getArrayAccess (retval); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); if (any_masked(arg3)) { arg3_masked_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } else { arg3_direct_access_type arg3Access = getArrayAccess (arg3); if (any_masked(arg4)) { arg4_masked_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } else { arg4_direct_access_type arg4Access = getArrayAccess (arg4); if (any_masked(arg5)) { arg5_masked_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } else { arg5_direct_access_type arg5Access = getArrayAccess (arg5); VectorizedOperation5 vop (resultAccess, arg1Access, arg2Access, arg3Access, arg4Access, arg5Access); dispatchTask(vop,len); } } } } } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<5> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+","+args.elements[1].name+","+args.elements[2].name+","+args.elements[3].name+","+args.elements[4].name+") - "; } }; template struct function_binding { std::string _name, _doc; const Keywords &_args; function_binding(const std::string &name, const std::string &doc,const Keywords &args) : _name(name), _doc(doc), _args(args) {} template void operator()(Vectorize) const { typedef typename at, VectorizedFunction2, VectorizedFunction3, VectorizedFunction4, VectorizedFunction5 >, long_::arity> >::type vectorized_function_type; std::string doc = _name + vectorized_function_type::format_arguments(_args) + _doc; boost::python::def(_name.c_str(),&vectorized_function_type::apply,doc.c_str(),_args); } }; template function_binding build_function_binding(Func *func,const std::string &name,const std::string &doc,const Keywords &args) { return function_binding(name,doc,args); } template struct generate_bindings_struct { //BOOST_STATIC_ASSERT(size::value == function_traits::arity); static void apply(const std::string &name,const std::string &doc,const Keywords &args) { for_each::type>(build_function_binding(Op::apply,name,doc,args)); } }; template struct VectorizedVoidOperation0 : public Task { access_type access; VectorizedVoidOperation0 (access_type a) : access(a) {} void execute (size_t start, size_t end) { for (size_t i = start; i < end; ++i) { Op::apply (access[i]); } } }; template struct VectorizedVoidOperation1 : public Task { access_type access; arg1_access_type arg1; VectorizedVoidOperation1(access_type a, arg1_access_type a1) : access(a), arg1(a1) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { Op::apply (access[i], arg1[i]); } } }; template struct VectorizedMaskedVoidOperation1 : public Task { access_type access; arg1_access_type arg1; array_type array; VectorizedMaskedVoidOperation1(access_type a, arg1_access_type a1, array_type arr) : access(a), arg1(a1), array(arr) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { const size_t ri = array.raw_ptr_index(i); Op::apply (access[i], arg1[ri]); } } }; template struct VectorizedVoidOperation2 : public Task { access_type access; arg1_access_type arg1; arg2_access_type arg2; VectorizedVoidOperation2(access_type a, arg1_access_type a1, arg2_access_type a2) : access(a), arg1(a1), arg2(a2) {} void execute(size_t start, size_t end) { for (size_t i = start; i < end; ++i) { Op::apply (access[i], arg1[i], arg2[i]); } } }; template struct VectorizedVoidMemberFunction0 { BOOST_STATIC_ASSERT((size::value+1 == function_traits::arity)); typedef function_traits traits; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; static reference_type apply(reference_type array) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(array); op_precompute::apply(len); if (any_masked(array)) { masked_access_type access (array); VectorizedVoidOperation0 vop (access); dispatchTask(vop,len); } else { direct_access_type access (array); VectorizedVoidOperation0 vop (access); dispatchTask(vop,len); } PY_IMATH_RETURN_PYTHON; return array; } }; template struct VectorizedVoidMemberFunction1 { BOOST_STATIC_ASSERT((size::value+1 == function_traits::arity)); typedef function_traits traits; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; static reference_type apply(reference_type array, arg1_type arg1) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(array,arg1); op_precompute::apply(len); if (any_masked(array)) { masked_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } } else { direct_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } } PY_IMATH_RETURN_PYTHON; return array; } static std::string format_arguments(const boost::python::detail::keywords<1> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+") - "; } }; // // special class to handle single argument void memberfunctions, such as those // used for the inplace operators like +=, -=, etc. In this case we allow additional // compatibilty between a masked class and an unmasked right hand side, using the // mask to select results. // template struct VectorizedVoidMaskableMemberFunction1 { BOOST_STATIC_ASSERT((2 == function_traits::arity)); typedef function_traits traits; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; typedef typename argument_access_type::type arg1_type; typedef typename argument_access_type::direct arg1_direct_access_type; typedef typename argument_access_type::masked arg1_masked_access_type; static reference_type apply(reference_type array, arg1_type arg1) { PY_IMATH_LEAVE_PYTHON; size_t len = array.match_dimension(arg1, false); op_precompute::apply(len); if (array.isMaskedReference() && (size_t) arg1.len() == array.unmaskedLength()) { // class is masked, and the unmasked length matches the right hand side masked_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedMaskedVoidOperation1 vop (arrayAccess, argAccess, array); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedMaskedVoidOperation1 vop (arrayAccess, argAccess, array); dispatchTask(vop,len); } } else { // the two arrays match length (masked or otherwise), use the standard path. if (any_masked(array)) { masked_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } } else { direct_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedVoidOperation1 vop (arrayAccess, argAccess); dispatchTask(vop,len); } } } PY_IMATH_RETURN_PYTHON; return array; } static std::string format_arguments(const boost::python::detail::keywords<1> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+") - "; } }; template struct VectorizedVoidMemberFunction2 { BOOST_STATIC_ASSERT((size::value+1 == function_traits::arity)); typedef function_traits traits; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; typedef typename argument_access_type >::type>::type arg2_type; typedef typename argument_access_type >::type>::direct arg2_direct_access_type; typedef typename argument_access_type >::type>::masked arg2_masked_access_type; static reference_type apply(reference_type array, arg1_type arg1, arg2_type arg2) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(array,arg1,arg2); op_precompute::apply(len); if (any_masked(array)) { masked_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } } } else { direct_access_type arrayAccess (array); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedVoidOperation2 vop (arrayAccess, arg1Access, arg2Access); dispatchTask(vop,len); } } } PY_IMATH_RETURN_PYTHON; return array; } static std::string format_arguments(const boost::python::detail::keywords<2> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - "; } }; template struct VectorizedMemberFunction0 { BOOST_STATIC_ASSERT((size::value+1 == function_traits::arity)); typedef function_traits traits; typedef typename vectorized_result_type::type result_type; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; // The return value can't be const or masked. Verify that condition. BOOST_STATIC_ASSERT( !is_const::value ); typedef typename result_type::WritableDirectAccess result_access_type; static result_type apply(reference_type array) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(array); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type returnAccess (retval); if (any_masked(array)) { masked_access_type access (array); VectorizedOperation1 vop(returnAccess,access); dispatchTask(vop,len); } else { direct_access_type access (array); VectorizedOperation1 vop(returnAccess,access); dispatchTask(vop,len); } PY_IMATH_RETURN_PYTHON; return retval; } }; template struct VectorizedMemberFunction1 { BOOST_STATIC_ASSERT((size::value+1 == function_traits::arity)); typedef function_traits traits; typedef typename vectorized_result_type::type result_type; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; // The return value can't be const or masked. Verify that condition. BOOST_STATIC_ASSERT( !is_const::value ); typedef typename result_type::WritableDirectAccess result_access_type; static result_type apply(reference_type array, arg1_type arg1) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(array,arg1); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type returnAccess (retval); if (any_masked(array)) { masked_access_type access (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedOperation2 vop (returnAccess, access, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedOperation2 vop (returnAccess, access, argAccess); dispatchTask(vop,len); } } else { direct_access_type access (array); if (any_masked(arg1)) { arg1_masked_access_type argAccess = getArrayAccess (arg1); VectorizedOperation2 vop (returnAccess, access, argAccess); dispatchTask(vop,len); } else { arg1_direct_access_type argAccess = getArrayAccess (arg1); VectorizedOperation2 vop (returnAccess, access, argAccess); dispatchTask(vop,len); } } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<1> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+") - "; } }; template struct VectorizedMemberFunction2 { BOOST_STATIC_ASSERT((size::value+1 == function_traits::arity)); typedef function_traits traits; typedef typename vectorized_result_type::type result_type; typedef typename access_type::reference_type reference_type; typedef typename access_type::direct direct_access_type; typedef typename access_type::masked masked_access_type; typedef typename argument_access_type >::type>::type arg1_type; typedef typename argument_access_type >::type>::direct arg1_direct_access_type; typedef typename argument_access_type >::type>::masked arg1_masked_access_type; typedef typename argument_access_type >::type>::type arg2_type; typedef typename argument_access_type >::type>::direct arg2_direct_access_type; typedef typename argument_access_type >::type>::masked arg2_masked_access_type; // The return value can't be const or masked. Verify that condition. BOOST_STATIC_ASSERT( !is_const::value ); typedef typename result_type::WritableDirectAccess result_access_type; static result_type apply(reference_type array, arg1_type arg1, arg2_type arg2) { PY_IMATH_LEAVE_PYTHON; size_t len = measure_arguments(array,arg1,arg2); op_precompute::apply(len); result_type retval = create_uninitalized_return_value::apply(len); result_access_type returnAccess (retval); if (any_masked(array)) { masked_access_type access (array); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } } } else { direct_access_type access (array); if (any_masked(arg1)) { arg1_masked_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } } else { arg1_direct_access_type arg1Access = getArrayAccess (arg1); if (any_masked(arg2)) { arg2_masked_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } else { arg2_direct_access_type arg2Access = getArrayAccess (arg2); VectorizedOperation3 vop (returnAccess, access, arg1Access, arg2Access); dispatchTask(vop,len); } } } PY_IMATH_RETURN_PYTHON; return retval; } static std::string format_arguments(const boost::python::detail::keywords<2> &args) { // TODO: add types here return std::string("(")+args.elements[0].name+","+args.elements[1].name+") - "; } }; template struct member_function_binding { Cls &_cls; std::string _name, _doc; const Keywords &_args; member_function_binding(Cls &cls,const std::string &name, const std::string &doc,const Keywords &args) : _cls(cls), _name(name), _doc(doc), _args(args) {} template void operator()(Vectorize) const { typedef typename if_::result_type>, typename if_ >, VectorizedVoidMaskableMemberFunction1, VectorizedVoidMemberFunction1 >::type, VectorizedMemberFunction1 >::type member_func1_type; typedef typename if_::result_type>, VectorizedVoidMemberFunction2, VectorizedMemberFunction2 >::type member_func2_type; typedef typename if_::result_type>, boost::python::return_internal_reference<>, // the void vectorizations return a reference to self boost::python::default_call_policies>::type call_policies; typedef typename at, long_::arity> >::type vectorized_function_type; std::string doc = _name + vectorized_function_type::format_arguments(_args) + _doc; _cls.def(_name.c_str(),&vectorized_function_type::apply,doc.c_str(),_args,call_policies()); } }; template member_function_binding build_member_function_binding(Cls &cls,Func *func,const std::string &name,const std::string &doc,const Keywords &args) { return member_function_binding(cls,name,doc,args); } template struct generate_member_bindings_struct { //BOOST_STATIC_ASSERT(size::value+1 == function_traits::arity); static void apply(Cls &cls,const std::string &name,const std::string &doc,const Keywords &args) { for_each::type>(build_member_function_binding(cls,Op::apply,name,doc,args)); } }; template void generate_single_member_binding(Cls &cls,Func *func,const std::string &name,const std::string &doc) { typedef typename if_::result_type>, VectorizedVoidMemberFunction0,Func>, VectorizedMemberFunction0,Func> >::type vectorized_function_type; typedef typename if_::result_type>, boost::python::return_internal_reference<>, // the void vectorizations return a reference to self boost::python::default_call_policies>::type call_policies; cls.def(name.c_str(),&vectorized_function_type::apply,doc.c_str(),call_policies()); } } // namespace detail // TODO: update for arg("name")=default_value syntax template void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<1> &args) { using namespace detail; generate_bindings_struct,boost::python::detail::keywords<1> >::apply(name,doc,args); } template void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<2> &args) { using namespace detail; generate_bindings_struct,boost::python::detail::keywords<2> >::apply(name,doc,args); } template void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<3> &args) { using namespace detail; generate_bindings_struct,boost::python::detail::keywords<3> >::apply(name,doc,args); } template void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<4> &args) { using namespace detail; generate_bindings_struct,boost::python::detail::keywords<4> >::apply(name,doc,args); } template void generate_bindings(const std::string &name,const std::string &doc,const boost::python::detail::keywords<5> &args) { using namespace detail; generate_bindings_struct,boost::python::detail::keywords<5> >::apply(name,doc,args); } template void generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc) { using namespace detail; generate_single_member_binding(cls,&Op::apply,name,doc); } template void generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc, const boost::python::detail::keywords<1> &args) { using boost::mpl::vector; detail::generate_member_bindings_struct, boost::python::detail::keywords<1> >::apply(cls,name,doc,args); } template void generate_member_bindings(Cls &cls,const std::string &name,const std::string &doc, const boost::python::detail::keywords<2> &args) { using boost::mpl::vector; detail::generate_member_bindings_struct, boost::python::detail::keywords<2> >::apply(cls,name,doc,args); } } // namespace PyImath #endif // _PyImathAutovectorize_h_ Imath-3.1.4/src/python/PyImath/PyImathBasicTypes.cpp000066400000000000000000000072631417213455000223240ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include #include #include "PyImath.h" #include "PyImathExport.h" #include "PyImathBasicTypes.h" #include "PyImathFixedArray.h" #include "PyImathFixedVArray.h" #include "PyImathBufferProtocol.h" using namespace boost::python; namespace PyImath { void register_basicTypes() { class_ bclass = BoolArray::register_("Fixed length array of bool"); add_comparison_functions(bclass); class_ scclass = SignedCharArray::register_("Fixed length array of signed chars"); add_arithmetic_math_functions(scclass); add_mod_math_functions(scclass); add_comparison_functions(scclass); add_ordered_comparison_functions(scclass); class_ ucclass = UnsignedCharArray::register_("Fixed length array of unsigned chars"); add_arithmetic_math_functions(ucclass); add_mod_math_functions(ucclass); add_comparison_functions(ucclass); add_ordered_comparison_functions(ucclass); add_buffer_protocol(ucclass); class_ sclass = ShortArray::register_("Fixed length array of shorts"); add_arithmetic_math_functions(sclass); add_mod_math_functions(sclass); add_comparison_functions(sclass); add_ordered_comparison_functions(sclass); class_ usclass = UnsignedShortArray::register_("Fixed length array of unsigned shorts"); add_arithmetic_math_functions(usclass); add_mod_math_functions(usclass); add_comparison_functions(usclass); add_ordered_comparison_functions(usclass); class_ iclass = IntArray::register_("Fixed length array of ints"); add_arithmetic_math_functions(iclass); add_mod_math_functions(iclass); add_comparison_functions(iclass); add_ordered_comparison_functions(iclass); add_explicit_construction_from_type(iclass); add_explicit_construction_from_type(iclass); add_buffer_protocol(iclass); class_ uiclass = UnsignedIntArray::register_("Fixed length array of unsigned ints"); add_arithmetic_math_functions(uiclass); add_mod_math_functions(uiclass); add_comparison_functions(uiclass); add_ordered_comparison_functions(uiclass); add_explicit_construction_from_type(uiclass); add_explicit_construction_from_type(uiclass); class_ fclass = FloatArray::register_("Fixed length array of floats"); add_arithmetic_math_functions(fclass); add_pow_math_functions(fclass); add_comparison_functions(fclass); add_ordered_comparison_functions(fclass); add_explicit_construction_from_type(fclass); add_explicit_construction_from_type(fclass); add_buffer_protocol(fclass); class_ dclass = DoubleArray::register_("Fixed length array of doubles"); add_arithmetic_math_functions(dclass); add_pow_math_functions(dclass); add_comparison_functions(dclass); add_ordered_comparison_functions(dclass); add_explicit_construction_from_type(dclass); add_explicit_construction_from_type(dclass); add_buffer_protocol(dclass); class_ ivclass = VIntArray::register_("Variable fixed length array of ints"); class_ fvclass = VFloatArray::register_("Variable fixed length array of floats"); class_ v2ivclass = VV2iArray::register_("Variable fixed length array of V2i"); class_ v2fvclass = VV2fArray::register_("Variable fixed length array of V2f"); // Don't add other functionality until its defined better. } } // namespace PyImath Imath-3.1.4/src/python/PyImath/PyImathBasicTypes.h000066400000000000000000000004341417213455000217620ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathBasicTypes_h_ #define _PyImathBasicTypes_h_ #include "PyImathExport.h" namespace PyImath { PYIMATH_EXPORT void register_basicTypes(); } #endif Imath-3.1.4/src/python/PyImath/PyImathBox.cpp000066400000000000000000000400241417213455000207760ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include #include #include #include "PyImathBox.h" #include "PyImathVec.h" #include "PyImathMathExc.h" #include "PyImathDecorators.h" #include "PyImathExport.h" #include "PyImathTask.h" #include "PyImathBoxArrayImpl.h" namespace PyImath { using namespace boost::python; using namespace IMATH_NAMESPACE; using namespace PyImath; template struct BoxName { static const char *value; }; template <> const char *BoxName::value = "Box2s"; template <> const char *BoxName::value = "Box2i"; template <> const char *BoxName::value = "Box2i64"; template <> const char *BoxName::value = "Box2f"; template <> const char *BoxName::value = "Box2d"; template <> const char *BoxName::value = "Box3s"; template <> const char *BoxName::value = "Box3i"; template <> const char *BoxName::value = "Box3i64"; template <> const char *BoxName::value = "Box3f"; template <> const char *BoxName::value = "Box3d"; template <> PYIMATH_EXPORT const char *PyImath::Box2sArray::name() { return "Box2sArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box2iArray::name() { return "Box2iArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box2i64Array::name() { return "Box2i64Array"; } template <> PYIMATH_EXPORT const char *PyImath::Box2fArray::name() { return "Box2fArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box2dArray::name() { return "Box2dArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box3sArray::name() { return "Box3sArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box3iArray::name() { return "Box3iArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box3i64Array::name() { return "Box3i64Array"; } template <> PYIMATH_EXPORT const char *PyImath::Box3fArray::name() { return "Box3fArray"; } template <> PYIMATH_EXPORT const char *PyImath::Box3dArray::name() { return "Box3dArray"; } template static Box * box2TupleConstructor1(const tuple &t) { if(t.attr("__len__")() == 2) { // The constructor was called like this: // Box2f ((V2f(1,2), V2f(3,4))) or // Box2f (((1,2), (3,4))) PyObject *t0Obj = extract (t[0])().ptr(); PyObject *t1Obj = extract (t[1])().ptr(); T t0, t1; if (V2::convert (t0Obj, &t0) && V2::convert (t1Obj, &t1)) { return new Box (t0, t1); } // The constructor was called like this: // Box2f ((1,2)) else { T point; point.x = extract(t[0]); point.y = extract(t[1]); return new Box(point); } } else throw std::invalid_argument ( "Invalid input to Box tuple constructor"); } template static Box * box2TupleConstructor2(const tuple &t0, const tuple &t1) { if(t0.attr("__len__")() == 2 && t1.attr("__len__")() == 2) { T point0, point1; point0.x = extract(t0[0]); point0.y = extract(t0[1]); point1.x = extract(t1[0]); point1.y = extract(t1[1]); return new Box(point0, point1); } else throw std::invalid_argument ("Invalid input to Box tuple constructor"); } template static Box *boxConstructor(const Box &box) { Box *newBox = new Box; newBox->min = box.min; newBox->max = box.max; return newBox; } template static Box * box3TupleConstructor1(const tuple &t) { if(t.attr("__len__")() == 3) { // The constructor was called like this: // Box3f ((1,2,3)) T point; point.x = extract(t[0]); point.y = extract(t[1]); point.z = extract(t[2]); return new Box(point); } else if (t.attr("__len__")() == 2) { // The constructor was called like this: // Box3f ((V3f(1,2,3), V3f(4,5,6))) or // Box3f (((1,2,3), (4,5,6))) PyObject *t0Obj = extract (t[0])().ptr(); PyObject *t1Obj = extract (t[1])().ptr(); T t0, t1; if (V3::convert (t0Obj, &t0) && V3::convert (t1Obj, &t1)) { return new Box (t0, t1); } else throw std::invalid_argument ("Invalid input to Box tuple constructor"); } else throw std::invalid_argument ("Invalid input to Box tuple constructor"); } template static Box * box3TupleConstructor2(const tuple &t0, const tuple &t1) { if(t0.attr("__len__")() == 3 && t1.attr("__len__")() == 3) { T point0, point1; point0.x = extract(t0[0]); point0.y = extract(t0[1]); point0.z = extract(t0[2]); point1.x = extract(t1[0]); point1.y = extract(t1[1]); point1.z = extract(t1[2]); return new Box(point0, point1); } else throw std::invalid_argument ("Invalid input to Box tuple constructor"); } template static std::string Box_repr(const Box &box) { std::stringstream stream; typename boost::python::return_by_value::apply ::type converter; handle<> minObj (converter (box.min)); handle<> minH (PYUTIL_OBJECT_REPR (minObj.get())); std::string minReprStr = extract (minH.get()); handle<> maxObj (converter (box.max)); handle<> maxH (PYUTIL_OBJECT_REPR (maxObj.get())); std::string maxReprStr = extract (maxH.get()); stream << BoxName::value << "(" << minReprStr << ", " << maxReprStr << ")"; return stream.str(); } template static void boxSetMin(IMATH_NAMESPACE::Box &box, const T &m) { box.min = m; } template static void boxSetMax(IMATH_NAMESPACE::Box &box, const T &m) { box.max = m; } template static T boxMin(IMATH_NAMESPACE::Box &box) { return box.min; } template static T boxMax(IMATH_NAMESPACE::Box &box) { return box.max; } template struct IntersectsTask : public Task { const IMATH_NAMESPACE::Box& box; const PyImath::FixedArray& points; PyImath::FixedArray& results; IntersectsTask(IMATH_NAMESPACE::Box& b, const PyImath::FixedArray &p, PyImath::FixedArray &r) : box(b), points(p), results(r) {} void execute(size_t start, size_t end) { for(size_t p = start; p < end; ++p) results[p] = box.intersects(points[p]); } }; template struct ExtendByTask : public Task { std::vector >& boxes; const PyImath::FixedArray& points; ExtendByTask(std::vector >& b, const PyImath::FixedArray &p) : boxes(b), points(p) {} void execute(size_t start, size_t end, int tid) { for(size_t p = start; p < end; ++p) boxes[tid].extendBy(points[p]); } void execute(size_t start, size_t end) { throw std::invalid_argument ("Box::ExtendBy execute requires a thread id"); } }; template static void box_extendBy(IMATH_NAMESPACE::Box &box, const PyImath::FixedArray &points) { size_t numBoxes = workers(); std::vector > boxes(numBoxes); ExtendByTask task(boxes,points); dispatchTask(task,points.len()); for (size_t i=0; i PyImath::FixedArray box_intersects(IMATH_NAMESPACE::Box& box, const PyImath::FixedArray& points) { size_t numPoints = points.len(); PyImath::FixedArray mask(numPoints); IntersectsTask task(box,points,mask); dispatchTask(task,numPoints); return mask; } template class_ > register_Box2() { void (IMATH_NAMESPACE::Box::*extendBy1)(const T&) = &IMATH_NAMESPACE::Box::extendBy; void (IMATH_NAMESPACE::Box::*extendBy2)(const IMATH_NAMESPACE::Box&) = &IMATH_NAMESPACE::Box::extendBy; bool (IMATH_NAMESPACE::Box::*intersects1)(const T&) const = &IMATH_NAMESPACE::Box::intersects; bool (IMATH_NAMESPACE::Box::*intersects2)(const IMATH_NAMESPACE::Box&) const = &IMATH_NAMESPACE::Box::intersects; const char *name = BoxName::value; class_ > box_class(name); box_class .def(init<>("Box() create empty box") ) .def(init("Box(point)create box containing the given point") ) .def(init("Box(point,point) create box continaing min and max") ) .def("__init__", make_constructor(box2TupleConstructor1), "Box(point) where point is a python tuple") .def("__init__", make_constructor(box2TupleConstructor2), "Box(point,point) where point is a python tuple") .def("__init__", make_constructor(boxConstructor)) .def("__init__", make_constructor(boxConstructor)) .def("__init__", make_constructor(boxConstructor)) .def("__init__", make_constructor(boxConstructor)) .def_readwrite("min",&Box::min) .def_readwrite("max",&Box::max) .def("min", &boxMin) .def("max", &boxMax) .def(self == self) // NOSONAR - suppress SonarCloud bug report. .def(self != self) // NOSONAR - suppress SonarCloud bug report. .def("__repr__", &Box_repr) .def("makeEmpty",&Box::makeEmpty,"makeEmpty() make the box empty") .def("makeInfinite",&Box::makeInfinite,"makeInfinite() make the box cover all space") .def("extendBy",extendBy1,"extendBy(point) extend the box by a point") .def("extendBy",box_extendBy,"extendBy(array) extend the box the values in the array") .def("extendBy",extendBy2,"extendBy(box) extend the box by a box") .def("size",&Box::size,"size() size of the box") .def("center",&Box::center,"center() center of the box") .def("intersects",intersects1,"intersects(point) returns true if the box intersects the given point") .def("intersects",intersects2,"intersects(box) returns true if the box intersects the given box") .def("majorAxis",&Box::majorAxis,"majorAxis() major axis of the box") .def("isEmpty",&Box::isEmpty,"isEmpty() returns true if the box is empty") .def("isInfinite",&Box::isInfinite,"isInfinite() returns true if the box covers all space") .def("hasVolume",&Box::hasVolume,"hasVolume() returns true if the box has volume") .def("setMin",&boxSetMin,"setMin() sets the min value of the box") .def("setMax",&boxSetMax,"setMax() sets the max value of the box") ; return box_class; } template static IMATH_NAMESPACE::Box mulM44 (const IMATH_NAMESPACE::Box &b, const Matrix44 &m) { MATH_EXC_ON; return IMATH_NAMESPACE::transform (b, m); } template static const IMATH_NAMESPACE::Box & imulM44 (IMATH_NAMESPACE::Box &b, const Matrix44 &m) { MATH_EXC_ON; b = IMATH_NAMESPACE::transform (b, m); return b; } template class_ > register_Box3() { void (IMATH_NAMESPACE::Box::*extendBy1)(const T&) = &IMATH_NAMESPACE::Box::extendBy; void (IMATH_NAMESPACE::Box::*extendBy2)(const IMATH_NAMESPACE::Box&) = &IMATH_NAMESPACE::Box::extendBy; bool (IMATH_NAMESPACE::Box::*intersects1)(const T&) const = &IMATH_NAMESPACE::Box::intersects; bool (IMATH_NAMESPACE::Box::*intersects2)(const IMATH_NAMESPACE::Box&) const = &IMATH_NAMESPACE::Box::intersects; const char *name = BoxName::value; class_ > box_class(name); box_class .def(init<>("Box() create empty box") ) .def(init("Box(point)create box containing the given point") ) .def(init("Box(point,point) create box continaing min and max") ) .def("__init__", make_constructor(box3TupleConstructor1), "Box(point) where point is a python tuple") .def("__init__", make_constructor(box3TupleConstructor2), "Box(point,point) where point is a python tuple") .def("__init__", make_constructor(boxConstructor)) .def("__init__", make_constructor(boxConstructor)) .def("__init__", make_constructor(boxConstructor)) .def("__init__", make_constructor(boxConstructor)) .def_readwrite("min",&Box::min) .def_readwrite("max",&Box::max) .def(self == self) // NOSONAR - suppress SonarCloud bug report. .def(self != self) // NOSONAR - suppress SonarCloud bug report. .def("__mul__", &mulM44) .def("__mul__", &mulM44) .def("__imul__", &imulM44,return_internal_reference<>()) .def("__imul__", &imulM44,return_internal_reference<>()) .def("min", &boxMin) .def("max", &boxMax) .def("__repr__", &Box_repr) .def("makeEmpty",&Box::makeEmpty,"makeEmpty() make the box empty") .def("makeInfinite",&Box::makeInfinite,"makeInfinite() make the box cover all space") .def("extendBy",extendBy1,"extendBy(point) extend the box by a point") .def("extendBy",box_extendBy,"extendBy(array) extend the box the values in the array") .def("extendBy",extendBy2,"extendBy(box) extend the box by a box") .def("size",&Box::size,"size() size of the box") .def("center",&Box::center,"center() center of the box") .def("intersects",intersects1,"intersects(point) returns true if the box intersects the given point") .def("intersects",intersects2,"intersects(box) returns true if the box intersects the given box") .def("intersects",box_intersects, "intersects(array) returns an int array where 0 indicates the point is not in the box and 1 indicates that it is") .def("majorAxis",&Box::majorAxis,"majorAxis() major axis of the box") .def("isEmpty",&Box::isEmpty,"isEmpty() returns true if the box is empty") .def("isInfinite",&Box::isInfinite,"isInfinite() returns true if the box covers all space") .def("hasVolume",&Box::hasVolume,"hasVolume() returns true if the box has volume") .def("setMin",&boxSetMin,"setMin() sets the min value of the box") .def("setMax",&boxSetMax,"setMax() sets the max value of the box") ; decoratecopy(box_class); return box_class; } template PYIMATH_EXPORT class_ > register_Box2(); template PYIMATH_EXPORT class_ > register_Box2(); template PYIMATH_EXPORT class_ > register_Box2(); template PYIMATH_EXPORT class_ > register_Box2(); template PYIMATH_EXPORT class_ > register_Box2(); template PYIMATH_EXPORT class_ > register_Box3(); template PYIMATH_EXPORT class_ > register_Box3(); template PYIMATH_EXPORT class_ > register_Box3(); template PYIMATH_EXPORT class_ > register_Box3(); template PYIMATH_EXPORT class_ > register_Box3(); } Imath-3.1.4/src/python/PyImath/PyImathBox.h000066400000000000000000000140441417213455000204460ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathBox_h_ #define _PyImathBox_h_ #include #include #include #include "PyImathVec.h" #include "PyImathFixedArray.h" namespace PyImath { template boost::python::class_ > register_Box2(); template boost::python::class_ > register_Box3(); template boost::python::class_ > > register_BoxArray(); typedef FixedArray Box2sArray; typedef FixedArray Box2iArray; typedef FixedArray Box2i64Array; typedef FixedArray Box2fArray; typedef FixedArray Box2dArray; typedef FixedArray Box3sArray; typedef FixedArray Box3iArray; typedef FixedArray Box3i64Array; typedef FixedArray Box3fArray; typedef FixedArray Box3dArray; // // Other code in the Zeno code base assumes the existance of a class with the // same name as the Imath class, and with static functions wrap() and // convert() to produce a PyImath object from an Imath object and vice-versa, // respectively. The class Boost generates from the Imath class does not // have these properties, so we define a companion class here. // The template argument, T, is the element type for the box (e.g., int, // float). template class Box2 { public: static PyObject * wrap (const IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec2 > &b); static int convert (PyObject *p, IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec2 > *b); }; template class Box3 { public: static PyObject * wrap (const IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec3 > &b); static int convert (PyObject *p, IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec3 > *v); }; template PyObject * Box2::wrap (const IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec2 > &b) { typename boost::python::return_by_value::apply < IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec2 > >::type converter; PyObject *p = converter (b); return p; } template PyObject * Box3::wrap (const IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec3 > &b) { typename boost::python::return_by_value::apply < IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec3 > >::type converter; PyObject *p = converter (b); return p; } template int Box2::convert (PyObject *p, IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec2 > *v) { boost::python::extract < IMATH_NAMESPACE::Box > extractorV2i (p); if (extractorV2i.check()) { IMATH_NAMESPACE::Box b = extractorV2i(); v->min = b.min; v->max = b.max; return 1; } boost::python::extract < IMATH_NAMESPACE::Box > extractorV2f (p); if (extractorV2f.check()) { IMATH_NAMESPACE::Box b = extractorV2f(); v->min = b.min; v->max = b.max; return 1; } boost::python::extract < IMATH_NAMESPACE::Box > extractorV2d (p); if (extractorV2d.check()) { IMATH_NAMESPACE::Box b = extractorV2d(); v->min = b.min; v->max = b.max; return 1; } boost::python::extract extractorTuple (p); if (extractorTuple.check()) { boost::python::tuple t = extractorTuple(); if (t.attr ("__len__") () == 2) { PyObject *minObj = boost::python::extract (t[0])().ptr(); PyObject *maxObj = boost::python::extract (t[1])().ptr(); IMATH_NAMESPACE::Vec2 min, max; if (! V2::convert (minObj, &min)) return 0; if (! V2::convert (maxObj, &max)) return 0; v->min = min; v->max = max; return 1; } } return 0; } template int Box3::convert (PyObject *p, IMATH_NAMESPACE::Box< IMATH_NAMESPACE::Vec3 > *v) { boost::python::extract < IMATH_NAMESPACE::Box > extractorV3i (p); if (extractorV3i.check()) { IMATH_NAMESPACE::Box b = extractorV3i(); v->min = b.min; v->max = b.max; return 1; } boost::python::extract < IMATH_NAMESPACE::Box > extractorV3f (p); if (extractorV3f.check()) { IMATH_NAMESPACE::Box b = extractorV3f(); v->min = b.min; v->max = b.max; return 1; } boost::python::extract < IMATH_NAMESPACE::Box > extractorV3d (p); if (extractorV3d.check()) { IMATH_NAMESPACE::Box b = extractorV3d(); v->min = b.min; v->max = b.max; return 1; } boost::python::extract extractorTuple (p); if (extractorTuple.check()) { boost::python::tuple t = extractorTuple(); if (t.attr ("__len__") () == 2) { PyObject *minObj = boost::python::extract (t[0])().ptr(); PyObject *maxObj = boost::python::extract (t[1])().ptr(); IMATH_NAMESPACE::Vec3 min, max; if (! V3::convert (minObj, &min)) return 0; if (! V3::convert (maxObj, &max)) return 0; v->min = min; v->max = max; return 1; } } return 0; } typedef Box2 Box2i; typedef Box2 Box2i64; typedef Box2 Box2f; typedef Box2 Box2d; typedef Box3 Box3i; typedef Box3 Box3i64; typedef Box3 Box3f; typedef Box3 Box3d; } #endif Imath-3.1.4/src/python/PyImath/PyImathBox2Array.cpp000066400000000000000000000030531417213455000220600ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include "PyImathBoxArrayImpl.h" #include "PyImathExport.h" namespace PyImath { using namespace boost::python; template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2s PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box2s(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2i PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box2i(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2i64 PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box2i64(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2f PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box2f(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2d PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box2d(); } } Imath-3.1.4/src/python/PyImath/PyImathBox3Array.cpp000066400000000000000000000030531417213455000220610ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include "PyImathBoxArrayImpl.h" #include "PyImathExport.h" namespace PyImath { using namespace boost::python; template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template PYIMATH_EXPORT class_ > register_BoxArray(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box3s PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box3s(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box3i PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box3i(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box3i64 PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box3i64(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box3f PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box3f(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box3d PyImath::FixedArrayDefaultValue::value() { return IMATH_NAMESPACE::Box3d(); } } Imath-3.1.4/src/python/PyImath/PyImathBoxArrayImpl.h000066400000000000000000000043031417213455000222640ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathBoxArrayImpl_h_ #define _PyImathBoxArrayImpl_h_ // // This .C file was turned into a header file so that instantiations // of the various Box* types can be spread across multiple files in // order to work around MSVC limitations. // #include #include #include #include #include #include #include #include "PyImath.h" #include "PyImathBox.h" #include "PyImathDecorators.h" #include "PyImathMathExc.h" #include "PyImathOperators.h" #include "PyImathVecOperators.h" namespace PyImath { using namespace boost::python; using namespace IMATH_NAMESPACE; template static FixedArray BoxArray_get(FixedArray > &va) { return index == 0 ? FixedArray(&(va.unchecked_index(0).min), va.len(),2*va.stride(),va.handle(),va.writable()) : FixedArray(&(va.unchecked_index(0).max), va.len(),2*va.stride(),va.handle(),va.writable()); } template static void setItemTuple(FixedArray > &va, Py_ssize_t index, const tuple &t) { if(t.attr("__len__")() == 2) { Box v; v.min = extract(t[0]); v.max = extract(t[1]); va[(size_t)va.canonical_index(index)] = v; } else throw std::invalid_argument ("tuple of length 2 expected"); } template class_ > > register_BoxArray() { using boost::mpl::true_; using boost::mpl::false_; class_ > > boxArray_class = FixedArray >::register_("Fixed length array of IMATH_NAMESPACE::Box"); boxArray_class .add_property("min",&BoxArray_get) .add_property("max",&BoxArray_get) .def("__setitem__", &setItemTuple) ; add_comparison_functions(boxArray_class); decoratecopy(boxArray_class); return boxArray_class; } } // namespace PyImath #endif // _PyImathBoxArrayImpl_h_ Imath-3.1.4/src/python/PyImath/PyImathBufferProtocol.cpp000066400000000000000000000326241417213455000232100ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include #include "PyImathBufferProtocol.h" #include "PyImathExport.h" #include "PyImathFixedArray.h" #include "PyImathFixedArrayTraits.h" #include namespace PyImath { namespace { // A wrapper API for the buffer protocol functions to access and traverse // the memory of a FixedArray. // template class BufferAPI { using T = typename ArrayT::BaseType; static_assert (std::is_same >::value, "BufferAPI is only valid for FixedArray classes"); public: virtual ~BufferAPI() { delete[] shape; delete[] stride; } // The size, in bytes, of the smallest individual element of a buffer // element. For example, a V3fArray is a 2D array of 4-byte floats. Py_ssize_t atomicSize() const { return FixedArrayAtomicSize::value; } // NonCopyable BufferAPI (const BufferAPI &rhs) = delete; BufferAPI &operator= (const BufferAPI &rhs) = delete; // API virtual bool sharedBuffer() const = 0; virtual Py_ssize_t numBytes() const = 0; virtual bool readOnly() const = 0; virtual void * buffer() = 0; protected: BufferAPI (const unsigned int length, const unsigned int interleave) : dimensions (FixedArrayDimension::value), shape (new Py_ssize_t[dimensions]), stride (new Py_ssize_t[dimensions]) { shape[0] = Py_ssize_t (length); stride[0] = atomicSize() * FixedArrayWidth::value * interleave; for (unsigned int d=1; d::value * interleave; stride[d] = atomicSize(); } } public: // The number of dimensions in the data buffer (e.g. a one dimensional // FixedArray of V3fs would have a data buffer dimension of 2). int dimensions; Py_ssize_t *shape; Py_ssize_t *stride; }; // The SharedBuffer class is used for buffers that will be shared between // two different Python objects, and so the FixedArray is stored internally // as a reference. // template class SharedBufferAPI : public BufferAPI { public: using BufferAPI::atomicSize; explicit SharedBufferAPI (ArrayT &a) : BufferAPI (a.len(), a.stride()), _orig (a) {} // NonCopyable SharedBufferAPI (const SharedBufferAPI &rhs) = delete; SharedBufferAPI &operator= (const SharedBufferAPI &rhs) = delete; virtual ~SharedBufferAPI() = default; bool sharedBuffer() const override { return true; } Py_ssize_t numBytes() const override { return _orig.len() * atomicSize() * _orig.stride(); } bool readOnly() const override { return !_orig.writable(); } void *buffer() override { return static_cast (&_orig.direct_index(0)); } private: ArrayT &_orig; }; // This class exists for the case in which the Python array view // object is writable but the source FixedArray is not. // template class CopyBufferAPI : public BufferAPI { public: using BufferAPI::atomicSize; explicit CopyBufferAPI (ArrayT &a) : BufferAPI (a.len(), a.stride()), _copy (a) {} virtual ~CopyBufferAPI() = default; // NonCopyable CopyBufferAPI (const CopyBufferAPI &rhs) = delete; CopyBufferAPI &operator= (const CopyBufferAPI &rhs) = delete; bool sharedBuffer() const override { return false; } Py_ssize_t numBytes() const override { return _copy.len() * atomicSize() * _copy.stride(); } bool readOnly() const override { return false; } void *buffer() override { return static_cast (&_copy.direct_index(0)); } private: ArrayT _copy; }; template Py_ssize_t bufferInfo (ArrayT &array, void **buf) { *buf = static_cast (&array.direct_index(0)); return array.len() * sizeof(typename ArrayT::BaseType); } template Py_ssize_t getreadbuf (PyObject *obj, Py_ssize_t segment, void **buf) { if (segment != 0) { PyErr_SetString (PyExc_ValueError, "FixedArrays are not segmented"); return -1; } boost::python::extract eObj (obj); if (!eObj.check()) { PyErr_SetString (PyExc_ValueError, "Cannot extract FixedArray"); return -1; } ArrayT array = eObj(); return bufferInfo (array, buf); } template Py_ssize_t getwritebuf (PyObject *obj, Py_ssize_t segment, void **buf) { PyErr_SetString (PyExc_ValueError, "writable buffers supported only with new-style buffer protocol."); return -1; } template Py_ssize_t getsegcount (PyObject *obj, Py_ssize_t *lenp) { // FixedArrays are always in one, fixed-sized block return 1; } template Py_ssize_t getcharbuf (PyObject *obj, Py_ssize_t segment, const char **charBuf) { return getreadbuf (obj, segment, (void **)charBuf); } template void releasebuffer (PyObject *obj, Py_buffer *view) { delete static_cast *>(view->internal); } template int getbuffer (PyObject *obj, Py_buffer *view, int flags) { if (view == nullptr) { PyErr_SetString (PyExc_ValueError, "Buffer view is NULL"); return -1; } if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) { PyErr_SetString (PyExc_ValueError, "FORTRAN order not supported"); return -1; } boost::python::extract eObj (obj); if (!eObj.check()) { PyErr_SetString (PyExc_ValueError, "Cannot extract FixedArray"); return -1; } ArrayT array = eObj(); if (array.isMaskedReference()) { PyErr_SetString (PyExc_ValueError, "Buffer protocol does not support masked references"); return -1; } BufferAPI *api = nullptr; bool writableBuffer = ((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE); if (writableBuffer && !array.writable()) api = new CopyBufferAPI (array); else api = new SharedBufferAPI (array); view->internal = api; view->buf = api->buffer(); view->len = api->numBytes(); view->readonly = api->readOnly(); view->itemsize = api->atomicSize(); view->suboffsets = nullptr; view->format = ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) ? PyFormat() : nullptr; view->strides = ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) ? api->stride : nullptr; if ((flags & PyBUF_ND) == PyBUF_ND) { view->ndim = api->dimensions; view->shape = api->shape; } else { view->ndim = 0; view->shape = nullptr; } view->obj = obj; Py_INCREF (obj); return 0; } // This structure serves to instantiate a PyBufferProcs instance with pointers // to the right buffer protocol functions. template struct FixedArrayBufferProcs { static PyBufferProcs procs; }; template PyBufferProcs FixedArrayBufferProcs::procs = { #if PY_MAJOR_VERSION == 2 (readbufferproc) getreadbuf, (writebufferproc) getwritebuf, (segcountproc) getsegcount, (charbufferproc) getcharbuf, (getbufferproc) getbuffer, (releasebufferproc) releasebuffer #else // Note deprecation of support for the older style (getbufferproc) getbuffer, (releasebufferproc) releasebuffer #endif }; } // anonymous template void add_buffer_protocol (boost::python::class_ &classObj) { auto *typeObj = reinterpret_cast (classObj.ptr()); typeObj->tp_as_buffer = &FixedArrayBufferProcs::procs; #if PY_MAJOR_VERSION == 2 typeObj->tp_flags |= (Py_TPFLAGS_HAVE_NEWBUFFER | Py_TPFLAGS_HAVE_GETCHARBUFFER); #endif } template ArrayT * fixedArrayFromBuffer (PyObject *obj) { if (!PyObject_CheckBuffer (obj)) throw std::invalid_argument ("Python object does not support the buffer protocol"); // Request a strided buffer with type & dimensions. Py_buffer view; memset(&view, 0, sizeof(view)); if (PyObject_GetBuffer (obj, &view, PyBUF_FORMAT | PyBUF_STRIDES) != 0) { throw std::logic_error ("Failed to get dimensioned, typed buffer"); } // We have a buffer. Check that the type matches. if (!view.format || view.format[0] == '>' || view.format[0] == '!' || view.format[0] == '=' || view.format[0] == '^') { PyBuffer_Release(&view); throw std::invalid_argument ("Unsupported buffer type"); } ArrayT *array = new ArrayT (view.shape[0], PyImath::UNINITIALIZED); memcpy (&array->direct_index(0), view.buf, view.len); return array; } /////////////////////////////////////////////////////////////////////////////// template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT void add_buffer_protocol (boost::python::class_ > > &classObj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray >* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray* fixedArrayFromBuffer (PyObject *obj); template PYIMATH_EXPORT FixedArray* fixedArrayFromBuffer (PyObject *obj); } Imath-3.1.4/src/python/PyImath/PyImathBufferProtocol.h000066400000000000000000000010741417213455000226500ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathBufferProtocol_h_ #define _PyImathBufferProtocol_h_ #include namespace PyImath { // For more information on working with the protocol see: // // https://docs.python.org/2.7/c-api/buffer.html // https://docs.python.org/3.7.10/c-api/buffer.html template void add_buffer_protocol (boost::python::class_ &classObj); template ArrayT* fixedArrayFromBuffer (PyObject *obj); } #endif Imath-3.1.4/src/python/PyImath/PyImathColor.h000066400000000000000000000164441417213455000210020ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathColor3_h_ #define _PyImathColor3_h_ #include #include #include #include "PyImath.h" namespace PyImath { template boost::python::class_ > register_Color4(); template boost::python::class_ > > register_Color4Array2D(); template boost::python::class_ > > register_Color4Array(); template boost::python::class_, boost::python::bases > > register_Color3(); template boost::python::class_ > > register_Color3Array(); typedef FixedArray2D Color4fArray; typedef FixedArray2D Color4cArray; typedef FixedArray C4fArray; typedef FixedArray C4cArray; typedef FixedArray C3fArray; typedef FixedArray C3cArray; // // Other code in the Zeno code base assumes the existance of a class with the // same name as the Imath class, and with static functions wrap() and // convert() to produce a PyImath object from an Imath object and vice-versa, // respectively. The class Boost generates from the Imath class does not // have these properties, so we define a companion class here. // The template argument, T, is the element type for the color in C++ (e.g., char, // float). The other argument, U, is how this type is represented in Python // (e.g., int, float). template class C3 { public: static PyObject * wrap (const IMATH_NAMESPACE::Color3 &c); static int convert (PyObject *p, IMATH_NAMESPACE::Color3 *v); }; template class C4 { public: static PyObject * wrap (const IMATH_NAMESPACE::Color4 &c); static int convert (PyObject *p, IMATH_NAMESPACE::Color4 *v); }; template PyObject * C3::wrap (const IMATH_NAMESPACE::Color3 &c) { typename boost::python::return_by_value::apply < IMATH_NAMESPACE::Color3 >::type converter; PyObject *p = converter (c); return p; } template PyObject * C4::wrap (const IMATH_NAMESPACE::Color4 &c) { typename boost::python::return_by_value::apply < IMATH_NAMESPACE::Color4 >::type converter; PyObject *p = converter (c); return p; } template int C3::convert (PyObject *p, IMATH_NAMESPACE::Color3 *v) { boost::python::extract extractorC3c (p); if (extractorC3c.check()) { IMATH_NAMESPACE::C3c c3c = extractorC3c(); v->setValue (U(c3c[0]), U(c3c[1]), U(c3c[2])); return 1; } boost::python::extract extractorC3f (p); if (extractorC3f.check()) { IMATH_NAMESPACE::C3f c3f = extractorC3f(); v->setValue (U(c3f[0]), U(c3f[1]), U(c3f[2])); return 1; } boost::python::extract extractorTuple (p); if (extractorTuple.check()) { boost::python::tuple t = extractorTuple(); if (t.attr ("__len__") () == 3) { double a = boost::python::extract (t[0]); double b = boost::python::extract (t[1]); double c = boost::python::extract (t[2]); v->setValue (U(a), U(b), U(c)); return 1; } } boost::python::extract extractorList (p); if (extractorList.check()) { boost::python::list l = extractorList(); if (l.attr ("__len__") () == 3) { boost::python::extract extractor0 (l[0]); boost::python::extract extractor1 (l[1]); boost::python::extract extractor2 (l[2]); if (extractor0.check() && extractor1.check() && extractor2.check()) { v->setValue (U(extractor0()), U(extractor1()), U(extractor2())); return 1; } } } boost::python::extract extractorV3i (p); if (extractorV3i.check()) { IMATH_NAMESPACE::V3i v3i = extractorV3i(); v->setValue (U(v3i[0]), U(v3i[1]), U(v3i[2])); return 1; } boost::python::extract extractorV3f (p); if (extractorV3f.check()) { IMATH_NAMESPACE::V3f v3f = extractorV3f(); v->setValue (U(v3f[0]), U(v3f[1]), U(v3f[2])); return 1; } boost::python::extract extractorV3d (p); if (extractorV3d.check()) { IMATH_NAMESPACE::V3d v3d = extractorV3d(); v->setValue (U(v3d[0]), U(v3d[1]), U(v3d[2])); return 1; } return 0; } template int C4::convert (PyObject *p, IMATH_NAMESPACE::Color4 *v) { boost::python::extract extractorC4c (p); if (extractorC4c.check()) { IMATH_NAMESPACE::C4c c4c = extractorC4c(); v->setValue (U(c4c[0]), U(c4c[1]), U(c4c[2]), U(c4c[3])); return 1; } boost::python::extract extractorC4f (p); if (extractorC4f.check()) { IMATH_NAMESPACE::C4f c4f = extractorC4f(); v->setValue (U(c4f[0]), U(c4f[1]), U(c4f[2]), U(c4f[3])); return 1; } boost::python::extract extractorTuple (p); if (extractorTuple.check()) { boost::python::tuple t = extractorTuple(); if (t.attr ("__len__") () == 4) { // As with V3, we extract the tuple elements as doubles and // cast them to Ts in setValue(), to avoid any odd cases where // extracting them as Ts from the start would fail. double a = boost::python::extract (t[0]); double b = boost::python::extract (t[1]); double c = boost::python::extract (t[2]); double d = boost::python::extract (t[3]); v->setValue (U(a), U(b), U(c), U(d)); return 1; } } boost::python::extract extractorList (p); if (extractorList.check()) { boost::python::list l = extractorList(); if (l.attr ("__len__") () == 4) { boost::python::extract extractor0 (l[0]); boost::python::extract extractor1 (l[1]); boost::python::extract extractor2 (l[2]); boost::python::extract extractor3 (l[3]); if (extractor0.check() && extractor1.check() && extractor2.check() && extractor3.check()) { v->setValue (U(extractor0()), U(extractor1()), U(extractor2()), U(extractor3())); return 1; } } } return 0; } typedef C3 Color3f; typedef C3 Color3c; typedef Color3f C3f; typedef Color3c C3c; typedef C4 Color4f; typedef C4 Color4c; typedef Color4f C4f; typedef Color4c C4c; } #endif Imath-3.1.4/src/python/PyImath/PyImathColor3.cpp000066400000000000000000000426351417213455000214210ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off // // This .C file was turned into a header file so that instantiations // of the various V3* types can be spread across multiple files in // order to work around MSVC limitations. // #include #include #include #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathColor.h" #include "PyImathVec.h" #include "PyImathDecorators.h" #include "PyImathExport.h" #include "PyImathColor3ArrayImpl.h" namespace PyImath { template <> const char *PyImath::C3cArray::name() { return "C3cArray"; } template <> const char *PyImath::C3fArray::name() { return "C3fArray"; } using namespace boost::python; using namespace IMATH_NAMESPACE; template struct Color3Name { static const char *value; }; template<> const char *Color3Name::value = "Color3c"; template<> const char *Color3Name::value = "Color3f"; // create a new default constructor that initializes Color3 to zero. template static Color3 * Color3_construct_default() { return new Color3(T(0),T(0),T(0)); } template static Color3 * Color3_component_construct1(S x, S y, S z) { // Assigning a floating point value to an integer type can cause a // float-point error, which we want to translate into an exception. MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char r = (unsigned char) x; unsigned char g = (unsigned char) y; unsigned char b = (unsigned char) z; return new Color3(r,g,b); } else return new Color3(T (x), T(y), T(z)); } template static Color3 * Color3_component_construct2(S x) { MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char u = (unsigned char) x; return new Color3(u,u,u); } else return new Color3(T(x), T(x), T(x)); } template static Color3 * Color3_color_construct(const Color3 &c) { MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char r = (unsigned char) c.x; unsigned char g = (unsigned char) c.y; unsigned char b = (unsigned char) c.z; return new Color3(r,g,b); } else return new Color3(T (c.x), T(c.y), T(c.z)); } template static Color3 * Color3_vector_construct(const Vec3 &c) { MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char r = (unsigned char) c.x; unsigned char g = (unsigned char) c.y; unsigned char b = (unsigned char) c.z; return new Color3(r,g,b); } else return new Color3(T (c.x), T(c.y), T(c.z)); } template static std::string color3_str(const Color3 &v) { std::stringstream stream; if(strcmp(Color3Name::value, "Color3c") == 0) { int r = int(v.x); int g = int(v.y); int b = int(v.z); stream << Color3Name::value << "(" << r << ", " << g << ", " << b << ")"; return stream.str(); } else { stream << Color3Name::value << "(" << v.x << ", " << v.y << ", " << v.z << ")"; return stream.str(); } } // Non-specialized repr is same as str template static std::string color3_repr(const Color3 &v) { return color3_str(v); } // Specialization for float to full precision template <> std::string color3_repr(const Color3 &v) { return (boost::format("%s(%.9g, %.9g, %.9g)") % Color3Name::value % v.x % v.y % v.z).str(); } // No specialization for double, since we don't instantiate Color3d template static Color3 * Color3_construct_tuple(const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) { return new Color3(extract(t[0]), extract(t[1]), extract(t[2])); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 * Color3_construct_list(const list &l) { MATH_EXC_ON; if(l.attr("__len__")() == 3) { return new Color3(extract(l[0]), extract(l[1]), extract(l[2])); } else throw std::invalid_argument ("Color3 expects list of length 3"); } template static const Color3 & iadd(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color += color2; } template static Color3 add(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color + color2; } template static Color3 addTuple(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x + extract(t[0]), color.y + extract(t[1]), color.z + extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 addT(Color3 &v, T a) { MATH_EXC_ON; Color3 w(v.x + a, v.y + a, v.z + a); return w; } template static const Color3 & isub(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color -= color2; } template static Color3 sub(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color - color2; } template static Color3 subtractL(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x - extract(t[0]), color.y - extract(t[1]), color.z - extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 subtractLT(const Color3 &color, T a) { MATH_EXC_ON; return Color3(color.x - a, color.y - a, color.z - a); } template static Color3 subtractRT(const Color3 &color, T a) { MATH_EXC_ON; return Color3(a - color.x, a - color.y, a - color.z); } template static Color3 subtractR(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(extract(t[0]) - color.x, extract(t[1]) - color.y, extract(t[2]) - color.z); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 neg(Color3 &color) { MATH_EXC_ON; return -color; } template static const Color3 & negate(Color3 &color) { MATH_EXC_ON; return color.negate(); } template static const Color3 & imul(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color *= color2; } template static const Color3 & imulT(Color3 &color, const T &t) { MATH_EXC_ON; return color *= t; } template static Color3 mul(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color * color2; } template static Color3 mulT(Color3 &color, const T &t) { MATH_EXC_ON; return color * t; } template static Color3 rmulT(Color3 &color, const T &t) { MATH_EXC_ON; return t * color; } template static Color3 mulTuple(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x * extract(t[0]), color.y * extract(t[1]), color.z * extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static const Color3 & idiv(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color /= color2; } template static const Color3 & idivT(Color3 &color, const T &t) { MATH_EXC_ON; return color /= t; } template static Color3 div(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color / color2; } template static Color3 divT(Color3 &color, const T &t) { MATH_EXC_ON; return color / t; } template static Color3 divTupleL(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x / extract(t[0]), color.y / extract(t[1]), color.z / extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 divTupleR(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(extract(t[0]) / color.x, extract(t[1]) / color.y, extract(t[2]) / color.z); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 divTR(Color3 &color, T a) { MATH_EXC_ON; return Color3(a / color.x, a / color.y, a / color.z); } template static Color3 hsv2rgb(Color3 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::hsv2rgb(color); } template static Color3 hsv2rgbTuple(const tuple &t) { MATH_EXC_ON; Color3 color; if(t.attr("__len__")() == 3) { color.x = extract(t[0]); color.y = extract(t[1]); color.z = extract(t[2]); return IMATH_NAMESPACE::hsv2rgb(color); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 rgb2hsv(Color3 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::rgb2hsv(color); } template static Color3 rgb2hsvTuple(const tuple &t) { MATH_EXC_ON; Color3 color; if(t.attr("__len__")() == 3) { color.x = extract(t[0]); color.y = extract(t[1]); color.z = extract(t[2]); return IMATH_NAMESPACE::rgb2hsv(color); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static void setValue1(Color3 &color, const T &a, const T &b, const T &c) { MATH_EXC_ON; color.setValue(a, b, c); } template static void setValue2(Color3 &color, const Color3 &v) { MATH_EXC_ON; color.setValue(v); } template static void setValueTuple(Color3 &color, const tuple &t) { MATH_EXC_ON; Color3 v; if(t.attr("__len__")() == 3) { v.x = extract(t[0]); v.y = extract(t[1]); v.z = extract(t[2]); color.setValue(v); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static bool lessThan(Color3 &v, const Color3 &w) { bool isLessThan = (v.x <= w.x && v.y <= w.y && v.z <= w.z) && v != w; return isLessThan; } template static bool greaterThan(Color3 &v, const Color3 &w) { bool isGreaterThan = (v.x >= w.x && v.y >= w.y && v.z >= w.z) && v != w; return isGreaterThan; } template static bool lessThanEqual(Color3 &v, const Color3 &w) { bool isLessThanEqual = (v.x <= w.x && v.y <= w.y && v.z <= w.z); return isLessThanEqual; } template static bool greaterThanEqual(Color3 &v, const Color3 &w) { bool isGreaterThanEqual = (v.x >= w.x && v.y >= w.y && v.z >= w.z); return isGreaterThanEqual; } template class_, bases > > register_Color3() { class_, bases > > color3_class(Color3Name::value, Color3Name::value,init >("copy construction")); color3_class .def("__init__",make_constructor(Color3_construct_default),"initialize to (0,0,0)") .def("__init__",make_constructor(Color3_construct_tuple), "initialize to (r,g,b) with a python tuple") .def("__init__",make_constructor(Color3_construct_list), "initialize to (r,g,b) with a python list") .def("__init__",make_constructor(Color3_component_construct1)) .def("__init__",make_constructor(Color3_component_construct1)) .def("__init__",make_constructor(Color3_component_construct2)) .def("__init__",make_constructor(Color3_component_construct2)) .def("__init__",make_constructor(Color3_color_construct)) .def("__init__",make_constructor(Color3_color_construct)) .def("__init__",make_constructor(Color3_color_construct)) .def("__init__",make_constructor(Color3_vector_construct)) .def("__init__",make_constructor(Color3_vector_construct)) .def("__init__",make_constructor(Color3_vector_construct)) .def_readwrite("r", &Color3::x) .def_readwrite("g", &Color3::y) .def_readwrite("b", &Color3::z) .def("__str__", &color3_str) .def("__repr__", &color3_repr) .def(self == self) // NOSONAR - suppress SonarCloud bug report. .def(self != self) // NOSONAR - suppress SonarCloud bug report. .def("__iadd__", &iadd,return_internal_reference<>()) .def("__add__", &add) .def("__add__", &addTuple) .def("__add__", &addT) .def("__radd__", &addTuple) .def("__radd__", &addT) .def("__isub__", &isub,return_internal_reference<>()) .def("__sub__", &sub) .def("__sub__", &subtractL) .def("__sub__", &subtractLT) .def("__rsub__", &subtractR) .def("__rsub__", &subtractRT) .def("__neg__", &neg) .def("negate",&negate,return_internal_reference<>(),"component-wise multiplication by -1") .def("__imul__", &imul,return_internal_reference<>()) .def("__imul__", &imulT,return_internal_reference<>()) .def("__mul__", &mul) .def("__mul__", &mulT) .def("__rmul__", &rmulT) .def("__mul__", &mulTuple) .def("__rmul__", &mulTuple) .def("__idiv__", &idiv,return_internal_reference<>()) .def("__idiv__", &idivT,return_internal_reference<>()) .def("__itruediv__", &idiv,return_internal_reference<>()) .def("__itruediv__", &idivT,return_internal_reference<>()) .def("__div__", &div) .def("__div__", &divT) .def("__div__", &divTupleL) .def("__truediv__", &div) .def("__truediv__", &divT) .def("__truediv__", &divTupleL) .def("__rdiv__", &divTupleR) .def("__rdiv__", &divTR) .def("__rtruediv__", &divTupleR) .def("__rtruediv__", &divTR) .def("__lt__", &lessThan) .def("__gt__", &greaterThan) .def("__le__", &lessThanEqual) .def("__ge__", &greaterThanEqual) .def("dimensions", &Color3::dimensions,"dimensions() number of dimensions in the color") .staticmethod("dimensions") .def("baseTypeEpsilon", &Color3::baseTypeEpsilon,"baseTypeEpsilon() epsilon value of the base type of the color") .staticmethod("baseTypeEpsilon") .def("baseTypeMax", &Color3::baseTypeMax,"baseTypeMax() max value of the base type of the color") .staticmethod("baseTypeMax") .def("baseTypeLowest", &Color3::baseTypeLowest,"baseTypeLowest() largest negative value of the base type of the color") .staticmethod("baseTypeLowest") .def("baseTypeSmallest", &Color3::baseTypeSmallest,"baseTypeSmallest() smallest value of the base type of the color") .staticmethod("baseTypeSmallest") .def("hsv2rgb", &hsv2rgb, "C.hsv2rgb() -- returns a new color which " "is C converted from RGB to HSV") .def("hsv2rgb", &rgb2hsvTuple) .def("rgb2hsv", &rgb2hsv, "C.rgb2hsv() -- returns a new color which " "is C converted from HSV to RGB") .def("rgb2hsv", &rgb2hsvTuple) .def("setValue", &setValue1, "C1.setValue(C2)\nC1.setValue(a,b,c) -- " "set C1's elements") .def("setValue", &setValue2) .def("setValue", &setValueTuple) ; decoratecopy(color3_class); return color3_class; } template PYIMATH_EXPORT class_, bases > > register_Color3(); template PYIMATH_EXPORT class_, bases > > register_Color3(); template PYIMATH_EXPORT class_ > > register_Color3Array(); template PYIMATH_EXPORT class_ > > register_Color3Array(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color3 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color3(0,0,0); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color3 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color3(0,0,0); } } Imath-3.1.4/src/python/PyImath/PyImathColor3ArrayImpl.h000066400000000000000000000030611417213455000226750ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathColor3ArrayImpl_h_ #define _PyImathColor3ArrayImpl_h_ // // This .C file was turned into a header file so that instantiations // of the various V3* types can be spread across multiple files in // order to work around MSVC limitations. // #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathDecorators.h" namespace PyImath { using namespace boost::python; using namespace IMATH_NAMESPACE; // XXX fixme - template this // really this should get generated automatically... template static FixedArray Color3Array_get(FixedArray > &ca) { return FixedArray(&(ca.unchecked_index(0)[index]), ca.len(),3*ca.stride(),ca.handle(),ca.writable()); } // Currently we are only exposing the RGBA components. template class_ > > register_Color3Array() { class_ > > color3Array_class = FixedArray >::register_("Fixed length array of Imath::Color3"); color3Array_class .add_property("r",&Color3Array_get) .add_property("g",&Color3Array_get) .add_property("b",&Color3Array_get) ; return color3Array_class; } } // namespace PyImath #endif // _PyImathColor3ArrayImpl_h_ Imath-3.1.4/src/python/PyImath/PyImathColor4.cpp000066400000000000000000000453041417213455000214160ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include #include #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathColor.h" #include "PyImathDecorators.h" #include "PyImathExport.h" #include "PyImathColor4Array2DImpl.h" #include "PyImathColor4ArrayImpl.h" namespace PyImath { template <> const char *PyImath::C4cArray::name() { return "C4cArray"; } template <> const char *PyImath::C4fArray::name() { return "C4fArray"; } using namespace boost::python; using namespace IMATH_NAMESPACE; template struct Color4Name { static const char *value; }; template<> const char *Color4Name::value = "Color4c"; template<> const char *Color4Name::value = "Color4f"; // template<> const char *Color4ArrayName::value() { return "Color4fArray"; } // template<> const char *Color4ArrayName::value() { return "Color4cArray"; } template<> const char *Color4Array2DName::value() { return "Color4fArray2D"; } template<> const char *Color4Array2DName::value() { return "Color4cArray2D"; } // create a new default constructor that initializes Color4 to zero. template static Color4 * Color4_construct_default() { return new Color4(T(0),T(0),T(0),T(0)); } template static Color4 * Color4_component_construct1(S x, S y, S z, S w) { // Assigning a floating point value to an integer type can cause a // float-point error, which we want to translate into an exception. MATH_EXC_ON; if(strcmp(Color4Name::value, "Color4c") == 0) { unsigned char r = (unsigned char) x; unsigned char g = (unsigned char) y; unsigned char b = (unsigned char) z; unsigned char a = (unsigned char) w; return new Color4(r,g,b,a); } else return new Color4(T(x) , T(y), T(z), T(w)); } template static Color4 * Color4_component_construct2(S x) { MATH_EXC_ON; if(strcmp(Color4Name::value, "Color4c") == 0) { unsigned char u = (unsigned char) x; return new Color4(u,u,u,u); } else return new Color4(T(x),T(x),T(x),T(x)); } template static Color4 * Color4_color_construct(const Color4 &c) { MATH_EXC_ON; if(strcmp(Color4Name::value, "Color4c") == 0) { unsigned char r = (unsigned char) c.r; unsigned char g = (unsigned char) c.g; unsigned char b = (unsigned char) c.b; unsigned char a = (unsigned char) c.a; return new Color4(r,g,b,a); } else return new Color4(T (c.r), T(c.g), T(c.b), T(c.a)); } template static Color4 * Color4_construct_tuple(const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) { return new Color4(extract(t[0]), extract(t[1]), extract(t[2]), extract(t[3])); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 * Color4_construct_list(const list &l) { MATH_EXC_ON; if(l.attr("__len__")() == 4) { return new Color4(extract(l[0]), extract(l[1]), extract(l[2]), extract(l[3])); } else throw std::invalid_argument ("Color4 expects list of length 4"); } template static std::string color4_str(const Color4 &c) { std::stringstream stream; if(strcmp(Color4Name::value, "Color4c") == 0) { int r = int(c.r); int g = int(c.g); int b = int(c.b); int a = int(c.a); stream << Color4Name::value << "(" << r << ", " << g << ", " << b << ", " << a << ")"; return stream.str(); } else { stream << Color4Name::value << "(" << c.r << ", " << c.g << ", " << c.b << ", " << c.a << ")"; return stream.str(); } } // Non-specialized repr is same as str template static std::string color4_repr(const Color4 &c) { return color4_str(c); } // Specialization for float to full precision template <> std::string color4_repr(const Color4 &c) { return (boost::format("%s(%.9g, %.9g, %.9g, %.9g)") % Color4Name::value % c.r % c.g % c.b % c.a).str(); } // No specialization for double, since we don't instantiate Color4d template static Color4 hsv2rgb(Color4 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::hsv2rgb(color); } template static Color4 hsv2rgbTuple(const tuple &t) { MATH_EXC_ON; Color4 color; if(t.attr("__len__")() == 4) { color.r = extract(t[0]); color.g = extract(t[1]); color.b = extract(t[2]); color.a = extract(t[3]); return IMATH_NAMESPACE::hsv2rgb(color); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 rgb2hsv(Color4 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::rgb2hsv(color); } template static Color4 rgb2hsvTuple(const tuple &t) { MATH_EXC_ON; Color4 color; if(t.attr("__len__")() == 4) { color.r = extract(t[0]); color.g = extract(t[1]); color.b = extract(t[2]); color.a = extract(t[3]); return IMATH_NAMESPACE::rgb2hsv(color); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static void setValue1(Color4 &color, const T &a, const T &b, const T &c, const T &d) { MATH_EXC_ON; color.setValue(a, b, c, d); } template static void setValue2(Color4 &color, const Color4 &v) { MATH_EXC_ON; color.setValue(v); } template static void setValueTuple(Color4 &color, const tuple &t) { MATH_EXC_ON; Color4 v; if(t.attr("__len__")() == 4) { v.r = extract(t[0]); v.g = extract(t[1]); v.b = extract(t[2]); v.a = extract(t[3]); color.setValue(v); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static const Color4 & iadd(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color += color2; } template static Color4 add(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color + color2; } template static Color4 addTuple(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r + extract(t[0]), color.g + extract(t[1]), color.b + extract(t[2]), color.a + extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 addT(Color4 &v, T a) { MATH_EXC_ON; Color4 w(v.r + a, v.g + a, v.b + a, v.a + a); return w; } template static const Color4 & isub(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color -= color2; } template static Color4 sub(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color - color2; } template static Color4 subtractL(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r - extract(t[0]), color.g - extract(t[1]), color.b - extract(t[2]), color.a - extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 subtractR(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(extract(t[0]) - color.r, extract(t[1]) - color.g, extract(t[2]) - color.b, extract(t[3]) - color.a); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 subtractLT(const Color4 &color, T a) { MATH_EXC_ON; return Color4(color.r - a, color.g - a, color.b - a, color.a - a); } template static Color4 subtractRT(const Color4 &color, T a) { MATH_EXC_ON; return Color4(a - color.r, a - color.g, a - color.b, a - color.a); } template static Color4 neg(Color4 &color) { MATH_EXC_ON; return -color; } template static const Color4 & negate(Color4 &color) { MATH_EXC_ON; return color.negate(); } template static const Color4 & imul(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color *= color2; } template static const Color4 & imulT(Color4 &color, const T &t) { MATH_EXC_ON; return color *= t; } template static Color4 mul(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color * color2; } template static Color4 mulT(Color4 &color, const T &t) { MATH_EXC_ON; return color * t; } template static Color4 rmulT(Color4 &color, const T &t) { MATH_EXC_ON; return t * color; } template static Color4 mulTuple(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r * extract(t[0]), color.g * extract(t[1]), color.b * extract(t[2]), color.a * extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static const Color4 & idiv(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color /= color2; } template static const Color4 & idivT(Color4 &color, const T &t) { MATH_EXC_ON; return color /= t; } template static Color4 div(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color / color2; } template static Color4 divT(Color4 &color, const T &t) { MATH_EXC_ON; return color / t; } template static Color4 divTupleL(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r / extract(t[0]), color.g / extract(t[1]), color.b / extract(t[2]), color.a / extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 divTupleR(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(extract(t[0]) / color.r, extract(t[1]) / color.g, extract(t[2]) / color.b, extract(t[3]) / color.a); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 divTR(Color4 &color, T a) { MATH_EXC_ON; return Color4(a / color.r, a / color.g, a / color.b, a / color.a); } template static bool lessThan(Color4 &v, const Color4 &w) { bool isLessThan = (v.r <= w.r && v.g <= w.g && v.b <= w.b && v.a <= w.a) && v != w; return isLessThan; } template static bool greaterThan(Color4 &v, const Color4 &w) { bool isGreaterThan = (v.r >= w.r && v.g >= w.g && v.b >= w.b && v.a >= w.a) && v != w; return isGreaterThan; } template static bool lessThanEqual(Color4 &v, const Color4 &w) { bool isLessThanEqual = (v.r <= w.r && v.g <= w.g && v.b <= w.b && v.a <= w.a); return isLessThanEqual; } template static bool greaterThanEqual(Color4 &v, const Color4 &w) { bool isGreaterThanEqual = (v.r >= w.r && v.g >= w.g && v.b >= w.b) && v.a >= w.a; return isGreaterThanEqual; } template class_ > register_Color4() { typedef PyImath::StaticFixedArray,T,4> Color4_helper; void (IMATH_NAMESPACE::Color4::*getValue1)(Color4 &) const = &IMATH_NAMESPACE::Color4::getValue; void (IMATH_NAMESPACE::Color4::*getValue2)(T &, T &, T &, T &) const = &IMATH_NAMESPACE::Color4::getValue; class_ > color4_class(Color4Name::value, Color4Name::value,init >("copy construction")); color4_class .def("__init__",make_constructor(Color4_construct_default),"initialize to (0,0,0,0)") .def("__init__",make_constructor(Color4_construct_tuple), "initialize to (r,g,b,a) with a python tuple") .def("__init__",make_constructor(Color4_construct_list), "initialize to (r,g,b,a) with a python list") .def("__init__",make_constructor(Color4_component_construct1)) .def("__init__",make_constructor(Color4_component_construct1)) .def("__init__",make_constructor(Color4_component_construct2)) .def("__init__",make_constructor(Color4_component_construct2)) .def("__init__",make_constructor(Color4_color_construct)) .def("__init__",make_constructor(Color4_color_construct)) .def("__init__",make_constructor(Color4_color_construct)) .def_readwrite("r", &Color4::r) .def_readwrite("g", &Color4::g) .def_readwrite("b", &Color4::b) .def_readwrite("a", &Color4::a) .def("__str__", &color4_str) .def("__repr__", &color4_repr) .def(self == self) // NOSONAR - suppress SonarCloud bug report. .def(self != self) // NOSONAR - suppress SonarCloud bug report. .def("__iadd__", &iadd,return_internal_reference<>()) .def("__add__", &add) .def("__add__", &addTuple) .def("__add__", &addT) .def("__radd__", &addTuple) .def("__radd__", &addT) .def("__isub__", &isub,return_internal_reference<>()) .def("__sub__", &sub) .def("__sub__", &subtractL) .def("__sub__", &subtractLT) .def("__rsub__", &subtractR) .def("__rsub__", &subtractRT) .def("__neg__", &neg) .def("negate",&negate,return_internal_reference<>(),"component-wise multiplication by -1") .def("__imul__", &imul,return_internal_reference<>()) .def("__imul__", &imulT,return_internal_reference<>()) .def("__mul__", &mul) .def("__mul__", &mulT) .def("__rmul__", &mulT) .def("__mul__", &mulTuple) .def("__rmul__", &mulTuple) .def("__idiv__", &idiv,return_internal_reference<>()) .def("__idiv__", &idivT,return_internal_reference<>()) .def("__itruediv__", &idiv,return_internal_reference<>()) .def("__itruediv__", &idivT,return_internal_reference<>()) .def("__div__", &div) .def("__div__", &divT) .def("__div__", &divTupleL) .def("__truediv__", &div) .def("__truediv__", &divT) .def("__truediv__", &divTupleL) .def("__rdiv__", &divTupleR) .def("__rdiv__", &divTR) .def("__rtruediv__", &divTupleR) .def("__rtruediv__", &divTR) .def("__lt__", &lessThan) .def("__gt__", &greaterThan) .def("__le__", &lessThanEqual) .def("__ge__", &greaterThanEqual) .def("__len__", Color4_helper::len) .def("__getitem__", Color4_helper::getitem,return_value_policy()) .def("__setitem__", Color4_helper::setitem) .def("dimensions", &Color4::dimensions,"dimensions() number of dimensions in the color") .staticmethod("dimensions") .def("baseTypeEpsilon", &Color4::baseTypeEpsilon,"baseTypeEpsilon() epsilon value of the base type of the color") .staticmethod("baseTypeEpsilon") .def("baseTypeMax", &Color4::baseTypeMax,"baseTypeMax() max value of the base type of the color") .staticmethod("baseTypeMax") .def("baseTypeLowest", &Color4::baseTypeLowest,"baseTypeLowest() largest negative value of the base type of the color") .staticmethod("baseTypeLowest") .def("baseTypeSmallest", &Color4::baseTypeSmallest,"baseTypeSmallest() smallest value of the base type of the color") .staticmethod("baseTypeSmallest") .def("__repr__",&color4_repr) .def("hsv2rgb", &hsv2rgb, "C.hsv2rgb() -- returns a new color which " "is C converted from RGB to HSV") .def("hsv2rgb", &rgb2hsvTuple) .def("rgb2hsv", &rgb2hsv, "C.rgb2hsv() -- returns a new color which " "is C converted from HSV to RGB") .def("rgb2hsv", &rgb2hsvTuple) .def("setValue", &setValue1, "C1.setValue(C2)\nC1.setValue(a,b,c) -- " "set C1's elements") .def("setValue", &setValue2) .def("setValue", &setValueTuple) .def("getValue", getValue1, "getValue()") .def("getValue", getValue2) ; decoratecopy(color4_class); return color4_class; } template PYIMATH_EXPORT class_ > register_Color4(); template PYIMATH_EXPORT class_ > register_Color4(); template PYIMATH_EXPORT class_ > > register_Color4Array(); template PYIMATH_EXPORT class_ > > register_Color4Array(); template PYIMATH_EXPORT class_ > > register_Color4Array2D(); template PYIMATH_EXPORT class_ > > register_Color4Array2D(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color4 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color4(0,0,0, 0); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color4 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color4(0,0,0,0); } } Imath-3.1.4/src/python/PyImath/PyImathColor4Array2DImpl.h000066400000000000000000000473021417213455000230720ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathColor4Array2DImpl_h_ #define _PyImathColor4Array2DImpl_h_ // // This .C file was turned into a header file so that instantiations // of the various V3* types can be spread across multiple files in // order to work around MSVC limitations. // #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathDecorators.h" namespace PyImath { using namespace boost::python; using namespace IMATH_NAMESPACE; template struct Color4Array2DName { static const char *value(); }; // XXX fixme - template this // really this should get generated automatically... template static FixedArray2D Color4Array2D_get(FixedArray2D > &va) { return FixedArray2D(&va(0,0)[index], va.len().x,va.len().y, 4*va.stride().x, va.stride().y, va.handle()); } // template // static FixedArray2D > // Color4Array_cross0(const FixedArray2D > &va, const FixedArray2D > &vb) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); // FixedArray2D > f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).cross(vb(i,j)); // return f; // } // // template // static FixedArray2D > // Color4Array_cross1(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // FixedArray2D > f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).cross(vb); // return f; // } // // template // static FixedArray2D // Color4Array_dot0(const FixedArray2D > &va, const FixedArray2D > &vb) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); // FixedArray2D f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).dot(vb(i,j)); // return f; // } // // template // static FixedArray2D // Color4Array_dot1(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // FixedArray2D f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).dot(vb); // return f; // } // template // static FixedArray2D // Color4Array_length(const FixedArray2D > &va) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // FixedArray2D f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).length(); // return f; // } // // template // static FixedArray2D // Color4Array_length2(const FixedArray2D > &va) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // FixedArray2D f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).length2(); // return f; // } // // template // static FixedArray2D > & // Color4Array_normalize(FixedArray2D > &va) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // for (size_t i = 0; i < len; ++i) // va(i,j).normalize(); // return va; // } // // template static FixedArray2D > // Color4Array_normalized(const FixedArray2D > &va) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // FixedArray2D > f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j).normalized(); // return f; // } // template static FixedArray2D > Color4Array_mulT(const FixedArray2D > &va, T t) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) * t; return f; } // // template // static FixedArray2D > // Color4Array_mulM44(const FixedArray2D > &va, const IMATH_NAMESPACE::Matrix44 &m) // { // PY_IMATH_LEAVE_PYTHON; // IMATH_NAMESPACE::Vec2 len = va.len(); // FixedArray2D > f(len); // for (size_t i = 0; i < len; ++i) // f(i,j) = va(i,j) * m; // return f; // } // template static FixedArray2D > Color4Array_mulArrayT(const FixedArray2D > &va, const FixedArray2D &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) * vb(i,j); return f; } template static const FixedArray2D > & Color4Array_imulT(FixedArray2D > &va, T t) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) *= t; return va; } template static const FixedArray2D > & Color4Array_imulArrayT(FixedArray2D > &va, const FixedArray2D &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) *= vb(i,j); return va; } template static FixedArray2D > Color4Array_divT(const FixedArray2D > &va, T t) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) / t; return f; } template static FixedArray2D > Color4Array_divArrayT(const FixedArray2D > &va, const FixedArray2D &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) / vb(i,j); return f; } template static const FixedArray2D > & Color4Array_idivT(FixedArray2D > &va, T t) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) /= t; return va; } template static const FixedArray2D > & Color4Array_idivArrayT(FixedArray2D > &va, const FixedArray2D &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) /= vb(i,j); return va; } template static FixedArray2D > Color4Array_add(const FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) + vb(i,j); return f; } template static FixedArray2D > Color4Array_addColor(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) + vb; return f; } template static FixedArray2D > Color4Array_sub(const FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) - vb(i,j); return f; } template static FixedArray2D > Color4Array_subColor(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) - vb; return f; } template static FixedArray2D > Color4Array_rsubColor(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = vb - va(i,j); return f; } template static FixedArray2D > Color4Array_mul(const FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) * vb(i,j); return f; } template static FixedArray2D > Color4Array_mulColor(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) * vb; return f; } template static FixedArray2D > Color4Array_div(const FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) / vb(i,j); return f; } template static FixedArray2D > Color4Array_divColor(const FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = va(i,j) / vb; return f; } template static FixedArray2D > Color4Array_neg(const FixedArray2D > &va) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); FixedArray2D > f(len); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) f(i,j) = -va(i,j); return f; } template static const FixedArray2D > & Color4Array_iadd(FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) += vb(i,j); return va; } template static const FixedArray2D > & Color4Array_iaddColor(FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) += vb; return va; } template static const FixedArray2D > & Color4Array_isub(FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) -= vb(i,j); return va; } template static const FixedArray2D > & Color4Array_isubColor(FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) -= vb; return va; } template static const FixedArray2D > & Color4Array_imul(FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) *= vb(i,j); return va; } template static const FixedArray2D > & Color4Array_imulColor(FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) *= vb; return va; } template static const FixedArray2D > & Color4Array_idiv(FixedArray2D > &va, const FixedArray2D > &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.match_dimension(vb); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) /= vb(i,j); return va; } template static const FixedArray2D > & Color4Array_idivColor(FixedArray2D > &va, const IMATH_NAMESPACE::Color4 &vb) { PY_IMATH_LEAVE_PYTHON; IMATH_NAMESPACE::Vec2 len = va.len(); for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) va(i,j) /= vb; return va; } template static void setItemTuple(FixedArray2D > &va, const tuple &index, const tuple &t) { if(t.attr("__len__")() == 4 && index.attr("__len__")() == 2) { Color4 v; v.r = extract(t[0]); v.g = extract(t[1]); v.b = extract(t[2]); v.a = extract(t[3]); va(va.canonical_index(extract(index[0]),va.len()[0]), va.canonical_index(extract(index[1]),va.len()[1])) = v; } else throw std::invalid_argument ("tuple of length 4 expected"); } template class_ > > register_Color4Array2D() { class_ > > color4Array2D_class = FixedArray2D >::register_(Color4Array2DName::value(),"Fixed length 2d array of IMATH_NAMESPACE::Color4"); color4Array2D_class .add_property("r",&Color4Array2D_get) .add_property("g",&Color4Array2D_get) .add_property("b",&Color4Array2D_get) .add_property("a",&Color4Array2D_get) // .def("dot",&Color4Array_dot0) // .def("dot",&Color4Array_dot1) // .def("cross", &Color4Array_cross0) // .def("cross", &Color4Array_cross1) // .def("length", &Color4Array_length) // .def("length2", &Color4Array_length2) // .def("normalize", &Color4Array_normalize,return_internal_reference<>()) // .def("normalized", &Color4Array_normalized) .def("__setitem__", &setItemTuple) .def("__mul__", &Color4Array_mulT) // .def("__mul__", &Color4Array_mulM44) // .def("__mul__", &Color4Array_mulM44) .def("__rmul__", &Color4Array_mulT) .def("__mul__", &Color4Array_mulArrayT) .def("__rmul__", &Color4Array_mulArrayT) .def("__imul__", &Color4Array_imulT,return_internal_reference<>()) .def("__imul__", &Color4Array_imulArrayT,return_internal_reference<>()) .def("__div__", &Color4Array_divT) .def("__div__", &Color4Array_divArrayT) .def("__truediv__", &Color4Array_divT) .def("__truediv__", &Color4Array_divArrayT) .def("__idiv__", &Color4Array_idivT,return_internal_reference<>()) .def("__idiv__", &Color4Array_idivArrayT,return_internal_reference<>()) .def("__itruediv__", &Color4Array_idivT,return_internal_reference<>()) .def("__itruediv__", &Color4Array_idivArrayT,return_internal_reference<>()) .def("__add__",&Color4Array_add) .def("__add__",&Color4Array_addColor) .def("__radd__",&Color4Array_addColor) .def("__sub__",&Color4Array_sub) .def("__sub__",&Color4Array_subColor) .def("__rsub__",&Color4Array_rsubColor) .def("__mul__",&Color4Array_mul) .def("__mul__",&Color4Array_mulColor) .def("__rmul__",&Color4Array_mulColor) .def("__div__",&Color4Array_div) .def("__div__",&Color4Array_divColor) .def("__truediv__",&Color4Array_div) .def("__truediv__",&Color4Array_divColor) .def("__neg__",&Color4Array_neg) .def("__iadd__",&Color4Array_iadd, return_internal_reference<>()) .def("__iadd__",&Color4Array_iaddColor, return_internal_reference<>()) .def("__isub__",&Color4Array_isub, return_internal_reference<>()) .def("__isub__",&Color4Array_isubColor, return_internal_reference<>()) .def("__imul__",&Color4Array_imul, return_internal_reference<>()) .def("__imul__",&Color4Array_imulColor, return_internal_reference<>()) .def("__idiv__",&Color4Array_idiv, return_internal_reference<>()) .def("__idiv__",&Color4Array_idivColor, return_internal_reference<>()) .def("__itruediv__",&Color4Array_idiv, return_internal_reference<>()) .def("__itruediv__",&Color4Array_idivColor, return_internal_reference<>()) ; add_comparison_functions(color4Array2D_class); decoratecopy(color4Array2D_class); return color4Array2D_class; } } // namespace PyImath #endif // _PyImathColor4ArrayImpl_h_ Imath-3.1.4/src/python/PyImath/PyImathColor4ArrayImpl.h000066400000000000000000000031541417213455000227010ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathColor4ArrayImpl_h_ #define _PyImathColor4ArrayImpl_h_ // // This .C file was turned into a header file so that instantiations // of the various V3* types can be spread across multiple files in // order to work around MSVC limitations. // #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathDecorators.h" namespace PyImath { using namespace boost::python; using namespace IMATH_NAMESPACE; // XXX fixme - template this // really this should get generated automatically... template static FixedArray Color4Array_get(FixedArray > &ca) { return FixedArray(&(ca.unchecked_index(0)[index]), ca.len(),4*ca.stride(),ca.handle(),ca.writable()); } // Currently we are only exposing the RGBA components. template class_ > > register_Color4Array() { class_ > > color4Array_class = FixedArray >::register_("Fixed length array of IMATH_NAMESPACE::Color4"); color4Array_class .add_property("r",&Color4Array_get) .add_property("g",&Color4Array_get) .add_property("b",&Color4Array_get) .add_property("a",&Color4Array_get) ; return color4Array_class; } } // namespace PyImath #endif // _PyImathColor4ArrayImpl_h_ Imath-3.1.4/src/python/PyImath/PyImathDecorators.h000066400000000000000000000016171417213455000220250ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef INCLUDED_PYIMATH_DECORATORS_H #define INCLUDED_PYIMATH_DECORATORS_H #include namespace PyImath { // These function add __copy__ and __deepcopy__ methods // to python classes by simply wrapping the copy constructors // This interface is needed for using these classes with // the python copy module. template static T copy(const T& x) { return T(x); } template static T deepcopy(const T& x, boost::python::dict&) { return copy(x); } template boost::python::class_& decoratecopy(boost::python::class_& cls) { cls.def("__copy__",©); cls.def("__deepcopy__",&deepcopy); return cls; } } // namespace PyImath #endif // INCLUDED_PYIMATH_DECORATORS_H Imath-3.1.4/src/python/PyImath/PyImathEuler.cpp000066400000000000000000000622231417213455000213270ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathEuler.h" #include "PyImathDecorators.h" #include "PyImathExport.h" #include "PyImathOperators.h" // XXX incomplete array wrapping, docstrings missing namespace PyImath { template<> const char *PyImath::EulerfArray::name() { return "EulerfArray"; } template<> const char *PyImath::EulerdArray::name() { return "EulerdArray"; } } namespace PyImath { using namespace boost::python; using namespace IMATH_NAMESPACE; template struct EulerName { static const char *value; }; template<> const char *EulerName::value = "Eulerf"; template<> const char *EulerName::value = "Eulerd"; template static std::string nameOfOrder(typename IMATH_NAMESPACE::Euler::Order order) { switch(order) { case IMATH_NAMESPACE::Euler::XYZ: return "EULER_XYZ"; case IMATH_NAMESPACE::Euler::XZY: return "EULER_XZY"; case IMATH_NAMESPACE::Euler::YZX: return "EULER_YZX"; case IMATH_NAMESPACE::Euler::YXZ: return "EULER_YXZ"; case IMATH_NAMESPACE::Euler::ZXY: return "EULER_ZXY"; case IMATH_NAMESPACE::Euler::ZYX: return "EULER_ZYX"; case IMATH_NAMESPACE::Euler::XZX: return "EULER_XZX"; case IMATH_NAMESPACE::Euler::XYX: return "EULER_XYX"; case IMATH_NAMESPACE::Euler::YXY: return "EULER_YXY"; case IMATH_NAMESPACE::Euler::YZY: return "EULER_YZY"; case IMATH_NAMESPACE::Euler::ZYZ: return "EULER_ZYZ"; case IMATH_NAMESPACE::Euler::ZXZ: return "EULER_ZXZ"; case IMATH_NAMESPACE::Euler::XYZr: return "EULER_XYZr"; case IMATH_NAMESPACE::Euler::XZYr: return "EULER_XZYr"; case IMATH_NAMESPACE::Euler::YZXr: return "EULER_YZXr"; case IMATH_NAMESPACE::Euler::YXZr: return "EULER_YXZr"; case IMATH_NAMESPACE::Euler::ZXYr: return "EULER_ZXYr"; case IMATH_NAMESPACE::Euler::ZYXr: return "EULER_ZYXr"; case IMATH_NAMESPACE::Euler::XZXr: return "EULER_XZXr"; case IMATH_NAMESPACE::Euler::XYXr: return "EULER_XYXr"; case IMATH_NAMESPACE::Euler::YXYr: return "EULER_YXYr"; case IMATH_NAMESPACE::Euler::YZYr: return "EULER_YZYr"; case IMATH_NAMESPACE::Euler::ZYZr: return "EULER_ZYZr"; case IMATH_NAMESPACE::Euler::ZXZr: return "EULER_ZXZr"; default: break; } return ""; } template static std::string Euler_str(const Euler &e) { std::stringstream stream; stream << EulerName::value << "(" << e.x << ", " << e.y << ", " << e.z << ", " << nameOfOrder (e.order()) << ")"; return stream.str(); } // Non-specialized repr is same as str template static std::string Euler_repr(const Euler &e) { return Euler_str(e); } // Specialization for float to full precision template <> std::string Euler_repr(const Euler &e) { return (boost::format("%s(%.9g, %.9g, %.9g, %s)") % EulerName::value % e.x % e.y % e.z % nameOfOrder(e.order()).c_str()).str(); } // Specialization for double to full precision template <> std::string Euler_repr(const Euler &e) { return (boost::format("%s(%.17g, %.17g, %.17g, %s)") % EulerName::value % e.x % e.y % e.z % nameOfOrder(e.order()).c_str()).str(); } template static bool equal(const Euler &e0, const Euler &e1) { if(e0.x == e1.x && e0.y == e1.y && e0.z == e1.z && (e0.order())==(e1.order())) return true; else return false; } template static bool notequal(const Euler &e0, const Euler &e1) { if(e0.x != e1.x || e0.y != e1.y || e0.z != e1.z || (e0.order()) != (e1.order())) { return true; } else return false; } template static IMATH_NAMESPACE::Vec3 getAngleOrder(Euler &euler) { int i, j, k; euler.angleOrder(i, j, k); return IMATH_NAMESPACE::Vec3 (i, j, k); } template static void setXYZTuple(Euler &euler, const tuple &t) { MATH_EXC_ON; Vec3 v; if(t.attr("__len__")() == 3) { v.x = extract(t[0]); v.y = extract(t[1]); v.z = extract(t[2]); euler.setXYZVector(v); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } // needed to convert Eulerf::Order to Euler::Order template static typename Euler::Order interpretOrder(typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = Euler::XYZ; switch(order) { case IMATH_NAMESPACE::Eulerf::XYZ: { o = Euler::XYZ; }break; case IMATH_NAMESPACE::Eulerf::XZY: { o = Euler::XZY; }break; case IMATH_NAMESPACE::Eulerf::YZX: { o = Euler::YZX; }break; case IMATH_NAMESPACE::Eulerf::YXZ: { o = Euler::YXZ; }break; case IMATH_NAMESPACE::Eulerf::ZXY: { o = Euler::ZXY; }break; case IMATH_NAMESPACE::Eulerf::ZYX: { o = Euler::ZYX; }break; case IMATH_NAMESPACE::Eulerf::XZX: { o = Euler::XZX; }break; case IMATH_NAMESPACE::Eulerf::XYX: { o = Euler::XYX; }break; case IMATH_NAMESPACE::Eulerf::YXY: { o = Euler::YXY; }break; case IMATH_NAMESPACE::Eulerf::YZY: { o = Euler::YZY; }break; case IMATH_NAMESPACE::Eulerf::ZYZ: { o = Euler::ZYZ; }break; case IMATH_NAMESPACE::Eulerf::ZXZ: { o = Euler::ZXZ; }break; case IMATH_NAMESPACE::Eulerf::XYZr: { o = Euler::XYZr; }break; case IMATH_NAMESPACE::Eulerf::XZYr: { o = Euler::XZYr; }break; case IMATH_NAMESPACE::Eulerf::YZXr: { o = Euler::YZXr; }break; case IMATH_NAMESPACE::Eulerf::YXZr: { o = Euler::YXZr; }break; case IMATH_NAMESPACE::Eulerf::ZXYr: { o = Euler::ZXYr; }break; case IMATH_NAMESPACE::Eulerf::ZYXr: { o = Euler::ZYXr; }break; case IMATH_NAMESPACE::Eulerf::XZXr: { o = Euler::XZXr; }break; case IMATH_NAMESPACE::Eulerf::XYXr: { o = Euler::XYXr; }break; case IMATH_NAMESPACE::Eulerf::YXYr: { o = Euler::YXYr; }break; case IMATH_NAMESPACE::Eulerf::YZYr: { o = Euler::YZYr; }break; case IMATH_NAMESPACE::Eulerf::ZYZr: { o = Euler::ZYZr; }break; case IMATH_NAMESPACE::Eulerf::ZXZr: { o = Euler::ZXZr; }break; default: break; } return o; } // needed to convert Eulerf::Axis to Euler::Axis template static typename Euler::Axis interpretAxis(typename IMATH_NAMESPACE::Eulerf::Axis axis) { if (axis == IMATH_NAMESPACE::Eulerf::X) return Euler::X; else if (axis == IMATH_NAMESPACE::Eulerf::Y) return Euler::Y; else return Euler::Z; } template static Euler * eulerConstructor1(const Vec3 &v, typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = interpretOrder(order); return new Euler(v, o); } template static Euler * eulerConstructor1a(const Vec3 &v) { return eulerConstructor1 (v, IMATH_NAMESPACE::Eulerf::Default); } template static Euler * eulerConstructor1b(const Vec3 &v, int iorder) { typename Euler::Order o = typename Euler::Order (iorder); return new Euler(v, o); } template static Euler * eulerConstructor2(T i, T j, T k, typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = interpretOrder(order); return new Euler(i, j, k, o); } template static Euler * eulerConstructor2a(T i, T j, T k) { return eulerConstructor2 (i, j, k, IMATH_NAMESPACE::Eulerf::Default); } template static Euler * eulerConstructor2b(T i, T j, T k, int iorder) { typename Euler::Order o = typename Euler::Order (iorder); return new Euler(i, j, k, o); } template static Euler * eulerConstructor3(const Matrix33 &mat, typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = interpretOrder(order); return new Euler(mat, o); } template static Euler * eulerConstructor3a(const Matrix33 &mat) { return eulerConstructor3 (mat, IMATH_NAMESPACE::Eulerf::Default); } template static Euler * eulerConstructor3b(const Matrix33 &mat, int iorder) { typename Euler::Order o = typename Euler::Order (iorder); return new Euler(mat, o); } template static Euler * eulerConstructor4(const Matrix44 &mat, typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = interpretOrder(order); return new Euler(mat, o); } template static Euler * eulerConstructor4a(const Matrix44 &mat) { return eulerConstructor4 (mat, IMATH_NAMESPACE::Eulerf::Default); } template static Euler * eulerConstructor4b(const Matrix44 &mat, int iorder) { typename Euler::Order o = typename Euler::Order (iorder); return new Euler(mat, o); } template static Euler * eulerConstructor5(typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = interpretOrder(order); return new Euler(o); } template static Euler * eulerConstructor5a() { typename Euler::Order o = interpretOrder(IMATH_NAMESPACE::Eulerf::Default); return new Euler(o); } template static Euler * eulerConstructor5b(int iorder) { typename Euler::Order o = typename Euler::Order (iorder); return new Euler(o); } template static Euler * eulerConstructor6(T x, T y, T z) { return new Euler(Vec3(x,y,z)); } template static Euler * eulerConstructor7(const Quat &quat, typename IMATH_NAMESPACE::Eulerf::Order order) { Euler *e = eulerConstructor5(order); e->extract(quat); return e; } template static Euler * eulerConstructor7a(const Quat &quat) { return eulerConstructor7(quat, IMATH_NAMESPACE::Eulerf::Default); } template static Euler * eulerConstructor7b(const Quat &quat, int iorder) { Euler *e = eulerConstructor5b(iorder); e->extract(quat); return e; } template static Euler * eulerConversionConstructor(const Euler &euler) { MATH_EXC_ON; Euler *e = new Euler; *e = euler; return e; } template static void eulerMakeNear(Euler &euler, Euler &target) { MATH_EXC_ON; euler.makeNear (target); } template static void eulerSetOrder(Euler &euler, typename IMATH_NAMESPACE::Eulerf::Order order) { typename Euler::Order o = interpretOrder(order); euler.setOrder (o); } template static void eulerSet(Euler &euler, IMATH_NAMESPACE::Eulerf::Axis axis, int relative, int parityEven, int firstRepeats) { MATH_EXC_ON; typename Euler::Axis a = interpretAxis(axis); euler.set (a, relative, parityEven, firstRepeats); } template static void extract1(Euler &euler, const Matrix33 &m) { MATH_EXC_ON; euler.extract(m); } template static void extract2(Euler &euler, const Matrix44 &m) { MATH_EXC_ON; euler.extract(m); } template static void extract3(Euler &euler, const Quat &q) { MATH_EXC_ON; euler.extract(q); } template static Matrix33 toMatrix33(Euler &euler) { MATH_EXC_ON; return euler.toMatrix33(); } template static Matrix44 toMatrix44(Euler &euler) { MATH_EXC_ON; return euler.toMatrix44(); } template static Quat toQuat(Euler &euler) { MATH_EXC_ON; return euler.toQuat(); } template static Vec3 toXYZVector(Euler &euler) { MATH_EXC_ON; return euler.toXYZVector(); } template class_,bases > > register_Euler() { class_,bases > > euler_class(EulerName::value,EulerName::value,init >("copy construction")); euler_class .def(init<>("imath Euler default construction")) .def("__init__", make_constructor(eulerConstructor1)) .def("__init__", make_constructor(eulerConstructor1a)) .def("__init__", make_constructor(eulerConstructor1b)) .def("__init__", make_constructor(eulerConstructor2)) .def("__init__", make_constructor(eulerConstructor2a)) .def("__init__", make_constructor(eulerConstructor2b)) .def("__init__", make_constructor(eulerConstructor3), "Euler-from-matrix construction assumes, but does\n" "not verify, that the matrix includes no shear or\n" "non-uniform scaling. If necessary, you can fix\n" "the matrix by calling the removeScalingAndShear()\n" "function.\n") .def("__init__", make_constructor(eulerConstructor3a)) .def("__init__", make_constructor(eulerConstructor3b)) .def("__init__", make_constructor(eulerConstructor4)) .def("__init__", make_constructor(eulerConstructor4a)) .def("__init__", make_constructor(eulerConstructor4b)) .def("__init__", make_constructor(eulerConstructor5)) .def("__init__", make_constructor(eulerConstructor5a)) .def("__init__", make_constructor(eulerConstructor5b)) .def("__init__", make_constructor(eulerConstructor6)) .def("__init__", make_constructor(eulerConstructor7)) .def("__init__", make_constructor(eulerConstructor7a)) .def("__init__", make_constructor(eulerConstructor7b)) .def("__init__", make_constructor(eulerConversionConstructor)) .def("__init__", make_constructor(eulerConversionConstructor)) .def("angleOrder", &getAngleOrder, "angleOrder() set the angle order") .def("frameStatic", &Euler::frameStatic, "e.frameStatic() -- returns true if the angles of e\n" "are measured relative to a set of fixed axes,\n" "or false if the angles of e are measured relative to\n" "each other\n") .def("initialAxis", &Euler::initialAxis, "e.initialAxis() -- returns the initial rotation\n" "axis of e (EULER_X_AXIS, EULER_Y_AXIS, EULER_Z_AXIS)") .def("initialRepeated", &Euler::initialRepeated, "e.initialRepeated() -- returns 1 if the initial\n" "rotation axis of e is repeated (for example,\n" "e.order() == EULER_XYX); returns 0 if the initial\n" "rotation axis is not repeated.\n") .def("makeNear", &eulerMakeNear, "e.makeNear(t) -- adjusts Euler e so that it\n" "represents the same rotation as before, but the\n" "individual angles of e differ from the angles of\n" "t by as little as possible.\n" "This method might not make sense if e.order()\n" "and t.order() are different\n") .def("order", &Euler::order, "e.order() -- returns the rotation order in e\n" "(EULER_XYZ, EULER_XZY, ...)") .def("parityEven", &Euler::parityEven, "e.parityEven() -- returns the parity of the\n" "axis permutation of e\n") .def("set", &eulerSet, "e.set(i,r,p,f) -- sets the rotation order in e\n" "according to the following flags:\n" "\n" " i initial axis (EULER_X_AXIS,\n" " EULER_Y_AXIS or EULER_Z_AXIS)\n" "\n" " r rotation angles are measured relative\n" " to each other (r == 1), or relative to a\n" " set of fixed axes (r == 0)\n" "\n" " p parity of axis permutation is even (r == 1)\n" " or odd (r == 0)\n" "\n" " f first rotation axis is repeated (f == 1)\n" " or not repeated (f == 0)\n") .def("setOrder", &eulerSetOrder, "e.setOrder(o) -- sets the rotation order in e\n" "to o (EULER_XYZ, EULER_XZY, ...)") .def("setXYZVector", &Euler::setXYZVector, "e.setXYZVector(v) -- sets the three rotation\n" "angles in e to v[0], v[1], v[2]") .def("setXYZVector", &setXYZTuple) .def("extract", &extract1, "e.extract(m) -- extracts the rotation component\n" "from 3x3 matrix m and stores the result in e.\n" "Assumes that m does not contain shear or non-\n" "uniform scaling. If necessary, you can fix m\n" "by calling m.removeScalingAndShear().") .def("extract", &extract2, "e.extract(m) -- extracts the rotation component\n" "from 4x4 matrix m and stores the result in e.\n" "Assumes that m does not contain shear or non-\n" "uniform scaling. If necessary, you can fix m\n" "by calling m.removeScalingAndShear().") .def("extract", &extract3, "e.extract(q) -- extracts the rotation component\n" "from quaternion q and stores the result in e") .def("toMatrix33", &toMatrix33, "e.toMatrix33() -- converts e into a 3x3 matrix\n") .def("toMatrix44", &toMatrix44, "e.toMatrix44() -- converts e into a 4x4 matrix\n") .def("toQuat", &toQuat, "e.toQuat() -- converts e into a quaternion\n") .def("toXYZVector", &toXYZVector, "e.toXYZVector() -- converts e into an XYZ\n" "rotation vector") .def("__str__", &Euler_str) .def("__repr__", &Euler_repr) .def("__eq__", &equal) .def("__ne__", ¬equal) ; // fill in the Euler scope { scope euler_scope(euler_class); enum_::Order> euler_order("Order"); euler_order .value("XYZ",Euler::XYZ) .value("XZY",Euler::XZY) .value("YZX",Euler::YZX) .value("YXZ",Euler::YXZ) .value("ZXY",Euler::ZXY) .value("ZYX",Euler::ZYX) .value("XZX",Euler::XZX) .value("XYX",Euler::XYX) .value("YXY",Euler::YXY) .value("YZY",Euler::YZY) .value("ZYZ",Euler::ZYZ) .value("ZXZ",Euler::ZXZ) .value("XYZr",Euler::XYZr) .value("XZYr",Euler::XZYr) .value("YZXr",Euler::YZXr) .value("YXZr",Euler::YXZr) .value("ZXYr",Euler::ZXYr) .value("ZYXr",Euler::ZYXr) .value("XZXr",Euler::XZXr) .value("XYXr",Euler::XYXr) .value("YXYr",Euler::YXYr) .value("YZYr",Euler::YZYr) .value("ZYZr",Euler::ZYZr) .value("ZXZr",Euler::ZXZr) // don't export these, they're not really part of the public interface //.value("Legal",Euler::Legal) //.value("Min",Euler::Min) //.value("Max",Euler::Max) // handle Default seperately since boost sets up a 1-1 mapping for enum values //.value("Default",Euler::Default) .export_values() ; // just set it to the XYZ value manually euler_scope.attr("Default") = euler_scope.attr("XYZ"); enum_::Axis>("Axis") .value("X",Euler::X) .value("Y",Euler::Y) .value("Z",Euler::Z) .export_values() ; enum_::InputLayout>("InputLayout") .value("XYZLayout",Euler::XYZLayout) .value("IJKLayout",Euler::IJKLayout) .export_values() ; } decoratecopy(euler_class); return euler_class; } // XXX fixme - template this // really this should get generated automatically... /* template static FixedArray EulerArray_get(FixedArray > &qa) { return FixedArray( &(qa[0].r)+index, qa.len(), 4*qa.stride()); } */ template static FixedArray > * EulerArray_eulerConstructor7a(const FixedArray > &q) { MATH_EXC_ON; size_t len = q.len(); FixedArray >* result = new FixedArray >(len); for (size_t i = 0; i < len; ++i) { (*result)[i].extract(q[i]); } return result; } template static FixedArray > * EulerArray_eulerConstructor8a(const FixedArray >& v) { MATH_EXC_ON; size_t len = v.len(); FixedArray >* result = new FixedArray >(len); for (size_t i = 0; i < len; ++i) (*result)[i] = Euler(v[i]); return result; } template static FixedArray > * EulerArray_eulerConstructor9a(const FixedArray >& v, typename IMATH_NAMESPACE::Eulerf::Order order) { MATH_EXC_ON; size_t len = v.len(); FixedArray >* result = new FixedArray >(len); typename Euler::Order o = interpretOrder(order); for (size_t i = 0; i < len; ++i) (*result)[i] = Euler(v[i], o); return result; } template static FixedArray > EulerArray_toXYZVector(const FixedArray >& e) { MATH_EXC_ON; size_t len = e.len(); FixedArray > result(len, UNINITIALIZED); for (size_t i = 0; i < len; ++i) result[i] = e[i].toXYZVector(); return result; } template static FixedArray > EulerArray_toQuat(const FixedArray >& e) { MATH_EXC_ON; size_t len = e.len(); FixedArray > result(len, UNINITIALIZED); for (size_t i = 0; i < len; ++i) result[i] = e[i].toQuat(); return result; } template class_ > > register_EulerArray() { class_ > > eulerArray_class = FixedArray >::register_("Fixed length array of IMATH_NAMESPACE::Euler"); eulerArray_class //.add_property("x",&EulerArray_get) //.add_property("y",&EulerArray_get) //.add_property("z",&EulerArray_get) .def("__init__", make_constructor(EulerArray_eulerConstructor7a)) .def("__init__", make_constructor(EulerArray_eulerConstructor8a)) .def("__init__", make_constructor(EulerArray_eulerConstructor9a)) .def("toXYZVector", EulerArray_toXYZVector) .def("toQuat", EulerArray_toQuat) ; add_comparison_functions(eulerArray_class); PyImath::add_explicit_construction_from_type >(eulerArray_class); PyImath::add_explicit_construction_from_type >(eulerArray_class); return eulerArray_class; } template PYIMATH_EXPORT class_,bases > > register_Euler(); template PYIMATH_EXPORT class_,bases > > register_Euler(); template PYIMATH_EXPORT class_ > > register_EulerArray(); template PYIMATH_EXPORT class_ > > register_EulerArray(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Euler FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Euler(); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Euler FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Euler(); } } // namespace PyImath Imath-3.1.4/src/python/PyImath/PyImathEuler.h000066400000000000000000000044651417213455000210000ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathEuler_h_ #define _PyImathEuler_h_ #include #include #include #include #include "PyImath.h" namespace PyImath { template boost::python::class_,boost::python::bases > > register_Euler(); template boost::python::class_ > > register_EulerArray(); typedef FixedArray EulerfArray; typedef FixedArray EulerdArray; // // Other code in the Zeno code base assumes the existance of a class with the // same name as the Imath class, and with static functions wrap() and // convert() to produce a PyImath object from an Imath object and vice-versa, // respectively. The class Boost generates from the Imath class does not // have these properties, so we define a companion class here. // The template argument, T, is the element type for the axis vector // (e.g.,float, double). template class E { public: static PyObject * wrap (const IMATH_NAMESPACE::Euler &e); static int convert (PyObject *p, IMATH_NAMESPACE::Euler *v); }; template PyObject * E::wrap (const IMATH_NAMESPACE::Euler &e) { typename boost::python::return_by_value::apply < IMATH_NAMESPACE::Euler >::type converter; PyObject *p = converter (e); return p; } template int E::convert (PyObject *p, IMATH_NAMESPACE::Euler *v) { boost::python::extract extractorEf (p); if (extractorEf.check()) { IMATH_NAMESPACE::Eulerf e = extractorEf(); v->x = T(e.x); v->y = T(e.y); v->z = T(e.z); v->setOrder (typename IMATH_NAMESPACE::Euler::Order (e.order())); return 1; } boost::python::extract extractorEd (p); if (extractorEd.check()) { IMATH_NAMESPACE::Eulerd e = extractorEd(); v->x = T(e.x); v->y = T(e.y); v->z = T(e.z); v->setOrder (typename IMATH_NAMESPACE::Euler::Order (e.order())); return 1; } return 0; } typedef E Eulerf; typedef E Eulerd; } #endif Imath-3.1.4/src/python/PyImath/PyImathExport.h000066400000000000000000000013071417213455000211750ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef PYIMATHEXPORT_H #define PYIMATHEXPORT_H #if defined(IMATH_DLL) #if defined(PLATFORM_VISIBILITY_AVAILABLE) #define PYIMATH_EXPORT __attribute__((visibility("default"))) #define PYIMATH_EXPORT __attribute__((visibility("default"))) #elif defined(_MSC_VER) #if defined(PYIMATH_BUILD) #define PYIMATH_EXPORT __declspec(dllexport) #else #define PYIMATH_EXPORT __declspec(dllimport) #endif #else #define PYIMATH_EXPORT #endif #else #define PYIMATH_EXPORT #endif #endif // #ifndef PYIMATHEXPORT_H Imath-3.1.4/src/python/PyImath/PyImathFixedArray.cpp000066400000000000000000000021761417213455000223120ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include "PyImathFixedArray.h" #include "PyImathExport.h" namespace PyImath { template <> PYIMATH_EXPORT bool FixedArrayDefaultValue::value() { return false; } template <> PYIMATH_EXPORT signed char FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT unsigned char FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT short FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT unsigned short FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT int FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT int64_t FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT unsigned int FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT float FixedArrayDefaultValue::value() { return 0; } template <> PYIMATH_EXPORT double FixedArrayDefaultValue::value() { return 0; } //int alloc_count = 0; } Imath-3.1.4/src/python/PyImath/PyImathFixedArray.h000066400000000000000000000664121417213455000217620ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathFixedArray_h_ #define _PyImathFixedArray_h_ #include #include #include #include #include #include "PyImathUtil.h" // // Note: when PyImath from the v2 release of OpenEXR depended on Iex, // the PY_IMATH_LEAVE/RETURN_PYTHON macros bracketed calls that // enabled/disabled float-point exceptions via via the MathExcOn // class. This was a compile-time option based on the setting of // PYIMATH_ENABLE_EXCEPTIONS. This behavior is now deprecated, hence // the empty macros. // #define PY_IMATH_LEAVE_PYTHON PyImath::PyReleaseLock pyunlock; #define PY_IMATH_RETURN_PYTHON namespace PyImath { namespace { // // Utility classes used for converting array members to boost python objects. // template struct ReturnReference { static boost::python::object applyReadOnly (const T& val) { typename boost::python::copy_const_reference::apply::type converter; return boost::python::object(boost::python::handle<>(converter(val))); } static boost::python::object applyWritable (T& val) { typename boost::python::reference_existing_object::apply::type converter; return boost::python::object(boost::python::handle<>(converter(val))); } static bool isReferenceWrap () { return true; } }; template struct ReturnByValue { static boost::python::object applyReadOnly (const T& val) { typename boost::python::return_by_value::apply::type converter; return boost::python::object(boost::python::handle<>(converter(val))); } static boost::python::object applyWritable (T& val) { return applyReadOnly (val); } static bool isReferenceWrap () { return false; } }; } // namespace // // Utility class for a runtime-specified fixed length array type in python // template struct FixedArrayDefaultValue { static T value(); }; enum Uninitialized {UNINITIALIZED}; template class FixedArray { T * _ptr; size_t _length; size_t _stride; bool _writable; // this handle optionally stores a shared_array to allocated array data // so that everything is freed properly on exit. boost::any _handle; boost::shared_array _indices; // non-NULL iff I'm a masked reference size_t _unmaskedLength; public: typedef T BaseType; FixedArray(T *ptr, Py_ssize_t length, Py_ssize_t stride = 1, bool writable = true) : _ptr(ptr), _length(length), _stride(stride), _writable(writable), _handle(), _unmaskedLength(0) { if (length < 0) { throw std::domain_error ("Fixed array length must be non-negative"); } if (stride <= 0) { throw std::domain_error ("Fixed array stride must be positive"); } // nothing } FixedArray(T *ptr, Py_ssize_t length, Py_ssize_t stride, boost::any handle, bool writable = true) : _ptr(ptr), _length(length), _stride(stride), _writable(writable), _handle(handle), _unmaskedLength(0) { if (_length < 0) { throw std::domain_error("Fixed array length must be non-negative"); } if (stride <= 0) { throw std::domain_error("Fixed array stride must be positive"); } // nothing } FixedArray(const T *ptr, Py_ssize_t length, Py_ssize_t stride = 1) : _ptr(const_cast(ptr)), _length(length), _stride(stride), _writable(false), _handle(), _unmaskedLength(0) { if (length < 0) { throw std::logic_error("Fixed array length must be non-negative"); } if (stride <= 0) { throw std::logic_error("Fixed array stride must be positive"); } // nothing } FixedArray(const T *ptr, Py_ssize_t length, Py_ssize_t stride, boost::any handle) : _ptr(const_cast(ptr)), _length(length), _stride(stride), _writable(false), _handle(handle), _unmaskedLength(0) { if (_length < 0) { throw std::logic_error("Fixed array length must be non-negative"); } if (stride <= 0) { throw std::logic_error("Fixed array stride must be positive"); } // nothing } explicit FixedArray(Py_ssize_t length) : _ptr(0), _length(length), _stride(1), _writable(true), _handle(), _unmaskedLength(0) { if (_length < 0) { throw std::domain_error("Fixed array length must be non-negative"); } boost::shared_array a(new T[length]); T tmp = FixedArrayDefaultValue::value(); for (Py_ssize_t i=0; i a(new T[length]); _handle = a; _ptr = a.get(); } FixedArray(const T &initialValue, Py_ssize_t length) : _ptr(0), _length(length), _stride(1), _writable(true), _handle(), _unmaskedLength(0) { if (_length < 0) { throw std::domain_error("Fixed array length must be non-negative"); } boost::shared_array a(new T[length]); for (Py_ssize_t i=0; i FixedArray(FixedArray& f, const MaskArrayType& mask) : _ptr(f._ptr), _stride(f._stride), _writable(f._writable), _handle(f._handle), _unmaskedLength(0) { if (f.isMaskedReference()) { throw std::invalid_argument("Masking an already-masked FixedArray not supported yet (SQ27000)"); } size_t len = f.match_dimension(mask); _unmaskedLength = len; size_t reduced_len = 0; for (size_t i = 0; i < len; ++i) if (mask[i]) reduced_len++; _indices.reset(new size_t[reduced_len]); for (size_t i = 0, j = 0; i < len; ++i) { if (mask[i]) { _indices[j] = i; j++; } } _length = reduced_len; } template FixedArray(const FixedArray& f, const MaskArrayType& mask) : _ptr(f._ptr), _stride(f._stride), _writable(false), _handle(f._handle), _unmaskedLength(0) { if (f.isMaskedReference()) { throw std::invalid_argument("Masking an already-masked FixedArray not supported yet (SQ27000)"); } size_t len = f.match_dimension(mask); _unmaskedLength = len; size_t reduced_len = 0; for (size_t i = 0; i < len; ++i) if (mask[i]) reduced_len++; _indices.reset(new size_t[reduced_len]); for (size_t i = 0, j = 0; i < len; ++i) { if (mask[i]) { _indices[j] = i; j++; } } _length = reduced_len; } template explicit FixedArray(const FixedArray &other) : _ptr(0), _length(other.len()), _stride(1), _writable(true), _handle(), _unmaskedLength(other.unmaskedLength()) { boost::shared_array a(new T[_length]); for (size_t i=0; i<_length; ++i) a[i] = T(other[i]); _handle = a; _ptr = a.get(); if (_unmaskedLength) { _indices.reset(new size_t[_length]); for (size_t i = 0; i < _length; ++i) _indices[i] = other.raw_ptr_index(i); } } FixedArray(const FixedArray &other) : _ptr(other._ptr), _length(other._length), _stride(other._stride), _writable(other._writable), _handle(other._handle), _indices(other._indices), _unmaskedLength(other._unmaskedLength) { } const FixedArray & operator = (const FixedArray &other) { if (&other == this) return *this; _ptr = other._ptr; _length = other._length; _stride = other._stride; _writable = other._writable; _handle = other._handle; _unmaskedLength = other._unmaskedLength; _indices = other._indices; return *this; } ~FixedArray() { // nothing } explicit operator bool() const {return _ptr != nullptr;} const boost::any & handle() { return _handle; } // // Make an index suitable for indexing into an array in c++ from // a python index, which can be negative for indexing relative to // the end of an array // size_t canonical_index(Py_ssize_t index) const { if (index < 0) index += len(); if (index >= len() || index < 0) { PyErr_SetString(PyExc_IndexError, "Index out of range"); boost::python::throw_error_already_set(); } return index; // still a virtual index if this is a masked reference array } void extract_slice_indices(PyObject *index, size_t &start, size_t &end, Py_ssize_t &step, size_t &slicelength) const { if (PySlice_Check(index)) { #if PY_MAJOR_VERSION > 2 PyObject *slice = index; #else PySliceObject *slice = reinterpret_cast(index); #endif Py_ssize_t s,e,sl; if (PySlice_GetIndicesEx(slice,_length,&s,&e,&step,&sl) == -1) { boost::python::throw_error_already_set(); } // e can be -1 if the iteration is backwards with a negative slice operator [::-n] (n > 0). if (s < 0 || e < -1 || sl < 0) { throw std::domain_error("Slice extraction produced invalid start, end, or length indices"); } start = s; end = e; slicelength = sl; } else if (PyInt_Check(index)) { size_t i = canonical_index(PyInt_AsSsize_t(index)); start = i; end = i+1; step = 1; slicelength = 1; } else { PyErr_SetString(PyExc_TypeError, "Object is not a slice"); boost::python::throw_error_already_set(); } } // Although this method isn't used directly by this class, // there are some sub-classes that are using it. typedef typename boost::mpl::if_, T&,T>::type get_type; get_type getitem(Py_ssize_t index) { return (*this)[canonical_index(index)]; } typedef typename boost::mpl::if_,const T&,T>::type get_type_const; get_type_const getitem(Py_ssize_t index) const { return (*this)[canonical_index(index)]; } // We return an internal reference for class-types and a copy of the data // for non-class types. Returning an internal refeference doesn't seem // to work with non-class types. boost::python::object getobjectTuple (Py_ssize_t index) { typedef typename boost::mpl::if_, ReturnReference, ReturnByValue >::type convertType; boost::python::object retval; int referenceMode = 0; const size_t i = canonical_index(index); T& val = _ptr[(isMaskedReference() ? raw_ptr_index(i) : i) * _stride]; if (_writable) { retval = convertType::applyWritable (val); if (convertType::isReferenceWrap()) referenceMode = 0; // Managed reference. else referenceMode = 2; // Default policy (return-by-value) } else { retval = convertType::applyReadOnly (val); if (convertType::isReferenceWrap()) referenceMode = 1; // Copy const reference else referenceMode = 2; // Default policy (return-by-value) } return boost::python::make_tuple (referenceMode, retval); } boost::python::object getobjectTuple (Py_ssize_t index) const { typedef typename boost::mpl::if_, ReturnReference, ReturnByValue >::type convertType; boost::python::object retval; int referenceMode = 1; const size_t i = canonical_index(index); const T& val = _ptr[(isMaskedReference() ? raw_ptr_index(i) : i) * _stride]; retval = convertType::applyReadOnly (val); if (convertType::isReferenceWrap()) referenceMode = 1; // Copy const reference else referenceMode = 2; // Default policy (return-by-value) return boost::python::make_tuple (referenceMode, retval); } FixedArray getslice(::PyObject *index) const { size_t start=0, end=0, slicelength=0; Py_ssize_t step; extract_slice_indices(index,start,end,step,slicelength); FixedArray f(slicelength); if (isMaskedReference()) { for (size_t i=0; i FixedArray getslice_mask(const MaskArrayType& mask) { // 'writable' state is preserved in the returned fixed-array. FixedArray f(*this, mask); return f; } void setitem_scalar(PyObject *index, const T &data) { if (!_writable) throw std::invalid_argument("Fixed array is read-only."); size_t start=0, end=0, slicelength=0; Py_ssize_t step; extract_slice_indices(index,start,end,step,slicelength); if (isMaskedReference()) { for (size_t i=0; i void setitem_scalar_mask(const MaskArrayType &mask, const T &data) { if (!_writable) throw std::invalid_argument("Fixed array is read-only."); size_t len = match_dimension(mask, false); if (isMaskedReference()) { for (size_t i = 0; i < len; ++i) _ptr[raw_ptr_index(i)*_stride] = data; } else { for (size_t i=0; i void setitem_vector(::PyObject *index, const ArrayType &data) { if (!_writable) throw std::invalid_argument("Fixed array is read-only."); size_t start=0, end=0, slicelength=0; Py_ssize_t step; extract_slice_indices(index,start,end,step,slicelength); // we have a valid range of indices if ((size_t)data.len() != slicelength) { PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination"); boost::python::throw_error_already_set(); } if (isMaskedReference()) { for (size_t i=0; i void setitem_vector_mask(const MaskArrayType &mask, const ArrayType &data) { if (!_writable) throw std::invalid_argument("Fixed array is read-only."); // We could relax this but this restriction if there's a good // enough reason too. if (isMaskedReference()) { throw std::invalid_argument("We don't support setting item masks for masked reference arrays."); } size_t len = match_dimension(mask); if ((size_t)data.len() == len) { for (size_t i = 0; i < len; ++i) if (mask[i]) _ptr[i*_stride] = data[i]; } else { size_t count = 0; for (size_t i = 0; i < len; ++i) if (mask[i]) count++; if (data.len() != count) { throw std::invalid_argument("Dimensions of source data do not match destination either masked or unmasked"); } Py_ssize_t dataIndex = 0; for (size_t i = 0; i < len; ++i) { if (mask[i]) { _ptr[i*_stride] = data[dataIndex]; dataIndex++; } } } } // exposed as Py_ssize_t for compatilbity with standard python sequences Py_ssize_t len() const { return _length; } size_t stride() const { return _stride; } bool writable() const { return _writable; } // This method is mainly here for use in confidence tests, but there may // be other use-cases where a writable array needs to be made read-only. // Note that we do not provide a 'makeWritable' method here, because that // type of operation shouldn't be allowed. void makeReadOnly() { _writable = false; } // no bounds checking on i! T& operator [] (size_t i) { if (!_writable) throw std::invalid_argument("Fixed array is read-only."); return _ptr[(isMaskedReference() ? raw_ptr_index(i) : i) * _stride]; } // no bounds checking on i! const T& operator [] (size_t i) const { return _ptr[(isMaskedReference() ? raw_ptr_index(i) : i) * _stride]; } // no mask conversion or bounds checking on i! T& direct_index(size_t i) { if (!_writable) throw std::invalid_argument("Fixed array is read-only."); return _ptr[i*_stride]; } // no mask conversion or bounds checking on i! const T& direct_index (size_t i) const { return _ptr[i*_stride]; } // In some cases, an access to the raw data without the 'writable' check // is needed. Generally in specialized python-wrapping helpers. T& unchecked_index (size_t i) { return _ptr[(isMaskedReference() ? raw_ptr_index(i) : i) * _stride]; } T& unchecked_direct_index (size_t i) { return _ptr[i*_stride]; } bool isMaskedReference() const {return _indices.get() != 0;} size_t unmaskedLength() const {return _unmaskedLength;} // Conversion of indices to raw pointer indices. // This should only be called when this is a masked reference. // No safety checks done for performance. size_t raw_ptr_index(size_t i) const { assert(isMaskedReference()); assert(i < _length); assert(_indices[i] >= 0 && _indices[i] < _unmaskedLength); return _indices[i]; } static boost::python::class_ > register_(const char *doc) { // Depending on the data-type (class or fundamental) and the writable // state of the array, different forms are returned by the '__getitem__' // method. If writable and a class, an internal reference to the data // is returned so that its value can be changed. If not-writable or a // fundemental data type (float, int, etc.), then a 'copy' of the data // is returned. typename boost::python::object (FixedArray::*nonconst_getobject)(Py_ssize_t) = &FixedArray::getobjectTuple; typename boost::python::object (FixedArray:: *const_getobject)(Py_ssize_t) const = &FixedArray::getobjectTuple; boost::python::class_ > c(name(),doc, boost::python::init("construct an array of the specified length initialized to the default value for the type")); c .def(boost::python::init &>("construct an array with the same values as the given array")) .def(boost::python::init("construct an array of the specified length initialized to the specified default value")) .def("__getitem__", &FixedArray::getslice) .def("__getitem__", &FixedArray::getslice_mask > ) .def("__getitem__", const_getobject, selectable_postcall_policy_from_tuple< boost::python::with_custodian_and_ward_postcall<0,1>, boost::python::return_value_policy, boost::python::default_call_policies>()) .def("__getitem__", nonconst_getobject, selectable_postcall_policy_from_tuple< boost::python::with_custodian_and_ward_postcall<0,1>, boost::python::return_value_policy, boost::python::default_call_policies>()) .def("__setitem__", &FixedArray::setitem_scalar) .def("__setitem__", &FixedArray::setitem_scalar_mask >) .def("__setitem__", &FixedArray::setitem_vector >) .def("__setitem__", &FixedArray::setitem_vector_mask, FixedArray >) .def("__len__",&FixedArray::len) .def("writable",&FixedArray::writable) .def("makeReadOnly", &FixedArray::makeReadOnly) .def("ifelse",&FixedArray::ifelse_scalar) .def("ifelse",&FixedArray::ifelse_vector) ; return c; } template size_t match_dimension(const ArrayType &a1, bool strictComparison = true) const { if (len() == a1.len()) return len(); bool throwExc = false; if (strictComparison) throwExc = true; else if (isMaskedReference()) { if (_unmaskedLength != a1.len()) throwExc = true; } else throwExc = true; if (throwExc) { throw std::invalid_argument("Dimensions of source do not match destination"); } return len(); } FixedArray ifelse_vector(const FixedArray &choice, const FixedArray &other) { size_t len = match_dimension(choice); match_dimension(other); FixedArray tmp(len); // should use default construction but V3f doens't initialize for (size_t i=0; i < len; ++i) tmp[i] = choice[i] ? (*this)[i] : other[i]; return tmp; } FixedArray ifelse_scalar(const FixedArray &choice, const T &other) { size_t len = match_dimension(choice); FixedArray tmp(len); // should use default construction but V3f doens't initialize for (size_t i=0; i < len; ++i) tmp[i] = choice[i] ? (*this)[i] : other; return tmp; } // Instantiations of fixed ararys must implement this static member static const char *name(); // Various 'Accessor' classes used in performance-critical areas while also // managing the writable/read-only state efficiently. class ReadOnlyDirectAccess { public: ReadOnlyDirectAccess (const FixedArray& array) : _ptr (array._ptr), _stride (array._stride) { if (array.isMaskedReference()) throw std::invalid_argument ("Fixed array is masked. ReadOnlyDirectAccess not granted."); } ReadOnlyDirectAccess (const ReadOnlyDirectAccess& other) : _ptr (other._ptr), _stride (other._stride) {} const T& operator[] (size_t i) const { return _ptr[i*_stride]; } private: const T* _ptr; protected: const size_t _stride; }; class WritableDirectAccess : public ReadOnlyDirectAccess { public: WritableDirectAccess (FixedArray& array) : ReadOnlyDirectAccess (array), _ptr (array._ptr) { if (!array.writable()) throw std::invalid_argument ("Fixed array is read-only. WritableDirectAccess not granted."); } WritableDirectAccess (const WritableDirectAccess& other) : ReadOnlyDirectAccess (other), _ptr (other._ptr) {} T& operator[] (size_t i) { return _ptr[i*_stride]; } private: T* _ptr; using ReadOnlyDirectAccess::_stride; }; // class ReadOnlyMaskedAccess { public: ReadOnlyMaskedAccess (const FixedArray& array) : _ptr (array._ptr), _stride (array._stride), _indices (array._indices) { if (!array.isMaskedReference()) throw std::invalid_argument ("Fixed array is not masked. ReadOnlyMaskedAccess not granted."); } ReadOnlyMaskedAccess (const ReadOnlyMaskedAccess& other) : _ptr (other._ptr), _stride (other._stride), _indices (other._indices) {} // No index-range check here. const T& operator[] (size_t i) const { return _ptr[_indices[i]*_stride]; } private: const T* _ptr; protected: const size_t _stride; boost::shared_array _indices; }; class WritableMaskedAccess : public ReadOnlyMaskedAccess { public: WritableMaskedAccess (FixedArray& array) : ReadOnlyMaskedAccess (array), _ptr (array._ptr) { if (!array.writable()) std::invalid_argument ("Fixed array is read-only. WritableMaskedAccess not granted."); } WritableMaskedAccess (const WritableMaskedAccess& other) : ReadOnlyMaskedAccess (other), _ptr (other._ptr) {} // No index-range check here. T& operator[] (size_t i) { return _ptr[_indices[i]*_stride]; } private: T* _ptr; using ReadOnlyMaskedAccess::_stride; using ReadOnlyMaskedAccess::_indices; }; }; // // Helper struct for arary indexing with a known compile time length // template struct IndexAccessDefault { typedef Data & result_type; static Data & apply(Container &c, size_t i) { return c[i]; } }; template > struct StaticFixedArray { static Py_ssize_t len(const Container &) { return Length; } static typename IndexAccess::result_type getitem(Container &c, Py_ssize_t index) { return IndexAccess::apply(c,canonical_index(index)); } static void setitem(Container &c, Py_ssize_t index, const Data &data) { IndexAccess::apply(c,canonical_index(index)) = data; } static size_t canonical_index(Py_ssize_t index) { if (index < 0) index += Length; if (index < 0 || index >= Length) { PyErr_SetString(PyExc_IndexError, "Index out of range"); boost::python::throw_error_already_set(); } return index; } }; } #endif // _PyImathFixedArray_h_ Imath-3.1.4/src/python/PyImath/PyImathFixedArray2D.h000066400000000000000000001126551417213455000221510ustar00rootroot00000000000000// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #ifndef _PyImathFixedArray2D_h_ #define _PyImathFixedArray2D_h_ #include #include #include #include #include #include #include "PyImathFixedArray.h" #include "PyImathOperators.h" namespace PyImath { template class FixedArray2D { T * _ptr; IMATH_NAMESPACE::Vec2 _length; IMATH_NAMESPACE::Vec2 _stride; size_t _size; //flattened size of the array // this handle optionally stores a shared_array to allocated array data // so that everything is freed properly on exit. boost::any _handle; public: FixedArray2D(T *ptr, Py_ssize_t lengthX, Py_ssize_t lengthY, Py_ssize_t strideX = 1) : _ptr(ptr), _length(lengthX, lengthY), _stride(strideX, lengthX), _handle() { if (lengthX < 0 || lengthY < 0) throw std::domain_error("Fixed array 2d lengths must be non-negative"); if (strideX <= 0) throw std::domain_error("Fixed array 2d strides must be positive"); initializeSize(); //std::cout << "fixed array external construct" << std::endl; // nothing } FixedArray2D(T *ptr, Py_ssize_t lengthX, Py_ssize_t lengthY, Py_ssize_t strideX, Py_ssize_t strideY) : _ptr(ptr), _length(lengthX, lengthY), _stride(strideX, strideY), _handle() { if (lengthX < 0 || lengthY < 0) throw std::domain_error("Fixed array 2d lengths must be non-negative"); if (strideX <= 0 || strideY < 0) throw std::domain_error("Fixed array 2d strides must be positive"); initializeSize(); //std::cout << "fixed array external construct" << std::endl; // nothing } FixedArray2D(T *ptr, Py_ssize_t lengthX, Py_ssize_t lengthY, Py_ssize_t strideX, Py_ssize_t strideY, boost::any handle) : _ptr(ptr), _length(lengthX, lengthY), _stride(strideX, strideY), _handle(handle) { initializeSize(); //std::cout << "fixed array external construct with handle" << std::endl; // nothing } explicit FixedArray2D(Py_ssize_t lengthX, Py_ssize_t lengthY) : _ptr(0), _length(lengthX, lengthY), _stride(1, lengthX), _handle() { if (lengthX < 0 || lengthY < 0) throw std::domain_error("Fixed array 2d lengths must be non-negative"); initializeSize(); T tmp = FixedArrayDefaultValue::value(); boost::shared_array a(new T[_size]); for (size_t i=0; i<_size; ++i) a[i] = tmp; _handle = a; _ptr = a.get(); } explicit FixedArray2D(const IMATH_NAMESPACE::V2i& length) : _ptr(0), _length(length), _stride(1, length.x), _handle() { if (length.x < 0 || length.y < 0) throw std::domain_error("Fixed array 2d lengths must be non-negative"); initializeSize(); T tmp = FixedArrayDefaultValue::value(); boost::shared_array a(new T[_size]); for (size_t i=0; i<_size; ++i) a[i] = tmp; _handle = a; _ptr = a.get(); } FixedArray2D(const T &initialValue, Py_ssize_t lengthX, Py_ssize_t lengthY) : _ptr(0), _length(lengthX, lengthY), _stride(1, lengthX), _handle() { if (lengthX < 0 || lengthY < 0) throw std::domain_error("Fixed array 2d lengths must be non-negative"); initializeSize(); boost::shared_array a(new T[_size]); for (size_t i=0; i<_size; ++i) a[i] = initialValue; _handle = a; _ptr = a.get(); } void initializeSize() { _size = _length.x*_length.y; } template explicit FixedArray2D(const FixedArray2D &other) : _ptr(0), _length(other.len()), _stride(1, other.len().x), _handle() { initializeSize(); boost::shared_array a(new T[_size]); size_t z = 0; for (size_t j = 0; j < _length.y; ++j) for (size_t i = 0; i < _length.x; ++i) a[z++] = T(other(i,j)); _handle = a; _ptr = a.get(); } FixedArray2D(const FixedArray2D &other) : _ptr(other._ptr), _length(other._length), _stride(other._stride), _size(other._size), _handle(other._handle) { //std::cout << "fixed array copy consturct construct" << std::endl; // nothing } const FixedArray2D & operator = (const FixedArray2D &other) { if (&other == this) return *this; //std::cout << "fixed array assign" << std::endl; _ptr = other._ptr; _length = other._length; _stride = other._stride; _handle = other._handle; _size = _length.x*_length.y; return *this; } ~FixedArray2D() { //std::cout << "fixed array delete" << std::endl; } const boost::any & handle() { return _handle; } size_t canonical_index(Py_ssize_t index, size_t length) const { if (index < 0) index += length; if ((size_t) index >= length || index < 0) { PyErr_SetString(PyExc_IndexError, "Index out of range"); boost::python::throw_error_already_set(); } return index; } void extract_slice_indices(PyObject *index, size_t length, size_t &start, size_t &end, Py_ssize_t &step, size_t &slicelength) const { if (PySlice_Check(index)) { #if PY_MAJOR_VERSION > 2 PyObject *slice = index; #else PySliceObject *slice = reinterpret_cast(index); #endif Py_ssize_t s, e, sl; if (PySlice_GetIndicesEx(slice,length,&s,&e,&step,&sl) == -1) { boost::python::throw_error_already_set(); } if (s < 0 || e < 0 || sl < 0) { throw std::domain_error("Slice extraction produced invalid start, end, or length indices"); } start = s; end = e; slicelength = sl; } else if (PyInt_Check(index)) { size_t i = canonical_index(PyInt_AsSsize_t(index), length); start = i; end = i+1; step = 1; slicelength = 1; } else { PyErr_SetString(PyExc_TypeError, "Object is not a slice"); boost::python::throw_error_already_set(); } //std::cout << "Slice indices are " << start << " " << end << " " << step << " " << slicelength << std::endl; } // return_internal_reference doesn't seem to work with non-class types typedef typename boost::mpl::if_,T&,T>::type get_type; // get_type getitem(Py_ssize_t index) const { return _ptr[canonical_index(index)*_stride]; } //FIXME: const does not work here with at least IMATH_NAMESPACE::Color4, why it works for V3fArray? get_type getitem(Py_ssize_t i, Py_ssize_t j) //const { return (*this)(canonical_index(i, _length.x), canonical_index(j, _length.y)); } //FIXME: anyway to seperate 2:3,4:5 from 2,4? we'd like to return int for the second one, and also 1d array for 2, 4:5 or 2:3, 4 FixedArray2D getslice(PyObject *index) const { if (PyTuple_Check(index) && PyTuple_Size(index) == 2) { size_t startx=0, endx=0, slicelengthx=0; size_t starty=0, endy=0, slicelengthy=0; Py_ssize_t stepx=0; Py_ssize_t stepy=0; extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx); extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy); FixedArray2D f(slicelengthx, slicelengthy); for (size_t j=0,z=0; j &mask) const { // size_t len = match_dimension(mask); // size_t slicelength = 0; // for (size_t i=0; i len = match_dimension(mask); FixedArray2D f(len); for (size_t j=0; j(index[0]); // Py_ssize_t j = boost::python::extract(index[1]); // (*this)(i,j) = data; // } void setitem_scalar(PyObject *index, const T &data) { if (!PyTuple_Check(index) || PyTuple_Size(index) != 2) { PyErr_SetString(PyExc_TypeError, "Slice syntax error"); boost::python::throw_error_already_set(); } size_t startx=0, endx=0, slicelengthx=0; size_t starty=0, endy=0, slicelengthy=0; Py_ssize_t stepx=0; Py_ssize_t stepy=0; extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx); extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy); for (size_t j=0; j &mask, const T &data) { IMATH_NAMESPACE::Vec2 len = match_dimension(mask); for (size_t j = 0; j < len.y; j++) for (size_t i=0; i(slicelengthx, slicelengthy)) { PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination"); boost::python::throw_error_already_set(); } for (size_t i=0; i &mask, const FixedArray2D &data) { IMATH_NAMESPACE::Vec2 len = match_dimension(mask); if (data.len() == len) { for (size_t j = 0; j < len.y; j++) for (size_t i=0; i &mask, const FixedArray &data) { IMATH_NAMESPACE::Vec2 len = match_dimension(mask); if ((size_t) data.len() == len.x*len.y) { for (size_t j = 0, z = 0; j < len.y; j++) for (size_t i=0; i &data) { //TODO:sanity check size_t startx=0, endx=0, slicelengthx=0; size_t starty=0, endy=0, slicelengthy=0; Py_ssize_t stepx=0; Py_ssize_t stepy=0; extract_slice_indices(PyTuple_GetItem(index, 0),_length.x,startx,endx,stepx,slicelengthx); extract_slice_indices(PyTuple_GetItem(index, 1),_length.y,starty,endy,stepy,slicelengthy); // we have a valid range of indices if ((size_t) data.len() != slicelengthx*slicelengthy) { PyErr_SetString(PyExc_IndexError, "Dimensions of source data do not match destination"); boost::python::throw_error_already_set(); } for (size_t j=0, z=0; j len() const { return _length; } IMATH_NAMESPACE::Vec2 stride() const { return _stride; } T & operator () (size_t i, size_t j) { return _ptr[_stride.x*(j*_stride.y + i)]; } const T & operator () (size_t i, size_t j) const { return _ptr[_stride.x*(j*_stride.y + i)]; } size_t totalLen() const { return _size; } boost::python::tuple size() const { return boost::python::make_tuple(_length.x, _length.y); } static boost::python::class_ > register_(const char *name, const char *doc) { // a little tricky, but here we go - class types return internal references // but fundemental types just get copied. this typedef sets up the appropriate // call policy for each type. typedef typename boost::mpl::if_< boost::is_class, boost::python::return_internal_reference<>, boost::python::default_call_policies>::type call_policy; boost::python::class_ > c(name,doc, boost::python::init( "construct an array of the specified length initialized to the default value for the type")); c .def(boost::python::init &>("construct an array with the same values as the given array")) .def(boost::python::init("construct an array of the specified length initialized to the specified default value")) .def("__getitem__", &FixedArray2D::getslice) .def("__getitem__", &FixedArray2D::getslice_mask) // .def("__getitem__", &FixedArray2D::getitem, call_policy()) .def("item", &FixedArray2D::getitem, call_policy()) // .def("__setitem__", &FixedArray2D::setitem) .def("__setitem__", &FixedArray2D::setitem_scalar) .def("__setitem__", &FixedArray2D::setitem_scalar_mask) .def("__setitem__", &FixedArray2D::setitem_vector) .def("__setitem__", &FixedArray2D::setitem_vector_mask) .def("__setitem__", &FixedArray2D::setitem_array1d) .def("__setitem__", &FixedArray2D::setitem_array1d_mask) .def("__len__",&FixedArray2D::totalLen) .def("size",&FixedArray2D::size) .def("ifelse",&FixedArray2D::ifelse_scalar) .def("ifelse",&FixedArray2D::ifelse_vector) ; return c; } // template // size_t match_dimension(const FixedArray &a1) const // { // if (_length.x != a1.len()) { // PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination"); // boost::python::throw_error_already_set(); // } // return _length.x; // } template IMATH_NAMESPACE::Vec2 match_dimension(const FixedArray2D &a1) const { if (len() != a1.len()) { PyErr_SetString(PyExc_IndexError, "Dimensions of source do not match destination"); boost::python::throw_error_already_set(); } return len(); } FixedArray2D ifelse_vector(const FixedArray2D &choice, const FixedArray2D &other) { IMATH_NAMESPACE::Vec2 len = match_dimension(choice); match_dimension(other); FixedArray2D tmp(len); // should use default construction but V3f doens't initialize for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) tmp(i,j) = choice(i,j) ? (*this)(i,j) : other(i,j); return tmp; } FixedArray2D ifelse_scalar(const FixedArray2D &choice, const T &other) { IMATH_NAMESPACE::Vec2 len = match_dimension(choice); FixedArray2D tmp(len); // should use default construction but V3f doens't initialize for (size_t j = 0; j < len.y; ++j) for (size_t i = 0; i < len.x; ++i) tmp(i,j) = choice(i,j) ? (*this)(i,j) : other; return tmp; } }; // unary operation application template