Repository: penn-graphics-research/claymore Branch: master Commit: 3b19462f1589 Files: 183 Total size: 2.1 MB Directory structure: gitextract_mlo6v1x3/ ├── .clang-format ├── .clang-tidy ├── .gitignore ├── .gitmodules ├── CMake/ │ ├── DownloadProject.CMakeLists.cmake.in │ ├── DownloadProject.LICENSE │ ├── DownloadProject.cmake │ ├── FindWayland.cmake │ └── FindXCB.cmake ├── CMake-Utils/ │ ├── setup_cpp.cmake │ ├── setup_cuda.cmake │ ├── setup_externallibs.cmake │ └── setup_python.cmake ├── CMakeLists.txt ├── Externals/ │ ├── CMakeLists.txt │ ├── SDFGen/ │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── array1.h │ │ ├── array2.h │ │ ├── array3.h │ │ ├── config.h.in │ │ ├── hashgrid.h │ │ ├── hashtable.h │ │ ├── main.cpp │ │ ├── makelevelset3.cpp │ │ ├── makelevelset3.h │ │ ├── util.h │ │ └── vec.h │ ├── function_ref/ │ │ └── tl/ │ │ └── function_ref.hpp │ ├── optional/ │ │ └── tl/ │ │ └── optional.hpp │ ├── partio/ │ │ ├── CMakeLists.txt │ │ ├── Partio.h │ │ ├── PartioAttribute.h │ │ ├── PartioIterator.h │ │ ├── PartioVec3.h │ │ ├── core/ │ │ │ ├── KdTree.h │ │ │ ├── Mutex.h │ │ │ ├── Particle.cpp │ │ │ ├── ParticleCaching.cpp │ │ │ ├── ParticleCaching.h │ │ │ ├── ParticleHeaders.cpp │ │ │ ├── ParticleHeaders.h │ │ │ ├── ParticleSimple.cpp │ │ │ ├── ParticleSimple.h │ │ │ ├── ParticleSimpleInterleave.cpp │ │ │ └── ParticleSimpleInterleave.h │ │ └── io/ │ │ ├── BGEO.cpp │ │ ├── BIN.cpp │ │ ├── GEO.cpp │ │ ├── MC.cpp │ │ ├── PDA.cpp │ │ ├── PDB.cpp │ │ ├── PDC.cpp │ │ ├── PRT.cppbak │ │ ├── PTC.cpp │ │ ├── PTS.cpp │ │ ├── ParticleIO.cpp │ │ ├── PartioEndian.h │ │ ├── RIB.cpp │ │ ├── ZIP.cpp │ │ ├── ZIP.h │ │ ├── half2float.h │ │ ├── pdb.h │ │ └── readers.h │ └── variant/ │ └── mpark/ │ ├── config.hpp │ ├── in_place.hpp │ ├── lib.hpp │ └── variant.hpp ├── LICENSE ├── Library/ │ ├── CMakeLists.txt │ ├── MnBase/ │ │ ├── Algorithm/ │ │ │ ├── MappingKernels.cuh │ │ │ ├── ParallelPatterns.cuh │ │ │ └── SortKernels.cuh │ │ ├── Concurrency/ │ │ │ └── Concurrency.h │ │ ├── DataStructure/ │ │ │ ├── Bvh/ │ │ │ │ └── Bvh.cuh │ │ │ ├── FSM/ │ │ │ │ └── FiniteStateMachine.h │ │ │ └── Hash/ │ │ │ └── Hash.cuh │ │ ├── Geometry/ │ │ │ └── GeometrySampler.h │ │ ├── Math/ │ │ │ ├── Bit/ │ │ │ │ ├── Bits.h │ │ │ │ └── SpatialEncoder.cuh │ │ │ ├── Matrix/ │ │ │ │ ├── EigenDecomposition.cuh │ │ │ │ ├── Givens.cuh │ │ │ │ ├── MatrixKernels.cuh │ │ │ │ ├── MatrixUtils.h │ │ │ │ ├── Utility.h │ │ │ │ ├── qr.cuh │ │ │ │ └── svd.cuh │ │ │ ├── Probability/ │ │ │ │ ├── Probability.cpp │ │ │ │ └── Probability.h │ │ │ └── Vec.h │ │ ├── Memory/ │ │ │ ├── Allocator.h │ │ │ ├── MemObj.h │ │ │ └── MemoryResource.h │ │ ├── Meta/ │ │ │ ├── AllocMeta.cuh │ │ │ ├── ControlFlow.h │ │ │ ├── Functional.h │ │ │ ├── MathMeta.h │ │ │ ├── Meta.h │ │ │ ├── Optional.h │ │ │ ├── PatternMeta.h │ │ │ ├── Polymorphism.h │ │ │ ├── Relationship.h │ │ │ ├── TupleMeta.h │ │ │ ├── TypeDecoration.h │ │ │ ├── TypeIdentity.h │ │ │ ├── TypeMeta.h │ │ │ ├── TypeOperation.h │ │ │ └── TypeProperty.h │ │ ├── Object/ │ │ │ ├── Function.h │ │ │ ├── Property.h │ │ │ ├── Structural.h │ │ │ ├── StructuralAuxiliary.h │ │ │ └── StructuralDeclaration.h │ │ ├── Profile/ │ │ │ ├── CppTimers.hpp │ │ │ └── CudaTimers.cuh │ │ ├── Reflection.h │ │ └── Singleton.h │ └── MnSystem/ │ ├── CMakeLists.txt │ ├── Cuda/ │ │ ├── Allocators.cuh │ │ ├── Cuda.cu │ │ ├── Cuda.h │ │ ├── DeviceUtils.cu │ │ ├── DeviceUtils.cuh │ │ ├── ExecutionPolicy.h │ │ ├── HostUtils.hpp │ │ ├── KernelLauncher.cuh │ │ ├── MemoryUtils.cu │ │ └── MemoryUtils.cuh │ ├── IO/ │ │ ├── IO.cpp │ │ ├── IO.h │ │ ├── ParticleIO.hpp │ │ └── PoissonDisk/ │ │ ├── PoissonDisk.h │ │ ├── SampleGenerator.h │ │ ├── cyCore.h │ │ ├── cyHeap.h │ │ ├── cyPoint.h │ │ ├── cyPointCloud.h │ │ └── cySampleElim.h │ └── sourcelist.cmake ├── Projects/ │ ├── CMakeLists.txt │ ├── GMPM/ │ │ ├── CMakeLists.txt │ │ ├── constitutive_models.cuh │ │ ├── gmpm.cu │ │ ├── gmpm_simulator.cuh │ │ ├── grid_buffer.cuh │ │ ├── hash_table.cuh │ │ ├── mgmpm_kernels.cuh │ │ ├── particle_buffer.cuh │ │ ├── partition_domain.h │ │ ├── scenes/ │ │ │ └── scene.json │ │ ├── settings.h │ │ └── utility_funcs.hpp │ ├── MGSP/ │ │ ├── CMakeLists.txt │ │ ├── boundary_condition.cuh │ │ ├── constitutive_models.cuh │ │ ├── grid_buffer.cuh │ │ ├── halo_buffer.cuh │ │ ├── halo_kernels.cuh │ │ ├── hash_table.cuh │ │ ├── mgmpm_kernels.cuh │ │ ├── mgsp.cu │ │ ├── mgsp_benchmark.cuh │ │ ├── particle_buffer.cuh │ │ ├── partition_domain.h │ │ ├── settings.h │ │ └── utility_funcs.hpp │ └── TaichiScripts/ │ └── gmpm.py ├── README.md ├── docs/ │ ├── benchmark.rst │ ├── compilation.rst │ ├── conf.py │ ├── credits.rst │ ├── datastructure.rst │ ├── index.rst │ ├── multigmpm.rst │ ├── overview.rst │ ├── philosophy.rst │ ├── pipeline.rst │ ├── sparsity.rst │ ├── structural.rst │ ├── system.rst │ └── usage.rst └── project_info.in ================================================ FILE CONTENTS ================================================ ================================================ FILE: .clang-format ================================================ Language: Cpp # Maybe change Standard: Auto # Maybe change BasedOnStyle: Google # Maybe change AlignAfterOpenBracket: BlockIndent # Better overview AlignArrayOfStructures: Right # Better overview (but might make editing harder) AlignConsecutiveAssignments: true # Better overview (but might make editing harder) AlignConsecutiveBitFields: true # Better overview (but might make editing harder) AlignConsecutiveDeclarations: false # Better Overview, as otherwise we would separate a identifier from its type AlignEscapedNewlines: Left # Better Overview AlignOperands: AlignAfterOperator # Better overview AlignTrailingComments: Kind: Always # Better overview AllowAllArgumentsOnNextLine: false # Better overview AllowAllParametersOfDeclarationOnNextLine: false # Better overview AllowShortBlocksOnASingleLine: Empty # Better overview AllowShortCaseLabelsOnASingleLine: false # Better overview AllowShortEnumsOnASingleLine: false # Better overview AllowShortFunctionsOnASingleLine: Empty # Better overview AllowShortIfStatementsOnASingleLine: Never # Better overview AllowShortLambdasOnASingleLine: Empty # Better overview AllowShortLoopsOnASingleLine: false # Better overview AlwaysBreakAfterReturnType: None # Don't produce an unnecessary empty line AlwaysBreakBeforeMultilineStrings: true # Better overview AlwaysBreakTemplateDeclarations: Yes # Better overview BinPackArguments: false # Better overview BinPackParameters: false # Better overview BitFieldColonSpacing: Both # Better overview BraceWrapping: AfterCaseLabel: false # Don't produce an unnecessary empty line AfterClass: false # Don't produce an unnecessary empty line AfterControlStatement: Never # Don't produce an unnecessary empty line AfterEnum: false # Don't produce an unnecessary empty line AfterFunction: false # Don't produce an unnecessary empty line AfterNamespace: false # Don't produce an unnecessary empty line AfterObjCDeclaration: false # Don't produce an unnecessary empty line AfterStruct: false # Don't produce an unnecessary empty line AfterUnion: false # Don't produce an unnecessary empty line AfterExternBlock: false # Don't produce an unnecessary empty line BeforeCatch: false # Don't produce an unnecessary empty line BeforeElse: false # Don't produce an unnecessary empty line BeforeLambdaBody: false # Don't produce an unnecessary empty line BeforeWhile: false # Don't produce an unnecessary empty line IndentBraces: false # Don't produce an unnecessary empty line SplitEmptyFunction: false # Don't produce an unnecessary empty line SplitEmptyRecord: false # Don't produce an unnecessary empty line SplitEmptyNamespace: false # Don't produce an unnecessary empty line BreakAfterAttributes: Never # Don't produce an unnecessary empty line BreakBeforeBinaryOperators: NonAssignment # Allows easier out-commenting of single parts of assignments BreakBeforeBraces: Attach # Don't produce an unnecessary empty line BreakBeforeConceptDeclarations: true # Better overview BreakBeforeTernaryOperators: true # Better overview BreakConstructorInitializers: BeforeComma # Better overview and easier out-commenting of single initializers BreakInheritanceList: BeforeComma # Better overview and easier out-commenting of base classes BreakStringLiterals: false # Avoid config-based wrapping of strings (as it actually depends on the users screen size how wrapping should be applied) ColumnLimit: 1000 # No limit (use high number to enforce removal of existing breaks); Avoid config-based wrapping of strings (as it actually depends on the users screen size how wrapping should be applied) CompactNamespaces: false # Better overview Cpp11BracedListStyle: true # Better overview DeriveLineEnding: false # Formatting should be fixed, not derived DerivePointerAlignment: false # Formatting should be fixed, not derived EmptyLineAfterAccessModifier: Never # Don't produce an unnecessary empty line EmptyLineBeforeAccessModifier: Always # Here empty lines help overview, as they clearly make the current access modifier more visible FixNamespaceComments: true # Better overview IncludeBlocks: Regroup # Better overview IndentAccessModifiers: false # As members will be intended, this separates access modifiers from members more clearly IndentCaseBlocks: false # We don't wrap braces here, so intend would move closing brace out of vertical line IndentCaseLabels: true # Better overview, as it's visible, that case is inside switch IndentExternBlock: Indent # Better overview IndentGotoLabels: true # Better overview, as otherwise e.gt breaks would break out intendation IndentPPDirectives: AfterHash # Better overview, as hash tag still marks post processing, but the directives are intended IndentRequiresClause: false #Intend would break statement out of vertical line IndentWidth: 4 # Make tab indentation work IndentWrappedFunctionNames: true # Better overview, as the breaking of function name is marked InsertBraces: false # Done by clang-tidy #Better overview and maintaining of code, as additional statements can be easily added. WARNING: May break code. Better directly avoid clauses without braces KeepEmptyLinesAtTheStartOfBlocks: false # Remove an unnecessary empty line LambdaBodyIndentation: Signature # Better overview NamespaceIndentation: Inner # Avoid having most of the code intended if we have a big namespace PackConstructorInitializers: Never # Better overview PointerAlignment: Left # Better overview, as star is part of the type QualifierAlignment: Leave # clang-format is not able to handle this without breaking code ReferenceAlignment: Left # Better overview, as ampersand is part of the type ReflowComments: false # I don't know, what clang-format is doing here, but it looks bad: Avoid config-based wrapping of strings (as it actually depends on the users screen size how wrapping should be applied) RequiresClausePosition: OwnLine # Better overview RequiresExpressionIndentation: OuterScope # Better overview SeparateDefinitionBlocks: Leave # Allow user to specify that on his own. May be used to group some blocks together that belong together, while separating other blocks ShortNamespaceLines: 0 # Better overview, as namespaces are clearly marked by closing comment and opening statement SortIncludes: CaseSensitive # Better overview. TODO: Maybe change that if it causes problems SortUsingDeclarations: true # Better overview. TODO: Maybe change that if it causes problems SpaceAfterCStyleCast: true # Better overview SpaceAfterLogicalNot: false # Avoid unnecessary space, cause actually the unary operator belongs to the identifier SpaceAfterTemplateKeyword: false # Space would separate template from it's parameters SpaceAroundPointerQualifiers: Default # Don't known why we should change this. TODO: Reevaluate? SpaceBeforeAssignmentOperators: true # Better overview, as we separate identifier from operator SpaceBeforeCaseColon: false # Avoid unnecessary space SpaceBeforeCpp11BracedList: true # Better overview SpaceBeforeCtorInitializerColon: true # Better overview, as we mark more clearly, where initializer list starts SpaceBeforeInheritanceColon: true # Better overview, as we mark more clearly, where base class list starts SpaceBeforeParens: Never # Avoid unnecessary space SpaceBeforeRangeBasedForLoopColon: false # Avoid unnecessary space SpaceBeforeSquareBrackets: false # Avoid unnecessary space SpaceInEmptyBlock: false # Avoid unnecessary space SpaceInEmptyParentheses: false # Avoid unnecessary space SpacesBeforeTrailingComments: 0 # Avoid unnecessary space SpacesInAngles: Never # Avoid unnecessary space SpacesInCStyleCastParentheses: false # Avoid unnecessary space SpacesInConditionalStatement: false # Avoid unnecessary space SpacesInParentheses: false # Avoid unnecessary space SpacesInSquareBrackets: false # Avoid unnecessary space TabWidth: 4 # Make tab indentation work UseCRLF: true # Better compatibility UseTab: Always # Use tabs where we can ================================================ FILE: .clang-tidy ================================================ # abseil-cleanup-ctad Avoid doubled printing of type # abseil-duration-addition Ensure explicit use of correct duration type # abseil-duration-comparison Ensure explicit use of correct duration type # abseil-duration-conversion-cast Ensure correct cast of durations # abseil-duration-division Ensure explicit use of correct duration division # abseil-duration-factory-float Avoid use of inperformant conversion funnctions # abseil-duration-factory-scale Avoid use of wrong scale conversion funnctions # abseil-duration-subtraction Ensure explicit use of correct duration type # abseil-duration-unnecessary-conversion Avoid unnecessary conversion # abseil-faster-strsplit-delimiter Avoid inperformant use of Strings when Characters are suggested #xabseil-no-internal-dependencies Not used, cause use of internal details is probably intended when found #xabseil-no-namespace Not used, cause use of namespace is probably intended when found # abseil-redundant-strcat-calls Avoid unnecessary function calls # abseil-str-cat-append Avoid concatination when appending is suggested # abseil-string-find-startswith Ensure std::string::startsWith is called instead of find-functions #xabseil-string-find-str-contains Not used, cause it suggests usage of abseil functions instead of standard library functions # abseil-time-comparison Ensure explicit use of time type when comnparing times # abseil-time-subtraction Ensure explicit use of time type #xabseil-upgrade-duration-conversions Not used, as it suggests possibly unwanted casts, which te compiler already warns us about #xaltera-id-dependent-backward-branch Not used, cause it did report at every loop # Avoid inperformant design of loops # altera-kernel-name-restriction Avoid usage of files named similiar to internal API files # altera-single-work-item-barrier Avoid unnecessary use of barriers #xaltera-struct-pack-align Not used, cause we don't want allignment messages for structs nnot used in OpenCL kernels #xaltera-unroll-loops Not used, cause it does not understand expression based unrolls and reports for all code, even code not in kernels # boost-use-to-string Ensure use of standard library functions where possible # bugprone-argument-comment Ensure correct use of argument names in comments # bugprone-assert-side-effect Avoid assertions with side-effects # bugprone-assignment-in-if-condition Avoid assignments in if-conditions # bugprone-bad-signal-to-kill-thread Avoid SIGTERM when attempting to kill a thread # bugprone-bool-pointer-implicit-conversion Avoid implicit conversion from pointer to bool # bugprone-branch-clone Avoid identical branches # bugprone-copy-constructor-init Avoid wrong usage of copy constructors # bugprone-dangling-handle Avoid dangling references # bugprone-dynamic-static-initializers Avoid dynamic initialization of static variables in possibly shared context #xbugprone-easily-swappable-parameters Not used, cause it would require refactoring of API #xbugprone-exception-escape Not used, cause it reported escape were non could take place # Avoid throwing of exceptions where it is not allowed # bugprone-fold-init-type Ensure explicit use of correct type in fold functions # bugprone-forward-declaration-namespace Avoid forward declarations in wrong namespace # bugprone-forwarding-reference-overload Avoid use of perfect forwarding constructor where use of copy or move constructor is suggested # bugprone-implicit-widening-of-multiplication-result Avoid unintended overflow on multiplication # bugprone-inaccurate-erase Ensure correct use of erase functions # bugprone-incorrect-roundings Avoid incorrect rounding of values # bugprone-infinite-loop Avoid infinite loops # bugprone-integer-division Avoid integer division in floating-point context # bugprone-lambda-function-name Avoid printing the name of an unnamed function # bugprone-macro-parentheses Avoid macros that rely on possibly misleading usage of parenthesis #xbugprone-macro-repeated-side-effects Not used, cause I don't know what it does # bugprone-misplaced-operator-in-strlen-in-alloc Avoid probably unintended addition to strings # bugprone-misplaced-pointer-arithmetic-in-alloc Avoid probably unintended addition to pointers # bugprone-misplaced-widening-cast Avoid loss of precision by misplaced casts # bugprone-move-forwarding-reference Ensure forwarding references are forwared not moved # bugprone-multiple-statement-macro Avoid statements from falling out an conditioned block when inserting macros. (NOTE: Should not happen if ifs without braces are avoided) # bugprone-no-escape Ensure pointers marked as noescape do not escape from their scope # bugprone-not-null-terminated-result Avoid strings, that are not null-terminated # bugprone-parent-virtual-call Avoid calls of inherited virtual functions when a call to non-virtual function is suggested # bugprone-posix-return Ensure posix fuinctions returning non-negatiove only do not return negative values # bugprone-redundant-branch-condition Avoid nested if-statements with the same condition a parent has. # bugprone-reserved-identifier Avoid usage of reserved names # bugprone-shared-ptr-array-mismatch Avoid wrong initializationj of shared pointers with arrays # bugprone-signal-handler Ensure correct behaviour of signal handlers # bugprone-signed-char-misuse Ensure correct conversion from signed char to bigger signed integer types # bugprone-sizeof-container Avoid use of sizeof where use of .size() is suggested # bugprone-sizeof-expression Avoid use of sizeof where it is not suggested # bugprone-spuriously-wake-up-functionsp Avoid missed spurious wakeup # bugprone-standalone-empty Avoid use of .empty() where use of .clear() is suggested # bugprone-string-constructor Avoid misuse of string constructors # bugprone-string-integer-assignment Avoid assignments of integers to strings # bugprone-string-literal-with-embedded-nul Avoid unintended use of escaped NUL characters in strings # bugprone-stringview-nullptr Avoid string views of null-pointers # bugprone-suspicious-enum-usage Avoid misuse of enums as integers where not suggested # bugprone-suspicious-include Avoid inclusion of implementation files # bugprone-suspicious-memory-comparison Avoid memory comparison where it seems to be not suggested # bugprone-suspicious-memset-usage Avoid usage of memset in a way probably not suggested # bugprone-suspicious-missing-comma Avoid possibly missing commata # bugprone-suspicious-realloc-usage Ensure that memory does not get lost on failure of realloc # bugprone-suspicious-semicolon Avoid semicolon where it is probably not intended # bugprone-suspicious-string-compare Avoid wrong comparison of the result of a string comparison # bugprone-swapped-arguments Avoid possibly swapped arguments on function calls # bugprone-terminating-continue Avoid continue from being executed in every loop iteration, skipping parts of the loop body # bugprone-throw-keyword-missing Ensure throw-keyword is used when exception might be thrown # bugprone-too-small-loop-variable Ensure loop variables have a type big enough for the loops range # bugprone-unchecked-optional-access Avoid unsafe access to optionals # bugprone-undefined-memory-manipulation Avoid undefined manipulation of memory # bugprone-undelegated-constructor Ensure delegated constructors are correctly called # bugprone-unhandled-exception-at-new Ensure exception is handled on call of new, if not passed to parent function #xbugprone-unhandled-self-assignment Not used, cause it reported even if the special case was handled # Avoid data loss on self assignment # bugprone-unsafe-functions Ensure safe functions are used where available # bugprone-unused-raii Avoid use of RAII where it is not suggested # bugprone-unused-return-value Avoid unused return values # bugprone-use-after-move Avoid usage of an object after it was moved # bugprone-virtual-near-miss Avoid unintended misname of virtual functions in derived classes # cert-dcl50-cpp Avoid c-style variadic functions #xcert-dcl58-cpp Not used, cause use of namespace is probably intended when found # cert-err34-c Avoid unchecked use of string to integer conversion functions # cert-err52-cpp Avoid long jumps # cert-err58-cpp Ensure exceptions in constructors at global space are handled # cert-err60-cpp Ensure throw expressions are nothrow copy constructible #xcert-flp30-c Not used, cause floats in for loops are probably intended when encountered # cert-mem57-cpp Avoid use of default new operator for over-aligned types #xcert-msc50-cpp Not used, cause usage of random number generators is probably intended when encountered #xcert-msc51-cpp Not used, cause usage of random number generators is probably intended when encountered # cert-oop57-cpp Avoid use of memory manipulation functions where a call to an apropriate class function is suggested # cert-oop58-cpp Ensure source object is not modified on copy constructors # concurrency-mt-unsafe Avoid parallel calls to non-threadsafe functions # concurrency-thread-canceltype-asynchronous Ensure pthreads are cancled safely # cppcoreguidelines-avoid-capture-default-when-capturing-this Avoid misleading captures in lambda functions # cppcoreguidelines-avoid-capturing-lambda-coroutines Avoid use of already freed variables in asynchronous lambdas # cppcoreguidelines-avoid-const-or-ref-data-members Ensure const accessors are used instead of const members #xcppcoreguidelines-avoid-do-while Not used, cause do-while loops can also increase readability in some scenarios # cppcoreguidelines-avoid-goto Avoid use of goto # cppcoreguidelines-avoid-non-const-global-variables Avoid global variables, that are not const # cppcoreguidelines-avoid-reference-coroutine-parameters Avoid dangling references by coroutines #xcppcoreguidelines-init-variables Not used, cause it marked valid assignments and compiler already does such checks # cppcoreguidelines-interfaces-global-init Avoid some order-of-initialization problems # cppcoreguidelines-macro-usage Avoid usage of macros where modern language structures are suggested # cppcoreguidelines-narrowing-conversions Avoid silent narrwoing # cppcoreguidelines-no-malloc Avoid usage of c allocation where modern language structures are suggested #xcppcoreguidelines-owning-memory Not used, cause we don't use gsl #xcppcoreguidelines-prefer-member-initializer Not used, cause initialization should happen at constructor. # cppcoreguidelines-pro-bounds-array-to-pointer-decay Avoid usage of pointers as arrays #xcppcoreguidelines-pro-bounds-constant-array-index Not used, cause it did not detect in fact constant ranges (like for loops with constant upper bound) # Avoid out-of-bounds for static arrays # cppcoreguidelines-pro-bounds-pointer-arithmetic Avoid usage of pointer-arithmetic # cppcoreguidelines-pro-type-const-cast Avoid modification of const values # cppcoreguidelines-pro-type-cstyle-cast Avoid unsafe casts # cppcoreguidelines-pro-type-member-init Ensure class members are initialized # cppcoreguidelines-pro-type-reinterpret-cast Avoid unsafe casts # cppcoreguidelines-pro-type-static-cast-downcast Avoid use of static_cast where dynamic_cast is suggested # cppcoreguidelines-pro-type-union-access Avoid use of unions (NOTE: Some compilers may explicitly allow the use of unions as type prunning) # cppcoreguidelines-pro-type-vararg Avoid c-style variadic functions # cppcoreguidelines-rvalue-reference-param-not-moved Ensure rvalue parameters are moved into a function # cppcoreguidelines-slicing Avoid copying a derived instance into a base instance # cppcoreguidelines-special-member-functions Ensure that all special members/constructors are defined # cppcoreguidelines-virtual-class-destructor Ensure correct definition of virtual destructors # darwin-avoid-spinlock Avoid use of deprecated locks # darwin-dispatch-once-nonstatic Avoid undefined behaviour when dispatching #xfuchsia-default-arguments-calls Not used, cause default arguments are intended to be used #xfuchsia-default-arguments-declarations Not used, cause default arguments are intended to be used #xfuchsia-multiple-inheritance Not used, cause multi inheritance is probably intended when encountered #xfuchsia-overloaded-operator Not used, cause operator overloading is intended to be used #xfuchsia-statically-constructed-objects Not used, cause already handled by other checks in a less restricting way #xfuchsia-trailing-return Not used, cause I'm not sure what it does #xfuchsia-virtual-inheritance Not used, cause virtual inheritance is probably intended when encountered # google-build-explicit-make-pair Ensure correct types are used in make_pair # google-build-namespaces Avoid anonymous namespaces in headers # google-build-using-namespace Ensure explicit use of namespaces #xgoogle-default-arguments Not used, cause default arguments are intended to be used # google-explicit-constructor Avoid unintended implicit conversion # google-global-names-in-headers Avoid excessive use of namespaces in headers #xgoogle-readability-avoid-underscore-in-googletest-name Not used, cause naming of tests is up to the user # google-readability-casting Avoid use of c-style casts #xgoogle-readability-todo Not used, cause TODOs might often be used without assignment to bug numbers or users #xgoogle-runtime-int Not used, cause platform-specific integer size may be intended #xgoogle-runtime-operator Not used, cause operator overloading is intended to be used # google-upgrade-googletest-case Avoid use of deprecated functions # hicpp-exception-baseclass Ensure only exceptions are thrown # hicpp-multiway-paths-covered Ensure explicit covering of all branches # hicpp-no-assembler Avoid inline assembly #xhicpp-signed-bitwise Not used, cause it is fixed or will be fixed in c++20 # Avoid undefined behaviour at bitwise operations on signed integers #xllvm-header-guard Not used, cause it does not take care of root directory, generating very weird header guards #xllvm-include-order Not used, cause different include order style might be wanted by user (see .clang-format) # llvm-namespace-comment Ensure namespace end comment for long namespaces #xlvm-prefer-isa-or-dyn-cast-in-conditionals Not used, cause use of different casts might be intended #xllvm-prefer-register-over-unsigned Not used, cause I don't know where this applies #xllvm-twine-local Not used, cause I don't know where this applies #xllvmlibc-callee-namespace Not used, cause I don't know where this applies #xllvmlibc-implementation-in-namespace Not used, cause I don't know where this applies #xllvmlibc-inline-function-decl Not used, cause user might not use LLVM for compilation #xllvmlibc-restrict-system-libc-headers Not used, cause user might not use LLVM for compilation # misc-confusable-identifiers Avoid confusable identifiers #xmisc-const-correctness Not used, cause id produced false-positives # Ensure const is used where suggested # misc-definitions-in-headers Avoid not inlined definitions in headers # misc-misleading-bidirectional Avoid misleading characters in code # misc-misleading-identifier Avoid misleading characters in code # misc-misplaced-const Avoid wrong usage of const caused by typedefs # misc-new-delete-overloads Ensure each object-level new got an corresponding delete and the other way round # misc-no-recursion Avoid recursion # misc-non-copyable-objects Avoid copying types that are not copieable #xmisc-non-private-member-variables-in-classes Not used, cause this would blow up code massively # misc-redundant-expression Avoid redundant expressions # misc-static-assert Avoid use of assert where static_assert is suggested # misc-throw-by-value-catch-by-reference Ensure exceptions are catched by reference and thrown by value # misc-unconventional-assign-operator Ensure assignment operators are correctly defined # misc-uniqueptr-reset-release Ensure unique_ptr are moved on assignment # misc-unused-alias-decls Avoid unused namespaces aliases # misc-unused-parameters Avoid unused parameters # misc-unused-using-decls Avoid unused usings # misc-use-anonymous-namespace Ensure anonymouse namespaces are preferred before static global scope # modernize-avoid-bind Avoid binding of functions where lambdas can be used # modernize-avoid-c-arrays Avoid use of c-style arrays where std::array can be used #xmodernize-concat-nested-namespaces Not used, as namespaces might be extended, later requiring rewriting # modernize-deprecated-headers Avoid deprecated headers # modernize-deprecated-ios-base-aliases Avoid deprecated namespace #xmodernize-loop-convert Not used, cause range-based for might be bugprone and not usable in some situations # modernize-macro-to-enum Avoid use of macros, where enums are suggested #xmodernize-make-shared Not used, cause both does have pros and cons #xmodernize-make-unique Not used, cause both does have pros and cons # modernize-pass-by-value Avoid inefficient pass-by-reference #xmodernize-raw-string-literal Not used, cause raw strings are confusing when mixed with non-raw strings # modernize-redundant-void-arg Avoid use of void arg # modernize-replace-auto-ptr Avoid use of deprecated type # modernize-replace-disallow-copy-and-assign-macro Avoid deprecated macro # modernize-replace-random-shuffle Avoid use of deprecated function #xmodernize-return-braced-init-list Not used, cause array initializers hide explicite function calls, making it less clear what happens # modernize-shrink-to-fit Ensure shrink_to_fit is used where suggested # modernize-type-traits Ensure type_traits short functions are used # modernize-unary-static-assert Avoid use of empty string static_assert #xmodernize-use-auto Not used, cause auto hides type information # modernize-use-bool-literals Avoid assigning integers to bools #xmodernize-use-default-member-init Not used, cause initialization should happen at constructor. # modernize-use-emplace Ensure emplace functions are used where suggested # modernize-use-equals-default Ensure default constructor is explicitly defined where suggested # modernize-use-equals-delete Ensure constructor is explicitly deleted where suggested # modernize-use-nodiscard Ensure nodiscard is used where suggested # modernize-use-noexcept Ensure noexcept is used where suggested # modernize-use-nullptr Avoid use of NULL, instead use nullptr # modernize-use-override Ensure override is used where suggested #xmodernize-use-trailing-return-type Not used, cause it blows up code #xmodernize-use-transparent-functors Not used, as the removed type information is probably relevant # modernize-use-uncaught-exceptions Avoid usage of deprecated type #xmodernize-use-using Not used, cause typedef has clear syntax and clear use, while using has not # mpi-buffer-deref Avoid passing double pointers to mpi functions where single pointers are suggested # mpi-type-mismatch Ensure correct type buffer is passed to mpi function # openmp-exception-escape Ensure OpenMP blocks are well-bracketed # openmp-use-default-none Ensure explicit declaration of data sharing type # performance-faster-string-find Avoid call to find with a string literall where a call with a character is suggested # performance-for-range-copy Avoid copying values in ranged for loops where use by reference is suggested # performance-implicit-conversion-in-loop Avoid implicit conversion in ranged for loops # performance-inefficient-algorithm Avoid inefficient usage of container functiosn where more efficient implementations exist # performance-inefficient-string-concatenation Avoid addition of strings where appending is suggested # performance-inefficient-vector-operation Avoid inefficient calls to std::vector functions where it could be acceletarted # performance-move-const-arg Avoid move where none is suggested # performance-move-constructor-init Avoid move construictor where copy constructor is suggested in initialization of base classes # performance-no-automatic-move Avoid const where it prevents moving # performance-no-int-to-ptr Avoid casts between integer and pointer # performance-noexcept-move-constructor Ensure move constructors are marked with noexcept # performance-trivially-destructible Avoid making a function non-trivial destructible when it should be possible # performance-type-promotion-in-math-fn Ensure math float functions are explicitly called # performance-unnecessary-copy-initialization Avoid copy initialization where initialization by const reference is suggested # performance-unnecessary-value-param Avoid pass-by-value where pass-by-reference is suggested # portability-simd-intrinsics Avoid use of SIMD builtins where standard library (experimental) function is suggested # portability-std-allocator-const Avoid use of containers of const types #xreadability-avoid-const-params-in-decls Not used, cause it may be intended to match declaration and definition # readability-avoid-unconditional-preprocessor-if Avoid preprocessor ifs always evaluation to zrue/false # readability-braces-around-statements Avoid conditionals and loops without braces, as they are bad readable, bugprone and bat maintainable # readability-const-return-type Avoid const in return types, improving compiler optimizations # readability-container-contains Avoid usage of find() and count() where use of contains() is suggested # readability-container-data-pointer Ensure data() is used where available # readability-container-size-empty Avoid usage of size() where use of empty() is suggested # readability-convert-member-functions-to-static Ensure members are declared static when they actually are static # readability-delete-null-pointer Avoid checks for nullptr where it is unnecessary # readability-duplicate-include Avoid duplicate includes #xreadability-else-after-return Not used, cause explicit usage of branches might highlight branch covering #xreadability-function-cognitive-complexity Not used, cause no easy fis is suggested #xreadability-function-size Not used, cause no easy fis is suggested #xreadability-identifier-length Not used, cause no easy fis is suggested # readability-identifier-naming Ensure consistent naming of identifiers # readability-implicit-bool-conversion Avoid implicit conversion of bool # readability-inconsistent-declaration-parameter-name Ensure names of parameters in definition match name of parametersin declaration # readability-isolate-declaration Avoid declaring several variables in one statement # readability-magic-numbers Avoid magic numbers #xreadability-make-member-function-const Not used, cause is produces wrong results (mark functions const that have non-const access to members) # Ensure constant member functions are declared const # readability-misleading-indentatione Ensure intendation is consistent # readability-misplaced-array-index Avoid misused array index # readability-named-parameter Ensure parameters are named #xreadability-non-const-parameter Not used, cause is produces wrong results (mark parameters const that are have non-const accessed) # Ensure the use constant pointers where suggested # readability-operators-representation Avoid mixed tokens for operators # readability-qualified-auto Ensure auto pointers are declared as pointers # readability-redundant-access-specifiers Avoid dooubling of access specifiers # readability-redundant-control-flow Avoid unnecessary return or continue # readability-redundant-declaration Avoid redundant declarations # readability-redundant-function-ptr-dereference Avoid doubled dereferencing of functions where single dereference is suggested # readability-redundant-member-init Avoid unnecessary member initialization # readability-redundant-preprocessor Avoid redundant preprocessors # readability-redundant-smartptr-get Avoid doubled dereferencing of smart pointers where single dereference is suggested # readability-redundant-string-cstr Avoid calls to c_str where it is not necessary # readability-redundant-string-init Avoid unnecessary string initialization # readability-simplify-boolean-expr Avoid complex boolean expressions when simple ones are suggested # readability-simplify-subscript-expr Avoid call to data() where it is not necessary # readability-static-accessed-through-instance Avoid access of static members through instances # readability-static-definition-in-anonymous-namespace Avoid unnecessary static in anonymous namespace # readability-string-compare Ensure string compare function is used where suggested #xreadability-suspicious-call-argument Not used as too heuristic # readability-uniqueptr-delete-release Avoid complex deletion of unique pointers #xreadability-uppercase-literal-suffix Not used, cause lower case is completely valid # readability-use-anyofallof Avoid use of ranged for loop where special function is suggested Checks: > abseil-cleanup-ctad ,abseil-duration-addition ,abseil-duration-comparison ,abseil-duration-conversion-cast ,abseil-duration-division ,abseil-duration-factory-float ,abseil-duration-factory-scale ,abseil-duration-subtraction ,abseil-duration-unnecessary-conversion ,abseil-faster-strsplit-delimiter ,abseil-redundant-strcat-calls ,abseil-str-cat-append ,abseil-string-find-startswith ,abseil-time-comparison ,abseil-time-subtraction ,altera-kernel-name-restriction ,altera-single-work-item-barrier ,boost-use-to-string ,bugprone-argument-comment ,bugprone-assert-side-effect ,bugprone-assignment-in-if-condition ,bugprone-bad-signal-to-kill-thread ,bugprone-bool-pointer-implicit-conversion ,bugprone-branch-clone ,bugprone-copy-constructor-init ,bugprone-dangling-handle ,bugprone-dynamic-static-initializers ,bugprone-fold-init-type ,bugprone-forward-declaration-namespace ,bugprone-forwarding-reference-overload ,bugprone-implicit-widening-of-multiplication-result ,bugprone-inaccurate-erase ,bugprone-incorrect-roundings ,bugprone-infinite-loop ,bugprone-integer-division ,bugprone-lambda-function-name ,bugprone-macro-parentheses ,bugprone-misplaced-operator-in-strlen-in-alloc ,bugprone-misplaced-pointer-arithmetic-in-alloc ,bugprone-misplaced-widening-cast ,bugprone-move-forwarding-reference ,bugprone-multiple-statement-macro ,bugprone-no-escape ,bugprone-not-null-terminated-result ,bugprone-parent-virtual-call ,bugprone-posix-return ,bugprone-redundant-branch-condition ,bugprone-reserved-identifier ,bugprone-shared-ptr-array-mismatch ,bugprone-signal-handler ,bugprone-signed-char-misuse ,bugprone-sizeof-container ,bugprone-sizeof-expression ,bugprone-spuriously-wake-up-functions ,bugprone-standalone-empty ,bugprone-string-constructor ,bugprone-string-integer-assignment ,bugprone-string-literal-with-embedded-nul ,bugprone-stringview-nullptr ,bugprone-suspicious-enum-usage ,bugprone-suspicious-include ,bugprone-suspicious-memory-comparison ,bugprone-suspicious-memset-usage ,bugprone-suspicious-missing-comma ,bugprone-suspicious-realloc-usage ,bugprone-suspicious-semicolon ,bugprone-suspicious-string-compare ,bugprone-swapped-arguments ,bugprone-terminating-continue ,bugprone-throw-keyword-missing ,bugprone-too-small-loop-variable ,bugprone-unchecked-optional-access ,bugprone-undefined-memory-manipulation ,bugprone-undelegated-constructor ,bugprone-unhandled-exception-at-new ,bugprone-unsafe-functions ,bugprone-unused-raii ,bugprone-unused-return-value ,bugprone-use-after-move ,bugprone-virtual-near-miss ,cert-dcl50-cpp ,cert-err34-c ,cert-err52-cpp ,cert-err58-cpp ,cert-err60-cpp ,cert-mem57-cpp ,cert-oop57-cpp ,cert-oop58-cpp ,concurrency-mt-unsafe ,concurrency-thread-canceltype-asynchronous ,cppcoreguidelines-avoid-capture-default-when-capturing-this ,cppcoreguidelines-avoid-capturing-lambda-coroutines ,cppcoreguidelines-avoid-const-or-ref-data-members ,cppcoreguidelines-avoid-goto ,cppcoreguidelines-avoid-non-const-global-variables ,cppcoreguidelines-avoid-reference-coroutine-parameters ,cppcoreguidelines-interfaces-global-init ,cppcoreguidelines-macro-usage ,cppcoreguidelines-narrowing-conversions ,cppcoreguidelines-no-malloc ,cppcoreguidelines-pro-bounds-array-to-pointer-decay ,cppcoreguidelines-pro-bounds-pointer-arithmetic ,cppcoreguidelines-pro-type-const-cast ,cppcoreguidelines-pro-type-cstyle-cast ,cppcoreguidelines-pro-type-member-init ,cppcoreguidelines-pro-type-reinterpret-cast ,cppcoreguidelines-pro-type-static-cast-downcast ,cppcoreguidelines-pro-type-union-access ,cppcoreguidelines-pro-type-vararg ,cppcoreguidelines-rvalue-reference-param-not-moved ,cppcoreguidelines-slicing ,cppcoreguidelines-special-member-functions ,cppcoreguidelines-virtual-class-destructor ,darwin-avoid-spinlock ,darwin-dispatch-once-nonstatic ,google-build-explicit-make-pair ,google-build-namespaces ,google-build-using-namespace ,google-explicit-constructor ,google-global-names-in-headers ,google-readability-casting ,google-upgrade-googletest-case ,hicpp-exception-baseclass ,hicpp-multiway-paths-covered ,hicpp-no-assembler ,llvm-namespace-comment ,misc-confusable-identifiers ,misc-definitions-in-headers ,misc-misleading-bidirectional ,misc-misleading-identifier ,misc-misplaced-const ,misc-new-delete-overloads ,misc-no-recursion ,misc-non-copyable-objects ,misc-redundant-expression ,misc-static-assert ,misc-throw-by-value-catch-by-reference ,misc-unconventional-assign-operator ,misc-uniqueptr-reset-release ,misc-unused-alias-decls ,misc-unused-parameters ,misc-unused-using-decls ,misc-use-anonymous-namespace ,modernize-avoid-bind ,modernize-avoid-c-arrays ,modernize-deprecated-headers ,modernize-deprecated-ios-base-aliases ,modernize-macro-to-enum ,modernize-pass-by-value ,modernize-redundant-void-arg ,modernize-replace-auto-ptr ,modernize-replace-disallow-copy-and-assign-macro ,modernize-replace-random-shuffle ,modernize-shrink-to-fit ,modernize-type-traits ,modernize-unary-static-assert ,modernize-use-bool-literals ,modernize-use-emplace ,modernize-use-equals-default ,modernize-use-equals-delete ,modernize-use-nodiscard ,modernize-use-noexcept ,modernize-use-nullptr ,modernize-use-override ,modernize-use-uncaught-exceptions ,mpi-buffer-deref ,mpi-type-mismatch ,openmp-exception-escape ,openmp-use-default-none ,performance-faster-string-find ,performance-for-range-copy ,performance-implicit-conversion-in-loop ,performance-inefficient-algorithm ,performance-inefficient-string-concatenation ,performance-inefficient-vector-operation ,performance-move-const-arg ,performance-move-constructor-init ,performance-no-automatic-move ,performance-no-int-to-ptr ,performance-noexcept-move-constructor ,performance-trivially-destructible ,performance-type-promotion-in-math-fn ,performance-unnecessary-copy-initialization ,performance-unnecessary-value-param ,portability-simd-intrinsics ,portability-std-allocator-const ,readability-avoid-unconditional-preprocessor-if ,readability-braces-around-statements ,readability-const-return-type ,readability-container-contains ,readability-container-data-pointer ,readability-container-size-empty ,readability-convert-member-functions-to-static ,readability-delete-null-pointer ,readability-duplicate-include ,readability-identifier-naming ,readability-implicit-bool-conversion ,readability-inconsistent-declaration-parameter-name ,readability-isolate-declaration ,readability-magic-numbers ,readability-misleading-indentation ,readability-misplaced-array-index ,readability-named-parameter ,readability-operators-representation ,readability-qualified-auto ,readability-redundant-access-specifiers ,readability-redundant-control-flow ,readability-redundant-declaration ,readability-redundant-function-ptr-dereference ,readability-redundant-member-init ,readability-redundant-preprocessor ,readability-redundant-smartptr-get ,readability-redundant-string-cstr ,readability-redundant-string-init ,readability-simplify-boolean-expr ,readability-simplify-subscript-expr ,readability-static-accessed-through-instance ,readability-static-definition-in-anonymous-namespace ,readability-string-compare ,readability-uniqueptr-delete-release ,readability-use-anyofallof CheckOptions: - key: bugprone-argument-comment.StrictMode # Must be the exact parameter name value: true - key: bugprone-misplaced-widening-cast.CheckImplicitCasts # Also check implicit casts value: true - key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression # Warn when fetching sizeof integer value value: true - key: bugprone-string-constructor.WarnOnLargeLength # Large strings are probably intended when encountered value: true - key: bugprone-suspicious-enum-usage.StrictMode # Also detect suspicious enums value: true - key: bugprone-suspicious-missing-comma.SizeThreshold # Detect all occurencies value: 0 - key: bugprone-suspicious-missing-comma.RatioThreshold # Detect all occurencies value: 1.0 - key: bugprone-suspicious-missing-comma.MaxConcatenatedTokens # But not if we got more than x tokens value: 5 - key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison # Also warn on negation value: true - key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField # Always warn value: false - key: cppcoreguidelines-narrowing-conversions.WarnWithinTemplateInstantiation # Also warn on template instantiations value: true - key: cppcoreguidelines-narrowing-conversions.PedanticMode # Also warn when assigned value is exactly representable value: true - key: cppcoreguidelines-pro-type-member-init.IgnoreArrays # Ignore arrays for performance reason value: true - key: cppcoreguidelines-pro-type-member-init.UseAssignment # Use assignment, cause bracket initializer hides information about the called function value: true - key: hicpp-multiway-paths-covered.WarnOnMissingElse # Also warn if else branch is not covered value: true - key: misc-const-correctness.WarnPointersAsValues # Also warn for pointer values value: true - key: misc-const-correctness.TransformPointersAsValues # Also transform for pointer values value: true - key: modernize-avoid-bind.PermissiveParameterList # Avoid errors causd by replacement value: true - key: performance-for-range-copy.WarnOnAllAutoCopies # Warn when using auto in ranged for loops value: true - key: performance-inefficient-string-concatenation.StrictMode # Check everywhere value: true - key: portability-simd-intrinsics.Suggest # Suggest alternatives value: true - key: readability-identifier-naming.GetConfigPerFile # Use config from where the identifier is defined value: true - key: readability-inconsistent-declaration-parameter-name.Strict # Parameters must match exactly value: true - key: readability-magic-numbers.IgnoredIntegerValues # Only accept 0 and 1 (for bitwise operation and as true value= value: '1' - key: readability-magic-numbers.IgnoredFloatingPointValues # Only accept 0.0 and 1.0 (for 1.0/x) value: '1.0' - key: readability-magic-numbers.IgnoreTypeAliases # Ignore in type definitions value: true - key: readability-magic-numbers.IgnoreUserDefinedLiterals # Ignore in literal definitions value: true - key: readability-redundant-member-init.IgnoreBaseInCopyConstructors # Ignore unnecessary base class initialuization for compiler compatibility value: true - key: readability-uniqueptr-delete-release.PreferResetCall # Call reset instead of assigning nullptr value: true #Naming conventions - key: readability-identifier-naming.AbstractClassCase value: CamelCase - key: readability-identifier-naming.ClassCase value: CamelCase - key: readability-identifier-naming.ClassConstantCase value: UPPER_CASE - key: readability-identifier-naming.ClassMemberCase value: lower_case - key: readability-identifier-naming.ClassMethodCase value: lower_case - key: readability-identifier-naming.ConstantCase value: lower_case - key: readability-identifier-naming.ConstantMemberCase value: lower_case - key: readability-identifier-naming.ConstantParameterCase value: lower_case - key: readability-identifier-naming.ConstantPointerParameterCase value: lower_case - key: readability-identifier-naming.ConstexprMethodCase value: lower_case - key: readability-identifier-naming.ConstexprVariableCase value: UPPER_CASE - key: readability-identifier-naming.EnumCase value: CamelCase - key: readability-identifier-naming.EnumConstantCase value: CamelCase - key: readability-identifier-naming.FunctionCase value: lower_case - key: readability-identifier-naming.GlobalConstantCase value: UPPER_CASE - key: readability-identifier-naming.GlobalConstantPointerCase value: UPPER_CASE - key: readability-identifier-naming.GlobalFunctionCase value: lower_case - key: readability-identifier-naming.GlobalPointerCase value: lower_case - key: readability-identifier-naming.GlobalVariableCase value: lower_case - key: readability-identifier-naming.InlineNamespaceCase value: lower_case - key: readability-identifier-naming.LocalConstantCase value: lower_case - key: readability-identifier-naming.LocalConstantPointerCase value: lower_case - key: readability-identifier-naming.LocalPointerCase value: lower_case - key: readability-identifier-naming.LocalVariableCase value: lower_case - key: readability-identifier-naming.MacroDefinitionCase value: UPPER_CASE - key: readability-identifier-naming.MemberCase value: lower_case - key: readability-identifier-naming.MethodCase value: lower_case - key: readability-identifier-naming.NamespaceCase value: lower_case - key: readability-identifier-naming.ParameterCase value: lower_case - key: readability-identifier-naming.ParameterPackCase value: lower_case - key: readability-identifier-naming.PointerParameterCase value: lower_case - key: readability-identifier-naming.PrivateMemberCase value: lower_case - key: readability-identifier-naming.PrivateMethodCase value: lower_case - key: readability-identifier-naming.ProtectedMemberCase value: lower_case - key: readability-identifier-naming.ProtectedMethodCase value: lower_case - key: readability-identifier-naming.PublicMemberCase value: lower_case - key: readability-identifier-naming.PublicMethodCase value: lower_case - key: readability-identifier-naming.ScopedEnumConstantCase value: UPPER_CASE - key: readability-identifier-naming.StaticConstantCase value: UPPER_CASE - key: readability-identifier-naming.StaticVariableCase value: lower_case - key: readability-identifier-naming.StructCase value: CamelCase - key: readability-identifier-naming.TemplateParameterCase value: CamelCase - key: readability-identifier-naming.TemplateTemplateParameterCase value: CamelCase - key: readability-identifier-naming.TypeTemplateParameterCase value: CamelCase - key: readability-identifier-naming.UnionCase value: CamelCase - key: readability-identifier-naming.ValueTemplateParameterCase value: CamelCase - key: readability-identifier-naming.VariableCase value: lower_case - key: readability-identifier-naming.VirtualMethodCase value: CamelCase FormatStyle: file # Use .clang-format for formatting HeaderFileExtensions: ['h', 'hh', 'hpp', 'hxx', 'cuh'] # All headers, including CUDA headers ImplementationFileExtensions: ['c', 'cc', 'cpp', 'cxx', 'cu'] # All implementations, including CUDA implementations InheritParentConfig: true # Inherit parent config if available #SystemHeaders: false # Ignore system headers UseColor: true # Use colors if available WarningsAsErrors: true # Treat all warnings as errors ================================================ FILE: .gitignore ================================================ .vscode build clang-format-all.bat clang-tidy-all.bat fix_compilation_database.py **/*.so **/*.exe.manifest **/*.exe **/*.bgeo ================================================ FILE: .gitmodules ================================================ [submodule "Data"] path = Data url = https://github.com/littlemine/Data.git ================================================ FILE: CMake/DownloadProject.CMakeLists.cmake.in ================================================ cmake_minimum_required(VERSION 2.8.2) project(${DL_ARGS_PROJ}-download NONE) include(ExternalProject) ExternalProject_Add(${DL_ARGS_PROJ}-download ${DL_ARGS_UNPARSED_ARGUMENTS} SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" BINARY_DIR "${DL_ARGS_BINARY_DIR}" CONFIGURE_COMMAND "" BUILD_COMMAND "" INSTALL_COMMAND "" TEST_COMMAND "" ) ================================================ FILE: CMake/DownloadProject.LICENSE ================================================ The MIT License (MIT) Copyright (c) 2015 Crascit Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: CMake/DownloadProject.cmake ================================================ # MODULE: DownloadProject # # PROVIDES: # download_project( PROJ projectName # [PREFIX prefixDir] # [DOWNLOAD_DIR downloadDir] # [SOURCE_DIR srcDir] # [BINARY_DIR binDir] # [QUIET] # ... # ) # # Provides the ability to download and unpack a tarball, zip file, git repository, # etc. at configure time (i.e. when the cmake command is run). How the downloaded # and unpacked contents are used is up to the caller, but the motivating case is # to download source code which can then be included directly in the build with # add_subdirectory() after the call to download_project(). Source and build # directories are set up with this in mind. # # The PROJ argument is required. The projectName value will be used to construct # the following variables upon exit (obviously replace projectName with its actual # value): # # projectName_SOURCE_DIR # projectName_BINARY_DIR # # The SOURCE_DIR and BINARY_DIR arguments are optional and would not typically # need to be provided. They can be specified if you want the downloaded source # and build directories to be located in a specific place. The contents of # projectName_SOURCE_DIR and projectName_BINARY_DIR will be populated with the # locations used whether you provide SOURCE_DIR/BINARY_DIR or not. # # The DOWNLOAD_DIR argument does not normally need to be set. It controls the # location of the temporary CMake build used to perform the download. # # The PREFIX argument can be provided to change the base location of the default # values of DOWNLOAD_DIR, SOURCE_DIR and BINARY_DIR. If all of those three arguments # are provided, then PREFIX will have no effect. The default value for PREFIX is # CMAKE_BINARY_DIR. # # The QUIET option can be given if you do not want to show the output associated # with downloading the specified project. # # In addition to the above, any other options are passed through unmodified to # ExternalProject_Add() to perform the actual download, patch and update steps. # The following ExternalProject_Add() options are explicitly prohibited (they # are reserved for use by the download_project() command): # # CONFIGURE_COMMAND # BUILD_COMMAND # INSTALL_COMMAND # TEST_COMMAND # # Only those ExternalProject_Add() arguments which relate to downloading, patching # and updating of the project sources are intended to be used. Also note that at # least one set of download-related arguments are required. # # If using CMake 3.2 or later, the UPDATE_DISCONNECTED option can be used to # prevent a check at the remote end for changes every time CMake is run # after the first successful download. See the documentation of the ExternalProject # module for more information. It is likely you will want to use this option if it # is available to you. # # EXAMPLE USAGE: # # include(download_project.cmake) # download_project(PROJ googletest # GIT_REPOSITORY https://github.com/google/googletest.git # GIT_TAG master # UPDATE_DISCONNECTED 1 # QUIET # ) # # add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR}) # #======================================================================================== set(_DownloadProjectDir "${CMAKE_CURRENT_LIST_DIR}") include(CMakeParseArguments) function(download_project) set(options QUIET) set(oneValueArgs PROJ PREFIX DOWNLOAD_DIR SOURCE_DIR BINARY_DIR # Prevent the following from being passed through CONFIGURE_COMMAND BUILD_COMMAND INSTALL_COMMAND TEST_COMMAND ) set(multiValueArgs "") cmake_parse_arguments(DL_ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) # Hide output if requested if (DL_ARGS_QUIET) set(OUTPUT_QUIET "OUTPUT_QUIET") else() unset(OUTPUT_QUIET) message(STATUS "Downloading/updating ${DL_ARGS_PROJ}") endif() # Set up where we will put our temporary CMakeLists.txt file and also # the base point below which the default source and binary dirs will be if (NOT DL_ARGS_PREFIX) set(DL_ARGS_PREFIX "${CMAKE_BINARY_DIR}") endif() if (NOT DL_ARGS_DOWNLOAD_DIR) set(DL_ARGS_DOWNLOAD_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-download") endif() # Ensure the caller can know where to find the source and build directories if (NOT DL_ARGS_SOURCE_DIR) set(DL_ARGS_SOURCE_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-src") endif() if (NOT DL_ARGS_BINARY_DIR) set(DL_ARGS_BINARY_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-build") endif() set(${DL_ARGS_PROJ}_SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" PARENT_SCOPE) set(${DL_ARGS_PROJ}_BINARY_DIR "${DL_ARGS_BINARY_DIR}" PARENT_SCOPE) # Create and build a separate CMake project to carry out the download. # If we've already previously done these steps, they will not cause # anything to be updated, so extra rebuilds of the project won't occur. configure_file("${_DownloadProjectDir}/DownloadProject.CMakeLists.cmake.in" "${DL_ARGS_DOWNLOAD_DIR}/CMakeLists.txt") execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . ${OUTPUT_QUIET} WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}" ) execute_process(COMMAND ${CMAKE_COMMAND} --build . ${OUTPUT_QUIET} WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}" ) endfunction() ================================================ FILE: CMake/FindWayland.cmake ================================================ # Try to find Wayland on a Unix system # # This will define: # # WAYLAND_FOUND - True if Wayland is found # WAYLAND_LIBRARIES - Link these to use Wayland # WAYLAND_INCLUDE_DIR - Include directory for Wayland # WAYLAND_DEFINITIONS - Compiler flags for using Wayland # # In addition the following more fine grained variables will be defined: # # WAYLAND_CLIENT_FOUND WAYLAND_CLIENT_INCLUDE_DIR WAYLAND_CLIENT_LIBRARIES # WAYLAND_SERVER_FOUND WAYLAND_SERVER_INCLUDE_DIR WAYLAND_SERVER_LIBRARIES # WAYLAND_EGL_FOUND WAYLAND_EGL_INCLUDE_DIR WAYLAND_EGL_LIBRARIES # # Copyright (c) 2013 Martin Gräßlin # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. IF (NOT WIN32) IF (WAYLAND_INCLUDE_DIR AND WAYLAND_LIBRARIES) # In the cache already SET(WAYLAND_FIND_QUIETLY TRUE) ENDIF () # Use pkg-config to get the directories and then use these values # in the FIND_PATH() and FIND_LIBRARY() calls FIND_PACKAGE(PkgConfig) PKG_CHECK_MODULES(PKG_WAYLAND QUIET wayland-client wayland-server wayland-egl wayland-cursor) SET(WAYLAND_DEFINITIONS ${PKG_WAYLAND_CFLAGS}) FIND_PATH(WAYLAND_CLIENT_INCLUDE_DIR NAMES wayland-client.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS}) FIND_PATH(WAYLAND_SERVER_INCLUDE_DIR NAMES wayland-server.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS}) FIND_PATH(WAYLAND_EGL_INCLUDE_DIR NAMES wayland-egl.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS}) FIND_PATH(WAYLAND_CURSOR_INCLUDE_DIR NAMES wayland-cursor.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS}) FIND_LIBRARY(WAYLAND_CLIENT_LIBRARIES NAMES wayland-client HINTS ${PKG_WAYLAND_LIBRARY_DIRS}) FIND_LIBRARY(WAYLAND_SERVER_LIBRARIES NAMES wayland-server HINTS ${PKG_WAYLAND_LIBRARY_DIRS}) FIND_LIBRARY(WAYLAND_EGL_LIBRARIES NAMES wayland-egl HINTS ${PKG_WAYLAND_LIBRARY_DIRS}) FIND_LIBRARY(WAYLAND_CURSOR_LIBRARIES NAMES wayland-cursor HINTS ${PKG_WAYLAND_LIBRARY_DIRS}) set(WAYLAND_INCLUDE_DIR ${WAYLAND_CLIENT_INCLUDE_DIR} ${WAYLAND_SERVER_INCLUDE_DIR} ${WAYLAND_EGL_INCLUDE_DIR} ${WAYLAND_CURSOR_INCLUDE_DIR}) set(WAYLAND_LIBRARIES ${WAYLAND_CLIENT_LIBRARIES} ${WAYLAND_SERVER_LIBRARIES} ${WAYLAND_EGL_LIBRARIES} ${WAYLAND_CURSOR_LIBRARIES}) list(REMOVE_DUPLICATES WAYLAND_INCLUDE_DIR) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CLIENT DEFAULT_MSG WAYLAND_CLIENT_LIBRARIES WAYLAND_CLIENT_INCLUDE_DIR) FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_SERVER DEFAULT_MSG WAYLAND_SERVER_LIBRARIES WAYLAND_SERVER_INCLUDE_DIR) FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_EGL DEFAULT_MSG WAYLAND_EGL_LIBRARIES WAYLAND_EGL_INCLUDE_DIR) FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CURSOR DEFAULT_MSG WAYLAND_CURSOR_LIBRARIES WAYLAND_CURSOR_INCLUDE_DIR) FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND DEFAULT_MSG WAYLAND_LIBRARIES WAYLAND_INCLUDE_DIR) MARK_AS_ADVANCED( WAYLAND_INCLUDE_DIR WAYLAND_LIBRARIES WAYLAND_CLIENT_INCLUDE_DIR WAYLAND_CLIENT_LIBRARIES WAYLAND_SERVER_INCLUDE_DIR WAYLAND_SERVER_LIBRARIES WAYLAND_EGL_INCLUDE_DIR WAYLAND_EGL_LIBRARIES WAYLAND_CURSOR_INCLUDE_DIR WAYLAND_CURSOR_LIBRARIES ) ENDIF () ================================================ FILE: CMake/FindXCB.cmake ================================================ # - FindXCB # # Copyright 2015 Valve Coporation find_package(PkgConfig) if(NOT XCB_FIND_COMPONENTS) set(XCB_FIND_COMPONENTS xcb) endif() include(FindPackageHandleStandardArgs) set(XCB_FOUND true) set(XCB_INCLUDE_DIRS "") set(XCB_LIBRARIES "") foreach(comp ${XCB_FIND_COMPONENTS}) # component name string(TOUPPER ${comp} compname) string(REPLACE "-" "_" compname ${compname}) # header name string(REPLACE "xcb-" "" headername xcb/${comp}.h) # library name set(libname ${comp}) pkg_check_modules(PC_${comp} QUIET ${comp}) find_path(${compname}_INCLUDE_DIR NAMES ${headername} HINTS ${PC_${comp}_INCLUDEDIR} ${PC_${comp}_INCLUDE_DIRS} ) find_library(${compname}_LIBRARY NAMES ${libname} HINTS ${PC_${comp}_LIBDIR} ${PC_${comp}_LIBRARY_DIRS} ) find_package_handle_standard_args(${comp} FOUND_VAR ${comp}_FOUND REQUIRED_VARS ${compname}_INCLUDE_DIR ${compname}_LIBRARY) mark_as_advanced(${compname}_INCLUDE_DIR ${compname}_LIBRARY) list(APPEND XCB_INCLUDE_DIRS ${${compname}_INCLUDE_DIR}) list(APPEND XCB_LIBRARIES ${${compname}_LIBRARY}) if(NOT ${comp}_FOUND) set(XCB_FOUND false) endif() endforeach() list(REMOVE_DUPLICATES XCB_INCLUDE_DIRS) ================================================ FILE: CMake-Utils/setup_cpp.cmake ================================================ function(add_cpp_executable binary) add_executable(${binary} ${ARGN}) target_compile_options(${binary} INTERFACE "${CMAKE_CXX_FLAGS} -O3 -fPIE -fuse-ld=lld -fvisibility=hidden" ) # -flto=thin -fsanitize=cfi # -fsanitize=address memory thread set_target_properties(${binary} PROPERTIES CXX_STANDARD 20 LINKER_LANGUAGE CXX RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) target_compile_features(${binary} INTERFACE cxx_std_20 ) target_link_libraries(${binary} PUBLIC #pthread #stdc++ fmt ) message("-- [${binary}]\tcpp executable build config") endfunction(add_cpp_executable) function(add_cpp_executable_debug binary) add_executable(${binary} ${ARGN}) target_compile_options(${binary} INTERFACE "${CMAKE_CXX_FLAGS} -O2 -fPIE -fuse-ld=lld -fvisibility=hidden -fsanitize=address -fsanitize=memory -fsanitize=thread -fno-sanitize-trap=cfi" ) # -flto=thin -fsanitize=cfi # -fsanitize=address memory thread set_target_properties(${binary} PROPERTIES CXX_STANDARD 20 LINKER_LANGUAGE CXX RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) target_compile_features(${binary} INTERFACE cxx_std_20 ) target_link_libraries(${binary} PUBLIC #pthread #stdc++ fmt ) message("-- [${binary}]\tcpp debug executable build config") endfunction(add_cpp_executable_debug) ================================================ FILE: CMake-Utils/setup_cuda.cmake ================================================ message("## setup cuda") #Find CUDA include(CheckLanguage) check_language(CUDA) if(CMAKE_CUDA_COMPILER) enable_language(CUDA) message("-- cuda-compiler " ${CMAKE_CUDA_COMPILER}) else() message(STATUS "No CUDA support") endif() set(CUDA_FOUND ${CMAKE_CUDA_COMPILER}) #Set Architecture set(CMAKE_CUDA_ARCHITECTURES native) # reference: https://cliutils.gitlab.io/modern-cmake/chapters/packages/CUDA.html function(CUDA_CONVERT_FLAGS EXISTING_TARGET) get_property(old_flags TARGET ${EXISTING_TARGET} PROPERTY INTERFACE_COMPILE_OPTIONS ) if(NOT "${old_flags}" STREQUAL "") string(REPLACE ";" "," CUDA_flags "${old_flags}") set_property( TARGET ${EXISTING_TARGET} PROPERTY INTERFACE_COMPILE_OPTIONS "$<$>:${old_flags}>$<$>:-Xcompiler=${CUDA_flags}>" ) endif() endfunction() #Cmake does not handle linking correctly for separable compilation: https://gitlab.kitware.com/cmake/cmake/-/issues/22788 function(GET_DEVICE_LINK_PATH TARGET_NAME ret) cmake_path(SET DEVICE_LINK_PATH ${CMAKE_BINARY_DIR}) cmake_path(APPEND DEVICE_LINK_PATH "CMakeFiles") cmake_path(APPEND DEVICE_LINK_PATH ${TARGET_NAME}.dir) cmake_path(APPEND DEVICE_LINK_PATH ${CMAKE_BUILD_TYPE}) cmake_path(APPEND DEVICE_LINK_PATH "cmake_device_link.obj") set(${ret} ${DEVICE_LINK_PATH} PARENT_SCOPE) endfunction() function(add_cuda_executable binary) if(CUDA_FOUND) add_executable(${binary} ${ARGN}) # seems not working target_compile_options(${binary} PRIVATE $<$,$>:-g> --expt-extended-lambda --expt-relaxed-constexpr --default-stream=per-thread --use_fast_math -lineinfo --ptxas-options=-allow-expensive-optimizations=true> ) target_compile_features(${binary} PRIVATE cuda_std_17 ) set_target_properties(${binary} PROPERTIES CUDA_EXTENSIONS ON CUDA_SEPARABLE_COMPILATION OFF #LINKER_LANGUAGE CUDA RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ) GET_DEVICE_LINK_PATH(${binary} DEVICE_LINK_PATH) target_link_libraries(${binary} PRIVATE mncuda ) target_link_options(${binary} PRIVATE /NODEFAULTLIB:libcmt.lib ) install(TARGETS ${binary} ) message("-- [${binary}]\tcuda executable build config") endif() endfunction(add_cuda_executable) function(add_cuda_library library) if(CUDA_FOUND) add_library(${library} ${ARGN}) # seems not working target_compile_options(${library} PUBLIC $<$,$>:-g> --expt-extended-lambda --expt-relaxed-constexpr --default-stream=per-thread --use_fast_math -lineinfo --ptxas-options=-allow-expensive-optimizations=true> ) #target_link_options(${library} # PRIVATE $<$:-arch=sm_75> #) target_compile_features(${library} PRIVATE cuda_std_17 ) set_target_properties(${library} PROPERTIES CUDA_EXTENSIONS ON CUDA_SEPARABLE_COMPILATION OFF CUDA_RESOLVE_DEVICE_SYMBOLS OFF POSITION_INDEPENDENT_CODE ON #LINKER_LANGUAGE CUDA ) target_compile_definitions(${library} PUBLIC CMAKE_GENERATOR_PLATFORM=x64 ) message("-- [${library}]\tcuda executable build config") endif() endfunction(add_cuda_library) ================================================ FILE: CMake-Utils/setup_externallibs.cmake ================================================ ##### set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM.cmake") set(CPM_DOWNLOAD_VERSION 0.38.1) if(NOT (EXISTS ${CPM_DOWNLOAD_LOCATION} AND CPM_VERSION STREQUAL CPM_DOWNLOAD_VERSION)) message(STATUS "Downloading CPM.cmake") file(DOWNLOAD https://github.com/TheLartians/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake ${CPM_DOWNLOAD_LOCATION}) endif() include(${CPM_DOWNLOAD_LOCATION}) ##### #Suppress warning cmake_policy(SET CMP0077 NEW) # rapidjson CPMAddPackage( NAME rapidjson GIT_TAG 949c771b03de448bdedea80c44a4a5f65284bfeb GITHUB_REPOSITORY Tencent/rapidjson OPTIONS "RAPIDJSON_BUILD_CXX11 Off" "RAPIDJSON_BUILD_CXX17 On" ) if(rapidjson_ADDED) add_library(rapidjson INTERFACE IMPORTED ) target_include_directories(rapidjson SYSTEM INTERFACE ${rapidjson_SOURCE_DIR}/include ) endif() # cxxopts CPMAddPackage( NAME cxxopts GITHUB_REPOSITORY jarro2783/cxxopts VERSION 2.2.0 OPTIONS "CXXOPTS_BUILD_EXAMPLES Off" "CXXOPTS_BUILD_TESTS Off" ) # spdlog CPMAddPackage( NAME spdlog VERSION 1.7.0 GITHUB_REPOSITORY gabime/spdlog ) #Set new timestamps cmake_policy(SET CMP0135 NEW) set(CMAKE_POLICY_DEFAULT_CMP0135 NEW) # ranges CPMAddPackage( NAME range-v3 URL https://github.com/ericniebler/range-v3/archive/0.10.0.zip VERSION 0.10.0 # the range-v3 CMakeLists screws with configuration options DOWNLOAD_ONLY True ) if(range-v3_ADDED) add_library(range-v3 INTERFACE IMPORTED ) target_include_directories(range-v3 SYSTEM INTERFACE ${range-v3_SOURCE_DIR}/include ) endif() # fmt CPMAddPackage( NAME fmt GIT_TAG 6.2.1 GITHUB_REPOSITORY fmtlib/fmt ) if(fmt_ADDED) target_include_directories(fmt SYSTEM INTERFACE ${fmt_SOURCE_DIR}/include ) endif() # glm CPMAddPackage( NAME glm GIT_TAG 0.9.9.8 GITHUB_REPOSITORY g-truc/glm ) # filesystem CPMAddPackage( NAME filesystem GITHUB_REPOSITORY gulrak/filesystem VERSION 1.3.4 ) if(filesystem_ADDED) add_library(filesystem INTERFACE IMPORTED ) target_include_directories(filesystem SYSTEM INTERFACE ${filesystem_SOURCE_DIR}/include ) endif() ================================================ FILE: CMake-Utils/setup_python.cmake ================================================ function(add_python_library library) add_library(${library} MODULE ${ARGN}) target_compile_options(${library} INTERFACE "${CMAKE_CXX_FLAGS} -O3 -fuse-ld=lld -fvisibility=hidden -fsized-deallocation") # -flto=thin -fsanitize=cfi set_target_properties(${library} PROPERTIES CPP_STANDARD 14 PREFIX "${PYTHON_MODULE_PREFIX}" SUFFIX "${PYTHON_MODULE_EXTENSION}" LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) target_compile_definitions(${library} INTERFACE CMAKE_GENERATOR_PLATFORM=x64 ) target_compile_features(${library} INTERFACE cxx_std_14) target_link_libraries(${library} PRIVATE pybind11::module ) message("-- [${library}]\tpython library build config") endfunction(add_python_library) ================================================ FILE: CMakeLists.txt ================================================ cmake_minimum_required(VERSION 3.15) # support relative path message("===============================================================") include("project_info.in") project(Mn VERSION ${project_version} DESCRIPTION ${project_description} LANGUAGES CXX CUDA ) option(BUILD_SHARED_LIBS "Enable compilation of shared libraries" OFF) #Fixes https://gitlab.kitware.com/cmake/cmake/-/issues/24154 for older cmake versions set(CMAKE_INCLUDE_SYSTEM_FLAG_CUDA "-isystem ") list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMake) include(CMake-Utils/setup_cpp.cmake) include(CMake-Utils/setup_cuda.cmake) include(CMake-Utils/setup_externallibs.cmake) add_subdirectory(Externals) # header only libraries include_directories( SYSTEM Externals/variant Externals/optional Externals/function_ref ) message("===============================================================") include_directories(Library) add_subdirectory(Library) add_subdirectory(Projects) ================================================ FILE: Externals/CMakeLists.txt ================================================ find_package(Git) include(FetchContent) include(ExternalProject) include(DownloadProject) # partio message("## building partio") add_subdirectory(partio) # optional #FetchContent_Declare( # optional # GIT_REPOSITORY https://github.com/TartanLlama/optional.git # GIT_TAG 83a0b49e5e9571438c3ebae638e9a37502911b8c #) #FetchContent_MakeAvailable(optional) # function_ref #FetchContent_Declare( # function_ref # GIT_REPOSITORY https://github.com/TartanLlama/function_ref.git # GIT_TAG 556c2c3fbfc144971c01ba6d177aaab48cab6870 #) ##FetchContent_MakeAvailable(function_ref) #if (NOT function_ref_POPULATED) # FetchContent_Populate(function_ref) #endif() # variant #FetchContent_Declare( # variant # GIT_REPOSITORY https://github.com/mpark/variant.git # GIT_TAG 4988879a9f5a95d72308eca2b1779db6ed9b135d #) #FetchContent_MakeAvailable(variant) ================================================ FILE: Externals/SDFGen/CMakeLists.txt ================================================ cmake_minimum_required(VERSION 2.6) Project("SDFGen") # Set the build type. Options are: # Coverage : w/ debug symbols, w/o optimization, w/ code-coverage # Debug : w/ debug symbols, w/o optimization # Release : w/o debug symbols, w/ optimization # RelWithDebInfo : w/ debug symbols, w/ optimization # MinSizeRel : w/o debug symbols, w/ optimization, stripped binaries # SET(CMAKE_BUILD_TYPE Coverage) SET(CMAKE_BUILD_TYPE Release) #set the default path for built executables to the "bin" directory set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/bin) #These flags might not work on every system, especially the release flags, comment out as needed set(CMAKE_CXX_FLAGS "-O3") set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g") set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native") #checks if VTK is available find_package(VTK QUIET) if(VTK_FOUND) set(HAVE_VTK 1) endif() #Generates config.h replacing expressions in config.h.in with actual values configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/config.h.in" "${CMAKE_CURRENT_SOURCE_DIR}/config.h" ) add_executable(${PROJECT_NAME} main.cpp makelevelset3.cpp) if(VTK_FOUND) include_directories(${VTK_INCLUDE_DIRS}) target_link_libraries(${PROJECT_NAME} ${VTK_LIBRARIES}) endif() ================================================ FILE: Externals/SDFGen/README.md ================================================ # SDFGen A simple commandline utility to generate grid-based signed distance field (level set) generator from triangle meshes, using code from Robert Bridson's website. The MIT License (MIT) Copyright (c) 2015, Christopher Batty Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: Externals/SDFGen/array1.h ================================================ #ifndef ARRAY1_H #define ARRAY1_H #include #include #include #include #include #include #include #include // In this file: // Array1: a dynamic 1D array for plain-old-data (not objects) // WrapArray1: a 1D array wrapper around an existing array (perhaps objects, perhaps data) // For the most part std::vector operations are supported, though for the Wrap version // note that memory is never allocated/deleted and constructor/destructors are never called // from within the class, thus only shallow copies can be made and some operations such as // resize() and push_back() are limited. // Note: for the most part assertions are done with assert(), not exceptions... // gross template hacking to determine if a type is integral or not struct Array1True {}; struct Array1False {}; template struct Array1IsIntegral{ typedef Array1False type; }; // default: no (specializations to yes follow) template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; template<> struct Array1IsIntegral{ typedef Array1True type; }; //============================================================================ template struct Array1 { // STL-friendly typedefs typedef T* iterator; typedef const T* const_iterator; typedef unsigned long size_type; typedef long difference_type; typedef T& reference; typedef const T& const_reference; typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; // the actual representation unsigned long n; unsigned long max_n; T* data; // STL vector's interface, with additions, but only valid when used with plain-old-data Array1(void) : n(0), max_n(0), data(0) {} // note: default initial values are zero Array1(unsigned long n_) : n(0), max_n(0), data(0) { if(n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc(); data=(T*)std::calloc(n_, sizeof(T)); if(!data) throw std::bad_alloc(); n=n_; max_n=n_; } Array1(unsigned long n_, const T& value) : n(0), max_n(0), data(0) { if(n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc(); data=(T*)std::calloc(n_, sizeof(T)); if(!data) throw std::bad_alloc(); n=n_; max_n=n_; for(unsigned long i=0; iULONG_MAX/sizeof(T)) throw std::bad_alloc(); data=(T*)std::calloc(max_n_, sizeof(T)); if(!data) throw std::bad_alloc(); n=n_; max_n=max_n_; for(unsigned long i=0; iULONG_MAX/sizeof(T)) throw std::bad_alloc(); data=(T*)std::calloc(n_, sizeof(T)); if(!data) throw std::bad_alloc(); n=n_; max_n=n_; assert(data_); std::memcpy(data, data_, n*sizeof(T)); } Array1(unsigned long n_, const T* data_, unsigned long max_n_) : n(0), max_n(0), data(0) { assert(n_<=max_n_); if(max_n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc(); data=(T*)std::calloc(max_n_, sizeof(T)); if(!data) throw std::bad_alloc(); max_n=max_n_; n=n_; assert(data_); std::memcpy(data, data_, n*sizeof(T)); } Array1(const Array1 &x) : n(0), max_n(0), data(0) { data=(T*)std::malloc(x.n*sizeof(T)); if(!data) throw std::bad_alloc(); n=x.n; max_n=x.n; std::memcpy(data, x.data, n*sizeof(T)); } ~Array1(void) { std::free(data); #ifndef NDEBUG data=0; n=max_n=0; #endif } const T& operator[](unsigned long i) const { return data[i]; } T& operator[](unsigned long i) { return data[i]; } // these are range-checked (in debug mode) versions of operator[], like at() const T& operator()(unsigned long i) const { assert(i& operator=(const Array1& x) { if(max_n& x) const { if(n!=x.n) return false; for(unsigned long i=0; i& x) const { if(n!=x.n) return true; for(unsigned long i=0; i& x) const { for(unsigned long i=0; i(const Array1& x) const { for(unsigned long i=0; ix[i]) return true; else if(x[i]>data[i]) return false; } return n>x.n; } bool operator<=(const Array1& x) const { for(unsigned long i=0; i=(const Array1& x) const { for(unsigned long i=0; ix[i]) return true; else if(x[i]>data[i]) return false; } return n>=x.n; } void add_unique(const T& value) { for(unsigned long i=0; imax_n){ if(num>ULONG_MAX/sizeof(T)) throw std::bad_alloc(); std::free(data); data=(T*)std::malloc(num*sizeof(T)); if(!data) throw std::bad_alloc(); max_n=num; } n=num; std::memcpy(data, copydata, n*sizeof(T)); } template void assign(InputIterator first, InputIterator last) { assign_(first, last, typename Array1IsIntegral::type()); } template void assign_(InputIterator first, InputIterator last, Array1True check) { fill(first, last); } template void assign_(InputIterator first, InputIterator last, Array1False check) { unsigned long i=0; InputIterator p=first; for(; p!=last; ++p, ++i){ if(i==max_n) grow(); data[i]=*p; } n=i; } const T& at(unsigned long i) const { assert(i0); return data[n-1]; } T& back(void) { assert(data && n>0); return data[n-1]; } const T* begin(void) const { return data; } T* begin(void) { return data; } unsigned long capacity(void) const { return max_n; } void clear(void) { std::free(data); data=0; max_n=0; n=0; } bool empty(void) const { return n==0; } const T* end(void) const { return data+n; } T* end(void) { return data+n; } void erase(unsigned long index) { assert(indexmax_n){ if(num>ULONG_MAX/sizeof(T)) throw std::bad_alloc(); std::free(data); data=(T*)std::malloc(num*sizeof(T)); if(!data) throw std::bad_alloc(); max_n=num; } n=num; for(unsigned long i=0; i0); return *data; } T& front(void) { assert(n>0); return *data; } void grow(void) { unsigned long new_size=(max_n*sizeof(T)index; --i) data[i]=data[i-1]; data[index]=entry; } unsigned long max_size(void) const { return ULONG_MAX/sizeof(T); } void pop_back(void) { assert(n>0); --n; } void push_back(const T& value) { if(n==max_n) grow(); data[n++]=value; } reverse_iterator rbegin(void) { return reverse_iterator(end()); } const_reverse_iterator rbegin(void) const { return const_reverse_iterator(end()); } reverse_iterator rend(void) { return reverse_iterator(begin()); } const_reverse_iterator rend(void) const { return const_reverse_iterator(begin()); } void reserve(unsigned long r) { if(r>ULONG_MAX/sizeof(T)) throw std::bad_alloc(); T *new_data=(T*)std::realloc(data, r*sizeof(T)); if(!new_data) throw std::bad_alloc(); data=new_data; max_n=r; } void resize(unsigned long n_) { if(n_>max_n) reserve(n_); n=n_; } void resize(unsigned long n_, const T& value) { if(n_>max_n) reserve(n_); if(n& x) { std::swap(n, x.n); std::swap(max_n, x.max_n); std::swap(data, x.data); } // resize the array to avoid wasted space, without changing contents // (Note: realloc, at least on some platforms, will not do the trick) void trim(void) { if(n==max_n) return; T *new_data=(T*)std::malloc(n*sizeof(T)); if(!new_data) return; std::memcpy(new_data, data, n*sizeof(T)); std::free(data); data=new_data; max_n=n; } }; // some common arrays typedef Array1 Array1d; typedef Array1 Array1f; typedef Array1 Array1ll; typedef Array1 Array1ull; typedef Array1 Array1i; typedef Array1 Array1ui; typedef Array1 Array1s; typedef Array1 Array1us; typedef Array1 Array1c; typedef Array1 Array1uc; //============================================================================ template struct WrapArray1 { // STL-friendly typedefs typedef T* iterator; typedef const T* const_iterator; typedef unsigned long size_type; typedef long difference_type; typedef T& reference; typedef const T& const_reference; typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; // the actual representation unsigned long n; unsigned long max_n; T* data; // most of STL vector's interface, with a few changes WrapArray1(void) : n(0), max_n(0), data(0) {} WrapArray1(unsigned long n_, T* data_) : n(n_), max_n(n_), data(data_) { assert(data || max_n==0); } WrapArray1(unsigned long n_, T* data_, unsigned long max_n_) : n(n_), max_n(max_n_), data(data_) { assert(n<=max_n); assert(data || max_n==0); } // Allow for simple shallow copies of existing arrays // Note that if the underlying arrays change where their data is, the WrapArray may be screwed up WrapArray1(Array1& a) : n(a.n), max_n(a.max_n), data(a.data) {} WrapArray1(std::vector& a) : n(a.size()), max_n(a.capacity()), data(&a[0]) {} void init(unsigned long n_, T* data_, unsigned long max_n_) { assert(n_<=max_n_); assert(data_ || max_n_==0); n=n_; max_n=max_n_; data=data_; } const T& operator[](unsigned long i) const { return data[i]; } T& operator[](unsigned long i) { return data[i]; } // these are range-checked (in debug mode) versions of operator[], like at() const T& operator()(unsigned long i) const { assert(i& x) const { if(n!=x.n) return false; for(unsigned long i=0; i& x) const { if(n!=x.n) return true; for(unsigned long i=0; i& x) const { for(unsigned long i=0; i(const WrapArray1& x) const { for(unsigned long i=0; ix[i]) return true; else if(x[i]>data[i]) return false; } return n>x.n; } bool operator<=(const WrapArray1& x) const { for(unsigned long i=0; i=(const WrapArray1& x) const { for(unsigned long i=0; ix[i]) return true; else if(x[i]>data[i]) return false; } return n>=x.n; } void add_unique(const T& value) { for(unsigned long i=0; i void assign(InputIterator first, InputIterator last) { assign_(first, last, typename Array1IsIntegral::type()); } template void assign_(InputIterator first, InputIterator last, Array1True check) { fill(first, last); } template void assign_(InputIterator first, InputIterator last, Array1False check) { unsigned long i=0; InputIterator p=first; for(; p!=last; ++p, ++i){ assert(i0); return data[n-1]; } T& back(void) { assert(data && n>0); return data[n-1]; } const T* begin(void) const { return data; } T* begin(void) { return data; } unsigned long capacity(void) const { return max_n; } void clear(void) { n=0; } bool empty(void) const { return n==0; } const T* end(void) const { return data+n; } T* end(void) { return data+n; } void erase(unsigned long index) { assert(index0); return *data; } T& front(void) { assert(n>0); return *data; } void insert(unsigned long index, const T& entry) { assert(index<=n); push_back(back()); for(unsigned long i=n-1; i>index; --i) data[i]=data[i-1]; data[index]=entry; } unsigned long max_size(void) const { return max_n; } void pop_back(void) { assert(n>0); --n; } void push_back(const T& value) { assert(n& x) { std::swap(n, x.n); std::swap(max_n, x.max_n); std::swap(data, x.data); } }; // some common arrays typedef WrapArray1 WrapArray1d; typedef WrapArray1 WrapArray1f; typedef WrapArray1 WrapArray1ll; typedef WrapArray1 WrapArray1ull; typedef WrapArray1 WrapArray1i; typedef WrapArray1 WrapArray1ui; typedef WrapArray1 WrapArray1s; typedef WrapArray1 WrapArray1us; typedef WrapArray1 WrapArray1c; typedef WrapArray1 WrapArray1uc; #endif ================================================ FILE: Externals/SDFGen/array2.h ================================================ #ifndef ARRAY2_H #define ARRAY2_H #include "array1.h" #include #include #include template > struct Array2 { // STL-friendly typedefs typedef typename ArrayT::iterator iterator; typedef typename ArrayT::const_iterator const_iterator; typedef typename ArrayT::size_type size_type; typedef long difference_type; typedef T& reference; typedef const T& const_reference; typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef typename ArrayT::reverse_iterator reverse_iterator; typedef typename ArrayT::const_reverse_iterator const_reverse_iterator; // the actual representation int ni, nj; ArrayT a; // the interface Array2(void) : ni(0), nj(0) {} Array2(int ni_, int nj_) : ni(ni_), nj(nj_), a(ni_*nj_) { assert(ni_>=0 && nj>=0); } Array2(int ni_, int nj_, ArrayT& a_) : ni(ni_), nj(nj_), a(a_) { assert(ni_>=0 && nj>=0); } Array2(int ni_, int nj_, const T& value) : ni(ni_), nj(nj_), a(ni_*nj_, value) { assert(ni_>=0 && nj>=0); } Array2(int ni_, int nj_, const T& value, size_type max_n_) : ni(ni_), nj(nj_), a(ni_*nj_, value, max_n_) { assert(ni_>=0 && nj>=0); } Array2(int ni_, int nj_, T* data_) : ni(ni_), nj(nj_), a(ni_*nj_, data_) { assert(ni_>=0 && nj>=0); } Array2(int ni_, int nj_, T* data_, size_type max_n_) : ni(ni_), nj(nj_), a(ni_*nj_, data_, max_n_) { assert(ni_>=0 && nj>=0); } template Array2(Array2& other) : ni(other.ni), nj(other.nj), a(other.a) {} ~Array2(void) { #ifndef NDEBUG ni=nj=0; #endif } const T& operator()(int i, int j) const { assert(i>=0 && i=0 && j=0 && i=0 && j& x) const { return ni==x.ni && nj==x.nj && a==x.a; } bool operator!=(const Array2& x) const { return ni!=x.ni || nj!=x.nj || a!=x.a; } bool operator<(const Array2& x) const { if(nix.ni) return false; if(njx.nj) return false; return a(const Array2& x) const { if(ni>x.ni) return true; else if(nix.nj) return true; else if(njx.a; } bool operator<=(const Array2& x) const { if(nix.ni) return false; if(njx.nj) return false; return a<=x.a; } bool operator>=(const Array2& x) const { if(ni>x.ni) return true; else if(nix.nj) return true; else if(nj=x.a; } void assign(const T& value) { a.assign(value); } void assign(int ni_, int nj_, const T& value) { a.assign(ni_*nj_, value); ni=ni_; nj=nj_; } void assign(int ni_, int nj_, const T* copydata) { a.assign(ni_*nj_, copydata); ni=ni_; nj=nj_; } const T& at(int i, int j) const { assert(i>=0 && i=0 && j=0 && i=0 && j=0 && nj_>=0); a.resize(ni_*nj_); ni=ni_; nj=nj_; } void resize(int ni_, int nj_, const T& value) { assert(ni_>=0 && nj_>=0); a.resize(ni_*nj_, value); ni=ni_; nj=nj_; } void set_zero(void) { a.set_zero(); } size_type size(void) const { return a.size(); } void swap(Array2& x) { std::swap(ni, x.ni); std::swap(nj, x.nj); a.swap(x.a); } void trim(void) { a.trim(); } }; // some common arrays typedef Array2 > Array2d; typedef Array2 > Array2f; typedef Array2 > Array2ll; typedef Array2 > Array2ull; typedef Array2 > Array2i; typedef Array2 > Array2ui; typedef Array2 > Array2s; typedef Array2 > Array2us; typedef Array2 > Array2c; typedef Array2 > Array2uc; // and wrapped versions typedef Array2 > WrapArray2d; typedef Array2 > WrapArray2f; typedef Array2 > WrapArray2ll; typedef Array2 > WrapArray2ull; typedef Array2 > WrapArray2i; typedef Array2 > WrapArray2ui; typedef Array2 > WrapArray2s; typedef Array2 > WrapArray2us; typedef Array2 > WrapArray2c; typedef Array2 > WrapArray2uc; #endif ================================================ FILE: Externals/SDFGen/array3.h ================================================ #ifndef ARRAY3_H #define ARRAY3_H #include "array1.h" #include #include #include template > struct Array3 { // STL-friendly typedefs typedef typename ArrayT::iterator iterator; typedef typename ArrayT::const_iterator const_iterator; typedef typename ArrayT::size_type size_type; typedef long difference_type; typedef T& reference; typedef const T& const_reference; typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef typename ArrayT::reverse_iterator reverse_iterator; typedef typename ArrayT::const_reverse_iterator const_reverse_iterator; // the actual representation int ni, nj, nk; ArrayT a; // the interface Array3(void) : ni(0), nj(0), nk(0) {} Array3(int ni_, int nj_, int nk_) : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_) { assert(ni_>=0 && nj_>=0 && nk_>=0); } Array3(int ni_, int nj_, int nk_, ArrayT& a_) : ni(ni_), nj(nj_), nk(nk_), a(a_) { assert(ni_>=0 && nj_>=0 && nk_>=0); } Array3(int ni_, int nj_, int nk_, const T& value) : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, value) { assert(ni_>=0 && nj_>=0 && nk_>=0); } Array3(int ni_, int nj_, int nk_, const T& value, size_type max_n_) : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, value, max_n_) { assert(ni_>=0 && nj_>=0 && nk_>=0); } Array3(int ni_, int nj_, int nk_, T* data_) : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, data_) { assert(ni_>=0 && nj_>=0 && nk_>=0); } Array3(int ni_, int nj_, int nk_, T* data_, size_type max_n_) : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, data_, max_n_) { assert(ni_>=0 && nj_>=0 && nk_>=0); } ~Array3(void) { #ifndef NDEBUG ni=nj=0; #endif } const T& operator()(int i, int j, int k) const { assert(i>=0 && i=0 && j=0 && k=0 && i=0 && j=0 && k& x) const { return ni==x.ni && nj==x.nj && nk==x.nk && a==x.a; } bool operator!=(const Array3& x) const { return ni!=x.ni || nj!=x.nj || nk!=x.nk || a!=x.a; } bool operator<(const Array3& x) const { if(nix.ni) return false; if(njx.nj) return false; if(nkx.nk) return false; return a(const Array3& x) const { if(ni>x.ni) return true; else if(nix.nj) return true; else if(njx.nk) return true; else if(nkx.a; } bool operator<=(const Array3& x) const { if(nix.ni) return false; if(njx.nj) return false; if(nkx.nk) return false; return a<=x.a; } bool operator>=(const Array3& x) const { if(ni>x.ni) return true; else if(nix.nj) return true; else if(njx.nk) return true; else if(nk=x.a; } void assign(const T& value) { a.assign(value); } void assign(int ni_, int nj_, int nk_, const T& value) { a.assign(ni_*nj_*nk_, value); ni=ni_; nj=nj_; nk=nk_; } void assign(int ni_, int nj_, int nk_, const T* copydata) { a.assign(ni_*nj_*nk_, copydata); ni=ni_; nj=nj_; nk=nk_; } const T& at(int i, int j, int k) const { assert(i>=0 && i=0 && j=0 && k=0 && i=0 && j=0 && k=0 && nj_>=0 && nk_>=0); a.resize(ni_*nj_*nk_); ni=ni_; nj=nj_; nk=nk_; } void resize(int ni_, int nj_, int nk_, const T& value) { assert(ni_>=0 && nj_>=0 && nk_>=0); a.resize(ni_*nj_*nk_, value); ni=ni_; nj=nj_; nk=nk_; } void set_zero(void) { a.set_zero(); } size_type size(void) const { return a.size(); } void swap(Array3& x) { std::swap(ni, x.ni); std::swap(nj, x.nj); std::swap(nk, x.nk); a.swap(x.a); } void trim(void) { a.trim(); } }; // some common arrays typedef Array3 > Array3d; typedef Array3 > Array3f; typedef Array3 > Array3ll; typedef Array3 > Array3ull; typedef Array3 > Array3i; typedef Array3 > Array3ui; typedef Array3 > Array3s; typedef Array3 > Array3us; typedef Array3 > Array3c; typedef Array3 > Array3uc; #endif ================================================ FILE: Externals/SDFGen/config.h.in ================================================ #ifndef SDFGEN_CONFIG_H #define SDFGEN_CONFIG_H /* * Configuration Header for SDFGEN */ /// Configured libraries #cmakedefine HAVE_VTK #endif //SDFGEN_CONFIG_H ================================================ FILE: Externals/SDFGen/hashgrid.h ================================================ #ifndef HASHGRID_H #define HASHGRID_H #include "hashtable.h" #include "vec.h" //========================================================= first do 2D ============================ template struct HashGrid2 { double dx, overdx; // side-length of a grid cell and its reciprocal HashTable grid; explicit HashGrid2(double dx_=1, int expected_size=512) : dx(dx_), overdx(1/dx_), grid(expected_size) {} // only do this with an empty grid void set_grid_size(double dx_) { assert(size()==0); dx=dx_; overdx=1/dx; } void add_point(const Vec2d &x, const DataType &datum) { grid.add(round(x*overdx), datum); } void delete_point(const Vec2d &x, const DataType &datum) { grid.delete_entry(round(x*overdx), datum); } void add_box(const Vec2d &xmin, const Vec2d &xmax, const DataType &datum) { Vec2i imin=round(xmin*overdx), imax=round(xmax*overdx); for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i) grid.add(Vec2i(i,j), datum); } void delete_box(const Vec2d &xmin, const Vec2d &xmax, const DataType &datum) { Vec2i imin=round(xmin*overdx), imax=round(xmax*overdx); for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i) grid.delete_entry(Vec2i(i,j), datum); } unsigned int size(void) const { return grid.size(); } void clear(void) { grid.clear(); } void reserve(unsigned int expected_size) { grid.reserve(expected_size); } bool find_first_point(const Vec2d &x, DataType &datum) const { return grid.get_entry(round(x*overdx), datum); } bool find_point(const Vec2d &x, std::vector &data_list) const { data_list.resize(0); grid.append_all_entries(round(x*overdx), data_list); return data_list.size()>0; } bool find_box(const Vec2d &xmin, const Vec2d &xmax, std::vector &data_list) const { data_list.resize(0); Vec2i imin=round(xmin*overdx), imax=round(xmax*overdx); for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i) grid.append_all_entries(Vec2i(i,j), data_list); return data_list.size()>0; } }; //==================================== and now in 3D ================================================= template struct HashGrid3 { double dx, overdx; // side-length of a grid cell and its reciprocal HashTable grid; explicit HashGrid3(double dx_=1, int expected_size=512) : dx(dx_), overdx(1/dx_), grid(expected_size) {} // only do this with an empty grid void set_grid_size(double dx_) { assert(size()==0); dx=dx_; overdx=1/dx; } void add_point(const Vec3d &x, const DataType &datum) { grid.add(round(x*overdx), datum); } void delete_point(const Vec3d &x, const DataType &datum) { grid.delete_entry(round(x*overdx), datum); } void add_box(const Vec3d &xmin, const Vec3d &xmax, const DataType &datum) { Vec3i imin=round(xmin*overdx), imax=round(xmax*overdx); for(int k=imin[2]; k<=imax[2]; ++k) for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i) grid.add(Vec3i(i,j,k), datum); } void delete_box(const Vec3d &xmin, const Vec3d &xmax, const DataType &datum) { Vec3i imin=round(xmin*overdx), imax=round(xmax*overdx); for(int k=imin[2]; k<=imax[2]; ++k) for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i) grid.delete_entry(Vec3i(i,j,k), datum); } unsigned int size(void) const { return grid.size(); } void clear(void) { grid.clear(); } void reserve(unsigned int expected_size) { grid.reserve(expected_size); } bool find_first_point(const Vec3d &x, DataType &index) const { return grid.get_entry(round(x*overdx), index); } bool find_point(const Vec3d &x, std::vector &data_list) const { data_list.resize(0); grid.append_all_entries(round(x*overdx), data_list); return data_list.size()>0; } bool find_box(const Vec3d &xmin, const Vec3d &xmax, std::vector &data_list) const { data_list.resize(0); Vec3i imin=round(xmin*overdx), imax=round(xmax*overdx); for(int k=imin[2]; k<=imax[2]; ++k) for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i) grid.append_all_entries(Vec3i(i, j, k), data_list); return data_list.size()>0; } }; #endif ================================================ FILE: Externals/SDFGen/hashtable.h ================================================ #ifndef HASHTABLE_H #define HASHTABLE_H #include #include #include template struct HashEntry { Key key; Data data; int next; }; // a useful core hash function inline unsigned int hash(unsigned int k) { return k*2654435769u; } // default hash function object struct DefaultHashFunction { template unsigned int operator() (const Key &k) const { return hash(k); } }; struct equal { template bool operator() (const T &a, const T &b) const { return a==b; } }; template struct HashTable { unsigned int table_rank; unsigned int table_bits; std::vector table; unsigned int num_entries; std::vector > pool; int free_list; const HashFunction hash_function; const KeyEqual key_equal; explicit HashTable(unsigned int expected_size=64) : hash_function(HashFunction()), key_equal(KeyEqual()) { init(expected_size); } explicit HashTable(const HashFunction &hf, unsigned int expected_size=64) : hash_function(hf), key_equal(KeyEqual()) { init(expected_size); } void init(unsigned int expected_size) { unsigned int i; num_entries=0; table_rank=4; while(1u<& data_return) const { unsigned int t=hash_function(k)&table_bits; int i=table[t]; while(i!=-1){ if(key_equal(k, pool[i].key)) data_return.push_back(pool[i].data); i=pool[i].next; } } Data &operator() (const Key &k, const Data &missing_data) { unsigned int t=hash_function(k)&table_bits; int i=table[t]; while(i!=-1){ if(key_equal(k, pool[i].key)) return pool[i].data; i=pool[i].next; } add(k, missing_data); // note - this could cause the table to be resized, and t made out-of-date return pool[table[hash_function(k)&table_bits]].data; // we know that add() puts it here! } const Data &operator() (const Key &k, const Data &missing_data) const { unsigned int t=hash_function(k)&table_bits; int i=table[t]; while(i!=-1){ if(key_equal(k, pool[i].key)) return pool[i].data; i=pool[i].next; } return missing_data; } void output_statistics() const { std::vector lengthcount(table.size()); unsigned int t; int total=0; for(t=0; t0){ std::cout<<"length "<0) maxlength=t; std::cout<<"longest list: "< #include #include #include #include #endif #include #include #include #include int main(int argc, char* argv[]) { if(argc != 4) { std::cout << "SDFGen - A utility for converting closed oriented triangle meshes into grid-based signed distance fields.\n"; std::cout << "\nThe output file format is:"; std::cout << " \n"; std::cout << " \n"; std::cout << "\n"; std::cout << " [...]\n\n"; std::cout << "(ni,nj,nk) are the integer dimensions of the resulting distance field.\n"; std::cout << "(origin_x,origin_y,origin_z) is the 3D position of the grid origin.\n"; std::cout << " is the grid spacing.\n\n"; std::cout << " are the signed distance data values, in ascending order of i, then j, then k.\n"; std::cout << "The output filename will match that of the input, with the OBJ suffix replaced with SDF.\n\n"; std::cout << "Usage: SDFGen \n\n"; std::cout << "Where:\n"; std::cout << "\t specifies a Wavefront OBJ (text) file representing a *triangle* mesh (no quad or poly meshes allowed). File must use the suffix \".obj\".\n"; std::cout << "\t specifies the length of grid cell in the resulting distance field.\n"; std::cout << "\t specifies the number of cells worth of padding between the object bound box and the boundary of the distance field grid. Minimum is 1.\n\n"; exit(-1); } std::string filename(argv[1]); if(filename.size() < 5 || filename.substr(filename.size()-4) != std::string(".obj")) { std::cerr << "Error: Expected OBJ file with filename of the form .obj.\n"; exit(-1); } std::stringstream arg2(argv[2]); float dx; arg2 >> dx; std::stringstream arg3(argv[3]); int padding; arg3 >> padding; if(padding < 1) padding = 1; //start with a massive inside out bound box. Vec3f min_box(std::numeric_limits::max(),std::numeric_limits::max(),std::numeric_limits::max()), max_box(-std::numeric_limits::max(),-std::numeric_limits::max(),-std::numeric_limits::max()); std::cout << "Reading data.\n"; std::ifstream infile(argv[1]); if(!infile) { std::cerr << "Failed to open. Terminating.\n"; exit(-1); } int ignored_lines = 0; std::string line; std::vector vertList; std::vector faceList; while(!infile.eof()) { std::getline(infile, line); //.obj files sometimes contain vertex normals indicated by "vn" if(line.substr(0,1) == std::string("v") && line.substr(0,2) != std::string("vn")){ std::stringstream data(line); char c; Vec3f point; data >> c >> point[0] >> point[1] >> point[2]; vertList.push_back(point); update_minmax(point, min_box, max_box); } else if(line.substr(0,1) == std::string("f")) { std::stringstream data(line); char c; int v0,v1,v2; data >> c >> v0 >> v1 >> v2; faceList.push_back(Vec3ui(v0-1,v1-1,v2-1)); } else if( line.substr(0,2) == std::string("vn") ){ std::cerr << "Obj-loader is not able to parse vertex normals, please strip them from the input file. \n"; exit(-2); } else { ++ignored_lines; } } infile.close(); if(ignored_lines > 0) std::cout << "Warning: " << ignored_lines << " lines were ignored since they did not contain faces or vertices.\n"; std::cout << "Read in " << vertList.size() << " vertices and " << faceList.size() << " faces." << std::endl; //Add padding around the box. Vec3f unit(1,1,1); min_box -= padding*dx*unit; max_box += padding*dx*unit; Vec3ui sizes = Vec3ui((max_box - min_box)/dx); std::cout << "Bound box size: (" << min_box << ") to (" << max_box << ") with dimensions " << sizes << "." << std::endl; std::cout << "Computing signed distance field.\n"; Array3f phi_grid; make_level_set3(faceList, vertList, min_box, dx, sizes[0], sizes[1], sizes[2], phi_grid); std::string outname; #ifdef HAVE_VTK // If compiled with VTK, we can directly output a volumetric image format instead //Very hackily strip off file suffix. outname = filename.substr(0, filename.size()-4) + std::string(".vti"); std::cout << "Writing results to: " << outname << "\n"; vtkSmartPointer output_volume = vtkSmartPointer::New(); output_volume->SetDimensions(phi_grid.ni ,phi_grid.nj ,phi_grid.nk); output_volume->SetOrigin( phi_grid.ni*dx/2, phi_grid.nj*dx/2,phi_grid.nk*dx/2); output_volume->SetSpacing(dx,dx,dx); vtkSmartPointer distance = vtkSmartPointer::New(); distance->SetNumberOfTuples(phi_grid.a.size()); output_volume->GetPointData()->AddArray(distance); distance->SetName("Distance"); for(unsigned int i = 0; i < phi_grid.a.size(); ++i) { distance->SetValue(i, phi_grid.a[i]); } vtkSmartPointer writer = vtkSmartPointer::New(); writer->SetFileName(outname.c_str()); #if VTK_MAJOR_VERSION <= 5 writer->SetInput(output_volume); #else writer->SetInputData(output_volume); #endif writer->Write(); #else // if VTK support is missing, default back to the original ascii file-dump. //Very hackily strip off file suffix. outname = filename.substr(0, filename.size()-4) + std::string(".sdf"); std::cout << "Writing results to: " << outname << "\n"; std::ofstream outfile( outname.c_str()); outfile << phi_grid.ni << " " << phi_grid.nj << " " << phi_grid.nk << std::endl; outfile << min_box[0] << " " << min_box[1] << " " << min_box[2] << std::endl; outfile << dx << std::endl; for(unsigned int i = 0; i < phi_grid.a.size(); ++i) { outfile << phi_grid.a[i] << std::endl; } outfile.close(); #endif std::cout << "Processing complete.\n"; return 0; } ================================================ FILE: Externals/SDFGen/makelevelset3.cpp ================================================ #include "makelevelset3.h" // find distance x0 is from segment x1-x2 static float point_segment_distance(const Vec3f &x0, const Vec3f &x1, const Vec3f &x2) { Vec3f dx(x2-x1); double m2=mag2(dx); // find parameter value of closest point on segment float s12=(float)(dot(x2-x0, dx)/m2); if(s12<0){ s12=0; }else if(s12>1){ s12=1; } // and find the distance return dist(x0, s12*x1+(1-s12)*x2); } // find distance x0 is from triangle x1-x2-x3 static float point_triangle_distance(const Vec3f &x0, const Vec3f &x1, const Vec3f &x2, const Vec3f &x3) { // first find barycentric coordinates of closest point on infinite plane Vec3f x13(x1-x3), x23(x2-x3), x03(x0-x3); float m13=mag2(x13), m23=mag2(x23), d=dot(x13,x23); float invdet=1.f/max(m13*m23-d*d,1e-30f); float a=dot(x13,x03), b=dot(x23,x03); // the barycentric coordinates themselves float w23=invdet*(m23*a-d*b); float w31=invdet*(m13*b-d*a); float w12=1-w23-w31; if(w23>=0 && w31>=0 && w12>=0){ // if we're inside the triangle return dist(x0, w23*x1+w31*x2+w12*x3); }else{ // we have to clamp to one of the edges if(w23>0) // this rules out edge 2-3 for us return min(point_segment_distance(x0,x1,x2), point_segment_distance(x0,x1,x3)); else if(w31>0) // this rules out edge 1-3 return min(point_segment_distance(x0,x1,x2), point_segment_distance(x0,x2,x3)); else // w12 must be >0, ruling out edge 1-2 return min(point_segment_distance(x0,x1,x3), point_segment_distance(x0,x2,x3)); } } static void check_neighbour(const std::vector &tri, const std::vector &x, Array3f &phi, Array3i &closest_tri, const Vec3f &gx, int i0, int j0, int k0, int i1, int j1, int k1) { if(closest_tri(i1,j1,k1)>=0){ unsigned int p, q, r; assign(tri[closest_tri(i1,j1,k1)], p, q, r); float d=point_triangle_distance(gx, x[p], x[q], x[r]); if(d &tri, const std::vector &x, Array3f &phi, Array3i &closest_tri, const Vec3f &origin, float dx, int di, int dj, int dk) { int i0, i1; if(di>0){ i0=1; i1=phi.ni; } else{ i0=phi.ni-2; i1=-1; } int j0, j1; if(dj>0){ j0=1; j1=phi.nj; } else{ j0=phi.nj-2; j1=-1; } int k0, k1; if(dk>0){ k0=1; k1=phi.nk; } else{ k0=phi.nk-2; k1=-1; } for(int k=k0; k!=k1; k+=dk) for(int j=j0; j!=j1; j+=dj) for(int i=i0; i!=i1; i+=di){ Vec3f gx(i*dx+origin[0], j*dx+origin[1], k*dx+origin[2]); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j, k); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i, j-dj, k); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j-dj, k); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i, j, k-dk); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j, k-dk); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i, j-dj, k-dk); check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j-dj, k-dk); } } // calculate twice signed area of triangle (0,0)-(x1,y1)-(x2,y2) // return an SOS-determined sign (-1, +1, or 0 only if it's a truly degenerate triangle) static int orientation(double x1, double y1, double x2, double y2, double &twice_signed_area) { twice_signed_area=y1*x2-x1*y2; if(twice_signed_area>0) return 1; else if(twice_signed_area<0) return -1; else if(y2>y1) return 1; else if(y2x2) return 1; else if(x1 &tri, const std::vector &x, const Vec3f &origin, float dx, int ni, int nj, int nk, Array3f &phi, const int exact_band) { phi.resize(ni, nj, nk); phi.assign((ni+nj+nk)*dx); // upper bound on distance Array3i closest_tri(ni, nj, nk, -1); Array3i intersection_count(ni, nj, nk, 0); // intersection_count(i,j,k) is # of tri intersections in (i-1,i]x{j}x{k} // we begin by initializing distances near the mesh, and figuring out intersection counts Vec3f ijkmin, ijkmax; for(unsigned int t=0; t &tri, const std::vector &x, const Vec3f &origin, float dx, int nx, int ny, int nz, Array3f &phi, const int exact_band=1); #endif ================================================ FILE: Externals/SDFGen/util.h ================================================ #ifndef UTIL_H #define UTIL_H #include #include #include #include #ifndef M_PI const double M_PI = 3.1415926535897932384626433832795; #endif #ifdef WIN32 #undef min #undef max #endif using std::min; using std::max; using std::swap; template inline T sqr(const T& x) { return x*x; } template inline T cube(const T& x) { return x*x*x; } template inline T min(T a1, T a2, T a3) { return min(a1, min(a2, a3)); } template inline T min(T a1, T a2, T a3, T a4) { return min(min(a1, a2), min(a3, a4)); } template inline T min(T a1, T a2, T a3, T a4, T a5) { return min(min(a1, a2), min(a3, a4), a5); } template inline T min(T a1, T a2, T a3, T a4, T a5, T a6) { return min(min(a1, a2), min(a3, a4), min(a5, a6)); } template inline T max(T a1, T a2, T a3) { return max(a1, max(a2, a3)); } template inline T max(T a1, T a2, T a3, T a4) { return max(max(a1, a2), max(a3, a4)); } template inline T max(T a1, T a2, T a3, T a4, T a5) { return max(max(a1, a2), max(a3, a4), a5); } template inline T max(T a1, T a2, T a3, T a4, T a5, T a6) { return max(max(a1, a2), max(a3, a4), max(a5, a6)); } template inline void minmax(T a1, T a2, T& amin, T& amax) { if(a1 inline void minmax(T a1, T a2, T a3, T& amin, T& amax) { if(a1 inline void minmax(T a1, T a2, T a3, T a4, T& amin, T& amax) { if(a1 inline void minmax(T a1, T a2, T a3, T a4, T a5, T& amin, T& amax) { //@@@ the logic could be shortcircuited a lot! amin=min(a1,a2,a3,a4,a5); amax=max(a1,a2,a3,a4,a5); } template inline void minmax(T a1, T a2, T a3, T a4, T a5, T a6, T& amin, T& amax) { //@@@ the logic could be shortcircuited a lot! amin=min(a1,a2,a3,a4,a5,a6); amax=max(a1,a2,a3,a4,a5,a6); } template inline void update_minmax(T a1, T& amin, T& amax) { if(a1amax) amax=a1; } template inline void sort(T &a, T &b, T &c) { T temp; if(a inline T clamp(T a, T lower, T upper) { if(aupper) return upper; else return a; } // only makes sense with T=float or double template inline T smooth_step(T r) { if(r<0) return 0; else if(r>1) return 1; return r*r*r*(10+r*(-15+r*6)); } // only makes sense with T=float or double template inline T smooth_step(T r, T r_lower, T r_upper, T value_lower, T value_upper) { return value_lower + smooth_step((r-r_lower)/(r_upper-r_lower)) * (value_upper-value_lower); } // only makes sense with T=float or double template inline T ramp(T r) { return smooth_step((r+1)/2)*2-1; } #ifdef WIN32 inline int lround(double x) { if(x>0) return (x-floor(x)<0.5) ? (int)floor(x) : (int)ceil(x); else return (x-floor(x)<=0.5) ? (int)floor(x) : (int)ceil(x); } inline double remainder(double x, double y) { return x-std::floor(x/y+0.5)*y; } #endif inline unsigned int round_up_to_power_of_two(unsigned int n) { int exponent=0; --n; while(n){ ++exponent; n>>=1; } return 1<1){ ++exponent; n>>=1; } return 1<>16); i*=2654435769u; i^=(i>>16); i*=2654435769u; return i; } // the inverse of randhash inline unsigned int unhash(unsigned int h) { h*=340573321u; h^=(h>>16); h*=340573321u; h^=(h>>16); h*=340573321u; h^=0xA3C59AC3u; return h; } // returns repeatable stateless pseudo-random number in [0,1] inline double randhashd(unsigned int seed) { return randhash(seed)/(double)UINT_MAX; } inline float randhashf(unsigned int seed) { return randhash(seed)/(float)UINT_MAX; } // returns repeatable stateless pseudo-random number in [a,b] inline double randhashd(unsigned int seed, double a, double b) { return (b-a)*randhash(seed)/(double)UINT_MAX + a; } inline float randhashf(unsigned int seed, float a, float b) { return ( (b-a)*randhash(seed)/(float)UINT_MAX + a); } inline int intlog2(int x) { int exp=-1; while(x){ x>>=1; ++exp; } return exp; } template inline void get_barycentric(T x, int& i, T& f, int i_low, int i_high) { T s=std::floor(x); i=(int)s; if(ii_high-2){ i=i_high-2; f=1; }else f=(T)(x-s); } template inline S lerp(const S& value0, const S& value1, T f) { return (1-f)*value0 + f*value1; } template inline S bilerp(const S& v00, const S& v10, const S& v01, const S& v11, T fx, T fy) { return lerp(lerp(v00, v10, fx), lerp(v01, v11, fx), fy); } template inline S trilerp(const S& v000, const S& v100, const S& v010, const S& v110, const S& v001, const S& v101, const S& v011, const S& v111, T fx, T fy, T fz) { return lerp(bilerp(v000, v100, v010, v110, fx, fy), bilerp(v001, v101, v011, v111, fx, fy), fz); } template inline S quadlerp(const S& v0000, const S& v1000, const S& v0100, const S& v1100, const S& v0010, const S& v1010, const S& v0110, const S& v1110, const S& v0001, const S& v1001, const S& v0101, const S& v1101, const S& v0011, const S& v1011, const S& v0111, const S& v1111, T fx, T fy, T fz, T ft) { return lerp(trilerp(v0000, v1000, v0100, v1100, v0010, v1010, v0110, v1110, fx, fy, fz), trilerp(v0001, v1001, v0101, v1101, v0011, v1011, v0111, v1111, fx, fy, fz), ft); } // f should be between 0 and 1, with f=0.5 corresponding to balanced weighting between w0 and w2 template inline void quadratic_bspline_weights(T f, T& w0, T& w1, T& w2) { w0=T(0.5)*sqr(f-1); w1=T(0.75)-sqr(f-T(0.5));; w2=T(0.5)*sqr(f); } // f should be between 0 and 1 template inline void cubic_interp_weights(T f, T& wneg1, T& w0, T& w1, T& w2) { T f2(f*f), f3(f2*f); wneg1=-T(1./3)*f+T(1./2)*f2-T(1./6)*f3; w0=1-f2+T(1./2)*(f3-f); w1=f+T(1./2)*(f2-f3); w2=T(1./6)*(f3-f); } template inline S cubic_interp(const S& value_neg1, const S& value0, const S& value1, const S& value2, T f) { T wneg1, w0, w1, w2; cubic_interp_weights(f, wneg1, w0, w1, w2); return wneg1*value_neg1 + w0*value0 + w1*value1 + w2*value2; } template void zero(std::vector& v) { for(int i=(int)v.size()-1; i>=0; --i) v[i]=0; } template T abs_max(const std::vector& v) { T m=0; for(int i=(int)v.size()-1; i>=0; --i){ if(std::fabs(v[i])>m) m=std::fabs(v[i]); } return m; } template bool contains(const std::vector& a, T e) { for(unsigned int i=0; i void add_unique(std::vector& a, T e) { for(unsigned int i=0; i void insert(std::vector& a, unsigned int index, T e) { a.push_back(a.back()); for(unsigned int i=(unsigned int)a.size()-1; i>index; --i) a[i]=a[i-1]; a[index]=e; } template void erase(std::vector& a, unsigned int index) { for(unsigned int i=index; i void erase_swap(std::vector& a, unsigned int index) { for(unsigned int i=index; i void erase_unordered(std::vector& a, unsigned int index) { a[index]=a.back(); a.pop_back(); } template void erase_unordered_swap(std::vector& a, unsigned int index) { swap(a[index], a.back()); a.pop_back(); } template void find_and_erase_unordered(std::vector& a, const T& doomed_element) { for(unsigned int i=0; i void replace_once(std::vector& a, const T& old_element, const T& new_element) { for(unsigned int i=0; i void write_matlab(std::ostream& output, const std::vector& a, const char *variable_name, bool column_vector=true, int significant_digits=18) { output< #include #include #include "util.h" // Defines a thin wrapper around fixed size C-style arrays, using template parameters, // which is useful for dealing with vectors of different dimensions. // For example, float[3] is equivalent to Vec<3,float>. // Entries in the vector are accessed with the overloaded [] operator, so // for example if x is a Vec<3,float>, then the middle entry is x[1]. // For convenience, there are a number of typedefs for abbreviation: // Vec<3,float> -> Vec3f // Vec<2,int> -> Vec2i // and so on. // Arithmetic operators are appropriately overloaded, and functions are defined // for additional operations (such as dot-products, norms, cross-products, etc.) template struct Vec { T v[N]; Vec(void) {} explicit Vec(T value_for_all) { for(unsigned int i=0; i explicit Vec(const S *source) { for(unsigned int i=0; i explicit Vec(const Vec& source) { for(unsigned int i=0; i(T v0, T v1) { assert(N==2); v[0]=v0; v[1]=v1; } Vec(T v0, T v1, T v2) { assert(N==3); v[0]=v0; v[1]=v1; v[2]=v2; } Vec(T v0, T v1, T v2, T v3) { assert(N==4); v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; } Vec(T v0, T v1, T v2, T v3, T v4) { assert(N==5); v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4; } Vec(T v0, T v1, T v2, T v3, T v4, T v5) { assert(N==6); v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4; v[5]=v5; } T &operator[](int index) { assert(0<=index && (unsigned int)index operator+=(const Vec &w) { for(unsigned int i=0; i operator+(const Vec &w) const { Vec sum(*this); sum+=w; return sum; } Vec operator-=(const Vec &w) { for(unsigned int i=0; i operator-(void) const // unary minus { Vec negative; for(unsigned int i=0; i operator-(const Vec &w) const // (binary) subtraction { Vec diff(*this); diff-=w; return diff; } Vec operator*=(T a) { for(unsigned int i=0; i operator*(T a) const { Vec w(*this); w*=a; return w; } Vec operator*=(const Vec &w) { for(unsigned int i=0; i operator*(const Vec &w) const { Vec componentwise_product; for(unsigned int i=0; i operator/=(T a) { for(unsigned int i=0; i operator/(T a) const { Vec w(*this); w/=a; return w; } }; typedef Vec<2,double> Vec2d; typedef Vec<2,float> Vec2f; typedef Vec<2,int> Vec2i; typedef Vec<2,unsigned int> Vec2ui; typedef Vec<2,short> Vec2s; typedef Vec<2,unsigned short> Vec2us; typedef Vec<2,char> Vec2c; typedef Vec<2,unsigned char> Vec2uc; typedef Vec<3,double> Vec3d; typedef Vec<3,float> Vec3f; typedef Vec<3,int> Vec3i; typedef Vec<3,unsigned int> Vec3ui; typedef Vec<3,short> Vec3s; typedef Vec<3,unsigned short> Vec3us; typedef Vec<3,char> Vec3c; typedef Vec<3,unsigned char> Vec3uc; typedef Vec<4,double> Vec4d; typedef Vec<4,float> Vec4f; typedef Vec<4,int> Vec4i; typedef Vec<4,unsigned int> Vec4ui; typedef Vec<4,short> Vec4s; typedef Vec<4,unsigned short> Vec4us; typedef Vec<4,char> Vec4c; typedef Vec<4,unsigned char> Vec4uc; typedef Vec<6,double> Vec6d; typedef Vec<6,float> Vec6f; typedef Vec<6,unsigned int> Vec6ui; typedef Vec<6,int> Vec6i; typedef Vec<6,short> Vec6s; typedef Vec<6,unsigned short> Vec6us; typedef Vec<6,char> Vec6c; typedef Vec<6,unsigned char> Vec6uc; template T mag2(const Vec &a) { T l=sqr(a.v[0]); for(unsigned int i=1; i T mag(const Vec &a) { return sqrt(mag2(a)); } template inline T dist2(const Vec &a, const Vec &b) { T d=sqr(a.v[0]-b.v[0]); for(unsigned int i=1; i inline T dist(const Vec &a, const Vec &b) { return std::sqrt(dist2(a,b)); } template inline void normalize(Vec &a) { a/=mag(a); } template inline Vec normalized(const Vec &a) { return a/mag(a); } template inline T infnorm(const Vec &a) { T d=std::fabs(a.v[0]); for(unsigned int i=1; i void zero(Vec &a) { for(unsigned int i=0; i std::ostream &operator<<(std::ostream &out, const Vec &v) { out< std::istream &operator>>(std::istream &in, Vec &v) { in>>v.v[0]; for(unsigned int i=1; i>v.v[i]; return in; } template inline bool operator==(const Vec &a, const Vec &b) { bool t = (a.v[0] == b.v[0]); unsigned int i=1; while(i inline bool operator!=(const Vec &a, const Vec &b) { bool t = (a.v[0] != b.v[0]); unsigned int i=1; while(i inline Vec operator*(T a, const Vec &v) { Vec w(v); w*=a; return w; } template inline T min(const Vec &a) { T m=a.v[0]; for(unsigned int i=1; i inline Vec min_union(const Vec &a, const Vec &b) { Vec m; for(unsigned int i=0; i inline Vec max_union(const Vec &a, const Vec &b) { Vec m; for(unsigned int i=0; i b.v[i]) ? m.v[i]=a.v[i] : m.v[i]=b.v[i]; return m; } template inline T max(const Vec &a) { T m=a.v[0]; for(unsigned int i=1; im) m=a.v[i]; return m; } template inline T dot(const Vec &a, const Vec &b) { T d=a.v[0]*b.v[0]; for(unsigned int i=1; i inline Vec<2,T> rotate(const Vec<2,T>& a, float angle) { T c = cos(angle); T s = sin(angle); return Vec<2,T>(c*a[0] - s*a[1],s*a[0] + c*a[1]); // counter-clockwise rotation } template inline Vec<2,T> perp(const Vec<2,T> &a) { return Vec<2,T>(-a.v[1], a.v[0]); } // counter-clockwise rotation by 90 degrees template inline T cross(const Vec<2,T> &a, const Vec<2,T> &b) { return a.v[0]*b.v[1]-a.v[1]*b.v[0]; } template inline Vec<3,T> cross(const Vec<3,T> &a, const Vec<3,T> &b) { return Vec<3,T>(a.v[1]*b.v[2]-a.v[2]*b.v[1], a.v[2]*b.v[0]-a.v[0]*b.v[2], a.v[0]*b.v[1]-a.v[1]*b.v[0]); } template inline T triple(const Vec<3,T> &a, const Vec<3,T> &b, const Vec<3,T> &c) { return a.v[0]*(b.v[1]*c.v[2]-b.v[2]*c.v[1]) +a.v[1]*(b.v[2]*c.v[0]-b.v[0]*c.v[2]) +a.v[2]*(b.v[0]*c.v[1]-b.v[1]*c.v[0]); } template inline unsigned int hash(const Vec &a) { unsigned int h=a.v[0]; for(unsigned int i=1; i inline void assign(const Vec &a, T &a0, T &a1) { assert(N==2); a0=a.v[0]; a1=a.v[1]; } template inline void assign(const Vec &a, T &a0, T &a1, T &a2) { assert(N==3); a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; } template inline void assign(const Vec &a, T &a0, T &a1, T &a2, T &a3) { assert(N==4); a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; a3=a.v[3]; } template inline void assign(const Vec &a, T &a0, T &a1, T &a2, T &a3, T &a4, T &a5) { assert(N==6); a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; a3=a.v[3]; a4=a.v[4]; a5=a.v[5]; } template inline Vec round(const Vec &a) { Vec rounded; for(unsigned int i=0; i inline Vec floor(const Vec &a) { Vec rounded; for(unsigned int i=0; i inline Vec ceil(const Vec &a) { Vec rounded; for(unsigned int i=0; i inline Vec fabs(const Vec &a) { Vec result; for(unsigned int i=0; i inline void minmax(const Vec &x0, const Vec &x1, Vec &xmin, Vec &xmax) { for(unsigned int i=0; i inline void minmax(const Vec &x0, const Vec &x1, const Vec &x2, Vec &xmin, Vec &xmax) { for(unsigned int i=0; i inline void minmax(const Vec &x0, const Vec &x1, const Vec &x2, const Vec &x3, Vec &xmin, Vec &xmax) { for(unsigned int i=0; i inline void minmax(const Vec &x0, const Vec &x1, const Vec &x2, const Vec &x3, const Vec &x4, Vec &xmin, Vec &xmax) { for(unsigned int i=0; i inline void minmax(const Vec &x0, const Vec &x1, const Vec &x2, const Vec &x3, const Vec &x4, const Vec &x5, Vec &xmin, Vec &xmax) { for(unsigned int i=0; i inline void update_minmax(const Vec &x, Vec &xmin, Vec &xmax) { for(unsigned int i=0; i. /// #ifndef TL_FUNCTION_REF_HPP #define TL_FUNCTION_REF_HPP #define TL_FUNCTION_REF_VERSION_MAJOR 1 #define TL_FUNCTION_REF_VERSION_MINOR 0 #define TL_FUNCTION_REF_VERSION_PATCH 0 #if (defined(_MSC_VER) && _MSC_VER == 1900) /// \exclude #define TL_FUNCTION_REF_MSVC2015 #endif #if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \ !defined(__clang__)) /// \exclude #define TL_FUNCTION_REF_GCC49 #endif #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \ !defined(__clang__)) /// \exclude #define TL_FUNCTION_REF_GCC54 #endif #if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \ !defined(__clang__)) // GCC < 5 doesn't support overloading on const&& for member functions /// \exclude #define TL_FUNCTION_REF_NO_CONSTRR #endif #if __cplusplus > 201103L /// \exclude #define TL_FUNCTION_REF_CXX14 #endif // constexpr implies const in C++11, not C++14 #if (__cplusplus == 201103L || defined(TL_FUNCTION_REF_MSVC2015) || \ defined(TL_FUNCTION_REF_GCC49)) && \ !defined(TL_FUNCTION_REF_GCC54) /// \exclude #define TL_FUNCTION_REF_11_CONSTEXPR #else /// \exclude #define TL_FUNCTION_REF_11_CONSTEXPR constexpr #endif #include #include namespace tl { namespace detail { namespace fnref { // C++14-style aliases for brevity template using remove_const_t = typename std::remove_const::type; template using remove_reference_t = typename std::remove_reference::type; template using decay_t = typename std::decay::type; template using enable_if_t = typename std::enable_if::type; template using conditional_t = typename std::conditional::type; // std::invoke from C++17 // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround template >::value>, int = 0> constexpr auto invoke(Fn &&f, Args &&... args) noexcept( noexcept(std::mem_fn(f)(std::forward(args)...))) -> decltype(std::mem_fn(f)(std::forward(args)...)) { return std::mem_fn(f)(std::forward(args)...); } template >{}>> constexpr auto invoke(Fn &&f, Args &&... args) noexcept( noexcept(std::forward(f)(std::forward(args)...))) -> decltype(std::forward(f)(std::forward(args)...)) { return std::forward(f)(std::forward(args)...); } // std::invoke_result from C++17 template struct invoke_result_impl; template struct invoke_result_impl< F, decltype(tl::detail::fnref::invoke(std::declval(), std::declval()...), void()), Us...> { using type = decltype(tl::detail::fnref::invoke(std::declval(), std::declval()...)); }; template using invoke_result = invoke_result_impl; template using invoke_result_t = typename invoke_result::type; template struct is_invocable_r_impl : std::false_type {}; template struct is_invocable_r_impl< typename std::is_convertible, R>::type, R, F, Args...> : std::true_type {}; template using is_invocable_r = is_invocable_r_impl; } // namespace detail } // namespace fnref /// A lightweight non-owning reference to a callable. /// /// Example usage: /// /// ```cpp /// void foo (function_ref func) { /// std::cout << "Result is " << func(21); //42 /// } /// /// foo([](int i) { return i*2; }); template class function_ref; /// Specialization for function types. template class function_ref { public: constexpr function_ref() noexcept = delete; /// Creates a `function_ref` which refers to the same callable as `rhs`. constexpr function_ref(const function_ref &rhs) noexcept = default; /// Constructs a `function_ref` referring to `f`. /// /// \synopsis template constexpr function_ref(F &&f) noexcept template , function_ref>::value && detail::fnref::is_invocable_r::value> * = nullptr> TL_FUNCTION_REF_11_CONSTEXPR function_ref(F &&f) noexcept : obj_(const_cast(reinterpret_cast(std::addressof(f)))) { callback_ = [](void *obj, Args... args) -> R { return detail::fnref::invoke( *reinterpret_cast::type>(obj), std::forward(args)...); }; } /// Makes `*this` refer to the same callable as `rhs`. TL_FUNCTION_REF_11_CONSTEXPR function_ref & operator=(const function_ref &rhs) noexcept = default; /// Makes `*this` refer to `f`. /// /// \synopsis template constexpr function_ref &operator=(F &&f) noexcept; template ::value> * = nullptr> TL_FUNCTION_REF_11_CONSTEXPR function_ref &operator=(F &&f) noexcept { obj_ = reinterpret_cast(std::addressof(f)); callback_ = [](void *obj, Args... args) { return detail::fnref::invoke( *reinterpret_cast::type>(obj), std::forward(args)...); }; return *this; } /// Swaps the referred callables of `*this` and `rhs`. constexpr void swap(function_ref &rhs) noexcept { std::swap(obj_, rhs.obj_); std::swap(callback_, rhs.callback_); } /// Call the stored callable with the given arguments. R operator()(Args... args) const { return callback_(obj_, std::forward(args)...); } private: void *obj_ = nullptr; R (*callback_)(void *, Args...) = nullptr; }; /// Swaps the referred callables of `lhs` and `rhs`. template constexpr void swap(function_ref &lhs, function_ref &rhs) noexcept { lhs.swap(rhs); } #if __cplusplus >= 201703L template function_ref(R (*)(Args...))->function_ref; // TODO, will require some kind of callable traits // template // function_ref(F) -> function_ref; #endif } // namespace tl #endif ================================================ FILE: Externals/optional/tl/optional.hpp ================================================ /// // optional - An implementation of std::optional with extensions // Written in 2017 by Simon Brand (simonrbrand@gmail.com, @TartanLlama) // // Documentation available at https://tl.tartanllama.xyz/ // // To the extent possible under law, the author(s) have dedicated all // copyright and related and neighboring rights to this software to the // public domain worldwide. This software is distributed without any warranty. // // You should have received a copy of the CC0 Public Domain Dedication // along with this software. If not, see // . /// #ifndef TL_OPTIONAL_HPP #define TL_OPTIONAL_HPP #define TL_OPTIONAL_VERSION_MAJOR 1 #define TL_OPTIONAL_VERSION_MINOR 0 #define TL_OPTIONAL_VERSION_PATCH 0 #include #include #include #include #include #if (defined(_MSC_VER) && _MSC_VER == 1900) #define TL_OPTIONAL_MSVC2015 #endif #if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \ !defined(__clang__)) #define TL_OPTIONAL_GCC49 #endif #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \ !defined(__clang__)) #define TL_OPTIONAL_GCC54 #endif #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && \ !defined(__clang__)) #define TL_OPTIONAL_GCC55 #endif #if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \ !defined(__clang__)) // GCC < 5 doesn't support overloading on const&& for member functions #define TL_OPTIONAL_NO_CONSTRR // GCC < 5 doesn't support some standard C++11 type traits #define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ std::has_trivial_copy_constructor::value #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign::value // This one will be different for GCC 5.7 if it's ever supported #define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value // GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks std::vector // for non-copyable types #elif (defined(__GNUC__) && __GNUC__ < 8 && \ !defined(__clang__)) #ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX #define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX namespace tl { namespace detail { template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible{}; #ifdef _GLIBCXX_VECTOR template struct is_trivially_copy_constructible> : std::is_trivially_copy_constructible{}; #endif } } #endif #define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ tl::detail::is_trivially_copy_constructible::value #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ std::is_trivially_copy_assignable::value #define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value #else #define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ std::is_trivially_copy_constructible::value #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ std::is_trivially_copy_assignable::value #define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value #endif #if __cplusplus > 201103L #define TL_OPTIONAL_CXX14 #endif // constexpr implies const in C++11, not C++14 #if (__cplusplus == 201103L || defined(TL_OPTIONAL_MSVC2015) || \ defined(TL_OPTIONAL_GCC49)) #define TL_OPTIONAL_11_CONSTEXPR #else #define TL_OPTIONAL_11_CONSTEXPR constexpr #endif namespace tl { #ifndef TL_MONOSTATE_INPLACE_MUTEX #define TL_MONOSTATE_INPLACE_MUTEX /// Used to represent an optional with no data; essentially a bool class monostate {}; /// A tag type to tell optional to construct its value in-place struct in_place_t { explicit in_place_t() = default; }; /// A tag to tell optional to construct its value in-place static constexpr in_place_t in_place{}; #endif template class optional; namespace detail { #ifndef TL_TRAITS_MUTEX #define TL_TRAITS_MUTEX // C++14-style aliases for brevity template using remove_const_t = typename std::remove_const::type; template using remove_reference_t = typename std::remove_reference::type; template using decay_t = typename std::decay::type; template using enable_if_t = typename std::enable_if::type; template using conditional_t = typename std::conditional::type; // std::conjunction from C++17 template struct conjunction : std::true_type {}; template struct conjunction : B {}; template struct conjunction : std::conditional, B>::type {}; #if defined(_LIBCPP_VERSION) && __cplusplus == 201103L #define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND #endif // In C++11 mode, there's an issue in libc++'s std::mem_fn // which results in a hard-error when using it in a noexcept expression // in some cases. This is a check to workaround the common failing case. #ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND template struct is_pointer_to_non_const_member_func : std::false_type{}; template struct is_pointer_to_non_const_member_func : std::true_type{}; template struct is_pointer_to_non_const_member_func : std::true_type{}; template struct is_pointer_to_non_const_member_func : std::true_type{}; template struct is_pointer_to_non_const_member_func : std::true_type{}; template struct is_pointer_to_non_const_member_func : std::true_type{}; template struct is_pointer_to_non_const_member_func : std::true_type{}; template struct is_const_or_const_ref : std::false_type{}; template struct is_const_or_const_ref : std::true_type{}; template struct is_const_or_const_ref : std::true_type{}; #endif // std::invoke from C++17 // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround template ::value && is_const_or_const_ref::value)>, #endif typename = enable_if_t>::value>, int = 0> constexpr auto invoke(Fn &&f, Args &&... args) noexcept( noexcept(std::mem_fn(f)(std::forward(args)...))) -> decltype(std::mem_fn(f)(std::forward(args)...)) { return std::mem_fn(f)(std::forward(args)...); } template >::value>> constexpr auto invoke(Fn &&f, Args &&... args) noexcept( noexcept(std::forward(f)(std::forward(args)...))) -> decltype(std::forward(f)(std::forward(args)...)) { return std::forward(f)(std::forward(args)...); } // std::invoke_result from C++17 template struct invoke_result_impl; template struct invoke_result_impl< F, decltype(detail::invoke(std::declval(), std::declval()...), void()), Us...> { using type = decltype(detail::invoke(std::declval(), std::declval()...)); }; template using invoke_result = invoke_result_impl; template using invoke_result_t = typename invoke_result::type; #if defined(_MSC_VER) && _MSC_VER <= 1900 // TODO make a version which works with MSVC 2015 template struct is_swappable : std::true_type {}; template struct is_nothrow_swappable : std::true_type {}; #else // https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept namespace swap_adl_tests { // if swap ADL finds this then it would call std::swap otherwise (same // signature) struct tag {}; template tag swap(T &, T &); template tag swap(T (&a)[N], T (&b)[N]); // helper functions to test if an unqualified swap is possible, and if it // becomes std::swap template std::false_type can_swap(...) noexcept(false); template (), std::declval()))> std::true_type can_swap(int) noexcept(noexcept(swap(std::declval(), std::declval()))); template std::false_type uses_std(...); template std::is_same(), std::declval())), tag> uses_std(int); template struct is_std_swap_noexcept : std::integral_constant::value && std::is_nothrow_move_assignable::value> {}; template struct is_std_swap_noexcept : is_std_swap_noexcept {}; template struct is_adl_swap_noexcept : std::integral_constant(0))> {}; } // namespace swap_adl_tests template struct is_swappable : std::integral_constant< bool, decltype(detail::swap_adl_tests::can_swap(0))::value && (!decltype(detail::swap_adl_tests::uses_std(0))::value || (std::is_move_assignable::value && std::is_move_constructible::value))> {}; template struct is_swappable : std::integral_constant< bool, decltype(detail::swap_adl_tests::can_swap(0))::value && (!decltype( detail::swap_adl_tests::uses_std(0))::value || is_swappable::value)> {}; template struct is_nothrow_swappable : std::integral_constant< bool, is_swappable::value && ((decltype(detail::swap_adl_tests::uses_std(0))::value &&detail::swap_adl_tests::is_std_swap_noexcept::value) || (!decltype(detail::swap_adl_tests::uses_std(0))::value && detail::swap_adl_tests::is_adl_swap_noexcept::value))> { }; #endif #endif // std::void_t from C++17 template struct voider { using type = void; }; template using void_t = typename voider::type; // Trait for checking if a type is a tl::optional template struct is_optional_impl : std::false_type {}; template struct is_optional_impl> : std::true_type {}; template using is_optional = is_optional_impl>; // Change void to tl::monostate template using fixup_void = conditional_t::value, monostate, U>; template > using get_map_return = optional>>; // Check if invoking F for some Us returns void template struct returns_void_impl; template struct returns_void_impl>, U...> : std::is_void> {}; template using returns_void = returns_void_impl; template using enable_if_ret_void = enable_if_t::value>; template using disable_if_ret_void = enable_if_t::value>; template using enable_forward_value = detail::enable_if_t::value && !std::is_same, in_place_t>::value && !std::is_same, detail::decay_t>::value>; template using enable_from_other = detail::enable_if_t< std::is_constructible::value && !std::is_constructible &>::value && !std::is_constructible &&>::value && !std::is_constructible &>::value && !std::is_constructible &&>::value && !std::is_convertible &, T>::value && !std::is_convertible &&, T>::value && !std::is_convertible &, T>::value && !std::is_convertible &&, T>::value>; template using enable_assign_forward = detail::enable_if_t< !std::is_same, detail::decay_t>::value && !detail::conjunction, std::is_same>>::value && std::is_constructible::value && std::is_assignable::value>; template using enable_assign_from_other = detail::enable_if_t< std::is_constructible::value && std::is_assignable::value && !std::is_constructible &>::value && !std::is_constructible &&>::value && !std::is_constructible &>::value && !std::is_constructible &&>::value && !std::is_convertible &, T>::value && !std::is_convertible &&, T>::value && !std::is_convertible &, T>::value && !std::is_convertible &&, T>::value && !std::is_assignable &>::value && !std::is_assignable &&>::value && !std::is_assignable &>::value && !std::is_assignable &&>::value>; // The storage base manages the actual storage, and correctly propagates // trivial destruction from T. This case is for when T is not trivially // destructible. template ::value> struct optional_storage_base { TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {} template TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u) : m_value(std::forward(u)...), m_has_value(true) {} ~optional_storage_base() { if (m_has_value) { m_value.~T(); m_has_value = false; } } struct dummy {}; union { dummy m_dummy; T m_value; }; bool m_has_value; }; // This case is for when T is trivially destructible. template struct optional_storage_base { TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {} template TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u) : m_value(std::forward(u)...), m_has_value(true) {} // No destructor, so this class is trivially destructible struct dummy {}; union { dummy m_dummy; T m_value; }; bool m_has_value = false; }; // This base class provides some handy member functions which can be used in // further derived classes template struct optional_operations_base : optional_storage_base { using optional_storage_base::optional_storage_base; void hard_reset() noexcept { get().~T(); this->m_has_value = false; } template void construct(Args &&... args) noexcept { new (std::addressof(this->m_value)) T(std::forward(args)...); this->m_has_value = true; } template void assign(Opt &&rhs) { if (this->has_value()) { if (rhs.has_value()) { this->m_value = std::forward(rhs).get(); } else { this->m_value.~T(); this->m_has_value = false; } } else if (rhs.has_value()) { construct(std::forward(rhs).get()); } } bool has_value() const { return this->m_has_value; } TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; } TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_value; } TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_value); } #ifndef TL_OPTIONAL_NO_CONSTRR constexpr const T &&get() const && { return std::move(this->m_value); } #endif }; // This class manages conditionally having a trivial copy constructor // This specialization is for when T is trivially copy constructible template struct optional_copy_base : optional_operations_base { using optional_operations_base::optional_operations_base; }; // This specialization is for when T is not trivially copy constructible template struct optional_copy_base : optional_operations_base { using optional_operations_base::optional_operations_base; optional_copy_base() = default; optional_copy_base(const optional_copy_base &rhs) { if (rhs.has_value()) { this->construct(rhs.get()); } else { this->m_has_value = false; } } optional_copy_base(optional_copy_base &&rhs) = default; optional_copy_base &operator=(const optional_copy_base &rhs) = default; optional_copy_base &operator=(optional_copy_base &&rhs) = default; }; // This class manages conditionally having a trivial move constructor // Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it // doesn't implement an analogue to std::is_trivially_move_constructible. We // have to make do with a non-trivial move constructor even if T is trivially // move constructible #ifndef TL_OPTIONAL_GCC49 template ::value> struct optional_move_base : optional_copy_base { using optional_copy_base::optional_copy_base; }; #else template struct optional_move_base; #endif template struct optional_move_base : optional_copy_base { using optional_copy_base::optional_copy_base; optional_move_base() = default; optional_move_base(const optional_move_base &rhs) = default; optional_move_base(optional_move_base &&rhs) noexcept( std::is_nothrow_move_constructible::value) { if (rhs.has_value()) { this->construct(std::move(rhs.get())); } else { this->m_has_value = false; } } optional_move_base &operator=(const optional_move_base &rhs) = default; optional_move_base &operator=(optional_move_base &&rhs) = default; }; // This class manages conditionally having a trivial copy assignment operator template struct optional_copy_assign_base : optional_move_base { using optional_move_base::optional_move_base; }; template struct optional_copy_assign_base : optional_move_base { using optional_move_base::optional_move_base; optional_copy_assign_base() = default; optional_copy_assign_base(const optional_copy_assign_base &rhs) = default; optional_copy_assign_base(optional_copy_assign_base &&rhs) = default; optional_copy_assign_base &operator=(const optional_copy_assign_base &rhs) { this->assign(rhs); return *this; } optional_copy_assign_base & operator=(optional_copy_assign_base &&rhs) = default; }; // This class manages conditionally having a trivial move assignment operator // Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it // doesn't implement an analogue to std::is_trivially_move_assignable. We have // to make do with a non-trivial move assignment operator even if T is trivially // move assignable #ifndef TL_OPTIONAL_GCC49 template ::value &&std::is_trivially_move_constructible::value &&std::is_trivially_move_assignable::value> struct optional_move_assign_base : optional_copy_assign_base { using optional_copy_assign_base::optional_copy_assign_base; }; #else template struct optional_move_assign_base; #endif template struct optional_move_assign_base : optional_copy_assign_base { using optional_copy_assign_base::optional_copy_assign_base; optional_move_assign_base() = default; optional_move_assign_base(const optional_move_assign_base &rhs) = default; optional_move_assign_base(optional_move_assign_base &&rhs) = default; optional_move_assign_base & operator=(const optional_move_assign_base &rhs) = default; optional_move_assign_base & operator=(optional_move_assign_base &&rhs) noexcept( std::is_nothrow_move_constructible::value &&std::is_nothrow_move_assignable::value) { this->assign(std::move(rhs)); return *this; } }; // optional_delete_ctor_base will conditionally delete copy and move // constructors depending on whether T is copy/move constructible template ::value, bool EnableMove = std::is_move_constructible::value> struct optional_delete_ctor_base { optional_delete_ctor_base() = default; optional_delete_ctor_base(const optional_delete_ctor_base &) = default; optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default; optional_delete_ctor_base & operator=(const optional_delete_ctor_base &) = default; optional_delete_ctor_base & operator=(optional_delete_ctor_base &&) noexcept = default; }; template struct optional_delete_ctor_base { optional_delete_ctor_base() = default; optional_delete_ctor_base(const optional_delete_ctor_base &) = default; optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete; optional_delete_ctor_base & operator=(const optional_delete_ctor_base &) = default; optional_delete_ctor_base & operator=(optional_delete_ctor_base &&) noexcept = default; }; template struct optional_delete_ctor_base { optional_delete_ctor_base() = default; optional_delete_ctor_base(const optional_delete_ctor_base &) = delete; optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = default; optional_delete_ctor_base & operator=(const optional_delete_ctor_base &) = default; optional_delete_ctor_base & operator=(optional_delete_ctor_base &&) noexcept = default; }; template struct optional_delete_ctor_base { optional_delete_ctor_base() = default; optional_delete_ctor_base(const optional_delete_ctor_base &) = delete; optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept = delete; optional_delete_ctor_base & operator=(const optional_delete_ctor_base &) = default; optional_delete_ctor_base & operator=(optional_delete_ctor_base &&) noexcept = default; }; // optional_delete_assign_base will conditionally delete copy and move // constructors depending on whether T is copy/move constructible + assignable template ::value && std::is_copy_assignable::value), bool EnableMove = (std::is_move_constructible::value && std::is_move_assignable::value)> struct optional_delete_assign_base { optional_delete_assign_base() = default; optional_delete_assign_base(const optional_delete_assign_base &) = default; optional_delete_assign_base(optional_delete_assign_base &&) noexcept = default; optional_delete_assign_base & operator=(const optional_delete_assign_base &) = default; optional_delete_assign_base & operator=(optional_delete_assign_base &&) noexcept = default; }; template struct optional_delete_assign_base { optional_delete_assign_base() = default; optional_delete_assign_base(const optional_delete_assign_base &) = default; optional_delete_assign_base(optional_delete_assign_base &&) noexcept = default; optional_delete_assign_base & operator=(const optional_delete_assign_base &) = default; optional_delete_assign_base & operator=(optional_delete_assign_base &&) noexcept = delete; }; template struct optional_delete_assign_base { optional_delete_assign_base() = default; optional_delete_assign_base(const optional_delete_assign_base &) = default; optional_delete_assign_base(optional_delete_assign_base &&) noexcept = default; optional_delete_assign_base & operator=(const optional_delete_assign_base &) = delete; optional_delete_assign_base & operator=(optional_delete_assign_base &&) noexcept = default; }; template struct optional_delete_assign_base { optional_delete_assign_base() = default; optional_delete_assign_base(const optional_delete_assign_base &) = default; optional_delete_assign_base(optional_delete_assign_base &&) noexcept = default; optional_delete_assign_base & operator=(const optional_delete_assign_base &) = delete; optional_delete_assign_base & operator=(optional_delete_assign_base &&) noexcept = delete; }; } // namespace detail /// A tag type to represent an empty optional struct nullopt_t { struct do_not_use {}; constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {} }; /// Represents an empty optional static constexpr nullopt_t nullopt{nullopt_t::do_not_use{}, nullopt_t::do_not_use{}}; class bad_optional_access : public std::exception { public: bad_optional_access() = default; const char *what() const noexcept { return "Optional has no value"; } }; /// An optional object is an object that contains the storage for another /// object and manages the lifetime of this contained object, if any. The /// contained object may be initialized after the optional object has been /// initialized, and may be destroyed before the optional object has been /// destroyed. The initialization state of the contained object is tracked by /// the optional object. template class optional : private detail::optional_move_assign_base, private detail::optional_delete_ctor_base, private detail::optional_delete_assign_base { using base = detail::optional_move_assign_base; static_assert(!std::is_same::value, "instantiation of optional with in_place_t is ill-formed"); static_assert(!std::is_same, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed"); public: // The different versions for C++14 and 11 are needed because deduced return // types are not SFINAE-safe. This provides better support for things like // generic lambdas. C.f. // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0826r0.html #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \ !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55) /// Carries out some operation which returns an optional on the stored /// object if there is one. template TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } template TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : result(nullopt); } template constexpr auto and_then(F &&f) const & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr auto and_then(F &&f) const && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : result(nullopt); } #endif #else /// Carries out some operation which returns an optional on the stored /// object if there is one. template TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t and_then(F &&f) & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } template TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t and_then(F &&f) && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : result(nullopt); } template constexpr detail::invoke_result_t and_then(F &&f) const & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr detail::invoke_result_t and_then(F &&f) const && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : result(nullopt); } #endif #endif #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \ !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55) /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & { return optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && { return optional_map_impl(std::move(*this), std::forward(f)); } template constexpr auto map(F &&f) const & { return optional_map_impl(*this, std::forward(f)); } template constexpr auto map(F &&f) const && { return optional_map_impl(std::move(*this), std::forward(f)); } #else /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval(), std::declval())) map(F &&f) & { return optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval(), std::declval())) map(F &&f) && { return optional_map_impl(std::move(*this), std::forward(f)); } template constexpr decltype(optional_map_impl(std::declval(), std::declval())) map(F &&f) const & { return optional_map_impl(*this, std::forward(f)); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr decltype(optional_map_impl(std::declval(), std::declval())) map(F &&f) const && { return optional_map_impl(std::move(*this), std::forward(f)); } #endif #endif #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \ !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55) /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & { return optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && { return optional_map_impl(std::move(*this), std::forward(f)); } template constexpr auto transform(F&& f) const & { return optional_map_impl(*this, std::forward(f)); } template constexpr auto transform(F&& f) const && { return optional_map_impl(std::move(*this), std::forward(f)); } #else /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval(), std::declval())) transform(F&& f) & { return optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval(), std::declval())) transform(F&& f) && { return optional_map_impl(std::move(*this), std::forward(f)); } template constexpr decltype(optional_map_impl(std::declval(), std::declval())) transform(F&& f) const & { return optional_map_impl(*this, std::forward(f)); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr decltype(optional_map_impl(std::declval(), std::declval())) transform(F&& f) const && { return optional_map_impl(std::move(*this), std::forward(f)); } #endif #endif /// Calls `f` if the optional is empty template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & { if (has_value()) return *this; std::forward(f)(); return nullopt; } template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & { return has_value() ? *this : std::forward(f)(); } template * = nullptr> optional or_else(F &&f) && { if (has_value()) return std::move(*this); std::forward(f)(); return nullopt; } template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) && { return has_value() ? std::move(*this) : std::forward(f)(); } template * = nullptr> optional or_else(F &&f) const & { if (has_value()) return *this; std::forward(f)(); return nullopt; } template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) const & { return has_value() ? *this : std::forward(f)(); } #ifndef TL_OPTIONAL_NO_CONSTRR template * = nullptr> optional or_else(F &&f) const && { if (has_value()) return std::move(*this); std::forward(f)(); return nullopt; } template * = nullptr> optional or_else(F &&f) const && { return has_value() ? std::move(*this) : std::forward(f)(); } #endif /// Maps the stored value with `f` if there is one, otherwise returns `u`. template U map_or(F &&f, U &&u) & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u); } template U map_or(F &&f, U &&u) && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u); } template U map_or(F &&f, U &&u) const & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u); } #ifndef TL_OPTIONAL_NO_CONSTRR template U map_or(F &&f, U &&u) const && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u); } #endif /// Maps the stored value with `f` if there is one, otherwise calls /// `u` and returns the result. template detail::invoke_result_t map_or_else(F &&f, U &&u) & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u)(); } template detail::invoke_result_t map_or_else(F &&f, U &&u) && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u)(); } template detail::invoke_result_t map_or_else(F &&f, U &&u) const & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u)(); } #ifndef TL_OPTIONAL_NO_CONSTRR template detail::invoke_result_t map_or_else(F &&f, U &&u) const && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u)(); } #endif /// Returns `u` if `*this` has a value, otherwise an empty optional. template constexpr optional::type> conjunction(U &&u) const { using result = optional>; return has_value() ? result{u} : result{nullopt}; } /// Returns `rhs` if `*this` is empty, otherwise the current value. TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & { return has_value() ? *this : rhs; } constexpr optional disjunction(const optional &rhs) const & { return has_value() ? *this : rhs; } TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && { return has_value() ? std::move(*this) : rhs; } #ifndef TL_OPTIONAL_NO_CONSTRR constexpr optional disjunction(const optional &rhs) const && { return has_value() ? std::move(*this) : rhs; } #endif TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & { return has_value() ? *this : std::move(rhs); } constexpr optional disjunction(optional &&rhs) const & { return has_value() ? *this : std::move(rhs); } TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && { return has_value() ? std::move(*this) : std::move(rhs); } #ifndef TL_OPTIONAL_NO_CONSTRR constexpr optional disjunction(optional &&rhs) const && { return has_value() ? std::move(*this) : std::move(rhs); } #endif /// Takes the value out of the optional, leaving it empty optional take() { optional ret = std::move(*this); reset(); return ret; } using value_type = T; /// Constructs an optional that does not contain a value. constexpr optional() noexcept = default; constexpr optional(nullopt_t) noexcept {} /// Copy constructor /// /// If `rhs` contains a value, the stored value is direct-initialized with /// it. Otherwise, the constructed optional is empty. TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default; /// Move constructor /// /// If `rhs` contains a value, the stored value is direct-initialized with /// it. Otherwise, the constructed optional is empty. TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default; /// Constructs the stored value in-place using the given arguments. template constexpr explicit optional( detail::enable_if_t::value, in_place_t>, Args &&... args) : base(in_place, std::forward(args)...) {} template TL_OPTIONAL_11_CONSTEXPR explicit optional( detail::enable_if_t &, Args &&...>::value, in_place_t>, std::initializer_list il, Args &&... args) { this->construct(il, std::forward(args)...); } /// Constructs the stored value with `u`. template < class U = T, detail::enable_if_t::value> * = nullptr, detail::enable_forward_value * = nullptr> constexpr optional(U &&u) : base(in_place, std::forward(u)) {} template < class U = T, detail::enable_if_t::value> * = nullptr, detail::enable_forward_value * = nullptr> constexpr explicit optional(U &&u) : base(in_place, std::forward(u)) {} /// Converting copy constructor. template < class U, detail::enable_from_other * = nullptr, detail::enable_if_t::value> * = nullptr> optional(const optional &rhs) { if (rhs.has_value()) { this->construct(*rhs); } } template * = nullptr, detail::enable_if_t::value> * = nullptr> explicit optional(const optional &rhs) { if (rhs.has_value()) { this->construct(*rhs); } } /// Converting move constructor. template < class U, detail::enable_from_other * = nullptr, detail::enable_if_t::value> * = nullptr> optional(optional &&rhs) { if (rhs.has_value()) { this->construct(std::move(*rhs)); } } template < class U, detail::enable_from_other * = nullptr, detail::enable_if_t::value> * = nullptr> explicit optional(optional &&rhs) { if (rhs.has_value()) { this->construct(std::move(*rhs)); } } /// Destroys the stored value if there is one. ~optional() = default; /// Assignment to empty. /// /// Destroys the current value if there is one. optional &operator=(nullopt_t) noexcept { if (has_value()) { this->m_value.~T(); this->m_has_value = false; } return *this; } /// Copy assignment. /// /// Copies the value from `rhs` if there is one. Otherwise resets the stored /// value in `*this`. optional &operator=(const optional &rhs) = default; /// Move assignment. /// /// Moves the value from `rhs` if there is one. Otherwise resets the stored /// value in `*this`. optional &operator=(optional &&rhs) = default; /// Assigns the stored value from `u`, destroying the old value if there was /// one. template * = nullptr> optional &operator=(U &&u) { if (has_value()) { this->m_value = std::forward(u); } else { this->construct(std::forward(u)); } return *this; } /// Converting copy assignment operator. /// /// Copies the value from `rhs` if there is one. Otherwise resets the stored /// value in `*this`. template * = nullptr> optional &operator=(const optional &rhs) { if (has_value()) { if (rhs.has_value()) { this->m_value = *rhs; } else { this->hard_reset(); } } if (rhs.has_value()) { this->construct(*rhs); } return *this; } // TODO check exception guarantee /// Converting move assignment operator. /// /// Moves the value from `rhs` if there is one. Otherwise resets the stored /// value in `*this`. template * = nullptr> optional &operator=(optional &&rhs) { if (has_value()) { if (rhs.has_value()) { this->m_value = std::move(*rhs); } else { this->hard_reset(); } } if (rhs.has_value()) { this->construct(std::move(*rhs)); } return *this; } /// Constructs the value in-place, destroying the current one if there is /// one. template T &emplace(Args &&... args) { static_assert(std::is_constructible::value, "T must be constructible with Args"); *this = nullopt; this->construct(std::forward(args)...); return value(); } template detail::enable_if_t< std::is_constructible &, Args &&...>::value, T &> emplace(std::initializer_list il, Args &&... args) { *this = nullopt; this->construct(il, std::forward(args)...); return value(); } /// Swaps this optional with the other. /// /// If neither optionals have a value, nothing happens. /// If both have a value, the values are swapped. /// If one has a value, it is moved to the other and the movee is left /// valueless. void swap(optional &rhs) noexcept(std::is_nothrow_move_constructible::value &&detail::is_nothrow_swappable::value) { using std::swap; if (has_value()) { if (rhs.has_value()) { swap(**this, *rhs); } else { new (std::addressof(rhs.m_value)) T(std::move(this->m_value)); this->m_value.T::~T(); } } else if (rhs.has_value()) { new (std::addressof(this->m_value)) T(std::move(rhs.m_value)); rhs.m_value.T::~T(); } swap(this->m_has_value, rhs.m_has_value); } /// Returns a pointer to the stored value constexpr const T *operator->() const { return std::addressof(this->m_value); } TL_OPTIONAL_11_CONSTEXPR T *operator->() { return std::addressof(this->m_value); } /// Returns the stored value TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; } constexpr const T &operator*() const & { return this->m_value; } TL_OPTIONAL_11_CONSTEXPR T &&operator*() && { return std::move(this->m_value); } #ifndef TL_OPTIONAL_NO_CONSTRR constexpr const T &&operator*() const && { return std::move(this->m_value); } #endif /// Returns whether or not the optional has a value constexpr bool has_value() const noexcept { return this->m_has_value; } constexpr explicit operator bool() const noexcept { return this->m_has_value; } /// Returns the contained value if there is one, otherwise throws bad_optional_access TL_OPTIONAL_11_CONSTEXPR T &value() & { if (has_value()) return this->m_value; throw bad_optional_access(); } TL_OPTIONAL_11_CONSTEXPR const T &value() const & { if (has_value()) return this->m_value; throw bad_optional_access(); } TL_OPTIONAL_11_CONSTEXPR T &&value() && { if (has_value()) return std::move(this->m_value); throw bad_optional_access(); } #ifndef TL_OPTIONAL_NO_CONSTRR TL_OPTIONAL_11_CONSTEXPR const T &&value() const && { if (has_value()) return std::move(this->m_value); throw bad_optional_access(); } #endif /// Returns the stored value if there is one, otherwise returns `u` template constexpr T value_or(U &&u) const & { static_assert(std::is_copy_constructible::value && std::is_convertible::value, "T must be copy constructible and convertible from U"); return has_value() ? **this : static_cast(std::forward(u)); } template TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && { static_assert(std::is_move_constructible::value && std::is_convertible::value, "T must be move constructible and convertible from U"); return has_value() ? **this : static_cast(std::forward(u)); } /// Destroys the stored value if one exists, making the optional empty void reset() noexcept { if (has_value()) { this->m_value.~T(); this->m_has_value = false; } } }; // namespace tl /// Compares two optional objects template inline constexpr bool operator==(const optional &lhs, const optional &rhs) { return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs); } template inline constexpr bool operator!=(const optional &lhs, const optional &rhs) { return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs); } template inline constexpr bool operator<(const optional &lhs, const optional &rhs) { return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs); } template inline constexpr bool operator>(const optional &lhs, const optional &rhs) { return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs); } template inline constexpr bool operator<=(const optional &lhs, const optional &rhs) { return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs); } template inline constexpr bool operator>=(const optional &lhs, const optional &rhs) { return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs); } /// Compares an optional to a `nullopt` template inline constexpr bool operator==(const optional &lhs, nullopt_t) noexcept { return !lhs.has_value(); } template inline constexpr bool operator==(nullopt_t, const optional &rhs) noexcept { return !rhs.has_value(); } template inline constexpr bool operator!=(const optional &lhs, nullopt_t) noexcept { return lhs.has_value(); } template inline constexpr bool operator!=(nullopt_t, const optional &rhs) noexcept { return rhs.has_value(); } template inline constexpr bool operator<(const optional &, nullopt_t) noexcept { return false; } template inline constexpr bool operator<(nullopt_t, const optional &rhs) noexcept { return rhs.has_value(); } template inline constexpr bool operator<=(const optional &lhs, nullopt_t) noexcept { return !lhs.has_value(); } template inline constexpr bool operator<=(nullopt_t, const optional &) noexcept { return true; } template inline constexpr bool operator>(const optional &lhs, nullopt_t) noexcept { return lhs.has_value(); } template inline constexpr bool operator>(nullopt_t, const optional &) noexcept { return false; } template inline constexpr bool operator>=(const optional &, nullopt_t) noexcept { return true; } template inline constexpr bool operator>=(nullopt_t, const optional &rhs) noexcept { return !rhs.has_value(); } /// Compares the optional with a value. template inline constexpr bool operator==(const optional &lhs, const U &rhs) { return lhs.has_value() ? *lhs == rhs : false; } template inline constexpr bool operator==(const U &lhs, const optional &rhs) { return rhs.has_value() ? lhs == *rhs : false; } template inline constexpr bool operator!=(const optional &lhs, const U &rhs) { return lhs.has_value() ? *lhs != rhs : true; } template inline constexpr bool operator!=(const U &lhs, const optional &rhs) { return rhs.has_value() ? lhs != *rhs : true; } template inline constexpr bool operator<(const optional &lhs, const U &rhs) { return lhs.has_value() ? *lhs < rhs : true; } template inline constexpr bool operator<(const U &lhs, const optional &rhs) { return rhs.has_value() ? lhs < *rhs : false; } template inline constexpr bool operator<=(const optional &lhs, const U &rhs) { return lhs.has_value() ? *lhs <= rhs : true; } template inline constexpr bool operator<=(const U &lhs, const optional &rhs) { return rhs.has_value() ? lhs <= *rhs : false; } template inline constexpr bool operator>(const optional &lhs, const U &rhs) { return lhs.has_value() ? *lhs > rhs : false; } template inline constexpr bool operator>(const U &lhs, const optional &rhs) { return rhs.has_value() ? lhs > *rhs : true; } template inline constexpr bool operator>=(const optional &lhs, const U &rhs) { return lhs.has_value() ? *lhs >= rhs : false; } template inline constexpr bool operator>=(const U &lhs, const optional &rhs) { return rhs.has_value() ? lhs >= *rhs : true; } template ::value> * = nullptr, detail::enable_if_t::value> * = nullptr> void swap(optional &lhs, optional &rhs) noexcept(noexcept(lhs.swap(rhs))) { return lhs.swap(rhs); } namespace detail { struct i_am_secret {}; } // namespace detail template ::value, detail::decay_t, T>> inline constexpr optional make_optional(U &&v) { return optional(std::forward(v)); } template inline constexpr optional make_optional(Args &&... args) { return optional(in_place, std::forward(args)...); } template inline constexpr optional make_optional(std::initializer_list il, Args &&... args) { return optional(in_place, il, std::forward(args)...); } #if __cplusplus >= 201703L template optional(T)->optional; #endif /// \exclude namespace detail { #ifdef TL_OPTIONAL_CXX14 template (), *std::declval())), detail::enable_if_t::value> * = nullptr> constexpr auto optional_map_impl(Opt &&opt, F &&f) { return opt.has_value() ? detail::invoke(std::forward(f), *std::forward(opt)) : optional(nullopt); } template (), *std::declval())), detail::enable_if_t::value> * = nullptr> auto optional_map_impl(Opt &&opt, F &&f) { if (opt.has_value()) { detail::invoke(std::forward(f), *std::forward(opt)); return make_optional(monostate{}); } return optional(nullopt); } #else template (), *std::declval())), detail::enable_if_t::value> * = nullptr> constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional { return opt.has_value() ? detail::invoke(std::forward(f), *std::forward(opt)) : optional(nullopt); } template (), *std::declval())), detail::enable_if_t::value> * = nullptr> auto optional_map_impl(Opt &&opt, F &&f) -> optional { if (opt.has_value()) { detail::invoke(std::forward(f), *std::forward(opt)); return monostate{}; } return nullopt; } #endif } // namespace detail /// Specialization for when `T` is a reference. `optional` acts similarly /// to a `T*`, but provides more operations and shows intent more clearly. template class optional { public: // The different versions for C++14 and 11 are needed because deduced return // types are not SFINAE-safe. This provides better support for things like // generic lambdas. C.f. // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0826r0.html #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \ !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55) /// Carries out some operation which returns an optional on the stored /// object if there is one. template TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } template TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } template constexpr auto and_then(F &&f) const & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr auto and_then(F &&f) const && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } #endif #else /// Carries out some operation which returns an optional on the stored /// object if there is one. template TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t and_then(F &&f) & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } template TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t and_then(F &&f) && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } template constexpr detail::invoke_result_t and_then(F &&f) const & { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr detail::invoke_result_t and_then(F &&f) const && { using result = detail::invoke_result_t; static_assert(detail::is_optional::value, "F must return an optional"); return has_value() ? detail::invoke(std::forward(f), **this) : result(nullopt); } #endif #endif #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \ !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55) /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & { return detail::optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } template constexpr auto map(F &&f) const & { return detail::optional_map_impl(*this, std::forward(f)); } template constexpr auto map(F &&f) const && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } #else /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval(), std::declval())) map(F &&f) & { return detail::optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval(), std::declval())) map(F &&f) && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } template constexpr decltype(detail::optional_map_impl(std::declval(), std::declval())) map(F &&f) const & { return detail::optional_map_impl(*this, std::forward(f)); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr decltype(detail::optional_map_impl(std::declval(), std::declval())) map(F &&f) const && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } #endif #endif #if defined(TL_OPTIONAL_CXX14) && !defined(TL_OPTIONAL_GCC49) && \ !defined(TL_OPTIONAL_GCC54) && !defined(TL_OPTIONAL_GCC55) /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & { return detail::optional_map_impl(*this, std::forward(f)); } template TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } template constexpr auto transform(F&& f) const & { return detail::optional_map_impl(*this, std::forward(f)); } template constexpr auto transform(F&& f) const && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } #else /// Carries out some operation on the stored object if there is one. template TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval(), std::declval())) transform(F&& f) & { return detail::optional_map_impl(*this, std::forward(f)); } /// \group map /// \synopsis template auto transform(F &&f) &&; template TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval(), std::declval())) transform(F&& f) && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } template constexpr decltype(detail::optional_map_impl(std::declval(), std::declval())) transform(F&& f) const & { return detail::optional_map_impl(*this, std::forward(f)); } #ifndef TL_OPTIONAL_NO_CONSTRR template constexpr decltype(detail::optional_map_impl(std::declval(), std::declval())) transform(F&& f) const && { return detail::optional_map_impl(std::move(*this), std::forward(f)); } #endif #endif /// Calls `f` if the optional is empty template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & { if (has_value()) return *this; std::forward(f)(); return nullopt; } template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) & { return has_value() ? *this : std::forward(f)(); } template * = nullptr> optional or_else(F &&f) && { if (has_value()) return std::move(*this); std::forward(f)(); return nullopt; } template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) && { return has_value() ? std::move(*this) : std::forward(f)(); } template * = nullptr> optional or_else(F &&f) const & { if (has_value()) return *this; std::forward(f)(); return nullopt; } template * = nullptr> optional TL_OPTIONAL_11_CONSTEXPR or_else(F &&f) const & { return has_value() ? *this : std::forward(f)(); } #ifndef TL_OPTIONAL_NO_CONSTRR template * = nullptr> optional or_else(F &&f) const && { if (has_value()) return std::move(*this); std::forward(f)(); return nullopt; } template * = nullptr> optional or_else(F &&f) const && { return has_value() ? std::move(*this) : std::forward(f)(); } #endif /// Maps the stored value with `f` if there is one, otherwise returns `u` template U map_or(F &&f, U &&u) & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u); } template U map_or(F &&f, U &&u) && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u); } template U map_or(F &&f, U &&u) const & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u); } #ifndef TL_OPTIONAL_NO_CONSTRR template U map_or(F &&f, U &&u) const && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u); } #endif /// Maps the stored value with `f` if there is one, otherwise calls /// `u` and returns the result. template detail::invoke_result_t map_or_else(F &&f, U &&u) & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u)(); } template detail::invoke_result_t map_or_else(F &&f, U &&u) && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u)(); } template detail::invoke_result_t map_or_else(F &&f, U &&u) const & { return has_value() ? detail::invoke(std::forward(f), **this) : std::forward(u)(); } #ifndef TL_OPTIONAL_NO_CONSTRR template detail::invoke_result_t map_or_else(F &&f, U &&u) const && { return has_value() ? detail::invoke(std::forward(f), std::move(**this)) : std::forward(u)(); } #endif /// Returns `u` if `*this` has a value, otherwise an empty optional. template constexpr optional::type> conjunction(U &&u) const { using result = optional>; return has_value() ? result{u} : result{nullopt}; } /// Returns `rhs` if `*this` is empty, otherwise the current value. TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & { return has_value() ? *this : rhs; } constexpr optional disjunction(const optional &rhs) const & { return has_value() ? *this : rhs; } TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && { return has_value() ? std::move(*this) : rhs; } #ifndef TL_OPTIONAL_NO_CONSTRR constexpr optional disjunction(const optional &rhs) const && { return has_value() ? std::move(*this) : rhs; } #endif TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & { return has_value() ? *this : std::move(rhs); } constexpr optional disjunction(optional &&rhs) const & { return has_value() ? *this : std::move(rhs); } TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && { return has_value() ? std::move(*this) : std::move(rhs); } #ifndef TL_OPTIONAL_NO_CONSTRR constexpr optional disjunction(optional &&rhs) const && { return has_value() ? std::move(*this) : std::move(rhs); } #endif /// Takes the value out of the optional, leaving it empty optional take() { optional ret = std::move(*this); reset(); return ret; } using value_type = T &; /// Constructs an optional that does not contain a value. constexpr optional() noexcept : m_value(nullptr) {} constexpr optional(nullopt_t) noexcept : m_value(nullptr) {} /// Copy constructor /// /// If `rhs` contains a value, the stored value is direct-initialized with /// it. Otherwise, the constructed optional is empty. TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) noexcept = default; /// Move constructor /// /// If `rhs` contains a value, the stored value is direct-initialized with /// it. Otherwise, the constructed optional is empty. TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default; /// Constructs the stored value with `u`. template >::value> * = nullptr> constexpr optional(U &&u) noexcept : m_value(std::addressof(u)) { static_assert(std::is_lvalue_reference::value, "U must be an lvalue"); } template constexpr explicit optional(const optional &rhs) noexcept : optional(*rhs) {} /// No-op ~optional() = default; /// Assignment to empty. /// /// Destroys the current value if there is one. optional &operator=(nullopt_t) noexcept { m_value = nullptr; return *this; } /// Copy assignment. /// /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise /// resets the stored value in `*this`. optional &operator=(const optional &rhs) = default; /// Rebinds this optional to `u`. template >::value> * = nullptr> optional &operator=(U &&u) { static_assert(std::is_lvalue_reference::value, "U must be an lvalue"); m_value = std::addressof(u); return *this; } /// Converting copy assignment operator. /// /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise /// resets the stored value in `*this`. template optional &operator=(const optional &rhs) noexcept { m_value = std::addressof(rhs.value()); return *this; } /// Rebinds this optional to `u`. template >::value> * = nullptr> optional &emplace(U &&u) noexcept { return *this = std::forward(u); } void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); } /// Returns a pointer to the stored value constexpr const T *operator->() const noexcept { return m_value; } TL_OPTIONAL_11_CONSTEXPR T *operator->() noexcept { return m_value; } /// Returns the stored value TL_OPTIONAL_11_CONSTEXPR T &operator*() noexcept { return *m_value; } constexpr const T &operator*() const noexcept { return *m_value; } constexpr bool has_value() const noexcept { return m_value != nullptr; } constexpr explicit operator bool() const noexcept { return m_value != nullptr; } /// Returns the contained value if there is one, otherwise throws bad_optional_access TL_OPTIONAL_11_CONSTEXPR T &value() { if (has_value()) return *m_value; throw bad_optional_access(); } TL_OPTIONAL_11_CONSTEXPR const T &value() const { if (has_value()) return *m_value; throw bad_optional_access(); } /// Returns the stored value if there is one, otherwise returns `u` template constexpr T value_or(U &&u) const & noexcept { static_assert(std::is_copy_constructible::value && std::is_convertible::value, "T must be copy constructible and convertible from U"); return has_value() ? **this : static_cast(std::forward(u)); } /// \group value_or template TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept { static_assert(std::is_move_constructible::value && std::is_convertible::value, "T must be move constructible and convertible from U"); return has_value() ? **this : static_cast(std::forward(u)); } /// Destroys the stored value if one exists, making the optional empty void reset() noexcept { m_value = nullptr; } private: T *m_value; }; // namespace tl } // namespace tl namespace std { // TODO SFINAE template struct hash> { ::std::size_t operator()(const tl::optional &o) const { if (!o.has_value()) return 0; return std::hash>()(*o); } }; } // namespace std #endif ================================================ FILE: Externals/partio/CMakeLists.txt ================================================ # PARTIO SOFTWARE # Copyright 2010 Disney Enterprises, Inc. All rights reserved # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * 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. # # * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation # Studios" or the names of its contributors may NOT be used to # endorse or promote products derived from this software without # specific prior written permission from Walt Disney Pictures. # # Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND # CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS # FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. # IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. CMAKE_MINIMUM_REQUIRED( VERSION 3.8.0 ) SET( CMAKE_SKIP_RPATH TRUE ) ## project name & version PROJECT(partio LANGUAGES CXX VERSION 1.5.2) # Enable C++11 SET(CMAKE_CXX_STANDARD 11) SET(CMAKE_CXX_STANDARD_REQUIRED YES) SET(CMAKE_CXX_EXTENSIONS NO) ## Setup platform specific helper defines build variants IF(WIN32) IF(MSVC) ADD_DEFINITIONS (-DPARTIO_WIN32) ENDIF() ADD_DEFINITIONS (-D_USE_MATH_DEFINES) ELSE() ADD_COMPILE_OPTIONS (-Wextra -Wno-unused-parameter) ENDIF() IF(APPLE) set (CMAKE_SHARED_LINKER_FLAGS "-undefined dynamic_lookup") ENDIF() SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "type of build" FORCE) ## Set install location IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) IF(WIN32) set(VARIANT_DIRECTORY "Windows-x86_64") ELSE() execute_process(COMMAND sh -c "echo `uname`-`uname -r | cut -d'-' -f1`-`uname -m`" OUTPUT_VARIABLE VARIANT_DIRECTORY OUTPUT_STRIP_TRAILING_WHITESPACE) ENDIF() set(CMAKE_INSTALL_PREFIX "${CMAKE_SOURCE_DIR}/${VARIANT_DIRECTORY}") ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) SET (ZLIB_LIBRARY "") #option(BUILD_SHARED_LIBS "Enabled shared libraries" OFF) file(GLOB io_cpp "io/*.cpp") file(GLOB core_cpp "core/*.cpp") add_library(partio ${io_cpp} ${core_cpp}) set_target_properties(partio PROPERTIES OUTPUT_NAME partio POSITION_INDEPENDENT_CODE ON) if (WIN32) if (MSVC) #target_compile_options(partio PUBLIC /MT) target_link_options(partio PRIVATE /INCREMENTAL:NO /NODEFAULTLIB:MSVCRT) endif() endif() target_include_directories(partio SYSTEM PUBLIC $) ================================================ FILE: Externals/partio/Partio.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ /*! The interface of the particle API (Partio) what type the primitive is, how many instances of the primitive there, name of the attribute and an index which speeds lookups of data */ #ifndef _Partioh_ #define _Partioh_ #include #include #include #include #include #include "PartioAttribute.h" #include "PartioIterator.h" namespace Partio{ //! Opaque random access method to a single particle. No number is implied or guaranteed. typedef uint64_t ParticleIndex; class ParticlesData; class ParticlesDataMutable; // Particle Collection Interface //! Particle Collection Interface /*! This class provides ways of accessing basic information about particles, the number in the set, the attribute names and types, etc. No actual data can be read or written. */ class ParticlesInfo { protected: virtual ~ParticlesInfo() {} public: //! Frees the memory if this particle set was created with create() or release() //! Reduces reference count if it was obtained with readCached() //! and if the ref count hits zero, frees the memory virtual void release()=0; //! Number of particles in the structure. virtual int numParticles() const=0; //! Number of per-particle attributes. virtual int numAttributes() const=0; //! Number of fixed attributes. virtual int numFixedAttributes() const=0; //! Lookup an attribute by name and store a handle to the attribute. virtual bool attributeInfo(const char* attributeName,ParticleAttribute& attribute) const=0; //! Lookup an attribute by name and store a handle to the attribute. virtual bool fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const=0; //! Lookup an attribute by index and store a handle to the attribute. virtual bool attributeInfo(const int index,ParticleAttribute& attribute) const=0; //! Lookup an attribute by index and store a handle to the attribute. virtual bool fixedAttributeInfo(const int index,FixedAttribute& attribute) const=0; }; // Particle Data Interface //! Particle Data Interface /*! This interface provides the ability to read data attributes for given particles and search for nearest neighbors using KD-Trees. */ class ParticlesData:public ParticlesInfo { protected: virtual ~ParticlesData() {} public: friend void freeCached(ParticlesData* particles); typedef ParticleIterator const_iterator; //! Fill the user supplied values array with data corresponding to the given //! list of particles. Specify whether or not your indices are sorted. //! note if T is void, then type checking is disabled. template inline void data(const ParticleAttribute& attribute, const int indexCount,const ParticleIndex* particleIndices,const bool sorted,T* values) { assert(typeCheck(attribute.type)); dataInternalMultiple(attribute,indexCount,particleIndices,sorted,(char*)values); } template inline const T* data(const ParticleAttribute& attribute, const ParticleIndex particleIndex) const { // TODO: add type checking return static_cast(dataInternal(attribute,particleIndex)); } template inline const T* fixedData(const FixedAttribute& attribute) const { // TODO: add type checking return static_cast(fixedDataInternal(attribute)); } /// All indexed strings for an attribute virtual const std::vector& indexedStrs(const ParticleAttribute& attr) const=0; /// All indexed strings for an attribute virtual const std::vector& fixedIndexedStrs(const FixedAttribute& attr) const=0; /// Looks up the index for a given string for a given attribute, returns -1 if not found virtual int lookupIndexedStr(const ParticleAttribute& attribute,const char* str) const=0; /// Looks up the index for a given string for a given attribute, returns -1 if not found virtual int lookupFixedIndexedStr(const FixedAttribute& attribute,const char* str) const=0; //! Fill the user supplied values array with data corresponding to the given //! list of particles. Specify whether or not your indices are sorted. Attributes //! that are not floating types are automatically casted before being placed //! in values. virtual void dataAsFloat(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,float* values) const=0; //! Find the points within the bounding box specified. //! Must call sort() before using this function //! NOTE: points array is not pre-cleared. virtual void findPoints(const float bboxMin[3],const float bboxMax[3], std::vector& points) const=0; //! Find the N nearest neighbors that are within maxRadius distance using STL types //! (measured in standard 2-norm). If less than N are found within the //! radius, the search radius is not increased. //! NOTE: points/pointsDistancesSquared are cleared before use. //! Must call sort() before using this function virtual float findNPoints(const float center[3],int nPoints,const float maxRadius, std::vector& points,std::vector& pointDistancesSquared) const=0; //! Find the N nearest neighbors that are within maxRadius distance using POD types //! NOTE: returns the number of found points and leaves in finalRadius2 the //! square of the final search radius used virtual int findNPoints(const float center[3],int nPoints,const float maxRadius, ParticleIndex *points, float *pointDistancesSquared, float *finalRadius2) const=0; //! Produce a const iterator virtual const_iterator setupConstIterator(const int index=0) const=0; //! Produce a beginning iterator for the particles const_iterator begin() const {return setupConstIterator();} //! Produce a ending iterator for the particles const_iterator end() const {return const_iterator();} private: virtual void* dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const=0; virtual void* fixedDataInternal(const FixedAttribute& attribute) const=0; virtual void dataInternalMultiple(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,char* values) const=0; }; // Particle Mutable Data Interface //! Particle Mutable Data Interface /*! This interface provides the ability to write data attributes, add attributes, add particles, etc. */ class ParticlesDataMutable:public ParticlesData { protected: virtual ~ParticlesDataMutable(){} public: typedef ParticleIterator iterator; //! Get a pointer to the data corresponding to the given particleIndex and //! attribute given by the attribute handle. template inline T* dataWrite(const ParticleAttribute& attribute, const ParticleIndex particleIndex) const { // TODO: add type checking return static_cast(dataInternal(attribute,particleIndex)); } //! Get a pointer to the data corresponding to the attribute given by the //! fixed attribute handle. template inline T* fixedDataWrite(const FixedAttribute& attribute) const { // TODO: add type checking return static_cast(fixedDataInternal(attribute)); } /// Set particle value for attribute template inline void set(const ParticleAttribute& attribute, const ParticleIndex particleIndex, const T* data) { T* ptr = static_cast(dataInternal(attribute, particleIndex)); memcpy(ptr, data, attribute.count * TypeSize(attribute.type)); } template inline void setFixed(const FixedAttribute& attribute, const T* data) { T* ptr = static_cast(fixedDataInternal(attribute)); memcpy(ptr, data, attribute.count * TypeSize(attribute.type)); } /// Returns a token for the given string. This allows efficient storage of string data virtual int registerIndexedStr(const ParticleAttribute& attribute,const char* str)=0; /// Returns a token for the given string. This allows efficient storage of string data virtual int registerFixedIndexedStr(const FixedAttribute& attribute,const char* str)=0; /// Returns a token for the given string. This allows efficient storage of string data virtual void setIndexedStr(const ParticleAttribute& attribute,int indexedStringToken,const char* str)=0; /// Returns a token for the given string. This allows efficient storage of string data virtual void setFixedIndexedStr(const FixedAttribute& attribute,int indexedStringToken,const char* str)=0; //! Preprocess the data for finding nearest neighbors by sorting into a //! KD-Tree. Note: all particle pointers are invalid after this call. virtual void sort()=0; //! Adds an attribute to the particle with the provided name, type and count virtual ParticleAttribute addAttribute(const char* attribute,ParticleAttributeType type, const int count)=0; //! Adds a fixed attribute with the provided name, type and count virtual FixedAttribute addFixedAttribute(const char* attribute,ParticleAttributeType type, const int count)=0; //! Add a particle to the particle set. Returns the offset to the particle virtual ParticleIndex addParticle()=0; //! Add a set of particles to the particle set. Returns the offset to the //! first particle virtual iterator addParticles(const int count)=0; //! Produce a beginning iterator for the particles iterator begin() {return setupIterator();} //! Produce a ending iterator for the particles iterator end() {return iterator();} //! Produce a const iterator virtual iterator setupIterator(const int index=0)=0; private: virtual void* dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const=0; virtual void* fixedDataInternal(const FixedAttribute& attribute) const=0; }; //! Provides an empty particle instance, freed with p->release() ParticlesDataMutable* create(); ParticlesDataMutable* createInterleave(); //! Clone a ParticlesData instance into a new ParticlesDataMutable instance. //! This does *not* copy data, it only copies the attribute schema. ParticlesDataMutable* cloneSchema(const ParticlesData&); //! Copy a ParticlesData instance into a new ParticlesDataMutable instance. //! clone() copies the detail attributes and particle data by default. //! To copy only the detail attributes, pass particles=false. ParticlesDataMutable* clone(const ParticlesData&, bool particles=true); //! Provides read/write access to a particle set stored in a file //! freed with p->release() ParticlesDataMutable* read(const char* filename,const bool verbose=true,std::ostream& errorStream=std::cerr); //! Provides read access to a particle headers (number of particles //! and attribute information, much cheapeer ParticlesInfo* readHeaders(const char* filename,const bool verbose=true,std::ostream& errorStream=std::cerr); //! Provides access to a particle set stored in a file //! if filename ends with .gz or forceCompressed is true, the file is compressed. void write(const char* filename,const ParticlesData&,const bool forceCompressed=false,bool verbose=true,std::ostream& errorStream=std::cerr); //! Cached (only one copy) read only way to read a particle file /*! Loads a file read-only if not already in memory, otherwise returns already loaded item. Pointer is owned by Partio and must be released with p->release(); (will not be deleted if others are also holding). If you want to do finding neighbors give true to sort */ ParticlesData* readCached(const char* filename,const bool sort,const bool verbose=true,std::ostream& errorStream=std::cerr); //! Begin accessing data in a cached file /*! Indicates to Partio that data access from a cached particle set will start. The sent in particles pointer must be from a readCached() call, not from read() or create(). Attributes can be read before this call. */ void beginCachedAccess(ParticlesData* particles); //! End accessing data in a cached file /*! Indicates to Partio that data from a cached particle read will end. The sent in particles pointer must be from a readCached() call, not from read() or create(). This allows the particle API to free all data pages, if they are needed. */ void endCachedAccess(ParticlesData* particles); //! Prints a subset of particle data in a textual form void print(const ParticlesData* particles); ParticlesDataMutable* computeClustering(ParticlesDataMutable* particles, const int numNeighbors,const double radiusSearch,const double radiusInside,const int connections,const double density); //! Merges one particle set into another /*! Given a ParticleSetMutable, merges it with a second ParticleSet, copying particles and attributes that align with the base particle set. If an identifier is provided, that will be used as a key to replace the particle in the base set with the particle in the second set with the same identifier attribute value. If the identifier is not provided or the particle's attribute value is not found in the base set, a new particle is added. If used, the identifier must be a single INT. */ void merge(ParticlesDataMutable& base, const ParticlesData& delta, const std::string& identifier=std::string()); } #endif ================================================ FILE: Externals/partio/PartioAttribute.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ /*! The interface of the particle API (Partio) what type the primitive is, how many instances of the primitive there, name of the attribute and an index which speeds lookups of data */ #ifndef _PartioParticleAttribute_h_ #define _PartioParticleAttribute_h_ namespace Partio{ // Particle Types enum ParticleAttributeType {NONE=0,VECTOR=1,FLOAT=2,INT=3,INDEXEDSTR=4}; template struct ETYPE_TO_TYPE {struct UNUSABLE;typedef UNUSABLE TYPE;}; template<> struct ETYPE_TO_TYPE{typedef float TYPE;}; template<> struct ETYPE_TO_TYPE{typedef float TYPE;}; template<> struct ETYPE_TO_TYPE{typedef int TYPE;}; template<> struct ETYPE_TO_TYPE{typedef int TYPE;}; template struct IS_SAME{static const bool value=false;}; template struct IS_SAME{static const bool value=true;}; template bool typeCheck(const ParticleAttributeType& type) { // if T is void, don't bother checking what we passed in if (IS_SAME::value) return true; switch(type){ case VECTOR: return IS_SAME::TYPE,T>::value; case FLOAT: return IS_SAME::TYPE,T>::value; case INT: return IS_SAME::TYPE,T>::value; case INDEXEDSTR: return IS_SAME::TYPE,T>::value; default: return false; // unknown type } } inline int TypeSize(ParticleAttributeType attrType) { switch(attrType){ case NONE: return 0; case VECTOR: return sizeof(float); case FLOAT: return sizeof(float); case INT: return sizeof(int); case INDEXEDSTR: return sizeof(int); default: return 0; } } std::string TypeName(ParticleAttributeType attrType); // Particle Attribute Specifier //! Particle Collection Interface /*! This class provides a handle and description of an attribute. This includes what type the primitive is, the number of entries, the name of the attribute and an index which speeds lookups of data */ class ParticleAttribute { public: //! Type of attribute ParticleAttributeType type; //! Number of entries, should be 3 if type is VECTOR int count; //! Name of attribute std::string name; //! Internal method of fast access, user should not use or change int attributeIndex; //! Comment used by various data/readers for extra attribute information //! for example for a PTC file to read and write this could be "color" or "point" // std::string comment; }; // Fixed Attribute Specifier //! Fixed Attribute Interface /*! This class provides a handle and description of an attribute. This includes what type the primitive is, the number of entries, the name of the attribute and an index which speeds lookups of data */ class FixedAttribute { public: //! Type of attribute ParticleAttributeType type; //! Number of entries, should be 3 if type is VECTOR int count; //! Name of attribute std::string name; //! Internal method of fast access, user should not use or change int attributeIndex; //! Comment used by various data/readers for extra attribute information //! for example for a PTC file to read and write this could be "color" or "point" // std::string comment; }; } #endif ================================================ FILE: Externals/partio/PartioIterator.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _PartioParticleIterator_h_ #define _PartioParticleIterator_h_ #include #include #include #include "PartioAttribute.h" namespace Partio{ class ParticlesData; struct ParticleAccessor; //! Data /*! This class represents a piece of data stored in a particle attribute. The only allowed values are float and d */ template struct Data { T x[d]; const T& operator[](const int i) const {return x[i];} T& operator[](const int i) {return x[i];} }; typedef Data DataI; typedef Data DataF; typedef Data DataV; template class ParticleIterator; struct Provider { virtual void setupIteratorNextBlock(ParticleIterator& iterator) const=0; virtual void setupIteratorNextBlock(ParticleIterator& iterator)=0; virtual void setupAccessor(ParticleIterator& iterator,ParticleAccessor& accessor) const=0; virtual void setupAccessor(ParticleIterator& iterator,ParticleAccessor& accessor)=0; virtual ~Provider(){} }; template struct PROVIDER { typedef Provider TYPE; }; template<> struct PROVIDER { typedef const Provider TYPE; }; // TODO: non copyable struct ParticleAccessor { int stride; char* basePointer; int attributeIndex; // index of attribute opaque, do not touch int count; private: ParticleAttributeType type; ParticleAccessor* next; public: ParticleAccessor(const ParticleAttribute& attr) :stride(0),basePointer(0),attributeIndex(attr.attributeIndex), count(attr.count),type(attr.type),next(0) {} template TDATA* raw(const TITERATOR& it) {return reinterpret_cast(basePointer+it.index*stride);} template const TDATA* raw(const TITERATOR& it) const {return reinterpret_cast(basePointer+it.index*stride);} template TDATA& data(const TITERATOR& it) {return *reinterpret_cast(basePointer+it.index*stride);} template const TDATA& data(const TITERATOR& it) const {return *reinterpret_cast(basePointer+it.index*stride);} friend class ParticleIterator; friend class ParticleIterator; }; template class ParticleIterator { public: private: typedef typename PROVIDER::TYPE PROVIDER; //! Delegate, null if the iterator is false PROVIDER* particles; public: //! Start of non-interleaved index of contiguous block size_t index; private: //! End of non-interleaved index of contiguous block size_t indexEnd; //! This is used for both non-interleaved and interleaved particle attributes ParticleAccessor* accessors; public: //! Construct an invalid iterator ParticleIterator() :particles(0),index(0),indexEnd(0),accessors(0) {} //! Copy constructor. NOTE: Invalidates any accessors that have been registered with it ParticleIterator(const ParticleIterator& other) :particles(other.particles),index(other.index),indexEnd(other.indexEnd),accessors(0) {} //! Construct an iterator with iteration parameters. This is typically only //! called by implementations of Particle (not by users). For users, use //! begin() and end() on the particle type ParticleIterator(PROVIDER* particles,size_t index,size_t indexEnd) :particles(particles),index(index),indexEnd(indexEnd) {} //! Whether the iterator is valid bool valid() const {return particles;} //! Increment the iterator (postfix). Prefer the prefix form below to this one. ParticleIterator operator++(int) { ParticleIterator newIt(*this); index++; return newIt; } //! Increment the iterator (prefix). ParticleIterator& operator++() { index++; // TODO: make particles==0 check unnecessary by using indexEnd=0 to signify invalid iterator if((index>indexEnd) && particles) particles->setupIteratorNextBlock(*this); return *this; } //! Iterator comparison equals bool operator==(const ParticleIterator& other) { // TODO: this is really really expensive // TODO: this needs a block or somethingt o say which segment it is return particles==other.particles && index==other.index; } //! Iterator comparison not-equals bool operator!=(const ParticleIterator& other) { if(other.particles!=particles) return true; // if not same delegate else if(particles==0) return false; // if both are invalid iterators else return !(*this==other); } void addAccessor(ParticleAccessor& newAccessor) { newAccessor.next=accessors; accessors=&newAccessor; if(particles) particles->setupAccessor(*this,newAccessor); } // TODO: add copy constructor that wipes out accessor linked list }; template std::ostream& operator<<(std::ostream& output,const Data& v) { output< #include #include namespace Partio{ class Vec3 { public: float x,y,z; inline Vec3() :x(0),y(0),z(0) {} inline Vec3(const float x,const float y,const float z) :x(x),y(y),z(z) {} inline Vec3(const float v[3]) :x(v[0]),y(v[1]),z(v[2]) {} inline float length() {return std::sqrt(x*x+y*y+z*z);} inline float normalize() {float l=length();x/=l;y/=l;z/=l;return l;} inline Vec3 normalized() const {Vec3 foo(x,y,z);foo.normalize();return foo;} inline Vec3 operator*(const float a) const {return Vec3(a*x,a*y,a*z);} inline Vec3 operator-(const Vec3& v) const {return Vec3(x-v.x,y-v.y,z-v.z);} inline Vec3 operator+(const Vec3& v) const {return Vec3(x+v.x,y+v.y,z+v.z);} inline Vec3 operator+=(const Vec3& v) {x+=v.x;y+=v.y;z+=v.z;return *this;} inline Vec3 cross(const Vec3& v) const {Vec3 ret(y*v.z-z*v.y,z*v.x-x*v.z,x*v.y-y*v.x);return ret;} inline Vec3 min(const Vec3& v) const { return Vec3(std::min(x,v.x),std::min(y,v.y),std::min(z,v.z)); } inline Vec3 max(const Vec3& v) const { return Vec3(std::max(x,v.x),std::max(y,v.y),std::max(z,v.z)); } }; inline std::ostream& operator<<(std::ostream& stream,const Vec3& v) {return stream< #elif defined(__GNUC__) #include #endif namespace Partio { /* balanced kdtree Brent Burley, Mar 2006 The tree is left-balanced (i.e. the left subtree is always complete). The nodes are stored in traversal order ("pre-order") to optimize memory lookahead and cache-coherence during traversal. This means that: 1) The root node is node 0, depth 0. 2) Any given subtree is stored in a contiguous memory block. 3) The left child of node n is node n+1. 4) The right child of node n is node n+(size of left subtree). 5) The size of the left subtree of any node can be easily determined based on the node's overall subtree size (left+right+1). This can be propagated down during traversal. */ #include #include #include #include #include template class BBox { public: float min[k]; float max[k]; BBox() { clear(); } BBox(const float p[k]) { set(p); } void set(const float p[k]) { for (int i = 0; i < k; i++) { min[i] = max[i] = p[i]; } } void clear() { for (int i = 0; i < k; i++) { min[i] = FLT_MAX; max[i] = FLT_MIN; } } void grow(const float p[k]) { for (int i = 0; i < k; i++) { if (p[i] < min[i]) min[i] = p[i]; if (p[i] > max[i]) max[i] = p[i]; } } void grow(float R) { for (int i = 0; i < k; i++) { min[i] -= R; max[i] += R; } } void grow(const BBox& b) { for (int i = 0; i < k; i++) { if (b.min[i] < min[i]) min[i] = b.min[i]; if (b.max[i] > max[i]) max[i] = b.max[i]; } } bool intersects(const BBox& b) const { for (int i = 0; i < k; i++) { if (b.max[i] < min[i] || b.min[i] > max[i]) return 0; } return 1; } bool inside(const float p[k]) const { for (int i = 0; i < k; i++) { if (p[i] < min[i] || p[i] > max[i]) return 0; } return 1; } }; // MAKE-heap on a binary (array based) heap // loosely based on Henrik Wann Jensen's Photon Mapping book, but made 0-indexed // and commented inline float buildHeap(uint64_t *result, float *distance_squared,int heap_size) { int max_non_leaf_index=heap_size/2-1; // 0 to max_non_leaf_index is indices of parents // go from bottom of tree scanning right to left in each height of the tree for(int subtreeParent=max_non_leaf_index;subtreeParent>=0;subtreeParent--){ int current_parent=subtreeParent; while(current_parent<=max_non_leaf_index){ int left_index=2*current_parent+1;int right_index=2*current_parent+2; // find largest element int largest_index=current_parent; if(left_indexdistance_squared[largest_index]) largest_index=left_index; if(right_indexdistance_squared[largest_index]) largest_index=right_index; // subtree parented at current_parent satisfies heap property because parent has largest if(largest_index==current_parent) break; // pull large value up and descend to tree to see if new that subtree is invalid std::swap(result[largest_index],result[current_parent]); std::swap(distance_squared[largest_index],distance_squared[current_parent]); current_parent=largest_index; } } return distance_squared[0]; // return max distance } // Inserts smaller element into heap (does not check so caller must) inline float insertToHeap(uint64_t *result,float*distance_squared,int heap_size,int new_id,float new_distance_squared) { assert(new_distance_squared=heap_size) break; else if(right>=heap_size || distance_squared[left]>distance_squared[right]) index_of_largest=left; else index_of_largest=right; // new element is largest if(new_distance_squared>distance_squared[index_of_largest]) break; // pull the biggest element up and recurse to where it came from std::swap(result[index_of_largest],result[current_parent]); std::swap(distance_squared[index_of_largest],distance_squared[current_parent]); current_parent=index_of_largest; } // overwrite current node in tree distance_squared[current_parent]=new_distance_squared; result[current_parent]=new_id; return distance_squared[0]; // return max distance } template class KdTree { struct NearestQuery { NearestQuery(uint64_t *result,float *distanceSquared,const float pquery_in[k], int maxPoints,float maxRadiusSquared) :result(result),distanceSquared(distanceSquared),maxPoints(maxPoints), foundPoints(0),maxRadiusSquared(maxRadiusSquared) {for(int i=0;i(_points.size()); } const BBox& bbox() const { return _bbox; } const float* point(int i) const { return _points[i].p; } uint64_t id(int i) const { return _ids[i]; } void setPoints(const float* p, int n); void sort(); void findPoints(std::vector& points, const BBox& bbox) const; float findNPoints(std::vector& result,std::vector& distanceSquared, const float p[k],int nPoints,float maxRadius) const; int findNPoints(uint64_t *result,float *distanceSquared, float *finalSearchRadius2, const float p[k], int nPoints, float maxRadius) const; private: void sortSubtree(int n, int count, int j); struct ComparePointsById { float* points; ComparePointsById(float* p) : points(p) {} bool operator() (uint64_t a, uint64_t b) { return points[a*k] < points[b*k]; } }; void findPoints(std::vector& result, const BBox& bbox, int n, int size, int j) const; void findNPoints(NearestQuery& query,int n,int size,int j) const; static inline void ComputeSubtreeSizes(int size, int& left, int& right) { // if (size+1) is a power of two, then subtree is balanced bool balanced = ((size+1) & size) == 0; if (balanced) { // subtree size = (size-1)/2 left = right = size>>1; // ignore -1 since size is always odd } else if (size == 2) { // special case left = 1; right = 0; } else { // left subtree size = (smallest power of 2 > half size)-1 int i = 0; for (int c = size; c != 1; c >>= 1) i++; left = (1< _bbox; struct Point { float p[k]; }; std::vector _points; std::vector _ids; bool _sorted; }; template KdTree::KdTree() : _sorted(0) {} template KdTree::~KdTree() {} // TODO: this should take an array of ids in template void KdTree::setPoints(const float* p, int n) { // copy points _points.resize(n); memcpy(&_points[0], p, sizeof(Point)*n); // compute bbox if (n) { _bbox.set(p); for (int i = 1; i < n; i++) _bbox.grow(_points[i].p); } else _bbox.clear(); // assign sequential ids _ids.resize(n); #if defined(__clang__) && defined(_LIBCPP_VERSION) std::iota(_ids.begin(), _ids.end(), 0); #elif defined(__GNUC__) __gnu_cxx::iota(_ids.begin(), _ids.end(), 0); #endif // _ids.reserve(n); // while ((int)_ids.size() < n) _ids.push_back(_ids.size()); _sorted = 0; } template void KdTree::sort() { if (_sorted) return; _sorted = 1; // reorder ids to sort points int np = static_cast(_points.size()); if (!np) return; if (np > 1) sortSubtree(0, np, 0); // reorder points to match id order std::vector newpoints(np); for (int i = 0; i < np; i++) newpoints[i] = _points[static_cast(_ids[i])]; std::swap(_points, newpoints); } template void KdTree::sortSubtree(int n, int size, int j) { int left, right; ComputeSubtreeSizes(size, left, right); // partition range [n, n+size) along axis j into two subranges: // [n, n+leftSize+1) and [n+leftSize+1, n+size) std::nth_element(&_ids[n], &_ids[n+left], &_ids[n+size], ComparePointsById(&_points[0].p[j])); // move median value (nth element) to front as root node of subtree std::swap(_ids[n], _ids[n+left]); // sort left and right subtrees using next discriminant if (left <= 1) return; #ifdef _MSC_VER #pragma warning (push) #pragma warning (disable : 4127) // suppress the warning due to the constant k being tested at runtime, an alternative would be to specialize the template class for k = 0 #endif if (k > 1) j = (j+1)%k; #ifdef _MSC_VER #pragma warning (pop) #endif sortSubtree(n+1, left, j); if (right <= 1) return; sortSubtree(n+left+1, right, j); } template float KdTree::findNPoints(std::vector& result, std::vector& distanceSquared,const float p[k],int nPoints,float maxRadius) const { result.resize(nPoints); distanceSquared.resize (nPoints); float finalRadius2 = maxRadius; int size = findNPoints (&result[0], &distanceSquared[0], &finalRadius2, p, nPoints, maxRadius); result.resize(size); distanceSquared.resize(size); return maxRadius; } template int KdTree::findNPoints(uint64_t *result, float *distanceSquared, float *finalSearchRadius2, const float p[k],int nPoints,float maxRadius) const { float radius_squared=maxRadius*maxRadius; if (!size() || !_sorted || nPoints<1) return 0; NearestQuery query(result,distanceSquared,p,nPoints,radius_squared); findNPoints(query,0,size(),0); *finalSearchRadius2=query.maxRadiusSquared; return query.foundPoints; } template void KdTree::findNPoints(typename KdTree::NearestQuery& query,int n,int size,int j) const { const float* p=&_points[n].p[0]; if(size>1){ float axis_distance=query.pquery[j]-p[j]; int left,right;ComputeSubtreeSizes(size,left,right); int nextj=(j+1)%k; if(axis_distance>0){ // visit right definitely, and left if within distance if(right) findNPoints(query,n+left+1,right,nextj); if(axis_distance*axis_distance void KdTree::findPoints(std::vector& result, const BBox& bbox) const { if (!size() || !_sorted) return; if (!bbox.intersects(_bbox)) return; findPoints(result, bbox, 0, size(), 0); } template void KdTree::findPoints(std::vector& result, const BBox& bbox, int n, int size, int j) const { // check point at n for inclusion const float* p = &_points[n].p[0]; if (bbox.inside(p)) result.push_back(n); if (size == 1) return; // visit left subtree int left, right; ComputeSubtreeSizes(size, left, right); int nextj = (k > 1)? (j+1)%k : j; if (p[j] >= bbox.min[j]) findPoints(result, bbox, n+1, left, nextj); // visit right subtree if (right && p[j] <= bbox.max[j]) findPoints(result, bbox, n+left+1, right, nextj); } } #endif ================================================ FILE: Externals/partio/core/Mutex.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _Mutex_ #define _Mutex_ #ifndef PARTIO_WIN32 #include namespace Partio { #ifndef PARTIO_USE_SPINLOCK class PartioMutex { pthread_mutex_t CacheLock; public: inline PartioMutex() { pthread_mutex_init(&CacheLock,0); } inline ~PartioMutex() { pthread_mutex_destroy(&CacheLock); } inline void lock() { pthread_mutex_lock(&CacheLock); } inline void unlock() { pthread_mutex_unlock(&CacheLock); } }; #else class PartioMutex { pthread_spinlock_t CacheLock; public: inline PartioMutex() { pthread_spinlock_init(&CacheLock,PTHREAD_PROCESS_PRIVATE); } inline ~PartioMutex() { pthread_spinlock_destroy(&CacheLock); } inline void lock() { pthread_spinlock_lock(&CacheLock); } inline void unlock() { pthread_spinlock_unlock(&CacheLock); } }; #endif // USE_PTHREAD_SPINLOCK } #else #include namespace Partio{ class PartioMutex { HANDLE CacheLock; public: inline PartioMutex() { CacheLock=CreateMutex(0,FALSE,"partiocache"); } inline ~PartioMutex() { CloseHandle(CacheLock); } inline void lock() { WaitForSingleObject(CacheLock,INFINITE); } inline void unlock() { ReleaseMutex(CacheLock); } }; } #endif // USE_PTHREADS #endif // Header guard ================================================ FILE: Externals/partio/core/Particle.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifdef PARTIO_WIN32 # define NOMINMAX #endif #define __STDC_LIMIT_MACROS #include #include "ParticleSimple.h" #include "ParticleSimpleInterleave.h" #include #include #include #include #include #include #include namespace Partio{ std::string TypeName(ParticleAttributeType attrType) { switch(attrType){ case NONE: return "NONE"; case VECTOR: return "VECTOR"; case FLOAT: return "FLOAT"; case INT: return "INT"; case INDEXEDSTR: return "INDEXEDSTR"; default: return 0; } } ParticlesDataMutable* create() { return new ParticlesSimple; } ParticlesDataMutable* createInterleave() { return new ParticlesSimpleInterleave; } ParticlesDataMutable* cloneSchema(const ParticlesData& other) { ParticlesDataMutable* p = create(); FixedAttribute detail; for(int i=0;iaddFixedAttribute(detail.name.c_str(), detail.type, detail.count); } ParticleAttribute attr; for(int j=0;jaddAttribute(attr.name.c_str(), attr.type, attr.count); } return p; } ParticlesDataMutable* clone(const ParticlesData& other, bool particles) { ParticlesDataMutable* p = create(); // Fixed attributes FixedAttribute srcFixedAttr, dstFixedAttr; for (int i(0), iend(other.numFixedAttributes()); i < iend; ++i) { other.fixedAttributeInfo(i, srcFixedAttr); dstFixedAttr = p->addFixedAttribute( srcFixedAttr.name.c_str(), srcFixedAttr.type, srcFixedAttr.count); assert(srcFixedAttr.type == dstFixedAttr.type); assert(srcFixedAttr.count == dstFixedAttr.count); // Register indexed strings if (srcFixedAttr.type == Partio::INDEXEDSTR) { const std::vector& values = other.fixedIndexedStrs(srcFixedAttr); for (int j = 0, jend = values.size(); j < jend; ++j) { p->registerFixedIndexedStr(dstFixedAttr, values[j].c_str()); } } // Copy fixed data const void* src = other.fixedData(srcFixedAttr); void* dst = p->fixedDataWrite(dstFixedAttr); size_t size = Partio::TypeSize(dstFixedAttr.type) * dstFixedAttr.count; std::memcpy(dst, src, size); } if (!particles) { return p; } // Particle data Partio::ParticleAttribute srcAttr, dstAttr; const int numAttributes = other.numAttributes(); const size_t numParticles = other.numParticles(); std::vector dstAttrs; p->addParticles(numParticles); // We can't assume that the particle backend stores data contiguously, so // we copy one particle at a time. A bulk memcpy would be faster. for (int i = 0; i < numAttributes; ++i) { other.attributeInfo(i, srcAttr); // Register indexed strings if (srcAttr.type == Partio::INDEXEDSTR) { const std::vector& values = other.indexedStrs(srcAttr); for (int m = 0, mend = values.size(); m < mend; ++m) { p->registerIndexedStr(dstAttr, values[m].c_str()); } } size_t size = Partio::TypeSize(srcAttr.type) * srcAttr.count; dstAttr = p->addAttribute(srcAttr.name.c_str(), srcAttr.type, srcAttr.count); for (Partio::ParticleIndex j = 0; j < numParticles; ++j) { const void *src = other.data(srcAttr, j); void *dst = p->dataWrite(dstAttr, j); std::memcpy(dst, src, size); } } return p; } template void printAttr(const ParticlesData* p,const ParticleAttribute& attr,const int particleIndex) { typedef typename ETYPE_TO_TYPE::TYPE TYPE; const TYPE* data=p->data(attr,particleIndex); for(int k=0;k getAttrs(const ParticlesData& particles) { std::vector attrs(particles.numAttributes()); for(int i=0;inumParticles()<numAttributes()< attrs = getAttrs(*particles); for (const ParticleAttribute& attr : attrs) { std::cout << "attribute " << attr.name << " type=" << TypeName(attr.type) << " count=" << attr.count << std::endl; } int numToPrint=std::min(10,particles->numParticles()); std::cout<<"num to print "<begin(),end=particles->end(); std::vector accessors; for(size_t k=0;k(it)[c]; } break; case INT: for(int c=0;c(it)[c]<<","; } break; case INDEXEDSTR: for(int c=0;c(it)[c]<<","; } break; } if (attrs[k].count > 1) std::cout<<")"; std::cout<<"\t"; } std::cout<> 11); seed ^= (seed << 7) & 0x9d2c5680UL; seed ^= (seed << 15) & 0xefc60000UL; seed ^= (seed >> 18); // permute static unsigned char p[256] = { 148,201,203,34,85,225,163,200,174,137,51,24,19,252,107,173, 110,251,149,69,180,152,141,132,22,20,147,219,37,46,154,114, 59,49,155,161,239,77,47,10,70,227,53,235,30,188,143,73, 88,193,214,194,18,120,176,36,212,84,211,142,167,57,153,71, 159,151,126,115,229,124,172,101,79,183,32,38,68,11,67,109, 221,3,4,61,122,94,72,117,12,240,199,76,118,5,48,197, 128,62,119,89,14,45,226,195,80,50,40,192,60,65,166,106, 90,215,213,232,250,207,104,52,182,29,157,103,242,97,111,17, 8,175,254,108,208,224,191,112,105,187,43,56,185,243,196,156, 246,249,184,7,135,6,158,82,130,234,206,255,160,236,171,230, 42,98,54,74,209,205,33,177,15,138,178,44,116,96,140,253, 233,125,21,133,136,86,245,58,23,1,75,165,92,217,39,0, 218,91,179,55,238,170,134,83,25,189,216,100,129,150,241,210, 123,99,2,164,16,220,121,139,168,64,190,9,31,228,95,247, 244,81,102,145,204,146,26,87,113,198,181,127,237,169,28,93, 27,41,231,248,78,162,13,186,63,66,131,202,35,144,222,223}; union { uint32_t i; unsigned char c[4]; } u1, u2; u1.i = seed; u2.c[3] = p[u1.c[0]]; u2.c[2] = p[(u1.c[1]+u2.c[3])&0xff]; u2.c[1] = p[(u1.c[2]+u2.c[2])&0xff]; u2.c[0] = p[(u1.c[3]+u2.c[1])&0xff]; // scale to [0.0 .. 1.0] return u2.i * (1.0/UINT32_MAX); } struct IdAndIndex { IdAndIndex(int id, int index) : _id(id), _index(index) {} int _id, _index; bool operator<(const IdAndIndex &other) const { return _id < other._id; } }; template T smoothstep(T t){return (3.-2.*t)*t*t;} void addClusterAttribute(ParticlesDataMutable* cluster, ParticleAttribute& clusterAttribute, const ParticlesDataMutable* particle, const int index, const ParticleAttribute& attribute, const int neighborIndex, const std::vector >& indexAndInterp) { switch(attribute.type){ case Partio::VECTOR: case Partio::FLOAT: { float* data = particle->dataWrite(attribute,index); float* neighborData = particle->dataWrite(attribute,neighborIndex); for (size_t i=0; idataWrite(clusterAttribute,indexAndInterp[i].first); for (int j=0; jdataWrite(attribute,index); for (size_t i=0; idataWrite(clusterAttribute,indexAndInterp[i].first); for (int j=0; j attributes; std::vector clusterAttributes; for (int i=0; inumAttributes(); i++) { ParticleAttribute attr; if (particles->attributeInfo(i,attr)) { if (attr.type == Partio::NONE) continue; attributes.push_back(attr); clusterAttributes.push_back(cluster->addAttribute(attributes[i].name.c_str(),attributes[i].type,attributes[i].count)); if (attr.type == Partio::INDEXEDSTR) { const std::vector& strings = particles->indexedStrs(attr); for (size_t j=0; jregisterIndexedStr(clusterAttributes.back(),strings[j].c_str()); } } if (attr.name == "position") { posAttr = attr; hasPosAttr = true; } else if (attr.name == "id") { idAttr = attr; hasIdAttr = true; } } } if (!hasPosAttr || (posAttr.type != VECTOR && posAttr.type != FLOAT) || posAttr.count !=3) { cluster->release(); return 0; } if (!hasIdAttr || idAttr.type != INT || idAttr.count != 1) { cluster->release(); return 0; } particles->sort(); ParticleAttribute clusterIdAttr = cluster->addAttribute("clusterId", Partio::INT, 1); for (int index=0; indexnumParticles(); index++) { const float* center=particles->data(posAttr,index); Vec3 position(center[0], center[1], center[2]); int id = particles->data(idAttr,index)[0]; double radius = std::max(0., radiusInside); radius = std::min(100., radiusInside); double innerRadius = .01 * radius * radiusSearch; double invRadius = 1 / (radiusSearch - innerRadius); std::vector points; std::vector distSq; particles->findNPoints(center, numNeighbors, radiusSearch, points, distSq); std::vector idAndIndex; idAndIndex.reserve(points.size()); idAndIndex.push_back(IdAndIndex(id, 0)); for (unsigned int i = 0; i < points.size(); i++) { const int pointid = particles->data(idAttr,points[i])[0]; if (pointid != id) idAndIndex.push_back(IdAndIndex(pointid, points[i])); } std::sort(++idAndIndex.begin(), idAndIndex.end()); std::vector > originalPoint; originalPoint.push_back(std::make_pair(cluster->addParticle(),0.0f)); int clusterId = 0; cluster->dataWrite(clusterIdAttr,originalPoint.back().first)[0] = clusterId++; for (size_t j = 0; j < attributes.size(); j++) { addClusterAttribute(cluster, clusterAttributes[j], particles, index, attributes[j], 0, originalPoint); } double hashArgs[3]; hashArgs[0] = id; int foundConnections = std::min((int) idAndIndex.size(), connections+1); for (int i = 1; i < foundConnections; i++) { const float* neighbor=particles->data(posAttr,idAndIndex[i]._index); Vec3 neighborPosition(neighbor[0], neighbor[1], neighbor[2]); Vec3 dir = neighborPosition - position; // calculate number of instances based on density int numInstances = 0; double len = dir.length(); if (len < innerRadius) { numInstances = density * len; } else { numInstances = density * len * smoothstep(1.-(len-innerRadius)*invRadius); } std::vector > indexAndInterp; for (int j = 0; j < numInstances; j++) { hashArgs[1] = idAndIndex[i]._id; hashArgs[2] = j; indexAndInterp.push_back(std::make_pair(cluster->addParticle(),static_cast(hash(3,hashArgs)))); cluster->dataWrite(clusterIdAttr,indexAndInterp.back().first)[0] = clusterId++; } for (size_t j = 0; j < attributes.size(); j++) { addClusterAttribute(cluster, clusterAttributes[j], particles, index, attributes[j], idAndIndex[i]._index, indexAndInterp); } } } return cluster;; } template struct AttributePair { T base; T delta; }; void merge(ParticlesDataMutable& base, const ParticlesData& delta, const std::string& identifier) { // Build a map from the identifier value to the particle index // and locate the identifier attribute in the base. // This assumes unique identifiers per particle. std::unordered_map idToParticleIndex; ParticleAttribute baseIdAttr; bool baseHasIdentifier = base.attributeInfo(identifier.c_str(), baseIdAttr); if (baseHasIdentifier) { if (baseIdAttr.type == INT) { for (int i=0; i(baseIdAttr,i)[0]] = i; } } else { baseHasIdentifier = false; } } // Locate the identifier attribute in the delta ParticleAttribute deltaIdAttr; bool deltaHasIdentifier = delta.attributeInfo(identifier.c_str(), deltaIdAttr); if (deltaHasIdentifier) { deltaHasIdentifier &= deltaIdAttr.type == INT; } bool hasIdentifier = baseHasIdentifier && deltaHasIdentifier; // Identify the attributes to be copied (base present in delta) std::vector> attrs; std::vector indexStrAttrs; /* indexes into attrs */ for (int i=0; i({std::move(baseAttr), std::move(deltaAttr)})); } } // Identify the attributes to be added (in delta, not present in base) double empty[16]{0}; for (int i=0; i({std::move(baseAttr), std::move(deltaAttr)})); // Set the attribute to a default value in the base particle set for (int p=0; p(deltaAttr); base.setFixed(baseAttr, src); } } // Identify fixed attributes to extend for (int i=0; i(deltaAttr); base.setFixed(baseAttr, src); } } // Merge the indexed strings. If the delta holds new strings for the same attribute, // we have to re-index it and extend the base string list with the new strings. // If the string exists in both, we still have to map the delta index to the base index. std::unordered_map > stringToString; for (size_t index : indexStrAttrs) { const AttributePair& attr = attrs[index]; /* For each string in the delta, add to base if missing. And re-index. */ const std::vector& baseStrs = base.indexedStrs(attr.base); // Map source indices name->index for faster searching std::unordered_map indexInBase; for (size_t i=0; i& deltaStrs = delta.indexedStrs(attr.delta); for (size_t i=0; isecond; } else { int newIndex = base.registerIndexedStr(attr.base, deltaStr.c_str()); stringToString[attr.base.name][i] = newIndex; } } } // Loop through the delta particles and incorporate into the base for (int i=0; i(deltaIdAttr, i)); auto it = idToParticleIndex.find(idValue); if (it != idToParticleIndex.end()) { index = it->second; } } if (index == -1) { index = base.addParticle(); } // Copy the attributes to the new/overridden particle for (const AttributePair& attr : attrs) { size_t size = Partio::TypeSize(attr.base.type) * attr.base.count; void *dst = base.dataWrite(attr.base, index); const void* src; std::unique_ptr newIndices; if (attr.base.type == INDEXEDSTR) { newIndices.reset(new int[attr.base.count]); const int* indices = delta.data(attr.delta, i); for (int j=0; j(attr.delta, i); } std::memcpy(dst, src, size); } } } } ================================================ FILE: Externals/partio/core/ParticleCaching.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #include #include #include "Mutex.h" #include "../Partio.h" //##################################################################### namespace Partio{ namespace { static PartioMutex mutex; } // cached read write std::map cachedParticlesCount; std::map cachedParticles; ParticlesData* readCached(const char* filename,const bool sort,const bool verbose,std::ostream& error) { mutex.lock(); std::map::iterator i=cachedParticles.find(filename); ParticlesData* p=0; if(i!=cachedParticles.end()){ p=i->second; cachedParticlesCount[p]++; }else{ ParticlesDataMutable* p_rw=read(filename,verbose); if(p_rw){ if(sort) p_rw->sort(); p=p_rw; cachedParticles[filename]=p; cachedParticlesCount[p]=1; } } mutex.unlock(); return p; } void freeCached(ParticlesData* particles) { if(!particles) return; mutex.lock(); std::map::iterator i=cachedParticlesCount.find(particles); if(i==cachedParticlesCount.end()){ // Not found in cache, just free delete particles; }else{ // found in cache i->second--; // decrement ref count if(i->second==0){ // ref count is now zero, remove from structure delete particles; cachedParticlesCount.erase(i); for(std::map::iterator i2=cachedParticles.begin(); i2!=cachedParticles.end();++i2){ if(i2->second==particles){ cachedParticles.erase(i2); goto exit_and_release; } } assert(false); } } exit_and_release: mutex.unlock(); } void beginCachedAccess(ParticlesData*) { // TODO: for future use } void endCachedAccess(ParticlesData*) { // TODO: for future use } } // namespace Partio ================================================ FILE: Externals/partio/core/ParticleCaching.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _ParticleCaching_h_ #define _ParticleCaching_h_ namespace Partio{ class Particles; void freeCached(ParticlesInfo* particles); } #endif ================================================ FILE: Externals/partio/core/ParticleHeaders.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #include "ParticleHeaders.h" #include #include #include #include using namespace Partio; ParticleHeaders:: ParticleHeaders() :particleCount(0) { } ParticleHeaders:: ~ParticleHeaders() { } void ParticleHeaders:: release() { delete this; } int ParticleHeaders:: numParticles() const { return particleCount; } int ParticleHeaders:: numAttributes() const { return static_cast(attributes.size()); } int ParticleHeaders:: numFixedAttributes() const { return static_cast(fixedAttributes.size()); } bool ParticleHeaders:: attributeInfo(const int attributeIndex,ParticleAttribute& attribute) const { if(attributeIndex<0 || attributeIndex>=(int)attributes.size()) return false; attribute=attributes[attributeIndex]; return true; } bool ParticleHeaders:: fixedAttributeInfo(const int attributeIndex,FixedAttribute& attribute) const { if(attributeIndex<0 || attributeIndex>=(int)fixedAttributes.size()) return false; attribute=fixedAttributes[attributeIndex]; return true; } bool ParticleHeaders:: attributeInfo(const char* attributeName,ParticleAttribute& attribute) const { std::map::const_iterator it=nameToAttribute.find(attributeName); if(it!=nameToAttribute.end()){ attribute=attributes[it->second]; return true; } return false; } bool ParticleHeaders:: fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const { std::map::const_iterator it=nameToFixedAttribute.find(attributeName); if(it!=nameToFixedAttribute.end()){ attribute=fixedAttributes[it->second]; return true; } return false; } void ParticleHeaders:: sort() { assert(false); } int ParticleHeaders:: registerIndexedStr(const ParticleAttribute&, const char*) { assert(false); return -1; } int ParticleHeaders:: registerFixedIndexedStr(const FixedAttribute&, const char* str) { assert(false); return -1; } int ParticleHeaders:: lookupIndexedStr(const ParticleAttribute&, const char*) const { assert(false); return -1; } int ParticleHeaders:: lookupFixedIndexedStr(const FixedAttribute&, const char* str) const { assert(false); return -1; } const std::vector& ParticleHeaders:: indexedStrs(const ParticleAttribute&) const { static std::vector dummy; assert(false); return dummy; } const std::vector& ParticleHeaders:: fixedIndexedStrs(const FixedAttribute& attr) const { static std::vector dummy; assert(false); return dummy; } void ParticleHeaders:: findPoints(const float[3],const float[3],std::vector&) const { assert(false); } float ParticleHeaders:: findNPoints(const float[3],const int,const float,std::vector&,std::vector&) const { assert(false); return 0; } int ParticleHeaders:: findNPoints(const float[3],int,const float, ParticleIndex *, float *, float *) const { assert(false); return 0; } ParticleAttribute ParticleHeaders:: addAttribute(const char* attribute,ParticleAttributeType type,const int count) { // TODO: check if attribute already exists and if so what data type ParticleAttribute attr; attr.name=attribute; attr.type=type; attr.attributeIndex=static_cast(attributes.size()); // all arrays separate so we don't use this here! attr.count=count; attributes.push_back(attr); nameToAttribute[attribute]=static_cast(attributes.size()-1); return attr; } FixedAttribute ParticleHeaders:: addFixedAttribute(const char* attribute,ParticleAttributeType type,const int count) { // TODO: check if attribute already exists and if so what data type FixedAttribute attr; attr.name=attribute; attr.type=type; attr.attributeIndex=fixedAttributes.size(); // all arrays separate so we don't use this here! attr.count=count; fixedAttributes.push_back(attr); nameToFixedAttribute[attribute]=fixedAttributes.size()-1; return attr; } ParticleIndex ParticleHeaders:: addParticle() { ParticleIndex index=particleCount; particleCount++; return index; } ParticlesDataMutable::iterator ParticleHeaders:: addParticles(const int countToAdd) { particleCount+=countToAdd; return iterator(); } void* ParticleHeaders:: dataInternal(const ParticleAttribute&,const ParticleIndex) const { assert(false); return 0; } void* ParticleHeaders:: fixedDataInternal(const FixedAttribute& attribute) const { assert(false); return 0; } void ParticleHeaders:: dataInternalMultiple(const ParticleAttribute&,const int, const ParticleIndex*,const bool,char*) const { assert(false); } void ParticleHeaders:: dataAsFloat(const ParticleAttribute&,const int, const ParticleIndex*,const bool,float*) const { assert(false); } void ParticleHeaders:: setIndexedStr(const ParticleAttribute& attribute,int indexedStringToken,const char* str){ assert(false); } void ParticleHeaders:: setFixedIndexedStr(const FixedAttribute& attribute,int indexedStringToken,const char* str){ assert(false); } ================================================ FILE: Externals/partio/core/ParticleHeaders.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _ParticlesHeaders_h_ #define _ParticlesHeaders_h_ #include "../Partio.h" namespace Partio{ class ParticleHeaders:public ParticlesDataMutable { public: ParticleHeaders(); virtual void release(); protected: virtual ~ParticleHeaders(); int numAttributes() const; int numFixedAttributes() const; int numParticles() const; bool attributeInfo(const char* attributeName,ParticleAttribute& attribute) const; bool fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const; bool attributeInfo(const int attributeInfo,ParticleAttribute& attribute) const; bool fixedAttributeInfo(const int attributeInfo,FixedAttribute& attribute) const; int registerIndexedStr(const ParticleAttribute& attribute,const char* str); int registerFixedIndexedStr(const FixedAttribute& attribute,const char* str); int lookupIndexedStr(const ParticleAttribute& attribute,const char* str) const; int lookupFixedIndexedStr(const FixedAttribute& attribute,const char* str) const; void setIndexedStr(const ParticleAttribute& attribute,int indexedStrHandle,const char* str); void setFixedIndexedStr(const FixedAttribute& attribute,int indexedStrHandle,const char* str); const std::vector& indexedStrs(const ParticleAttribute& attr) const; const std::vector& fixedIndexedStrs(const FixedAttribute& attr) const; virtual void dataAsFloat(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,float* values) const; void sort(); void findPoints(const float bboxMin[3],const float bboxMax[3],std::vector& points) const; float findNPoints(const float center[3],int nPoints,const float maxRadius, std::vector& points,std::vector& pointDistancesSquared) const; int findNPoints(const float center[3],int nPoints,const float maxRadius, ParticleIndex *points, float *pointDistancesSquared, float *finalRadius2) const; ParticlesDataMutable* computeClustering(const int numNeighbors,const double radiusSearch,const double radiusInside,const int connections,const double density) {assert(false); return nullptr;} ParticleAttribute addAttribute(const char* attribute,ParticleAttributeType type,const int count); FixedAttribute addFixedAttribute(const char* attribute,ParticleAttributeType type,const int count); ParticleIndex addParticle(); iterator addParticles(const int count); const_iterator setupConstIterator(const int index=0) const {return const_iterator();} iterator setupIterator(const int index=0) {return iterator();} private: void* dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const; void* fixedDataInternal(const FixedAttribute& attribute) const; void dataInternalMultiple(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,char* values) const; private: int particleCount; std::vector attributes; std::map nameToAttribute; std::vector fixedAttributes; std::map nameToFixedAttribute; }; } #endif ================================================ FILE: Externals/partio/core/ParticleSimple.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifdef PARTIO_WIN32 # define NOMINMAX #endif #include "ParticleSimple.h" #include "ParticleCaching.h" #include #include #include #include #include "KdTree.h" using namespace Partio; ParticlesSimple:: ParticlesSimple() :particleCount(0),allocatedCount(0),kdtree(0) { } ParticlesSimple:: ~ParticlesSimple() { for(unsigned int i=0;i(attributes.size()); } int ParticlesSimple:: numFixedAttributes() const { return fixedAttributes.size(); } bool ParticlesSimple:: attributeInfo(const int attributeIndex,ParticleAttribute& attribute) const { if(attributeIndex<0 || attributeIndex>=(int)attributes.size()) return false; attribute=attributes[attributeIndex]; return true; } bool ParticlesSimple:: fixedAttributeInfo(const int attributeIndex,FixedAttribute& attribute) const { if(attributeIndex<0 || attributeIndex>=(int)fixedAttributes.size()) return false; attribute=fixedAttributes[attributeIndex]; return true; } bool ParticlesSimple:: attributeInfo(const char* attributeName,ParticleAttribute& attribute) const { std::map::const_iterator it=nameToAttribute.find(attributeName); if(it!=nameToAttribute.end()){ attribute=attributes[it->second]; return true; } return false; } bool ParticlesSimple:: fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const { std::map::const_iterator it=nameToFixedAttribute.find(attributeName); if(it!=nameToFixedAttribute.end()){ attribute=fixedAttributes[it->second]; return true; } return false; } void ParticlesSimple:: sort() { ParticleAttribute attr; bool foundPosition=attributeInfo("position",attr); if(!foundPosition){ std::cerr<<"Partio: sort, Failed to find position in particle"<data(attr,baseParticleIndex); // contiguous assumption used here KdTree<3>* kdtree_temp=new KdTree<3>(); kdtree_temp->setPoints(data,numParticles()); kdtree_temp->sort(); kdtree_mutex.lock(); // TODO: this is not threadsafe! if(kdtree) delete kdtree; kdtree=kdtree_temp; kdtree_mutex.unlock(); } void ParticlesSimple:: findPoints(const float bboxMin[3],const float bboxMax[3],std::vector& points) const { if(!kdtree){ std::cerr<<"Partio: findPoints without first calling sort()"< box(bboxMin);box.grow(bboxMax); int startIndex=static_cast(points.size()); kdtree->findPoints(points,box); // remap points found in findPoints to original index space for(unsigned int i=startIndex;iid(static_cast(points[i])); } } float ParticlesSimple:: findNPoints(const float center[3],const int nPoints,const float maxRadius,std::vector& points, std::vector& pointDistancesSquared) const { if(!kdtree){ std::cerr<<"Partio: findNPoints without first calling sort()"<& rawPoints=points; float maxDistance=kdtree->findNPoints(points,pointDistancesSquared,center,nPoints,maxRadius); // remap all points since findNPoints clears array for(unsigned int i=0;iid(static_cast(points[i])); points[i]=index; } return maxDistance; } int ParticlesSimple:: findNPoints(const float center[3],int nPoints,const float maxRadius, ParticleIndex *points, float *pointDistancesSquared, float *finalRadius2) const { if(!kdtree){ std::cerr<<"Partio: findNPoints without first calling sort()"<findNPoints (points, pointDistancesSquared, finalRadius2, center, nPoints, maxRadius); // remap all points since findNPoints clears array for(int i=0; i < count; i++){ ParticleIndex index = kdtree->id(static_cast(points[i])); points[i]=index; } return count; } ParticleAttribute ParticlesSimple:: addAttribute(const char* attribute,ParticleAttributeType type,const int count) { if(nameToAttribute.find(attribute) != nameToAttribute.end()){ std::cerr<<"Partio: addAttribute failed because attr '"<(attributes.size()); // all arrays separate so we don't use this here! attr.count=count; attributes.push_back(attr); nameToAttribute[attribute]=static_cast(attributes.size()-1); int stride=TypeSize(type)*count; attributeStrides.push_back(stride); char* dataPointer=(char*)malloc((size_t)allocatedCount*(size_t)stride); attributeData.push_back(dataPointer); attributeOffsets.push_back(dataPointer-(char*)0); attributeIndexedStrs.push_back(IndexedStrTable()); return attr; } FixedAttribute ParticlesSimple:: addFixedAttribute(const char* attribute,ParticleAttributeType type,const int count) { if(nameToFixedAttribute.find(attribute) != nameToFixedAttribute.end()){ std::cerr<<"Partio: addFixedAttribute failed because attr '"<allocatedCount){ // TODO: this should follow 2/3 rule allocatedCount=allocatedCount+countToAdd; for(unsigned int i=0;i& iterator) { iterator=end(); } void ParticlesSimple:: setupIteratorNextBlock(Partio::ParticleIterator& iterator) const { iterator=ParticlesData::end(); } void ParticlesSimple:: setupAccessor(Partio::ParticleIterator&,ParticleAccessor& accessor) { accessor.stride=accessor.count*sizeof(float); accessor.basePointer=attributeData[accessor.attributeIndex]; } void ParticlesSimple:: setupAccessor(Partio::ParticleIterator&,ParticleAccessor& accessor) const { accessor.stride=accessor.count*sizeof(float); accessor.basePointer=attributeData[accessor.attributeIndex]; } void* ParticlesSimple:: dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const { assert(attribute.attributeIndex>=0 && attribute.attributeIndex<(int)attributes.size()); return attributeData[attribute.attributeIndex]+attributeStrides[attribute.attributeIndex]*particleIndex; } void* ParticlesSimple:: fixedDataInternal(const FixedAttribute& attribute) const { assert(attribute.attributeIndex>=0 && attribute.attributeIndex<(int)fixedAttributes.size()); return fixedAttributeData[attribute.attributeIndex]; } void ParticlesSimple:: dataInternalMultiple(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool,char* values) const { assert(attribute.attributeIndex>=0 && attribute.attributeIndex<(int)attributes.size()); char* base=attributeData[attribute.attributeIndex]; int bytes=attributeStrides[attribute.attributeIndex]; for(int i=0;i=0 && attribute.attributeIndex<(int)attributes.size()); if(attribute.type==FLOAT || attribute.type==VECTOR) dataInternalMultiple(attribute,indexCount,particleIndices,sorted,(char*)values); else if(attribute.type==INT || attribute.type==INDEXEDSTR){ char* attrrawbase=attributeData[attribute.attributeIndex]; int* attrbase=(int*)attrrawbase; int count=attribute.count; for(int i=0;i(attrbase[particleIndices[i]*count+k]); } } int ParticlesSimple:: registerIndexedStr(const ParticleAttribute& attribute,const char* str) { IndexedStrTable& table=attributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; int newIndex=static_cast(table.strings.size()); table.strings.push_back(str); table.stringToIndex[str]=newIndex; return newIndex; } int ParticlesSimple:: registerFixedIndexedStr(const FixedAttribute& attribute,const char* str) { IndexedStrTable& table=fixedAttributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; int newIndex=table.strings.size(); table.strings.push_back(str); table.stringToIndex[str]=newIndex; return newIndex; } int ParticlesSimple:: lookupIndexedStr(Partio::ParticleAttribute const &attribute, char const *str) const { const IndexedStrTable& table=attributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; return -1; } int ParticlesSimple:: lookupFixedIndexedStr(Partio::FixedAttribute const &attribute, char const *str) const { const IndexedStrTable& table=fixedAttributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; return -1; } const std::vector& ParticlesSimple:: indexedStrs(const ParticleAttribute& attr) const { const IndexedStrTable& table=attributeIndexedStrs[attr.attributeIndex]; return table.strings; } const std::vector& ParticlesSimple:: fixedIndexedStrs(const FixedAttribute& attr) const { const IndexedStrTable& table=fixedAttributeIndexedStrs[attr.attributeIndex]; return table.strings; } void ParticlesSimple::setIndexedStr(const ParticleAttribute& attribute,int indexedStringToken,const char* str){ IndexedStrTable& table=attributeIndexedStrs[attribute.attributeIndex]; if(indexedStringToken >= int(table.strings.size()) || indexedStringToken < 0) return; table.stringToIndex.erase(table.stringToIndex.find(table.strings[indexedStringToken])); table.strings[indexedStringToken] = str; table.stringToIndex[str]=indexedStringToken; } void ParticlesSimple::setFixedIndexedStr(const FixedAttribute& attribute,int indexedStringToken,const char* str){ IndexedStrTable& table=fixedAttributeIndexedStrs[attribute.attributeIndex]; if(indexedStringToken >= int(table.strings.size()) || indexedStringToken < 0) return; table.stringToIndex.erase(table.stringToIndex.find(table.strings[indexedStringToken])); table.strings[indexedStringToken] = str; table.stringToIndex[str]=indexedStringToken; } ================================================ FILE: Externals/partio/core/ParticleSimple.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #include #include #include #include #include "Mutex.h" #include "../Partio.h" namespace Partio{ template class KdTree; class ParticlesSimple:public ParticlesDataMutable, public Provider { protected: virtual ~ParticlesSimple(); public: using ParticlesDataMutable::iterator; using ParticlesData::const_iterator; virtual void release(); ParticlesSimple(); int numAttributes() const; int numFixedAttributes() const; int numParticles() const; bool attributeInfo(const char* attributeName,ParticleAttribute& attribute) const; bool fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const; bool attributeInfo(const int attributeInfo,ParticleAttribute& attribute) const; bool fixedAttributeInfo(const int attributeInfo,FixedAttribute& attribute) const; void dataAsFloat(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,float* values) const; int registerIndexedStr(const ParticleAttribute& attribute,const char* str); int registerFixedIndexedStr(const FixedAttribute& attribute,const char* str); void setIndexedStr(const ParticleAttribute& attribute,int indexedStringToken,const char* str); void setFixedIndexedStr(const FixedAttribute& attribute,int indexedStringToken,const char* str); int lookupIndexedStr(const ParticleAttribute& attribute,const char* str) const; int lookupFixedIndexedStr(const FixedAttribute& attribute,const char* str) const; const std::vector& indexedStrs(const ParticleAttribute& attr) const; const std::vector& fixedIndexedStrs(const FixedAttribute& attr) const; void sort(); void findPoints(const float bboxMin[3],const float bboxMax[3],std::vector& points) const; float findNPoints(const float center[3],int nPoints,const float maxRadius, std::vector& points,std::vector& pointDistancesSquared) const; int findNPoints(const float center[3],int nPoints,const float maxRadius, ParticleIndex *points, float *pointDistancesSquared, float *finalRadius2) const; ParticlesDataMutable* computeClustering(const int numNeighbors,const double radiusSearch,const double radiusInside,const int connections,const double density); ParticleAttribute addAttribute(const char* attribute,ParticleAttributeType type,const int count); FixedAttribute addFixedAttribute(const char* attribute,ParticleAttributeType type,const int count); ParticleIndex addParticle(); iterator addParticles(const int count); iterator setupIterator(const int index=0); const_iterator setupConstIterator(const int index=0) const; void setupIteratorNextBlock(Partio::ParticleIterator& iterator); void setupIteratorNextBlock(Partio::ParticleIterator& iterator) const; void setupAccessor(Partio::ParticleIterator& iterator,ParticleAccessor& accessor); void setupAccessor(Partio::ParticleIterator& iterator,ParticleAccessor& accessor) const; private: void* dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const; void* fixedDataInternal(const FixedAttribute& attribute) const; void dataInternalMultiple(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,char* values) const; private: int particleCount; int allocatedCount; std::vector attributeData; // Inside is data of appropriate type std::vector attributeOffsets; // Inside is data of appropriate type struct IndexedStrTable{ std::map stringToIndex; // TODO: this should be a hash table unordered_map std::vector strings; }; std::vector attributeIndexedStrs; std::vector attributes; std::vector attributeStrides; std::map nameToAttribute; std::vector fixedAttributeData; // Inside is data of appropriate type std::vector fixedAttributeIndexedStrs; std::vector fixedAttributes; std::map nameToFixedAttribute; PartioMutex kdtree_mutex; KdTree<3>* kdtree; }; } ================================================ FILE: Externals/partio/core/ParticleSimpleInterleave.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifdef PARTIO_WIN32 # define NOMINMAX #endif #include "ParticleSimpleInterleave.h" #include "ParticleCaching.h" #include #include #include #include #include "KdTree.h" using namespace Partio; ParticlesSimpleInterleave:: ParticlesSimpleInterleave() :particleCount(0),allocatedCount(0),data(0),fixedData(0),stride(0),kdtree(0) { } ParticlesSimpleInterleave:: ~ParticlesSimpleInterleave() { free(data); free(fixedData); delete kdtree; } void ParticlesSimpleInterleave:: release() { freeCached(this); } int ParticlesSimpleInterleave:: numParticles() const { return particleCount; } int ParticlesSimpleInterleave:: numAttributes() const { return static_cast(attributes.size()); } int ParticlesSimpleInterleave:: numFixedAttributes() const { return fixedAttributes.size(); } bool ParticlesSimpleInterleave:: attributeInfo(const int attributeIndex,ParticleAttribute& attribute) const { if(attributeIndex<0 || attributeIndex>=(int)attributes.size()) return false; attribute=attributes[attributeIndex]; return true; } bool ParticlesSimpleInterleave:: fixedAttributeInfo(const int attributeIndex,FixedAttribute& attribute) const { if(attributeIndex<0 || attributeIndex>=(int)fixedAttributes.size()) return false; attribute=fixedAttributes[attributeIndex]; return true; } bool ParticlesSimpleInterleave:: attributeInfo(const char* attributeName,ParticleAttribute& attribute) const { std::map::const_iterator it=nameToAttribute.find(attributeName); if(it!=nameToAttribute.end()){ attribute=attributes[it->second]; return true; } return false; } bool ParticlesSimpleInterleave:: fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const { std::map::const_iterator it=nameToFixedAttribute.find(attributeName); if(it!=nameToFixedAttribute.end()){ attribute=fixedAttributes[it->second]; return true; } return false; } void ParticlesSimpleInterleave:: sort() { #if 0 ParticleAttribute attr; bool foundPosition=attributeInfo("position",attr); if(!foundPosition){ std::cerr<<"Partio: sort, Failed to find position in particle"<data(attr,0); // contiguous assumption used here KdTree<3>* kdtree_temp=new KdTree<3>(); kdtree_temp->setPoints(data,numParticles()); kdtree_temp->sort(); kdtree_mutex.lock(); // TODO: this is not threadsafe! if(kdtree) delete kdtree; kdtree=kdtree_temp; kdtree_mutex.unlock(); #endif } void ParticlesSimpleInterleave:: findPoints(const float[3],const float[3],std::vector&) const { #if 0 if(!kdtree){ std::cerr<<"Partio: findPoints without first calling sort()"< box(bboxMin);box.grow(bboxMax); int startIndex=points.size(); kdtree->findPoints(points,box); // remap points found in findPoints to original index spac for(unsigned int i=startIndex;iid(points[i]); #endif } float ParticlesSimpleInterleave:: findNPoints(const float[3],const int,const float,std::vector&, std::vector&) const { #if 0 if(!kdtree){ std::cerr<<"Partio: findNPoints without first calling sort()"<findNPoints(points,pointDistancesSquared,center,nPoints,maxRadius); // remap all points since findNPoints clears array for(unsigned int i=0;iid(points[i]); return maxDistance; #endif return 0; } int ParticlesSimpleInterleave:: findNPoints(const float[3], int, const float, ParticleIndex *, float *, float *) const { // TODO: I guess they don't support this lookup here return 0; } ParticleAttribute ParticlesSimpleInterleave:: addAttribute(const char* attribute,ParticleAttributeType type,const int count) { //std::cerr<< "AddAttribute interleave" << std::endl; if(nameToAttribute.find(attribute) != nameToAttribute.end()){ std::cerr<<"Partio: addAttribute failed because attr '"<(attributes.size()); // all arrays separate so we don't use this here! attr.count=count; attributes.push_back(attr); nameToAttribute[attribute]=static_cast(attributes.size()-1); // repackage data for new attribute int oldStride=stride; int newStride=stride+TypeSize(type)*count; char* newData=(char*)malloc((size_t)allocatedCount*(size_t)newStride); if(data){ char* ptrNew=newData; char* ptrOld=data; for(int i=0;iallocatedCount){ while(allocatedCount& iterator) { iterator=end(); } void ParticlesSimpleInterleave:: setupIteratorNextBlock(Partio::ParticleIterator& iterator) const { iterator=ParticlesData::end(); } void ParticlesSimpleInterleave:: setupAccessor(Partio::ParticleIterator&,ParticleAccessor& accessor) { accessor.stride=stride; accessor.basePointer=data+attributeOffsets[accessor.attributeIndex]; } void ParticlesSimpleInterleave:: setupAccessor(Partio::ParticleIterator&,ParticleAccessor& accessor) const { accessor.stride=stride; accessor.basePointer=data+attributeOffsets[accessor.attributeIndex]; } void* ParticlesSimpleInterleave:: dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const { return data+particleIndex*stride+attributeOffsets[attribute.attributeIndex]; } void* ParticlesSimpleInterleave:: fixedDataInternal(const FixedAttribute& attribute) const { return data+allocatedCount*stride+fixedAttributeOffsets[attribute.attributeIndex]; } void ParticlesSimpleInterleave:: dataInternalMultiple(const ParticleAttribute&,const int,const ParticleIndex*,const bool,char*) const { #if 0 assert(attribute.attributeIndex>=0 && attribute.attributeIndex<(int)attributes.size()); char* base=attributeData[attribute.attributeIndex]; int bytes=attributeStrides[attribute.attributeIndex]; for(int i=0;i=0 && attribute.attributeIndex<(int)attributes.size()); if(attribute.type==FLOAT || attribute.type==VECTOR) dataInternalMultiple(attribute,indexCount,particleIndices,sorted,(char*)values); else if(attribute.type==INT){ char* attrrawbase=attributeData[attribute.attributeIndex]; int* attrbase=(int*)attrrawbase; int count=attribute.count; for(int i=0;i::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; int newIndex=static_cast(table.strings.size()); table.strings.push_back(str); table.stringToIndex[str]=newIndex; return newIndex; } int ParticlesSimpleInterleave:: registerFixedIndexedStr(const FixedAttribute& attribute,const char* str) { IndexedStrTable& table=fixedAttributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; int newIndex=table.strings.size(); table.strings.push_back(str); table.stringToIndex[str]=newIndex; return newIndex; } int ParticlesSimpleInterleave:: lookupIndexedStr(Partio::ParticleAttribute const &attribute, char const *str) const { const IndexedStrTable& table=attributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; return -1; } int ParticlesSimpleInterleave:: lookupFixedIndexedStr(Partio::FixedAttribute const &attribute, char const *str) const { const IndexedStrTable& table=fixedAttributeIndexedStrs[attribute.attributeIndex]; std::map::const_iterator it=table.stringToIndex.find(str); if(it!=table.stringToIndex.end()) return it->second; return -1; } const std::vector& ParticlesSimpleInterleave:: indexedStrs(const ParticleAttribute& attr) const { const IndexedStrTable& table=attributeIndexedStrs[attr.attributeIndex]; return table.strings; } const std::vector& ParticlesSimpleInterleave:: fixedIndexedStrs(const FixedAttribute& attr) const { const IndexedStrTable& table=fixedAttributeIndexedStrs[attr.attributeIndex]; return table.strings; } void ParticlesSimpleInterleave::setIndexedStr(const ParticleAttribute& attribute,int indexedStringToken,const char* str){ IndexedStrTable& table=attributeIndexedStrs[attribute.attributeIndex]; if(indexedStringToken >= int(table.strings.size()) || indexedStringToken < 0) return; table.stringToIndex.erase(table.stringToIndex.find(table.strings[indexedStringToken])); table.strings[indexedStringToken] = str; table.stringToIndex[str]=indexedStringToken; } void ParticlesSimpleInterleave::setFixedIndexedStr(const FixedAttribute& attribute,int indexedStringToken,const char* str){ IndexedStrTable& table=fixedAttributeIndexedStrs[attribute.attributeIndex]; if(indexedStringToken >= int(table.strings.size()) || indexedStringToken < 0) return; table.stringToIndex.erase(table.stringToIndex.find(table.strings[indexedStringToken])); table.strings[indexedStringToken] = str; table.stringToIndex[str]=indexedStringToken; } ================================================ FILE: Externals/partio/core/ParticleSimpleInterleave.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _ParticleSimpleInterleave_h_ #define _ParticleSimpleInterleave_h_ #include #include #include #include "Mutex.h" #include "../Partio.h" namespace Partio{ template class KdTree; class ParticlesSimpleInterleave:public ParticlesDataMutable, public Provider { protected: virtual ~ParticlesSimpleInterleave(); public: using ParticlesDataMutable::iterator; using ParticlesData::const_iterator; virtual void release(); ParticlesSimpleInterleave(); int numAttributes() const; int numFixedAttributes() const; int numParticles() const; bool attributeInfo(const char* attributeName,ParticleAttribute& attribute) const; bool fixedAttributeInfo(const char* attributeName,FixedAttribute& attribute) const; bool attributeInfo(const int attributeInfo,ParticleAttribute& attribute) const; bool fixedAttributeInfo(const int attributeInfo,FixedAttribute& attribute) const; virtual void dataAsFloat(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,float* values) const; int registerIndexedStr(const ParticleAttribute& attribute,const char* str); int registerFixedIndexedStr(const FixedAttribute& attribute,const char* str); void setIndexedStr(const ParticleAttribute& attribute,int indexedStringToken,const char* str); void setFixedIndexedStr(const FixedAttribute& attribute,int indexedStringToken,const char* str); int lookupIndexedStr(const ParticleAttribute& attribute,const char* str) const; int lookupFixedIndexedStr(const FixedAttribute& attribute,const char* str) const; const std::vector& indexedStrs(const ParticleAttribute& attr) const; const std::vector& fixedIndexedStrs(const FixedAttribute& attr) const; void sort(); void findPoints(const float bboxMin[3],const float bboxMax[3],std::vector& points) const; float findNPoints(const float center[3],int nPoints,const float maxRadius, std::vector& points,std::vector& pointDistancesSquared) const; int findNPoints(const float center[3],int nPoints,const float maxRadius, ParticleIndex *points, float *pointDistancesSquared, float *finalRadius2) const; ParticlesDataMutable* computeClustering(const int numNeighbors,const double radiusSearch,const double radiusInside,const int connections,const double density) { assert(false); return nullptr; } ParticleAttribute addAttribute(const char* attribute,ParticleAttributeType type,const int count); FixedAttribute addFixedAttribute(const char* attribute,ParticleAttributeType type,const int count); ParticleIndex addParticle(); iterator addParticles(const int count); iterator setupIterator(const int index=0); const_iterator setupConstIterator(const int index=0) const; void setupIteratorNextBlock(Partio::ParticleIterator& iterator); void setupIteratorNextBlock(Partio::ParticleIterator& iterator) const; void setupAccessor(Partio::ParticleIterator& iterator,ParticleAccessor& accessor); void setupAccessor(Partio::ParticleIterator& iterator,ParticleAccessor& accessor) const; private: void* dataInternal(const ParticleAttribute& attribute,const ParticleIndex particleIndex) const; void* fixedDataInternal(const FixedAttribute& attribute) const; void dataInternalMultiple(const ParticleAttribute& attribute,const int indexCount, const ParticleIndex* particleIndices,const bool sorted,char* values) const; private: int particleCount; int allocatedCount; char* data; char* fixedData; int stride; struct IndexedStrTable{ std::map stringToIndex; // TODO: this should be a hash table unordered_map std::vector strings; }; std::vector attributeIndexedStrs; std::vector attributeOffsets; // Inside is data of appropriate type std::vector attributes; std::map nameToAttribute; std::vector fixedAttributeIndexedStrs; std::vector fixedAttributeOffsets; // Inside is data of appropriate type std::vector fixedAttributes; std::map nameToFixedAttribute; PartioMutex kdtree_mutex; KdTree<3>* kdtree; }; } #endif ================================================ FILE: Externals/partio/io/BGEO.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #include "../Partio.h" #include "PartioEndian.h" #include "../core/ParticleHeaders.h" #include "ZIP.h" #include #include #include #include #include #include namespace Partio { using namespace std; void writeHoudiniStr(ostream& ostream,const string& s) { write(ostream,(short)s.size()); ostream.write(s.c_str(),s.size()); } template struct Helper { T addAttribute(ParticlesDataMutable* simple, const char* name, ParticleAttributeType type, int size); int registerIndexedStr(const T& attribute,const char* str); }; template<> struct Helper { ParticleAttribute addAttribute(ParticlesDataMutable* simple, const char* name, ParticleAttributeType type, int size) {return simple->addAttribute(name,type,size);} int registerIndexedStr(ParticlesDataMutable* simple, const ParticleAttribute& attribute,const char* str) {return simple->registerIndexedStr(attribute,str);} }; template<> struct Helper { FixedAttribute addAttribute(ParticlesDataMutable* simple, const char* name, ParticleAttributeType type, int size) {return simple->addFixedAttribute(name,type,size);} int registerIndexedStr(ParticlesDataMutable* simple, const FixedAttribute& attribute,const char* str) {return simple->registerFixedIndexedStr(attribute,str);} }; class DummyAttribute {}; template<> struct Helper { DummyAttribute addAttribute(ParticlesDataMutable* simple, const char* name, ParticleAttributeType type, int size) { return DummyAttribute(); } int registerIndexedStr(ParticlesDataMutable* simple, const DummyAttribute& attribute,const char* str) { return 0; } }; struct DummyAccessor{ template DummyAccessor(const T& /*attr*/){} }; template bool getAttributes(int& particleSize, vector& attrOffsets, vector& attrHandles, vector& accessors, int nAttrib, istream* input, ParticlesDataMutable* simple, bool headersOnly, std::ostream* errorStream) { Helper helper; for(int i=0;i(*input,nameLength); char* name=new char[nameLength+1]; input->read(name,nameLength);name[nameLength]=0; unsigned short size; int houdiniType; read(*input,size,houdiniType); if(houdiniType==0 || houdiniType==1 || houdiniType==5){ // read default values. don't do anything with them for(int i=0;iread((char*)&defaultValue,sizeof(int)); } ParticleAttributeType type=NONE; if(houdiniType==0) type=FLOAT; else if(houdiniType==1) type=INT; else if(houdiniType==5) type=VECTOR; attrHandles.push_back(helper.addAttribute(simple,name,type,size)); accessors.push_back(TAccessor(attrHandles.back())); attrOffsets.push_back(particleSize); particleSize+=size; }else if(houdiniType==4){ TAttribute attribute=helper.addAttribute(simple,name,INDEXEDSTR,size); attrHandles.push_back(attribute); accessors.push_back(TAccessor(attrHandles.back())); attrOffsets.push_back(particleSize); int numIndices=0; read(*input,numIndices); for(int ii=0;ii(*input,indexNameLength); char* indexName=new char[indexNameLength+1];; input->read(indexName,indexNameLength); indexName[indexNameLength]=0; if (!headersOnly) { int id=helper.registerIndexedStr(simple,attribute,indexName); if(id != ii){ if(errorStream) *errorStream <<"Partio: error on read, expected registerIndexStr to return index "<release(); return 0; }else{ if(errorStream) *errorStream <<"Partio: unknown attribute "<release(); return 0; } delete[] name; } return true; } // read buffer, seekg doesn't work with gzip void skip(istream *input, size_t numChars) { static const size_t bufferSize = 4096; static char buffer[bufferSize]; while (numChars>0) { int toRead=std::min(numChars,bufferSize); input->read(buffer,toRead); numChars-=toRead; } } // ignore primitive attributes, only know about Particle Systems currently bool skipPrimitives(int nPoints, int nPrims, int nPrimAttrib, istream* input,std::ostream* errorStream) { int particleSize=0; vector primAttrOffsets; // offsets in # of 32 bit offsets vector primAttrHandles; vector primAccessors; getAttributes(particleSize, primAttrOffsets, primAttrHandles, primAccessors, nPrimAttrib, input, 0, true, errorStream); for(int i=0;i(*input,primType); if(primType==0x00008000) { int size; read(*input,size); if(nPoints>=(int)1<<16) skip(input,size*sizeof(int)); else skip(input,size*sizeof(unsigned short)); skip(input,particleSize*sizeof(int)); } else { if(errorStream) *errorStream << "Partio: Unrecognized Primitive Type: 0x" << std::hex << primType << " - Cannot process detail attributes" << std::endl; return false; } } return true; } ParticlesDataMutable* readBGEO(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in|ios::binary)); if(!*input){ if(errorStream) *errorStream<<"Partio: Unable to open file "<(*input,magic[0],magic[1],magic[2],magic[3]); read(*input,versionChar,version,nPoints,nPrims,nPointGroups); read(*input,nPrimGroups,nPointAttrib,nVertexAttrib,nPrimAttrib,nAttrib); // Check header magic and version const char bgeo_magic[5]={'B','g','e','o',0}; if(strcmp(magic,bgeo_magic)){ const char new_bgeo_magic[5]={0x7f,0x4e,0x53,0x4a,0}; if(!strcmp(magic,new_bgeo_magic)){ if(errorStream) *errorStream<<"Partio: Attempting to read new BGEO format, we only support old BGEO format. Try writing .bhclassic from Houdini."<addParticles(nPoints); // Read attribute definitions int particleSize=4; // Size in # of 32 bit primitives vector attrOffsets; // offsets in # of 32 bit offsets vector attrHandles; vector accessors; attrOffsets.push_back(0); // pull values from byte offset attrHandles.push_back(simple->addAttribute("position",VECTOR,3)); // we always have one accessors.push_back(ParticleAccessor(attrHandles[0])); getAttributes(particleSize, attrOffsets, attrHandles, accessors, nPointAttrib, input.get(), simple, headersOnly, errorStream); if(headersOnly) { skip(input.get(),nPoints*particleSize*sizeof(int)); } else { // Read the points int *buffer=new int[particleSize]; // make iterator and register accessors ParticlesDataMutable::iterator iterator=simple->begin(); for(size_t i=0;iend();iterator!=end;++iterator){ input->read((char*)buffer,particleSize*sizeof(int)); for(unsigned int attrIndex=0;attrIndex(iterator); for(int k=0;k fixedAttrOffsets; // offsets in # of 32 bit offsets vector fixedAttrHandles; vector fixedAccessors; getAttributes(particleSize, fixedAttrOffsets, fixedAttrHandles, fixedAccessors, nAttrib, input.get(), simple, headersOnly, errorStream); if (headersOnly) return simple; // Read the points int *fixedBuffer=new int[particleSize]; input->read((char*)fixedBuffer,particleSize*sizeof(int)); for(unsigned int attrIndex=0;attrIndexfixedDataWrite(fixedAttrHandles[attrIndex])[k]=fixedBuffer[fixedAttrOffsets[attrIndex]+k]; } } delete [] fixedBuffer; // return the populated simpleParticle return simple; } bool writeBGEO(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) { unique_ptr output( compressed ? Gzip_Out(filename,ios::out|ios::binary) :new ofstream(filename,ios::out|ios::binary)); if(!*output){ if(errorStream) *errorStream <<"Partio Unable to open file "<(*output,magic,versionChar,version,nPoints,nPrims,nPointGroups); write(*output,nPrimGroups,nPointAttrib,nVertexAttrib,nPrimAttrib,nAttrib); vector handles; vector accessors; vector attrOffsets; bool foundPosition=false; int particleSize=4; for(int i=0;i(attr.count); const std::vector& indexTable=p.indexedStrs(attr); int numIndexes=static_cast(indexTable.size()); write(*output,size,houdiniType,numIndexes); for(int i=0;i(attr.count); write(*output,size,houdiniType); for(int i=0;i(*output,defaultValue); } } attrOffsets.push_back(particleSize); particleSize+=attr.count; } handles.push_back(attr); accessors.push_back(ParticleAccessor(handles.back())); } if(!foundPosition){ if(errorStream) *errorStream <<"Partio: didn't find attr 'position' while trying to write GEO"<(iterator); for(int k=0;kwrite((char*)buffer,particleSize*sizeof(int)); } delete [] buffer; vector fixedHandles; vector fixedAttrOffsets; particleSize=0; for(int i=0;i& indexTable=p.fixedIndexedStrs(attr); int numIndexes=indexTable.size(); write(*output,size,houdiniType,numIndexes); for(int ii=0;ii(*output,size,houdiniType); for(int i=0;i(*output,defaultValue); } } fixedAttrOffsets.push_back(particleSize); particleSize+=attr.count; fixedHandles.push_back(attr); } int *fixedBuffer=new int[particleSize]; for(unsigned int attrIndex=0;attrIndex(fixedHandles[attrIndex])[k]; BIGEND::swap(fixedBuffer[fixedAttrOffsets[attrIndex]+k]); } } output->write((char*)fixedBuffer,particleSize*sizeof(int)); delete [] fixedBuffer; // Write extra write(*output,(char)0x00); #ifdef _MSC_VER #pragma warning (push) #pragma warning (disable : 4310 ) // suppress the warning for 0xff being truncated to 0x7f (max value of a signed char) #endif write(*output,(char)0xff); #ifdef _MSC_VER #pragma warning (pop) #endif // success return true; } } ================================================ FILE: Externals/partio/io/BIN.cpp ================================================ /* PARTIO SOFTWARE Copyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. Format Contributed by github user: Jinkuen Some code for this format was helped along by referring to an implementation by Digital Cinema Arts THANKS! Modifications from: github user: redpawfx (redpawFX@gmail.com) and Luma Pictures 2011 */ #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "PartioEndian.h" #include "ZIP.h" #include #include #include #include namespace Partio{ using namespace std; static const long BIN_MAGIC = 0xFABADA; typedef struct{ int verificationCode; char fluidName[250] ; short version; float scaleScene; int fluidType; float elapsedSimulationTime; int frameNumber; int framePerSecond; int numParticles; float radius; float pressure[3]; float speed[3]; float temperature[3]; float emitterPosition[3]; float emitterRotation[3]; float emitterScale[3]; } BIN_HEADER; typedef struct{ int verificationCode; char fluidName[250] ; short version; float scaleScene; int fluidType; float elapsedSimulationTime; int frameNumber; int framePerSecond; int numParticles; float radius; float pressure[3]; float speed[3]; float temperature[3]; } BIN_HEADERV6; ParticlesDataMutable* readBIN(const char* filename, const bool headersOnly,std::ostream* errorStream){ unique_ptr input(new ifstream(filename,ios::in|ios::binary)); if(!*input){ if(errorStream) *errorStream << "Partio: Unable to open file " << filename << endl; return 0; } BIN_HEADER header; input->read((char*)&header, sizeof(BIN_HEADERV6)); // According to the NextLimit bin_particles_file_format.pdf file if (header.version >= 7) { input->read((char*)&header.emitterPosition, sizeof(header.emitterPosition)); input->read((char*)&header.emitterRotation, sizeof(header.emitterRotation)); input->read((char*)&header.emitterScale, sizeof(header.emitterScale)); } // After version 13, we don't know what to do if(header.version > 13){ cerr << "Partio: Unknown .bin version : " << header.version << endl; return 0; } if(BIN_MAGIC != header.verificationCode){ if(errorStream) *errorStream<< "Partio: Magic number '" << hex<< header.verificationCode << "' of '" << filename << "' doesn't match BIN magic '" << BIN_MAGIC << "'" << endl; return 0; } ParticlesDataMutable* simple = headersOnly ? new ParticleHeaders: create(); simple->addParticles(header.numParticles); ParticleAttribute posAttr; posAttr = simple->addAttribute("position", VECTOR, 3); ParticleAttribute veloAttr; veloAttr = simple->addAttribute("velocity", VECTOR, 3); ParticleAttribute forceAttr; forceAttr = simple->addAttribute("force", VECTOR, 3); ParticleAttribute vortAttr; if (header.version >= 9) vortAttr = simple->addAttribute("vorticity", VECTOR, 3); ParticleAttribute normAttr; if (header.version >= 3) normAttr = simple->addAttribute("normal", VECTOR, 3); ParticleAttribute neighborsAttr; if (header.version >= 4) neighborsAttr = simple->addAttribute("neighbors", INT, 1); ParticleAttribute uvwAttr; if (header.version >= 5) uvwAttr = simple->addAttribute("uvw", VECTOR, 3); ParticleAttribute ageAttr; ageAttr = simple->addAttribute("age", FLOAT, 1); ParticleAttribute isoTimeAttr; isoTimeAttr = simple->addAttribute("isolationTime", FLOAT, 1); ParticleAttribute viscosityAttr; viscosityAttr = simple->addAttribute("viscosity", FLOAT, 1); ParticleAttribute densityAttr; densityAttr = simple->addAttribute("density", FLOAT, 1); ParticleAttribute pressureAttr; pressureAttr = simple->addAttribute("pressure", FLOAT, 1); ParticleAttribute massAttr; massAttr = simple->addAttribute("mass", FLOAT, 1); ParticleAttribute tempAttr; tempAttr = simple->addAttribute("temperature", FLOAT, 1); ParticleAttribute pidAttr; pidAttr = simple->addAttribute("id", INT, 1); if (!headersOnly) { for(int partIndex = 0; partIndex < simple->numParticles(); partIndex++) { float position[3] = {0.0,0.0,0.0}; float velocity[3] = {0.0,0.0,0.0}; float force[3] = {0.0,0.0,0.0}; float vorticity[3] = {0.0,0.0,0.0}; float normal[3] = {0.0,0.0,0.0}; int neighbors = 0; float uvw[3] = {0.0,0.0,0.0}; short infoBits = 7; float age = 0.0; float isolationTime = 1.0; float viscosity = 1.0; float density = 1.0; float pressure = 1.0; float mass = 1.0; float temperature = 1.0; int pid = 0; input->read ((char *) &position[0], sizeof(float)); simple->dataWrite(posAttr, partIndex)[0] = (float)position[0]; input->read ((char *) &position[1], sizeof(float)); simple->dataWrite(posAttr, partIndex)[1] = (float)position[1]; input->read ((char *) &position[2], sizeof(float)); simple->dataWrite(posAttr, partIndex)[2] = (float)position[2]; input->read ((char *) &velocity[0], sizeof(float)); simple->dataWrite(veloAttr, partIndex)[0] = (float)velocity[0]; input->read ((char *) &velocity[1], sizeof(float)); simple->dataWrite(veloAttr, partIndex)[1] = (float)velocity[1]; input->read ((char *) &velocity[2], sizeof(float)); simple->dataWrite(veloAttr, partIndex)[2] = (float)velocity[2]; input->read ((char *) &force[0], sizeof(float)); simple->dataWrite(forceAttr, partIndex)[0] = (float)force[0]; input->read ((char *) &force[1], sizeof(float)); simple->dataWrite(forceAttr, partIndex)[1] = (float)force[1]; input->read ((char *) &force[2], sizeof(float)); simple->dataWrite(forceAttr, partIndex)[2] = (float)force[2]; if (header.version >= 9) { input->read ((char *) &vorticity[0], sizeof(float)); simple->dataWrite(vortAttr, partIndex)[0] = (float)vorticity[0]; input->read ((char *) &vorticity[1], sizeof(float)); simple->dataWrite(vortAttr, partIndex)[1] = (float)vorticity[1]; input->read ((char *) &vorticity[2], sizeof(float)); simple->dataWrite(vortAttr, partIndex)[2] = (float)vorticity[2]; } if (header.version >= 3) { input->read ((char *) &normal[0], sizeof(float)); simple->dataWrite(normAttr, partIndex)[0] = (float)normal[0]; input->read ((char *) &normal[1], sizeof(float)); simple->dataWrite(normAttr, partIndex)[1] = (float)normal[1]; input->read ((char *) &normal[2], sizeof(float)); simple->dataWrite(normAttr, partIndex)[2] = (float)normal[2]; } if (header.version >= 4) { input->read ((char *) &neighbors, sizeof (int)); simple->dataWrite(neighborsAttr, partIndex)[0] = (int)neighbors; } if (header.version >= 5) { input->read ((char *) &uvw[0], sizeof(float)); simple->dataWrite(uvwAttr, partIndex)[0] = (float)uvw[0]; input->read ((char *) &uvw[1], sizeof(float)); simple->dataWrite(uvwAttr, partIndex)[1] = (float)uvw[1]; input->read ((char *) &uvw[2], sizeof(float)); simple->dataWrite(uvwAttr, partIndex)[2] = (float)uvw[2]; input->read ((char *) &infoBits, sizeof(infoBits)); } // don't do anything with this.. input->read ((char *) &age, sizeof(age)); simple->dataWrite(ageAttr, partIndex)[0] = (float)age; input->read ((char *) &isolationTime, sizeof(isolationTime)); simple->dataWrite(isoTimeAttr, partIndex)[0] = (float)isolationTime; input->read ((char *) &viscosity, sizeof(viscosity)); simple->dataWrite(viscosityAttr, partIndex)[0] = (float)viscosity; input->read ((char *) &density, sizeof(density)); simple->dataWrite(densityAttr, partIndex)[0] = (float)density; input->read ((char *) &pressure, sizeof(pressure)); simple->dataWrite(pressureAttr, partIndex)[0] = (float)pressure; input->read ((char *) &mass, sizeof(mass)); simple->dataWrite(massAttr, partIndex)[0] = (float)mass; input->read ((char *) &temperature, sizeof(temperature)); simple->dataWrite(tempAttr, partIndex)[0] = (float)temperature; // pid if (header.version < 12) input->read ((char *) &pid, sizeof(pid)); else { // Warning, cast the id on 32 bits here uint64_t pid64; input->read ((char*) &pid64, sizeof(pid64)); pid = (int)pid64; } simple->dataWrite(pidAttr, partIndex)[0] = (int)pid; } } return simple; } bool writeBIN(const char* filename,const ParticlesData& p,const bool /*compressed*/,std::ostream* errorStream) { unique_ptr output( new ofstream(filename,ios::out|ios::binary)); if (!*output) { if(errorStream) *errorStream<<"Partio Unable to open file "<write ((const char *) &header.verificationCode, sizeof (int)); output->write ((const char *) &header.fluidName, 250); output->write ((const char *) &header.version, sizeof (short int)); output->write ((const char *) &header.scaleScene, sizeof (float)); output->write ((const char *) &header.fluidType, sizeof (int)); output->write ((const char *) &header.elapsedSimulationTime, sizeof (float)); output->write ((const char *) &header.frameNumber, sizeof (int)); output->write ((const char *) &header.framePerSecond, sizeof (int)); output->write ((const char *) &header.numParticles, sizeof (int)); output->write ((const char *) &header.radius, sizeof (float)); for(int i=0; i <=2; i++) output->write ((const char *) &header.pressure[i], sizeof(float)); for(int i=0; i<= 2; i++) output->write ((const char *) &header.speed[i], sizeof(float)); for(int i=0; i<= 2; i++) output->write ((const char *) &header.temperature[i], sizeof(float)); for(int i=0; i<= 2; i++) output->write ((const char *) &header.emitterPosition[i], sizeof(float)); for(int i=0; i <= 2; i++) output->write ((const char *) &header.emitterRotation[i], sizeof(float)); for(int i=0; i <= 2; i++) output->write ((const char *) &header.emitterScale[i], sizeof(float)); for (int particles = 0; particles < p.numParticles(); particles++) { // set defaults for stuff that is not exported... float position[3] = {0.0,0.0,0.0}; float velocity[3] = {0.0,0.0,0.0}; float force[3] = {0.0,0.0,0.0}; float vorticity[3] = {0.0,0.0,0.0}; float normal[3] = {0.0,0.0,0.0}; int neighbors = 0; float uvw[3] = {0.0,0.0,0.0}; short infoBits = 7; float age = 0.0; float isolationTime = 1.0; float viscosity = 1.0; float density = 1.0; float pressure = 1.0; float mass = 1.0; float temperature = 1.0; int pid = particles; // now run thru the exported attrs and replace values for things that we do have for(int attrIndex = 0; attrIndex < p.numAttributes(); attrIndex++) { ParticleAttribute attr; p.attributeInfo(attrIndex,attr); //cout << attr.name << endl; if (attr.name == "position") { const float* data = p.data(attr, particles); position[0] = data[0]; position[1] = data[1]; position[2] = data[2]; } else if (attr.name == "velocity") { const float* data = p.data(attr, particles); velocity[0] = data[0]; velocity[1] = data[1]; velocity[2] = data[2]; } else if (attr.name == "force") { const float* data = p.data(attr, particles); force[0] = data[0]; force[1] = data[1]; force[2] = data[2]; } else if (attr.name == "vorticity") { const float* data = p.data(attr, particles); vorticity[0] = data[0]; vorticity[1] = data[1]; vorticity[2] = data[2]; } else if (attr.name == "normal") { const float* data = p.data(attr, particles); normal[0] = data[0]; normal[1] = data[1]; normal[2] = data[2]; } else if (attr.name == "neighbors") { const int* data = p.data(attr, particles); neighbors= data[0]; } else if (attr.name == "uvw") { const float* data = p.data(attr, particles); uvw[0] = data[0]; uvw[1] = data[1]; uvw[2] = data[2]; } else if (attr.name == "age") { const float* data = p.data(attr, particles); age= data[0]; } else if (attr.name == "isolationTime") { const float* data = p.data(attr, particles); isolationTime= data[0]; } else if (attr.name == "viscosity") { const float* data = p.data(attr, particles); viscosity= data[0]; } else if (attr.name == "density") { const float* data = p.data(attr, particles); density= data[0]; } else if (attr.name == "pressure") { const float* data = p.data(attr, particles); pressure= data[0]; } else if (attr.name == "mass") { const float* data = p.data(attr, particles); mass= data[0]; } else if (attr.name == "temperature") { const float* data = p.data(attr, particles); temperature= data[0]; } else if (attr.name == "id") { const int* data = p.data(attr, particles); pid= data[0]; } else { cout << "Attribute found that we don't support yet" << endl; } } output->write ((const char *) &position[0], sizeof (float)); output->write ((const char *) &position[1], sizeof (float)); output->write ((const char *) &position[2], sizeof (float)); output->write ((const char *) &velocity[0], sizeof (float)); output->write ((const char *) &velocity[1], sizeof (float)); output->write ((const char *) &velocity[2], sizeof (float)); output->write ((const char *) &force[0], sizeof (float)); output->write ((const char *) &force[1], sizeof (float)); output->write ((const char *) &force[2], sizeof (float)); output->write ((const char *) &vorticity[0], sizeof (float)); output->write ((const char *) &vorticity[1], sizeof (float)); output->write ((const char *) &vorticity[2], sizeof (float)); output->write ((const char *) &normal[0], sizeof (float)); output->write ((const char *) &normal[1], sizeof (float)); output->write ((const char *) &normal[2], sizeof (float)); output->write ((const char *) &neighbors, sizeof (neighbors)); output->write ((const char *) &uvw[0], sizeof (float)); output->write ((const char *) &uvw[1], sizeof (float)); output->write ((const char *) &uvw[2], sizeof (float)); output->write ((const char *) &infoBits, sizeof (infoBits)); output->write ((const char *) &age, sizeof (age)); output->write ((const char *) &isolationTime, sizeof (isolationTime)); output->write ((const char *) &viscosity, sizeof (viscosity)); output->write ((const char *) &density, sizeof (density)); output->write ((const char *) &pressure, sizeof (pressure)); output->write ((const char *) &mass, sizeof (mass)); output->write ((const char *) &temperature, sizeof (temperature)); output->write ((const char *) &pid, sizeof (pid)); } // per the file format spec, we have to atleast write out the fact that we don't support per-particle data and additional real flow internal data int zero = 0; output->write((const char*)&zero, sizeof(int)); // no per particle data output->write((const char*)&zero, sizeof(char)); // no RF 4 data (just 1 byte of 0) output->write((const char*)&zero, sizeof(char)); // no RF 5 data (just 1 byte of 0) return true; } }// end of namespace Partio ================================================ FILE: Externals/partio/io/GEO.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "ZIP.h" #include #include #include #include #include namespace Partio { using namespace std; template void readGeoAttr(istream& f,const ParticleAttribute& attr,ParticleAccessor& accessor,ParticlesDataMutable::iterator& iterator) { //cout<<"reading "<::TYPE TYPE; TYPE* data=accessor.raw(iterator); for(int k=0;k>data[k]; } } void writeString(std::ostream& output,const char* s){ const char* p=s; output<<"\""; while(*p != 0){ if(*p=='\\' || *p=='"') output<<'\\'; output<<*p; p++; } output<<"\""; } string scanString(istream& input) { // TODO: this code does not check for buf overrun // TODO: this code doesn't properly check for FEOF condition char buf[4096]; char *ptr=buf; char c; while(input.good()){ input.get(c); if(!isspace(c)) break; } if(!input.good()) return ""; if(c!='"'){ while(input.good()){ *ptr++=c; input.get(c); if(isspace(c)) break; } }else{ while(input.good()){ input.get(c); if(c=='\\'){ input.get(c); *ptr++=c; }else if(c=='"'){ break; }else{ *ptr++=c; } } } *ptr++=0; return string(buf); } ParticlesDataMutable* readGEO(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in)); if(!*input){ if(errorStream) *errorStream<<"Partio: Can't open particle data file: "<good()){ *input>>word; if(word=="NPoints") *input>>NPoints; else if(word=="NPointAttrib"){*input>>NPointAttrib;break;} } // skip until PointAttrib while(input->good()){ *input>>word; if(word=="PointAttrib") break; } // read attribute descriptions int attrInfoRead = 0; ParticleAttribute positionAttr=simple->addAttribute("position",VECTOR,3); ParticleAccessor positionAccessor(positionAttr); vector attrs; vector accessors; while (input->good() && attrInfoRead < NPointAttrib) { string attrName, attrType; int nvals = 0; *input >> attrName >> nvals >> attrType; if(attrType=="index"){ if(errorStream) *errorStream<<"Partio: attr '"<>nIndices; ParticleAttribute attribute=simple->addAttribute(attrName.c_str(),INDEXEDSTR,1); attrs.push_back(attribute); for(int j=0;j>indexName; indexName=scanString(*input); if (!headersOnly) { int id=simple->registerIndexedStr(attribute,indexName.c_str()); if(id != j){ if(errorStream) *errorStream<<"Partio: error on read, expected registerIndexStr to return index "<>defval; } ParticleAttributeType type; // TODO: fix for other attribute types if(attrType=="float") type=FLOAT; else if(attrType=="vector") type=VECTOR; else if(attrType=="int") type=INT; else{ if(errorStream) *errorStream<<"Partio: unknown attribute "<addAttribute(attrName.c_str(),type,nvals)); accessors.push_back(ParticleAccessor(attrs.back())); attrInfoRead++; } } simple->addParticles(NPoints); ParticlesDataMutable::iterator iterator=simple->begin(); iterator.addAccessor(positionAccessor); for(size_t i=0;iend();iterator!=end && input->good();++iterator){ float* posInternal=positionAccessor.raw(iterator); for(int i=0;i<3;i++) *input>>posInternal[i]; *input>>fval; //cout<<"saw "<> paren; if (paren != '(') break; // read additional attribute values for (unsigned int i=0;i(*input,attrs[i],accessors[i],iterator);break; case VECTOR: readGeoAttr(*input,attrs[i],accessors[i],iterator);break; case INT: readGeoAttr(*input,attrs[i],accessors[i],iterator);break; case INDEXEDSTR: readGeoAttr(*input,attrs[i],accessors[i],iterator);break; } } // skip closing parenthes *input >> paren; if (paren != ')') break; } return simple; } template void writeType(ostream& output,const ParticlesData&,const ParticleAttribute& attrib, const ParticleAccessor& accessor,const ParticlesData::const_iterator& iterator) { const T* data=accessor.raw(iterator); for(int i=0;i0) output<<" "; output< output( compressed ? Gzip_Out(filename,ios::out) :new ofstream(filename,ios::out)); *output<<"PGEOMETRY V5"<0) *output<<"PointAttrib"< handles; vector accessors; for(int i=0;i& indexes=p.indexedStrs(attrib); *output<& point=positionAccessor.data >(iterator); *output<0) *output<<"\t"; ParticleAttribute& handle=handles[aindex]; ParticleAccessor& accessor=accessors[aindex]; switch(handle.type){ case NONE: assert(false);break; case FLOAT: writeType::TYPE>(*output,p,handle,accessor,iterator);break; case INT: writeType::TYPE>(*output,p,handle,accessor,iterator);break; case VECTOR: writeType::TYPE>(*output,p,handle,accessor,iterator);break; case INDEXEDSTR: writeType::TYPE>(*output,p,handle,accessor,iterator);break; } } if(handles.size()) *output<<")"; *output< #include #include #include #include namespace Partio { //#define PartioBIG_ENDIAN using namespace std; // TODO: convert this to use iterators like the rest of the readers/writers std::string GetString(std::istream& input, unsigned int size){ char* tmp = new char [size]; input.read(tmp, size); std::string result(tmp); // fix read tag error (ex: DBLA --> DBLAi, why !!) if(result.size() > size){ result.resize(size); } delete [] tmp; return result; } typedef struct{ std::string name; std::string type; unsigned int numParticles; unsigned int blocksize; } Attribute_Header; bool ReadAttrHeader(std::istream& input, Attribute_Header& attribute){ char tag[4]; input.read(tag, 4); // CHNM int chnmSize; read(input, chnmSize); if(chnmSize%4 > 0){ chnmSize = chnmSize - chnmSize%4 + 4; } attribute.name = GetString(input, chnmSize); attribute.name = attribute.name.substr(attribute.name.find_first_of("_")+1); input.read(tag, 4); // SIZE int dummy; read(input, dummy); // 4 read(input, attribute.numParticles); attribute.type = GetString(input, 4); read(input, attribute.blocksize); return true; } int CharArrayLen(char** charArray){ int i = 0; if(charArray != NULL){ while(charArray[i] != NULL){ i++; } } return i; } bool IsStringInCharArray(std::string target, char** list){ //std::cout << "Is " << target << " in "; for(int i = 0; i < CharArrayLen(list); i++){ //std::cout << std::string(list[i]) << " "; if(target == std::string(list[i])){ //std::cout << "? (YES)" << std::endl; return true; } } //std::cout << "? (NO)" << std::endl; return false; } static const int MC_MAGIC = ((((('F'<<8)|'O')<<8)|'R')<<8)|'4'; static const int HEADER_SIZE = 56; ParticlesDataMutable* readMC(const char* filename, const bool headersOnly,std::ostream* errorStream){ std::unique_ptr input(Gzip_In(filename,std::ios::in|std::ios::binary)); if(!*input){ if(errorStream) *errorStream << "Partio: Unable to open file " << filename << std::endl; return 0; } int magic; read(*input, magic); if(MC_MAGIC != magic){ if(errorStream) *errorStream << "Partio: Magic number '" << magic << "' of '" << filename << "' doesn't match mc magic '" << MC_MAGIC << "'" << std::endl; return 0; } int headerSize; read(*input, headerSize); int dummy; // tmp1, tmp2, num1, tmp3, tmp4, num2, num3, tmp5, num4, num5, blockTag for(int i = 0; i < 10; i++){ read(*input, dummy); //std::cout << dummy << std::endl; } char tag[4]; input->read(tag, 4); // FOR4 int blockSize; read(*input, blockSize); // Allocate a simple particle with the appropriate number of points ParticlesDataMutable* simple=0; if(headersOnly){ simple = new ParticleHeaders; } else{ simple=create(); } int numParticles = 0; input->read(tag, 4); // MYCH while(((int)input->tellg()-HEADER_SIZE) < blockSize){ Attribute_Header attrHeader; ReadAttrHeader(*input, attrHeader); if(attrHeader.name == std::string("id")){ numParticles = attrHeader.numParticles; } if(attrHeader.blocksize/sizeof(double) == 1){ // for who ? input->seekg((int)input->tellg() + attrHeader.blocksize); continue; } #if 0 // TODO: if we ever put back attributes re-enable this if(attributes && (IsStringInCharArray(attrHeader.name, attributes)==false)){ input->seekg((int)input->tellg() + attrHeader.blocksize); continue; } #endif if(attrHeader.type == std::string("FVCA")){ input->seekg((int)input->tellg() + attrHeader.blocksize); simple->addAttribute(attrHeader.name.c_str(), VECTOR, 3); } else if(attrHeader.type == std::string("DBLA")){ input->seekg((int)input->tellg() + attrHeader.blocksize); if(attrHeader.name == "id"){ simple->addAttribute(attrHeader.name.c_str(), INT, 1); } else{ simple->addAttribute(attrHeader.name.c_str(), FLOAT, 1); } } else { input->seekg((int)input->tellg() + attrHeader.blocksize); if(errorStream) *errorStream << "Partio: Attribute '" << attrHeader.name << " " << attrHeader.type << "' cannot map type" << std::endl; } } simple->addParticles(numParticles); // If all we care about is headers, then return.-- if(headersOnly){ return simple; } //cout << "==============================================================" << endl; input->seekg(HEADER_SIZE); input->read(tag, 4); // MYCH while((int)input->tellg()-HEADER_SIZE < blockSize){ Attribute_Header attrHeader; ReadAttrHeader(*input, attrHeader); if(attrHeader.blocksize/sizeof(double) == 1){ // for who ? input->seekg((int)input->tellg() + attrHeader.blocksize); continue; } ParticleAttribute attrHandle; if(simple->attributeInfo(attrHeader.name.c_str(), attrHandle) == false){ input->seekg((int)input->tellg() + attrHeader.blocksize); continue; } Partio::ParticlesDataMutable::iterator it = simple->begin(); Partio::ParticleAccessor accessor(attrHandle); it.addAccessor(accessor); //std::cout << attrHeader.name << std::endl; if (attrHeader.type == std::string("DBLA")){ if (attrHeader.name == "id") { for (int i = 0; i < simple->numParticles(); i++) { double tmp; read(*input, tmp); int* data = simple->dataWrite(attrHandle, i); data[0] = (int)tmp; } } else{ for (int i = 0; i < simple->numParticles(); i++){ double tmp; read(*input, tmp); float* data = simple->dataWrite(attrHandle, i); data[0] = (float)tmp; } } } else if(attrHeader.type == std::string("FVCA")){ for(Partio::ParticlesDataMutable::iterator end = simple->end(); it != end; ++it){ input->read(accessor.raw(it), sizeof(float)*attrHandle.count); } it = simple->begin(); for(Partio::ParticlesDataMutable::iterator end = simple->end(); it != end; ++it){ float* data = accessor.raw(it); for(int i = 0; i < attrHandle.count; i++){ BIGEND::swap(data[i]); //data[k]=buffer[attrOffsets[attrIndex]+k]; //data[i] = endianSwap(data[i]); } } } /* if(0){ std::cout << typeName << std::endl; std::cerr << "Partio: " << filename << " had unknown attribute spec " << typeName << " " << name << std::endl; simple->release(); return 0; }*/ } return simple; } /* bool dgMc::open(string filePath){ timeval t1, t2; ReadStr(file, 4); // MYCH while(((int)file.tellg()-8-40-8) < header.blockSize){ ReadStr(file, 4); // CHNM int chnmSize = ReadInt(file); if(chnmSize%4 > 0){ chnmSize = chnmSize - chnmSize%4 + 4; } string attrname = ReadChar(file, chnmSize); attrname = attrname.substr(attrname.find_first_of("_")+1); //cout << attrname << endl; ReadStr(file, 4); // SIZE ReadInt(file); int arrayLength = ReadInt(file); string format = ReadStr(file, 4); // DBLA or FVCA int bufferLength = ReadInt(file); string DBLA("DBLA"); //cout << format << " " << arrayLength << " " << bufferLength << endl; if(format == string("DBLA")){ ReadDoubleArray(file, (int)file.tellg(), &_doubleArray[attrname], arrayLength); //file.seekg((int)file.tellg() + bufferLength); } else{ // FVCA ReadVectorArray(file, (int)file.tellg(), &_vectorArray[attrname], arrayLength); if(attrname == string("position")){ //ReadVectorArray(file, (int)file.tellg(), &_vectorArray[attrname], arrayLength); //file.seekg((int)file.tellg() + bufferLength); } else{ //file.seekg((int)file.tellg() + bufferLength); } //return true; } if(attrname == string("id")){ _numParticles = arrayLength; } } return true; } int main(){ cout << "go" << endl; timeval t1, t2; double elapsedTime; gettimeofday(&t1, NULL); for(int i = 0; i < 1; i++){ dgMc mc; mc.open(string("/dept/rdworks/jinkuen/testfile/mc/real_nParticleShape1Frame47.mc")); cout << mc.numParticles() << " "; for(int i = 0; i < mc.count(); i++){ cout << mc.list(dgParticle::All)[i] << " "; } mc.clear(); } cout << endl; gettimeofday(&t2, NULL); elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0; // sec to ms elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0; // us to ms cout << elapsedTime << " ms.\n"; return 1; } */ } ================================================ FILE: Externals/partio/io/PDA.cpp ================================================ /* PARTIO SOFTWARE Copyright 2011 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "ZIP.h" #include #include #include #include #include namespace Partio { using namespace std; // TODO: convert this to use iterators like the rest of the readers/writers ParticlesDataMutable* readPDA(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in|ios::binary)); if(!*input){ if(errorStream) *errorStream <<"Partio: Can't open particle data file: "<good()){ *input>>word; if(word!="ATTRIBUTES"){simple->release();return 0;} } vector attrNames; vector attrs; while(input->good()){ *input>>word; if(word=="TYPES") break;; attrNames.push_back(word); } size_t index=0; while(input->good()){ *input>>word; if(word=="NUMBER_OF_PARTICLES:") break; if(index>=attrNames.size()) continue; if(word=="V"){ attrs.push_back(simple->addAttribute(attrNames[index].c_str(),Partio::VECTOR,3)); }else if(word=="R"){ attrs.push_back(simple->addAttribute(attrNames[index].c_str(),Partio::FLOAT,1)); }else if(word=="I"){ attrs.push_back(simple->addAttribute(attrNames[index].c_str(),Partio::INT,1)); } index++; } unsigned int num=0; if(input->good()){ *input>>num; simple->addParticles(num); if(headersOnly) return simple; // escape before we try to touch data }else{ simple->release(); return 0; } // look for beginning of header if(input->good()){ *input>>word; if(word != "BEGIN"){simple->release();return 0;} } if(input->good()){ *input>>word; if(word != "DATA"){simple->release();return 0;} } // Read actual particle data if(!input->good()){simple->release();return 0;} for(unsigned int particleIndex=0;input->good() && particleIndexdataWrite(attrs[attrIndex],particleIndex); for(int count=0;count>ival; data[count]=ival; } }else if(attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR){ float* data=simple->dataWrite(attrs[attrIndex],particleIndex); for(int count=0;count>fval; data[count]=fval; } } } } return simple; } bool writePDA(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) { unique_ptr output( compressed ? Gzip_Out(filename,ios::out|ios::binary) :new ofstream(filename,ios::out|ios::binary)); *output<<"ATTRIBUTES"< attrs; for (int aIndex=0;aIndex(attrs[attrIndex],particleIndex); for(int count=0;count(attrs[attrIndex],particleIndex); for(int count=0;count #include #include #include #include #include #include namespace Partio { using namespace std; template struct PDB_POLICY; template<> struct PDB_POLICY<32> { typedef PDB::PDB_Header32 HEADER; typedef PDB::PDBdata32 DATA; typedef PDB::Channel32 CHANNEL; typedef PDB::Channel_Data32 CHANNEL_DATA; typedef PDB::Channel_io_Header CHANNEL_IO; }; template<> struct PDB_POLICY<64> { typedef PDB::PDB_Header HEADER; typedef PDB::PDBdata DATA; typedef PDB::Channel CHANNEL; typedef PDB::Channel_Data CHANNEL_DATA; typedef PDB::Channel_io_Header CHANNEL_IO; }; string GetString(istream& input,bool& error) { const char terminator='\0'; // TODO: make this check for FEOF condition! and also more efficient char c=' '; string s=""; error=true; while (input) { input.read(&c,sizeof(char)); if(c == terminator){error=false;break;} s += c; } return s; } template ParticlesDataMutable* readPDBHelper(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in|ios::binary)); if(!*input){ if(errorStream) *errorStream<<"Partio: Unable to open file "<::HEADER header; input->read((char*)&header,sizeof(typename PDB_POLICY::HEADER)); if(header.magic != PDB_MAGIC){ if(errorStream) *errorStream<<"Partio: failed to get PDB magic"<addParticles(header.data_size); for(unsigned int i=0;i::CHANNEL_IO channelIOHeader; input->read((char*)&channelIOHeader,sizeof(channelIOHeader)); typename PDB_POLICY::CHANNEL channelHeader; input->read((char*)&channelHeader,sizeof(channelHeader)); bool error; string name=GetString(*input,error); if(error){ simple->release(); return 0; } typename PDB_POLICY::CHANNEL_DATA channelData; input->read((char*)&channelData,sizeof(channelData)); ParticleAttributeType type; switch(channelHeader.type){ case PDB_VECTOR: type=VECTOR;break; case PDB_REAL: type=FLOAT;break; case PDB_LONG: type=INT;break; default: type=NONE;break; } int size=header.data_size*channelData.datasize; // Read data or skip if we haven't found appropriate type handle if(type==NONE){ char buf[1024]; int toSkip=size; while(toSkip>0){ input->read(buf,min(toSkip,1024)); toSkip-=1024; } if(errorStream) *errorStream<<"Partio: Attribute '"<addAttribute(name.c_str(),type,count); if(headersOnly){ char buf[1024]; int toSkip=size; while(toSkip>0){ input->read(buf,min(toSkip,1024)); toSkip-=1024; } }else{ Partio::ParticlesDataMutable::iterator it=simple->begin(); Partio::ParticleAccessor accessor(attrHandle); it.addAccessor(accessor); for(Partio::ParticlesDataMutable::iterator end=simple->end();it!=end;++it){ input->read(accessor.raw(it),sizeof(float)*attrHandle.count); } } } } return simple; } template bool writePDBHelper(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) { unique_ptr output( compressed ? Gzip_Out(filename,ios::out|ios::binary) :new ofstream(filename,ios::out|ios::binary)); if(!*output){ if(errorStream) *errorStream<<"Partio Unable to open file "<::HEADER h32; memset(&h32,0,sizeof(typename PDB_POLICY::HEADER)); h32.magic=PDB_MAGIC; h32.swap=1; h32.version=1.0; h32.time=0.0; h32.data_size=p.numParticles(); h32.num_data=p.numAttributes(); for(int k=0;k<32;k++) h32.padding[k]=0; h32.data=0; output->write((char*)&h32,sizeof(typename PDB_POLICY::HEADER)); for(int attrIndex=0;attrIndex::CHANNEL_IO cio; typename PDB_POLICY::CHANNEL channel; typename PDB_POLICY::CHANNEL_DATA data_header; memset(&cio,0,sizeof(typename PDB_POLICY::CHANNEL_IO)); memset(&channel,0,sizeof(typename PDB_POLICY::CHANNEL)); memset(&data_header,0,sizeof(typename PDB_POLICY::CHANNEL_DATA)); cio.magic=0; cio.swap=1; cio.encoding=0; cio.type=0; output->write((char*)&cio,sizeof(typename PDB_POLICY::CHANNEL_IO)); // TODO: assert cproper count! channel.name=0; switch(attr.type){ case INDEXEDSTR:channel.type=PDB_LONG;break; case INT:channel.type=PDB_LONG;break; case FLOAT:channel.type=PDB_REAL;break; case VECTOR:channel.type=PDB_VECTOR;break; default: assert(false); } channel.size=0; channel.active_start=0; channel.active_end=h32.data_size-1; channel.hide=0; channel.disconnect=0; channel.data=0; channel.link=0; channel.next=0; output->write((char*)&channel,sizeof(channel)); output->write(attr.name.c_str(),attr.name.length()*sizeof(char)+1); data_header.type=channel.type; data_header.datasize=attr.count*sizeof(float); data_header.blocksize=p.numParticles(); data_header.num_blocks=1; data_header.block=0; output->write((char*)&data_header,sizeof(data_header)); Partio::ParticlesData::const_iterator it=p.begin(); Partio::ParticleAccessor accessor(attr); it.addAccessor(accessor); for(Partio::ParticlesData::const_iterator end=p.end();it!=end;++it){ output->write(accessor.raw(it),sizeof(float)*attr.count); } } return true; } ParticlesDataMutable* readPDB32(const char* filename,const bool headersOnly,std::ostream* errorStream) {return readPDBHelper<32>(filename,headersOnly,errorStream);} ParticlesDataMutable* readPDB64(const char* filename,const bool headersOnly,std::ostream* errorStream) {return readPDBHelper<64>(filename,headersOnly,errorStream);} bool writePDB32(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) {return writePDBHelper<32>(filename,p,compressed,errorStream);} bool writePDB64(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) {return writePDBHelper<64>(filename,p,compressed,errorStream);} ParticlesDataMutable* readPDB(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in|ios::binary)); if(!*input){ if(errorStream) *errorStream <<"Partio: Unable to open file "<::HEADER header; input->read((char*)&header,sizeof(header)); if(header.magic != PDB_MAGIC){ if(errorStream) *errorStream <<"Partio: failed to get PDB magic"<::CHANNEL_IO channelIOHeader; input->read((char*)&channelIOHeader,sizeof(channelIOHeader)); //cout<<"we got channel io as "< 5 || channelIOHeader.type < 0 || (channelIOHeader.swap != 1 && channelIOHeader.swap != 0)){ return readPDBHelper<32>(filename,headersOnly,errorStream); }else{ return readPDBHelper<64>(filename,headersOnly,errorStream); } } bool writePDB(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) {return writePDBHelper<32>(filename,p,compressed,errorStream);} } ================================================ FILE: Externals/partio/io/PDC.cpp ================================================ /* PARTIO SOFTWARE Copyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved keypress events also added the PTS file format (all need cleanup) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. Format Contributed by github user: Jinkuen Modifications from: github user: redpawfx (redpawFX@gmail.com) and Luma Pictures 2011 */ #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "PartioEndian.h" #include "ZIP.h" #include #include #include #include namespace Partio{ using namespace std; static const int PDC_MAGIC = (((((' '<<8)|'C')<<8)|'D')<<8)|'P'; // " CDP" typedef struct{ int magic; int version; int bitorder; int tmp1; int tmp2; int numParticles; int numAttrs; } PDC_HEADER; string readName(istream& input){ int nameLen = 0; read(input, nameLen); char* name = new char[nameLen]; input.read(name, nameLen); string result(name, name+nameLen); delete [] name; return result; } ParticlesDataMutable* readPDC(const char* filename, const bool headersOnly,std::ostream* errorStream){ unique_ptr input(Gzip_In(filename,std::ios::in|std::ios::binary)); if(!*input){ if(errorStream) *errorStream << "Partio: Unable to open file " << filename << std::endl; return 0; } PDC_HEADER header; input->read((char*)&header, sizeof(header)); if(PDC_MAGIC != header.magic){ if(errorStream) *errorStream << "Partio: Magic number '" << header.magic << "' of '" << filename << "' doesn't match pdc magic '" << PDC_MAGIC << "'" << std::endl; return 0; } BIGEND::swap(header.numParticles); BIGEND::swap(header.numAttrs); ParticlesDataMutable* simple = headersOnly ? new ParticleHeaders: create(); simple->addParticles(header.numParticles); for(int attrIndex = 0; attrIndex < header.numAttrs; attrIndex++){ // add attribute ParticleAttribute attr; string attrName = readName(*input); int type; read(*input, type); if(type == 3){ attr = simple->addAttribute(attrName.c_str(), FLOAT, 1); } else if(type == 5){ attr = simple->addAttribute(attrName.c_str(), VECTOR, 3); } // if headersOnly, skip if(headersOnly){ input->seekg((int)input->tellg() + header.numParticles*sizeof(double)*attr.count); continue; } else{ double tmp[3]; for(int partIndex = 0; partIndex < simple->numParticles(); partIndex++){ for(int dim = 0; dim < attr.count; dim++){ read(*input, tmp[dim]); simple->dataWrite(attr, partIndex)[dim] = (float)tmp[dim]; } } } } return simple; } bool writePDC(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream){ unique_ptr output( compressed ? Gzip_Out(filename,ios::out|ios::binary) :new std::ofstream(filename,ios::out|ios::binary)); if(!*output){ if(errorStream) *errorStream << "Partio Unable to open file " << filename << endl; return false; } // write .pdc header write(*output, PDC_MAGIC); write(*output, (int)1); // version write(*output, (int)1); // bitorder write(*output, (int)0); // tmp1 write(*output, (int)0); // tmp2 write(*output, (int)p.numParticles()); write(*output, (int)p.numAttributes()); for(int attrIndex = 0; attrIndex < p.numAttributes(); attrIndex++){ ParticleAttribute attr; p.attributeInfo(attrIndex,attr); // write attribute name write(*output, (int)attr.name.length()); output->write(attr.name.c_str(), (int)attr.name.length()); // write type int count = 1; // FLOAT if(attr.type == VECTOR){ count = 3; } write(*output, (int)(count+2)); // write data for(int partIndex = 0; partIndex < p.numParticles(); partIndex++){ const float* data = p.data(attr, partIndex); for(int dim = 0; dim < count; dim++){ write(*output, (double)data[dim]); } } } return true; } }// end of namespace Partio ================================================ FILE: Externals/partio/io/PRT.cppbak ================================================ /* PARTIO SOFTWARE Copyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. Format Contributed by github user: K240 Some Code for this format was helped along by referring to an implementation by Bo Schwartzstein and ThinkBox Software THANKS! Modifications from: github user: redpawfx (redpawFX@gmail.com) and Luma Pictures 2011 */ #ifndef PARTIO_WIN32 #ifdef PARTIO_USE_ZLIB #include "../Partio.h" #include "PartioEndian.h" #include "../core/ParticleHeaders.h" #include //#define USE_ILMHALF // use Ilm's Half library #define AUTO_CASES // auto upcase ie:position => Position #ifdef USE_ILMHALF #include #endif #include #include #include #include #include #endif namespace Partio{ #define OUT_BUFSIZE (4096) typedef struct FileHeadder { unsigned char magic[8]; unsigned int headersize; unsigned char signature[32]; unsigned int version; unsigned long long numParticles; } PRT_File_Headder; typedef struct Channel { unsigned char name[32]; unsigned int type; unsigned int arity; unsigned int offset; } Channel; static unsigned char magic[8] = {192, 'P', 'R', 'T', '\r', '\n', 26, '\n'}; static unsigned char signature[32] = { 0x45,0x78,0x74,0x65,0x6e,0x73,0x69,0x62,0x6c,0x65,0x20,0x50,0x61,0x72,0x74,0x69, 0x63,0x6c,0x65,0x20,0x46,0x6f,0x72,0x6d,0x61,0x74,0x00,0x00,0x00,0x00,0x00,0x00 }; static unsigned int sizes[11] = {2, 4, 8, 2, 4, 8, 2, 4, 8, 1, 1}; #ifndef USE_ILMHALF union f_ui { unsigned int ui; float f; }; static f_ui half2float[65536] = { #include "half2float.h" }; #endif static bool read_buffer(std::istream& is, z_stream& z, char* in_buf, void* p, size_t size, std::ostream* errorStream) { z.next_out=(Bytef*)p; z.avail_out=(uInt)size; while (z.avail_out) { if ( z.avail_in == 0 ) { if (!is.eof()) { z.next_in = (Bytef*)in_buf; is.read((char*)z.next_in, OUT_BUFSIZE); if (is.bad()) { if(errorStream) *errorStream<<"read error "< 0) { std::cerr<<"Truncated prt file "< input(new std::ifstream(filename,std::ios::in|std::ios::binary)); if (!*input) { if(errorStream) *errorStream<<"Partio: Unable to open file "<read((char*)&header,sizeof(FileHeadder)); if (memcmp(header.magic, magic, sizeof(magic))) { if(errorStream) *errorStream<<"Partio: failed to get PRT magic"< sizeof(FileHeadder)) input->seekg(header.headersize); int reserve=0; int channels=0; int channelsize=0; read(*input,reserve); // reserved read(*input,channels); // number of channel read(*input,channelsize); // size of channel simple->addParticles((const int)header.numParticles); std::vector chans; std::vector attrs; unsigned particleSize = 0; for (int i=0; iread((char*)&ch, sizeof(Channel)); ParticleAttributeType type=NONE; switch (ch.type) { case 0: // int16 case 1: // int32 case 2: // int64 type = INT; break; case 3: // float16 case 4: // float32 case 5: // float64 if (ch.arity == 3) type = VECTOR; else type = FLOAT; break; case 6: // uint16 case 7: // uint32 case 8: // uint64 type = INT; break; case 9: // int8 case 10:// uint8 type = INT; break; } if (type != NONE) { #ifdef AUTO_CASES if (ch.name[0] >= 'A' && ch.name[0] <= 'Z') { ch.name[0] += 0x20; } #endif std::string name((char*)ch.name); ParticleAttribute attrHandle=simple->addAttribute(name.c_str(),type,ch.arity); chans.push_back(ch); attrs.push_back(attrHandle); } // The size of the particle is determined from the channel with largest offset. The channels are not required to be listed in order. particleSize = (std::max)( particleSize, chans.back().offset + sizes[ch.type] ); // The channel entry might have more data in other PRT versions. if ((unsigned)channelsize > sizeof(Channel)) input->seekg(channelsize - sizeof(Channel), std::ios::cur); } if (headersOnly) return simple; z_stream z; z.zalloc = Z_NULL;z.zfree = Z_NULL;z.opaque = Z_NULL; if (inflateInit( &z ) != Z_OK) { if(errorStream) *errorStream<<"Zlib inflateInit error"<numParticles();particleIndex++) { // Read the particle from the file, and decompress it into a single particle-sized buffer. read_buffer(*input, z, (char*)in_buf, prt_buf, particleSize, errorStream); for (unsigned int attrIndex=0;attrIndexdataWrite(attrs[attrIndex],particleIndex); for (int count=0;count( &prt_buf[ chans[attrIndex].offset + count * sizeof(short) ] ); } break; case 1: // int32 { ival = (int)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(int) ] ); } break; case 2: // int64 { ival = (int)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(long long) ] ); } break; case 6: // uint16 { ival = (int)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned short) ] ); } break; case 7: // uint32 { ival = (int)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + + count * sizeof(unsigned int) ] ); } break; case 8: // uint64 { ival = (int)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned long long) ] ); } break; case 9: // int8 { ival = (int)prt_buf[ chans[attrIndex].offset + count ]; } break; case 10:// uint8 { ival = (int)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned char) ] ); } break; } data[count]=ival; } }else if (attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR) { float* data=simple->dataWrite(attrs[attrIndex],particleIndex); for (int count=0;count( &prt_buf[ chans[attrIndex].offset + count * sizeof(half) ] ); #else unsigned short val = *reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned short) ] ); fval = half2float[val].f; #endif } break; case 4: // float32 { fval = (float)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(float) ] ); } break; case 5: // float64 { fval = (float)*reinterpret_cast( &prt_buf[ chans[attrIndex].offset + count * sizeof(double) ] ); } break; } data[count]=fval; } } } } delete[] prt_buf; if (inflateEnd( &z ) != Z_OK) { if(errorStream) *errorStream<<"Zlib inflateEnd error"< output( new std::ofstream(filename,std::ios::out|std::ios::binary)); if (!*output) { if(errorStream) *errorStream <<"Partio Unable to open file "<write((char*)&header,sizeof(FileHeadder)); write(*output, reserve); write(*output, (int)p.numAttributes()); reserve = 0x2c; write(*output, reserve); std::vector attrs; int offset = 0; for (int i=0;i= 'a' && ch.name[0] <= 'z') { ch.name[0] -= 0x20; } #endif output->write((char*)&ch,sizeof(Channel)); attrs.push_back(attr); } } z_stream z; z.zalloc = Z_NULL;z.zfree = Z_NULL;z.opaque = Z_NULL; if (deflateInit( &z, Z_DEFAULT_COMPRESSION ) != Z_OK) { if(errorStream) *errorStream<<"Zlib deflateInit error"<(attrs[attrIndex],particleIndex); if (!write_buffer(*output, z, (char*)out_buf, (void*)data, sizeof(int)*attrs[attrIndex].count, false, errorStream)) return false; } else if (attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR) { const float* data=p.data(attrs[attrIndex],particleIndex); if (!write_buffer(*output, z, (char*)out_buf, (void*)data, sizeof(int)*attrs[attrIndex].count, false, errorStream)) return false; } } } write_buffer(*output, z, (char*)out_buf, 0, 0, true, errorStream); if (deflateEnd( &z ) != Z_OK) { if(errorStream) *errorStream<<"Zlib deflateEnd error"< 0 return true; } } #else #include "../Partio.h" #include #include namespace Partio{ ParticlesDataMutable* readPRT(const char* filename,const bool headersOnly, std::ostream* error) { std::cerr<<"PRT not supported on windows"< #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "PartioEndian.h" #include "ZIP.h" #include #include #include #include #include #include #include namespace Partio { using namespace std; static const int ptc_magic=((((('c'<<8)|'t')<<8)|'p')<<8)|'p'; inline string GetString(istream& input,const char terminator='\0') { // TODO: make this check for FEOF condition! and also more efficient char c=' '; string s; while (c!=terminator && input) { input.read(&c,sizeof(char)); s += c; } return s; } bool ParseSpec(const string& spec,string& typeName,string& name) { // TODO: make more robust const char* s=spec.c_str(); typeName="";name=""; while(*s!=' ') typeName+=*s++; while(*s==' ') s++; while(*s!='\n') name+=*s++; return true; } ParticlesDataMutable* readPTC(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in|ios::binary)); if(!*input){ if(errorStream) *errorStream <<"Partio: Unable to open file "<(*input,magic); if(ptc_magic!=magic){ if(errorStream) *errorStream <<"Partio: Magic number '"<(*input,version); if(version>2){ if(errorStream) *errorStream <<"Partio: ptc reader only supports version 2 or less"<(*input,nPoints); // TODO: allow access to this in the headers only mode for times when only bbox is necessary float xmin,ymin,zmin,xmax,ymax,zmax; read(*input,xmin,ymin,zmin,xmax,ymax,zmax); float dummy; // Who knows what this is? if (version>=1) for (int d=0;d<4;d++) read(*input,dummy); // This seems to be 4 bytes of something and 32 0xDEADBEEF guys if (version>=2){ float maxRadius; read(*input,maxRadius); for (int d=0;d<32;d++) read(*input,dummy); } // world-to-eye for(int i=0;i<16;i++) read(*input,dummy); // eye-to-screen for(int i=0;i<16;i++) read(*input,dummy); float imgWidth,imgHeight,imgDepth; read(*input,imgWidth,imgHeight,imgDepth); int nVars,dataSize; read(*input,nVars,dataSize); // Allocate a simple particle with the appropriate number of points ParticlesDataMutable* simple=0; if(headersOnly) simple=new ParticleHeaders; else simple=create(); simple->addParticles((int)nPoints); // PTC files always have something for these items, so allocate the data vector attrHandles; ParticleAttribute positionHandle=simple->addAttribute("position",VECTOR,3); ParticleAttribute normalHandle=simple->addAttribute("normal",VECTOR,3); ParticleAttribute radiusHandle=simple->addAttribute("radius",FLOAT,1); string typeName,name; // data types are "float", "point", "vector", "normal", "color", or "matrix" int parsedSize=0; for(int chanNum=0;chanNumrelease(); return 0; } // make unqiue name int unique=1; string effectiveName=name; ParticleAttribute info; while(simple->attributeInfo(effectiveName.c_str(),info)){ ostringstream ss; ss<addAttribute(effectiveName.c_str(),dataType,dataSize)); parsedSize+=dataSize; } if(dataSize!=parsedSize){ if(errorStream) *errorStream <<"Partio: error with PTC, computed dataSize ("<release(); return 0; } // If all we care about is headers, then return. if(headersOnly){ return simple; } // more weird input attributes if(version>=1) for(int i=0;i<2;i++) read(*input,dummy); for(int pointIndex=0;pointIndexdataWrite(positionHandle,pointIndex); read(*input,pos[0],pos[1],pos[2]); unsigned short phi,z; // normal encoded read(*input,phi,z); float* norm=simple->dataWrite(normalHandle,pointIndex); // Convert unsigned short (phi,nz) to xyz normal // This packing code is based on Per Christensen's rman forum post if (phi != 65535 || z != 65535) { float nz = (float)z / 65535.0f; norm[2] = 2.0f * nz - 1.0f; float fphi = (float)phi / 65535.0f; fphi = 2.0f * static_cast(M_PI) * (fphi - 0.5f); //assert(-M_PI-0.0001 <= fphi && fphi <= M_PI+0.0001); float rxy = sqrt(1.0f - norm[2]*norm[2]); norm[0] = rxy * sin(fphi); norm[1] = rxy * cos(fphi); } else { norm[0] = norm[1] = norm[2] = 0.0f; } float* radius=simple->dataWrite(radiusHandle,pointIndex); read(*input,radius[0]); for(unsigned int i=0;idataWrite(attrHandles[i],pointIndex); for(int j=0;j(*input,data[j]); } } return simple; } bool writePTC(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream) { //ofstream output(filename,ios::out|ios::binary); unique_ptr output( compressed ? Gzip_Out(filename,ios::out|ios::binary) :new ofstream(filename,ios::out|ios::binary)); if(!*output){ if(errorStream) *errorStream <<"Partio Unable to open file "<(*output,ptc_magic); write(*output,(int)0); // particle count double numParticlesAsDouble=p.numParticles(); write(*output,numParticlesAsDouble); ParticleAttribute positionHandle,normalHandle,radiusHandle; bool foundPosition=p.attributeInfo("position",positionHandle); bool foundNormal=p.attributeInfo("normal",normalHandle); bool foundRadius=p.attributeInfo("radius",radiusHandle); if(!foundPosition){ if(errorStream) *errorStream <<"Partio: failed to find attr 'position' for PTC output"<(positionHandle,i); for(int k=0;k<3;k++){ boxmin[k]=min(pos[k],boxmin[k]); boxmax[k]=max(pos[k],boxmax[k]); } } write(*output,boxmin[0],boxmin[1],boxmin[2]); write(*output,boxmax[0],boxmax[1],boxmax[2]); // world-to-eye & for(int i=0;i<4;i++) for(int j=0;j<4;j++){ if(i==j) write(*output,(float)1); else write(*output,(float)0); } // eye-to-screen const float foo[4][4]={{1.8f,0,0,0}, {0,2.41f,0,0}, {0,0,1,1}, {0,0,-.1f,0}}; for(int i=0;i<4;i++) for(int j=0;j<4;j++){ write(*output,foo[i][j]); } // imgwidth imgheight, imgdepth write(*output,(float)640,(float)480,(float)300); int nVars=0,dataSize=0; vector specs; vector attrs; for(int i=0;i(*output,nVars,dataSize); for(unsigned int i=0;iwrite(specs[i].c_str(),specs[i].length()); } for(int pointIndex=0;pointIndex(positionHandle,pointIndex); write(*output,pos[0],pos[1],pos[2]); // write normal static const float static_n[3]={0,0,0}; const float* n=static_n; if(foundNormal) n=p.data(normalHandle,pointIndex); // normalize and encode normals as two unsigned short integers z and // phi, representing the z coordinate and angle in the xy plane. The // special value z == phi == 65535 encodes a zero normal. int phi, z; if (n[0] == 0 && n[1] == 0 && n[2] == 0) phi = z = 65535; else { float mag_squared=n[0]*n[0]+n[1]*n[1]+n[2]*n[2]; phi = int((atan2(n[0], n[1]) * (1/(2*M_PI)) + 0.5) * 65535 + 0.5); z = std::min(int((n[2]/sqrt(mag_squared)+1)/2 * 65535 + 0.5), 65535); // phi is redundent when z == 65535; avoid the special value. if (phi == 65535 && z == 65535) phi = 0; } write(*output,(unsigned short)phi,(unsigned short)z); // write radius static const float static_r[1]={1.f}; const float* radius=static_r; if(foundRadius) radius=p.data(radiusHandle,pointIndex); write(*output,radius[0]); // write other attributes for(unsigned int i=0;i(attrs[i],pointIndex); for(int k=0;k(*output,data[k]); } } } return true; } } ================================================ FILE: Externals/partio/io/PTS.cpp ================================================ /* PARTIO SOFTWARE Copyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. Format Contributed by github user: redpawfx (redpawFX@gmail.com) and Luma Pictures 2011 Some code for this format was helped along by referring to an implementation by */ #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "ZIP.h" #include #include #include #include #include #include #include namespace Partio { using namespace std; // TODO: convert this to use iterators like the rest of the readers/writers ParticlesDataMutable* readPTS(const char* filename,const bool headersOnly,std::ostream* errorStream) { unique_ptr input(Gzip_In(filename,ios::in|ios::binary)); if (!*input) { if(errorStream) *errorStream<<"Partio: Can't open particle data file: "< attrNames; vector attrs; /// we're going to fake the ID attribute since there's no such thing in PTS Files attrNames.push_back((string)"id"); attrs.push_back(simple->addAttribute(attrNames[0].c_str(),Partio::INT,1)); /// FORMAT is up to 8 elements space delimited { posX posY posZ remission quality red green blue } // since there's no header data to parse we're just going to hard code this /* Start from the beginning */ input->seekg(0,ios::beg); /* Determine amount of values per line */ char line[1024]; /* Jump over first line. */ input->getline(line,1024); input->getline(line,1024); int valcount = 0; #ifdef PARTIO_WIN32 char * nextLine = NULL; char * pch = strtok_s( line, "\t ", &nextLine ); #else char * pch = strtok( line, "\t " ); #endif while ( pch ) { if ( *pch != 0 && *pch != '\n' ) { valcount++; } #ifdef PARTIO_WIN32 pch = strtok_s( NULL, "\t ", &nextLine ); #else pch = strtok( NULL, "\t " ); #endif } switch ( valcount ) { case 3: // position only { attrNames.push_back((string)"position"); attrs.push_back(simple->addAttribute(attrNames[1].c_str(),Partio::VECTOR,3)); } break; case 4: // position and remission { attrNames.push_back((string)"position"); attrNames.push_back((string)"remission"); attrs.push_back(simple->addAttribute(attrNames[1].c_str(),Partio::VECTOR,3)); attrs.push_back(simple->addAttribute(attrNames[2].c_str(),Partio::FLOAT,1)); } break; case 6: // position and RGB { attrNames.push_back((string)"position"); attrNames.push_back((string)"pointColor"); attrs.push_back(simple->addAttribute(attrNames[1].c_str(),Partio::VECTOR,3)); attrs.push_back(simple->addAttribute(attrNames[2].c_str(),Partio::VECTOR,3)); } break; case 7: // position remission and RGB { attrNames.push_back((string)"position"); attrNames.push_back((string)"remission"); attrNames.push_back((string)"pointColor"); attrs.push_back(simple->addAttribute(attrNames[1].c_str(),Partio::VECTOR,3)); attrs.push_back(simple->addAttribute(attrNames[2].c_str(),Partio::FLOAT,1)); attrs.push_back(simple->addAttribute(attrNames[3].c_str(),Partio::VECTOR,3)); } break; case 8: // everything { attrNames.push_back((string)"position"); attrNames.push_back((string)"remission"); attrNames.push_back((string)"quality"); attrNames.push_back((string)"pointColor"); attrs.push_back(simple->addAttribute(attrNames[1].c_str(),Partio::VECTOR,3)); attrs.push_back(simple->addAttribute(attrNames[2].c_str(),Partio::FLOAT,1)); attrs.push_back(simple->addAttribute(attrNames[3].c_str(),Partio::INT,1)); attrs.push_back(simple->addAttribute(attrNames[4].c_str(),Partio::VECTOR,3)); } break; default: { return 0; } break; } input->seekg(0,ios::beg); unsigned int num=0; simple->addParticles(num); if (headersOnly) return simple; // escape before we try to touch data if (input->good()) { // garbage count at top of file char junk[1024]; input->getline(junk,1024); } // Read actual particle data if (!input->good()) { simple->release(); return 0; } // we have to read line by line, because data is not clean and consistent so we skip any lines that dont' conform for (unsigned int particleIndex=0;input->good();) { string token = ""; char line[1024]; input->getline(line, 1024); stringstream ss(line); float lineData[8]; int i = 0; while (ss >> token) { stringstream foo(token); float x; foo >> x; lineData[i] = x; i++; } if (i == valcount) { simple->addParticle(); for (unsigned int attrIndex=0;attrIndexdataWrite(attrs[attrIndex],particleIndex); if (attrs[attrIndex].name == "id") { data[0]=particleIndex; } else { data[0] = (int)lineData[4]; } } else if (attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR) { float* data=simple->dataWrite(attrs[attrIndex],particleIndex); if (attrs[attrIndex].name == "pointColor") { // 8 bit color conversion data[0]=lineData[4]/255; data[1]=lineData[5]/255; data[2]=lineData[6]/255; } else if (attrs[attrIndex].name == "position") { // position, we flip y/z data[0]=lineData[0]; data[1]=lineData[2]; data[2]=lineData[1]; } else if (attrs[attrIndex].name == "remission") { data[0] = lineData[3]; } } } particleIndex++; } } return simple; } /// THIS DOESENT WORK YET>> /* bool writePTS(const char* filename,const ParticlesData& p,const bool compressed) { unique_ptr output( compressed ? Gzip_Out(filename,ios::out|ios::binary) :new ofstream(filename,ios::out|ios::binary)); *output<<"ATTRIBUTES"< attrs; for (int aIndex=0;aIndex(attrs[attrIndex],particleIndex); for(int count=0;count(attrs[attrIndex],particleIndex); for(int count=0;count #include "../core/Mutex.h" #include "../Partio.h" #include "readers.h" namespace Partio{ using namespace std; // reader and writer code typedef ParticlesDataMutable* (*READER_FUNCTION)(const char*,const bool,std::ostream*); typedef bool (*WRITER_FUNCTION)(const char*,const ParticlesData&,const bool,std::ostream*); PartioMutex initializationMutex; map& readers() { static map data; static bool initialized=false; if(!initialized){ initializationMutex.lock(); data["bgeo"]=readBGEO; data["bhclassic"]=readBGEO; data["geo"]=readGEO; data["hclassic"]=readGEO; data["pdb"]=readPDB; data["pdb32"]=readPDB32; data["pdb64"]=readPDB64; data["pda"]=readPDA; data["mc"]=readMC; data["ptc"]=readPTC; data["pdc"]=readPDC; //data["prt"]=readPRT; data["bin"]=readBIN; data["pts"]=readPTS; data["ptf"]=readPTC; data["itbl"]=readBGEO; data["atbl"]=readBGEO; initialized=true; initializationMutex.unlock(); } return data; } map& writers() { static map data; static bool initialized=false; if(!initialized){ initializationMutex.lock(); data["bgeo"]=writeBGEO; data["bhclassic"]=writeBGEO; data["geo"]=writeGEO; data["hclassic"]=writeGEO; data["pdb"]=writePDB; data["pdb32"]=writePDB32; data["pdb64"]=writePDB64; data["pda"]=writePDA; data["ptc"]=writePTC; data["rib"]=writeRIB; data["pdc"]=writePDC; //data["prt"]=writePRT; data["bin"]=writeBIN; data["ptf"]=writePTC; data["itbl"]=writeBGEO; data["atbl"]=writeBGEO; initialized=true; initializationMutex.unlock(); } return data; } //! Gives extension of a file ignoring any trailing .gz //! i.e. for 'foo.pdb.gz' it gives 'pdb', for 'foo.pdb' it gives 'pdb' bool extensionIgnoringGz(const string& filename,string& ret,bool &endsWithGz,std::ostream& errorStream) { size_t period=filename.rfind('.'); endsWithGz=false; if(period==string::npos){ errorStream<<"Partio: No extension detected in filename"<::iterator i=readers().find(extension); if(i==readers().end()){ errorStream<<"Partio: No reader defined for extension "<second)(c_filename,false,verbose ? &errorStream : 0); } ParticlesInfo* readHeaders(const char* c_filename,bool verbose,std::ostream& errorStream) { string filename(c_filename); string extension; bool endsWithGz; if(!extensionIgnoringGz(filename,extension,endsWithGz,errorStream)) return 0; map::iterator i=readers().find(extension); if(i==readers().end()){ errorStream<<"Partio: No reader defined for extension "<second)(c_filename,true,verbose ? &errorStream : 0); } void write(const char* c_filename,const ParticlesData& particles,const bool forceCompressed,bool verbose,std::ostream& errorStream) { string filename(c_filename); string extension; bool endsWithGz; if(!extensionIgnoringGz(filename,extension,endsWithGz,errorStream)) return; map::iterator i=writers().find(extension); if(i==writers().end()){ errorStream<<"Partio: No writer defined for extension "<second)(c_filename,particles,forceCompressed || endsWithGz,verbose ? &errorStream : 0); } } // namespace Partio ================================================ FILE: Externals/partio/io/PartioEndian.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _partioendian_h_ #define _partioendian_h_ #include #include namespace Partio{ template void endianSwap(T& value) { T temp=value; char* src=(char*)&temp; char* dest=(char*)&value; for(unsigned int i=0;i static void swap(T&){ } }; struct LITEND { template static void swap(T& x){ endianSwap(x); } }; #else struct BIGEND { template static void swap(T& x){ endianSwap(x); } }; struct LITEND { template static void swap(T&){ } }; #endif template inline void read(std::istream& input,T& d) { input.read((char*)&d,sizeof(T)); E::swap(d); } template inline void write(std::ostream& output,const T& d) { T copy=d; E::swap(copy); output.write((char*)©,sizeof(T)); } template void read(std::istream& input,T1& d1,T2& d2) {read(input,d1);read(input,d2);} template void read(std::istream& input,T1& d1,T2& d2,T3& d3) {read(input,d1);read(input,d2,d3);} template void read(std::istream& input,T1& d1,T2& d2,T3& d3,T4& d4) {read(input,d1);read(input,d2,d3,d4);} template void read(std::istream& input,T1& d1,T2& d2,T3& d3,T4& d4,T5& d5) {read(input,d1);read(input,d2,d3,d4,d5);} template void read(std::istream& input,T1& d1,T2& d2,T3& d3,T4& d4,T5& d5,T6& d6) {read(input,d1);read(input,d2,d3,d4,d5,d6);} template void write(std::ostream& output,const T1& d1,const T2& d2) {write(output,d1);write(output,d2);} template void write(std::ostream& output,const T1& d1,const T2& d2,const T3& d3) {write(output,d1);write(output,d2,d3);} template void write(std::ostream& output,const T1& d1,const T2& d2,const T3& d3,const T4& d4) {write(output,d1);write(output,d2,d3,d4);} template void write(std::ostream& output,const T1& d1,const T2& d2,const T3& d3,const T4& d4,const T5& d5) {write(output,d1);write(output,d2,d3,d4,d5);} template void write(std::ostream& output,const T1& d1,const T2& d2,const T3& d3,const T4& d4,const T5& d5,const T6& d6) {write(output,d1);write(output,d2,d3,d4,d5,d6);} } #endif ================================================ FILE: Externals/partio/io/RIB.cpp ================================================ /* * Copyright (c) 2010 - 2011 Sebastien Noury * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. * */ #include "../Partio.h" #include "../core/ParticleHeaders.h" #include "ZIP.h" #include #include #include #include #include namespace Partio { using namespace std; bool writeRIB(const char* filename, const ParticlesData& p, const bool compressed,std::ostream* errorStream) { unique_ptr output( compressed ? Gzip_Out(filename, ios::out | ios::binary) : new ofstream(filename, ios::out | ios::binary)); ParticleAttribute dummy; bool foundP = p.attributeInfo("position", dummy) || p.attributeInfo("P", dummy); bool foundP2 = p.attributeInfo("position2", dummy) || p.attributeInfo("P2", dummy); bool foundWidth = p.attributeInfo("radius", dummy) || p.attributeInfo("width", dummy) || p.attributeInfo("radiusPP", dummy); if (!foundP) { if(errorStream) *errorStream << "Partio: failed to find attr 'position' or 'P' for RIB output" << endl; return false; } if (!foundWidth) if(errorStream) *errorStream << "Partio: failed to find attr 'width','radius', or 'radiusPP' for RIB output, using constantwidth = 1" << endl; *output << "version 3.04" << endl; if (foundP2) *output << "GeometricApproximation \"motionfactor\" 1.0" << endl; *output << "AttributeBegin" << endl; *output << " ResourceBegin" << endl; *output << " Attribute \"identifier\" \"name\" [\"|partioParticle1|partioParticleShape1\"]" << endl; int numPasses = foundP2 ? 2 : 1; if (foundP2) *output << " MotionBegin [0.0 1.0]" << endl; for (int passIndex = 0; passIndex < numPasses; ++passIndex) { *output << (foundP2 ? " " : "") << " Points "; for (int attrIndex = 0; attrIndex < p.numAttributes(); ++attrIndex) { ParticleAttribute attr; p.attributeInfo(attrIndex, attr); if ((passIndex == 0 && (attr.name == "P2" || attr.name == "position2")) || (passIndex == 1 && (attr.name == "P" || attr.name == "position"))) continue; string attrname = (attr.name == "position" || attr.name == "position2" || attr.name == "P" || attr.name == "P2") ? "P" : (attr.name == "radius" ? "width" : attr.name); *output << "\"" << attrname << "\" [ "; int spaceCount = 0; switch (attr.type) { case Partio::FLOAT: case Partio::VECTOR: { for (int particleIndex = 0; particleIndex < p.numParticles(); ++particleIndex) { const float *data = p.data(attr, particleIndex); for (int count = 0; count < attr.count; ++count) { *output << data[count] << " "; spaceCount ++; } if (spaceCount > 12) { *output << "\n "; spaceCount = 0; } } break; } case Partio::INT: { for (int particleIndex = 0; particleIndex < p.numParticles(); ++particleIndex) { const int *data = p.data(attr, particleIndex); for (int count = 0; count < attr.count; ++count) { *output << data[count] << " "; spaceCount ++; } if (spaceCount > 12) { *output << "\n "; spaceCount = 0; } } break; } case Partio::NONE: default: break; } *output << "]\n "; } if (!foundWidth) *output << "\"constantwidth\" [1.0]"; *output << endl; } if (foundP2) *output << " MotionEnd" << endl; *output << " ResourceEnd" << endl; *output << "AttributeEnd" << endl; return true; } } ================================================ FILE: Externals/partio/io/ZIP.cpp ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifdef PARTIO_USE_ZLIB extern "C"{ # include } #endif #include #include #include #include #include #include #include #include #include "ZIP.h" namespace Partio{ template inline void Swap_Endianity(T& x) { assert(sizeof(T)<=8); if(sizeof(T)>1) { T old=x; for(unsigned int k=1;k<=sizeof(T);k++) ((char*)&x)[k-1]=((char*)&old)[sizeof(T)-k]; } } template inline void Read_Primitive(std::istream& stream,T& x) { stream.read(&(char&)x,sizeof(T)); } template inline void Write_Primitive(std::ostream& stream,const T& x) { stream.write(&(char&)x,sizeof(T)); } //##################################################################### // class GZipFileHeader //##################################################################### struct GZipFileHeader { unsigned char magic0,magic1; // magic should be 0x8b,0x1f unsigned char cm; // compression method 0x8 is gzip unsigned char flags; // flags unsigned int modtime; // 4 byte modification time unsigned char flags2; // secondary flags unsigned char os; // operating system 0xff for unknown unsigned short crc16; // crc check unsigned int crc32; GZipFileHeader() :magic0(0),magic1(0),flags(0),modtime(0),flags2(0),os(0),crc16(0),crc32(0) {} bool Read(std::istream& istream) {Read_Primitive(istream,magic0); Read_Primitive(istream,magic1); if(magic0 != 0x1f || magic1 != 0x8b){//std::cerr<<"gzip: did not find gzip magic 0x1f 0x8b"<(istream.gcount()); total_read+=strm.avail_in; strm.next_in=(Bytef*)in;} int ret=inflate(&strm,Z_NO_FLUSH); // decompress switch(ret){ case Z_STREAM_ERROR: std::cerr<<"libz error Z_STREAM_ERROR"<(istream.gcount()); total_read+=count; return count;} } virtual int underflow() {if(gptr() && (gptr()(gptr()-eback()); if(put_back_count>4) put_back_count=4; std::memmove(out+(4-put_back_count),gptr()-put_back_count,put_back_count); int num=process(); setg((char*)(out+4-put_back_count),(char*)(out+4),(char*)(out+4+num)); if(num<=0) return EOF; return traits_type::to_int_type(*gptr());} virtual int overflow(int) {assert(false);return EOF;} // assignment operator declared and not defined, to suppress warning 4512 for Visual Studio ZipStreambufDecompress& operator=(const ZipStreambufDecompress& _Right); //##################################################################### }; //##################################################################### // class ZipStreambufCompress //##################################################################### class ZipStreambufCompress:public std::streambuf { static const int buffer_size=512; std::ostream& ostream; // owned when header==0 (when not part of zip file) z_stream strm; unsigned char in[buffer_size],out[buffer_size]; ZipFileHeader* header; GZipFileHeader gzip_header; unsigned int header_offset; unsigned int uncompressed_size; unsigned int crc; bool valid; public: ZipStreambufCompress(ZipFileHeader* header,std::ostream& stream) :ostream(stream),header(header),valid(true) { strm.zalloc=Z_NULL;strm.zfree=Z_NULL;strm.opaque=Z_NULL; int ret=deflateInit2(&strm,Z_DEFAULT_COMPRESSION,Z_DEFLATED,-MAX_WBITS,8,Z_DEFAULT_STRATEGY); if(ret != Z_OK){std::cerr<<"libz: failed to deflateInit"<header_offset=static_cast(stream.tellp());header->Write(ostream,false);} else{header_offset=static_cast(stream.tellp());gzip_header.Write(ostream);} uncompressed_size=crc=0; } virtual ~ZipStreambufCompress() {if(valid){ process(true); deflateEnd(&strm); if(header){ std::ios::streampos final_position=ostream.tellp(); header->uncompressed_size=uncompressed_size; header->crc=crc; ostream.seekp(header->header_offset); header->Write(ostream,false); ostream.seekp(final_position);} else{Write_Primitive(ostream,crc);Write_Primitive(ostream,uncompressed_size);}} if(!header) delete &ostream;} protected: int process(bool flush) {if(!valid) return -1; strm.next_in=(Bytef*)pbase(); strm.avail_in=static_cast(pptr()-pbase()); while(strm.avail_in!=0 || flush){ strm.avail_out=buffer_size; strm.next_out=(Bytef*)out; int ret=deflate(&strm,flush?Z_FINISH:Z_NO_FLUSH); if(!(ret!=Z_BUF_ERROR && ret!=Z_STREAM_ERROR)){ valid=false; std::cerr<<"gzip: gzip error "<(strm.next_out-(Bytef*)out); ostream.write((char*)out,generated_output); if(header) header->compressed_size+=generated_output; if(ret==Z_STREAM_END) break;} // update counts, crc's and buffers int consumed_input=static_cast(pptr()-pbase()); uncompressed_size+=consumed_input; crc=crc32(crc,(Bytef*)in,consumed_input); setp(pbase(),pbase()+buffer_size-4);return 1;} virtual int sync() {if(pptr() && pptr()>pbase()) return process(false);return 0;} virtual int underflow() {std::runtime_error("Attempt to read write only ostream");return 0;} virtual int overflow(int c=EOF) {if(c!=EOF){*pptr()=static_cast(c);pbump(1);} if(process(false)==EOF) return EOF; return c;} // assignment operator declared and not defined, to suppress warning 4512 for Visual Studio ZipStreambufCompress& operator=(const ZipStreambufCompress& _Right); //##################################################################### }; //##################################################################### // Class ZIP_FILE_ISTREAM //##################################################################### // Class needed because istream cannot own its streambuf class ZIP_FILE_ISTREAM:public std::istream { ZipStreambufDecompress buf; public: ZIP_FILE_ISTREAM(std::istream& istream,bool part_of_zip_file) :std::istream(&buf),buf(istream,part_of_zip_file) {} virtual ~ZIP_FILE_ISTREAM() {} //##################################################################### }; //##################################################################### // Class ZIP_FILE_OSTREAM //##################################################################### // Class needed because ostream cannot own its streambuf class ZIP_FILE_OSTREAM:public std::ostream { ZipStreambufCompress buf; public: ZIP_FILE_OSTREAM(ZipFileHeader* header,std::ostream& ostream) :std::ostream(&buf),buf(header,ostream) {} virtual ~ZIP_FILE_OSTREAM() {} //##################################################################### }; //##################################################################### // Function ZipFileWriter //##################################################################### ZipFileWriter:: ZipFileWriter(const std::string& filename) { ostream.open(filename.c_str(),std::ios::out|std::ios::binary); if(!ostream) throw std::runtime_error("ZIP: Invalid file handle"); } //##################################################################### // Function ZipFileWriter //##################################################################### ZipFileWriter:: ~ZipFileWriter() { // Write all file headers std::ios::streampos final_position=ostream.tellp(); for(unsigned int i=0;iWrite(ostream,true);delete files[i];} std::ios::streampos central_end=ostream.tellp(); // Write end of central Write_Primitive(ostream,(unsigned int)0x06054b50); // end of central Write_Primitive(ostream,(unsigned short)0); // this disk number Write_Primitive(ostream,(unsigned short)0); // this disk number Write_Primitive(ostream,(unsigned short)files.size()); // one entry in center in this disk Write_Primitive(ostream,(unsigned short)files.size()); // one entry in center Write_Primitive(ostream,(unsigned int)(central_end-final_position)); // size of header Write_Primitive(ostream,(unsigned int)final_position); // offset to header Write_Primitive(ostream,(unsigned short)0); // zip comment } //##################################################################### // Function ZipFileWriter //##################################################################### std::ostream* ZipFileWriter:: Add_File(const std::string& filename,const bool) { files.push_back(new ZipFileHeader(filename)); return new ZIP_FILE_OSTREAM(files.back(),ostream); } //##################################################################### // Function ZipFileReader //##################################################################### ZipFileReader:: ZipFileReader(const std::string& filename) { istream.open(filename.c_str(),std::ios::in|std::ios::binary); if(!istream) throw std::runtime_error("ZIP: Invalid file handle"); Find_And_Read_Central_Header(); } //##################################################################### // Function ZipFileReader //##################################################################### ZipFileReader:: ~ZipFileReader() { std::map::iterator i=filename_to_header.begin(); for(;i!=filename_to_header.end();++i) delete i->second; } //##################################################################### // Function Find_And_Read_Central_Header //##################################################################### bool ZipFileReader:: Find_And_Read_Central_Header() { // Find the header // NOTE: this assumes the zip file header is the last thing written to file... istream.seekg(0,std::ios_base::end); std::ios::streampos end_position=istream.tellg(); unsigned int max_comment_size=0xffff; // max size of header unsigned int read_size_before_comment=22; std::ios::streamoff read_start=max_comment_size+read_size_before_comment; if(read_start>end_position) read_start=end_position; istream.seekg(end_position-read_start); char *buf=new char[static_cast(read_start)]; if(read_start<=0){std::cerr<<"ZIP: Invalid read buffer size"<Read(istream,true); if(valid) filename_to_header[header->filename]=header;} return true; } //##################################################################### // Function Get_File //##################################################################### std::istream* ZipFileReader::Get_File(const std::string& filename,const bool) { std::map::iterator i=filename_to_header.find(filename); if(i!=filename_to_header.end()){ ZipFileHeader* header=i->second; istream.seekg((*header).header_offset);return new ZIP_FILE_ISTREAM(istream,true); } return 0; } //##################################################################### // Function Get_File_List //##################################################################### void ZipFileReader::Get_File_List(std::vector& filenames) const { filenames.clear(); std::map::const_iterator i=filename_to_header.begin(); for(;i!=filename_to_header.end();++i) filenames.push_back(i->first); } //##################################################################### // Function Gzip_In //##################################################################### std::istream* Gzip_In(const std::string& filename,std::ios::openmode mode) { std::ifstream* infile=new std::ifstream(filename.c_str(),mode | std::ios::binary); GZipFileHeader header; bool zipped=header.Read(*infile); infile->seekg(0); if(!zipped) return infile; else return new ZIP_FILE_ISTREAM(*infile,false); } //##################################################################### // Function Gzip_Out //##################################################################### std::ostream* Gzip_Out(const std::string& filename,std::ios::openmode mode) { std::ofstream* outfile=new std::ofstream(filename.c_str(),mode); return new ZIP_FILE_OSTREAM(0,*outfile); } //##################################################################### #else //##################################################################### // Function Gzip_In //##################################################################### std::istream* Gzip_In(const std::string& filename,std::ios::openmode mode) { std::ifstream* infile=new std::ifstream(filename.c_str(),mode | std::ios::binary); GZipFileHeader header; bool zipped=header.Read(*infile); infile->seekg(0); if(!zipped) return infile; delete infile; std::cerr<<"Partio: encountered gz file '"< #include #include #include #include #include namespace Partio{ struct ZipFileHeader; //##################################################################### // Functions Gzip_Out/Gzip_In - Create streams that read/write .gz //##################################################################### std::istream* Gzip_In(const std::string& filename,std::ios::openmode mode); std::ostream* Gzip_Out(const std::string& filename,std::ios::openmode mode); //##################################################################### // Class ZipFileWriter //##################################################################### class ZipFileWriter { std::ofstream ostream; std::vector files; public: //##################################################################### ZipFileWriter(const std::string& filename); virtual ~ZipFileWriter(); std::ostream* Add_File(const std::string& filename,const bool binary=true); //##################################################################### }; //##################################################################### // Class ZipFileReader //##################################################################### class ZipFileReader { std::ifstream istream; public: std::map filename_to_header; //##################################################################### ZipFileReader(const std::string& filename); virtual ~ZipFileReader(); std::istream* Get_File(const std::string& filename,const bool binary=true); void Get_File_List(std::vector& filenames) const; private: bool Find_And_Read_Central_Header(); //##################################################################### }; } #endif ================================================ FILE: Externals/partio/io/half2float.h ================================================ { 0},{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},{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}, {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},{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}, {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}, ================================================ FILE: Externals/partio/io/pdb.h ================================================ /* PARTIO SOFTWARE Copyright 2010 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. This code is based on the Gifts/readpdb directory of Autodesk Maya NOTE: some modifications were made and "32-bit" versions of the structures were created to allow us to assume the pointers were 32-bit integers instead of system dependent pointers. As originally defined, this format would be architecture dependent (behave differently on 32-bit and 64-bit architectures). Maya's writers may or may not also be doing this. If you have any files that don't work, please let me know. But in general, it would be difficult/error prone to detect what type the PDB file is. */ #define PDB_VECTOR 1 #define PDB_REAL 2 #define PDB_LONG 3 #define PDB_CHAR 4 #define PDB_POINTERT 5 typedef float Real; typedef struct { Real x,y,z; } Vector; typedef struct Channel_Data32 { int type; unsigned int datasize; unsigned int blocksize; int num_blocks; unsigned int block; //was void **block; } Channel_Data32; typedef struct { int type; unsigned int datasize; unsigned int blocksize; int num_blocks; void **block; } Channel_Data; typedef struct Channel { char *name; int type; unsigned int size; unsigned int active_start; unsigned int active_end; char hide; char disconnect; Channel_Data *data; struct Channel *link; struct Channel *next; } Channel; typedef struct Channel32 { unsigned int name; int type; unsigned int size; unsigned int active_start; unsigned int active_end; char hide; char disconnect; unsigned int data; unsigned int link; unsigned int next; } Channel32; typedef struct { char magic; unsigned short swap; char encoding; char type; } Channel_io_Header; typedef struct { int numAttributes; int numParticles; float time; short *types; char **names; void **data; } PDBdata; typedef struct { int numAttributes; int numParticles; float time; short *types; char **names; unsigned int data; } PDBdata32; #define PDB_MAGIC 670 typedef struct { int magic; unsigned short swap; float version; float time; unsigned data_size; unsigned num_data; char padding[32]; Channel **data; } PDB_Header; typedef struct { int magic; unsigned short swap; float version; float time; unsigned data_size; unsigned num_data; char padding[32]; unsigned int data; } PDB_Header32; ================================================ FILE: Externals/partio/io/readers.h ================================================ /* PARTIO SOFTWARE Copyright 2011 Disney Enterprises, Inc. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation Studios" or the names of its contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission from Walt Disney Pictures. Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. IN NO EVENT SHALL WALT DISNEY PICTURES, 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 BASED 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 DAMAGES. */ #ifndef _READERS_h_ #define _READERS_h_ namespace Partio{ ParticlesDataMutable* readBGEO( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readGEO( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPDB( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPDB32(const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPDB64(const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPDA( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readMC( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPTC( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPDC( const char* filename,const bool headersOnly,std::ostream* errorStream); //ParticlesDataMutable* readPRT( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readBIN( const char* filename,const bool headersOnly,std::ostream* errorStream); ParticlesDataMutable* readPTS( const char* filename,const bool headersOnly,std::ostream* errorStream); bool writeBGEO(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writeGEO(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writePDB(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writePDB32(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writePDB64(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writePDA(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writePTC(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writeRIB(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writePDC(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); //bool writePRT(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); bool writeBIN(const char* filename,const ParticlesData& p,const bool compressed,std::ostream* errorStream); } #endif ================================================ FILE: Externals/variant/mpark/config.hpp ================================================ // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_CONFIG_HPP #define MPARK_CONFIG_HPP // MSVC 2015 Update 3. #if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210) #error "MPark.Variant requires C++11 support." #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_builtin #define __has_builtin(x) 0 #endif #ifndef __has_include #define __has_include(x) 0 #endif #ifndef __has_feature #define __has_feature(x) 0 #endif #if __has_attribute(always_inline) || defined(__GNUC__) #define MPARK_ALWAYS_INLINE __attribute__((__always_inline__)) inline #elif defined(_MSC_VER) #define MPARK_ALWAYS_INLINE __forceinline #else #define MPARK_ALWAYS_INLINE inline #endif #if __has_builtin(__builtin_addressof) || \ (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER) #define MPARK_BUILTIN_ADDRESSOF #endif #if __has_builtin(__builtin_unreachable) || defined(__GNUC__) #define MPARK_BUILTIN_UNREACHABLE __builtin_unreachable() #elif defined(_MSC_VER) #define MPARK_BUILTIN_UNREACHABLE __assume(false) #else #define MPARK_BUILTIN_UNREACHABLE #endif #if __has_builtin(__type_pack_element) #define MPARK_TYPE_PACK_ELEMENT #endif #if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \ !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9) #define MPARK_CPP11_CONSTEXPR #endif #if defined(__cpp_constexpr) && __cpp_constexpr >= 201304 #define MPARK_CPP14_CONSTEXPR #endif #if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \ (defined(_MSC_VER) && defined(_CPPUNWIND)) #define MPARK_EXCEPTIONS #endif #if defined(__cpp_generic_lambdas) || defined(_MSC_VER) #define MPARK_GENERIC_LAMBDAS #endif #if defined(__cpp_lib_integer_sequence) #define MPARK_INTEGER_SEQUENCE #endif #if (defined(__cpp_decltype_auto) && defined(__cpp_return_type_deduction)) || defined(_MSC_VER) #define MPARK_RETURN_TYPE_DEDUCTION #endif #if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER) #define MPARK_TRANSPARENT_OPERATORS #endif #if defined(__cpp_variable_templates) || defined(_MSC_VER) #define MPARK_VARIABLE_TEMPLATES #endif #if !defined(__GLIBCXX__) || __has_include() // >= libstdc++-5 #define MPARK_TRIVIALITY_TYPE_TRAITS #define MPARK_INCOMPLETE_TYPE_TRAITS #endif #endif // MPARK_CONFIG_HPP ================================================ FILE: Externals/variant/mpark/in_place.hpp ================================================ // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_IN_PLACE_HPP #define MPARK_IN_PLACE_HPP #include #include "config.hpp" namespace mpark { struct in_place_t { explicit in_place_t() = default; }; template struct in_place_index_t { explicit in_place_index_t() = default; }; template struct in_place_type_t { explicit in_place_type_t() = default; }; #ifdef MPARK_VARIABLE_TEMPLATES constexpr in_place_t in_place{}; template constexpr in_place_index_t in_place_index{}; template constexpr in_place_type_t in_place_type{}; #endif } // namespace mpark #endif // MPARK_IN_PLACE_HPP ================================================ FILE: Externals/variant/mpark/lib.hpp ================================================ // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_LIB_HPP #define MPARK_LIB_HPP #include #include #include #include #include "config.hpp" #define MPARK_RETURN(...) \ noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; } namespace mpark { namespace lib { template struct identity { using type = T; }; inline namespace cpp14 { template struct array { constexpr const T &operator[](std::size_t index) const { return data[index]; } T data[N == 0 ? 1 : N]; }; template using add_pointer_t = typename std::add_pointer::type; template using common_type_t = typename std::common_type::type; template using decay_t = typename std::decay::type; template using enable_if_t = typename std::enable_if::type; template using remove_const_t = typename std::remove_const::type; template using remove_reference_t = typename std::remove_reference::type; template using remove_cvref_t = typename std::remove_cv>::type; template inline constexpr T &&forward(remove_reference_t &t) noexcept { return static_cast(t); } template inline constexpr T &&forward(remove_reference_t &&t) noexcept { static_assert(!std::is_lvalue_reference::value, "can not forward an rvalue as an lvalue"); return static_cast(t); } template inline constexpr remove_reference_t &&move(T &&t) noexcept { return static_cast &&>(t); } #ifdef MPARK_INTEGER_SEQUENCE using std::integer_sequence; using std::index_sequence; using std::make_index_sequence; using std::index_sequence_for; #else template struct integer_sequence { using value_type = T; static constexpr std::size_t size() noexcept { return sizeof...(Is); } }; template using index_sequence = integer_sequence; template struct make_index_sequence_concat; template struct make_index_sequence_concat, index_sequence> : identity> {}; template struct make_index_sequence_impl; template using make_index_sequence = typename make_index_sequence_impl::type; template struct make_index_sequence_impl : make_index_sequence_concat, make_index_sequence> {}; template <> struct make_index_sequence_impl<0> : identity> {}; template <> struct make_index_sequence_impl<1> : identity> {}; template using index_sequence_for = make_index_sequence; #endif // #ifdef MPARK_TRANSPARENT_OPERATORS using equal_to = std::equal_to<>; #else struct equal_to { template inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const MPARK_RETURN(lib::forward(lhs) == lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using not_equal_to = std::not_equal_to<>; #else struct not_equal_to { template inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const MPARK_RETURN(lib::forward(lhs) != lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using less = std::less<>; #else struct less { template inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const MPARK_RETURN(lib::forward(lhs) < lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using greater = std::greater<>; #else struct greater { template inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const MPARK_RETURN(lib::forward(lhs) > lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using less_equal = std::less_equal<>; #else struct less_equal { template inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const MPARK_RETURN(lib::forward(lhs) <= lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using greater_equal = std::greater_equal<>; #else struct greater_equal { template inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const MPARK_RETURN(lib::forward(lhs) >= lib::forward(rhs)) }; #endif } // namespace cpp14 inline namespace cpp17 { // template using bool_constant = std::integral_constant; template struct voider : identity {}; template using void_t = typename voider::type; namespace detail { namespace swappable { using std::swap; template struct is_swappable { private: template (), std::declval()))> inline static std::true_type test(int); template inline static std::false_type test(...); public: static constexpr bool value = decltype(test(0))::value; }; template struct is_nothrow_swappable { static constexpr bool value = noexcept(swap(std::declval(), std::declval())); }; template struct is_nothrow_swappable : std::false_type {}; } // namespace swappable } // namespace detail using detail::swappable::is_swappable; template using is_nothrow_swappable = detail::swappable::is_nothrow_swappable::value, T>; // namespace detail { template struct is_reference_wrapper : std::false_type {}; template struct is_reference_wrapper> : std::true_type {}; template struct Invoke; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args) MPARK_RETURN((lib::forward(arg).*pmf)(lib::forward(args)...)) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args) MPARK_RETURN((lib::forward(arg).get().*pmf)(lib::forward(args)...)) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args) MPARK_RETURN(((*lib::forward(arg)).*pmf)(lib::forward(args)...)) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmo, Arg &&arg) MPARK_RETURN(lib::forward(arg).*pmo) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmo, Arg &&arg) MPARK_RETURN(lib::forward(arg).get().*pmo) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmo, Arg &&arg) MPARK_RETURN((*lib::forward(arg)).*pmo) }; template inline constexpr auto invoke(R T::*f, Arg &&arg, Args &&... args) MPARK_RETURN( Invoke::value, (std::is_base_of>::value ? 0 : is_reference_wrapper>::value ? 1 : 2)>::invoke(f, lib::forward(arg), lib::forward(args)...)) #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) #endif template inline constexpr auto invoke(F &&f, Args &&... args) MPARK_RETURN(lib::forward(f)(lib::forward(args)...)) #ifdef _MSC_VER #pragma warning(pop) #endif } // namespace detail template inline constexpr auto invoke(F &&f, Args &&... args) MPARK_RETURN(detail::invoke(lib::forward(f), lib::forward(args)...)) namespace detail { template struct invoke_result {}; template struct invoke_result(), std::declval()...))>, F, Args...> : identity(), std::declval()...))> {}; } // namespace detail template using invoke_result = detail::invoke_result; template using invoke_result_t = typename invoke_result::type; namespace detail { template struct is_invocable : std::false_type {}; template struct is_invocable>, F, Args...> : std::true_type {}; template struct is_invocable_r : std::false_type {}; template struct is_invocable_r>, R, F, Args...> : std::is_convertible, R> {}; } // namespace detail template using is_invocable = detail::is_invocable; template using is_invocable_r = detail::is_invocable_r; // #ifdef MPARK_BUILTIN_ADDRESSOF template inline constexpr T *addressof(T &arg) noexcept { return __builtin_addressof(arg); } #else namespace detail { namespace has_addressof_impl { struct fail; template inline fail operator&(T &&); template inline static constexpr bool impl() { return (std::is_class::value || std::is_union::value) && !std::is_same()), fail>::value; } } // namespace has_addressof_impl template using has_addressof = bool_constant()>; template inline constexpr T *addressof(T &arg, std::true_type) noexcept { return std::addressof(arg); } template inline constexpr T *addressof(T &arg, std::false_type) noexcept { return &arg; } } // namespace detail template inline constexpr T *addressof(T &arg) noexcept { return detail::addressof(arg, detail::has_addressof{}); } #endif template inline constexpr T *addressof(const T &&) = delete; } // namespace cpp17 template struct remove_all_extents : identity {}; template struct remove_all_extents> : remove_all_extents {}; template using remove_all_extents_t = typename remove_all_extents::type; template using size_constant = std::integral_constant; template struct indexed_type : size_constant { using type = T; }; template using all = std::is_same, integer_sequence>; #ifdef MPARK_TYPE_PACK_ELEMENT template using type_pack_element_t = __type_pack_element; #else template struct type_pack_element_impl { private: template struct set; template struct set> : indexed_type... {}; template inline static std::enable_if impl(indexed_type); inline static std::enable_if impl(...); public: using type = decltype(impl(set>{})); }; template using type_pack_element = typename type_pack_element_impl::type; template using type_pack_element_t = typename type_pack_element::type; #endif #ifdef MPARK_TRIVIALITY_TYPE_TRAITS using std::is_trivially_copy_constructible; using std::is_trivially_move_constructible; using std::is_trivially_copy_assignable; using std::is_trivially_move_assignable; #else template struct is_trivially_copy_constructible : bool_constant< std::is_copy_constructible::value && __has_trivial_copy(T)> {}; template struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {}; template struct is_trivially_copy_assignable : bool_constant< std::is_copy_assignable::value && __has_trivial_assign(T)> {}; template struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {}; #endif template struct dependent_type : T {}; template struct push_back; template using push_back_t = typename push_back::type; template struct push_back, J> { using type = index_sequence; }; } // namespace lib } // namespace mpark #undef MPARK_RETURN #endif // MPARK_LIB_HPP ================================================ FILE: Externals/variant/mpark/variant.hpp ================================================ // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_VARIANT_HPP #define MPARK_VARIANT_HPP /* variant synopsis namespace std { // 20.7.2, class template variant template class variant { public: // 20.7.2.1, constructors constexpr variant() noexcept(see below); variant(const variant&); variant(variant&&) noexcept(see below); template constexpr variant(T&&) noexcept(see below); template constexpr explicit variant(in_place_type_t, Args&&...); template constexpr explicit variant( in_place_type_t, initializer_list, Args&&...); template constexpr explicit variant(in_place_index_t, Args&&...); template constexpr explicit variant( in_place_index_t, initializer_list, Args&&...); // 20.7.2.2, destructor ~variant(); // 20.7.2.3, assignment variant& operator=(const variant&); variant& operator=(variant&&) noexcept(see below); template variant& operator=(T&&) noexcept(see below); // 20.7.2.4, modifiers template T& emplace(Args&&...); template T& emplace(initializer_list, Args&&...); template variant_alternative& emplace(Args&&...); template variant_alternative& emplace(initializer_list, Args&&...); // 20.7.2.5, value status constexpr bool valueless_by_exception() const noexcept; constexpr size_t index() const noexcept; // 20.7.2.6, swap void swap(variant&) noexcept(see below); }; // 20.7.3, variant helper classes template struct variant_size; // undefined template constexpr size_t variant_size_v = variant_size::value; template struct variant_size; template struct variant_size; template struct variant_size; template struct variant_size>; template struct variant_alternative; // undefined template using variant_alternative_t = typename variant_alternative::type; template struct variant_alternative; template struct variant_alternative; template struct variant_alternative; template struct variant_alternative>; constexpr size_t variant_npos = -1; // 20.7.4, value access template constexpr bool holds_alternative(const variant&) noexcept; template constexpr variant_alternative_t>& get(variant&); template constexpr variant_alternative_t>&& get(variant&&); template constexpr variant_alternative_t> const& get(const variant&); template constexpr variant_alternative_t> const&& get(const variant&&); template constexpr T& get(variant&); template constexpr T&& get(variant&&); template constexpr const T& get(const variant&); template constexpr const T&& get(const variant&&); template constexpr add_pointer_t>> get_if(variant*) noexcept; template constexpr add_pointer_t>> get_if(const variant*) noexcept; template constexpr add_pointer_t get_if(variant*) noexcept; template constexpr add_pointer_t get_if(const variant*) noexcept; // 20.7.5, relational operators template constexpr bool operator==(const variant&, const variant&); template constexpr bool operator!=(const variant&, const variant&); template constexpr bool operator<(const variant&, const variant&); template constexpr bool operator>(const variant&, const variant&); template constexpr bool operator<=(const variant&, const variant&); template constexpr bool operator>=(const variant&, const variant&); // 20.7.6, visitation template constexpr see below visit(Visitor&&, Variants&&...); // 20.7.7, class monostate struct monostate; // 20.7.8, monostate relational operators constexpr bool operator<(monostate, monostate) noexcept; constexpr bool operator>(monostate, monostate) noexcept; constexpr bool operator<=(monostate, monostate) noexcept; constexpr bool operator>=(monostate, monostate) noexcept; constexpr bool operator==(monostate, monostate) noexcept; constexpr bool operator!=(monostate, monostate) noexcept; // 20.7.9, specialized algorithms template void swap(variant&, variant&) noexcept(see below); // 20.7.10, class bad_variant_access class bad_variant_access; // 20.7.11, hash support template struct hash; template struct hash>; template <> struct hash; } // namespace std */ #include #include #include #include #include #include #include #include #include "config.hpp" #include "in_place.hpp" #include "lib.hpp" namespace mpark { #ifdef MPARK_RETURN_TYPE_DEDUCTION #define AUTO auto #define AUTO_RETURN(...) { return __VA_ARGS__; } #define AUTO_REFREF auto && #define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; } #define DECLTYPE_AUTO decltype(auto) #define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; } #else #define AUTO auto #define AUTO_RETURN(...) \ -> lib::decay_t { return __VA_ARGS__; } #define AUTO_REFREF auto #define AUTO_REFREF_RETURN(...) \ -> decltype((__VA_ARGS__)) { \ static_assert(std::is_reference::value, ""); \ return __VA_ARGS__; \ } #define DECLTYPE_AUTO auto #define DECLTYPE_AUTO_RETURN(...) \ -> decltype(__VA_ARGS__) { return __VA_ARGS__; } #endif class bad_variant_access : public std::exception { public: virtual const char *what() const noexcept override { return "bad_variant_access"; } }; [[noreturn]] inline void throw_bad_variant_access() { #ifdef MPARK_EXCEPTIONS throw bad_variant_access{}; #else std::terminate(); MPARK_BUILTIN_UNREACHABLE; #endif } template class variant; template struct variant_size; #ifdef MPARK_VARIABLE_TEMPLATES template constexpr std::size_t variant_size_v = variant_size::value; #endif template struct variant_size : variant_size {}; template struct variant_size : variant_size {}; template struct variant_size : variant_size {}; template struct variant_size> : lib::size_constant {}; template struct variant_alternative; template using variant_alternative_t = typename variant_alternative::type; template struct variant_alternative : std::add_const> {}; template struct variant_alternative : std::add_volatile> {}; template struct variant_alternative : std::add_cv> {}; template struct variant_alternative> { static_assert(I < sizeof...(Ts), "index out of bounds in `std::variant_alternative<>`"); using type = lib::type_pack_element_t; }; constexpr std::size_t variant_npos = static_cast(-1); namespace detail { constexpr std::size_t not_found = static_cast(-1); constexpr std::size_t ambiguous = static_cast(-2); #ifdef MPARK_CPP14_CONSTEXPR template inline constexpr std::size_t find_index() { constexpr lib::array matches = { {std::is_same::value...} }; std::size_t result = not_found; for (std::size_t i = 0; i < sizeof...(Ts); ++i) { if (matches[i]) { if (result != not_found) { return ambiguous; } result = i; } } return result; } #else inline constexpr std::size_t find_index_impl(std::size_t result, std::size_t) { return result; } template inline constexpr std::size_t find_index_impl(std::size_t result, std::size_t idx, bool b, Bs... bs) { return b ? (result != not_found ? ambiguous : find_index_impl(idx, idx + 1, bs...)) : find_index_impl(result, idx + 1, bs...); } template inline constexpr std::size_t find_index() { return find_index_impl(not_found, 0, std::is_same::value...); } #endif template using find_index_sfinae_impl = lib::enable_if_t>; template using find_index_sfinae = find_index_sfinae_impl()>; template struct find_index_checked_impl : lib::size_constant { static_assert(I != not_found, "the specified type is not found."); static_assert(I != ambiguous, "the specified type is ambiguous."); }; template using find_index_checked = find_index_checked_impl()>; struct valueless_t {}; enum class Trait { TriviallyAvailable, Available, Unavailable }; template class IsTriviallyAvailable, template class IsAvailable> inline constexpr Trait trait() { return IsTriviallyAvailable::value ? Trait::TriviallyAvailable : IsAvailable::value ? Trait::Available : Trait::Unavailable; } #ifdef MPARK_CPP14_CONSTEXPR template inline constexpr Trait common_trait(Traits... traits_) { Trait result = Trait::TriviallyAvailable; lib::array traits = {{traits_...}}; for (std::size_t i = 0; i < sizeof...(Traits); ++i) { Trait t = traits[i]; if (static_cast(t) > static_cast(result)) { result = t; } } return result; } #else inline constexpr Trait common_trait_impl(Trait result) { return result; } template inline constexpr Trait common_trait_impl(Trait result, Trait t, Traits... ts) { return static_cast(t) > static_cast(result) ? common_trait_impl(t, ts...) : common_trait_impl(result, ts...); } template inline constexpr Trait common_trait(Traits... ts) { return common_trait_impl(Trait::TriviallyAvailable, ts...); } #endif template struct traits { static constexpr Trait copy_constructible_trait = common_trait(trait()...); static constexpr Trait move_constructible_trait = common_trait(trait()...); static constexpr Trait copy_assignable_trait = common_trait(copy_constructible_trait, trait()...); static constexpr Trait move_assignable_trait = common_trait(move_constructible_trait, trait()...); static constexpr Trait destructible_trait = common_trait(trait()...); }; namespace access { struct recursive_union { #ifdef MPARK_RETURN_TYPE_DEDUCTION template inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) { return lib::forward(v).head_; } template inline static constexpr auto &&get_alt(V &&v, in_place_index_t) { return get_alt(lib::forward(v).tail_, in_place_index_t{}); } #else template struct get_alt_impl { template inline constexpr AUTO_REFREF operator()(V &&v) const AUTO_REFREF_RETURN(get_alt_impl{}(lib::forward(v).tail_)) }; template struct get_alt_impl<0, Dummy> { template inline constexpr AUTO_REFREF operator()(V &&v) const AUTO_REFREF_RETURN(lib::forward(v).head_) }; template inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t) AUTO_REFREF_RETURN(get_alt_impl{}(lib::forward(v))) #endif }; struct base { template inline static constexpr AUTO_REFREF get_alt(V &&v) #ifdef _MSC_VER AUTO_REFREF_RETURN(recursive_union::get_alt( lib::forward(v).data_, in_place_index_t{})) #else AUTO_REFREF_RETURN(recursive_union::get_alt( data(lib::forward(v)), in_place_index_t{})) #endif }; struct variant { template inline static constexpr AUTO_REFREF get_alt(V &&v) AUTO_REFREF_RETURN(base::get_alt(lib::forward(v).impl_)) }; } // namespace access namespace visitation { #if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER) #define MPARK_VARIANT_SWITCH_VISIT #endif struct base { template using dispatch_result_t = decltype( lib::invoke(std::declval(), access::base::get_alt<0>(std::declval())...)); template struct expected { template inline static constexpr bool but_got() { return std::is_same::value; } }; template struct visit_return_type_check { static_assert( expected::template but_got(), "`visit` requires the visitor to have a single return type"); template inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor, Alts &&... alts) DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward(visitor), lib::forward(alts)...)) }; #ifdef MPARK_VARIANT_SWITCH_VISIT template struct dispatcher; template struct dispatcher { template MPARK_ALWAYS_INLINE static constexpr R dispatch( F &&, typename ITs::type &&..., Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } template MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } template MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t, F &&, Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } }; template struct dispatcher { template MPARK_ALWAYS_INLINE static constexpr R dispatch( F &&f, typename ITs::type &&... visited_vs) { using Expected = R; using Actual = decltype(lib::invoke( lib::forward(f), access::base::get_alt( lib::forward(visited_vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt( lib::forward(visited_vs))...); } template MPARK_ALWAYS_INLINE static constexpr R dispatch( F &&f, typename ITs::type &&... visited_vs, V &&v, Vs &&... vs) { #define MPARK_DISPATCH(I) \ dispatcher<(I < lib::decay_t::size()), \ R, \ ITs..., \ lib::indexed_type>:: \ template dispatch<0>(lib::forward(f), \ lib::forward(visited_vs)..., \ lib::forward(v), \ lib::forward(vs)...) #define MPARK_DEFAULT(I) \ dispatcher<(I < lib::decay_t::size()), R, ITs...>::template dispatch( \ lib::forward(f), \ lib::forward(visited_vs)..., \ lib::forward(v), \ lib::forward(vs)...) switch (v.index()) { case B + 0: return MPARK_DISPATCH(B + 0); case B + 1: return MPARK_DISPATCH(B + 1); case B + 2: return MPARK_DISPATCH(B + 2); case B + 3: return MPARK_DISPATCH(B + 3); case B + 4: return MPARK_DISPATCH(B + 4); case B + 5: return MPARK_DISPATCH(B + 5); case B + 6: return MPARK_DISPATCH(B + 6); case B + 7: return MPARK_DISPATCH(B + 7); case B + 8: return MPARK_DISPATCH(B + 8); case B + 9: return MPARK_DISPATCH(B + 9); case B + 10: return MPARK_DISPATCH(B + 10); case B + 11: return MPARK_DISPATCH(B + 11); case B + 12: return MPARK_DISPATCH(B + 12); case B + 13: return MPARK_DISPATCH(B + 13); case B + 14: return MPARK_DISPATCH(B + 14); case B + 15: return MPARK_DISPATCH(B + 15); case B + 16: return MPARK_DISPATCH(B + 16); case B + 17: return MPARK_DISPATCH(B + 17); case B + 18: return MPARK_DISPATCH(B + 18); case B + 19: return MPARK_DISPATCH(B + 19); case B + 20: return MPARK_DISPATCH(B + 20); case B + 21: return MPARK_DISPATCH(B + 21); case B + 22: return MPARK_DISPATCH(B + 22); case B + 23: return MPARK_DISPATCH(B + 23); case B + 24: return MPARK_DISPATCH(B + 24); case B + 25: return MPARK_DISPATCH(B + 25); case B + 26: return MPARK_DISPATCH(B + 26); case B + 27: return MPARK_DISPATCH(B + 27); case B + 28: return MPARK_DISPATCH(B + 28); case B + 29: return MPARK_DISPATCH(B + 29); case B + 30: return MPARK_DISPATCH(B + 30); case B + 31: return MPARK_DISPATCH(B + 31); default: return MPARK_DEFAULT(B + 32); } #undef MPARK_DEFAULT #undef MPARK_DISPATCH } template MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f, Vs &&... vs) { using Expected = R; using Actual = decltype( lib::invoke(lib::forward(f), access::base::get_alt(lib::forward(vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...); } template MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index, F &&f, V &&v, Vs &&... vs) { static_assert(lib::all<(lib::decay_t::size() == lib::decay_t::size())...>::value, "all of the variants must be the same size."); #define MPARK_DISPATCH_AT(I) \ dispatcher<(I < lib::decay_t::size()), R>::template dispatch_case( \ lib::forward(f), lib::forward(v), lib::forward(vs)...) #define MPARK_DEFAULT(I) \ dispatcher<(I < lib::decay_t::size()), R>::template dispatch_at( \ index, lib::forward(f), lib::forward(v), lib::forward(vs)...) switch (index) { case B + 0: return MPARK_DISPATCH_AT(B + 0); case B + 1: return MPARK_DISPATCH_AT(B + 1); case B + 2: return MPARK_DISPATCH_AT(B + 2); case B + 3: return MPARK_DISPATCH_AT(B + 3); case B + 4: return MPARK_DISPATCH_AT(B + 4); case B + 5: return MPARK_DISPATCH_AT(B + 5); case B + 6: return MPARK_DISPATCH_AT(B + 6); case B + 7: return MPARK_DISPATCH_AT(B + 7); case B + 8: return MPARK_DISPATCH_AT(B + 8); case B + 9: return MPARK_DISPATCH_AT(B + 9); case B + 10: return MPARK_DISPATCH_AT(B + 10); case B + 11: return MPARK_DISPATCH_AT(B + 11); case B + 12: return MPARK_DISPATCH_AT(B + 12); case B + 13: return MPARK_DISPATCH_AT(B + 13); case B + 14: return MPARK_DISPATCH_AT(B + 14); case B + 15: return MPARK_DISPATCH_AT(B + 15); case B + 16: return MPARK_DISPATCH_AT(B + 16); case B + 17: return MPARK_DISPATCH_AT(B + 17); case B + 18: return MPARK_DISPATCH_AT(B + 18); case B + 19: return MPARK_DISPATCH_AT(B + 19); case B + 20: return MPARK_DISPATCH_AT(B + 20); case B + 21: return MPARK_DISPATCH_AT(B + 21); case B + 22: return MPARK_DISPATCH_AT(B + 22); case B + 23: return MPARK_DISPATCH_AT(B + 23); case B + 24: return MPARK_DISPATCH_AT(B + 24); case B + 25: return MPARK_DISPATCH_AT(B + 25); case B + 26: return MPARK_DISPATCH_AT(B + 26); case B + 27: return MPARK_DISPATCH_AT(B + 27); case B + 28: return MPARK_DISPATCH_AT(B + 28); case B + 29: return MPARK_DISPATCH_AT(B + 29); case B + 30: return MPARK_DISPATCH_AT(B + 30); case B + 31: return MPARK_DISPATCH_AT(B + 31); default: return MPARK_DEFAULT(B + 32); } #undef MPARK_DEFAULT #undef MPARK_DISPATCH_AT } }; #else template inline static constexpr const T &at(const T &elem) noexcept { return elem; } template inline static constexpr const lib::remove_all_extents_t &at( const lib::array &elems, std::size_t i, Is... is) noexcept { return at(elems[i], is...); } template inline static constexpr lib::array, sizeof...(Fs) + 1> make_farray(F &&f, Fs &&... fs) { return {{lib::forward(f), lib::forward(fs)...}}; } template struct make_fmatrix_impl { template inline static constexpr dispatch_result_t dispatch( F &&f, Vs &&... vs) { using Expected = dispatch_result_t; using Actual = decltype(lib::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...); } #ifdef MPARK_RETURN_TYPE_DEDUCTION template inline static constexpr auto impl(lib::index_sequence) { return &dispatch; } template inline static constexpr auto impl(Is, lib::index_sequence, Ls... ls) { return make_farray(impl(lib::push_back_t{}, ls...)...); } #else template struct impl; template struct impl> { inline constexpr AUTO operator()() const AUTO_RETURN(&dispatch) }; template struct impl, Ls...> { inline constexpr AUTO operator()() const AUTO_RETURN( make_farray(impl, Ls...>{}()...)) }; #endif }; #ifdef MPARK_RETURN_TYPE_DEDUCTION template inline static constexpr auto make_fmatrix() { return make_fmatrix_impl::impl( lib::index_sequence<>{}, lib::make_index_sequence::size()>{}...); } #else template inline static constexpr AUTO make_fmatrix() AUTO_RETURN( typename make_fmatrix_impl::template impl< lib::index_sequence<>, lib::make_index_sequence::size()>...>{}()) #endif template struct make_fdiagonal_impl { template inline static constexpr dispatch_result_t dispatch( F &&f, Vs &&... vs) { using Expected = dispatch_result_t; using Actual = decltype( lib::invoke(lib::forward(f), access::base::get_alt(lib::forward(vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...); } template inline static constexpr AUTO impl(lib::index_sequence) AUTO_RETURN(make_farray(&dispatch...)) }; template inline static constexpr auto make_fdiagonal() -> decltype(make_fdiagonal_impl::impl( lib::make_index_sequence::size()>{})) { static_assert(lib::all<(lib::decay_t::size() == lib::decay_t::size())...>::value, "all of the variants must be the same size."); return make_fdiagonal_impl::impl( lib::make_index_sequence::size()>{}); } #endif }; #if !defined(MPARK_VARIANT_SWITCH_VISIT) && \ (!defined(_MSC_VER) || _MSC_VER >= 1910) template using fmatrix_t = decltype(base::make_fmatrix()); template struct fmatrix { static constexpr fmatrix_t value = base::make_fmatrix(); }; template constexpr fmatrix_t fmatrix::value; template using fdiagonal_t = decltype(base::make_fdiagonal()); template struct fdiagonal { static constexpr fdiagonal_t value = base::make_fdiagonal(); }; template constexpr fdiagonal_t fdiagonal::value; #endif struct alt { template inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, Vs &&... vs) #ifdef MPARK_VARIANT_SWITCH_VISIT DECLTYPE_AUTO_RETURN( base::dispatcher< true, base::dispatch_result_t(vs)))...>>:: template dispatch<0>(lib::forward(visitor), as_base(lib::forward(vs))...)) #elif !defined(_MSC_VER) || _MSC_VER >= 1910 DECLTYPE_AUTO_RETURN(base::at( fmatrix(vs)))...>::value, vs.index()...)(lib::forward(visitor), as_base(lib::forward(vs))...)) #else DECLTYPE_AUTO_RETURN(base::at( base::make_fmatrix(vs)))...>(), vs.index()...)(lib::forward(visitor), as_base(lib::forward(vs))...)) #endif template inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&... vs) #ifdef MPARK_VARIANT_SWITCH_VISIT DECLTYPE_AUTO_RETURN( base::dispatcher< true, base::dispatch_result_t(vs)))...>>:: template dispatch_at<0>(index, lib::forward(visitor), as_base(lib::forward(vs))...)) #elif !defined(_MSC_VER) || _MSC_VER >= 1910 DECLTYPE_AUTO_RETURN(base::at( fdiagonal(vs)))...>::value, index)(lib::forward(visitor), as_base(lib::forward(vs))...)) #else DECLTYPE_AUTO_RETURN(base::at( base::make_fdiagonal(vs)))...>(), index)(lib::forward(visitor), as_base(lib::forward(vs))...)) #endif }; struct variant { private: template struct visitor { template inline static constexpr bool does_not_handle() { return lib::is_invocable::value; } }; template struct visit_exhaustiveness_check { static_assert(visitor::template does_not_handle(), "`visit` requires the visitor to be exhaustive."); inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor, Values &&... values) DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward(visitor), lib::forward(values)...)) }; template struct value_visitor { Visitor &&visitor_; template inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const DECLTYPE_AUTO_RETURN( visit_exhaustiveness_check< Visitor, decltype((lib::forward(alts).value))...>:: invoke(lib::forward(visitor_), lib::forward(alts).value...)) }; template inline static constexpr AUTO make_value_visitor(Visitor &&visitor) AUTO_RETURN(value_visitor{lib::forward(visitor)}) public: template inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward(visitor), lib::forward(vs).impl_...)) template inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN( alt::visit_alt_at(index, lib::forward(visitor), lib::forward(vs).impl_...)) template inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN( visit_alt(make_value_visitor(lib::forward(visitor)), lib::forward(vs)...)) template inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index, Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN( visit_alt_at(index, make_value_visitor(lib::forward(visitor)), lib::forward(vs)...)) }; } // namespace visitation template struct alt { using value_type = T; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4244) #endif template inline explicit constexpr alt(in_place_t, Args &&... args) : value(lib::forward(args)...) {} #ifdef _MSC_VER #pragma warning(pop) #endif T value; }; template union recursive_union; template union recursive_union {}; #define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor) \ template \ union recursive_union { \ public: \ inline explicit constexpr recursive_union(valueless_t) noexcept \ : dummy_{} {} \ \ template \ inline explicit constexpr recursive_union(in_place_index_t<0>, \ Args &&... args) \ : head_(in_place_t{}, lib::forward(args)...) {} \ \ template \ inline explicit constexpr recursive_union(in_place_index_t, \ Args &&... args) \ : tail_(in_place_index_t{}, lib::forward(args)...) {} \ \ recursive_union(const recursive_union &) = default; \ recursive_union(recursive_union &&) = default; \ \ destructor \ \ recursive_union &operator=(const recursive_union &) = default; \ recursive_union &operator=(recursive_union &&) = default; \ \ private: \ char dummy_; \ alt head_; \ recursive_union tail_; \ \ friend struct access::recursive_union; \ } MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable, ~recursive_union() = default;); MPARK_VARIANT_RECURSIVE_UNION(Trait::Available, ~recursive_union() {}); MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable, ~recursive_union() = delete;); #undef MPARK_VARIANT_RECURSIVE_UNION template using index_t = typename std::conditional< sizeof...(Ts) < (std::numeric_limits::max)(), unsigned char, typename std::conditional< sizeof...(Ts) < (std::numeric_limits::max)(), unsigned short, unsigned int>::type >::type; template class base { public: inline explicit constexpr base(valueless_t tag) noexcept : data_(tag), index_(static_cast>(-1)) {} template inline explicit constexpr base(in_place_index_t, Args &&... args) : data_(in_place_index_t{}, lib::forward(args)...), index_(I) {} inline constexpr bool valueless_by_exception() const noexcept { return index_ == static_cast>(-1); } inline constexpr std::size_t index() const noexcept { return valueless_by_exception() ? variant_npos : index_; } protected: using data_t = recursive_union; friend inline constexpr base &as_base(base &b) { return b; } friend inline constexpr const base &as_base(const base &b) { return b; } friend inline constexpr base &&as_base(base &&b) { return lib::move(b); } friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); } friend inline constexpr data_t &data(base &b) { return b.data_; } friend inline constexpr const data_t &data(const base &b) { return b.data_; } friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; } friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; } inline static constexpr std::size_t size() { return sizeof...(Ts); } data_t data_; index_t index_; friend struct access::base; friend struct visitation::base; }; struct dtor { #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) #endif template inline void operator()(Alt &alt) const noexcept { alt.~Alt(); } #ifdef _MSC_VER #pragma warning(pop) #endif }; #if !defined(_MSC_VER) || _MSC_VER >= 1910 #define MPARK_INHERITING_CTOR(type, base) using base::base; #else #define MPARK_INHERITING_CTOR(type, base) \ template \ inline explicit constexpr type(Args &&... args) \ : base(lib::forward(args)...) {} #endif template class destructor; #define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \ template \ class destructor, destructible_trait> \ : public base { \ using super = base; \ \ public: \ MPARK_INHERITING_CTOR(destructor, super) \ using super::operator=; \ \ destructor(const destructor &) = default; \ destructor(destructor &&) = default; \ definition \ destructor &operator=(const destructor &) = default; \ destructor &operator=(destructor &&) = default; \ \ protected: \ destroy \ } MPARK_VARIANT_DESTRUCTOR( Trait::TriviallyAvailable, ~destructor() = default;, inline void destroy() noexcept { this->index_ = static_cast>(-1); }); MPARK_VARIANT_DESTRUCTOR( Trait::Available, ~destructor() { destroy(); }, inline void destroy() noexcept { if (!this->valueless_by_exception()) { visitation::alt::visit_alt(dtor{}, *this); } this->index_ = static_cast>(-1); }); MPARK_VARIANT_DESTRUCTOR( Trait::Unavailable, ~destructor() = delete;, inline void destroy() noexcept = delete;); #undef MPARK_VARIANT_DESTRUCTOR template class constructor : public destructor { using super = destructor; public: MPARK_INHERITING_CTOR(constructor, super) using super::operator=; protected: #ifndef MPARK_GENERIC_LAMBDAS struct ctor { template inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const { constructor::construct_alt(lhs_alt, lib::forward(rhs_alt).value); } }; #endif template inline static T &construct_alt(alt &a, Args &&... args) { auto *result = ::new (static_cast(lib::addressof(a))) alt(in_place_t{}, lib::forward(args)...); return result->value; } template inline static void generic_construct(constructor &lhs, Rhs &&rhs) { lhs.destroy(); if (!rhs.valueless_by_exception()) { visitation::alt::visit_alt_at( rhs.index(), #ifdef MPARK_GENERIC_LAMBDAS [](auto &lhs_alt, auto &&rhs_alt) { constructor::construct_alt( lhs_alt, lib::forward(rhs_alt).value); } #else ctor{} #endif , lhs, lib::forward(rhs)); lhs.index_ = rhs.index_; } } }; template class move_constructor; #define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \ template \ class move_constructor, move_constructible_trait> \ : public constructor> { \ using super = constructor>; \ \ public: \ MPARK_INHERITING_CTOR(move_constructor, super) \ using super::operator=; \ \ move_constructor(const move_constructor &) = default; \ definition \ ~move_constructor() = default; \ move_constructor &operator=(const move_constructor &) = default; \ move_constructor &operator=(move_constructor &&) = default; \ } MPARK_VARIANT_MOVE_CONSTRUCTOR( Trait::TriviallyAvailable, move_constructor(move_constructor &&that) = default;); MPARK_VARIANT_MOVE_CONSTRUCTOR( Trait::Available, move_constructor(move_constructor &&that) noexcept( lib::all::value...>::value) : move_constructor(valueless_t{}) { this->generic_construct(*this, lib::move(that)); }); MPARK_VARIANT_MOVE_CONSTRUCTOR( Trait::Unavailable, move_constructor(move_constructor &&) = delete;); #undef MPARK_VARIANT_MOVE_CONSTRUCTOR template class copy_constructor; #define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \ template \ class copy_constructor, copy_constructible_trait> \ : public move_constructor> { \ using super = move_constructor>; \ \ public: \ MPARK_INHERITING_CTOR(copy_constructor, super) \ using super::operator=; \ \ definition \ copy_constructor(copy_constructor &&) = default; \ ~copy_constructor() = default; \ copy_constructor &operator=(const copy_constructor &) = default; \ copy_constructor &operator=(copy_constructor &&) = default; \ } MPARK_VARIANT_COPY_CONSTRUCTOR( Trait::TriviallyAvailable, copy_constructor(const copy_constructor &that) = default;); MPARK_VARIANT_COPY_CONSTRUCTOR( Trait::Available, copy_constructor(const copy_constructor &that) : copy_constructor(valueless_t{}) { this->generic_construct(*this, that); }); MPARK_VARIANT_COPY_CONSTRUCTOR( Trait::Unavailable, copy_constructor(const copy_constructor &) = delete;); #undef MPARK_VARIANT_COPY_CONSTRUCTOR template class assignment : public copy_constructor { using super = copy_constructor; public: MPARK_INHERITING_CTOR(assignment, super) using super::operator=; template inline /* auto & */ auto emplace(Args &&... args) -> decltype(this->construct_alt(access::base::get_alt(*this), lib::forward(args)...)) { this->destroy(); auto &result = this->construct_alt(access::base::get_alt(*this), lib::forward(args)...); this->index_ = I; return result; } protected: #ifndef MPARK_GENERIC_LAMBDAS template struct assigner { template inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const { self->assign_alt(this_alt, lib::forward(that_alt).value); } assignment *self; }; #endif template inline void assign_alt(alt &a, Arg &&arg) { if (this->index() == I) { #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4244) #endif a.value = lib::forward(arg); #ifdef _MSC_VER #pragma warning(pop) #endif } else { struct { void operator()(std::true_type) const { this_->emplace(lib::forward(arg_)); } void operator()(std::false_type) const { this_->emplace(T(lib::forward(arg_))); } assignment *this_; Arg &&arg_; } impl{this, lib::forward(arg)}; impl(lib::bool_constant< std::is_nothrow_constructible::value || !std::is_nothrow_move_constructible::value>{}); } } template inline void generic_assign(That &&that) { if (this->valueless_by_exception() && that.valueless_by_exception()) { // do nothing. } else if (that.valueless_by_exception()) { this->destroy(); } else { visitation::alt::visit_alt_at( that.index(), #ifdef MPARK_GENERIC_LAMBDAS [this](auto &this_alt, auto &&that_alt) { this->assign_alt( this_alt, lib::forward(that_alt).value); } #else assigner{this} #endif , *this, lib::forward(that)); } } }; template class move_assignment; #define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \ template \ class move_assignment, move_assignable_trait> \ : public assignment> { \ using super = assignment>; \ \ public: \ MPARK_INHERITING_CTOR(move_assignment, super) \ using super::operator=; \ \ move_assignment(const move_assignment &) = default; \ move_assignment(move_assignment &&) = default; \ ~move_assignment() = default; \ move_assignment &operator=(const move_assignment &) = default; \ definition \ } MPARK_VARIANT_MOVE_ASSIGNMENT( Trait::TriviallyAvailable, move_assignment &operator=(move_assignment &&that) = default;); MPARK_VARIANT_MOVE_ASSIGNMENT( Trait::Available, move_assignment & operator=(move_assignment &&that) noexcept( lib::all<(std::is_nothrow_move_constructible::value && std::is_nothrow_move_assignable::value)...>::value) { this->generic_assign(lib::move(that)); return *this; }); MPARK_VARIANT_MOVE_ASSIGNMENT( Trait::Unavailable, move_assignment &operator=(move_assignment &&) = delete;); #undef MPARK_VARIANT_MOVE_ASSIGNMENT template class copy_assignment; #define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \ template \ class copy_assignment, copy_assignable_trait> \ : public move_assignment> { \ using super = move_assignment>; \ \ public: \ MPARK_INHERITING_CTOR(copy_assignment, super) \ using super::operator=; \ \ copy_assignment(const copy_assignment &) = default; \ copy_assignment(copy_assignment &&) = default; \ ~copy_assignment() = default; \ definition \ copy_assignment &operator=(copy_assignment &&) = default; \ } MPARK_VARIANT_COPY_ASSIGNMENT( Trait::TriviallyAvailable, copy_assignment &operator=(const copy_assignment &that) = default;); MPARK_VARIANT_COPY_ASSIGNMENT( Trait::Available, copy_assignment &operator=(const copy_assignment &that) { this->generic_assign(that); return *this; }); MPARK_VARIANT_COPY_ASSIGNMENT( Trait::Unavailable, copy_assignment &operator=(const copy_assignment &) = delete;); #undef MPARK_VARIANT_COPY_ASSIGNMENT template class impl : public copy_assignment> { using super = copy_assignment>; public: MPARK_INHERITING_CTOR(impl, super) using super::operator=; impl(const impl&) = default; impl(impl&&) = default; ~impl() = default; impl &operator=(const impl &) = default; impl &operator=(impl &&) = default; template inline void assign(Arg &&arg) { this->assign_alt(access::base::get_alt(*this), lib::forward(arg)); } inline void swap(impl &that) { if (this->valueless_by_exception() && that.valueless_by_exception()) { // do nothing. } else if (this->index() == that.index()) { visitation::alt::visit_alt_at(this->index(), #ifdef MPARK_GENERIC_LAMBDAS [](auto &this_alt, auto &that_alt) { using std::swap; swap(this_alt.value, that_alt.value); } #else swapper{} #endif , *this, that); } else { impl *lhs = this; impl *rhs = lib::addressof(that); if (lhs->move_nothrow() && !rhs->move_nothrow()) { std::swap(lhs, rhs); } impl tmp(lib::move(*rhs)); #ifdef MPARK_EXCEPTIONS // EXTENSION: When the move construction of `lhs` into `rhs` throws // and `tmp` is nothrow move constructible then we move `tmp` back // into `rhs` and provide the strong exception safety guarantee. try { this->generic_construct(*rhs, lib::move(*lhs)); } catch (...) { if (tmp.move_nothrow()) { this->generic_construct(*rhs, lib::move(tmp)); } throw; } #else this->generic_construct(*rhs, lib::move(*lhs)); #endif this->generic_construct(*lhs, lib::move(tmp)); } } private: #ifndef MPARK_GENERIC_LAMBDAS struct swapper { template inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const { using std::swap; swap(this_alt.value, that_alt.value); } }; #endif inline constexpr bool move_nothrow() const { return this->valueless_by_exception() || lib::array{ {std::is_nothrow_move_constructible::value...} }[this->index()]; } }; #undef MPARK_INHERITING_CTOR template struct is_non_narrowing_convertible { template static std::true_type test(T(&&)[1]); template static auto impl(int) -> decltype(test({std::declval()})); template static auto impl(...) -> std::false_type; static constexpr bool value = decltype(impl(0))::value; }; template ::value, typename = void> struct overload_leaf {}; template struct overload_leaf { using impl = lib::size_constant (*)(T); operator impl() const { return nullptr; }; }; template struct overload_leaf< Arg, I, T, true #if defined(__clang__) || !defined(__GNUC__) || __GNUC__ >= 5 , lib::enable_if_t< std::is_same, bool>::value ? std::is_same, bool>::value : is_non_narrowing_convertible::value> #endif > { using impl = lib::size_constant (*)(T); operator impl() const { return nullptr; }; }; template struct overload_impl { private: template struct impl; template struct impl> : overload_leaf... {}; public: using type = impl>; }; template using overload = typename overload_impl::type; template using best_match = lib::invoke_result_t, Arg>; template struct is_in_place_index : std::false_type {}; template struct is_in_place_index> : std::true_type {}; template struct is_in_place_type : std::false_type {}; template struct is_in_place_type> : std::true_type {}; } // detail template class variant { static_assert(0 < sizeof...(Ts), "variant must consist of at least one alternative."); static_assert(lib::all::value...>::value, "variant can not have an array type as an alternative."); static_assert(lib::all::value...>::value, "variant can not have a reference type as an alternative."); static_assert(lib::all::value...>::value, "variant can not have a void type as an alternative."); public: template < typename Front = lib::type_pack_element_t<0, Ts...>, lib::enable_if_t::value, int> = 0> inline constexpr variant() noexcept( std::is_nothrow_default_constructible::value) : impl_(in_place_index_t<0>{}) {} variant(const variant &) = default; variant(variant &&) = default; template < typename Arg, typename Decayed = lib::decay_t, lib::enable_if_t::value, int> = 0, lib::enable_if_t::value, int> = 0, lib::enable_if_t::value, int> = 0, std::size_t I = detail::best_match::value, typename T = lib::type_pack_element_t, lib::enable_if_t::value, int> = 0> inline constexpr variant(Arg &&arg) noexcept( std::is_nothrow_constructible::value) : impl_(in_place_index_t{}, lib::forward(arg)) {} template < std::size_t I, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t::value, int> = 0> inline explicit constexpr variant( in_place_index_t, Args &&... args) noexcept(std::is_nothrow_constructible::value) : impl_(in_place_index_t{}, lib::forward(args)...) {} template < std::size_t I, typename Up, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t &, Args...>::value, int> = 0> inline explicit constexpr variant( in_place_index_t, std::initializer_list il, Args &&... args) noexcept(std:: is_nothrow_constructible< T, std::initializer_list &, Args...>::value) : impl_(in_place_index_t{}, il, lib::forward(args)...) {} template < typename T, typename... Args, std::size_t I = detail::find_index_sfinae::value, lib::enable_if_t::value, int> = 0> inline explicit constexpr variant( in_place_type_t, Args &&... args) noexcept(std::is_nothrow_constructible::value) : impl_(in_place_index_t{}, lib::forward(args)...) {} template < typename T, typename Up, typename... Args, std::size_t I = detail::find_index_sfinae::value, lib::enable_if_t &, Args...>::value, int> = 0> inline explicit constexpr variant( in_place_type_t, std::initializer_list il, Args &&... args) noexcept(std:: is_nothrow_constructible< T, std::initializer_list &, Args...>::value) : impl_(in_place_index_t{}, il, lib::forward(args)...) {} ~variant() = default; variant &operator=(const variant &) = default; variant &operator=(variant &&) = default; template , variant>::value, int> = 0, std::size_t I = detail::best_match::value, typename T = lib::type_pack_element_t, lib::enable_if_t<(std::is_assignable::value && std::is_constructible::value), int> = 0> inline variant &operator=(Arg &&arg) noexcept( (std::is_nothrow_assignable::value && std::is_nothrow_constructible::value)) { impl_.template assign(lib::forward(arg)); return *this; } template < std::size_t I, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t::value, int> = 0> inline T &emplace(Args &&... args) { return impl_.template emplace(lib::forward(args)...); } template < std::size_t I, typename Up, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t &, Args...>::value, int> = 0> inline T &emplace(std::initializer_list il, Args &&... args) { return impl_.template emplace(il, lib::forward(args)...); } template < typename T, typename... Args, std::size_t I = detail::find_index_sfinae::value, lib::enable_if_t::value, int> = 0> inline T &emplace(Args &&... args) { return impl_.template emplace(lib::forward(args)...); } template < typename T, typename Up, typename... Args, std::size_t I = detail::find_index_sfinae::value, lib::enable_if_t &, Args...>::value, int> = 0> inline T &emplace(std::initializer_list il, Args &&... args) { return impl_.template emplace(il, lib::forward(args)...); } inline constexpr bool valueless_by_exception() const noexcept { return impl_.valueless_by_exception(); } inline constexpr std::size_t index() const noexcept { return impl_.index(); } template , Dummy>::value && lib::dependent_type, Dummy>::value)...>::value, int> = 0> inline void swap(variant &that) noexcept( lib::all<(std::is_nothrow_move_constructible::value && lib::is_nothrow_swappable::value)...>::value) { impl_.swap(that.impl_); } private: detail::impl impl_; friend struct detail::access::variant; friend struct detail::visitation::variant; }; template inline constexpr bool holds_alternative(const variant &v) noexcept { return v.index() == I; } template inline constexpr bool holds_alternative(const variant &v) noexcept { return holds_alternative::value>(v); } namespace detail { template struct generic_get_impl { constexpr generic_get_impl(int) noexcept {} constexpr AUTO_REFREF operator()(V &&v) const AUTO_REFREF_RETURN( access::variant::get_alt(lib::forward(v)).value) }; template inline constexpr AUTO_REFREF generic_get(V &&v) AUTO_REFREF_RETURN(generic_get_impl( holds_alternative(v) ? 0 : (throw_bad_variant_access(), 0))( lib::forward(v))) } // namespace detail template inline constexpr variant_alternative_t> &get( variant &v) { return detail::generic_get(v); } template inline constexpr variant_alternative_t> &&get( variant &&v) { return detail::generic_get(lib::move(v)); } template inline constexpr const variant_alternative_t> &get( const variant &v) { return detail::generic_get(v); } template inline constexpr const variant_alternative_t> &&get( const variant &&v) { return detail::generic_get(lib::move(v)); } template inline constexpr T &get(variant &v) { return get::value>(v); } template inline constexpr T &&get(variant &&v) { return get::value>(lib::move(v)); } template inline constexpr const T &get(const variant &v) { return get::value>(v); } template inline constexpr const T &&get(const variant &&v) { return get::value>(lib::move(v)); } namespace detail { template inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept AUTO_RETURN(v && holds_alternative(*v) ? lib::addressof(access::variant::get_alt(*v).value) : nullptr) } // namespace detail template inline constexpr lib::add_pointer_t>> get_if(variant *v) noexcept { return detail::generic_get_if(v); } template inline constexpr lib::add_pointer_t< const variant_alternative_t>> get_if(const variant *v) noexcept { return detail::generic_get_if(v); } template inline constexpr lib::add_pointer_t get_if(variant *v) noexcept { return get_if::value>(v); } template inline constexpr lib::add_pointer_t get_if(const variant *v) noexcept { return get_if::value>(v); } namespace detail { template struct convert_to_bool { template inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const { static_assert(std::is_convertible, bool>::value, "relational operators must return a type" " implicitly convertible to bool"); return lib::invoke( RelOp{}, lib::forward(lhs), lib::forward(rhs)); } }; } // namespace detail template inline constexpr bool operator==(const variant &lhs, const variant &rhs) { using detail::visitation::variant; using equal_to = detail::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.index() != rhs.index()) return false; if (lhs.valueless_by_exception()) return true; return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs); #else return lhs.index() == rhs.index() && (lhs.valueless_by_exception() || variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs)); #endif } template inline constexpr bool operator!=(const variant &lhs, const variant &rhs) { using detail::visitation::variant; using not_equal_to = detail::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.index() != rhs.index()) return true; if (lhs.valueless_by_exception()) return false; return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs); #else return lhs.index() != rhs.index() || (!lhs.valueless_by_exception() && variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs)); #endif } template inline constexpr bool operator<(const variant &lhs, const variant &rhs) { using detail::visitation::variant; using less = detail::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (rhs.valueless_by_exception()) return false; if (lhs.valueless_by_exception()) return true; if (lhs.index() < rhs.index()) return true; if (lhs.index() > rhs.index()) return false; return variant::visit_value_at(lhs.index(), less{}, lhs, rhs); #else return !rhs.valueless_by_exception() && (lhs.valueless_by_exception() || lhs.index() < rhs.index() || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), less{}, lhs, rhs))); #endif } template inline constexpr bool operator>(const variant &lhs, const variant &rhs) { using detail::visitation::variant; using greater = detail::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.valueless_by_exception()) return false; if (rhs.valueless_by_exception()) return true; if (lhs.index() > rhs.index()) return true; if (lhs.index() < rhs.index()) return false; return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs); #else return !lhs.valueless_by_exception() && (rhs.valueless_by_exception() || lhs.index() > rhs.index() || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), greater{}, lhs, rhs))); #endif } template inline constexpr bool operator<=(const variant &lhs, const variant &rhs) { using detail::visitation::variant; using less_equal = detail::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.valueless_by_exception()) return true; if (rhs.valueless_by_exception()) return false; if (lhs.index() < rhs.index()) return true; if (lhs.index() > rhs.index()) return false; return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs); #else return lhs.valueless_by_exception() || (!rhs.valueless_by_exception() && (lhs.index() < rhs.index() || (lhs.index() == rhs.index() && variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs)))); #endif } template inline constexpr bool operator>=(const variant &lhs, const variant &rhs) { using detail::visitation::variant; using greater_equal = detail::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (rhs.valueless_by_exception()) return true; if (lhs.valueless_by_exception()) return false; if (lhs.index() > rhs.index()) return true; if (lhs.index() < rhs.index()) return false; return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs); #else return rhs.valueless_by_exception() || (!lhs.valueless_by_exception() && (lhs.index() > rhs.index() || (lhs.index() == rhs.index() && variant::visit_value_at( lhs.index(), greater_equal{}, lhs, rhs)))); #endif } struct monostate {}; inline constexpr bool operator<(monostate, monostate) noexcept { return false; } inline constexpr bool operator>(monostate, monostate) noexcept { return false; } inline constexpr bool operator<=(monostate, monostate) noexcept { return true; } inline constexpr bool operator>=(monostate, monostate) noexcept { return true; } inline constexpr bool operator==(monostate, monostate) noexcept { return true; } inline constexpr bool operator!=(monostate, monostate) noexcept { return false; } #ifdef MPARK_CPP14_CONSTEXPR namespace detail { inline constexpr bool any(std::initializer_list bs) { for (bool b : bs) { if (b) { return true; } } return false; } } // namespace detail template inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) { return (!detail::any({vs.valueless_by_exception()...}) ? (void)0 : throw_bad_variant_access()), detail::visitation::variant::visit_value( lib::forward(visitor), lib::forward(vs)...); } #else namespace detail { template inline constexpr bool all_impl(const lib::array &bs, std::size_t idx) { return idx >= N || (bs[idx] && all_impl(bs, idx + 1)); } template inline constexpr bool all(const lib::array &bs) { return all_impl(bs, 0); } } // namespace detail template inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN( (detail::all( lib::array{{!vs.valueless_by_exception()...}}) ? (void)0 : throw_bad_variant_access()), detail::visitation::variant::visit_value(lib::forward(visitor), lib::forward(vs)...)) #endif template inline auto swap(variant &lhs, variant &rhs) noexcept(noexcept(lhs.swap(rhs))) -> decltype(lhs.swap(rhs)) { lhs.swap(rhs); } namespace detail { template using enabled_type = T; namespace hash { template constexpr bool meets_requirements() noexcept { return std::is_copy_constructible::value && std::is_move_constructible::value && lib::is_invocable_r::value; } template constexpr bool is_enabled() noexcept { using H = std::hash; return meets_requirements() && std::is_default_constructible::value && std::is_copy_assignable::value && std::is_move_assignable::value; } } // namespace hash } // namespace detail #undef AUTO #undef AUTO_RETURN #undef AUTO_REFREF #undef AUTO_REFREF_RETURN #undef DECLTYPE_AUTO #undef DECLTYPE_AUTO_RETURN } // namespace mpark namespace std { template struct hash, mpark::lib::enable_if_t>()...>::value>>> { using argument_type = mpark::variant; using result_type = std::size_t; inline result_type operator()(const argument_type &v) const { using mpark::detail::visitation::variant; std::size_t result = v.valueless_by_exception() ? 299792458 // Random value chosen by the universe upon creation : variant::visit_alt( #ifdef MPARK_GENERIC_LAMBDAS [](const auto &alt) { using alt_type = mpark::lib::decay_t; using value_type = mpark::lib::remove_const_t< typename alt_type::value_type>; return hash{}(alt.value); } #else hasher{} #endif , v); return hash_combine(result, hash{}(v.index())); } private: #ifndef MPARK_GENERIC_LAMBDAS struct hasher { template inline std::size_t operator()(const Alt &alt) const { using alt_type = mpark::lib::decay_t; using value_type = mpark::lib::remove_const_t; return hash{}(alt.value); } }; #endif static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) { return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2); } }; template <> struct hash { using argument_type = mpark::monostate; using result_type = std::size_t; inline result_type operator()(const argument_type &) const noexcept { return 66740831; // return a fundamentally attractive random value. } }; } // namespace std #endif // MPARK_VARIANT_HPP ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2020 Xinlei Wang, Yuxing Qiu, Stuart R. Slattery, Yu Fang, Minchen Li, Song-Chun Zhu, Yixin Zhu, Min Tang, Dinesh Manocha, Chenfanfu Jiang Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: Library/CMakeLists.txt ================================================ add_subdirectory(MnSystem) ================================================ FILE: Library/MnBase/Algorithm/MappingKernels.cuh ================================================ #ifndef MAPPING_KERNELS_CUH #define MAPPING_KERNELS_CUH #include #define PRINT_FIRST_INDICES 0 namespace mn { template __global__ void mark_boundary(int num, const EntryType* entries, MarkerType* marks, BinaryOp op) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } /// mark the tails of all segments marks[idx] = (idx != num - 1) ? op(entries[idx], entries[idx + 1]) : 1; } template __global__ void set_inverse(int num, const IndexType* map, IndexType* map_inv) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } auto map_idx = map[idx]; if(idx == 0 || map_idx != map[idx - 1]) { map_inv[map_idx] = idx; #if PRINT_FIRST_INDICES if(map_idx < 5) { printf("%d-th block starts at %d\n", map_idx, map_inv[map_idx]); } #endif } if(idx == num - 1) { map_inv[map_idx + 1] = num; } #if PRINT_FIRST_INDICES if(idx < 5) { printf("%d-th particle belongs to block %d\n", idx, map_idx); } #endif } template __global__ void exclusive_scan_inverse(CounterType num, const IndexType* map, IndexType* map_inv) { const uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } const auto map_idx = map[idx]; if(map_idx != map[idx + 1]) { map_inv[map_idx] = idx; } } template __global__ void map_inverse(int num, const IndexType* map, IndexType* map_inv) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } map_inv[map[idx]] = idx; } template __global__ void set_range_inverse(int count, const MappingType* to_packed_range_map, const MappingType* to_range_map, CounterType* num_packed_range, MappingType* range_ids, MappingType* range_left_bound, MappingType* range_right_bound) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= count) { return; } auto packed_range_idx = to_packed_range_map[idx]; auto range_idx = to_range_map[idx]; bool l_tag = idx == 0 || range_idx != to_range_map[idx - 1]; bool r_tag = idx == count - 1 || range_idx != to_range_map[idx + 1]; /// left bound if(l_tag) { range_left_bound[packed_range_idx] = idx; range_ids[packed_range_idx] = range_idx; #if PRINT_FIRST_INDICES if(packed_range_idx == 0) { printf("%d-th block st (%d): %d\n", packed_range_idx, range_idx, range_left_bound[packed_range_idx]); } #endif } /// right bound if(r_tag) { range_right_bound[packed_range_idx] = idx + 1; #if PRINT_FIRST_INDICES if(packed_range_idx == 0) { printf("%d-th block ed: %d\n", packed_range_idx, range_right_bound[packed_range_idx]); } #endif } if(idx == count - 1) { *num_packed_range = packed_range_idx + 1; } } }// namespace mn #endif ================================================ FILE: Library/MnBase/Algorithm/ParallelPatterns.cuh ================================================ #ifndef PARALLEL_PATTERNS_CUH #define PARALLEL_PATTERNS_CUH #include "MnSystem/Cuda/HostUtils.hpp" #include "MnSystem/Cuda/MemoryUtils.cuh" //#include //#include //#include #include #include //#include #define ENABLE_KEY_FUNCTIONS 0 namespace mn { /// sequence template void sequence(std::size_t count, T* array, T value = 0, cudaStream_t stream = cudaStreamDefault) { checkThrustErrors(thrust::sequence(thrust::cuda::par.on(stream), getDevicePtr(array), getDevicePtr(array) + count, value)); } /// reduece template T reduce(std::size_t count, T* array, T value = 0, cudaStream_t stream = cudaStreamDefault) { T result = (thrust::reduce(thrust::cuda::par.on(stream), getDevicePtr(array), getDevicePtr(array) + count, value)); return result; } /// fill template void fill_with(std::size_t count, T* array, T value, cudaStream_t stream = cudaStreamDefault) { checkThrustErrors(thrust::fill(thrust::cuda::par.on(stream), getDevicePtr(array), getDevicePtr(array) + count, value)); } template void fill_with(std::size_t count, AttribPort attribs, T value, cudaStream_t stream = cudaStreamDefault) { for(int i = 0; i < (int) Size; ++i) { fill_with(count, attribs[i], value, stream); } } /// set template __global__ void set_values(std::size_t num, T* array, ValueOp op) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } array[idx] = op(idx); } template void set_with(std::size_t count, T* array, ValueOp value_op) { cuda_launch({(count + 255) / 256, 256}, set_values, count, array, value_op); } template void set_with(std::size_t count, AttribPort attribs, ValueOp value_op) { for(int i = 0; i < Size; ++i) { set_with(count, attribs[i], value_op); } } #if ENABLE_KEY_FUNCTIONS template void sort_by_key(std::size_t count, const Key* keys_in, const Value* values_in, Key* keys_out, Value* values_out, cudaStream_t stream = cudaStreamDefault) { void* d_temp_storage = nullptr; std::size_t temp_storage_bytes = 0; checkCudaErrors(cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, keys_in, keys_out, values_in, values_out, count, 0, sizeof(Key) * 8, stream)); d_temp_storage = cudaMemBorrow(temp_storage_bytes);///< more managable memory consumption //printf("requires %lu bytes for sort_by_key\n", temp_storage_bytes); checkCudaErrors(cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, keys_in, keys_out, values_in, values_out, count, 0, sizeof(Key) * 8, stream)); } template void sort_by_key_bits(std::size_t count, const Key* keys_in, const Value* values_in, Key* keys_out, Value* values_out, int least_sig_bits = 12, int most_sig_bits = sizeof(Key) * 8, cudaStream_t stream = cudaStreamDefault) { void* d_temp_storage = nullptr; std::size_t temp_storage_bytes = 0; checkCudaErrors(cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, keys_in, keys_out, values_in, values_out, count, least_sig_bits, most_sig_bits, stream)); d_temp_storage = cudaMemBorrow(temp_storage_bytes);///< more managable memory consumption //printf("requires %lu bytes for sort_by_key\n", temp_storage_bytes); checkCudaErrors(cub::DeviceRadixSort::SortPairs(d_temp_storage, temp_storage_bytes, keys_in, keys_out, values_in, values_out, count, least_sig_bits, most_sig_bits, stream)); } /// exclusive scan template void exclusive_scan(std::size_t count, const TIn* input, TOut* output, BinaryOp&& op, cudaStream_t stream = cudaStreamDefault) { void* d_temp_storage = nullptr; std::size_t temp_storage_bytes = 0; checkCudaErrors(cub::DeviceScan::ExclusiveScan(d_temp_storage, temp_storage_bytes, input, output, std::forward(op), 0, count, stream)); d_temp_storage = cudaMemBorrow(temp_storage_bytes);///< more managable memory consumption //printf("requires %llu bytes for exclusive scan\n", (long long unsigned int)temp_storage_bytes); checkCudaErrors(cub::DeviceScan::ExclusiveScan(d_temp_storage, temp_storage_bytes, input, output, std::forward(op), 0, count, stream)); } /// count if template void select_if(std::size_t inputcount, const T* input, CounterType* outputcount, T* output, UnaryOp&& op, cudaStream_t stream = cudaStreamDefault) { void* d_temp_storage = nullptr; std::size_t temp_storage_bytes = 0; cub::DeviceSelect::If(d_temp_storage, temp_storage_bytes, input, output, outputcount, inputcount, std::forward(op), stream); d_temp_storage = cudaMemBorrow(temp_storage_bytes);///< more managable memory consumption //printf("requires %llu bytes for select if\n", (long long unsigned int)temp_storage_bytes); cub::DeviceSelect::If(d_temp_storage, temp_storage_bytes, input, output, outputcount, inputcount, std::forward(op), stream); } #endif }// namespace mn #endif ================================================ FILE: Library/MnBase/Algorithm/SortKernels.cuh ================================================ #ifndef SORT_KERNELS_CUH #define SORT_KERNELS_CUH #include namespace mn { template __global__ void gather_entry(int num, const AttribPort from, AttribPort to, const IndexType* prev) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } for(int i = 0; i < Size; ++i) { to[i][idx] = from[i][prev[idx]]; } } template __global__ void scatter_entry(int num, const AttribPort from, AttribPort to, const IndexType* _next) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } for(int i = 0; i < Size; ++i) { to[i][_next[idx]] = from[i][idx]; } } }// namespace mn #endif ================================================ FILE: Library/MnBase/Concurrency/Concurrency.h ================================================ #ifndef CONCURRENCY_H #define CONCURRENCY_H #include #include #include #include #include #include #include #include "MnBase/Meta/Optional.h" namespace mn { template inline auto really_async(F&& f, Ts&&... params) { return std::async(std::launch::async, std::forward(f), std::forward(params)...); } /// <> template class ThreadsafeQueue { private: mutable std::mutex mut; std::queue data_queue; std::condition_variable data_cond; public: ThreadsafeQueue() = default; ~ThreadsafeQueue() = default; ThreadsafeQueue(ThreadsafeQueue const& other) noexcept { std::lock_guard lk(other.mut); data_queue = other.data_queue; } ThreadsafeQueue(ThreadsafeQueue&& other) noexcept { std::lock_guard lk(other.mut); data_queue = std::move(other.data_queue); } ThreadsafeQueue& operator=(ThreadsafeQueue const& other) noexcept { if(&other != this) { std::lock_guard lk(other.mut); data_queue = other.data_queue; } return *this; } ThreadsafeQueue& operator=(ThreadsafeQueue&& other) noexcept { if(&other != this) { std::lock_guard lk(other.mut); data_queue = std::move(other.data_queue); } return *this; } void push(T new_value) { std::lock_guard lk(mut); data_queue.push(new_value); data_cond.notify_one(); } void wait_and_pop(T& value) { /// spinlock should be better std::unique_lock lk(mut); data_cond.wait(lk, [this] { return !data_queue.empty(); }); value = data_queue.front(); data_queue.pop(); } decltype(auto) wait_and_pop() { /// spinlock should be better std::unique_lock lk(mut); data_cond.wait(lk, [this] { return !data_queue.empty(); }); T value = data_queue.front(); data_queue.pop(); return value; } std::shared_ptr wait_and_pop_ptr() { std::unique_lock lk(mut); data_cond.wait(lk, [this] { return !data_queue.empty(); }); std::shared_ptr res(std::make_shared(data_queue.front())); data_queue.pop(); return res; } bool try_pop(T& value) { std::lock_guard lk(mut); if(data_queue.empty()) { return false; } value = data_queue.front(); data_queue.pop(); return true; } decltype(auto) try_pop() { std::lock_guard lk(mut); if(data_queue.empty()) { return optional {}; } optional value {data_queue.front()}; data_queue.pop(); return value; } std::shared_ptr try_pop_ptr() { std::lock_guard lk(mut); if(data_queue.empty()) { return std::shared_ptr(); } std::shared_ptr res(std::make_shared(data_queue.front())); data_queue.pop(); return res; } bool empty() const { std::lock_guard lk(mut); return data_queue.empty(); } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/DataStructure/Bvh/Bvh.cuh ================================================ #ifndef BVH_CUH #define BVH_CUH #include #include namespace mn {} #endif ================================================ FILE: Library/MnBase/DataStructure/FSM/FiniteStateMachine.h ================================================ #ifndef FINITE_STATE_MACHINE_H #define FINITE_STATE_MACHINE_H #include "MnBase/Meta/Optional.h" #include "MnBase/Meta/Polymorphism.h" #include "MnBase/Object/Property.h" namespace mn { /// CRTP template class FSM { private: StateVariant state; public: explicit FSM(StateVariant&& state) : state(state) {} template void dispatch(Event&& event) { Derived& self = static_cast(*this); auto newState = match(state)([this, &event](auto& s) -> optional { return self.onEvent(s, std::forward(event)); }); //[&](auto & s) ->optional { return self.onEvent(s, (event)); }); if(newState) { state = *std::move(newState); } } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/DataStructure/Hash/Hash.cuh ================================================ #ifndef HASH_CUH #define HASH_CUH #include "MnBase/AggregatedAttribs.cuh" #include "MnBase/Math/Bit/Bits.h" #include "MnSystem/Cuda/HostUtils.hpp" ///< For multiGPU_TEST Flag only #include "MnWorld/SimulationSetting.h" #define NO_OPT_HASH_TABLE 0 namespace mn { #if NO_OPT_HASH_TABLE template> # if MULTI_GPU_TEST///< HashTable on UM struct HashTable : public CudaAttribs { using Base = CudaAttribs; # else struct HashTable : public CudaAttribs { using Base = CudaAttribs; # endif #endif template> struct HashTable : public CudaAttribs { using Base = CudaAttribs; struct CudaPort { static_assert(sizeof(KeyType) == 8 || sizeof(KeyType) == 4, "Hashtable KeyType neither 64-bit or 32-bit!\n"); static_assert(sizeof(unsigned long long int) == 8 && sizeof(unsigned int) == 4, "\'unsigned long long int\' not 64-bit or \'unsigned int\' not 32-bit!\n"); using KT = std::conditional_t; using VT = ValueType; enum : uint64_t { HASH_KEY_OFFSET = 127 }; enum : KT { SENTINEL_VALUE = (KT) -1 }; std::size_t mask; KT* key_table;///< should be cuda compatible! VT* value_table; VT* entry_count; CudaPort(std::size_t mask, KeyType* key_table, ValueType* val_table, ValueType* entry_count) : mask {std::move(mask)} , key_table {static_cast(static_cast(key_table))} , value_table {static_cast(static_cast(val_table))} , entry_count {static_cast(static_cast(entry_count))} {} template __forceinline__ __device__ void insert(KeyT&& key) { KeyType hashkey = std::forward(key) & mask; KeyType ori; while((ori = key_table[hashkey]) != std::forward(key)) { if(ori == SENTINEL_VALUE) { ori = atomicCAS(key_table + hashkey, SENTINEL_VALUE, std::forward(key)); } if(key_table[hashkey] == std::forward(key)) {///< found if(ori == SENTINEL_VALUE) { value_table[hashkey] = atomicAdd(entry_count, 1);///< created a record } break; } hashkey += HASH_KEY_OFFSET;///< search next entry if(hashkey > mask) { hashkey = hashkey & mask; } }; } template __forceinline__ __device__ void insert(KeyT&& key, KeyT* records, RecoverKeyOp recover_op) { KeyType hashkey = std::forward(key) & mask; KeyType ori; while((ori = key_table[hashkey]) != std::forward(key)) { if(ori == SENTINEL_VALUE) { ori = atomicCAS(key_table + hashkey, SENTINEL_VALUE, std::forward(key)); } if(key_table[hashkey] == std::forward(key)) {///< found if(ori == SENTINEL_VALUE) { records[value_table[hashkey] = atomicAdd(entry_count, 1)] = recover_op(std::forward(key));///< created a record } break; } hashkey += HASH_KEY_OFFSET;///< search next entry if(hashkey > mask) { hashkey = hashkey & mask; } }; } template __forceinline__ __device__ auto query(KeyT&& key) const -> ValueType { KeyType hashkey = std::forward(key) & mask; KeyType ori; while((ori = key_table[hashkey]) != std::forward(key)) { if(ori == SENTINEL_VALUE) { return -1; } hashkey += HASH_KEY_OFFSET;///< search next entry if(hashkey > mask) { hashkey = hashkey & mask; } } return value_table[hashkey]; } }; std::size_t entry_size; std::size_t table_size; std::size_t mask; KeyType* key_table; ValueType* value_table; ValueType* entry_count; HashTable() = delete; template HashTable(Integer size) : Base {static_cast(1) << bit_count(estimate_table_size(size))} , entry_size {size} , table_size {static_cast(1) << bit_count(estimate_table_size(size))} { static_assert(std::is_integral::value, "Hashtable value type is not integer."); mask = table_size - 1; //printf("required size: %llu, actual alloced size: %llu, mask: %llx(%llu)\n", size, table_size, mask, mask); key_table = static_cast(static_cast(Base::_attribs[0])); value_table = static_cast(static_cast(Base::_attribs[1])); // #if MULTI_GPU_TEST // checkCudaErrors(cudaMallocManaged((void**)&entry_count, sizeof(int))); // #else // checkCudaErrors(cudaMalloc((void**)&entry_count, sizeof(int))); // #endif if(Opt == 1) { checkCudaErrors(cudaMallocManaged(static_cast(static_cast(&entry_count)), sizeof(int))); } else { checkCudaErrors(cudaMalloc(static_cast(static_cast(&entry_count)), sizeof(int))); } } ~HashTable() { cudaFree(entry_count); } auto estimate_table_size(std::size_t entry_size) const noexcept { return entry_size << 5; } // auto estimate_table_size(std::size_t entry_size) const noexcept { return entry_size << 5; } void clear_count() { cudaMemset(entry_count, 0, sizeof(ValueType)); } void clear_count(cudaStream_t stream) { cudaMemsetAsync(entry_count, 0, sizeof(ValueType), stream); } void clear() { cudaMemset(entry_count, 0, sizeof(ValueType)); cudaMemset(key_table, 0xff, sizeof(KeyType) * table_size); cudaMemset(value_table, 0xff, sizeof(ValueType) * table_size); } void clear(cudaStream_t stream) { cudaMemsetAsync(entry_count, 0, sizeof(ValueType), stream); cudaMemsetAsync(key_table, 0xff, sizeof(KeyType) * table_size, stream); cudaMemsetAsync(value_table, 0xff, sizeof(ValueType) * table_size, stream); } auto get_port() { return CudaPort {mask, key_table, value_table, entry_count}; } void retrieve_entry_count(ValueType* addr, cudaStream_t stream = cudaStreamDefault) { cudaMemcpyAsync(addr, entry_count, sizeof(ValueType), cudaMemcpyDeviceToHost, stream); } #if MULTI_GPU_TEST void um_advise_access_by_init(int dev_id) { # if DEBUG printf("[DEBUG] Setting HashTable_UM_Advice AccessBy for Dev %d\n", dev_id); # endif // checkCudaErrors(cudaMemAdvise(entry_count, sizeof(int), cudaMemAdviseSetAccessedBy, dev_id)); // checkCudaErrors(cudaMemAdvise(key_table, sizeof(KeyType) * table_size, cudaMemAdviseSetAccessedBy, dev_id)); // checkCudaErrors(cudaMemAdvise(value_table, sizeof(ValueType) * table_size, cudaMemAdviseSetAccessedBy, dev_id)); } void um_advise_preferred_loc_init(int dev_id = 0) { # if DEBUG printf("[DEBUG] Setting HashTable_UM_Advice PreferredLocation for Dev %d\n", dev_id); # endif // checkCudaErrors(cudaMemAdvise(entry_count, sizeof(int), cudaMemAdviseSetPreferredLocation, dev_id)); // checkCudaErrors(cudaMemAdvise(key_table, sizeof(KeyType) * table_size, cudaMemAdviseSetPreferredLocation, dev_id)); // checkCudaErrors(cudaMemAdvise(value_table, sizeof(ValueType) * table_size, cudaMemAdviseSetPreferredLocation, dev_id)); } #endif }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Geometry/GeometrySampler.h ================================================ #ifndef GEOMETRY_SAMPLER_H #define GEOMETRY_SAMPLER_H #include #include #include "MnBase/Math/Vec.h" namespace mn { template auto sample_uniform_box(T dx, vec minc, vec maxc) {///< cube std::vector> data; for(int i = minc[0]; i < maxc[0]; ++i) { for(int j = minc[1]; j < maxc[1]; ++j) { for(int k = minc[2]; k < maxc[2]; ++k) { std::array cell_center; cell_center[0] = (i) *dx; cell_center[1] = (j) *dx; cell_center[2] = (k) *dx; for(int ii = -1; ii <= 1; ii = ii + 2) { for(int jj = -1; jj <= 1; jj = jj + 2) { for(int kk = -1; kk <= 1; kk = kk + 2) { std::array particle; particle[0] = cell_center[0] + ii * 0.25 * dx; particle[1] = cell_center[1] + jj * 0.25 * dx; particle[2] = cell_center[2] + kk * 0.25 * dx; data.push_back(particle); } } } } } } return data; } }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Bit/Bits.h ================================================ #ifndef BITS_H #define BITS_H #include #include #include namespace mn { /** */ template constexpr Integer interleaved_bit_mask(int dim) noexcept { constexpr Integer UNIT {1}; auto totalBits = sizeof(Integer) << 3; Integer mask = 0; for(decltype(totalBits) curBit = 0; curBit < totalBits; curBit += dim) { mask |= (UNIT << curBit); } return mask; } /** * \fn uint32_t bit_length(uint32_t n) * \brief compute the count of significant digits of a number * \param N the number */ template constexpr Integer bit_length(Integer n) noexcept { if(n > 0) { return bit_length(n >> 1) + static_cast(1); } else { return 0; } } /** * \fn uint32_t bit_count(uint32_t N) * \brief compute the count of digits required to express integers in [0, *N) \param N the maximum of the range */ template constexpr Integer bit_count(Integer n) noexcept { if(n > 0) { return bit_length(n - 1); } else { return Integer {0}; } } /** * \fn uint32_t next_power_of_two(uint32_t i) * \brief compute the next power of two bigger than the number i * \param i the number */ constexpr uint32_t next_power_of_two(uint32_t i) noexcept { i--; i |= i >> 1; i |= i >> 2; i |= i >> 4; i |= i >> 8; i |= i >> 16; return i + 1; } template constexpr Integer binary_reverse(Integer data, char loc = sizeof(Integer) * 8 - 1) { if(data == 0) { return 0; } return ((data & 1) << loc) | binary_reverse(data >> 1, loc - 1); } template constexpr unsigned count_leading_zeros(Integer data) { unsigned res {0}; data = binary_reverse(data); if(data == 0) { return sizeof(Integer) * 8; } while((data & 1) == 0) { res++; data >>= 1; } return res; } constexpr int bit_pack(const uint64_t mask, const uint64_t data) { uint64_t slresult = 0; uint64_t& ulresult {slresult}; uint64_t uldata = data; int count = 0; ulresult = 0; uint64_t rmask = binary_reverse(mask); unsigned char lz {0}; while(rmask) { lz = count_leading_zeros(rmask); uldata >>= lz; ulresult <<= 1; count++; ulresult |= (uldata & 1); uldata >>= 1; rmask <<= lz + 1; } ulresult <<= 64 - count;// 64 means 64 bits ... maybe not use a constant 64 ... ulresult = binary_reverse(ulresult); return static_cast(slresult); } constexpr uint64_t bit_spread(const uint64_t mask, const int data) { uint64_t rmask = binary_reverse(mask); int dat = data; uint64_t result = 0; unsigned char lz {0}; while(rmask) { lz = count_leading_zeros(rmask) + 1; result = result << lz | (dat & 1); dat >>= 1, rmask <<= lz; } result = binary_reverse(result) >> count_leading_zeros(mask); return result; } }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Bit/SpatialEncoder.cuh ================================================ #ifndef SPATIAL_ENCODER_CUH #define SPATIAL_ENCODER_CUH #include #include #include "MnBase/AggregatedAttribs.cuh" #include "MnBase/Math/Bit/Bits.h" #define CHECK_ERRORS 0 namespace mn { __forceinline__ __device__ int bit_pack_64(const uint64_t mask, const uint64_t data) { union { uint64_t slresult; uint64_t ulresult; };//FIXME:Why this union? (Both members have the same type) uint64_t uldata = data; int count = 0; ulresult = 0; uint64_t rmask = __brevll(mask); unsigned char lz; while(rmask) { lz = __clzll(rmask); uldata >>= lz; ulresult <<= 1; count++; ulresult |= (uldata & 1); uldata >>= 1; rmask <<= lz + 1; } //NOLINTNEXTLINE(readability-magic-numbers) Define as constant? ulresult <<= 64 - count;// 64 means 64 bits ... maybe not use a constant 64 ... ulresult = __brevll(ulresult); return (int) slresult; } __forceinline__ __device__ uint64_t bit_spread_64(const uint64_t mask, const int data) { uint64_t rmask = __brevll(mask); int dat = data; uint64_t result = 0; unsigned char lz, offset = __clzll(rmask); while(rmask) { lz = __clzll(rmask) + 1; result = result << lz | (dat & 1); dat >>= 1, rmask <<= lz; } result = __brevll(result) >> __clzll(mask); return result; } template struct CoordToOffset { const CoordType dx_inv; std::array masks; CoordToOffset() = delete; __host__ CoordToOffset(CoordType dxinv, std::array masks) : dx_inv(std::move(dxinv)) { std::move(masks.begin(), masks.end(), masks); } template __forceinline__ __host__ __device__ auto operator()(int dim_no, In&& in) -> MaskType { static_assert(std::is_convertible::value, "CoordToOffset: coordinate type not convertible."); #if CHECK_ERRORS uint64_t res = bit_spread(masks[dim_no], static_cast(std::forward(in) * static_cast(dx_inv) + static_cast(0.5)) - 1); unsigned pcoordtrue = static_cast(std::forward(in) * static_cast(dx_inv) + static_cast(0.5)) - 1; unsigned pcoord = bit_pack(masks[dim_no], res); if(pcoord != pcoordtrue) { printf("particle's %d-th comp coord(%d)-offset(%u) mapping error!\n", dim_no, pcoordtrue, pcoord); } #endif return bit_spread_64(masks[dim_no], static_cast(std::forward(in) * static_cast(dx_inv) + static_cast(0.5)) - 1); } }; template struct OffsetToIndex { std::array masks; OffsetToIndex() = delete; __host__ OffsetToIndex(std::array masks) { std::move(masks.begin(), masks.end(), masks); } template __forceinline__ __host__ __device__ auto operator()(int dim_no, MT&& offset) -> IndexType { return bit_pack_64(masks[dim_no], std::forward(offset)); } }; template struct ComputeNeighborKey { static constexpr int DIM = SPGTraits::dimension; template __forceinline__ __host__ __device__ std::enable_if_t operator()(uint64_t key) { constexpr uint64_t NEIGHBOR_OFFSET = SPGTraits::neighbor_block_offset((neighborid & 2) != 0 ? 1 : 0, neighborid & 1); //printf("%d-th neighbor %llx\n", neighborid, NEIGHBOR_OFFSET); uint64_t x_result = ((key | SPGTraits::MXADD_Xmask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Xmask)) & ~SPGTraits::MXADD_Xmask; uint64_t y_result = ((key | SPGTraits::MXADD_Ymask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Ymask)) & ~SPGTraits::MXADD_Ymask; uint64_t w_result = ((key | SPGTraits::MXADD_Wmask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Wmask)) & ~SPGTraits::MXADD_Wmask; uint64_t result = x_result | y_result | w_result; return result >> SPGTraits::page_bits; } template __forceinline__ __host__ __device__ std::enable_if_t operator()(uint64_t key) { constexpr uint64_t NEIGHBOR_OFFSET = SPGTraits::neighbor_block_offset((neighborid & 4) != 0 ? 1 : 0, neighborid & 2 ? 1 : 0, neighborid & 1); //printf("%d-th neighbor %llx\n", neighborid, NEIGHBOR_OFFSET); uint64_t x_result = ((key | SPGTraits::MXADD_Xmask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Xmask)) & ~SPGTraits::MXADD_Xmask; uint64_t y_result = ((key | SPGTraits::MXADD_Ymask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Ymask)) & ~SPGTraits::MXADD_Ymask; uint64_t z_result = ((key | SPGTraits::MXADD_Zmask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Zmask)) & ~SPGTraits::MXADD_Zmask; uint64_t w_result = ((key | SPGTraits::MXADD_Wmask) + (NEIGHBOR_OFFSET & ~SPGTraits::MXADD_Wmask)) & ~SPGTraits::MXADD_Wmask; uint64_t result = x_result | y_result | z_result | w_result; return result >> SPGTraits::page_bits; } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/EigenDecomposition.cuh ================================================ #ifndef EIGEN_DECOMPOSITION_CUH #define EIGEN_DECOMPOSITION_CUH #include #include "MatrixUtils.h" namespace mn { namespace math { template __forceinline__ __device__ void fast_eigenvalues(const std::array& mat, std::array& lambda) { // 24 mults, 20 adds, 1 atan2, 1 sincos, 2 sqrts double m = (1.0 / 3) * (mat[0] + mat[4] + mat[8]); double a00 = mat[0] - m; double a11 = mat[4] - m; double a22 = mat[8] - m; double a12_sqr = mat[3] * mat[3]; double a13_sqr = mat[6] * mat[6]; double a23_sqr = mat[7] * mat[7]; double p = (1.0 / 6) * (a00 * a00 + a11 * a11 + a22 * a22 + 2 * (a12_sqr + a13_sqr + a23_sqr)); double q = 0.5 * (a00 * (a11 * a22 - a23_sqr) - a11 * a13_sqr - a22 * a12_sqr) + mat[3] * mat[6] * mat[7]; double sqrt_p = sqrt(p); double disc = p * p * p - q * q; double phi = (1.0 / 3) * atan2(sqrt(fmax(0.0, disc)), q); double c = cos(phi), s = sin(phi); double sqrt_p_cos = sqrt_p * c; double root_three_sqrt_p_sin = sqrt(3.0) * sqrt_p * s; lambda[0] = m + 2 * sqrt_p_cos; lambda[1] = m - sqrt_p_cos - root_three_sqrt_p_sin; lambda[2] = m - sqrt_p_cos + root_three_sqrt_p_sin; if(lambda[0] < lambda[1]) { swap(lambda + 0, lambda + 1); } if(lambda[1] < lambda[2]) { swap(lambda + 1, lambda + 2); } if(lambda[0] < lambda[1]) { swap(lambda + 0, lambda + 1); } } template __forceinline__ __device__ void fast_eigenvectors(const std::array& mat, std::array& lambda, std::array vecs) {///< column major assumed // 71 mults, 44 adds, 3 divs, 3 sqrts // flip if necessary so that first eigenvalue is the most different bool flipped = false; double lambda_flip[3] = {lambda[0], lambda[1], lambda[2]}; if(lambda[0] - lambda[1] < lambda[1] - lambda[2]) {// 2a swap(lambda_flip + 0, lambda_flip + 2); flipped = true; } // get first eigenvector std::array c1; std::array tmp; std::array dtmp; for(int i = 0; i < 9; ++i) { tmp[i] = mat[i] - (((i & 3) == 0) ? lambda_flip[0] : 0); } matrixCofactor3d(tmp, c1); // Eigen::Matrix3d::Index i; // T norm2 = c1.colwise().squaredNorm().maxCoeff(&i); // 3a + 12m+6a + // 9m+6a+1d+1s = 21m+15a+1d+1s int i; dtmp[0] = c1[0] * c1[0] + c1[1] * c1[1] + c1[2] * c1[2]; dtmp[1] = c1[3] * c1[3] + c1[4] * c1[4] + c1[5] * c1[5]; dtmp[2] = c1[6] * c1[6] + c1[7] * c1[7] + c1[8] * c1[8]; double norm2 = dtmp[0]; i = 0; if(dtmp[1] > norm2) { norm2 = dtmp[1]; i = 1; } if(dtmp[2] > norm2) { norm2 = dtmp[2]; i = 2; } // Eigen::Vector3d v1; std::array v1; if(sgn(norm2) > 0) { double one_over_sqrt = 1.0 / sqrt(norm2); for(int c = 0; c < 3; ++c) { v1[c] = c1[i * 3 + c] * one_over_sqrt; } } else { v1[0] = 1; v1[1] = 0; v1[2] = 0; } // form basis for orthogonal complement to v1, and reduce A to this space orthogonalVector(v1, tmp); dtmp[3] = tmp[0] * tmp[0] + tmp[1] * tmp[1] + tmp[2] * tmp[2]; dtmp[3] = 1.0 / sqrt(dtmp[3]); for(int i = 0; i < 3; ++i) { tmp[i] *= dtmp[3]; } std::array v1_orthogonal = {tmp[0], tmp[1], tmp[2]};// 6m+2a+1d+1s (tweak: 5m+1a+1d+1s) // Eigen::Matrix other_v; std::array other_v;///< 3x2 other_v[0] = v1_orthogonal[0]; other_v[1] = v1_orthogonal[1]; other_v[2] = v1_orthogonal[2]; // other_v.col(1) = v1.cross(v1_orthogonal); // 6m+3a (tweak: 4m+1a) cross(v1, v1_orthogonal, tmp); other_v[3] = tmp[0]; other_v[4] = tmp[1]; other_v[5] = tmp[2]; // 2x3 tmp[0] = other_v[0] * mat[0] + other_v[1] * mat[1] + other_v[2] * mat[2]; tmp[1] = other_v[3] * mat[0] + other_v[4] * mat[1] + other_v[5] * mat[2]; tmp[2] = other_v[0] * mat[3] + other_v[1] * mat[4] + other_v[2] * mat[5]; tmp[3] = other_v[3] * mat[3] + other_v[4] * mat[4] + other_v[5] * mat[5]; tmp[4] = other_v[0] * mat[6] + other_v[1] * mat[7] + other_v[2] * mat[8]; tmp[5] = other_v[3] * mat[6] + other_v[4] * mat[7] + other_v[5] * mat[8]; std::array A_reduced = {tmp[0] * other_v[0] + tmp[2] * other_v[1] + tmp[4] * other_v[2], tmp[1] * other_v[0] + tmp[3] * other_v[1] + tmp[5] * other_v[2], tmp[0] * other_v[3] + tmp[2] * other_v[4] + tmp[4] * other_v[5], tmp[1] * other_v[3] + tmp[3] * other_v[4] + tmp[5] * other_v[5]}; // Eigen::Matrix2d A_reduced = other_v.transpose() * A_Sym * other_v; // // 21m+12a (tweak: 18m+9a) // find third eigenvector from A_reduced, and fill in second via cross product // Eigen::Matrix2d c3; std::array c3; // computeCofactorMtr<2>(A_reduced - lambda_flip(2) * // Eigen::Matrix2d::Identity(), c3); for(int i = 0; i < 4; ++i) { tmp[i] = A_reduced[i] - (((i % 3) == 0) ? lambda_flip[2] : 0); } matrixCofactor2d(tmp, c3); int j; // norm2 = c3.colwise().squaredNorm().maxCoeff(&j); // 3a + 12m+6a + // 9m+6a+1d+1s = 21m+15a+1d+1s dtmp[0] = c3[0] * c3[0] + c3[1] * c3[1]; dtmp[1] = c3[2] * c3[2] + c3[3] * c3[3]; norm2 = dtmp[0]; j = 0; if(dtmp[1] > norm2) { norm2 = dtmp[1]; j = 1; } std::array v3; if(sgn(norm2) > 0) { double one_over_sqrt = (T) 1 / sqrt(norm2); v3[0] = (other_v[0] * c3[j * 2 + 0] + other_v[3] * c3[j * 2 + 1]) * one_over_sqrt; v3[1] = (other_v[1] * c3[j * 2 + 0] + other_v[4] * c3[j * 2 + 1]) * one_over_sqrt; v3[2] = (other_v[2] * c3[j * 2 + 0] + other_v[5] * c3[j * 2 + 1]) * one_over_sqrt; } else { v3[0] = other_v[0]; v3[1] = other_v[1]; v3[2] = other_v[2]; } std::array v2; cross(v3, v1, v2); // v2 = v3.cross(v1); // 6m+3a // finish if(flipped) { vector_copy(1., v3, vecs + 0); vector_copy(1., v2, vecs + 3); vector_copy(-1., v1, vecs + 6); } else { vector_copy(1., v1, vecs + 0); vector_copy(1., v2, vecs + 3); vector_copy(1., v3, vecs + 6); } } template __forceinline__ __device__ void make_pd_3d(const std::array& mat, T eps = 1e-6) { std::array vals; std::array vecs; std::array VT; std::array tmp; fast_eigenvalues(mat, vals); fast_eigenvectors(mat, vals, vecs); for(int i = 0; i < 3; ++i) { vals[i] = vals[i] > eps ? vals[i] : eps;///< clamp } matrix_transpose_3d(vecs, VT); matrix_diagonal_matrix_multiplication_3d(vecs, vals, tmp); matrix_matrix_multiplication_3d(tmp, VT, mat); } template __forceinline__ __device__ void make_pd_2d(const std::array& mat, T eps = 1e-6) { // based on // http://www.math.harvard.edu/archive/21b_fall_04/exhibits/2dmatrices/ const double a = mat[0]; const double b = (mat[2] + mat[1]) / 2.0; const double d = mat[3]; double b2 = b * b; const double d_big = a * d - b2; const double t_div_2 = (a + d) / 2.0; const double sqrt_tt_4d = sqrt(t_div_2 * t_div_2 - d_big); const double l2 = t_div_2 - sqrt_tt_4d; if(l2 < 0.0) { const double l1 = t_div_2 + sqrt_tt_4d; if(l1 <= 0.0) { mat[0] = mat[1] = mat[2] = mat[3] = 0.0; } else { if(b2 == 0.0) { mat[0] = l1; mat[1] = mat[2] = mat[3] = 0.0f; } else { const double L1md = l1 - d; const double L1md_div_L1 = L1md / l1; mat[0] = L1md_div_L1 * L1md; mat[1] = mat[2] = b * L1md_div_L1; mat[3] = b2 / l1; } } } } }// namespace math }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/Givens.cuh ================================================ /** Givens rotation */ #ifndef GIVENS_CUH #define GIVENS_CUH #include #include #define ENABLE_COLUMN_ROTATION 0 #define ENABLE_ADDITIONAL_GIVENS_FUNCTION 0 namespace mn { //Stable calculation from https://en.wikipedia.org/wiki/Givens_rotation namespace math { /** Class for givens rotation. Row rotation G*A corresponds to something like c -s 0 ( s c 0 ) A 0 0 1 Column rotation A G' corresponds to something like c -s 0 A ( s c 0 ) 0 0 1 c and s are always computed so that ( c -s ) ( a ) = ( * ) s c b ( 0 ) Assume rowi struct GivensRotation { public: int rowi; int rowk; T c; T s; T r; __forceinline__ __host__ __device__ GivensRotation(int rowi_in, int rowk_in) : rowi(rowi_in) , rowk(rowk_in) , c(1) , s(0) {} __forceinline__ __host__ __device__ GivensRotation(T a, T b, int rowi_in, int rowk_in) : rowi(rowi_in) , rowk(rowk_in) { compute(a, b); } __forceinline__ __host__ __device__ ~GivensRotation() {} __forceinline__ __host__ __device__ void set_identity() { c = 1; s = 0; } __forceinline__ __host__ __device__ void transpose_in_place() { s = -s; } /** Compute c and s from a and b so that ( c -s ) ( a ) = ( * ) s c b ( 0 ) */ template __forceinline__ __host__ __device__ std::enable_if_t, std::is_same>::value, void> compute(const TT a, const TT b) { if(b == 0.0){ if(a == 0.0){ c = static_cast(1.0); }else{ c = std::copysign(static_cast(1.0), a); } s = 0.0; r = std::abs(a); }else if(a == 0.0){ c = 0.0; s = std::copysign(static_cast(1.0), b); r = std::abs(b); }else if (std::abs(a) > std::abs(b)){ const TT t = b / a; const TT u = std::copysign(sqrt(static_cast(1.0) + t * t), a); c = static_cast(1.0) / u; s = -c * t; r = a * u; }else{ const TT t = a / b; const TT u = std::copysign(sqrt(static_cast(1.0) + t * t), b); s = -static_cast(1.0) / u; c = t / u; r = b * u; } } /** Fill the R with the entries of this rotation */ template __forceinline__ __host__ __device__ void fill(std::array& a) const { for(int i = 0; i < Dim * Dim; ++i) { a[i] = 0; } for(int i = 0; i < Dim * Dim; i += Dim + 1) { a[i] = 1; } a[rowi + rowi * Dim] = c; a[rowk + rowi * Dim] = s; a[rowi + rowk * Dim] = -s; a[rowk + rowk * Dim] = c; } /** This function does something like Q^T A -> A [ c -s 0 ] [ s c 0 ] A -> A [ 0 0 1 ] It only affects row i and row k of A. */ template __forceinline__ __host__ __device__ void mat_rotation(std::array& a) const { for(int d = 0; d < Dim; d++) { T1 tau1 = a[rowi + d * Dim]; T1 tau2 = a[rowk + d * Dim]; a[rowi + d * Dim] = c * tau1 - s * tau2; a[rowk + d * Dim] = s * tau1 + c * tau2; } } template __forceinline__ void vec_rotation(std::array& a) const { T1 tau1 = a[rowi]; T1 tau2 = a[rowk]; a[rowi] = c * tau1 - s * tau2; a[rowk] = s * tau1 + c * tau2; } #if ENABLE_COLUMN_ROTATION /** This function does something like A Q -> A [ c s 0 ] A [-s c 0 ] -> A [ 0 0 1 ] It only affects column i and column k of A. */ template ZIRAN_FORCE_INLINE void column_rotation(MatrixType& a) const { for(int j = 0; j < a.rows(); j++) { T tau1 = a(j, rowi); T tau2 = a(j, rowk); a(j, rowi) = c * tau1 - s * tau2; a(j, rowk) = s * tau1 + c * tau2; } //not type safe :/ } #endif /** Multiply givens must be for same row and column **/ __forceinline__ __host__ __device__ void operator*=(const GivensRotation& a) { T new_c = c * a.c - s * a.s; T new_s = s * a.c + c * a.s; c = new_c; s = new_s; } /** Multiply givens must be for same row and column **/ __forceinline__ __host__ __device__ GivensRotation operator*(const GivensRotation& a) const { GivensRotation r(*this); r *= a; return r; } }; #if ENABLE_ADDITIONAL_GIVENS_FUNCTION /** \brief zero chasing the 3X3 matrix to bidiagonal form original form of H: x x 0 x x x 0 0 x after zero chase: x x 0 0 x x 0 0 x */ template inline ZIRAN_FORCE_INLINE void zero_chase(Matrix& h, Matrix& u, Matrix& v) { /** Reduce H to of form x x + 0 x x 0 0 x */ GivensRotation r1(h(0, 0), h(1, 0), 0, 1); /** Reduce H to of form x x 0 0 x x 0 + x Can calculate r2 without multiplying by r1 since both entries are in first two rows thus no need to divide by sqrt(a^2+b^2) */ GivensRotation r2(1, 2); if(h(1, 0) != 0) { r2.compute(h(0, 0) * h(0, 1) + h(1, 0) * h(1, 1), h(0, 0) * h(0, 2) + h(1, 0) * h(1, 2)); } else { r2.compute(h(0, 1), h(0, 2)); } r1.row_rotation(h); /* GivensRotation r2(h(0, 1), h(0, 2), 1, 2); */ r2.column_rotation(h); r2.column_rotation(v); /** Reduce H to of form x x 0 0 x x 0 0 x */ GivensRotation r3(h(1, 1), h(2, 1), 1, 2); r3.row_rotation(h); // Save this till end for better cache coherency // r1.row_rotation(u_transpose); // r3.row_rotation(u_transpose); r1.column_rotation(u); r3.column_rotation(u); } /** \brief make a 3X3 matrix to upper bidiagonal form original form of H: x x x x x x x x x after zero chase: x x 0 0 x x 0 0 x */ template inline ZIRAN_FORCE_INLINE void make_upper_bidiag(Matrix& h, Matrix& u, Matrix& v) { u = Matrix::Identity(); v = Matrix::Identity(); /** Reduce H to of form x x x x x x 0 x x */ GivensRotation r(h(1, 0), h(2, 0), 1, 2); r.row_rotation(h); // r.row_rotation(u_transpose); r.column_rotation(u); // zero_chase(h, u_transpose, v); zero_chase(h, u, v); } /** \brief make a 3X3 matrix to lambda shape original form of H: x x x * x x x * x x x after : * x 0 0 * x x 0 * x 0 x */ template inline ZIRAN_FORCE_INLINE void make_lambda_shape(Matrix& h, Matrix& u, Matrix& v) { u = Matrix::Identity(); v = Matrix::Identity(); /** Reduce H to of form * x x 0 * x x x * x x x */ GivensRotation r1(h(0, 1), h(0, 2), 1, 2); r1.column_rotation(h); r1.column_rotation(v); /** Reduce H to of form * x x 0 * x x 0 * x x x */ r1.compute_unconventional(h(1, 2), h(2, 2)); r1.row_rotation(h); r1.column_rotation(u); /** Reduce H to of form * x x 0 * x x 0 * x 0 x */ GivensRotation r2(h(2, 0), h(2, 1), 0, 1); r2.column_rotation(h); r2.column_rotation(v); /** Reduce H to of form * x 0 0 * x x 0 * x 0 x */ r2.compute_unconventional(h(0, 1), h(1, 1)); r2.row_rotation(h); r2.column_rotation(u); } #endif }// namespace math }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/MatrixKernels.cuh ================================================ #ifndef MATRIX_KERNELS_CUH #define MATRIX_KERNELS_CUH #include #include "MnBase/AggregatedAttribs.cuh" namespace mn { template __global__ std::enable_if_t set_identity(int num, AttribPort mat) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } for(int c = 0; c < 9; ++c) { mat[c][idx] = (c & 0x3) != 0 ? 0 : 1; } } template __global__ std::enable_if_t set_identity(int num, AttribPort mat) { uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= num) { return; } mat[0][idx] = 1; mat[1][idx] = 0; mat[2][idx] = 0; mat[3][idx] = 1; } }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/MatrixUtils.h ================================================ #ifndef MATRIX_UTILS_H #define MATRIX_UTILS_H #include "Utility.h" namespace mn { //TODO: When we have c++20 use std::span // matrix multiplification // return mat1 * diagnal_matrix * mat2^T // input diag: only have diagnal entries template constexpr void matmul_mat_diag_mat_t_2d(std::array& out, const std::array& mat1, const std::array& diag, const std::array& mat2_t) { out[0] = mat1[0] * diag[0] * mat2_t[0] + mat1[2] * diag[1] * mat2_t[2]; out[1] = mat1[1] * diag[0] * mat2_t[0] + mat1[3] * diag[1] * mat2_t[2]; out[2] = mat1[0] * diag[0] * mat2_t[1] + mat1[2] * diag[1] * mat2_t[3]; out[3] = mat1[1] * diag[0] * mat2_t[1] + mat1[3] * diag[1] * mat2_t[3]; } /* matrix indexes mat1 | diag | mat2^T 0 3 6 | 0 | 0 1 2 1 4 7 | 1 | 3 4 5 2 5 8 | 2 | 6 7 8 */ template constexpr void matmul_mat_diag_mat_t_3d(std::array& out, const std::array& mat1, const std::array& diag, const std::array& mat2_t) { out[0] = mat1[0] * diag[0] * mat2_t[0] + mat1[3] * diag[1] * mat2_t[3] + mat1[6] * diag[2] * mat2_t[6]; out[1] = mat1[1] * diag[0] * mat2_t[0] + mat1[4] * diag[1] * mat2_t[3] + mat1[7] * diag[2] * mat2_t[6]; out[2] = mat1[2] * diag[0] * mat2_t[0] + mat1[5] * diag[1] * mat2_t[3] + mat1[8] * diag[2] * mat2_t[6]; out[3] = mat1[0] * diag[0] * mat2_t[1] + mat1[3] * diag[1] * mat2_t[4] + mat1[6] * diag[2] * mat2_t[7]; out[4] = mat1[1] * diag[0] * mat2_t[1] + mat1[4] * diag[1] * mat2_t[4] + mat1[7] * diag[2] * mat2_t[7]; out[5] = mat1[2] * diag[0] * mat2_t[1] + mat1[5] * diag[1] * mat2_t[4] + mat1[8] * diag[2] * mat2_t[7]; out[6] = mat1[0] * diag[0] * mat2_t[2] + mat1[3] * diag[1] * mat2_t[5] + mat1[6] * diag[2] * mat2_t[8]; out[7] = mat1[1] * diag[0] * mat2_t[2] + mat1[4] * diag[1] * mat2_t[5] + mat1[7] * diag[2] * mat2_t[8]; out[8] = mat1[2] * diag[0] * mat2_t[2] + mat1[5] * diag[1] * mat2_t[5] + mat1[8] * diag[2] * mat2_t[8]; } /* out = mat^T * vec */ template constexpr void mat_t_mul_vec_3d(std::array& out, const std::array& mat, const std::array& vec) { out[0] = mat[0] * vec[0] + mat[1] * vec[1] + mat[2] * vec[2]; out[1] = mat[3] * vec[0] + mat[4] * vec[1] + mat[5] * vec[2]; out[2] = mat[6] * vec[0] + mat[7] * vec[1] + mat[8] * vec[2]; } /* out = a x b (cross product) * = {[a]_x} * b */ template constexpr void vec_cross_mul_vec_3d(std::array& out, const std::array& a, const std::array& b) { out[0] = a[1] * b[2] + a[2] * b[1]; out[1] = a[2] * b[0] + a[0] * b[2]; out[2] = a[0] * b[1] + a[1] * b[0]; } template constexpr void matrix_cofactor_2d(const std::array& x, std::array& cof) { cof[0] = x[3]; cof[1] = -x[2]; cof[2] = -x[1]; cof[3] = x[0]; } template constexpr void matrix_cofactor_3d(const std::array& x, std::array& cof) { T cofactor11 = x[4] * x[8] - x[7] * x[5]; T cofactor12 = x[7] * x[2] - x[1] * x[8]; T cofactor13 = x[1] * x[5] - x[4] * x[2]; cof[0] = cofactor11; cof[1] = cofactor12; cof[2] = cofactor13; cof[3] = x[6] * x[5] - x[3] * x[8]; cof[4] = x[0] * x[8] - x[6] * x[2]; cof[5] = x[3] * x[2] - x[0] * x[5]; cof[6] = x[3] * x[7] - x[6] * x[4]; cof[7] = x[6] * x[1] - x[0] * x[7]; cof[8] = x[0] * x[4] - x[3] * x[1]; } #if 0 template constexpr void matrix_inverse(const std::array& x, std::array& inv) { T cofactor11 = x[4] * x[8] - x[7] * x[5]; T cofactor12 = x[7] * x[2] - x[1] * x[8]; T cofactor13 = x[1] * x[5] - x[4] * x[2]; T determinant = x[0] * cofactor11 + x[3] * cofactor12 + x[6] * cofactor13; T s = 1 / determinant; inv[0] = s * cofactor11; inv[1] = s * cofactor12; inv[2] = s * cofactor13; inv[3] = s * x[6] * x[5] - s * x[3] * x[8]; inv[4] = s * x[0] * x[8] - s * x[6] * x[2]; inv[5] = s * x[3] * x[2] - s * x[0] * x[5]; inv[6] = s * x[3] * x[7] - s * x[6] * x[4]; inv[7] = s * x[6] * x[1] - s * x[0] * x[7]; inv[8] = s * x[0] * x[4] - s * x[3] * x[1]; } #endif template constexpr T matrix_determinant_3d(const std::array& x) { return x[0] * (x[4] * x[8] - x[7] * x[5]) + x[3] * (x[7] * x[2] - x[1] * x[8]) + x[6] * (x[1] * x[5] - x[4] * x[2]); } template constexpr T matrix_determinant_2d(const std::array& x) { return x[0] * x[3] - x[1] * x[2]; } template constexpr void matrix_transpose_3d(const std::array& x, std::array& transpose) { transpose[0] = x[0]; transpose[1] = x[3]; transpose[2] = x[6]; transpose[3] = x[1]; transpose[4] = x[4]; transpose[5] = x[7]; transpose[6] = x[2]; transpose[7] = x[5]; transpose[8] = x[8]; } template constexpr void matrix_transpose_2d(const std::array& x, std::array& transpose) { transpose[0] = x[0]; transpose[1] = x[2]; transpose[2] = x[1]; transpose[3] = x[3]; } template constexpr T matrix_trace_3d(const std::array& x) { return x[0] + x[4] + x[8]; } template constexpr T matrix_trace_2d(const std::array& x) { return x[0] + x[3]; } template constexpr void matrix_matrix_multiplication_3d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0] + a[3] * b[1] + a[6] * b[2]; c[1] = a[1] * b[0] + a[4] * b[1] + a[7] * b[2]; c[2] = a[2] * b[0] + a[5] * b[1] + a[8] * b[2]; c[3] = a[0] * b[3] + a[3] * b[4] + a[6] * b[5]; c[4] = a[1] * b[3] + a[4] * b[4] + a[7] * b[5]; c[5] = a[2] * b[3] + a[5] * b[4] + a[8] * b[5]; c[6] = a[0] * b[6] + a[3] * b[7] + a[6] * b[8]; c[7] = a[1] * b[6] + a[4] * b[7] + a[7] * b[8]; c[8] = a[2] * b[6] + a[5] * b[7] + a[8] * b[8]; } template constexpr void matrix_matrix_multiplication_2d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0] + a[2] * b[1]; c[1] = a[1] * b[0] + a[3] * b[1]; c[2] = a[0] * b[2] + a[2] * b[3]; c[3] = a[1] * b[2] + a[3] * b[3]; } template constexpr void matrix_diagonal_matrix_multiplication_3d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0]; c[1] = a[1] * b[0]; c[2] = a[2] * b[0]; c[3] = a[3] * b[1]; c[4] = a[4] * b[1]; c[5] = a[5] * b[1]; c[6] = a[6] * b[2]; c[7] = a[7] * b[2]; c[8] = a[8] * b[2]; } template constexpr void matrix_diagonal_matrix_multiplication_2d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0]; c[1] = a[1] * b[0]; c[2] = a[2] * b[1]; c[3] = a[3] * b[1]; } template constexpr void matrix_transpose_matrix_multiplication_3d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; c[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2]; c[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2]; c[3] = a[0] * b[3] + a[1] * b[4] + a[2] * b[5]; c[4] = a[3] * b[3] + a[4] * b[4] + a[5] * b[5]; c[5] = a[6] * b[3] + a[7] * b[4] + a[8] * b[5]; c[6] = a[0] * b[6] + a[1] * b[7] + a[2] * b[8]; c[7] = a[3] * b[6] + a[4] * b[7] + a[5] * b[8]; c[8] = a[6] * b[6] + a[7] * b[7] + a[8] * b[8]; } template constexpr void matrix_transpose_matrix_multiplication_2d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0] + a[1] * b[1]; c[1] = a[2] * b[0] + a[3] * b[1]; c[2] = a[0] * b[2] + a[1] * b[3]; c[3] = a[2] * b[2] + a[3] * b[3]; } template constexpr void matrix_vector_multiplication_3d(const std::array& x, const std::array& v, std::array& result) { result[0] = x[0] * v[0] + x[3] * v[1] + x[6] * v[2]; result[1] = x[1] * v[0] + x[4] * v[1] + x[7] * v[2]; result[2] = x[2] * v[0] + x[5] * v[1] + x[8] * v[2]; } template constexpr void matrix_vector_multiplication_2d(const std::array& x, const std::array& v, std::array& result) { result[0] = x[0] * v[0] + x[2] * v[1]; result[1] = x[1] * v[0] + x[3] * v[1]; } template constexpr void vector_matrix_multiplication_3d(const std::array& v, const std::array& x, std::array& result) { result[0] = x[0] * v[0] + x[1] * v[1] + x[2] * v[2]; result[1] = x[3] * v[0] + x[4] * v[1] + x[5] * v[2]; result[2] = x[6] * v[0] + x[7] * v[1] + x[8] * v[2]; } template constexpr void vector_matrix_multiplication_2d(const std::array& v, const std::array& x, std::array& result) { result[0] = x[0] * v[0] + x[1] * v[1]; result[1] = x[2] * v[0] + x[3] * v[1]; } template constexpr void matrix_matrix_transpose_multiplication_3d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0] + a[3] * b[3] + a[6] * b[6]; c[1] = a[1] * b[0] + a[4] * b[3] + a[7] * b[6]; c[2] = a[2] * b[0] + a[5] * b[3] + a[8] * b[6]; c[3] = a[0] * b[1] + a[3] * b[4] + a[6] * b[7]; c[4] = a[1] * b[1] + a[4] * b[4] + a[7] * b[7]; c[5] = a[2] * b[1] + a[5] * b[4] + a[8] * b[7]; c[6] = a[0] * b[2] + a[3] * b[5] + a[6] * b[8]; c[7] = a[1] * b[2] + a[4] * b[5] + a[7] * b[8]; c[8] = a[2] * b[2] + a[5] * b[5] + a[8] * b[8]; } template constexpr void matrix_matrix_transpose_multiplication_2d(const std::array& a, const std::array& b, std::array& c) { c[0] = a[0] * b[0] + a[2] * b[2]; c[1] = a[1] * b[0] + a[3] * b[2]; c[2] = a[0] * b[1] + a[2] * b[3]; c[3] = a[1] * b[1] + a[3] * b[3]; } template constexpr void matrix_matrix_tranpose_multiplication_3d(const std::array& in, std::array& out) { out[0] = in[0] * in[0] + in[3] * in[3] + in[6] * in[6]; out[1] = in[1] * in[0] + in[4] * in[3] + in[7] * in[6]; out[2] = in[2] * in[0] + in[5] * in[3] + in[8] * in[6]; out[3] = in[0] * in[1] + in[3] * in[4] + in[6] * in[7]; out[4] = in[1] * in[1] + in[4] * in[4] + in[7] * in[7]; out[5] = in[2] * in[1] + in[5] * in[4] + in[8] * in[7]; out[6] = in[0] * in[2] + in[3] * in[5] + in[6] * in[8]; out[7] = in[1] * in[2] + in[4] * in[5] + in[7] * in[8]; out[8] = in[2] * in[2] + in[5] * in[5] + in[8] * in[8]; } template constexpr void matrix_deviatoric_3d(const std::array& in, std::array& out) { //FIXME: Rewrote this, cause for some reasons sometimes precision errors occured (Probably compiler bug) //T trace_in_div_d = (in[0] + in[4] + in[8]) / static_cast(3.0); out[0] = in[0] * static_cast(2.0 / 3.0) - (in[4] + in[8]) / static_cast(3.0); out[1] = in[1]; out[2] = in[2]; out[3] = in[3]; out[4] = in[4] * static_cast(2.0 / 3.0) - (in[0] + in[8]) / static_cast(3.0); out[5] = in[5]; out[6] = in[6]; out[7] = in[7]; out[8] = in[8] * static_cast(2.0 / 3.0) - (in[0] + in[4]) / static_cast(3.0); } #if 0 template constexpr T vector_max_component(const std::array& x) { T tmp = x[0]; if (tmp < x[1]){ tmp = x[1]; } if (tmp < x[2]){ tmp = x[2]; } return tmp; } template constexpr T vector_magnitude(const std::array& x) { return sqrtf(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]); } template constexpr void vector_component_max(const std::array& x, const std::array& y, std::array& result) { for (int v = 0; v < 3; ++v){ result[v] = x[v] > y[v] ? x[v] : y[v]; } } template constexpr T signed_distance_oriented_box(const std::array& point, const std::array& box_center, const std::array& edges, const std::array& rotation) { std::array tmp; for (int v = 0; v < 3; ++v){ tmp[v] = point[v] - box_center[v]; } std::array diff; matrixvectormultiplication(rotation, tmp, diff); std::array phi; for (int v = 0; v < 3; ++v){ phi[v] = (diff[v] > 0 ? diff[v] : -diff[v]) - edges[v] * .5f; } if (phi[0] <= 0 && phi[1] <= 0 && phi[2] <= 0){ return vector_max_component(phi); }else { T zeros[3] = {0, 0, 0}; vector_component_max(phi, zeros, diff); return vector_magnitude(diff); } } template constexpr void quat_cast(std::array& mat, std::array& quat) { std::array, 3> m; for (int i = 0; i < 3; ++i){ for (int j = 0; j < 3; ++j){ m[i][j] = mat[i + j * 3]; } } T four_x_squared_minus1 = m[0][0] - m[1][1] - m[2][2]; T four_y_squared_minus1 = m[1][1] - m[0][0] - m[2][2]; T four_z_squared_minus1 = m[2][2] - m[0][0] - m[1][1]; T four_w_squared_minus1 = m[0][0] + m[1][1] + m[2][2]; int biggest_index = 0; T four_biggest_squared_minus1 = four_w_squared_minus1; if (four_x_squared_minus1 > four_biggest_squared_minus1) { four_biggest_squared_minus1 = four_x_squared_minus1; biggest_index = 1; } if (four_y_squared_minus1 > four_biggest_squared_minus1) { four_biggest_squared_minus1 = four_y_squared_minus1; biggest_index = 2; } if (four_z_squared_minus1 > four_biggest_squared_minus1) { four_biggest_squared_minus1 = four_z_squared_minus1; biggest_index = 3; } T biggest_val = sqrt(four_biggest_squared_minus1 + static_cast(1)) * static_cast(0.5); T mult = static_cast(0.25) / biggest_val; switch (biggest_index) { case 0: quat[0] = biggest_val; quat[1] = (m[1][2] - m[2][1]) * mult; quat[2] = (m[2][0] - m[0][2]) * mult; quat[3] = (m[0][1] - m[1][0]) * mult; break; case 1: quat[0] = (m[1][2] - m[2][1]) * mult; quat[1] = biggest_val; quat[2] = (m[0][1] + m[1][0]) * mult; quat[3] = (m[2][0] + m[0][2]) * mult; break; case 2: quat[0] = (m[2][0] - m[0][2]) * mult; quat[1] = (m[0][1] + m[1][0]) * mult; quat[2] = biggest_val; quat[3] = (m[1][2] + m[2][1]) * mult; break; case 3: quat[0] = (m[0][1] - m[1][0]) * mult; quat[1] = (m[2][0] + m[0][2]) * mult; quat[2] = (m[1][2] + m[2][1]) * mult; quat[3] = biggest_val; break; default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity. //assert(false); break; } } template constexpr void mat3_cast(const std::array& q, std::array& mat) { T qxx(q[0] * q[0]); T qyy(q[1] * q[1]); T qzz(q[2] * q[2]); T qxz(q[0] * q[2]); T qxy(q[0] * q[1]); T qyz(q[1] * q[2]); T qwx(q[3] * q[0]); T qwy(q[3] * q[1]); T qwz(q[3] * q[2]); /*Result[0][0] = */ mat[0] = T(1) - T(2) * (qyy + qzz); /*Result[0][1] = */ mat[3] = T(2) * (qxy + qwz); /*Result[0][2] = */ mat[6] = T(2) * (qxz - qwy); /*Result[1][0] = */ mat[1] = T(2) * (qxy - qwz); /*Result[1][1] = */ mat[4] = T(1) - T(2) * (qxx + qzz); /*Result[1][2] = */ mat[7] = T(2) * (qyz + qwx); /*Result[2][0] = */ mat[2] = T(2) * (qxz + qwy); /*Result[2][1] = */ mat[5] = T(2) * (qyz - qwx); /*Result[2][2] = */ mat[8] = T(1) - T(2) * (qxx + qyy); } #endif }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/Utility.h ================================================ #ifndef MATRIX_UTILITY_H #define MATRIX_UTILITY_H namespace mn { namespace math { template constexpr int sgn(const T n) noexcept { return n < -1e-10 ? -1 : n > 1e-10; // return n < 0.0 ? -1 : n > 0.0; // return n == 0 ? 0 : 1; } template constexpr T abs(const T n) noexcept { return n > 0 ? n : -n; } template constexpr void orthogonal_vector(const std::array& input, std::array& output) noexcept { T abs_x = abs(input[0]); T abs_y = abs(input[1]); T abs_z = abs(input[2]); if(abs_x < abs_y) { if(abs_x < abs_z) { output[0] = 0; output[1] = input[2]; output[2] = -input[1]; } else { output[0] = input[1]; output[1] = -input[0]; output[2] = 0; } } else { if(abs_y < abs_z) { output[0] = -input[2]; output[1] = 0; output[2] = input[0]; } else { output[0] = input[1]; output[1] = -input[0]; output[2] = 0; } } } template constexpr void cross(const std::array& operand1, const std::array& operand2, std::array& output) { const T& x1 = operand1[0]; const T& y1 = operand1[1]; const T& z1 = operand1[2]; const T& x2 = operand2[0]; const T& y2 = operand2[1]; const T& z2 = operand2[2]; output[0] = y1 * z2 - y2 * z1; output[1] = x2 * z1 - x1 * z2; output[2] = x1 * y2 - x2 * y1; } template constexpr void vector_copy(const T scale, const std::array& v, std::array& res) { res[0] = v[0] * scale; res[1] = v[1] * scale; res[2] = v[2] * scale; } }// namespace math }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/qr.cuh ================================================ #ifndef QR_CUH #define QR_CUH #include "Givens.cuh" namespace mn { namespace math { /** \brief 2x2 polar decomposition. \param[in] A matrix. \param[out] R Robustly a rotation matrix in givens form \param[out] S_Sym Symmetric. Whole matrix is stored Whole matrix S is stored since its faster to calculate due to simd vectorization Polar guarantees negative sign is on the small magnitude singular value. S is guaranteed to be the closest one to identity. R is guaranteed to be the closest rotation to A. */ template __forceinline__ __host__ __device__ void polar_decomposition(const std::array& a, GivensRotation& r, std::array& s) { double x[2] = {a[0] + a[3], a[1] - a[2]}; double denominator = sqrt(x[0] * x[0] + x[1] * x[1]); r.c = (T) 1; r.s = (T) 0; if(denominator != 0) { /* No need to use a tolerance here because x(0) and x(1) always have smaller magnitude then denominator, therefore overflow never happens. */ r.c = x[0] / denominator; r.s = -x[1] / denominator; } for(int i = 0; i < 4; ++i) { s[i] = a[i]; } r.template mat_rotation<2, T>(s); } /** \brief 2x2 polar decomposition. \param[in] A matrix. \param[out] R Robustly a rotation matrix. \param[out] S_Sym Symmetric. Whole matrix is stored Whole matrix S is stored since its faster to calculate due to simd vectorization Polar guarantees negative sign is on the small magnitude singular value. S is guaranteed to be the closest one to identity. R is guaranteed to be the closest rotation to A. */ template __forceinline__ __host__ __device__ void polar_decomposition(const std::array& a, const std::array& r, const std::array& s) { GivensRotation rotation(0, 1); polar_decomposition(a, rotation, s); rotation.fill<2>(R); } }// namespace math }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Matrix/svd.cuh ================================================ #ifndef SVD3_CUH #define SVD3_CUH #include #include "Utility.h" #include "math.h"// CUDA math library #include "qr.cuh" #define gone 1065353216 #define gsine_pi_over_eight 1053028117 #define gcosine_pi_over_eight 1064076127 #define gone_half 0.5f #define gsmall_number 1.e-12f #define gtiny_number 1.e-20f #define gfour_gamma_squared 5.8284273147583007813f namespace mn { namespace math { union un { float f; unsigned int ui; }; template __forceinline__ __device__ void svd( T a11, T a12, T a13, T a21, T a22, T a23, T a31, T a32, T a33,// input A T& u11, T& u12, T& u13, T& u21, T& u22, T& u23, T& u31, T& u32, T& u33,// output U T& s11, //float &s12, float &s13, float &s21, T& s22, //float &s23, float &s31, float &s32, T& s33,// output S T& v11, T& v12, T& v13, T& v21, T& v22, T& v23, T& v31, T& v32, T& v33// output V ) { un s_a11; un s_a21; un s_a31; un s_a12; un s_a22; un s_a32; un s_a13; un s_a23; un s_a33; un s_u11; un s_u21; un s_u31; un s_u12; un s_u22; un s_u32; un s_u13; un s_u23; un s_u33; un s_v11; un s_v21; un s_v31; un s_v12; un s_v22; un s_v32; un s_v13; un s_v23; un s_v33; un s_c; un s_s; un s_ch; un s_sh; un s_tmp1; un s_tmp2; un s_tmp3; un s_tmp4; un s_tmp5; un s_s11; un s_s21; un s_s31; un s_s22; un s_s32; un s_s33; un s_qvs; un s_qvvx; un s_qvvy; un s_qvvz; s_a11.f = a11; s_a12.f = a12; s_a13.f = a13; s_a21.f = a21; s_a22.f = a22; s_a23.f = a23; s_a31.f = a31; s_a32.f = a32; s_a33.f = a33; //########################################################### // Compute normal equations matrix //########################################################### s_s11.f = s_a11.f * s_a11.f; s_tmp1.f = s_a21.f * s_a21.f; s_s11.f = __fadd_rn(s_tmp1.f, s_s11.f); s_tmp1.f = s_a31.f * s_a31.f; s_s11.f = __fadd_rn(s_tmp1.f, s_s11.f); s_s21.f = s_a12.f * s_a11.f; s_tmp1.f = s_a22.f * s_a21.f; s_s21.f = __fadd_rn(s_tmp1.f, s_s21.f); s_tmp1.f = s_a32.f * s_a31.f; s_s21.f = __fadd_rn(s_tmp1.f, s_s21.f); s_s31.f = s_a13.f * s_a11.f; s_tmp1.f = s_a23.f * s_a21.f; s_s31.f = __fadd_rn(s_tmp1.f, s_s31.f); s_tmp1.f = s_a33.f * s_a31.f; s_s31.f = __fadd_rn(s_tmp1.f, s_s31.f); s_s22.f = s_a12.f * s_a12.f; s_tmp1.f = s_a22.f * s_a22.f; s_s22.f = __fadd_rn(s_tmp1.f, s_s22.f); s_tmp1.f = s_a32.f * s_a32.f; s_s22.f = __fadd_rn(s_tmp1.f, s_s22.f); s_s32.f = s_a13.f * s_a12.f; s_tmp1.f = s_a23.f * s_a22.f; s_s32.f = __fadd_rn(s_tmp1.f, s_s32.f); s_tmp1.f = s_a33.f * s_a32.f; s_s32.f = __fadd_rn(s_tmp1.f, s_s32.f); s_s33.f = s_a13.f * s_a13.f; s_tmp1.f = s_a23.f * s_a23.f; s_s33.f = __fadd_rn(s_tmp1.f, s_s33.f); s_tmp1.f = s_a33.f * s_a33.f; s_s33.f = __fadd_rn(s_tmp1.f, s_s33.f); s_qvs.f = 1.f; s_qvvx.f = 0.f; s_qvvy.f = 0.f; s_qvvz.f = 0.f; //########################################################### // Solve symmetric eigenproblem using Jacobi iteration //########################################################### for(int i = 0; i < 4; i++) { s_sh.f = s_s21.f * 0.5f; s_tmp5.f = __fsub_rn(s_s11.f, s_s22.f); s_tmp2.f = s_sh.f * s_sh.f; s_tmp1.ui = (s_tmp2.f >= gtiny_number) ? 0xffffffff : 0; s_sh.ui = s_tmp1.ui & s_sh.ui; s_ch.ui = s_tmp1.ui & s_tmp5.ui; s_tmp2.ui = ~s_tmp1.ui & gone; s_ch.ui = s_ch.ui | s_tmp2.ui; s_tmp1.f = s_sh.f * s_sh.f; s_tmp2.f = s_ch.f * s_ch.f; s_tmp3.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp4.f = __frsqrt_rn(s_tmp3.f); s_sh.f = s_tmp4.f * s_sh.f; s_ch.f = s_tmp4.f * s_ch.f; s_tmp1.f = gfour_gamma_squared * s_tmp1.f; s_tmp1.ui = (s_tmp2.f <= s_tmp1.f) ? 0xffffffff : 0; s_tmp2.ui = gsine_pi_over_eight & s_tmp1.ui; s_sh.ui = ~s_tmp1.ui & s_sh.ui; s_sh.ui = s_sh.ui | s_tmp2.ui; s_tmp2.ui = gcosine_pi_over_eight & s_tmp1.ui; s_ch.ui = ~s_tmp1.ui & s_ch.ui; s_ch.ui = s_ch.ui | s_tmp2.ui; s_tmp1.f = s_sh.f * s_sh.f; s_tmp2.f = s_ch.f * s_ch.f; s_c.f = __fsub_rn(s_tmp2.f, s_tmp1.f); s_s.f = s_ch.f * s_sh.f; s_s.f = __fadd_rn(s_s.f, s_s.f); #ifdef DEBUG_JACOBI_CONJUGATE printf("GPU s %.20g, c %.20g, sh %.20g, ch %.20g\n", s_s.f, s_c.f, s_sh.f, s_ch.f); #endif //########################################################### // Perform the actual Givens conjugation //########################################################### s_tmp3.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_s33.f = s_s33.f * s_tmp3.f; s_s31.f = s_s31.f * s_tmp3.f; s_s32.f = s_s32.f * s_tmp3.f; s_s33.f = s_s33.f * s_tmp3.f; s_tmp1.f = s_s.f * s_s31.f; s_tmp2.f = s_s.f * s_s32.f; s_s31.f = s_c.f * s_s31.f; s_s32.f = s_c.f * s_s32.f; s_s31.f = __fadd_rn(s_tmp2.f, s_s31.f); s_s32.f = __fsub_rn(s_s32.f, s_tmp1.f); s_tmp2.f = s_s.f * s_s.f; s_tmp1.f = s_s22.f * s_tmp2.f; s_tmp3.f = s_s11.f * s_tmp2.f; s_tmp4.f = s_c.f * s_c.f; s_s11.f = s_s11.f * s_tmp4.f; s_s22.f = s_s22.f * s_tmp4.f; s_s11.f = __fadd_rn(s_s11.f, s_tmp1.f); s_s22.f = __fadd_rn(s_s22.f, s_tmp3.f); s_tmp4.f = __fsub_rn(s_tmp4.f, s_tmp2.f); s_tmp2.f = __fadd_rn(s_s21.f, s_s21.f); s_s21.f = s_s21.f * s_tmp4.f; s_tmp4.f = s_c.f * s_s.f; s_tmp2.f = s_tmp2.f * s_tmp4.f; s_tmp5.f = s_tmp5.f * s_tmp4.f; s_s11.f = __fadd_rn(s_s11.f, s_tmp2.f); s_s21.f = __fsub_rn(s_s21.f, s_tmp5.f); s_s22.f = __fsub_rn(s_s22.f, s_tmp2.f); #ifdef DEBUG_JACOBI_CONJUGATE printf("%.20g\n", s_s11.f); printf("%.20g %.20g\n", s_s21.f, s_s22.f); printf("%.20g %.20g %.20g\n", s_s31.f, s_s32.f, s_s33.f); #endif //########################################################### // Compute the cumulative rotation, in quaternion form //########################################################### s_tmp1.f = s_sh.f * s_qvvx.f; s_tmp2.f = s_sh.f * s_qvvy.f; s_tmp3.f = s_sh.f * s_qvvz.f; s_sh.f = s_sh.f * s_qvs.f; s_qvs.f = s_ch.f * s_qvs.f; s_qvvx.f = s_ch.f * s_qvvx.f; s_qvvy.f = s_ch.f * s_qvvy.f; s_qvvz.f = s_ch.f * s_qvvz.f; s_qvvz.f = __fadd_rn(s_qvvz.f, s_sh.f); s_qvs.f = __fsub_rn(s_qvs.f, s_tmp3.f); s_qvvx.f = __fadd_rn(s_qvvx.f, s_tmp2.f); s_qvvy.f = __fsub_rn(s_qvvy.f, s_tmp1.f); #ifdef DEBUG_JACOBI_CONJUGATE printf("GPU q %.20g %.20g %.20g %.20g\n", s_qvvx.f, s_qvvy.f, s_qvvz.f, s_qvs.f); #endif ////////////////////////////////////////////////////////////////////////// // (1->3) ////////////////////////////////////////////////////////////////////////// s_sh.f = s_s32.f * 0.5f; s_tmp5.f = __fsub_rn(s_s22.f, s_s33.f); s_tmp2.f = s_sh.f * s_sh.f; s_tmp1.ui = (s_tmp2.f >= gtiny_number) ? 0xffffffff : 0; s_sh.ui = s_tmp1.ui & s_sh.ui; s_ch.ui = s_tmp1.ui & s_tmp5.ui; s_tmp2.ui = ~s_tmp1.ui & gone; s_ch.ui = s_ch.ui | s_tmp2.ui; s_tmp1.f = s_sh.f * s_sh.f; s_tmp2.f = s_ch.f * s_ch.f; s_tmp3.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp4.f = __frsqrt_rn(s_tmp3.f); s_sh.f = s_tmp4.f * s_sh.f; s_ch.f = s_tmp4.f * s_ch.f; s_tmp1.f = gfour_gamma_squared * s_tmp1.f; s_tmp1.ui = (s_tmp2.f <= s_tmp1.f) ? 0xffffffff : 0; s_tmp2.ui = gsine_pi_over_eight & s_tmp1.ui; s_sh.ui = ~s_tmp1.ui & s_sh.ui; s_sh.ui = s_sh.ui | s_tmp2.ui; s_tmp2.ui = gcosine_pi_over_eight & s_tmp1.ui; s_ch.ui = ~s_tmp1.ui & s_ch.ui; s_ch.ui = s_ch.ui | s_tmp2.ui; s_tmp1.f = s_sh.f * s_sh.f; s_tmp2.f = s_ch.f * s_ch.f; s_c.f = __fsub_rn(s_tmp2.f, s_tmp1.f); s_s.f = s_ch.f * s_sh.f; s_s.f = __fadd_rn(s_s.f, s_s.f); #ifdef DEBUG_JACOBI_CONJUGATE printf("GPU s %.20g, c %.20g, sh %.20g, ch %.20g\n", s_s.f, s_c.f, s_sh.f, s_ch.f); #endif //########################################################### // Perform the actual Givens conjugation //########################################################### s_tmp3.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_s11.f = s_s11.f * s_tmp3.f; s_s21.f = s_s21.f * s_tmp3.f; s_s31.f = s_s31.f * s_tmp3.f; s_s11.f = s_s11.f * s_tmp3.f; s_tmp1.f = s_s.f * s_s21.f; s_tmp2.f = s_s.f * s_s31.f; s_s21.f = s_c.f * s_s21.f; s_s31.f = s_c.f * s_s31.f; s_s21.f = __fadd_rn(s_tmp2.f, s_s21.f); s_s31.f = __fsub_rn(s_s31.f, s_tmp1.f); s_tmp2.f = s_s.f * s_s.f; s_tmp1.f = s_s33.f * s_tmp2.f; s_tmp3.f = s_s22.f * s_tmp2.f; s_tmp4.f = s_c.f * s_c.f; s_s22.f = s_s22.f * s_tmp4.f; s_s33.f = s_s33.f * s_tmp4.f; s_s22.f = __fadd_rn(s_s22.f, s_tmp1.f); s_s33.f = __fadd_rn(s_s33.f, s_tmp3.f); s_tmp4.f = __fsub_rn(s_tmp4.f, s_tmp2.f); s_tmp2.f = __fadd_rn(s_s32.f, s_s32.f); s_s32.f = s_s32.f * s_tmp4.f; s_tmp4.f = s_c.f * s_s.f; s_tmp2.f = s_tmp2.f * s_tmp4.f; s_tmp5.f = s_tmp5.f * s_tmp4.f; s_s22.f = __fadd_rn(s_s22.f, s_tmp2.f); s_s32.f = __fsub_rn(s_s32.f, s_tmp5.f); s_s33.f = __fsub_rn(s_s33.f, s_tmp2.f); #ifdef DEBUG_JACOBI_CONJUGATE printf("%.20g\n", s_s11.f); printf("%.20g %.20g\n", s_s21.f, s_s22.f); printf("%.20g %.20g %.20g\n", s_s31.f, s_s32.f, s_s33.f); #endif //########################################################### // Compute the cumulative rotation, in quaternion form //########################################################### s_tmp1.f = s_sh.f * s_qvvx.f; s_tmp2.f = s_sh.f * s_qvvy.f; s_tmp3.f = s_sh.f * s_qvvz.f; s_sh.f = s_sh.f * s_qvs.f; s_qvs.f = s_ch.f * s_qvs.f; s_qvvx.f = s_ch.f * s_qvvx.f; s_qvvy.f = s_ch.f * s_qvvy.f; s_qvvz.f = s_ch.f * s_qvvz.f; s_qvvx.f = __fadd_rn(s_qvvx.f, s_sh.f); s_qvs.f = __fsub_rn(s_qvs.f, s_tmp1.f); s_qvvy.f = __fadd_rn(s_qvvy.f, s_tmp3.f); s_qvvz.f = __fsub_rn(s_qvvz.f, s_tmp2.f); #ifdef DEBUG_JACOBI_CONJUGATE printf("GPU q %.20g %.20g %.20g %.20g\n", s_qvvx.f, s_qvvy.f, s_qvvz.f, s_qvs.f); #endif #if 1 ////////////////////////////////////////////////////////////////////////// // 1 -> 2 ////////////////////////////////////////////////////////////////////////// s_sh.f = s_s31.f * 0.5f; s_tmp5.f = __fsub_rn(s_s33.f, s_s11.f); s_tmp2.f = s_sh.f * s_sh.f; s_tmp1.ui = (s_tmp2.f >= gtiny_number) ? 0xffffffff : 0; s_sh.ui = s_tmp1.ui & s_sh.ui; s_ch.ui = s_tmp1.ui & s_tmp5.ui; s_tmp2.ui = ~s_tmp1.ui & gone; s_ch.ui = s_ch.ui | s_tmp2.ui; s_tmp1.f = s_sh.f * s_sh.f; s_tmp2.f = s_ch.f * s_ch.f; s_tmp3.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp4.f = __frsqrt_rn(s_tmp3.f); s_sh.f = s_tmp4.f * s_sh.f; s_ch.f = s_tmp4.f * s_ch.f; s_tmp1.f = gfour_gamma_squared * s_tmp1.f; s_tmp1.ui = (s_tmp2.f <= s_tmp1.f) ? 0xffffffff : 0; s_tmp2.ui = gsine_pi_over_eight & s_tmp1.ui; s_sh.ui = ~s_tmp1.ui & s_sh.ui; s_sh.ui = s_sh.ui | s_tmp2.ui; s_tmp2.ui = gcosine_pi_over_eight & s_tmp1.ui; s_ch.ui = ~s_tmp1.ui & s_ch.ui; s_ch.ui = s_ch.ui | s_tmp2.ui; s_tmp1.f = s_sh.f * s_sh.f; s_tmp2.f = s_ch.f * s_ch.f; s_c.f = __fsub_rn(s_tmp2.f, s_tmp1.f); s_s.f = s_ch.f * s_sh.f; s_s.f = __fadd_rn(s_s.f, s_s.f); # ifdef DEBUG_JACOBI_CONJUGATE printf("GPU s %.20g, c %.20g, sh %.20g, ch %.20g\n", s_s.f, s_c.f, s_sh.f, s_ch.f); # endif //########################################################### // Perform the actual Givens conjugation //########################################################### s_tmp3.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_s22.f = s_s22.f * s_tmp3.f; s_s32.f = s_s32.f * s_tmp3.f; s_s21.f = s_s21.f * s_tmp3.f; s_s22.f = s_s22.f * s_tmp3.f; s_tmp1.f = s_s.f * s_s32.f; s_tmp2.f = s_s.f * s_s21.f; s_s32.f = s_c.f * s_s32.f; s_s21.f = s_c.f * s_s21.f; s_s32.f = __fadd_rn(s_tmp2.f, s_s32.f); s_s21.f = __fsub_rn(s_s21.f, s_tmp1.f); s_tmp2.f = s_s.f * s_s.f; s_tmp1.f = s_s11.f * s_tmp2.f; s_tmp3.f = s_s33.f * s_tmp2.f; s_tmp4.f = s_c.f * s_c.f; s_s33.f = s_s33.f * s_tmp4.f; s_s11.f = s_s11.f * s_tmp4.f; s_s33.f = __fadd_rn(s_s33.f, s_tmp1.f); s_s11.f = __fadd_rn(s_s11.f, s_tmp3.f); s_tmp4.f = __fsub_rn(s_tmp4.f, s_tmp2.f); s_tmp2.f = __fadd_rn(s_s31.f, s_s31.f); s_s31.f = s_s31.f * s_tmp4.f; s_tmp4.f = s_c.f * s_s.f; s_tmp2.f = s_tmp2.f * s_tmp4.f; s_tmp5.f = s_tmp5.f * s_tmp4.f; s_s33.f = __fadd_rn(s_s33.f, s_tmp2.f); s_s31.f = __fsub_rn(s_s31.f, s_tmp5.f); s_s11.f = __fsub_rn(s_s11.f, s_tmp2.f); # ifdef DEBUG_JACOBI_CONJUGATE printf("%.20g\n", s_s11.f); printf("%.20g %.20g\n", s_s21.f, s_s22.f); printf("%.20g %.20g %.20g\n", s_s31.f, s_s32.f, s_s33.f); # endif //########################################################### // Compute the cumulative rotation, in quaternion form //########################################################### s_tmp1.f = s_sh.f * s_qvvx.f; s_tmp2.f = s_sh.f * s_qvvy.f; s_tmp3.f = s_sh.f * s_qvvz.f; s_sh.f = s_sh.f * s_qvs.f; s_qvs.f = s_ch.f * s_qvs.f; s_qvvx.f = s_ch.f * s_qvvx.f; s_qvvy.f = s_ch.f * s_qvvy.f; s_qvvz.f = s_ch.f * s_qvvz.f; s_qvvy.f = __fadd_rn(s_qvvy.f, s_sh.f); s_qvs.f = __fsub_rn(s_qvs.f, s_tmp2.f); s_qvvz.f = __fadd_rn(s_qvvz.f, s_tmp1.f); s_qvvx.f = __fsub_rn(s_qvvx.f, s_tmp3.f); #endif } //########################################################### // Normalize quaternion for matrix V //########################################################### s_tmp2.f = s_qvs.f * s_qvs.f; s_tmp1.f = s_qvvx.f * s_qvvx.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = s_qvvy.f * s_qvvy.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = s_qvvz.f * s_qvvz.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5f; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_qvs.f = s_qvs.f * s_tmp1.f; s_qvvx.f = s_qvvx.f * s_tmp1.f; s_qvvy.f = s_qvvy.f * s_tmp1.f; s_qvvz.f = s_qvvz.f * s_tmp1.f; //########################################################### // Transform quaternion to matrix V //########################################################### s_tmp1.f = s_qvvx.f * s_qvvx.f; s_tmp2.f = s_qvvy.f * s_qvvy.f; s_tmp3.f = s_qvvz.f * s_qvvz.f; s_v11.f = s_qvs.f * s_qvs.f; s_v22.f = __fsub_rn(s_v11.f, s_tmp1.f); s_v33.f = __fsub_rn(s_v22.f, s_tmp2.f); s_v33.f = __fadd_rn(s_v33.f, s_tmp3.f); s_v22.f = __fadd_rn(s_v22.f, s_tmp2.f); s_v22.f = __fsub_rn(s_v22.f, s_tmp3.f); s_v11.f = __fadd_rn(s_v11.f, s_tmp1.f); s_v11.f = __fsub_rn(s_v11.f, s_tmp2.f); s_v11.f = __fsub_rn(s_v11.f, s_tmp3.f); s_tmp1.f = __fadd_rn(s_qvvx.f, s_qvvx.f); s_tmp2.f = __fadd_rn(s_qvvy.f, s_qvvy.f); s_tmp3.f = __fadd_rn(s_qvvz.f, s_qvvz.f); s_v32.f = s_qvs.f * s_tmp1.f; s_v13.f = s_qvs.f * s_tmp2.f; s_v21.f = s_qvs.f * s_tmp3.f; s_tmp1.f = s_qvvy.f * s_tmp1.f; s_tmp2.f = s_qvvz.f * s_tmp2.f; s_tmp3.f = s_qvvx.f * s_tmp3.f; s_v12.f = __fsub_rn(s_tmp1.f, s_v21.f); s_v23.f = __fsub_rn(s_tmp2.f, s_v32.f); s_v31.f = __fsub_rn(s_tmp3.f, s_v13.f); s_v21.f = __fadd_rn(s_tmp1.f, s_v21.f); s_v32.f = __fadd_rn(s_tmp2.f, s_v32.f); s_v13.f = __fadd_rn(s_tmp3.f, s_v13.f); ///########################################################### // Multiply (from the right) with V //########################################################### s_tmp2.f = s_a12.f; s_tmp3.f = s_a13.f; s_a12.f = s_v12.f * s_a11.f; s_a13.f = s_v13.f * s_a11.f; s_a11.f = s_v11.f * s_a11.f; s_tmp1.f = s_v21.f * s_tmp2.f; s_a11.f = __fadd_rn(s_a11.f, s_tmp1.f); s_tmp1.f = s_v31.f * s_tmp3.f; s_a11.f = __fadd_rn(s_a11.f, s_tmp1.f); s_tmp1.f = s_v22.f * s_tmp2.f; s_a12.f = __fadd_rn(s_a12.f, s_tmp1.f); s_tmp1.f = s_v32.f * s_tmp3.f; s_a12.f = __fadd_rn(s_a12.f, s_tmp1.f); s_tmp1.f = s_v23.f * s_tmp2.f; s_a13.f = __fadd_rn(s_a13.f, s_tmp1.f); s_tmp1.f = s_v33.f * s_tmp3.f; s_a13.f = __fadd_rn(s_a13.f, s_tmp1.f); s_tmp2.f = s_a22.f; s_tmp3.f = s_a23.f; s_a22.f = s_v12.f * s_a21.f; s_a23.f = s_v13.f * s_a21.f; s_a21.f = s_v11.f * s_a21.f; s_tmp1.f = s_v21.f * s_tmp2.f; s_a21.f = __fadd_rn(s_a21.f, s_tmp1.f); s_tmp1.f = s_v31.f * s_tmp3.f; s_a21.f = __fadd_rn(s_a21.f, s_tmp1.f); s_tmp1.f = s_v22.f * s_tmp2.f; s_a22.f = __fadd_rn(s_a22.f, s_tmp1.f); s_tmp1.f = s_v32.f * s_tmp3.f; s_a22.f = __fadd_rn(s_a22.f, s_tmp1.f); s_tmp1.f = s_v23.f * s_tmp2.f; s_a23.f = __fadd_rn(s_a23.f, s_tmp1.f); s_tmp1.f = s_v33.f * s_tmp3.f; s_a23.f = __fadd_rn(s_a23.f, s_tmp1.f); s_tmp2.f = s_a32.f; s_tmp3.f = s_a33.f; s_a32.f = s_v12.f * s_a31.f; s_a33.f = s_v13.f * s_a31.f; s_a31.f = s_v11.f * s_a31.f; s_tmp1.f = s_v21.f * s_tmp2.f; s_a31.f = __fadd_rn(s_a31.f, s_tmp1.f); s_tmp1.f = s_v31.f * s_tmp3.f; s_a31.f = __fadd_rn(s_a31.f, s_tmp1.f); s_tmp1.f = s_v22.f * s_tmp2.f; s_a32.f = __fadd_rn(s_a32.f, s_tmp1.f); s_tmp1.f = s_v32.f * s_tmp3.f; s_a32.f = __fadd_rn(s_a32.f, s_tmp1.f); s_tmp1.f = s_v23.f * s_tmp2.f; s_a33.f = __fadd_rn(s_a33.f, s_tmp1.f); s_tmp1.f = s_v33.f * s_tmp3.f; s_a33.f = __fadd_rn(s_a33.f, s_tmp1.f); //########################################################### // Permute columns such that the singular values are sorted //########################################################### s_tmp1.f = s_a11.f * s_a11.f; s_tmp4.f = s_a21.f * s_a21.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp4.f = s_a31.f * s_a31.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp2.f = s_a12.f * s_a12.f; s_tmp4.f = s_a22.f * s_a22.f; s_tmp2.f = __fadd_rn(s_tmp2.f, s_tmp4.f); s_tmp4.f = s_a32.f * s_a32.f; s_tmp2.f = __fadd_rn(s_tmp2.f, s_tmp4.f); s_tmp3.f = s_a13.f * s_a13.f; s_tmp4.f = s_a23.f * s_a23.f; s_tmp3.f = __fadd_rn(s_tmp3.f, s_tmp4.f); s_tmp4.f = s_a33.f * s_a33.f; s_tmp3.f = __fadd_rn(s_tmp3.f, s_tmp4.f); // Swap columns 1-2 if necessary s_tmp4.ui = (s_tmp1.f < s_tmp2.f) ? 0xffffffff : 0; s_tmp5.ui = s_a11.ui ^ s_a12.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a11.ui = s_a11.ui ^ s_tmp5.ui; s_a12.ui = s_a12.ui ^ s_tmp5.ui; s_tmp5.ui = s_a21.ui ^ s_a22.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a21.ui = s_a21.ui ^ s_tmp5.ui; s_a22.ui = s_a22.ui ^ s_tmp5.ui; s_tmp5.ui = s_a31.ui ^ s_a32.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a31.ui = s_a31.ui ^ s_tmp5.ui; s_a32.ui = s_a32.ui ^ s_tmp5.ui; s_tmp5.ui = s_v11.ui ^ s_v12.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v11.ui = s_v11.ui ^ s_tmp5.ui; s_v12.ui = s_v12.ui ^ s_tmp5.ui; s_tmp5.ui = s_v21.ui ^ s_v22.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v21.ui = s_v21.ui ^ s_tmp5.ui; s_v22.ui = s_v22.ui ^ s_tmp5.ui; s_tmp5.ui = s_v31.ui ^ s_v32.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v31.ui = s_v31.ui ^ s_tmp5.ui; s_v32.ui = s_v32.ui ^ s_tmp5.ui; s_tmp5.ui = s_tmp1.ui ^ s_tmp2.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_tmp1.ui = s_tmp1.ui ^ s_tmp5.ui; s_tmp2.ui = s_tmp2.ui ^ s_tmp5.ui; // If columns 1-2 have been swapped, negate 2nd column of A and V so that V is still a rotation s_tmp5.f = -2.f; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_tmp4.f = 1.f; s_tmp4.f = __fadd_rn(s_tmp4.f, s_tmp5.f); s_a12.f = s_a12.f * s_tmp4.f; s_a22.f = s_a22.f * s_tmp4.f; s_a32.f = s_a32.f * s_tmp4.f; s_v12.f = s_v12.f * s_tmp4.f; s_v22.f = s_v22.f * s_tmp4.f; s_v32.f = s_v32.f * s_tmp4.f; // Swap columns 1-3 if necessary s_tmp4.ui = (s_tmp1.f < s_tmp3.f) ? 0xffffffff : 0; s_tmp5.ui = s_a11.ui ^ s_a13.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a11.ui = s_a11.ui ^ s_tmp5.ui; s_a13.ui = s_a13.ui ^ s_tmp5.ui; s_tmp5.ui = s_a21.ui ^ s_a23.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a21.ui = s_a21.ui ^ s_tmp5.ui; s_a23.ui = s_a23.ui ^ s_tmp5.ui; s_tmp5.ui = s_a31.ui ^ s_a33.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a31.ui = s_a31.ui ^ s_tmp5.ui; s_a33.ui = s_a33.ui ^ s_tmp5.ui; s_tmp5.ui = s_v11.ui ^ s_v13.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v11.ui = s_v11.ui ^ s_tmp5.ui; s_v13.ui = s_v13.ui ^ s_tmp5.ui; s_tmp5.ui = s_v21.ui ^ s_v23.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v21.ui = s_v21.ui ^ s_tmp5.ui; s_v23.ui = s_v23.ui ^ s_tmp5.ui; s_tmp5.ui = s_v31.ui ^ s_v33.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v31.ui = s_v31.ui ^ s_tmp5.ui; s_v33.ui = s_v33.ui ^ s_tmp5.ui; s_tmp5.ui = s_tmp1.ui ^ s_tmp3.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_tmp1.ui = s_tmp1.ui ^ s_tmp5.ui; s_tmp3.ui = s_tmp3.ui ^ s_tmp5.ui; // If columns 1-3 have been swapped, negate 1st column of A and V so that V is still a rotation s_tmp5.f = -2.f; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_tmp4.f = 1.f; s_tmp4.f = __fadd_rn(s_tmp4.f, s_tmp5.f); s_a11.f = s_a11.f * s_tmp4.f; s_a21.f = s_a21.f * s_tmp4.f; s_a31.f = s_a31.f * s_tmp4.f; s_v11.f = s_v11.f * s_tmp4.f; s_v21.f = s_v21.f * s_tmp4.f; s_v31.f = s_v31.f * s_tmp4.f; // Swap columns 2-3 if necessary s_tmp4.ui = (s_tmp2.f < s_tmp3.f) ? 0xffffffff : 0; s_tmp5.ui = s_a12.ui ^ s_a13.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a12.ui = s_a12.ui ^ s_tmp5.ui; s_a13.ui = s_a13.ui ^ s_tmp5.ui; s_tmp5.ui = s_a22.ui ^ s_a23.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a22.ui = s_a22.ui ^ s_tmp5.ui; s_a23.ui = s_a23.ui ^ s_tmp5.ui; s_tmp5.ui = s_a32.ui ^ s_a33.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_a32.ui = s_a32.ui ^ s_tmp5.ui; s_a33.ui = s_a33.ui ^ s_tmp5.ui; s_tmp5.ui = s_v12.ui ^ s_v13.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v12.ui = s_v12.ui ^ s_tmp5.ui; s_v13.ui = s_v13.ui ^ s_tmp5.ui; s_tmp5.ui = s_v22.ui ^ s_v23.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v22.ui = s_v22.ui ^ s_tmp5.ui; s_v23.ui = s_v23.ui ^ s_tmp5.ui; s_tmp5.ui = s_v32.ui ^ s_v33.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_v32.ui = s_v32.ui ^ s_tmp5.ui; s_v33.ui = s_v33.ui ^ s_tmp5.ui; s_tmp5.ui = s_tmp2.ui ^ s_tmp3.ui; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_tmp2.ui = s_tmp2.ui ^ s_tmp5.ui; s_tmp3.ui = s_tmp3.ui ^ s_tmp5.ui; // If columns 2-3 have been swapped, negate 3rd column of A and V so that V is still a rotation s_tmp5.f = -2.f; s_tmp5.ui = s_tmp5.ui & s_tmp4.ui; s_tmp4.f = 1.f; s_tmp4.f = __fadd_rn(s_tmp4.f, s_tmp5.f); s_a13.f = s_a13.f * s_tmp4.f; s_a23.f = s_a23.f * s_tmp4.f; s_a33.f = s_a33.f * s_tmp4.f; s_v13.f = s_v13.f * s_tmp4.f; s_v23.f = s_v23.f * s_tmp4.f; s_v33.f = s_v33.f * s_tmp4.f; //########################################################### // Construct QR factorization of A*V (=U*D) using Givens rotations //########################################################### s_u11.f = 1.f; s_u12.f = 0.f; s_u13.f = 0.f; s_u21.f = 0.f; s_u22.f = 1.f; s_u23.f = 0.f; s_u31.f = 0.f; s_u32.f = 0.f; s_u33.f = 1.f; s_sh.f = s_a21.f * s_a21.f; s_sh.ui = (s_sh.f >= gsmall_number) ? 0xffffffff : 0; s_sh.ui = s_sh.ui & s_a21.ui; s_tmp5.f = 0.f; s_ch.f = __fsub_rn(s_tmp5.f, s_a11.f); s_ch.f = max(s_ch.f, s_a11.f); s_ch.f = max(s_ch.f, gsmall_number); s_tmp5.ui = (s_a11.f >= s_tmp5.f) ? 0xffffffff : 0; s_tmp1.f = s_ch.f * s_ch.f; s_tmp2.f = s_sh.f * s_sh.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5f; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_tmp1.f = s_tmp1.f * s_tmp2.f; s_ch.f = __fadd_rn(s_ch.f, s_tmp1.f); s_tmp1.ui = ~s_tmp5.ui & s_sh.ui; s_tmp2.ui = ~s_tmp5.ui & s_ch.ui; s_ch.ui = s_tmp5.ui & s_ch.ui; s_sh.ui = s_tmp5.ui & s_sh.ui; s_ch.ui = s_ch.ui | s_tmp1.ui; s_sh.ui = s_sh.ui | s_tmp2.ui; s_tmp1.f = s_ch.f * s_ch.f; s_tmp2.f = s_sh.f * s_sh.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5f; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_ch.f = s_ch.f * s_tmp1.f; s_sh.f = s_sh.f * s_tmp1.f; s_c.f = s_ch.f * s_ch.f; s_s.f = s_sh.f * s_sh.f; s_c.f = __fsub_rn(s_c.f, s_s.f); s_s.f = s_sh.f * s_ch.f; s_s.f = __fadd_rn(s_s.f, s_s.f); //########################################################### // Rotate matrix A //########################################################### s_tmp1.f = s_s.f * s_a11.f; s_tmp2.f = s_s.f * s_a21.f; s_a11.f = s_c.f * s_a11.f; s_a21.f = s_c.f * s_a21.f; s_a11.f = __fadd_rn(s_a11.f, s_tmp2.f); s_a21.f = __fsub_rn(s_a21.f, s_tmp1.f); s_tmp1.f = s_s.f * s_a12.f; s_tmp2.f = s_s.f * s_a22.f; s_a12.f = s_c.f * s_a12.f; s_a22.f = s_c.f * s_a22.f; s_a12.f = __fadd_rn(s_a12.f, s_tmp2.f); s_a22.f = __fsub_rn(s_a22.f, s_tmp1.f); s_tmp1.f = s_s.f * s_a13.f; s_tmp2.f = s_s.f * s_a23.f; s_a13.f = s_c.f * s_a13.f; s_a23.f = s_c.f * s_a23.f; s_a13.f = __fadd_rn(s_a13.f, s_tmp2.f); s_a23.f = __fsub_rn(s_a23.f, s_tmp1.f); //########################################################### // Update matrix U //########################################################### s_tmp1.f = s_s.f * s_u11.f; s_tmp2.f = s_s.f * s_u12.f; s_u11.f = s_c.f * s_u11.f; s_u12.f = s_c.f * s_u12.f; s_u11.f = __fadd_rn(s_u11.f, s_tmp2.f); s_u12.f = __fsub_rn(s_u12.f, s_tmp1.f); s_tmp1.f = s_s.f * s_u21.f; s_tmp2.f = s_s.f * s_u22.f; s_u21.f = s_c.f * s_u21.f; s_u22.f = s_c.f * s_u22.f; s_u21.f = __fadd_rn(s_u21.f, s_tmp2.f); s_u22.f = __fsub_rn(s_u22.f, s_tmp1.f); s_tmp1.f = s_s.f * s_u31.f; s_tmp2.f = s_s.f * s_u32.f; s_u31.f = s_c.f * s_u31.f; s_u32.f = s_c.f * s_u32.f; s_u31.f = __fadd_rn(s_u31.f, s_tmp2.f); s_u32.f = __fsub_rn(s_u32.f, s_tmp1.f); // Second Givens rotation s_sh.f = s_a31.f * s_a31.f; s_sh.ui = (s_sh.f >= gsmall_number) ? 0xffffffff : 0; s_sh.ui = s_sh.ui & s_a31.ui; s_tmp5.f = 0.f; s_ch.f = __fsub_rn(s_tmp5.f, s_a11.f); s_ch.f = max(s_ch.f, s_a11.f); s_ch.f = max(s_ch.f, gsmall_number); s_tmp5.ui = (s_a11.f >= s_tmp5.f) ? 0xffffffff : 0; s_tmp1.f = s_ch.f * s_ch.f; s_tmp2.f = s_sh.f * s_sh.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_tmp1.f = s_tmp1.f * s_tmp2.f; s_ch.f = __fadd_rn(s_ch.f, s_tmp1.f); s_tmp1.ui = ~s_tmp5.ui & s_sh.ui; s_tmp2.ui = ~s_tmp5.ui & s_ch.ui; s_ch.ui = s_tmp5.ui & s_ch.ui; s_sh.ui = s_tmp5.ui & s_sh.ui; s_ch.ui = s_ch.ui | s_tmp1.ui; s_sh.ui = s_sh.ui | s_tmp2.ui; s_tmp1.f = s_ch.f * s_ch.f; s_tmp2.f = s_sh.f * s_sh.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5f; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_ch.f = s_ch.f * s_tmp1.f; s_sh.f = s_sh.f * s_tmp1.f; s_c.f = s_ch.f * s_ch.f; s_s.f = s_sh.f * s_sh.f; s_c.f = __fsub_rn(s_c.f, s_s.f); s_s.f = s_sh.f * s_ch.f; s_s.f = __fadd_rn(s_s.f, s_s.f); //########################################################### // Rotate matrix A //########################################################### s_tmp1.f = s_s.f * s_a11.f; s_tmp2.f = s_s.f * s_a31.f; s_a11.f = s_c.f * s_a11.f; s_a31.f = s_c.f * s_a31.f; s_a11.f = __fadd_rn(s_a11.f, s_tmp2.f); s_a31.f = __fsub_rn(s_a31.f, s_tmp1.f); s_tmp1.f = s_s.f * s_a12.f; s_tmp2.f = s_s.f * s_a32.f; s_a12.f = s_c.f * s_a12.f; s_a32.f = s_c.f * s_a32.f; s_a12.f = __fadd_rn(s_a12.f, s_tmp2.f); s_a32.f = __fsub_rn(s_a32.f, s_tmp1.f); s_tmp1.f = s_s.f * s_a13.f; s_tmp2.f = s_s.f * s_a33.f; s_a13.f = s_c.f * s_a13.f; s_a33.f = s_c.f * s_a33.f; s_a13.f = __fadd_rn(s_a13.f, s_tmp2.f); s_a33.f = __fsub_rn(s_a33.f, s_tmp1.f); //########################################################### // Update matrix U //########################################################### s_tmp1.f = s_s.f * s_u11.f; s_tmp2.f = s_s.f * s_u13.f; s_u11.f = s_c.f * s_u11.f; s_u13.f = s_c.f * s_u13.f; s_u11.f = __fadd_rn(s_u11.f, s_tmp2.f); s_u13.f = __fsub_rn(s_u13.f, s_tmp1.f); s_tmp1.f = s_s.f * s_u21.f; s_tmp2.f = s_s.f * s_u23.f; s_u21.f = s_c.f * s_u21.f; s_u23.f = s_c.f * s_u23.f; s_u21.f = __fadd_rn(s_u21.f, s_tmp2.f); s_u23.f = __fsub_rn(s_u23.f, s_tmp1.f); s_tmp1.f = s_s.f * s_u31.f; s_tmp2.f = s_s.f * s_u33.f; s_u31.f = s_c.f * s_u31.f; s_u33.f = s_c.f * s_u33.f; s_u31.f = __fadd_rn(s_u31.f, s_tmp2.f); s_u33.f = __fsub_rn(s_u33.f, s_tmp1.f); // Third Givens Rotation s_sh.f = s_a32.f * s_a32.f; s_sh.ui = (s_sh.f >= gsmall_number) ? 0xffffffff : 0; s_sh.ui = s_sh.ui & s_a32.ui; s_tmp5.f = 0.f; s_ch.f = __fsub_rn(s_tmp5.f, s_a22.f); s_ch.f = max(s_ch.f, s_a22.f); s_ch.f = max(s_ch.f, gsmall_number); s_tmp5.ui = (s_a22.f >= s_tmp5.f) ? 0xffffffff : 0; s_tmp1.f = s_ch.f * s_ch.f; s_tmp2.f = s_sh.f * s_sh.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5f; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_tmp1.f = s_tmp1.f * s_tmp2.f; s_ch.f = __fadd_rn(s_ch.f, s_tmp1.f); s_tmp1.ui = ~s_tmp5.ui & s_sh.ui; s_tmp2.ui = ~s_tmp5.ui & s_ch.ui; s_ch.ui = s_tmp5.ui & s_ch.ui; s_sh.ui = s_tmp5.ui & s_sh.ui; s_ch.ui = s_ch.ui | s_tmp1.ui; s_sh.ui = s_sh.ui | s_tmp2.ui; s_tmp1.f = s_ch.f * s_ch.f; s_tmp2.f = s_sh.f * s_sh.f; s_tmp2.f = __fadd_rn(s_tmp1.f, s_tmp2.f); s_tmp1.f = __frsqrt_rn(s_tmp2.f); s_tmp4.f = s_tmp1.f * 0.5f; s_tmp3.f = s_tmp1.f * s_tmp4.f; s_tmp3.f = s_tmp1.f * s_tmp3.f; s_tmp3.f = s_tmp2.f * s_tmp3.f; s_tmp1.f = __fadd_rn(s_tmp1.f, s_tmp4.f); s_tmp1.f = __fsub_rn(s_tmp1.f, s_tmp3.f); s_ch.f = s_ch.f * s_tmp1.f; s_sh.f = s_sh.f * s_tmp1.f; s_c.f = s_ch.f * s_ch.f; s_s.f = s_sh.f * s_sh.f; s_c.f = __fsub_rn(s_c.f, s_s.f); s_s.f = s_sh.f * s_ch.f; s_s.f = __fadd_rn(s_s.f, s_s.f); //########################################################### // Rotate matrix A //########################################################### s_tmp1.f = s_s.f * s_a21.f; s_tmp2.f = s_s.f * s_a31.f; s_a21.f = s_c.f * s_a21.f; s_a31.f = s_c.f * s_a31.f; s_a21.f = __fadd_rn(s_a21.f, s_tmp2.f); s_a31.f = __fsub_rn(s_a31.f, s_tmp1.f); s_tmp1.f = s_s.f * s_a22.f; s_tmp2.f = s_s.f * s_a32.f; s_a22.f = s_c.f * s_a22.f; s_a32.f = s_c.f * s_a32.f; s_a22.f = __fadd_rn(s_a22.f, s_tmp2.f); s_a32.f = __fsub_rn(s_a32.f, s_tmp1.f); s_tmp1.f = s_s.f * s_a23.f; s_tmp2.f = s_s.f * s_a33.f; s_a23.f = s_c.f * s_a23.f; s_a33.f = s_c.f * s_a33.f; s_a23.f = __fadd_rn(s_a23.f, s_tmp2.f); s_a33.f = __fsub_rn(s_a33.f, s_tmp1.f); //########################################################### // Update matrix U //########################################################### s_tmp1.f = s_s.f * s_u12.f; s_tmp2.f = s_s.f * s_u13.f; s_u12.f = s_c.f * s_u12.f; s_u13.f = s_c.f * s_u13.f; s_u12.f = __fadd_rn(s_u12.f, s_tmp2.f); s_u13.f = __fsub_rn(s_u13.f, s_tmp1.f); s_tmp1.f = s_s.f * s_u22.f; s_tmp2.f = s_s.f * s_u23.f; s_u22.f = s_c.f * s_u22.f; s_u23.f = s_c.f * s_u23.f; s_u22.f = __fadd_rn(s_u22.f, s_tmp2.f); s_u23.f = __fsub_rn(s_u23.f, s_tmp1.f); s_tmp1.f = s_s.f * s_u32.f; s_tmp2.f = s_s.f * s_u33.f; s_u32.f = s_c.f * s_u32.f; s_u33.f = s_c.f * s_u33.f; s_u32.f = __fadd_rn(s_u32.f, s_tmp2.f); s_u33.f = __fsub_rn(s_u33.f, s_tmp1.f); v11 = s_v11.f; v12 = s_v12.f; v13 = s_v13.f; v21 = s_v21.f; v22 = s_v22.f; v23 = s_v23.f; v31 = s_v31.f; v32 = s_v32.f; v33 = s_v33.f; u11 = s_u11.f; u12 = s_u12.f; u13 = s_u13.f; u21 = s_u21.f; u22 = s_u22.f; u23 = s_u23.f; u31 = s_u31.f; u32 = s_u32.f; u33 = s_u33.f; s11 = s_a11.f; //s12 = s_a12.f; s13 = s_a13.f; s21 = s_a21.f; s22 = s_a22.f; //s23 = s_a23.f; s31 = s_a31.f; s32 = s_a32.f; s33 = s_a33.f; } /** \brief 2x2 SVD (singular value decomposition) A=USV' \param[in] A Input matrix. \param[out] u Robustly a rotation matrix in Givens form \param[out] sigma Vector of singular values sorted with decreasing magnitude. The second one can be negative. \param[out] V Robustly a rotation matrix in Givens form */ template __forceinline__ __host__ __device__ void singular_value_decomposition(const std::array& aa, GivensRotation& u, std::array& sigma, GivensRotation& v) { std::array s_sym;///< column-major std::array a {aa[0], aa[1], aa[2], aa[3]}; polar_decomposition(a, u, s_sym); double cosine; double sine; double x = s_sym[0]; double y = s_sym[2]; double z = s_sym[3]; double y2 = y * y; if(y2 == 0) { // S is already diagonal cosine = 1; sine = 0; sigma[0] = x; sigma[1] = z; } else { double tau = T(0.5) * (x - z); double w = sqrt(tau * tau + y2); // w > y > 0 double t; if(tau > 0) { // tau + w > w > y > 0 ==> division is safe t = y / (tau + w); } else { // tau - w < -w < -y < 0 ==> division is safe t = y / (tau - w); } cosine = T(1) / sqrt(t * t + T(1)); sine = -t * cosine; /* v = [cosine -sine; sine cosine] sigma = v'SV. Only compute the diagonals for efficiency. Also utilize symmetry of S and don't form v yet. */ double c2 = cosine * cosine; double csy = 2 * cosine * sine * y; double s2 = sine * sine; sigma[0] = c2 * x - csy + s2 * z; sigma[1] = s2 * x + csy + c2 * z; } // Sorting // Polar already guarantees negative sign is on the small magnitude singular value. if(sigma[0] < sigma[1]) { std::swap(sigma[0], sigma[1]); v.c = -sine; v.s = cosine; } else { v.c = cosine; v.s = sine; } u *= v; } template __forceinline__ __device__ void svd(const std::array& f, std::array& u, std::array& s, std::array& v) { printf("Not implemented yet!\n"); } /** \brief 2x2 SVD (singular value decomposition) a=USV' \param[in] a Input matrix. \param[out] u Robustly a rotation matrix. \param[out] sigma Vector of singular values sorted with decreasing magnitude. The second one can be negative. \param[out] v Robustly a rotation matrix. */ template<> __forceinline__ __device__ void svd(const std::array& a, std::array& u, std::array& sigma, std::array& v) { GivensRotation gv(0, 1); GivensRotation gu(0, 1); singular_value_decomposition(a, gu, sigma, gv); gu.template fill<2, float>(u); gv.template fill<2, float>(v); } template<> __forceinline__ __device__ void svd(const std::array& a, std::array& u, std::array& sigma, std::array& v) { GivensRotation gv(0, 1); GivensRotation gu(0, 1); singular_value_decomposition(a, gu, sigma, gv); gu.template fill<2, double>(u); gv.template fill<2, double>(v); } template<> __forceinline__ __device__ void svd(const std::array& f, std::array& u, std::array& s, std::array& v) { svd(f[0], f[3], f[6], f[1], f[4], f[7], f[2], f[5], f[8], u[0], u[3], u[6], u[1], u[4], u[7], u[2], u[5], u[8], s[0], s[1], s[2], v[0], v[3], v[6], v[1], v[4], v[7], v[2], v[5], v[8]); } template<> __forceinline__ __device__ void svd(const std::array& f, std::array& u, std::array& s, std::array& v) { svd(f[0], f[3], f[6], f[1], f[4], f[7], f[2], f[5], f[8], u[0], u[3], u[6], u[1], u[4], u[7], u[2], u[5], u[8], s[0], s[1], s[2], v[0], v[3], v[6], v[1], v[4], v[7], v[2], v[5], v[8]); } }// namespace math }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Probability/Probability.cpp ================================================ #include "Probability.h" #ifdef _WIN32 # ifndef M_PI # define M_PI 3.14159265358979323846//NOLINT(cppcoreguidelines-macro-usage) M_PI is usually a macro # endif #endif namespace mn { Propability::Propability() : distribution(0.0, 1.0) , generator(device()) {} double Propability::pdf(double lambda, int k) { double pdf_value = 1; int i; for(i = 1; i <= k; ++i) { pdf_value *= lambda / static_cast(i); } return pdf_value * exp(-1.0 * lambda); } double Propability::pdf(double u, double o, double x) { static const double CO = 1.0 / sqrt(2 * M_PI); //NOLINT(readability-magic-numbers) Formula specific double index = -(x - u) * (x - u) / 2.0 / o / o;//NOLINT(readability-magic-numbers) Formula specific return CO / o * exp(index); } double Propability::anti_normal_pdf(double u, double o, double x) { static const double CO = 1.0 / sqrt(2 * M_PI); //NOLINT(readability-magic-numbers) Formula specific double index = -(x - u) * (x - u) / 2.0 / o / o;//NOLINT(readability-magic-numbers) Formula specific return 1 - CO / o * exp(index); } int Propability::rand_p(double lambda) { double u = distribution(generator); int x = 0; double cdf = exp(-1.0 * lambda); while(u >= cdf) { x++; cdf += pdf(lambda, x); } return x; } int Propability::rand_normal(double u, double o) { double val = distribution(generator); int x = 0; double cdf = 0;// pdf(u, o, x) while(val >= cdf) { x++; cdf += pdf(u, o, static_cast(x)); } return x; } int Propability::rand_anti_normal(double u, double o) { double val = distribution(generator); int x = 0; double cdf = 0;// pdf(u, o, x) while(val >= cdf) { x++; cdf += anti_normal_pdf(u, o, static_cast(x)); } return x; } }// namespace mn ================================================ FILE: Library/MnBase/Math/Probability/Probability.h ================================================ #ifndef PROBABILITY_H #define PROBABILITY_H #include #include namespace mn { class Propability { std::uniform_real_distribution distribution; std::random_device device; std::mt19937 generator; Propability(); public: static double pdf(double lambda, int k); int rand_p(double lambda); static double anti_normal_pdf(double u, double o, double x); static double pdf(double u, double o, double x); int rand_normal(double u, double o); int rand_anti_normal(double u, double o); }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Math/Vec.h ================================================ #ifndef MN_VEC_H #define MN_VEC_H #include #include #include #include #include "MnBase/Meta/MathMeta.h" #include "MnBase/Meta/Meta.h" #include "MnBase/Meta/PatternMeta.h" #include "MnBase/Meta/Relationship.h" #define ENABLE_BITWISE_OPERATORS 0 namespace mn { struct identity_vec {}; /// declarations template struct indexer_impl; template struct vec_view; template struct vec_impl; template using indexer = indexer_impl>; template using vec = vec_impl>; /// indexer template struct indexer_impl> { static constexpr auto dim = sizeof...(Ns); static constexpr auto extent = integral_seq_mul::value; using index_type = Tn; using extends = std::integer_sequence; template __host__ __device__ static constexpr Tn range(std::integral_constant i) { (void) i; return select_value::value;// select_indexed_value::value; } template __host__ __device__ static constexpr Tn offset_impl(std::index_sequence seq, Args&&... args) { (void) seq; Tn idx = 0; (void) std::initializer_list {(idx += std::forward(args) * excl_suffix_mul {}, 0)...}; return idx; } template = 0> __host__ __device__ static constexpr Tn offset(Args&&... args) { return offset_impl(std::index_sequence_for {}, std::forward(args)...); } }; /// vec without lifetime managing template struct vec_view> : identity_vec , indexer { private: T* m_data; public: using base_t = indexer; using base_t::dim; using base_t::extent; using value_type = T; using base_t::offset; using typename base_t::extends; using typename base_t::index_type; constexpr vec_view() = delete; __host__ __device__ explicit constexpr vec_view(T* ptr) : m_data {ptr} {} /// random access // () template = 0> __host__ __device__ constexpr T& operator()(Args&&... args) noexcept { return m_data[offset(std::forward(args)...)]; } template = 0> __host__ __device__ constexpr const T& operator()(Args&&... args) const noexcept { return m_data[offset(std::forward(args)...)]; } // [] template, 1>, extends>>, Tn D = dim, enable_if_t<(D > 1)> = 0> __host__ __device__ constexpr R operator[](Index&& index) noexcept { return R {m_data + offset(std::forward(index))}; } template, gather_t, 1>, extends>>, Tn D = dim, enable_if_t<(D > 1)> = 0> __host__ __device__ constexpr R operator[](Index index) const noexcept { return R {m_data + offset(std::forward(index))}; } template = 0> __host__ __device__ constexpr T& operator[](Index index) noexcept { return m_data[std::forward(index)]; } template = 0> __host__ __device__ constexpr const T& operator[](Index index) const noexcept { return m_data[std::forward(index)]; } template __host__ __device__ constexpr T& val(Index index) noexcept { return m_data[std::forward(index)]; } template __host__ __device__ constexpr const T& val(Index index) const noexcept { return m_data[std::forward(index)]; } }; /// vec template struct vec_impl> : identity_vec , indexer { static_assert(std::is_trivial::value, "Vec element type is not trivial!\n"); using base_t = indexer; using base_t::dim; using base_t::extent; using value_type = T; using base_t::offset; using typename base_t::extends; using typename base_t::index_type; private: std::array m_data; public: /// construct constexpr vec_impl() = default; template::value...> = 0> __host__ __device__ explicit constexpr vec_impl(Vals&&... vals) noexcept : m_data {std::forward(vals)...} {} template 1), std::is_convertible::value> = 0> __host__ __device__ explicit constexpr vec_impl(Val&& val) noexcept { for(Tn idx = 0; idx < extent; ++idx) { m_data[idx] = std::forward(val); } } __host__ __device__ constexpr void set(T val) noexcept { for(Tn idx = 0; idx < extent; ++idx) { m_data[idx] = val; } } /// expose internal __host__ __device__ constexpr auto data() noexcept -> T* { return m_data.data(); } __host__ __device__ constexpr auto data() const noexcept -> const T* { return m_data.data(); } __host__ __device__ constexpr std::array& data_arr() noexcept { return m_data; } __host__ __device__ constexpr const std::array& data_arr() const noexcept { return m_data; } /// random access // () template = 0> __host__ __device__ constexpr T& operator()(Args&&... args) noexcept { return m_data[offset(std::forward(args)...)]; } template = 0> __host__ __device__ constexpr const T& operator()(Args&&... args) const noexcept { return m_data[offset(std::forward(args)...)]; } // [] template, 1>, extends>>, Tn D = dim, enable_if_t<(D > 1)> = 0> __host__ __device__ constexpr R operator[](Index&& index) noexcept { return R {m_data.data() + offset(std::forward(index))}; } template, gather_t, 1>, extends>>, Tn D = dim, enable_if_t<(D > 1)> = 0> __host__ __device__ constexpr R operator[](Index index) const noexcept { return R {m_data.data() + offset(std::forward(index))}; } template = 0> __host__ __device__ constexpr T& operator[](Index index) noexcept { return m_data[std::forward(index)]; } template = 0> __host__ __device__ constexpr const T& operator[](Index index) const noexcept { return m_data[std::forward(index)]; } template __host__ __device__ constexpr T& val(Index index) noexcept { return m_data[std::forward(index)]; } template __host__ __device__ constexpr const T& val(Index index) const noexcept { return m_data[std::forward(index)]; } /// template __host__ __device__ constexpr auto cast() const noexcept { vec_impl r {}; for(Tn idx = 0; idx < extent; ++idx) { r.val(idx) = m_data[idx]; } return r; } /// compare template::value, is_same::value, std::is_convertible::value> = 0> __host__ __device__ constexpr auto operator==(Vec&& o) noexcept -> bool { for(int i = 0; i < extent; ++i) { if(m_data[i] != std::forward(o).val(i)) { return false; } } return true; } template::value, is_same::value, std::is_convertible::value> = 0> __host__ __device__ constexpr auto operator!=(Vec&& o) noexcept -> bool { for(int i = 0; i < extent; ++i) { if(m_data[i] == std::forward(o).val(i)) { return false; } } return true; } /// linalg template> __host__ __device__ constexpr R dot(vec_impl const& o) const noexcept { R res {0}; for(int i = 0; i < extent; ++i) { res += m_data[i] * o.val(i); } return res; } template> __host__ __device__ constexpr R dot(vec_impl&& o) const noexcept { R res {0}; for(int i = 0; i < extent; ++i) { res += m_data[i] * o.val(i); } return res; } __host__ __device__ constexpr T prod() noexcept { T res {1}; for(int i = 0; i < extent; ++i) { res *= m_data[i]; } return res; } __host__ __device__ constexpr T l2NormSqr() noexcept { T res {0}; for(int i = 0; i < extent; ++i) { res += m_data[i] * m_data[i]; } return res; } __host__ __device__ constexpr T infNormSqr() noexcept { T res {0}; for(int i = 0; i < extent; ++i) { T sqr = m_data[i] * m_data[i]; if(sqr > res) { res = sqr; } } return res; } /// borrowed from /// https://github.com/cemyuksel/cyCodeBase/blob/master/cyIVector.h /// east const //!@name Unary operators __host__ __device__ constexpr vec_impl operator-() const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = -m_data[i]; } return r; } //!@name Binary operators // scalar template> __host__ __device__ friend constexpr auto operator+(vec_impl const& e, TT const v) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = e.val(i) + v; } return r; } template> __host__ __device__ friend constexpr auto operator+(TT const v, vec_impl const& e) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = e.val(i) + v; } return r; } template> __host__ __device__ friend constexpr auto operator-(vec_impl const& e, TT const v) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = e.val(i) - v; } return r; } template> __host__ __device__ friend constexpr auto operator-(TT const v, vec_impl const& e) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = v - e.val(i); } return r; } template> __host__ __device__ friend constexpr auto operator*(vec_impl const& e, TT const v) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = e.val(i) * v; } return r; } template> __host__ __device__ friend constexpr auto operator*(TT const v, vec_impl const& e) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = e.val(i) * v; } return r; } template> __host__ __device__ friend constexpr auto operator/(vec_impl const& e, TT const v) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = e.val(i) / v; } return r; } template> __host__ __device__ friend constexpr auto operator/(TT const v, vec_impl const& e) noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = v / e.val(i); } return r; } // vector template> __host__ __device__ constexpr auto operator+(vec_impl const& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] + o.val(i); } return r; } template> __host__ __device__ constexpr auto operator+(vec_impl&& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] + o.val(i); } return r; } template> __host__ __device__ constexpr auto operator-(vec_impl const& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] - o.val(i); } return r; } template> __host__ __device__ constexpr auto operator-(vec_impl&& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] - o.val(i); } return r; } template> __host__ __device__ constexpr auto operator*(vec_impl const& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] * o.val(i); } return r; } template> __host__ __device__ constexpr auto operator*(vec_impl&& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] * o.val(i); } return r; } template> __host__ __device__ constexpr auto operator/(vec_impl const& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] / o.val(i); } return r; } template> __host__ __device__ constexpr auto operator/(vec_impl&& o) const noexcept { vec_impl r {}; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] / o.val(i); } return r; } //!@name Assignment operators // scalar template::value> = 0> __host__ __device__ constexpr vec_impl& operator+=(TT&& v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] += std::forward(v); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator-=(TT&& v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] -= std::forward(v); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator*=(TT&& v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] *= std::forward(v); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator/=(TT&& v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] /= std::forward(v); } return *this; } // vector template::value> = 0> __host__ __device__ constexpr vec_impl& operator+=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] += o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator+=(vec_impl&& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] += o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator-=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] -= o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator-=(vec_impl&& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] -= o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator*=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] *= o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator*=(vec_impl&& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] *= o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator/=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] /= o.val(i); } return *this; } template::value> = 0> __host__ __device__ constexpr vec_impl& operator/=(vec_impl&& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] /= o.val(i); } return *this; } #if ENABLE_BITWISE_OPERATORS //!@name Bitwise operators __host__ __device__ vec_impl operator<<(vec_impl const& o) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] << o.val(i); } return r; } __host__ __device__ vec_impl operator>>(vec_impl const& o) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] >> o.val(i); } return r; } __host__ __device__ vec_impl operator&(vec_impl const& o) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] & o.val(i); } return r; } __host__ __device__ vec_impl operator|(vec_impl const& o) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] | o.val(i); } return r; } __host__ __device__ vec_impl operator^(vec_impl const& o) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] ^ o.val(i); } return r; } __host__ __device__ vec_impl operator<<(T const v) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] << v; } return r; } __host__ __device__ vec_impl operator>>(T const v) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] >> v; } return r; } __host__ __device__ vec_impl operator&(T const v) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] & v; } return r; } __host__ __device__ vec_impl operator|(T const v) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] | v; } return r; } __host__ __device__ vec_impl operator^(T const v) const noexcept { vec_impl r; for(int i = 0; i < extent; ++i) { r.val(i) = m_data[i] ^ v; } return r; } //!@name Bitwise Assignment operators __host__ __device__ vec_impl& operator<<=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] <<= o.val(i); } return *this; } __host__ __device__ vec_impl& operator>>=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] >>= o.val(i); } return *this; } __host__ __device__ vec_impl& operator&=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] &= o.val(i); } return *this; } __host__ __device__ vec_impl& operator|=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] |= o.val(i); } return *this; } __host__ __device__ vec_impl& operator^=(vec_impl const& o) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] ^= o.val(i); } return *this; } __host__ __device__ vec_impl& operator<<=(T const v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] <<= v; } return *this; } __host__ __device__ vec_impl& operator>>=(T const v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] >>= v; } return *this; } __host__ __device__ vec_impl& operator&=(T const v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] &= v; } return *this; } __host__ __device__ vec_impl& operator|=(T const v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] |= v; } return *this; } __host__ __device__ vec_impl& operator^=(T const v) noexcept { for(int i = 0; i < extent; ++i) { m_data[i] ^= v; } return *this; } #endif }; /// affine map = linear map + translation matrix+(0, 0, 1) point(vec+{1}) /// vector(vec+{0}) homogeneous coordinates }// namespace mn #endif ================================================ FILE: Library/MnBase/Memory/Allocator.h ================================================ #ifndef ALLOCATOR_H #define ALLOCATOR_H #include #include "MemoryResource.h" namespace mn { /// stateless allocator struct HeapAllocator { using mr_type = MemoryResource; HeapAllocator() = default; HeapAllocator(const HeapAllocator& o) noexcept {} mr_type* resource() const { return &HeapMemoryResource::instance(); } void* allocate(std::size_t bytes) { return resource()->allocate(bytes); } void deallocate(void* p, std::size_t bytes) { (void) bytes; resource()->deallocate(p); } }; /// stateful allocator template struct StackAllocator { using mr_type = MemoryResource; private: mr_type* mr; public: char* data; char* head; char* tail; std::size_t align; StackAllocator() = delete; explicit StackAllocator(mr_type* mr, std::size_t align_bytes, std::size_t total_mem_bytes) : mr {mr} , align {align_bytes} { data = head = (char*) (mr->allocate(total_mem_bytes)); tail = head + total_mem_bytes; }; ~StackAllocator() { mr->deallocate((void*) data, (std::size_t)(tail - data)); } mr_type* resource() const noexcept { return mr; } /// learnt from taichi void* allocate(std::size_t bytes) { /// first align head char* ret = head + align - 1 - ((std::size_t) head + align - 1) % align; head = ret + bytes; if(head > tail) { throw std::bad_alloc {}; } else { return ret; } } void deallocate(void* p, std::size_t bytes) { (void) bytes; if(p >= head) { throw std::bad_alloc {}; } else if(p < data) { throw std::bad_alloc {}; } head = (char*) p; } void reset() { head = data; } }; template struct ObjectAllocator { using value_type = value_t; using mr_type = MemoryResource; private: mr_type* mr; public: ObjectAllocator() = delete; ObjectAllocator(mr_type* mr) : mr {mr} {}; template explicit ObjectAllocator(const ObjectAllocator& o) noexcept { mr = o.resource(); } mr_type* resource() const noexcept { return mr; } value_type* allocate(std::size_t n) { return (value_type*) (mr->allocate(n * sizeof(value_type), alignof(value_type))); } void deallocate(value_type* p, std::size_t n) { mr->deallocate((void*) p, n * sizeof(value_type), alignof(value_type)); } }; template struct PoolAllocator { static constexpr std::size_t chunk_size = chunk_size_v; using mr_type = MemoryResource; }; template using page_allocator = PoolAllocator<4096, MemoryResource_t>; template struct structural_allocator : PoolAllocator {}; /// 4K, 64K, 2M template struct multiPoolAllocator; template struct multiPoolAllocator, MemoryResource_t> : PoolAllocator... {}; }// namespace mn #endif ================================================ FILE: Library/MnBase/Memory/MemObj.h ================================================ #ifndef MEM_OBJ_H #define MEM_OBJ_H namespace mn { struct MemBackend { using uchar = unsigned char; enum class Physical : uchar { CPU = 0, GPU = 1 }; }; struct MemResource { union { void* ptr; uintptr_t ptrval; uint64_t offset;///< only legal for 64-bit app }; }; struct MemStack { char* top; char* end; }; struct MemBlock { void* mem; std::size_t size; }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Memory/MemoryResource.h ================================================ #ifndef MEMORY_RESOURCE_H #define MEMORY_RESOURCE_H #include "MnBase/Singleton.h" namespace mn { template struct MemoryResource { using pointer_t = void*; pointer_t allocate(std::size_t bytes, std::size_t alignment = alignof(max_align_t)) { return static_cast(*this).do_allocate(bytes, alignment); } void deallocate(pointer_t ptr, std::size_t bytes = 0, std::size_t alignment = alignof(max_align_t)) { static_cast(*this).do_deallocate(ptr, bytes, alignment); } bool is_equal(const MemoryResource& other) const noexcept { return (this == &other); } }; struct HeapMemoryResource : Singleton , MemoryResource { void* do_allocate(std::size_t bytes, std::size_t align) { // return ::operator new(bytes, std::align_val_t(align)); return ::operator new(bytes); } void do_deallocate(void* ptr, std::size_t bytes, std::size_t align) { //::operator delete(ptr, bytes, std::align_val_t(align)); ::operator delete(ptr); } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/AllocMeta.cuh ================================================ #ifndef ALLOC_META_H #define ALLOC_META_H #include #include #include "MnSystem/Cuda/HostUtils.hpp" #include "TypeMeta.h" namespace mn { /** HEAP **/ template auto make_vector(Args&&... args) { using Item = std::common_type_t; std::vector result(sizeof...(Args)); // works as a building block forArgs( [&result](auto&& x) { result.emplace_back(std::forward(x)); }, std::forward(args)... ); return result; } /** CUDA **/ template auto cuda_alloc(Integer size) -> Type* { Type* addr {nullptr}; checkCudaErrors(cudaMalloc(static_cast(static_cast(&addr)), sizeof(Type) * size)); return addr; } template auto cuda_virtual_alloc(Integer size) -> Type* { Type* addr {nullptr}; checkCudaErrors(cudaMallocManaged(static_cast(static_cast(&addr)), sizeof(Type) * size)); return addr; } template auto cuda_alloc(Integer size, AllocFunc&& allocFunc) -> Type* { return static_cast(static_cast((std::forward(allocFunc)(sizeof(Type) * size)))); } #if 0 template auto cuda_allocs(Integer size) { std::array>::value> addrs; forIndexAlloc( [&addrs, size](std::size_t &&i, std::size_t &&typeSize) { checkCudaErrors(cudaMalloc(&addrs[i], typeSize * size)); }, std::make_index_sequence>::value>{}); return std::move(addrs); } template auto cuda_virtual_allocs(Integer size) { std::array>::value> addrs; forIndexAlloc( [&addrs, size](std::size_t &&i, std::size_t &&typeSize) { checkCudaErrors(cudaMallocManaged(&addrs[i], typeSize * size)); }, std::make_index_sequence>::value>{}); return std::move(addrs); } template auto cuda_allocs(const Integer *sizes) { std::array>::value> addrs; forIndexAlloc( [&addrs, &sizes](std::size_t &&i, std::size_t &&typeSize) { checkCudaErrors(cudaMalloc(&addrs[i], typeSize * sizes[i])); }, std::make_index_sequence>::value>{}); return std::move(addrs); } template auto cuda_virtual_allocs(const Integer *sizes) { std::array>::value> addrs; forIndexAlloc( [&addrs, &sizes](std::size_t &&i, std::size_t &&typeSize) { checkCudaErrors(cudaMallocManaged(&addrs[i], typeSize * sizes[i])); }, std::make_index_sequence>::value>{}); return std::move(addrs); } template auto cuda_allocs(Integer size, AllocFunc &&allocFunc) { std::array>::value> addrs; forIndexAlloc( [&addrs, &allocFunc, size](std::size_t &&i, std::size_t &&typeSize) { addrs[i] = std::forward(allocFunc)(typeSize * size); }, std::make_index_sequence>::value>{}); return std::move(addrs); } template void cuda_frees(std::array &_attribs) { for (auto &attrib : _attribs){ checkCudaErrors(cudaFree(attrib)); } } template void cuda_free(Type *addr) { checkCudaErrors(cudaFree(addr)); } template void cuda_memcpys(const Integer size, Attribs &&from, Attribs &&to, cudaStream_t stream = cudaStreamDefault) { forIndexAlloc( [&from, &to, &size, &stream](std::size_t &&i, std::size_t &&typeSize) { cudaMemcpyAsync(to[i], from[i], typeSize * size, cudaMemcpyDeviceToDevice, stream); }, std::make_index_sequence>::value>{}); } #endif }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/ControlFlow.h ================================================ #ifndef CONTROL_FLOW_H #define CONTROL_FLOW_H #include #include "Meta.h" namespace mn { // enable_if // conditional template struct conditional_impl { template using type = T; }; template<> struct conditional_impl { template using type = F; }; template using conditional_t = typename conditional_impl::type; template struct do_if; template<> struct do_if { template auto operator()(F&& f, Args&&... args) { return std::forward(f)(std::forward(args)...); } }; template<> struct do_if { template auto operator()(F&& f, Args&&... args) {} }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/Functional.h ================================================ #ifndef FUNCTIONAL_H #define FUNCTIONAL_H #include #include #include "Meta.h" #include "TupleMeta.h" namespace mn { template constexpr decltype(auto) fold(F&& f, T&& v) { return std::forward(v); } template constexpr decltype(auto) fold(F&& f, T&& v, Ts&&... vs) { return std::forward(f)(std::forward(v), fold(std::forward(f), std::forward(vs)...)); } /// map, transform /// result_of template struct add_optionality_t { using type = std::optional; }; template struct add_optionality_t> { using type = std::optional; }; template using add_optionality = typename add_optionality_t::type; template auto operator|(std::optional const& opt, Func const& func) -> add_optionality { if(opt) { return func(*opt); } else { return {}; } } template>::value, int> = 0> auto operator|(T&& t, F&& f) -> decltype(detail::void_or_nullopt(t).operator*()))>()) { using return_type = decltype(f(std::forward(t).operator*())); if(t) { return f(std::forward(t).operator*()); } else { return detail::void_or_nullopt(); } } }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/MathMeta.h ================================================ #ifndef MATH_META_H #define MATH_META_H #include #include #include "Meta.h" #include "MnBase/Math/Bit/Bits.h" #include "TypeMeta.h" namespace mn { template struct next_2pow { static_assert(std::is_integral::value, "next_2pow: template parameter not an integral!\n"); static constexpr T value = static_cast(1) << bit_count(I); }; template struct mul; template struct mul : std::integral_constant {}; template struct mul : std::integral_constant::value> {}; template struct add; template struct add : std::integral_constant {}; template struct add : std::integral_constant::value> {}; /// use some designs from https://github.com/taocpp/sequences/ namespace meta_impl { template constexpr T integral_seq_mul_impl() noexcept { T res {1}; (void) std::initializer_list {(res *= Ns, 0)...}; return res; } template constexpr T integral_seq_sum_impl() noexcept { T res {0}; (void) std::initializer_list {(res += Ns, 0)...}; return res; } }// namespace meta_impl template struct value_seq_traits_impl; template struct value_seq_traits_impl> { static constexpr T sum = meta_impl::integral_seq_sum_impl(); static constexpr T prod = meta_impl::integral_seq_mul_impl(); }; template using value_seq_traits = value_seq_traits_impl>; /// seq reduction template using integral_seq_sum = std::integral_constant 0) ? Ns : 0)...>::sum - value_seq_traits::sum>; template using integral_seq_mul = std::integral_constant::prod>; template struct integral_seq_max; template struct integral_seq_max : std::integral_constant {}; template struct integral_seq_max : std::integral_constant integral_seq_max::value) ? N : integral_seq_max::value> {}; /// prefix sum template> struct excl_prefix_sum; template> struct incl_prefix_sum; template struct excl_prefix_sum, std::index_sequence> : integral_seq_sum { static_assert(I < sizeof...(Ns), "excl_prefix_sum out-of-bound access "); using type = integral_seq_sum; }; template struct incl_prefix_sum, std::index_sequence> : integral_seq_sum { static_assert(I < sizeof...(Ns), "incl_prefix_sum out-of-bound access "); using type = integral_seq_sum; }; /// suffix mul template> struct excl_suffix_mul; template struct excl_suffix_mul, std::index_sequence> : integral_seq_mul I ? Ns : 1)...> { static_assert(I < sizeof...(Ns), "excl_suffix_mul out-of-bound access "); using type = integral_seq_mul I ? Ns : 1)...>; }; /// seq scan(sum) template> struct excl_scan_seq; template struct excl_scan_seq> : std::integer_sequence::value...> { using type = std::integer_sequence::value...>; }; template using excl_scan_seq_t = typename excl_scan_seq::type; template> struct incl_scan_seq; template struct incl_scan_seq> : std::integer_sequence::value...> { using type = std::integer_sequence::value...>; }; template using incl_scan_seq_t = typename incl_scan_seq::type; /// seq coefficient-wise arithmetic template> struct minus_seq; template struct minus_seq> { static_assert(Seq0::size() == Seq1::size(), "minus_seq error"); using type = std::integer_sequence, (select_value::value - select_value::value)...>; }; template using minus_seq_t = typename minus_seq::type; template struct translate_seq; template struct translate_seq, Offset> { using type = std::integer_sequence; }; template using translate_seq_t = typename translate_seq::type; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/Meta.h ================================================ #ifndef META_H #define META_H #include #include namespace mn { /// initializer list & function overload /// or constexpr bool logic_or(std::initializer_list) { return false; } constexpr bool logic_or(std::initializer_list) { return true; } /// and constexpr bool logic_and(std::initializer_list) { return true; } constexpr bool logic_and(std::initializer_list) { return false; } template class Predicate, typename... Ts> constexpr bool all_satisfy() { return logic_and({typename Predicate::type()...}); } template class Predicate, typename... Ts> constexpr bool any_satisfy() { return logic_or({typename Predicate::type()...}); } /// pre C++14 impl, https://zh.cppreference.com/w/cpp/types/void_t /// check ill-formed types template struct make_void { using type = void; }; template using void_t = typename make_void::type; /// SFINAE template struct enable_if; template<> struct enable_if { using type = char; }; template using enable_if_t = typename enable_if::type; template using enable_if_all = typename enable_if...>::value>::type; template using enable_if_any = typename enable_if()...})>::type; /// underlying_type /// common_type }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/Optional.h ================================================ #ifndef OPTIONAL_H #define OPTIONAL_H //#include #include namespace mn { // template using optional = mapbox::util::optional; template using optional = tl::optional; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/PatternMeta.h ================================================ #ifndef PATTERN_META_H #define PATTERN_META_H #include #include #include "TypeMeta.h" namespace mn { template struct gather; /// Seq must be integer_sequence template struct gather, ValueSeq> { using type = std::integer_sequence::value...>; }; template using gather_t = typename gather::type; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/Polymorphism.h ================================================ #ifndef POLYMORPHISM_H #define POLYMORPHISM_H //#include #include #define ADVANCED_OVERLOAD_SET 0 namespace mn { #if ADVANCED_OVERLOAD_SET /// only in c++17 template struct overload_set : TFs... { using TFs::operator()...; }; template overload(TFs...)->overload_set; #else template struct overload_set : TF , overload_set { using TF::operator(); using overload_set::operator(); template overload_set(TFFwd&& f, TFsFwd&&... fs) : TF {std::forward(f)} , overload_set {std::forward(fs)...} {} }; template struct overload_set : TF { using TF::operator(); template overload_set(TFFwd&& f) : TF {std::forward(f)} {} }; template constexpr auto overload(TFs&&... fs) { return overload_set...>(std::forward(fs)...); } template //using variant = mapbox::util::variant; using variant = mpark::variant; template auto& get(TVariant&& variant) { //return mapbox::util::get(std::forward(variant)); return mpark::get(std::forward(variant)); } template constexpr auto match(TVariants&&... vs) { return [&vs...](auto&&... fs) -> decltype(auto) { auto visitor = overload(std::forward(fs)...); //return mapbox::util::apply_visitor(visitor, std::forward(vs)...); return mpark::visit(visitor, std::forward(vs)...); }; } #endif }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/Relationship.h ================================================ #ifndef RELATIONSHIP_H #define RELATIONSHIP_H #include "Meta.h" namespace mn { struct wrapper_base { static constexpr bool is_same(void*) { return false; }; }; template struct wrapper : wrapper_base { using wrapper_base::is_same; static constexpr bool is_same(wrapper*) { return true; }; }; template using is_same = std::integral_constant::is_same((wrapper*) nullptr)>; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/TupleMeta.h ================================================ #ifndef TUPLE_META_H #define TUPLE_META_H #include #include #include #include #include "MathMeta.h" #include "Meta.h" #include "PatternMeta.h" #include "TypeMeta.h" namespace mn { /// Jorg Brown, Cppcon2019, reducing template compilation overhead using /// features from C++11, 14, 17, and 20 struct identity_tuple {}; template struct tuple_value { static constexpr std::size_t tuple_size = 1; T value; constexpr tuple_value() = default; template explicit constexpr tuple_value(Args&&... args) : value {std::forward(args)...} {} // constexpr auto &get(std::integral_constant) noexcept { constexpr T& get() noexcept { return value; } constexpr const T& get() const noexcept { return value; } }; template struct tuple_base; template struct tuple_base, Ts...> : tuple_value... { static constexpr std::size_t tuple_size = sizeof...(Ts); using tuple_types = type_seq; // explicit constexpr tuple_base(Ts &&... args) : tuple_leaf(args)... // {} constexpr tuple_base() = default; template explicit constexpr tuple_base(Args&&... args) : tuple_value(std::forward(args))... {} /// function overload, disabled due to c++17 feature using expansion // using tuple_leaf::get...; // template auto &get() { // return get(std::integral_constant{}); //} /// c++14 impl template constexpr auto& get_element(tuple_value* leaf) noexcept { return *leaf; } template constexpr typename tuple_types::type& get() noexcept { return get_element(this).value; } template constexpr const typename tuple_types::type& get() const noexcept { return get_element(this).value; } }; template struct tuple_impl; template struct tuple_impl> : identity_tuple { static constexpr std::size_t tuple_size = sizeof...(Ts); using base_t = tuple_base, Ts...>; using tuple_types = type_seq; base_t base; constexpr tuple_impl() = default; template explicit constexpr tuple_impl(Args&&... args) : base {std::forward(args)...} {} template constexpr auto& get() noexcept { return base.template get(); } template constexpr const auto& get() const noexcept { return base.template get(); } }; template using tuple = tuple_impl>; template using is_tuple = std::is_base_of; template using tuple_size = std::integral_constant; template using tuple_element = select_type; /// get (ridiculous syntax) template constexpr const auto& get(const tuple_impl& t) noexcept { return t.template get(); // return static_cast> // &>(t.base).get(); } template constexpr typename TypeSeq::type& get(tuple_impl& t) noexcept { return t.template get(); // return static_cast> // &>(t.base).get(); } template constexpr typename TypeSeq::type&& get(tuple_impl&& t) noexcept { return std::move(t).template get(); // return static_cast> // &&>(std::move(t.base)).get(); } /// make_tuple template...>> constexpr R make_tuple(Args&&... args) { return R {std::forward(args)...}; } /// forward as tuple template> constexpr R tuple_forward(Ts&&... ts) noexcept { return R {std::forward(ts)...}; } /// taocpp namespace meta_impl { template struct count_less_or_equal; template struct count_less_or_equal> : integral_seq_sum {}; template struct expand; template using expand_t = typename expand::type; template struct expand, Seq> : std::index_sequence::value...> { using type = std::index_sequence::value...>; }; template struct tuple_cat_result; template struct tuple_cat_result, std::index_sequence, Ts...> { using type = tuple::tuple_types::type...>; }; template using tuple_cat_result_t = typename tuple_cat_result::type; template struct tuple_cat_helper { using tuple_index_seq = std::index_sequence; using tuple_size_seq = std::index_sequence::value...>; using result_index_seq = std::make_index_sequence::value...>::value>; using outer_index_seq = expand_t>; using inner_index_seq = minus_seq_t>>; using result_type = tuple_cat_result_t; }; template constexpr decltype(auto) tuple_cat_impl(std::index_sequence, std::index_sequence, Tuple&& tup) { return R {get(get(tup))...}; } }// namespace meta_impl template::type...>, typename R = typename H::result_type> constexpr R tuple_cat(Ts&&... tuples) { return meta_impl::tuple_cat_impl(typename H::outer_index_seq {}, typename H::inner_index_seq {}, tuple_forward(std::forward(tuples)...)); } /// legacy // template // using TupleAttribType = std::decay_t>; template struct tuple_type_list { template using type = typename std::tuple_element::type; }; template using TupleAttribType = std::decay_t::template type>; template constexpr decltype(auto) gen_uniform_tuple(std::index_sequence) { using Tuple = std::tuple= 0, T>...>; return Tuple {}; }; template using UniformTuple = decltype(gen_uniform_tuple>(std::make_index_sequence {})); template struct tupleOffset; template struct tupleOffset { static constexpr std::size_t value = tupleOffset::value + sizeof(TupleAttribType); }; template struct tupleOffset<0, Tuple> { static constexpr std::size_t value = 0; }; template constexpr void gen_tuple_offsets_impl(std::array& offsets, std::index_sequence) { (void) std::initializer_list {(offsets[Is] = tupleOffset::value, 0)...}; } template constexpr auto gen_tuple_offsets() { auto tuplesize = std::tuple_size::value; std::array::value> offsets; using Indices = std::make_index_sequence::value>; gen_tuple_offsets_impl(offsets, Indices {}); return offsets; } template void forIndexAlloc(Func&& f, std::index_sequence) { return (void) std::initializer_list {(std::forward(f)(std::forward(I), sizeof(TupleAttribType)), 0)...}; } /// tuple functionality template void forArgs(Func&& f, Args&&... args) { return (void) std::initializer_list {(f(std::forward(args)), 0)...}; } template decltype(auto) apply_impl(F&& f, Tuple t, std::index_sequence) { return std::forward(f)(std::get(std::forward(t))...); } template decltype(auto) apply(F&& f, Tuple t) { using Indices = std::make_index_sequence>::value>; return apply_impl(std::forward(f), std::forward(t), Indices {}); } template void forTuple(Func&& f, Tpl&& tpl) { apply( [&f](auto&&... xs) { forArgs(f, std::forward(xs)...); }, std::forward(tpl) ); } template constexpr decltype(auto) gen_uniform_channel_tuple(std::index_sequence) { // static_assert((sizeof(T) & 0x3) == 0); using Tuple = std::tuple, T>...>; return Tuple {}; }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/TypeDecoration.h ================================================ #ifndef TYPE_DECORATION_H #define TYPE_DECORATION_H #include "Meta.h" namespace mn { /// decay /// const, volatile, reference, pointer, sign, extent template using add_const_t = const T; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/TypeIdentity.h ================================================ #ifndef TYPE_IDENTITY_H #define TYPE_IDENTITY_H #include "Meta.h" namespace mn { /// primary type struct { ; }; /// composite type }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/TypeMeta.h ================================================ #ifndef TYPE_META_H #define TYPE_META_H #include #include #include #include "MnBase/Reflection.h" namespace mn { /// https://zh.cppreference.com/w/cpp/utility/tuple/make_tuple template struct unwrap_refwrapper { using type = T; }; template struct unwrap_refwrapper> { using type = T&; }; template using special_decay_t = typename unwrap_refwrapper>::type; /// indexable type list to avoid recursion namespace meta_impl { template struct type_wrapper { using type = T; }; template struct indexed_type { using type = T; }; template struct indexed_types; template struct indexed_types, Ts...> : indexed_type... {}; /// use pointer rather than reference as in taocpp! [incomplete type error] template indexed_type extract_type(indexed_type*); }// namespace meta_impl template struct type_seq { using indices = std::index_sequence_for; template using type = typename decltype(meta_impl::extract_type(std::add_pointer_t> {}))::type; }; template struct type_seq> { using indices = std::make_index_sequence; template using type = typename decltype(meta_impl::extract_type(std::add_pointer_t...>> {}))::type; }; /// select type by index template using select_indexed_type = typename type_seq::template type; template using select_type = typename TypeSeq::template type; /// select (constant integral) value (integral_constant) by index template using select_indexed_value = select_indexed_type...>; template using select_value = typename type_seq::template type; /// reverse seq namespace meta_impl { template struct reverse_type_seq_impl; template struct reverse_type_seq_impl, type_seq> { static_assert(sizeof...(Is) == sizeof...(Ts), "reverse_type_seq_impl error"); using type = type_seq::template type...>; }; template struct reverse_value_seq_impl; template struct reverse_value_seq_impl, std::integer_sequence> { static_assert(sizeof...(Is) == sizeof...(Ns), "reverse_value_seq_impl error"); using type = std::integer_sequence...>::template type {})...>; }; }// namespace meta_impl template using type_seq_rev = typename meta_impl::reverse_type_seq_impl, type_seq>::type; template struct rev_type_seq_impl; template struct rev_type_seq_impl> { using type = typename meta_impl::reverse_type_seq_impl, type_seq>::type; }; template using rev_type_seq = typename rev_type_seq_impl::type; template using value_seq_rev = typename meta_impl::reverse_value_seq_impl, std::integer_sequence>::type; template struct rev_value_seq_impl; template struct rev_value_seq_impl> { using type = typename meta_impl::reverse_value_seq_impl, std::integer_sequence>::type; }; template using rev_value_seq = typename rev_value_seq_impl::type; /// legacy template struct type_list { using Indices = std::make_integer_sequence; using types = std::tuple...>; template using type = typename std::tuple_element::type; static constexpr auto count = sizeof...(Ts); static constexpr auto size = sizeof(types);// wrong: std::tuple_size::value; // template // static constexpr auto offset = tupleOffset::value; // using Indices = ; }; template using AttribType = typename type_seq::template type; //TODO: Avoid confusion with std::placeholders namespace placeholder { using placeholder_type = unsigned; constexpr auto _0 = std::integral_constant {}; constexpr auto _1 = std::integral_constant {}; constexpr auto _2 = std::integral_constant {}; constexpr auto _3 = std::integral_constant {}; constexpr auto _4 = std::integral_constant {}; constexpr auto _5 = std::integral_constant {}; constexpr auto _6 = std::integral_constant {}; constexpr auto _7 = std::integral_constant {}; constexpr auto _8 = std::integral_constant {}; constexpr auto _9 = std::integral_constant {}; constexpr auto _10 = std::integral_constant {}; constexpr auto _11 = std::integral_constant {}; constexpr auto _12 = std::integral_constant {}; constexpr auto _13 = std::integral_constant {}; constexpr auto _14 = std::integral_constant {}; constexpr auto _15 = std::integral_constant {}; constexpr auto _16 = std::integral_constant {}; constexpr auto _17 = std::integral_constant {}; constexpr auto _18 = std::integral_constant {}; constexpr auto _19 = std::integral_constant {}; constexpr auto _20 = std::integral_constant {}; constexpr auto _21 = std::integral_constant {}; constexpr auto _22 = std::integral_constant {}; constexpr auto _23 = std::integral_constant {}; constexpr auto _24 = std::integral_constant {}; constexpr auto _25 = std::integral_constant {}; constexpr auto _26 = std::integral_constant {}; constexpr auto _27 = std::integral_constant {}; constexpr auto _28 = std::integral_constant {}; constexpr auto _29 = std::integral_constant {}; constexpr auto _30 = std::integral_constant {}; constexpr auto _31 = std::integral_constant {}; }// namespace placeholder using place_id = typename placeholder::placeholder_type; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/TypeOperation.h ================================================ #ifndef TYPE_OPERATION_H #define TYPE_OPERATION_H #include "Meta.h" namespace mn { template struct is_iterable : std::false_type {}; template struct is_iterable())), decltype(*std::end(std::declval()))>> : std::true_type {}; }// namespace mn #endif ================================================ FILE: Library/MnBase/Meta/TypeProperty.h ================================================ #ifndef TYPE_PROPERTY_H #define TYPE_PROPERTY_H #include "Meta.h" namespace mn { struct { ; }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Object/Function.h ================================================ #ifndef FUNCTION_H #define FUNCTION_H #include #include #include #include "MnBase/Meta/TypeMeta.h" namespace mn { //typename //using func_ref = tl::function_ref; template struct FunctionTraits; template struct FunctionTraits> { static constexpr std::size_t nargs = sizeof...(Args); using resultType = R; template using argType = AttribType; }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Object/Property.h ================================================ #ifndef PROPERTY_H #define PROPERTY_H #include namespace mn { struct NonCopyable { NonCopyable() = default; NonCopyable(const NonCopyable&) = delete; NonCopyable& operator=(const NonCopyable&) = delete; }; template struct is_base_of; template struct is_base_of { static_assert(std::is_base_of::value, "T is not a subclass of Base!"); }; template struct is_base_of : public is_base_of { static_assert(std::is_base_of::value, "T is not a subclass of Base!"); }; template class Feature, typename... Ts> struct satisfy; template class Feature, typename T> struct satisfy { static_assert(Feature::value, "T does not satisfy the feature!"); }; template class Feature, typename T, typename... Ts> struct satisfy : public satisfy { static_assert(Feature::value, "T does not satisfy the feature!"); }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Object/Structural.h ================================================ #ifndef STRUCTURAL_H #define STRUCTURAL_H #include #include #include #include "Function.h" #include "MnBase/Meta/ControlFlow.h" #include "MnBase/Meta/MathMeta.h" #include "MnBase/Meta/Polymorphism.h" #include "MnBase/Meta/TypeMeta.h" #include "Property.h" #include "StructuralAuxiliary.h" #include "StructuralDeclaration.h" namespace mn { enum class StructuralComponentIndex : std::size_t { HANDLE_PTR = 0, PARENT_SCOPE_HANDLE, ACTIVE_MASK///< for on-demand allocation }; using ci = StructuralComponentIndex; /// cuda forbids ci as int_seq type using orphan_signature = std::integer_sequence(StructuralComponentIndex::HANDLE_PTR)>; using standard_signature = std::integer_sequence(StructuralComponentIndex::PARENT_SCOPE_HANDLE)>; using sparse_orphan_signature = std::integer_sequence(StructuralComponentIndex::ACTIVE_MASK)>; /// instance related declarations template struct StructuralInstance; template using Instance = StructuralInstance, (attrib_index) 0, Signature>; template struct StructuralInstanceTraits : ParentInstance::attribs::template type<(std::size_t) AttribNo> { using self = typename ParentInstance::attribs::type<(std::size_t) AttribNo>; using parent_indexer = typename ParentInstance::domain::index; using self_indexer = typename self::domain::index; }; template struct StructuralInstanceComponent; template struct StructuralInstanceComponent {}; template struct StructuralInstanceComponent { typename StructuralInstanceTraits::ParentInstance _parent; typename StructuralInstanceTraits::parent_indexer _index; }; template struct StructuralInstanceComponent { static_assert(sizeof(char) == 1, "size (byte) of char is not 1."); char* active_mask; }; template struct StructuralInstance> : StructuralInstanceTraits , StructuralInstanceComponent(Cs)>... { using traits = StructuralInstanceTraits; using component_seq = std::integer_sequence; using self_instance = StructuralInstance; template using accessor = typename traits::template Accessor; // hierarchy traverse template constexpr auto chfull(std::integral_constant, Indices&&... indices) const { StructuralInstance ret {}; ret._parent = *this; ret._index = traits::self_indexer(std::forward(indices)...); ret.handle = MemResource {reinterpret_cast(this->handle.ptrval + accessor::coord_offset(std::forward(indices)...))}; return ret; } template constexpr auto ch(std::integral_constant, Indices&&... indices) const { StructuralInstance ret {}; ret.handle = MemResource {reinterpret_cast(this->handle.ptrval + accessor::coord_offset(std::forward(indices)...))}; return ret; } template constexpr auto chptr(std::integral_constant, Indices&&... indices) const { StructuralInstance ret {}; ret.handle.ptrval = *reinterpret_cast(this->handle.ptrval + accessor::coord_offset(std::forward(indices)...)); return ret; } }; /// initialization template constexpr auto spawn(Allocator allocator) { auto ret = Instance {}; ret.allocate_handle(allocator); return ret; } template constexpr auto spawn(Allocator allocator, std::size_t size) { auto ret = Instance {}; ret.allocate_handle(allocator, size); return ret; } template constexpr void recycle(Instance& instance, Allocator allocator) { instance.deallocate(allocator); } /// common notation using empty_ = StructuralEntity; using i64_ = StructuralEntity; using u64_ = StructuralEntity; using f64_ = StructuralEntity; using i32_ = StructuralEntity; using u32_ = StructuralEntity; using f32_ = StructuralEntity; }// namespace mn #endif ================================================ FILE: Library/MnBase/Object/StructuralAuxiliary.h ================================================ #ifndef STRUCTURAL_AUXILIARY_H #define STRUCTURAL_AUXILIARY_H #include "MnBase/Math/Vec.h" #include "MnBase/Meta/MathMeta.h" namespace mn { struct MemoryLayout { enum class element : unsigned char { AOS = 0, SOA = 1 }; }; enum class StructuralAllocationPolicy : std::size_t { FULL_ALLOCATION = 0, ON_DEMAND = 1, TOTAL }; enum class StructuralPaddingPolicy : std::size_t { COMPACT = 0, SUM_POW2_ALIGN = 1, MAX_POW2_ALIGN = 2, TOTAL }; using attrib_layout = MemoryLayout::element; struct IdentityDecorator {}; template struct Decorator : IdentityDecorator { static constexpr auto alloc_policy = AllocPolicy; static constexpr auto padding_policy = PaddingPolicy; }; struct IdentityStructuralIndex {}; template struct CompactDomain : IdentityStructuralIndex , indexer { using base_t = indexer; using index = vec; }; template using AlignedDomain = CompactDomain::value...>; }// namespace mn #endif ================================================ FILE: Library/MnBase/Object/StructuralDeclaration.h ================================================ #ifndef STRUCTURAL_DECLARATION_H #define STRUCTURAL_DECLARATION_H #include #include "MnBase/Math/Vec.h" #include "MnBase/Memory/MemObj.h" #include "MnBase/Meta/MathMeta.h" namespace mn { enum class StructuralType : std::size_t { /// no child SENTINEL = 0, ENTITY = 1, /// with child HASH = 2, DENSE = 3, DYNAMIC = 4, BINARY = 5, TOTAL }; using attrib_index = place_id; struct IdentityStructural {}; template struct Structural; template struct StructuralTraits { static constexpr StructuralType node_type = NodeType; static constexpr attrib_layout elementLayout = Layout; using decoration = Decoration; using domain = Domain; using attribs = type_seq; using self = Structural; using vt = void*;///< should be hidden by Structural ENTITY template using value_type = select_indexed_type; static constexpr auto attrib_count = attribs::indices::size(); static constexpr std::size_t element_size = select_indexed_value< (std::size_t) decoration::padding_policy, std::size_t, // compact integral_seq_sum::value, // sum aligned next_2pow::value>::value, // max aligned (integral_seq_max::value)...>::value) * sizeof...(Structurals)>::value; static constexpr std::size_t element_storage_size = select_indexed_value< (std::size_t) decoration::alloc_policy, std::size_t, /// full-allocation element_size, /// on-demand sizeof(void*) * sizeof...(Structurals)>::value; /// for allocation static constexpr std::size_t size = domain::extent * element_storage_size; // SOA -> multipool, AOS -> pool template struct Accessor { private: static constexpr uintptr_t element_stride_in_bytes_func() { switch(decoration::alloc_policy) { case StructuralAllocationPolicy::FULL_ALLOCATION: return (elementLayout == attrib_layout::AOS ? element_storage_size : attribs::template type<(std::size_t) AttribNo>::size); case StructuralAllocationPolicy::ON_DEMAND: return sizeof(void*) * (elementLayout == attrib_layout::AOS ? sizeof...(Structurals) : 1); default: return 0; } } static constexpr uintptr_t attrib_base_offset_func() { switch(decoration::alloc_policy) { case StructuralAllocationPolicy::FULL_ALLOCATION: return (elementLayout == attrib_layout::AOS ? 1 : domain::extent) * excl_prefix_sum<(std::size_t) AttribNo, std::integer_sequence>::value; case StructuralAllocationPolicy::ON_DEMAND: return (elementLayout == attrib_layout::AOS ? 1 : domain::extent) * (std::size_t) AttribNo * sizeof(void*); default: return 0; } } public: static constexpr uintptr_t element_stride_in_bytes = element_stride_in_bytes_func(); static constexpr uintptr_t attrib_base_offset = attrib_base_offset_func(); template static constexpr uintptr_t coord_offset(Indices&&... is) noexcept { return attrib_base_offset + domain::offset(std::forward(is)...) * element_stride_in_bytes; } template static constexpr uintptr_t linear_offset(Index&& i) noexcept { return attrib_base_offset + std::forward(i) * element_stride_in_bytes; } }; MemResource handle; // memory manage template void allocate_handle(Allocator allocator) { if(self::size != 0) { handle.ptr = allocator.allocate(self::size); } else { handle.ptr = nullptr; } } template void allocate_handle(Allocator allocator, std::size_t s) { if(s != 0) { handle.ptr = allocator.allocate(s); } else { handle.ptr = nullptr; } } template void deallocate(Allocator allocator) { allocator.deallocate(handle.ptr, self::size); handle.ptr = nullptr; } template void deallocate(Allocator allocator, std::size_t s) { allocator.deallocate(handle.ptr, s); handle.ptr = nullptr; } // value access template, typename... Indices> constexpr auto& val(std::integral_constant, Indices&&... indices) { return *reinterpret_cast(handle.ptrval + Accessor::coord_offset(std::forward(indices)...)); } template> constexpr auto& val(std::integral_constant) { return *reinterpret_cast(handle.ptrval + Accessor::attrib_base_offset); } template, typename... Indices> constexpr const auto& val(std::integral_constant, Indices&&... indices) const { return *reinterpret_cast(handle.ptrval + Accessor::coord_offset(std::forward(indices)...)); } template> constexpr const auto& val(std::integral_constant) const { return *reinterpret_cast(handle.ptrval + Accessor::attrib_base_offset); } template, typename Index> constexpr auto& val_1d(std::integral_constant, Index&& index) { return *reinterpret_cast(handle.ptrval + Accessor::linear_offset(std::forward(index))); } template, typename Index> constexpr const auto& val_1d(std::integral_constant, Index&& index) const { return *reinterpret_cast(handle.ptrval + Accessor::linear_offset(std::forward(index))); } }; /// root template struct RootInstance : IdentityStructural , StructuralTraits, CompactDomain, attrib_layout::AOS, Structural> { /// purely for its domain and attrib info query, i.e. Structural info using vt = void*; }; /// ENTITY template struct StructuralEntity : IdentityStructural { static constexpr std::size_t size = sizeof(T); using vt = T; using domain = AlignedDomain; }; template<> struct StructuralEntity : IdentityStructural { static constexpr std::size_t size = 0; using vt = void; using domain = AlignedDomain;// int[0] is allowed in c++ }; /// HASH template struct Structural : IdentityStructural , StructuralTraits { using base_t = StructuralTraits; using CheckPrerequisite = void_t, is_base_of, is_base_of, satisfy>; using key_t = vec; using value_t = typename Domain::index_type; static constexpr auto sentinel_v = value_t(-1); // data members value_t capacity; value_t* count; key_t* active_keys; // value_t* index_table;// // func members template void allocate_table(Allocator allocator, value_t capacity) { this->capacity = capacity; count = static_cast(allocator.allocate(sizeof(value_t))); active_keys = static_cast(allocator.allocate(sizeof(key_t) * capacity)); /// lookup table index_table = static_cast(allocator.allocate(sizeof(value_t) * Domain::extent)); } template void resize_table(Allocator allocator, std::size_t capacity) { allocator.deallocate(active_keys, this->capacity); active_keys = static_cast(allocator.allocate(sizeof(key_t) * capacity)); this->capacity = capacity; } template void deallocate(Allocator allocator) { allocator.deallocate(count, sizeof(value_t)); allocator.deallocate(active_keys, sizeof(key_t) * capacity); allocator.deallocate(index_table, sizeof(value_t) * Domain::extent); base_t::deallocate(allocator); capacity = 0; count = nullptr; active_keys = nullptr; index_table = nullptr; } //TODO: Add (optional) range checks here (and maybe elsewhere too) template constexpr auto& val(Indices&&... indices) { return *static_cast(static_cast(index_table + Domain::offset(std::forward(indices)...))); } template constexpr auto& index_impl(key_t& coord, std::index_sequence) { return *static_cast(static_cast(index_table + Domain::offset((coord[Is])...))); } constexpr auto& index(key_t coord) { return index_impl(coord, std::make_index_sequence {}); } template constexpr const auto& index_impl(key_t& coord, std::index_sequence) const { return *static_cast(static_cast(index_table + Domain::offset((coord[Is])...))); } constexpr const auto& index(key_t coord) const { return index_impl(coord, std::make_index_sequence {}); } }; /// DENSE template struct Structural : IdentityStructural , StructuralTraits { using base_t = StructuralTraits; using CheckPrerequisite = void_t, is_base_of, is_base_of, satisfy>; }; /// DYNAMIC template struct Structural : IdentityStructural , StructuralTraits { using base_t = StructuralTraits; using CheckPrerequisite = void_t, is_base_of, is_base_of, satisfy, enable_if_t>; using value_t = unsigned long long int; std::size_t capacity; template void allocate_handle(Allocator allocator, std::size_t capacity = Domain::extent) { if(capacity != 0) { this->handle.ptr = allocator.allocate(capacity * base_t::element_storage_size); } else { this->handle.ptr = nullptr; } this->capacity = capacity; } template void resize(Allocator allocator, std::size_t capacity) { allocator.deallocate(this->handle.ptr, this->capacity); this->capacity = capacity;///< each time multiply by 2 this->handle.ptr = allocator.allocate(capacity * base_t::element_storage_size); } template void deallocate(Allocator allocator) { allocator.deallocate(this->handle.ptr, this->capacity * base_t::element_storage_size); this->capacity = 0; this->handle.ptr = nullptr; } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Profile/CppTimers.hpp ================================================ #ifndef CPP_TIMERS_HPP #define CPP_TIMERS_HPP #include #include #include namespace mn { struct CppTimer { using HRC = std::chrono::high_resolution_clock; using NS = std::chrono::nanoseconds;///< default timer unit using TimeStamp = HRC::time_point; private: TimeStamp last; TimeStamp cur; public: void tick() { last = HRC::now(); } void tock() { cur = HRC::now(); } float elapsed() { float duration = std::chrono::duration_cast(cur - last).count() * 1e-6; return duration; } void tock(std::string tag) { tock(); fmt::print(fg(fmt::color::cyan), "{}: {} ms\n", tag.c_str(), elapsed()); } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Profile/CudaTimers.cuh ================================================ #ifndef CUDA_TIMERS_CUH #define CUDA_TIMERS_CUH #include #include #include namespace mn { struct CudaTimer { using TimeStamp = cudaEvent_t; private: cudaStream_t stream_id; TimeStamp last; TimeStamp cur; public: explicit CudaTimer(cudaStream_t sid) : stream_id {sid} { cudaEventCreate(&last); cudaEventCreate(&cur); } ~CudaTimer() { cudaEventDestroy(last); cudaEventDestroy(cur); } void tick() { cudaEventRecord(last, stream_id); } void tock() { cudaEventRecord(cur, stream_id); } float elapsed() { float duration; cudaEventSynchronize(cur); cudaEventElapsedTime(&duration, last, cur); return duration; } void tock(std::string tag) { tock(); fmt::print(fg(fmt::color::cyan), "{}: {} ms\n", tag.c_str(), elapsed()); } }; }// namespace mn #endif ================================================ FILE: Library/MnBase/Reflection.h ================================================ #ifndef REFLECTION_H #define REFLECTION_H #include namespace mn { /// compile-time type inspection template class that_type; template void name_that_type(T& param) { that_type tType; that_type paramType; } /// runtime //typeid(x).name() template constexpr decltype(auto) query_type_name(T&& x) { return typeid(std::forward(x)).name(); } }// namespace mn #endif ================================================ FILE: Library/MnBase/Singleton.h ================================================ #ifndef SINGLETON_H #define SINGLETON_H #include // http ://www.boost.org/doc/libs/1_39_0/boost/pool/detail/singleton.hpp namespace mn { /* * @note Singleton */ // T must be: no-throw default constructible and no-throw destructible template struct Singleton { public: static T& instance() { static T instance {}; return instance; } }; /* * \class ManagedSingleton * \note Used in global systems */ template struct ManagedSingleton { protected: static T* p_instance;//NOLINT(cppcoreguidelines-avoid-non-const-global-variables) Cannot avoid this public: static void startup() { assert(p_instance == nullptr); p_instance = new T(); } static void shutdown() { assert(p_instance != nullptr); delete p_instance; } /// T* operator->() { return p_instance; } static T& instance() { assert(p_instance != nullptr); return *p_instance; } static T* get_instance() { assert(p_instance != nullptr); return p_instance; } static const T* get_const_instance() { assert(p_instance != nullptr); return p_instance; } }; template T* ManagedSingleton::p_instance = nullptr;//NOLINT(cppcoreguidelines-avoid-non-const-global-variables) Cannot avoid this }// namespace mn #endif ================================================ FILE: Library/MnSystem/CMakeLists.txt ================================================ include(sourcelist.cmake) # build: PRIVATE, usage: INTERFACE, both: PUBLIC. if (CUDA_FOUND) add_cuda_library(mncuda) target_include_directories(mncuda PUBLIC ${PROJECT_SOURCE_DIR}/Library ) target_sources(mncuda PRIVATE ${CudaSystemSrc} ) target_precompile_headers(mncuda INTERFACE Cuda/Cuda.h Cuda/DeviceUtils.cuh Cuda/HostUtils.hpp ) endif() add_library(mnio) set_target_properties(mnio PROPERTIES #CXX_STANDARD 20 #LINKER_LANGUAGE CXX POSITION_INDEPENDENT_CODE ON ) target_include_directories(mnio PUBLIC ${PROJECT_SOURCE_DIR}/Library ) target_compile_definitions(mnio INTERFACE AssetDirPath="${PROJECT_SOURCE_DIR}/Data/" ) target_sources(mnio PRIVATE IO/IO.cpp ) target_precompile_headers(mnio INTERFACE IO/IO.h ) target_link_libraries(mnio PUBLIC partio ) ================================================ FILE: Library/MnSystem/Cuda/Allocators.cuh ================================================ #ifndef ALLOCATORS_CUH #define ALLOCATORS_CUH #include #include #include #include "HostUtils.hpp" #include "MnBase/Memory/Allocator.h" namespace mn { struct DeviceMemoryResource : Singleton , MemoryResource { static constexpr size_t MAX_ALIGNMENT = 256; DeviceMemoryResource() = default; void* do_allocate(std::size_t bytes, std::size_t alignment) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member if(alignment > MAX_ALIGNMENT) { throw std::bad_alloc {}; } void* ret; if(cudaMalloc((void**) &ret, bytes) != cudaSuccess) { throw std::bad_alloc {}; } return ret; } void do_deallocate(void* ptr, std::size_t bytes, std::size_t alignment) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) bytes; (void) alignment; if(cudaFree(ptr) != cudaSuccess) { throw std::bad_alloc {}; } } }; struct UnifiedMemoryResource : Singleton , MemoryResource { static constexpr size_t MAX_ALIGNMENT = 256; UnifiedMemoryResource() = default; void* do_allocate(std::size_t bytes, std::size_t alignment) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member if(alignment > MAX_ALIGNMENT) { throw std::bad_alloc {}; } void* ret; if(cudaMallocManaged((void**) &ret, bytes) != cudaSuccess) { throw std::bad_alloc {}; } return ret; } void do_deallocate(void* ptr, std::size_t bytes, std::size_t alignment) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) bytes; (void) alignment; if(cudaFree(ptr) != cudaSuccess) { throw std::bad_alloc {}; } } }; /// std::allocator /// stateless allocator struct DeviceAllocator { using mr_type = MemoryResource; DeviceAllocator() = default; DeviceAllocator(const DeviceAllocator& o) noexcept = default; DeviceAllocator(DeviceAllocator&& o) noexcept = default; DeviceAllocator& operator=(const DeviceAllocator& o) noexcept = default; DeviceAllocator& operator=(DeviceAllocator&& o) noexcept = default; [[nodiscard]] mr_type* resource() const { return &DeviceMemoryResource::instance(); } void* allocate(std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member return resource()->allocate(bytes); } void deallocate(void* p, std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) bytes; resource()->deallocate(p); } }; struct UnifiedAllocator { using mr_type = MemoryResource; UnifiedAllocator() = default; UnifiedAllocator(const UnifiedAllocator& o) noexcept = default; UnifiedAllocator(UnifiedAllocator&& o) noexcept = default; UnifiedAllocator& operator=(const UnifiedAllocator& o) noexcept = default; UnifiedAllocator& operator=(UnifiedAllocator&& o) noexcept = default; [[nodiscard]] mr_type* resource() const { return &UnifiedMemoryResource::instance(); } void* allocate(std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member return resource()->allocate(bytes); } void deallocate(void* p, std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) bytes; resource()->deallocate(p); } }; /// memory types: device only, pageable, pinned /// usage: static, intermediate, dynamic small, dynamic large, dynamic random struct MonotonicAllocator : StackAllocator { using base_t = StackAllocator; MonotonicAllocator(std::size_t texturealign_bytes, std::size_t total_mem_bytes) : StackAllocator {&DeviceMemoryResource::instance(), texturealign_bytes, total_mem_bytes} { std::cout << std::string {"monotonic allocator alignment (Bytes): "} << texturealign_bytes << std::string {"\tsize (MB): "} << static_cast(total_mem_bytes) / static_cast(1 << 20) << std::endl;//NOLINT(readability-magic-numbers) Unit conversion } ~MonotonicAllocator() = default; MonotonicAllocator(const MonotonicAllocator& o) noexcept = default; MonotonicAllocator(MonotonicAllocator&& o) noexcept = default; MonotonicAllocator& operator=(const MonotonicAllocator& o) noexcept = default; MonotonicAllocator& operator=(MonotonicAllocator&& o) noexcept = default; auto borrow(std::size_t bytes) -> void* {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member return allocate(bytes); } void reset() { std::size_t used_bytes = head - data; std::size_t total_bytes = tail - data; if(used_bytes >= total_bytes * 3 / 4) {//NOLINT(readability-magic-numbers) Threshold values? base_t::resource()->deallocate((void*) this->data, total_bytes); std::size_t total_mem_bytes = total_bytes * 3 / 2;//NOLINT(readability-magic-numbers) Threshold values? this->data = static_cast(base_t::resource()->allocate(total_mem_bytes)); this->head = this->data; this->tail = this->data + total_mem_bytes; } else { this->head = this->data; } } }; struct MonotonicVirtualAllocator : StackAllocator { using base_t = StackAllocator; ~MonotonicVirtualAllocator() = default; MonotonicVirtualAllocator(int devId, std::size_t texturealign_bytes, std::size_t total_mem_bytes) : StackAllocator {&UnifiedMemoryResource::instance(), texturealign_bytes, total_mem_bytes} { // checkCudaErrors(cudaMemAdvise(addr, total_mem_bytes, // cudaMemAdviseSetPreferredLocation, devId)); std::cout << std::string {"monotonic virtual allocator alignment (Bytes): "} << texturealign_bytes << std::string {"\tsize (MB): "} << static_cast(total_mem_bytes) / static_cast(1 << 20) << std::endl;//NOLINT(readability-magic-numbers) Unit conversion } auto borrow(std::size_t bytes) -> void* {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member return allocate(bytes); } void reset() { std::size_t used_bytes = head - data; std::size_t total_bytes = tail - data; if(used_bytes >= total_bytes * 3 / 4) {//NOLINT(readability-magic-numbers) Threshold values? this->resource()->deallocate((void*) this->data, total_bytes); std::size_t total_mem_bytes = total_bytes * 3 / 2;//NOLINT(readability-magic-numbers) Threshold values? this->data = static_cast(this->resource()->allocate(total_mem_bytes)); this->head = this->data; this->tail = this->data + total_mem_bytes; } else { this->head = this->data; } } }; }// namespace mn #endif ================================================ FILE: Library/MnSystem/Cuda/Cuda.cu ================================================ #include ///< for optimal kernel launching #include ///< for evaluating kernel performance #include #include #include #include "Cuda.h" constexpr size_t MEM_POOL_CTRL = 3; namespace mn { //NOLINTBEGIN(cppcoreguidelines-pro-type-vararg) Cuda has no other way to print KernelConfig::KernelConfig(KernelFunc f, cudaFuncCache cache_config, bool is_wave) : attribs() , func(f) , cache_preference(cache_config) , wave_fashion(is_wave) { cudaFuncGetAttributes(&attribs, f); max_occ_block_size = Cuda::eval_optimal_block_size(attribs, cache_preference); if(cache_config != cudaFuncCachePreferNone) {///< should be different from ///< device cache preference check_cuda_errors(cudaFuncSetCacheConfig(f, cache_config)); } } Cuda::Cuda() : default_dev_id {0} , dev_num_using() , i_dev_id() { printf("[Init -- Begin] Cuda\n"); //< acquire devices dev_num_available = 0; cudaError_t error_id = cudaGetDeviceCount(&dev_num_available); if(error_id != cudaSuccess) { printf("cudaGetDeviceCount returned %d\n-> %s\n", static_cast(error_id), cudaGetErrorString(error_id)); printf("Result = FAIL\n"); throw std::runtime_error("Failure"); } if(dev_num_available == 0) { printf( "\t[InitInfo -- DevNum] There are no available device(s) that " "support CUDA\n" ); } else { printf("\t[InitInfo -- DevNum] Detected %d CUDA Capable device(s)\n", dev_num_available); } set_max_device();//<[TMP] printf("\t[InitInfo -- DevNum] Prepare to use %d device(s) in Multi-GPU test\n", dev_num_using); ak_device_props.resize(dev_num_available); ak_streams.resize(dev_num_available); ak_events.resize(dev_num_available); for(int i = 0; i < dev_num_available; i++) { // check_cuda_errors(cudaSetDevice(i)); check_cuda_errors(cudaSetDevice(i)); ///< device properties check_cuda_errors(cudaGetDeviceProperties(&ak_device_props[i], i)); const auto& prop {ak_device_props[i]}; printf( "\t[InitInfo -- Dev Property] GPU device %d (%d-th group on " "board)\n\t\tglobal memory: %llu bytes,\n\t\tshared memory per " "block: %llu bytes,\n\t\tregisters per SM: %d,\n\t\tMulti-Processor " "count: %d,\n\t\tSM compute capabilities: %d.%d.\n", i, prop.multiGpuBoardGroupID, static_cast(prop.totalGlobalMem), static_cast(prop.sharedMemPerBlock), prop.regsPerBlock, prop.multiProcessorCount, prop.major, prop.minor ); ///< streams // int leastPriority = 0; // int greatestPriority = leastPriority; // cudaDeviceGetStreamPriorityRange(&leastPriority, &greatestPriority); // cudaStreamCreateWithPriority(&compute_stream, cudaStreamDefault, // leastPriority); cudaStreamCreateWithPriority(&push_top_stream, // cudaStreamDefault, greatestPriority); // cudaStreamCreateWithPriority(&push_bottom_stream, cudaStreamDefault, // greatestPriority); // for (auto &stream : ak_streams[i]) for(int j = 0; j < static_cast(StreamIndex::TOTAL); ++j) { check_cuda_errors(cudaStreamCreate(&ak_streams[i][j])); } printf("\t[InitInfo -- stream] Create %lu streams for device %d\n", static_cast(ak_streams[i].extent), i); // for (auto &event : ak_events[i]) for(int j = 0; j < static_cast(EventIndex::TOTAL); ++j) { check_cuda_errors(cudaEventCreateWithFlags( &ak_events[i][j],// cudaEventDefault | cudaEventBlockingSync | // cudaEventInterprocess | cudaEventDisableTiming )); } ///< memory allocator std::size_t free_byte, total_byte; check_cuda_errors(cudaMemGetInfo(&free_byte, &total_byte)); /// ak_monotonic_allocators.emplace_back(std::make_unique(prop.textureAlignment, free_byte >> MEM_POOL_CTRL));///< preserve 1/4 space for intermediate ///< computations cudaDeviceSynchronize(); printf( "\t[InitInfo -- memory] device %d\n\t\tfree bytes/total bytes: " "%lu/%lu,\n\t\tpre-allocated size: %lu bytes\n\n", i, static_cast(free_byte), static_cast(total_byte), static_cast(free_byte >> MEM_POOL_CTRL) ); } //< enable peer access for(int i = 0; i < dev_num_available; i++) { for(int j = 0; j < dev_num_available; j++) { if(i != j) { establish_peer_access(i, j); printf("\t[InitInfo -- Peer Access] Enable peer access from %d to %d\n", i, j); } } } //< init cuda context for(int i = 0; i < dev_num_available; i++) { ak_cu_dev_contexts.emplace_back(i);//< set device when construct } printf("\t[InitInfo -- Default Dev] Default context: %d\n", default_dev_id); check_cuda_errors(cudaSetDevice(default_dev_id)); printf("\n[Init -- End] == Finished \'Cuda\' initialization\n\n"); // getchar(); } Cuda::~Cuda() { // cudaStreamDestroy(_kMemCopyStream); get_instance()->ak_device_props.clear(); for(auto& streams: get_instance()->ak_streams) { // for (auto &stream : streams) for(int j = 0; j < static_cast(StreamIndex::TOTAL); ++j) { check_cuda_errors(cudaStreamDestroy(streams[j])); } } for(auto& events: get_instance()->ak_events) { // for (auto &event : events) for(int j = 0; j < static_cast(EventIndex::TOTAL); ++j) { check_cuda_errors(cudaEventDestroy(events[j])); } } //for (auto &monoAllocator : ak_monotonic_allocators){ //for (int i = 0; i < get_instance()->ak_monotonic_allocators.size(); ++i){ // get_instance()->ak_monotonic_allocators[i].~MonotonicAllocator(); //} //} printf(" Finished \'Cuda\' termination\n"); } int Cuda::general_grid_size(int& thread_num, int& block_size) const { return (thread_num + block_size - 1) / block_size; } int Cuda::wave_grid_size(int& thread_num, int& block_size) const { auto blocksPerSM = (thread_num / block_size / get_instance()->ak_device_props[i_dev_id].multiProcessorCount) * get_instance()->ak_device_props[i_dev_id].multiProcessorCount; return (blocksPerSM != 0) ? blocksPerSM : 1; } /// static methods int Cuda::eval_optimal_block_size(cudaFuncAttributes attribs, cudaFuncCache cache_preference, std::size_t smem_bytes) { auto* instance = get_instance(); cudaOccDeviceProp prop = get_instance()->ak_device_props[instance->i_dev_id];///< cache preference cudaOccFuncAttributes occ_attribs = attribs; cudaOccDeviceState occ_cache; switch(cache_preference) { case cudaFuncCachePreferNone: occ_cache.cacheConfig = CACHE_PREFER_NONE; break; case cudaFuncCachePreferShared: occ_cache.cacheConfig = CACHE_PREFER_SHARED; break; case cudaFuncCachePreferL1: occ_cache.cacheConfig = CACHE_PREFER_L1; break; case cudaFuncCachePreferEqual: occ_cache.cacheConfig = CACHE_PREFER_EQUAL; break; default:;///< should throw error } int minGridSize; //TODO: Make constant? int block_size = 32;//NOLINT(readability-magic-numbers) Is block size cudaOccMaxPotentialOccupancyBlockSize(&minGridSize, &block_size, &prop, &occ_attribs, &occ_cache, nullptr, smem_bytes); return block_size; } ExecutionPolicy Cuda::launch_config(std::string kernel_name, int thread_num, bool sync, std::size_t smem_size, cudaStream_t sid) const { (void) sid; auto* instance = get_instance(); if(instance->k_func_table.find(kernel_name) == instance->k_func_table.end()) { //TODO: Make constant? int bs = 256;//NOLINT(readability-magic-numbers) Is block size printf("Warning: Kernel function %s not registered! Use 256 setting!\n", kernel_name.data()); return {general_grid_size(thread_num, bs), bs, smem_size, sync}; } auto& config = instance->k_func_table[kernel_name.data()]; int bs = config.max_occ_block_size; if(smem_size > 0) { bs = eval_optimal_block_size(config.attribs, config.cache_preference, smem_size); } // printf("configurating for kernel[%s] blocksize: %d\n", kernel_name.c_str(), // bs); if(config.wave_fashion) { return {wave_grid_size(thread_num, bs), bs, smem_size, sync}; } return {general_grid_size(thread_num, bs), bs, smem_size, sync}; } void Cuda::register_kernel(std::string tag, KernelFunc f, cudaFuncCache cache_config, bool wave_fashion) { auto* instance = get_instance(); instance->k_func_table.emplace(tag, KernelConfig(f, cache_config, wave_fashion)); printf("Kernel[%s](%s) block size configuration: %d\n", tag.data(), wave_fashion ? "wave" : "general", instance->k_func_table[tag.data()].max_occ_block_size); } const KernelConfig& Cuda::find_kernel(std::string tag) { auto* instance = get_instance(); return instance->k_func_table[tag.data()]; } //NOLINTEND(cppcoreguidelines-pro-type-vararg) Cuda has no other way to print }// namespace mn ================================================ FILE: Library/MnSystem/Cuda/Cuda.h ================================================ #ifndef SYSTEM_CUDA_H #define SYSTEM_CUDA_H #include //#include #include #include #include "Allocators.cuh" #include "ExecutionPolicy.h" #include "HostUtils.hpp" #include "MnBase/Math/Vec.h" #include "MnBase/Meta/AllocMeta.cuh" #include "MnBase/Object/Function.h" #include "MnBase/Singleton.h" namespace mn { using KernelFunc = const void*; struct KernelConfig {///< static kernel attrib, could contain run-time debugger ///< setting(error checking/ time recording etc...) KernelFunc func; cudaFuncAttributes attribs; cudaFuncCache cache_preference; bool wave_fashion; ///< general fashion or loop fashion int max_occ_block_size;///< condition: use no shared memory explicit KernelConfig(KernelFunc f = nullptr, cudaFuncCache cache_config = cudaFuncCachePreferNone, bool is_wave = false); }; class Cuda : public ManagedSingleton { public: /// kernel launching enum class StreamIndex { COMPUTE = 0, H2DCOPY, D2HCOPY, D2DCOPY, SPARE, TOTAL = 32 }; enum class EventIndex { COMPUTE = 0, H2DCOPY, D2HCOPY, D2DCOPY, SPARE, TOTAL = 32 }; struct CudaContext { private: int dev_id; auto monotonicAllocator() -> MonotonicAllocator& { // setContext(); return *Cuda::get_instance()->ak_monotonic_allocators[dev_id]; } public: explicit CudaContext(int dev_id = -1) : dev_id {dev_id} { if(dev_id != -1) { printf("\t[Init] CudaContext %d\n", dev_id); check_cuda_errors(cudaSetDevice(dev_id)); } } //< context & prop void set_context() { check_cuda_errors(cudaSetDevice(dev_id)); } auto get_dev_id() const noexcept { return dev_id; } auto get_context_info() noexcept { return dev_id; } const auto& get_dev_prop() const noexcept { return Cuda::get_instance()->ak_device_props[dev_id]; } /// stream & event // stream template auto stream() const -> cudaStream_t { return Cuda::get_instance()->ak_streams[dev_id][static_cast(sid)]; } auto stream(unsigned sid) const -> cudaStream_t { return Cuda::get_instance()->ak_streams[dev_id][sid]; } auto stream_compute() const -> cudaStream_t { return Cuda::get_instance()->ak_streams[dev_id][static_cast(StreamIndex::COMPUTE)]; } auto stream_spare(unsigned sid = 0) const -> cudaStream_t { return Cuda::get_instance()->ak_streams[dev_id][static_cast(StreamIndex::SPARE) + sid]; } void syncCompute() const { check_cuda_errors(cudaStreamSynchronize(Cuda::get_instance()->ak_streams[dev_id][static_cast(StreamIndex::COMPUTE)])); } template void syncStream() const { check_cuda_errors(cudaStreamSynchronize(Cuda::get_instance()->ak_streams[dev_id][static_cast(sid)])); } void syncStream(unsigned sid) const { check_cuda_errors(cudaStreamSynchronize(Cuda::get_instance()->ak_streams[dev_id][sid])); } void syncStreamSpare(unsigned sid = 0) const { check_cuda_errors(cudaStreamSynchronize(Cuda::get_instance()->ak_streams[dev_id][static_cast(StreamIndex::SPARE) + sid])); } // event auto event_compute() const -> cudaEvent_t { return Cuda::get_instance()->ak_events[dev_id][static_cast(EventIndex::COMPUTE)]; } auto event_spare(unsigned eid = 0) const -> cudaEvent_t { return Cuda::get_instance()->ak_events[dev_id][static_cast(EventIndex::SPARE) + eid]; } auto compute_event_record() { check_cuda_errors(cudaEventRecord(event_compute(), stream_compute())); } auto spare_event_record(unsigned id = 0) { check_cuda_errors(cudaEventRecord(event_spare(id), stream_spare(id))); } void computeStreamWaitForEvent(cudaEvent_t event) { check_cuda_errors(cudaStreamWaitEvent(stream_compute(), event, 0)); } void spareStreamWaitForEvent(unsigned sid, cudaEvent_t event) { check_cuda_errors(cudaStreamWaitEvent(stream_spare(sid), event, 0)); } /// kernel launch ///< 1. compute stream template void compute_launch( LaunchConfig&& lc, Func&& f, Arguments... args ) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); /// compiler will handle type conversions if(lc.dg.x && lc.dg.y && lc.dg.z && lc.db.x && lc.db.y && lc.db.z) { std::forward(f)<<()>>>(args...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("[Dev %d] Kernel launch failure on [COMPUTE stream] %s\n", dev_id, cudaGetErrorString(error)); } } } template void compute_launch( LaunchConfig&& lc, void (*f)(Arguments...), Arguments... args ) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); /// compiler will handle type conversions if(lc.dg.x && lc.dg.y && lc.dg.z && lc.db.x && lc.db.y && lc.db.z) { f<<()>>>(args...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("[Dev %d] Kernel launch failure on [COMPUTE stream] %s\n", dev_id, cudaGetErrorString(error)); } // if(error!= cudaSuccess) getchar(); } } template void spare_launch( unsigned sid, LaunchConfig&& lc, Func&& f, Arguments... args ) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); /// compiler will handle type conversions if(lc.dg.x && lc.dg.y && lc.dg.z && lc.db.x && lc.db.y && lc.db.z) { std::forward(f)<<>>(std::forward(args)...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("[Dev %d] Kernel launch failure on [COMPUTE stream] %s\n", dev_id, cudaGetErrorString(error)); } } } template void spare_launch( unsigned sid, LaunchConfig&& lc, void (*f)(Arguments...), Arguments... args ) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); /// compiler will handle type conversions if(lc.dg.x && lc.dg.y && lc.dg.z && lc.db.x && lc.db.y && lc.db.z) { f<<>>(std::forward(args)...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("[Dev %d] Kernel launch failure on [COMPUTE stream] %s\n", dev_id, cudaGetErrorString(error)); } // if(error!= cudaSuccess) getchar(); } } /// 2. general stream // template // void general_launch(LaunchConfig&& lc, Func&& f, Arguments... args) { // std::forward(f) <<() >>> // (std::forward(args)...); cudaError_t error = // cudaGetLastError(); if (error != cudaSuccess) printf("[Dev %d] Kernel // launch failure on [stream %lu] %s\n", dev_id, (unsigned long)sid, // cudaGetErrorString(error)); // } template void general_launch( LaunchConfig&& lc, void (*f)(Arguments...), Arguments... args ) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); if(lc.dg.x && lc.dg.y && lc.dg.z && lc.db.x && lc.db.y && lc.db.z) { f<<()>>>(std::forward(args)...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("[Dev %d] Kernel launch failure on [stream %lu] %s\n", dev_id, (unsigned long) sid, cudaGetErrorString(error)); } } } ///< 3. pre-allocated memory auto borrow(std::size_t bytes) -> void* { return monotonicAllocator().borrow(bytes); } void reset_mem() { monotonicAllocator().reset(); } ///< 4. cuda memset template void memset(StreamIndex sid, const Integer size, Attrib addr, Type value) { // setContext(); check_cuda_errors(cudaMemsetAsync(addr, value, sizeof(Type) * size, stream((unsigned) sid))); } };//< [end] struct CudaContext private: int dev_num_using; int dev_num_available; int default_dev_id; std::vector ak_cu_dev_contexts; std::vector ak_device_props; std::vector> ak_streams;///< 16 is enough for most needs std::vector> ak_events; std::vector> ak_monotonic_allocators;///< an allocator is a handle to a heap std::unordered_map k_func_table; int i_dev_id;///< need changing public: Cuda(); ~Cuda(); static void register_kernel(std::string tag, KernelFunc f, cudaFuncCache cache_config = cudaFuncCachePreferL1, bool wave_fashion = true); static const KernelConfig& find_kernel(std::string tag); int general_grid_size(int& thread_num, int& block_size) const; int wave_grid_size(int& thread_num, int& block_size) const; static int eval_optimal_block_size(cudaFuncAttributes attribs, cudaFuncCache cache_preference, size_t smem_bytes = 0); ExecutionPolicy launch_config(std::string kernel_name, int thread_num, bool sync = false, size_t smem_size = 0, cudaStream_t sid = cudaStreamDefault) const; auto establish_peer_access(int devA, int devB) { check_cuda_errors(cudaSetDevice(devA)); int canAccessPeer = 0; check_cuda_errors(cudaDeviceCanAccessPeer(&canAccessPeer, devA, devB)); if(canAccessPeer) { check_cuda_errors(cudaDeviceEnablePeerAccess(devB, 0)); // cudaSetDevice(i_dev_id); return true; } // cudaSetDevice(i_dev_id); return false; } //< dev_num info auto dev_using_count() noexcept { return dev_num_using; } auto dev_available_count() noexcept { return dev_num_available; } void set_max_device() noexcept { dev_num_using = dev_num_available; } //< context ref int get_default_dev_id() noexcept { return default_dev_id; } static auto get_device_count() noexcept -> int { return get_instance()->dev_num_available; } static auto ref_cuda_context(int dev_id) noexcept -> CudaContext& { return get_instance()->ak_cu_dev_contexts[dev_id]; } }; }// namespace mn #endif ================================================ FILE: Library/MnSystem/Cuda/DeviceUtils.cu ================================================ #include "DeviceUtils.cuh" namespace mn { template __device__ int retrieve_block_local_offset(int level, uint64_t block_offset) {///< the level number starts from 0 return (block_offset >> (NumPageBits + level * 3)) & 7; } }// namespace mn ================================================ FILE: Library/MnSystem/Cuda/DeviceUtils.cuh ================================================ #ifndef DEVICE_UTILS_CUH #define DEVICE_UTILS_CUH #include #include #include namespace mn { namespace cg = cooperative_groups; __forceinline__ __device__ double unsigned_longlong_as_double(unsigned long long val) { const long long val_as_ll = *static_cast(static_cast(&val)); return __longlong_as_double(val_as_ll); } __forceinline__ __device__ unsigned long long double_as_unsigned_longlong(double val) { const long long val_as_ll = __double_as_longlong(val); return *static_cast(static_cast(&val_as_ll)); } __forceinline__ __device__ int clzull(unsigned long long val) { const long long val_as_ll = *static_cast(static_cast(&val)); return __clzll(val_as_ll); } template __forceinline__ __device__ bool atomic_min(T* address, T val); template __forceinline__ __device__ bool atomic_max(T* address, T val); template __forceinline__ __device__ T atomic_add_float(T* address, T val); template<> __forceinline__ __device__ float atomic_add_float(float* address, float val) { int* address_as_i = static_cast(static_cast(address)); int old = *address_as_i; int assumed; do { assumed = old; old = atomicCAS(address_as_i, assumed, __float_as_int(val + __int_as_float(assumed))); } while(assumed != old); return __int_as_float(old); } template<> __forceinline__ __device__ double atomic_add_float(double* address, double val) { unsigned long long* address_as_ull = static_cast(static_cast(address)); unsigned long long old = *address_as_ull; unsigned long long assumed; do { assumed = old; old = atomicCAS(address_as_ull, assumed, double_as_unsigned_longlong(val + unsigned_longlong_as_double(assumed))); } while(assumed != old); return unsigned_longlong_as_double(old); } template<> __forceinline__ __device__ bool atomic_min(float* address, float val) { int* address_as_i = static_cast(static_cast(address)); int old = *address_as_i; int assumed; if(*address <= val) { return false; } do { assumed = old; old = ::atomicCAS(address_as_i, assumed, __float_as_int(::fminf(val, __int_as_float(assumed)))); } while(assumed != old); return true; } template<> __forceinline__ __device__ bool atomic_max(float* address, float val) { int* address_as_i = static_cast(static_cast(address)); int old = *address_as_i; int assumed; if(*address >= val) { return false; } do { assumed = old; old = ::atomicCAS(address_as_i, assumed, __float_as_int(::fmaxf(val, __int_as_float(assumed)))); } while(assumed != old); return true; } template<> __forceinline__ __device__ bool atomic_min(double* address, double val) { #ifdef _WIN32 uint64_t* address_as_ull = static_cast(static_cast(address)); uint64_t old = *address_as_ull; uint64_t assumed; #else unsigned long long* address_as_ull = static_cast(static_cast(address)); unsigned long long old = *address_as_ull; unsigned long long assumed; #endif// _WIN32 if(*address <= val) { return false; } do { assumed = old; old = ::atomicCAS(address_as_ull, assumed, double_as_unsigned_longlong(::fmin(val, unsigned_longlong_as_double(assumed)))); } while(assumed != old); return true; } template<> __forceinline__ __device__ bool atomic_max(double* address, double val) { #ifdef _WIN32 uint64_t* address_as_ull = static_cast(static_cast(address)); uint64_t old = *address_as_ull; uint64_t assumed; #else unsigned long long* address_as_ull = static_cast(static_cast(address)); unsigned long long old = *address_as_ull; unsigned long long assumed; #endif// _WIN32 if(*address >= val) { return false; } do { assumed = old; old = ::atomicCAS(address_as_ull, assumed, double_as_unsigned_longlong(::fmax(val, unsigned_longlong_as_double(assumed)))); } while(assumed != old); return true; } __device__ uint64_t packed_add(const uint64_t* masks, const uint64_t i, const uint64_t j); template __device__ uint64_t packed_add_father_neighbor(const uint64_t* masks, const uint64_t child_offset, const int father_level, const uint64_t father_neighbor_offset); template __device__ int retrieve_block_local_offset(int level, uint64_t block_offset); __forceinline__ __device__ uint64_t bit_spread_cuda(const uint64_t mask, int data) { uint64_t rmask = __brevll(mask); uint64_t result = 0; unsigned char lz; unsigned char offset = clzull(rmask); while(rmask != 0) { lz = clzull(rmask) + 1; result = result << lz | (data & 1); data >>= 1, rmask <<= lz; } result = __brevll(result) >> clzull(mask); return result; } //NOLINTBEGIN(cppcoreguidelines-pro-type-union-access) Allowed in CUDA __forceinline__ __device__ int bit_pack_cuda(const uint64_t mask, uint64_t data) { union { uint64_t slresult; uint64_t ulresult; } un = {};//FIXME:Why this union? (Both members have the same type) int count = 0; un.ulresult = 0; uint64_t rmask = __brevll(mask); unsigned char lz; while(rmask != 0) { lz = clzull(rmask); data >>= lz; un.ulresult <<= 1; count++; un.ulresult |= (data & 1); data >>= 1; rmask <<= lz + 1; } //NOLINTNEXTLINE(readability-magic-numbers) Define as constant? un.ulresult <<= 64 - count;// 64 means 64 bits ... maybe not use a constant 64 ... un.ulresult = __brevll(un.ulresult); return static_cast(un.slresult); } //NOLINTEND(cppcoreguidelines-pro-type-union-access) template __forceinline__ __device__ T atomic_agg_inc(T* p) { //Create group for all threads in this warp cg::coalesced_group g = cg::coalesced_threads(); //First thread increases size T prev; if(g.thread_rank() == 0) { prev = atomicAdd(p, g.size()); } //All threads fetch the value from the first thread and add their rank as offset prev = g.thread_rank() + g.shfl(prev, 0); return prev; } }// namespace mn #endif ================================================ FILE: Library/MnSystem/Cuda/ExecutionPolicy.h ================================================ #ifndef CUDA_EXECUTION_POLICY_H #define CUDA_EXECUTION_POLICY_H #include #include namespace mn { struct LaunchConfig { dim3 dg {}; dim3 db {}; std::size_t shmem {0}; cudaStream_t sid {cudaStreamDefault}; template LaunchConfig(IndexType0 gs, IndexType1 bs) : dg {static_cast(gs)} , db {static_cast(bs)} , shmem {0} , sid {cudaStreamDefault} {} template LaunchConfig(IndexType0 gs, IndexType1 bs, IndexType2 mem) : dg {static_cast(gs)} , db {static_cast(bs)} , shmem {static_cast(mem)} , sid {cudaStreamDefault} {} template LaunchConfig(IndexType0 gs, IndexType1 bs, IndexType2 mem, cudaStream_t stream) : dg {static_cast(gs)} , db {static_cast(bs)} , shmem {static_cast(mem)} , sid {stream} {} }; struct LaunchInput {///< could contain more information on operation (error checking/ time recording/ etc...) private: const std::string kernel_name; const int num_threads; const std::size_t shared_mem_bytes; public: LaunchInput() = delete; LaunchInput(std::string kernel, int task_num, std::size_t shared_mem_bytes = 0) : kernel_name(kernel) , num_threads(task_num) , shared_mem_bytes(shared_mem_bytes) {} const std::string& name() { return kernel_name; } const int& threads() { return num_threads; } const std::size_t& mem_bytes() { return shared_mem_bytes; } }; /// kernel launching configuration struct ExecutionPolicy { private: int grid_size {0}; int block_size {0}; std::size_t shared_mem_bytes {0}; bool sync {false}; public: ExecutionPolicy() {} ExecutionPolicy(int gs, int bs, std::size_t memsize, bool s) : grid_size(gs) , block_size(bs) , shared_mem_bytes(memsize) , sync(s) {} int get_grid_size() const { return grid_size; } int get_block_size() const { return block_size; } std::size_t get_shared_mem_bytes() const { return shared_mem_bytes; } bool need_sync() const { return sync; } }; }// namespace mn #endif ================================================ FILE: Library/MnSystem/Cuda/HostUtils.hpp ================================================ #ifndef HOST_UTILS_HPP #define HOST_UTILS_HPP #include #include #include namespace mn { #define check_thrust_errors(func) \ try { \ func; \ } catch(thrust::system_error & e) { \ std::cout << std::string(__FILE__) << ":" << __LINE__ << " " << e.what() << std::endl; \ } inline static const char* cuda_get_error_enum(cudaError_t error) { return cudaGetErrorName(error); } #ifdef __DRIVER_TYPES_H__ # ifndef DEVICE_RESET # define DEVICE_RESET cudaDeviceReset(); # endif #else # ifndef DEVICE_RESET # define DEVICE_RESET # endif #endif template void check(T result, char const* const func, const char* const file, int const line) { if(result) { fprintf(stderr, "CUDA error at %s:%d code=%d(%s) \"%s\" \n", file, line, static_cast(result), cuda_get_error_enum(result), func); DEVICE_RESET // Make sure we call CUDA Device Reset before exiting exit(EXIT_FAILURE); } } // This will output the proper CUDA error strings in the event // that a CUDA host call returns an error #define check_cuda_errors(val) check((val), #val, __FILE__, __LINE__) // This will output the proper error string when calling cudaGetLastError #define get_last_cuda_error(msg) get_last_cuda_error_impl(msg, __FILE__, __LINE__) inline void get_last_cuda_error_impl(const char* errorMessage, const char* file, const int line) { cudaError_t err = cudaGetLastError(); if(cudaSuccess != err) { fprintf( stderr, "%s(%i) : get_last_cuda_error() CUDA error :" " %s : (%d) %s.\n", file, line, errorMessage, static_cast(err), cudaGetErrorString(err) ); DEVICE_RESET exit(EXIT_FAILURE); } } template __inline__ __host__ T* get_raw_ptr(thrust::device_vector& V) { return thrust::raw_pointer_cast(V.data()); } template __inline__ __host__ thrust::device_ptr get_device_ptr(thrust::device_vector& V) { return thrust::device_ptr(thrust::raw_pointer_cast(V.data())); } template __inline__ __host__ thrust::device_ptr get_device_ptr(T* V) { return thrust::device_ptr(V); } inline void report_memory(std::string msg) { std::size_t free_byte; std::size_t total_byte; cudaError_t cuda_status = cudaMemGetInfo(&free_byte, &total_byte); if(cudaSuccess != cuda_status) { printf("Error: cudaMemGetInfo fails, %s \n", cudaGetErrorString(cuda_status)); exit(1); } double free_db = (double) free_byte; double total_db = (double) total_byte; double used_db = total_db - free_db; printf("GPU memory usage (%s): used = %f, free = %f MB, total = %f MB\n", msg.data(), used_db / 1024.0 / 1024.0, free_db / 1024.0 / 1024.0, total_db / 1024.0 / 1024.0); } }// namespace mn #endif ================================================ FILE: Library/MnSystem/Cuda/KernelLauncher.cuh ================================================ #ifndef KERNEL_LAUNCHER_CUH #define KERNEL_LAUNCHER_CUH #include "ExecutionPolicy.h" #include "MnUtility/Profiler/Performance/CudaTimer.cuh" namespace mn { template void cuda_launch(LaunchConfig&& lc, Func&& f, Arguments... args) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); /// compiler will handle type conversions std::forward(f)<<>>(std::forward(args)...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("Kernel launch failure %s\n", cudaGetErrorString(error)); } } /// backup template void cuda_launch(LaunchConfig&& lc, void (*f)(Arguments...), Arguments... args) {///< launch on the current device static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); /// compiler will handle type conversions f<<>>(std::forward(args)...); cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("Kernel launch failure %s\n", cudaGetErrorString(error)); } } /// option: 1 error checking 2 execution time recording 3 synchronizing template void debug_launch(int gs, int bs, void (*f)(Arguments...), Arguments... args) { static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); cudaError_t error; f<<>>(std::forward(args)...); cudaDeviceSynchronize(); error = cudaGetLastError(); if(error != cudaSuccess) { printf("Kernel launch failure %s\n", cudaGetErrorString(error)); } } template void record_launch(std::string&& tag, int gs, int bs, std::size_t mem, void (*f)(Arguments...), Arguments... args) { static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); CudaTimer timer; if(!mem) { timer.tick(); f<<>>(std::forward(args)...); timer.tock(tag); } else { timer.tick(); f<<>>(std::forward(args)...); timer.tock(tag); } cudaError_t error = cudaGetLastError(); if(error != cudaSuccess) { printf("Kernel launch failure %s\n", cudaGetErrorString(error)); } } template void cleanLaunch(int gs, int bs, void (*f)(Arguments...), Arguments... args) { static_assert(!std::disjunction...>::value, "Cannot pass values to Cuda kernels by reference"); f<<>>(args...); } }// namespace mn #endif ================================================ FILE: Library/MnSystem/Cuda/MemoryUtils.cu ================================================ #include "Cuda.h" #include "MemoryUtils.cuh" namespace mn {}// namespace mn ================================================ FILE: Library/MnSystem/Cuda/MemoryUtils.cuh ================================================ #ifndef MEMORY_UTILS_CUH #define MEMORY_UTILS_CUH #include "Allocators.cuh" namespace mn {}// namespace mn #endif ================================================ FILE: Library/MnSystem/IO/IO.cpp ================================================ #include "IO.h" //#include //#include //#include namespace mn { /* void f() { double foo = -0.0; double bar = 0.0; auto res = foo <=> bar; if (res < 0) std::cout << "-0 is less than 0"; else if (res == 0) std::cout << "-0 and 0 are equal"; else if (res > 0) std::cout << "-0 is greater than 0"; } */ }// namespace mn ================================================ FILE: Library/MnSystem/IO/IO.h ================================================ #ifndef IO_H #define IO_H #include #include "MnBase/Concurrency/Concurrency.h" #include "MnBase/Singleton.h" namespace mn { struct IO : Singleton { private: bool b_running; std::mutex mut; std::condition_variable cv; ThreadsafeQueue> jobs; std::thread th; void wait() { std::unique_lock lk {mut}; cv.wait(lk, [this]() { return !this->b_running || !this->jobs.empty(); }); }; void worker() { while(b_running) { wait(); auto job = jobs.try_pop(); if(job) { (*job)(); } } } public: IO() : b_running {true} { th = std::thread([this]() { this->worker(); }); } ~IO() { while(!jobs.empty()) { cv.notify_all(); } b_running = false; th.join(); } //TODO: Maybe implement IO(IO& other) = delete; IO(IO&& other) = delete; IO& operator=(IO& other) = delete; IO& operator=(IO&& other) = delete; static void flush() { while(!instance().jobs.empty()) { instance().cv.notify_all(); } } static void insert_job(const std::function& job) { std::unique_lock lk {instance().mut}; instance().jobs.push(job); lk.unlock(); instance().cv.notify_all(); } }; }// namespace mn #endif ================================================ FILE: Library/MnSystem/IO/ParticleIO.hpp ================================================ #ifndef __PARTICLE_IO_HPP_ #define __PARTICLE_IO_HPP_ #include #include #include #include #include "MnBase/Math/Vec.h" #include "PoissonDisk/SampleGenerator.h" namespace mn { template void write_partio(const std::string& filename, const std::vector>& data, const std::string& tag = std::string {"position"}) { Partio::ParticlesDataMutable* parts = Partio::create(); Partio::ParticleAttribute attrib = parts->addAttribute(tag.c_str(), Partio::VECTOR, dim); parts->addParticles(data.size()); for(int idx = 0; idx < (int) data.size(); ++idx) { float* val = parts->dataWrite(attrib, idx); for(int k = 0; k < dim; k++) { val[k] = data[idx][k]; } } Partio::write(filename.c_str(), *parts); parts->release(); } /// have issues auto read_sdf(const std::string& fn, float ppc, float dx, vec offset, vec lengths) { std::vector> data; std::string filename = std::string(AssetDirPath) + "MpmParticles/" + fn; float levelsetDx; SampleGenerator pd; std::vector samples; vec mins; vec maxs; vec scales; vec maxns; pd.LoadSDF(filename, levelsetDx, mins[0], mins[1], mins[2], maxns[0], maxns[1], maxns[2]); maxs = maxns.cast() * levelsetDx; scales = lengths / (maxs - mins); float scale = scales[0] < scales[1] ? scales[0] : scales[1]; scale = scales[2] < scale ? scales[2] : scale; float samplePerLevelsetCell = ppc * levelsetDx / dx * scale; pd.GenerateUniformSamples(samplePerLevelsetCell, samples); for(int i = 0, size = samples.size() / 3; i < size; i++) { vec p {samples[i * 3 + 0], samples[i * 3 + 1], samples[i * 3 + 2]}; p = (p - mins) * scale + offset; // particle[0] = ((samples[i * 3 + 0]) + offset[0]); // particle[1] = ((samples[i * 3 + 1]) + offset[1]); // particle[2] = ((samples[i * 3 + 2]) + offset[2]); data.push_back(std::array {p[0], p[1], p[2]}); } printf("[%f, %f, %f] - [%f, %f, %f], scale %f, parcount %d, lsdx %f, dx %f\n", mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2], scale, (int) data.size(), levelsetDx, dx); return data; } auto read_sdf(const std::string& fn, float ppc, float dx, int domainsize, vec offset, vec lengths) { std::vector> data; std::string filename = std::string(AssetDirPath) + "MpmParticles/" + fn; float levelsetDx; SampleGenerator pd; std::vector samples; vec mins; vec maxs; vec scales; vec maxns; pd.LoadSDF(filename, levelsetDx, mins[0], mins[1], mins[2], maxns[0], maxns[1], maxns[2]); maxs = maxns.cast() * levelsetDx; scales = maxns.cast() / domainsize; float scale = scales[0] < scales[1] ? scales[0] : scales[1]; scale = scales[2] < scale ? scales[2] : scale; float samplePerLevelsetCell = ppc * scale; pd.GenerateUniformSamples(samplePerLevelsetCell, samples); scales = lengths / (maxs - mins) / maxns.cast(); scale = scales[0] < scales[1] ? scales[0] : scales[1]; scale = scales[2] < scale ? scales[2] : scale; for(int i = 0, size = samples.size() / 3; i < size; i++) { vec p {samples[i * 3 + 0], samples[i * 3 + 1], samples[i * 3 + 2]}; p = (p - mins) * scale + offset; data.push_back(std::array {p[0], p[1], p[2]}); } printf("[%f, %f, %f] - [%f, %f, %f], scale %f, parcount %d, lsdx %f, dx %f\n", mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2], scale, (int) data.size(), levelsetDx, dx); return data; } }// namespace mn #endif ================================================ FILE: Library/MnSystem/IO/PoissonDisk/PoissonDisk.h ================================================ #include #include #include #include #include "cyPoint.h" #include "cySampleElim.h" class PoissonDisk { public: PoissonDisk(); ~PoissonDisk(); void LoadSDF(std::string filename); void GenerateSamples(int samplesPerVol, std::vector& outputSamples, int inputScale = 5); protected: inline float fetchGrid(int i, int j, int k) { return m_phiGrid[i + m_ni * (j + m_nj * k)]; } inline float fetchGridTrilinear(float x, float y, float z) { float dx = x - floor(x); float dy = y - floor(y); float dz = z - floor(z); float c000 = fetchGrid(floor(x), floor(y), floor(z)); float c001 = fetchGrid(floor(x), floor(y), ceil(z)); float c010 = fetchGrid(floor(x), ceil(y), floor(z)); float c011 = fetchGrid(floor(x), ceil(y), ceil(z)); float c100 = fetchGrid(ceil(x), floor(y), floor(z)); float c101 = fetchGrid(ceil(x), floor(y), ceil(z)); float c110 = fetchGrid(ceil(x), ceil(y), floor(z)); float c111 = fetchGrid(ceil(x), ceil(y), ceil(z)); float c00 = c000 * (1 - dx) + c100 * dx; float c01 = c001 * (1 - dx) + c101 * dx; float c10 = c010 * (1 - dx) + c110 * dx; float c11 = c011 * (1 - dx) + c111 * dx; float c0 = c00 * (1 - dy) + c10 * dy; float c1 = c01 * (1 - dy) + c11 * dy; return c0 * (1 - dz) + c1 * dz; } private: int m_ni, m_nj, m_nk; float m_dx; int m_padding; cyPoint3f m_minBox; std::vector m_phiGrid; cy::WeightedSampleElimination m_wse; }; PoissonDisk::PoissonDisk() {} PoissonDisk::~PoissonDisk() {} void PoissonDisk::LoadSDF(std::string filename) { std::ifstream infile(filename); infile >> m_ni >> m_nj >> m_nk; infile >> m_minBox[0] >> m_minBox[1] >> m_minBox[2]; infile >> m_dx; std::cout << "load grid size " << m_ni << ", " << m_nj << ", " << m_nk << std::endl; int gridSize = m_ni * m_nj * m_nk; m_phiGrid.resize(gridSize); for(int i = 0; i < gridSize; ++i) { infile >> m_phiGrid[i]; } infile.close(); } void PoissonDisk::GenerateSamples(int samplesPerVol, std::vector& outputSamples, int inputScale) { int numSamples = m_phiGrid.size() * samplesPerVol; std::cout << "Generate input " << numSamples * inputScale << " samples..."; std::vector inputPoints(numSamples * inputScale); for(size_t i = 0; i < inputPoints.size(); i++) { inputPoints[i].x = (float) rand() / RAND_MAX * (m_ni - 1); inputPoints[i].y = (float) rand() / RAND_MAX * (m_nj - 1); inputPoints[i].z = (float) rand() / RAND_MAX * (m_nk - 1); } std::cout << "done\n"; std::cout << "Eliminate samples..."; std::vector tmpPoints; tmpPoints.resize(numSamples); m_wse.Eliminate(inputPoints.data(), inputPoints.size(), tmpPoints.data(), tmpPoints.size()); std::cout << "done\n"; outputSamples.clear(); for(int i = 0; i < (int) tmpPoints.size(); i++) { if(fetchGridTrilinear(tmpPoints[i].x, tmpPoints[i].y, tmpPoints[i].z) < 0) { outputSamples.push_back(tmpPoints[i].x); outputSamples.push_back(tmpPoints[i].y); outputSamples.push_back(tmpPoints[i].z); } } } ================================================ FILE: Library/MnSystem/IO/PoissonDisk/SampleGenerator.h ================================================ #if 1 # include # include # include # include # include # include # include "cyPoint.h" # include "cySampleElim.h" class SampleGenerator { public: SampleGenerator(); ~SampleGenerator(); void test(); void LoadSDF(std::string filename, float& pDx, float& minx, float& miny, float& minz, int& ni, int& nj, int& nk); void GeneratePoissonSamples(float samplesPerVol, std::vector& outputSamples, int inputScale = 5); void GeneratePoissonSamples(int length, int width, int height, float scale, int outputSamplesNumber, std::vector& outputSamples, int inputScale = 5); int GenerateUniformSamples(float samplesPerVol, std::vector& outputSamples); protected: inline float fetchGrid(int i, int j, int k) { return m_phiGrid[i + m_ni * (j + m_nj * k)]; } inline float fetchGridTrilinear(float x, float y, float z) { float dx = x - floor(x); float dy = y - floor(y); float dz = z - floor(z); float c000 = fetchGrid((int) floor(x), (int) floor(y), (int) floor(z)); float c001 = fetchGrid((int) floor(x), (int) floor(y), (int) ceil(z)); float c010 = fetchGrid((int) floor(x), (int) ceil(y), (int) floor(z)); float c011 = fetchGrid((int) floor(x), (int) ceil(y), (int) ceil(z)); float c100 = fetchGrid((int) ceil(x), (int) floor(y), (int) floor(z)); float c101 = fetchGrid((int) ceil(x), (int) floor(y), (int) ceil(z)); float c110 = fetchGrid((int) ceil(x), (int) ceil(y), (int) floor(z)); float c111 = fetchGrid((int) ceil(x), (int) ceil(y), (int) ceil(z)); float c00 = c000 * (1 - dx) + c100 * dx; float c01 = c001 * (1 - dx) + c101 * dx; float c10 = c010 * (1 - dx) + c110 * dx; float c11 = c011 * (1 - dx) + c111 * dx; float c0 = c00 * (1 - dy) + c10 * dy; float c1 = c01 * (1 - dy) + c11 * dy; return c0 * (1 - dz) + c1 * dz; } private: int m_ni, m_nj, m_nk; float m_dx; int m_padding; cyPoint3f m_minBox; std::vector m_phiGrid; cy::WeightedSampleElimination m_wse; }; SampleGenerator::SampleGenerator() {} SampleGenerator::~SampleGenerator() {} void SampleGenerator::LoadSDF(std::string filename, float& pDx, float& minx, float& miny, float& minz, int& ni, int& nj, int& nk) { std::ifstream infile(filename); infile >> m_ni >> m_nj >> m_nk; infile >> m_minBox[0] >> m_minBox[1] >> m_minBox[2]; infile >> m_dx; //std::cout << m_dx << std::endl; pDx = m_dx; ni = m_ni; nj = m_nj; nk = m_nk; minx = m_minBox[0]; miny = m_minBox[1]; minz = m_minBox[2]; std::cout << "load grid size " << m_ni << ", " << m_nj << ", " << m_nk << std::endl; int gridSize = m_ni * m_nj * m_nk; m_phiGrid.resize(gridSize); for(int i = 0; i < gridSize; ++i) { infile >> m_phiGrid[i]; } infile.close(); } void SampleGenerator::GeneratePoissonSamples(int length, int width, int height, float scale, int outputSamplesNumber, std::vector& outputSamples, int inputScale) { int numSamples = outputSamplesNumber; std::cout << "Generate input " << numSamples * inputScale << " samples..."; std::vector inputPoints(numSamples * inputScale); for(size_t i = 0; i < inputPoints.size(); i++) { inputPoints[i].x = (float) rand() / RAND_MAX * length; inputPoints[i].y = (float) rand() / RAND_MAX * width; inputPoints[i].z = (float) rand() / RAND_MAX * height; } std::cout << "done\n"; std::cout << "Eliminate samples..."; std::vector tmpPoints; tmpPoints.resize(numSamples); m_wse.Eliminate(inputPoints.data(), inputPoints.size(), tmpPoints.data(), tmpPoints.size()); std::cout << "done\n"; for(int i = 0; i < (int) tmpPoints.size(); i++) { outputSamples.push_back(tmpPoints[i].x * scale); outputSamples.push_back(tmpPoints[i].y * scale); outputSamples.push_back(tmpPoints[i].z * scale); } } void SampleGenerator::GeneratePoissonSamples(float samplesPerVol, std::vector& outputSamples, int inputScale) { int numSamples = m_phiGrid.size() * samplesPerVol; std::cout << "Generate input " << numSamples * inputScale << " samples..."; std::vector inputPoints(numSamples * inputScale); for(size_t i = 0; i < inputPoints.size(); i++) { inputPoints[i].x = (float) rand() / RAND_MAX * (m_ni - 1); inputPoints[i].y = (float) rand() / RAND_MAX * (m_nj - 1); inputPoints[i].z = (float) rand() / RAND_MAX * (m_nk - 1); } std::cout << "done\n"; std::cout << "Eliminate samples..."; std::vector tmpPoints; tmpPoints.resize(numSamples); m_wse.Eliminate(inputPoints.data(), inputPoints.size(), tmpPoints.data(), tmpPoints.size()); std::cout << "done\n"; outputSamples.clear(); for(int i = 0; i < (int) tmpPoints.size(); i++) { if(fetchGridTrilinear(tmpPoints[i].x, tmpPoints[i].y, tmpPoints[i].z) < 0) { outputSamples.push_back(tmpPoints[i].x); outputSamples.push_back(tmpPoints[i].y); outputSamples.push_back(tmpPoints[i].z); } } } # if 1 int SampleGenerator::GenerateUniformSamples(float samplesPerCell, std::vector& outputSamples) { // get total sample number int validCellNum = 0; for(int i = 0; i < m_ni - 1; i++) { for(int j = 0; j < m_nj - 1; j++) { for(int k = 0; k < m_nk - 1; k++) { if(fetchGrid(i, j, k) < 0 || fetchGrid(i, j, k + 1) < 0 || fetchGrid(i, j + 1, k) < 0 || fetchGrid(i, j + 1, k + 1) < 0 || fetchGrid(i + 1, j, k) < 0 || fetchGrid(i + 1, j, k + 1) < 0 || fetchGrid(i + 1, j + 1, k) < 0 || fetchGrid(i + 1, j + 1, k + 1) < 0) validCellNum++; } } } int sampleNum = validCellNum * samplesPerCell; for(int i = 0; i < sampleNum; i++) { cyPoint3f tmpPoint; do { tmpPoint.x = (float) rand() / RAND_MAX * (m_ni - 1); tmpPoint.y = (float) rand() / RAND_MAX * (m_nj - 1); tmpPoint.z = (float) rand() / RAND_MAX * (m_nk - 1); } while(fetchGridTrilinear(tmpPoint.x, tmpPoint.y, tmpPoint.z) >= 0); outputSamples.push_back(tmpPoint.x); outputSamples.push_back(tmpPoint.y); outputSamples.push_back(tmpPoint.z); } return sampleNum; } # endif void SampleGenerator::test() { /* std::vector< cy::Point3f > inputPoints(160000);*/ //for (size_t i = 0; i < inputPoints.size(); i++) { //inputPoints[i].x = (float)rand() / RAND_MAX; //inputPoints[i].y = (float)rand() / RAND_MAX; //inputPoints[i].z = (float)rand() / RAND_MAX; //} //std::vector< cy::Point3f > outputPoints(32000); //std::clock_t start; //double duration; //start = std::clock(); //m_dx = m_wse.Eliminate(inputPoints.data(), inputPoints.size(), //outputPoints.data(), outputPoints.size()); //duration = (std::clock() - start) / (double)CLOCKS_PER_SEC; //std::cout << "time = " << duration << '\n'; //float minRadius = 255; //for (int i = 0; i < 12000; i++) //for (int j = 0; j < 12000; j++) //{ //if (i == j) continue; //float tmp = (outputPoints[i] - outputPoints[j]).Length(); //minRadius = fminf(minRadius, tmp); //} //std::cout << "min radius = " << minRadius << std::endl; //std::cout << m_dx << std::endl; /*std::cout << minRadius / m_dx << std::endl;*/ //int gNi = 10, gNj = 10, gNk = 10; //int samplesPerSubcell = 12; //int inputScale = 5; //int sampleVolume = gNi * gNj * gNk; //int inputSampleCount = sampleVolume * samplesPerSubcell * inputScale; //int outputSampleCount = sampleVolume * samplesPerSubcell; //std::vector inputSamples; //inputSamples.resize(inputSampleCount); //int c = 0; //for (int i = 0; i < gNi; i++) for (int j = 0; j < gNj; j++) for (int k = 0; k < gNk; k++) // for (int si = 0; si < samplesPerSubcell * inputScale; si++) // { // inputSamples[c][0] = (float)rand() / RAND_MAX; // inputSamples[c][1] = (float)rand() / RAND_MAX; // inputSamples[c][2] = (float)rand() / RAND_MAX; // c++; // } //std::vector tmpPoints; //tmpPoints.resize(outputSampleCount); //m_wse.Eliminate(inputSamples.data(), inputSamples.size(), tmpPoints.data(), tmpPoints.size()); //float minRadius = 255; //for (int i = 0; i < outputSampleCount; i++) // for (int j = 0; j < outputSampleCount; j++) // { // if (i == j) continue; // float tmp = (tmpPoints[i] - tmpPoints[j]).Length(); // minRadius = fminf(minRadius, tmp); // } //std::cout << "min radius = " << minRadius << std::endl; } #else # include # include # include # include # include # include # include "cyPoint.h" # include "cySampleElim.h" class SampleGenerator { public: SampleGenerator(); ~SampleGenerator(); void test(); void LoadSDF(std::string filename); void GeneratePoissonSamples(int samplesPerVol, std::vector& outputSamples, int inputScale = 5); int GenerateUniformSamples(int samplesPerVol, std::vector& outputSamples); protected: inline float fetchGrid(int i, int j, int k) { return m_phiGrid[i + m_ni * (j + m_nj * k)]; } inline float fetchGridTrilinear(float x, float y, float z) { float dx = x - floor(x); float dy = y - floor(y); float dz = z - floor(z); float c000 = fetchGrid((int) floor(x), (int) floor(y), (int) floor(z)); float c001 = fetchGrid((int) floor(x), (int) floor(y), (int) ceil(z)); float c010 = fetchGrid((int) floor(x), (int) ceil(y), (int) floor(z)); float c011 = fetchGrid((int) floor(x), (int) ceil(y), (int) ceil(z)); float c100 = fetchGrid((int) ceil(x), (int) floor(y), (int) floor(z)); float c101 = fetchGrid((int) ceil(x), (int) floor(y), (int) ceil(z)); float c110 = fetchGrid((int) ceil(x), (int) ceil(y), (int) floor(z)); float c111 = fetchGrid((int) ceil(x), (int) ceil(y), (int) ceil(z)); float c00 = c000 * (1 - dx) + c100 * dx; float c01 = c001 * (1 - dx) + c101 * dx; float c10 = c010 * (1 - dx) + c110 * dx; float c11 = c011 * (1 - dx) + c111 * dx; float c0 = c00 * (1 - dy) + c10 * dy; float c1 = c01 * (1 - dy) + c11 * dy; return c0 * (1 - dz) + c1 * dz; } private: int m_ni, m_nj, m_nk; float m_dx; int m_padding; cyPoint3f m_minBox; std::vector m_phiGrid; cy::WeightedSampleElimination m_wse; }; SampleGenerator::SampleGenerator() {} SampleGenerator::~SampleGenerator() {} void SampleGenerator::LoadSDF(std::string filename) { std::ifstream infile(filename); infile >> m_ni >> m_nj >> m_nk; infile >> m_minBox[0] >> m_minBox[1] >> m_minBox[2]; infile >> m_dx; std::cout << "load grid size " << m_ni << ", " << m_nj << ", " << m_nk << std::endl; int gridSize = m_ni * m_nj * m_nk; m_phiGrid.resize(gridSize); for(int i = 0; i < gridSize; ++i) { infile >> m_phiGrid[i]; } infile.close(); } void SampleGenerator::GeneratePoissonSamples(int samplesPerVol, std::vector& outputSamples, int inputScale) { int numSamples = m_phiGrid.size() * samplesPerVol; std::cout << "Generate input " << numSamples * inputScale << " samples..."; std::vector inputPoints(numSamples * inputScale); for(size_t i = 0; i < inputPoints.size(); i++) { inputPoints[i].x = (float) rand() / RAND_MAX * (m_ni - 1); inputPoints[i].y = (float) rand() / RAND_MAX * (m_nj - 1); inputPoints[i].z = (float) rand() / RAND_MAX * (m_nk - 1); } std::cout << "done\n"; std::cout << "Eliminate samples..."; std::vector tmpPoints; tmpPoints.resize(numSamples); m_wse.Eliminate(inputPoints.data(), inputPoints.size(), tmpPoints.data(), tmpPoints.size()); std::cout << "done\n"; outputSamples.clear(); for(int i = 0; i < (int) tmpPoints.size(); i++) { if(fetchGridTrilinear(tmpPoints[i].x, tmpPoints[i].y, tmpPoints[i].z) < 0) { outputSamples.push_back(tmpPoints[i].x); outputSamples.push_back(tmpPoints[i].y); outputSamples.push_back(tmpPoints[i].z); } } } int SampleGenerator::GenerateUniformSamples(int samplesPerCell, std::vector& outputSamples) { // get total sample number int validCellNum = 0; for(int i = 0; i < m_ni - 1; i++) { for(int j = 0; j < m_nj - 1; j++) { for(int k = 0; k < m_nk - 1; k++) { if(fetchGrid(i, j, k) < 0 || fetchGrid(i, j, k + 1) < 0 || fetchGrid(i, j + 1, k) < 0 || fetchGrid(i, j + 1, k + 1) < 0 || fetchGrid(i + 1, j, k) < 0 || fetchGrid(i + 1, j, k + 1) < 0 || fetchGrid(i + 1, j + 1, k) < 0 || fetchGrid(i + 1, j + 1, k + 1) < 0) validCellNum++; } } } int sampleNum = validCellNum * samplesPerCell; for(int i = 0; i < sampleNum; i++) { cyPoint3f tmpPoint; do { tmpPoint.x = (float) rand() / RAND_MAX * (m_ni - 1); tmpPoint.y = (float) rand() / RAND_MAX * (m_nj - 1); tmpPoint.z = (float) rand() / RAND_MAX * (m_nk - 1); } while(fetchGridTrilinear(tmpPoint.x, tmpPoint.y, tmpPoint.z) >= 0); outputSamples.push_back(tmpPoint.x); outputSamples.push_back(tmpPoint.y); outputSamples.push_back(tmpPoint.z); } return sampleNum; } void SampleGenerator::test() { std::vector inputPoints(160000); for(size_t i = 0; i < inputPoints.size(); i++) { inputPoints[i].x = (float) rand() / RAND_MAX; inputPoints[i].y = (float) rand() / RAND_MAX; inputPoints[i].z = (float) rand() / RAND_MAX; } std::vector outputPoints(32000); std::clock_t start; double duration; start = std::clock(); m_wse.Eliminate(inputPoints.data(), inputPoints.size(), outputPoints.data(), outputPoints.size()); duration = (std::clock() - start) / (double) CLOCKS_PER_SEC; std::cout << "time = " << duration << '\n'; float minRadius = 255; for(int i = 0; i < 12000; i++) for(int j = 0; j < 12000; j++) { if(i == j) continue; float tmp = (outputPoints[i] - outputPoints[j]).Length(); minRadius = fminf(minRadius, tmp); } std::cout << "min radius = " << minRadius << std::endl; //int gNi = 10, gNj = 10, gNk = 10; //int samplesPerSubcell = 12; //int inputScale = 5; //int sampleVolume = gNi * gNj * gNk; //int inputSampleCount = sampleVolume * samplesPerSubcell * inputScale; //int outputSampleCount = sampleVolume * samplesPerSubcell; //std::vector inputSamples; //inputSamples.resize(inputSampleCount); //int c = 0; //for (int i = 0; i < gNi; i++) for (int j = 0; j < gNj; j++) for (int k = 0; k < gNk; k++) // for (int si = 0; si < samplesPerSubcell * inputScale; si++) // { // inputSamples[c][0] = (float)rand() / RAND_MAX; // inputSamples[c][1] = (float)rand() / RAND_MAX; // inputSamples[c][2] = (float)rand() / RAND_MAX; // c++; // } //std::vector tmpPoints; //tmpPoints.resize(outputSampleCount); //m_wse.Eliminate(inputSamples.data(), inputSamples.size(), tmpPoints.data(), tmpPoints.size()); //float minRadius = 255; //for (int i = 0; i < outputSampleCount; i++) // for (int j = 0; j < outputSampleCount; j++) // { // if (i == j) continue; // float tmp = (tmpPoints[i] - tmpPoints[j]).Length(); // minRadius = fminf(minRadius, tmp); // } //std::cout << "min radius = " << minRadius << std::endl; } #endif ================================================ FILE: Library/MnSystem/IO/PoissonDisk/cyCore.h ================================================ // cyCodeBase by Cem Yuksel // [www.cemyuksel.com] //------------------------------------------------------------------------------- //! \file cyCore.h //! \author Cem Yuksel //! //! \brief Core functions and macros //! //! Core functions and macros for math and other common operations //! //------------------------------------------------------------------------------- // // Copyright (c) 2016, Cem Yuksel // All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. // //------------------------------------------------------------------------------- #ifndef _CY_CORE_H_INCLUDED_ #define _CY_CORE_H_INCLUDED_ //------------------------------------------------------------------------------- #ifndef _CY_CORE_MEMCPY_LIMIT # define _CY_CORE_MEMCPY_LIMIT 256 #endif //------------------------------------------------------------------------------- #include #include #include #include #include //------------------------------------------------------------------------------- ////////////////////////////////////////////////////////////////////////// // Compiler compatibility ////////////////////////////////////////////////////////////////////////// #if defined(__INTEL_COMPILER) # define _CY_COMPILER_INTEL __INTEL_COMPILER # define _CY_COMPILER_VER_MEETS(msc, gcc, clang, intel) _CY_COMPILER_INTEL >= intel # define _CY_COMPILER_VER_BELOW(msc, gcc, clang, intel) _CY_COMPILER_INTEL < intel #elif defined(__clang__) # define _CY_COMPILER_CLANG (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) # define _CY_COMPILER_VER_MEETS(msc, gcc, clang, intel) _CY_COMPILER_CLANG >= clang # define _CY_COMPILER_VER_BELOW(msc, gcc, clang, intel) _CY_COMPILER_CLANG < clang #elif defined(_MSC_VER) # define _CY_COMPILER_MSC _MSC_VER # define _CY_COMPILER_VER_MEETS(msc, gcc, clang, intel) _CY_COMPILER_MSC >= msc # define _CY_COMPILER_VER_BELOW(msc, gcc, clang, intel) _CY_COMPILER_MSC < msc #elif __GNUC__ # define _CY_COMPILER_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) # define _CY_COMPILER_VER_MEETS(msc, gcc, clang, intel) _CY_COMPILER_GCC >= gcc # define _CY_COMPILER_VER_BELOW(msc, gcc, clang, intel) _CY_COMPILER_GCC < gcc #else # define _CY_COMPILER_UNKNOWN # define _CY_COMPILER_VER_MEETS(msc, gcc, clang, intel) false # define _CY_COMPILER_VER_BELOW(msc, gcc, clang, intel) false #endif // constexpr #ifndef __cpp_constexpr # if _CY_COMPILER_VER_MEETS(1900, 40600, 30100, 1310) # define __cpp_constexpr # else # define constexpr # endif #endif // nullptr #if _CY_COMPILER_VER_BELOW(1600, 40600, 20900, 1210) class _cy_nullptr_t { public: template operator T*() const { return 0; } template operator T C::*() const { return 0; } private: void operator&() const {} }; static _cy_nullptr_t nullptr; #endif // template aliases #define _CY_TEMPLATE_ALIAS_UNPACK(...) __VA_ARGS__ #if _CY_COMPILER_VER_BELOW(1800, 40700, 30000, 1210) # define _CY_TEMPLATE_ALIAS(template_name, template_equivalent) \ class template_name : public _CY_TEMPLATE_ALIAS_UNPACK template_equivalent {} #else # define _CY_TEMPLATE_ALIAS(template_name, template_equivalent) using template_name = _CY_TEMPLATE_ALIAS_UNPACK template_equivalent #endif // std::is_trivially_copyable #if _CY_COMPILER_VER_MEETS(1700, 50000, 30400, 1300) # define _cy_std_is_trivially_copyable 1 #endif ////////////////////////////////////////////////////////////////////////// // Auto Vectorization ////////////////////////////////////////////////////////////////////////// #ifdef _MSC_VER # if _MSC_VER >= 1700 # define _CY_IVDEP __pragma(loop(ivdep)) # endif #elif defined __GNUC__ # if _CY_GCC_VER >= 40900 # define _CY_IVDEP _Pragma("GCC ivdep"); # endif #elif defined __clang__ # if _CY_CLANG_VER >= 30500 # define _CY_IVDEP _Pragma("clang loop vectorize(enable) interleave(enable)"); # endif #else //# define _CY_IVDEP _Pragma("ivdep"); # define _CY_IVDEP #endif #ifndef _CY_IVDEP # define _CY_IVDEP #endif #define _CY_IVDEP_FOR _CY_IVDEP for ////////////////////////////////////////////////////////////////////////// //------------------------------------------------------------------------------- namespace cy { //------------------------------------------------------------------------------- ////////////////////////////////////////////////////////////////////////// // Math functions ////////////////////////////////////////////////////////////////////////// //!@name Common math function templates template inline TYPE cySin(TYPE a) { return (TYPE)::sin(a); } template inline TYPE cyCos(TYPE a) { return (TYPE)::cos(a); } template inline TYPE cyTan(TYPE a) { return (TYPE)::tan(a); } template inline TYPE cyAbs(TYPE a) { return (TYPE)::abs(a); } template inline TYPE cySqrt(TYPE a) { return (TYPE)::sqrt((double) a); } template inline TYPE cyPow(TYPE a, TYPE e) { return (TYPE)::pow(a, e); } template inline TYPE cyPi() { return TYPE(3.141592653589793238462643383279502884197169); } template<> inline float cySin(float a) { return ::sinf(a); } template<> inline float cyCos(float a) { return ::cosf(a); } template<> inline float cyTan(float a) { return ::tanf(a); } template<> inline float cyAbs(float a) { return ::fabsf(a); } template<> inline float cySqrt(float a) { return ::sqrtf(a); } template<> inline float cyPow(float a, float e) { return ::powf(a, e); } template<> inline double cyAbs(double a) { return ::fabs(a); } ////////////////////////////////////////////////////////////////////////// // Memory Operations ////////////////////////////////////////////////////////////////////////// #ifdef _cy_std_is_trivially_copyable # define CY_MEMCOPY(type, dest, source, n) \ { \ if(!std::is_trivially_copyable() || (n) * sizeof(type) < _CY_CORE_MEMCPY_LIMIT) { \ for(int i = 0; i < (n); i++) \ (dest)[i] = (source)[i]; \ } else { \ memcpy(dest, source, (n) * sizeof(type)); \ } \ } #else # define CY_MEMCOPY(type, dest, source, n) \ { \ for(int i = 0; i < (n); i++) \ (dest)[i] = (source)[i]; \ } #endif #define CY_MEMCONVERT(type, dest, source, n) \ { \ for(int i = 0; i < (n); i++) \ (dest)[i] = type((source)[i]); \ } #define CY_MEMCLEAR(type, dest, n) memset(dest, 0, (n) * sizeof(type)) ////////////////////////////////////////////////////////////////////////// //------------------------------------------------------------------------------- }// namespace cy //------------------------------------------------------------------------------- #endif ================================================ FILE: Library/MnSystem/IO/PoissonDisk/cyHeap.h ================================================ // cyCodeBase by Cem Yuksel // [www.cemyuksel.com] //------------------------------------------------------------------------------- //! \file cyHeap.h //! \author Cem Yuksel //! //! \brief A general-purpose heap class //! //! This file includes a general-purpose heap class. //! //------------------------------------------------------------------------------- // // Copyright (c) 2016, Cem Yuksel // All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. // //------------------------------------------------------------------------------- #ifndef _CY_HEAP_H_INCLUDED_ #define _CY_HEAP_H_INCLUDED_ //------------------------------------------------------------------------------- #include #include //------------------------------------------------------------------------------- namespace cy { //------------------------------------------------------------------------------- //! A general-purpose max-heap structure that allows random access and updates. //! //! The main data can be kept in an external array or within the Heap class. template class Heap { public: //////////////////////////////////////////////////////////////////////////!//!//! //!@name Constructor and Destructor Heap() : size(0) , heapItemCount(0) , data(nullptr) , heap(nullptr) , heapPos(nullptr) , deleteData(false) {} ~Heap() { Clear(); } //////////////////////////////////////////////////////////////////////////!//!//! //!@name Initialization methods //! Deletes all data owned by the class. void Clear() { ClearData(); ClearHeap(); } //! Copies the main data items from an array into the internal storage of this class. void CopyData(const DATA_TYPE* items, SIZE_TYPE itemCount) { ClearData(); size = itemCount; data = new DATA_TYPE[size]; for(SIZE_TYPE i = 0; i < size; i++) data[i] = items[i]; deleteData = true; } //! Moves the main data items from an array to the internal storage of this class. //! Modifying this array externally can invalidate the heap structure. //! The given array must NOT be deleted externally. //! The given items pointer still points to the same data, but the class claims //! ownership of the data. Therefore, when the class object is deleted, the data //! items are deleted as well. If this is not desirable, use SetDataPointer. void MoveData(DATA_TYPE* items, SIZE_TYPE itemCount) { ClearData(); data = items; size = itemCount; deleteData = true; } //! Sets the data pointer of this class. This method is used for sharing the items //! array with other structures. Unlike setting the main data using the MoveData //! method, when SetDataPointer is used, the class does NOT claim ownership //! of the data. Therefore, it does not deallocate memory used for the main data //! when it is deleted, and the data items must be deleted externally. //! However, the data items must NOT be deleted while an object of this class is used. void SetDataPointer(DATA_TYPE* items, SIZE_TYPE itemCount) { ClearData(); data = items; size = itemCount; deleteData = false; } //! The Build method builds the heap structure using the main data. Therefore, //! the main data must be set using either CopyData, MoveData, or SetDataPointer //! before calling the Build method. void Build() { ClearHeap(); heapItemCount = size; heap = new SIZE_TYPE[size + 1]; heapPos = new SIZE_TYPE[size]; for(SIZE_TYPE i = 0; i < heapItemCount; i++) heapPos[i] = i + 1; for(SIZE_TYPE i = 1; i <= heapItemCount; i++) heap[i] = i - 1; if(heapItemCount <= 1) return; for(SIZE_TYPE ix = heapItemCount / 2; ix > 0; ix--) HeapMoveDown(ix); } //////////////////////////////////////////////////////////////////////////!//!//! //!@name Access and manipulation methods //! Returns the item from the main data with the given id. const DATA_TYPE& GetItem(SIZE_TYPE id) const { assert(id < size); return data[id]; } //! Sets the item with the given id and updates the heap structure accordingly. //! Returns false if the item is not in the heap anymore (removed by Pop) or if its heap position is not changed. bool SetItem(SIZE_TYPE id, const DATA_TYPE& item) { assert(id < size); data[id] = item; return MoveItem(id); } //! Moves the item with the given id to the correct position in the heap. //! This method is useful for fixing the heap position after an item is modified externally. //! Returns false if the item is not in the heap anymore (removed by Pop) or if its heap position is not changed. bool MoveItem(SIZE_TYPE id) { return HeapOrder(heapPos[id]); } //! Moves the item with the given id towards the top of the heap. //! This method is useful for fixing the heap position after an item is modified externally to increase its priority. //! Returns false if the item is not in the heap anymore (removed by Pop) or if its heap position is not changed. bool MoveItemUp(SIZE_TYPE id) { return HeapMoveUp(heapPos[id]); } //! Moves the item with the given id towards the top of the heap. //! This method is useful for fixing the heap position after an item is modified externally to decrease its priority. //! Returns false if the item is not in the heap anymore (removed by Pop) or if its heap position is not changed. bool MoveItemDown(SIZE_TYPE id) { return HeapMoveDown(heapPos[id]); } //! Returns if the item with the given id is in the heap or removed by Pop. bool IsInHeap(SIZE_TYPE id) const { assert(id < size); return heapPos[id] <= heapItemCount; } //! Returns the number of items in the heap. SIZE_TYPE NumItemsInHeap() const { return heapItemCount; } //! Returns the item from the heap with the given heap position. //! Note that items that are removed from the heap appear in the inverse order //! with which they were removed after the last item in the heap. const DATA_TYPE& GetFromHeap(SIZE_TYPE heapIndex) const { assert(heapIndex < size); return data[heap[heapIndex + 1]]; } //! Returns the id of the item from the heap with the given heap position. //! Note that items that are removed from the heap appear in the inverse order //! with which they were removed after the last item in the heap. SIZE_TYPE GetIDFromHeap(SIZE_TYPE heapIndex) const { assert(heapIndex < size); return heap[heapIndex + 1]; } //! Returns the item at the top of the heap. const DATA_TYPE& GetTopItem() const { assert(size >= 1); return data[heap[1]]; } //! Returns the id of the item at the top of the heap. SIZE_TYPE GetTopItemID() const { assert(size >= 1); return heap[1]; } //! Removes and returns the item at the top of the heap. //! The removed item is not deleted, but it is removed from the heap //! by placing it right after the last item in the heap. void Pop(DATA_TYPE& item) { Pop(); item = data[heap[heapItemCount]]; } //! Removes the item at the top of the heap. //! The removed item is not deleted, but it is removed from the heap //! by placing it right after the last item in the heap. void Pop() { SwapItems(1, heapItemCount); heapItemCount--; HeapMoveDown(1); } private: //////////////////////////////////////////////////////////////////////////!//!//! //!@name Internal structures and methods DATA_TYPE* data; // The main data pointer. SIZE_TYPE* heap; // The heap array, keeping the id of each data item. SIZE_TYPE* heapPos; // The heap position of each item. SIZE_TYPE heapItemCount;// The number of items in the heap. SIZE_TYPE size; // The total item count, including the ones removed from the heap. bool deleteData; // Determines whether the data pointer owns the memory it points to. // Clears the data pointer and deallocates memory if the data is owned. void ClearData() { if(deleteData) delete[] data; data = nullptr; deleteData = false; size = 0; } // Clears the heap structure. void ClearHeap() { delete[] heap; heap = nullptr; delete[] heapPos; heapPos = nullptr; heapItemCount = 0; } // Checks if the item should be moved. // Returns true if the item is in the heap. bool HeapOrder(SIZE_TYPE ix) { if(ix > heapItemCount) return false; if(HeapMoveUp(ix)) return true; return HeapMoveDown(ix);// if it can't be move up, move it down } // Checks if the item should be moved up, returns true if the item is moved. bool HeapMoveUp(SIZE_TYPE ix) { SIZE_TYPE org = ix; while(ix >= 2) { SIZE_TYPE parent = ix / 2; if(!IsSmaller(parent, ix)) break; SwapItems(parent, ix); ix = parent; } return ix != org; } // Checks if the item should be moved down, returns true if the item is moved. bool HeapMoveDown(SIZE_TYPE ix) { SIZE_TYPE org = ix; SIZE_TYPE child = ix * 2; while(child + 1 <= heapItemCount) { if(IsSmaller(child, child + 1)) child++; if(!IsSmaller(ix, child)) return ix != org; SwapItems(ix, child); ix = child; child = ix * 2; } // Check the very last item as well if(child <= heapItemCount) { if(IsSmaller(ix, child)) { SwapItems(ix, child); return true; } } return ix != org; } // Returns if the item at ix1 is smaller than the one at ix2. bool IsSmaller(SIZE_TYPE ix1, SIZE_TYPE ix2) { return data[heap[ix1]] < data[heap[ix2]]; } // Swaps the heap positions of items at ix1 and ix2. void SwapItems(SIZE_TYPE ix1, SIZE_TYPE ix2) { SIZE_TYPE t = heap[ix1]; heap[ix1] = heap[ix2]; heap[ix2] = t; heapPos[heap[ix1]] = ix1; heapPos[heap[ix2]] = ix2; } //////////////////////////////////////////////////////////////////////////!//!//! }; //------------------------------------------------------------------------------- }// namespace cy //------------------------------------------------------------------------------- #endif ================================================ FILE: Library/MnSystem/IO/PoissonDisk/cyPoint.h ================================================ // cyCodeBase by Cem Yuksel // [www.cemyuksel.com] //------------------------------------------------------------------------------- //! \file cyPoint.h //! \author Cem Yuksel //! //! \brief 2D, 3D, 4D, and ND point classes. //! //------------------------------------------------------------------------------- // // Copyright (c) 2016, Cem Yuksel // All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. // //------------------------------------------------------------------------------- #ifndef _CY_POINT_H_INCLUDED_ #define _CY_POINT_H_INCLUDED_ //------------------------------------------------------------------------------- #include "cyCore.h" //------------------------------------------------------------------------------- namespace cy { //------------------------------------------------------------------------------- // Forward declarations //! \cond HIDDEN_SYMBOLS template class Point2; template class Point3; template class Point4; //! \endcond //------------------------------------------------------------------------------- //! A general class for N-dimensional points (vectors). template class Point { friend Point operator+(const TYPE v, const Point& p) { return p + v; }//!< Addition with a constant friend Point operator-(const TYPE v, const Point& p) { return -(p - v); }//!< Subtraction from a constant friend Point operator*(const TYPE v, const Point& p) { return p * v; }//!< Multiplication with a constant public: //!@name Components of the point/vector TYPE data[N]; //!@name Constructors Point() {} Point(const Point& p) { CY_MEMCOPY(TYPE, data, p.data, N); } explicit Point(const TYPE* p) { CY_MEMCOPY(TYPE, data, p, N); } explicit Point(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] = v; } template explicit Point(const Point& p) { CY_MEMCONVERT(TYPE, data, p.data, N); } template explicit Point(const Point& p) { if(N <= M) { CY_MEMCOPY(TYPE, data, p.data, N); } else { CY_MEMCOPY(TYPE, data, p.data, M); CY_MEMCLEAR(TYPE, data, N - M); } } template explicit Point(const Point& p) { if(N <= M) { CY_MEMCONVERT(TYPE, data, p.data, N); } else { CY_MEMCONVERT(TYPE, data, p.data, M); CY_MEMCLEAR(TYPE, data, N - M); } } explicit Point(const Point2& p); explicit Point(const Point3& p); explicit Point(const Point4& p); template explicit Point(const Point2& p); template explicit Point(const Point3& p); template explicit Point(const Point4& p); template explicit Point(const P& p) { for(int i = 0; i < N; ++i) data[i] = (TYPE) p[i]; } //!@name Set & Get value methods void Zero() { CY_MEMCLEAR(TYPE, data, N); }//!< Sets the coordinates as zero void Get(TYPE* p) const { CY_MEMCOPY(TYPE, p, data, N); }//!< Puts the coordinate values into the array void Set(const TYPE* p) { CY_MEMCOPY(TYPE, data, p, N); }//!< Sets the coordinates using the values in the given array void Set(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] = v; }//!< Sets all coordinates using the given value template void CopyData(TYPE* p) { if(M <= N) { CY_MEMCOPY(TYPE, p, data, M); } else { CY_MEMCOPY(TYPE, p, data, N); CY_MEMCLEAR(TYPE, p + N, M - N); } } template void ConvertData(T* p) { if(M <= N) { CY_MEMCONVERT(T, p, data, M); } else { CY_MEMCONVERT(T, p, data, N); CY_MEMCLEAR(T, p + N, M - N); } } //!@name General methods TYPE LengthSquared() const { Point p = operator*(*this); return p.Sum(); }//!< Returns the square of the length. Effectively, this is the dot product of the vector with itself. TYPE Length() const { return (TYPE) cySqrt(LengthSquared()); }//!< Returns the length of the vector. void Normalize() { *this /= Length(); }//!< Normalizes the vector, such that its length becomes 1. Point GetNormalized() const { return *this / Length(); }//!< Returns a normalized copy of the vector. TYPE Sum() const { TYPE v = data[0]; for(int i = 1; i < N; ++i) v += data[i]; return v; }//!< Returns the sum of its components bool IsZero() const { for(int i = 0; i < N; ++i) if(data[i] != TYPE(0)) return false; return true; }//!< Returns true if all components are exactly zero TYPE Min() const { TYPE m = data[0]; for(int i = 1; i < N; ++i) if(m > data[i]) m = data[i]; return m; } TYPE Max() const { TYPE m = data[0]; for(int i = 1; i < N; ++i) if(m < data[i]) m = data[i]; return m; } int MinID() const { TYPE m = data[0]; int ix = 0; for(int i = 1; i < N; ++i) if(m > data[i]) { m = data[i]; ix = i; } return m; } int MaxID() const { TYPE m = data[0]; int ix = 0; for(int i = 1; i < N; ++i) if(m < data[i]) { m = data[i]; ix = i; } return m; } //!@name Limit methods void Clamp(const TYPE& minValue, const TYPE& maxValue) { ClampMin(minValue); ClampMax(maxValue); } void ClampMin(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] = (data[i] < v) ? v : data[i]; } void ClampMax(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] = (data[i] > v) ? v : data[i]; } void Abs() { for(int i = 0; i < N; i++) data[i] = cyAbs(data[i]); }//!< Converts all negative components to positive values //!@name Unary operators Point operator-() const { Point r; for(int i = 0; i < N; ++i) r.data[i] = -data[i]; return r; } //!@name Binary operators Point operator+(const Point& p) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] + p.data[i]; return r; } Point operator-(const Point& p) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] - p.data[i]; return r; } Point operator*(const Point& p) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] * p.data[i]; return r; } Point operator/(const Point& p) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] / p.data[i]; return r; } Point operator+(const TYPE& v) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] + v; return r; } Point operator-(const TYPE& v) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] - v; return r; } Point operator*(const TYPE& v) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] * v; return r; } Point operator/(const TYPE& v) const { Point r; for(int i = 0; i < N; ++i) r.data[i] = data[i] / v; return r; } //!@name Assignment operators const Point& operator=(const Point& p) { CY_MEMCOPY(TYPE, data, p.data, N); return *this; } const Point& operator+=(const Point& p) { for(int i = 0; i < N; ++i) data[i] += p.data[i]; return *this; } const Point& operator-=(const Point& p) { for(int i = 0; i < N; ++i) data[i] -= p.data[i]; return *this; } const Point& operator*=(const Point& p) { for(int i = 0; i < N; ++i) data[i] *= p.data[i]; return *this; } const Point& operator/=(const Point& p) { for(int i = 0; i < N; ++i) data[i] /= p.data[i]; return *this; } const Point& operator+=(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] += v; return *this; } const Point& operator-=(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] -= v; return *this; } const Point& operator*=(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] *= v; return *this; } const Point& operator/=(const TYPE& v) { for(int i = 0; i < N; ++i) data[i] /= v; return *this; } //!@name Test operators bool operator==(const Point& p) const { for(int i = 0; i < N; ++i) if(data[i] != p.data[i]) return false; return true; } bool operator!=(const Point& p) const { for(int i = 0; i < N; ++i) if(data[i] != p.data[i]) return true; return false; } //!@name Access operators TYPE& operator[](int i) { return data[i]; } TYPE operator[](int i) const { return data[i]; } //!@name Dot product TYPE Dot(const Point& p) const { Point r = operator*(p); return r.Sum(); }//!< Dot product TYPE operator%(const Point& p) const { return Dot(p); }//!< Dot product operator }; //------------------------------------------------------------------------------- //! 2D point (vector) class template class Point2 { friend Point2 operator+(const TYPE v, const Point2& p) { return p + v; }//!< Addition with a constant friend Point2 operator-(const TYPE v, const Point2& p) { return -(p - v); }//!< Subtraction from a constant friend Point2 operator*(const TYPE v, const Point2& p) { return p * v; }//!< Multiplication with a constant public: //!@name Components of the point/vector TYPE x, y; //!@name Constructors Point2() {} Point2(const TYPE& _x, const TYPE& _y) : x(_x) , y(_y) {} Point2(const Point2& p) : x(p.x) , y(p.y) {} explicit Point2(const TYPE& v) : x(v) , y(v) {} explicit Point2(const Point3& p); explicit Point2(const Point4& p); template explicit Point2(const Point2& p) : x(TYPE(p.x)) , y(TYPE(p.y)) {} template explicit Point2(const Point3& p); template explicit Point2(const Point4& p); template explicit Point2(const Point& p) { p.CopyData<2>(&x); } template explicit Point2(const Point& p) { p.template ConvertData(&x); } template explicit Point2(const P& p) : x((TYPE) p[0]) , y((TYPE) p[1]) {} //!@name Set & Get value methods void Zero() { CY_MEMCLEAR(TYPE, Data(), 2); }//!< Sets the coordinates as zero. void Get(TYPE* p) const { ((Point2*) p)->operator=(*this); }//!< Puts the coordinate values into the array. void Set(const TYPE* p) { operator=(*((Point2*) p)); }//!< Sets the coordinates using the values in the given array. void Set(const TYPE& v) { x = v; y = v; }//!< Sets all coordinates using the given value void Set(const TYPE& _x, const TYPE& _y) { x = _x; y = _y; }//!< Sets the coordinates using the given values //!@name General methods TYPE LengthSquared() const { Point2 p = operator*(*this); return p.Sum(); }//!< Returns the square of the length. Effectively, this is the dot product of the vector with itself. TYPE Length() const { return (TYPE) cySqrt(LengthSquared()); }//!< Returns the length of the vector. void Normalize() { *this /= Length(); }//!< Normalizes the vector, such that its length becomes 1. Point2 GetNormalized() const { return *this / Length(); }//!< Returns a normalized copy of the vector. TYPE Sum() const { return x + y; }//!< Returns the sum of its components bool IsZero() const { return x == TYPE(0) && y == TYPE(0); }//!< Returns true if all components are exactly zero TYPE Min() const { return x < y ? x : y; } TYPE Max() const { return x > y ? x : y; } int MinID() const { return x < y ? 0 : 1; } int MaxID() const { return x > y ? 0 : 1; } //!@name Limit methods void Clamp(const TYPE& minValue, const TYPE& maxValue) { ClampMin(minValue); ClampMax(maxValue); } void ClampMin(const TYPE& v) { x = (x < v) ? v : x; y = (y < v) ? v : y; } void ClampMax(const TYPE& v) { x = (x > v) ? v : x; y = (y > v) ? v : y; } void Abs() { x = cyAbs(x); y = cyAbs(y); }//!< Converts all negative components to positive values //!@name Unary operators Point2 operator-() const { Point2 r; r.x = -x; r.y = -y; return r; } //!@name Binary operators Point2 operator+(const Point2& p) const { Point2 r; r.x = x + p.x; r.y = y + p.y; return r; } Point2 operator-(const Point2& p) const { Point2 r; r.x = x - p.x; r.y = y - p.y; return r; } Point2 operator*(const Point2& p) const { Point2 r; r.x = x * p.x; r.y = y * p.y; return r; } Point2 operator/(const Point2& p) const { Point2 r; r.x = x / p.x; r.y = y / p.y; return r; } Point2 operator+(const TYPE& v) const { Point2 r; r.x = x + v; r.y = y + v; return r; } Point2 operator-(const TYPE& v) const { Point2 r; r.x = x - v; r.y = y - v; return r; } Point2 operator*(const TYPE& v) const { Point2 r; r.x = x * v; r.y = y * v; return r; } Point2 operator/(const TYPE& v) const { Point2 r; r.x = x / v; r.y = y / v; return r; } //!@name Assignment operators const Point2& operator=(const Point2& p) { x = p.x; y = p.y; return *this; } const Point2& operator+=(const Point2& p) { x += p.x; y += p.y; return *this; } const Point2& operator-=(const Point2& p) { x -= p.x; y -= p.y; return *this; } const Point2& operator*=(const Point2& p) { x *= p.x; y *= p.y; return *this; } const Point2& operator/=(const Point2& p) { x /= p.x; y /= p.y; return *this; } const Point2& operator+=(const TYPE& v) { x += v; y += v; return *this; } const Point2& operator-=(const TYPE& v) { x -= v; y -= v; return *this; } const Point2& operator*=(const TYPE& v) { x *= v; y *= v; return *this; } const Point2& operator/=(const TYPE& v) { x /= v; y /= v; return *this; } //!@name Test operators bool operator==(const Point2& p) const { return x == p.x && y == p.y; } bool operator!=(const Point2& p) const { return x != p.x && y != p.y; } //!@name Access operators TYPE& operator[](int i) { return Element(i); } const TYPE& operator[](int i) const { return Element(i); } TYPE& Element(int i) { return (&x)[i]; } const TYPE& Element(int i) const { return (&x)[i]; } TYPE* Data() { return &x; } const TYPE* Data() const { return &x; } //!@name Cross product and dot product TYPE Cross(const Point2& p) const { Point2 r(-y, x); return r.Dot(p); }//!< Cross product TYPE operator^(const Point2& p) const { return Cross(p); }//!< Cross product operator TYPE Dot(const Point2& p) const { Point2 r = operator*(p); return r.Sum(); }//!< Dot product TYPE operator%(const Point2& p) const { return Dot(p); }//!< Dot product operator }; //------------------------------------------------------------------------------- //! 3D point (vector) class template class Point3 { friend Point3 operator+(const TYPE v, const Point3& p) { return p + v; }//!< Addition with a constant friend Point3 operator-(const TYPE v, const Point3& p) { return -(p - v); }//!< Subtraction from a constant friend Point3 operator*(const TYPE v, const Point3& p) { return p * v; }//!< Multiplication with a constant public: //!@name Components of the point/vector TYPE x, y, z; //!@name Constructors Point3() {} Point3(const TYPE& _x, const TYPE& _y, const TYPE& _z) : x(_x) , y(_y) , z(_z) {} Point3(const Point3& p) : x(p.x) , y(p.y) , z(p.z) {} explicit Point3(const TYPE& v) : x(v) , y(v) , z(v) {} explicit Point3(const Point2& p, TYPE _z = 0) : x(p.x) , y(p.y) , z(_z) {} explicit Point3(const Point4& p); template explicit Point3(const Point3& p) : x(TYPE(p.x)) , y(TYPE(p.y)) , z(TYPE(p.z)) {} template explicit Point3(const Point2& p, TYPE _z = 0) : x(TYPE(p.x)) , y(TYPE(p.y)) , z(_z) {} template explicit Point3(const Point4& p); template explicit Point3(const Point& p) { p.CopyData<3>(&x); } template explicit Point3(const Point& p) { p.template ConvertData(&x); } template explicit Point3(const P& p) : x((TYPE) p[0]) , y((TYPE) p[1]) , z((TYPE) p[2]) {} //!@name Set & Get value methods void Zero() { CY_MEMCLEAR(TYPE, Data(), 3); }//!< Sets the coordinates as zero void Get(TYPE* p) const { ((Point3*) p)->operator=(*this); }//!< Puts the coordinate values into the array void Set(const TYPE* p) { operator=(*((Point3*) p)); }//!< Sets the coordinates using the values in the given array void Set(const TYPE& v) { x = v; y = v; z = v; }//!< Sets all coordinates using the given value void Set(const TYPE& _x, const TYPE& _y, const TYPE& _z) { x = _x; y = _y; z = _z; }//!< Sets the coordinates using the given values //!@name General methods TYPE LengthSquared() const { Point3 p = operator*(*this); return p.Sum(); }//!< Returns the square of the length. Effectively, this is the dot product of the vector with itself. TYPE Length() const { return (TYPE) cySqrt(LengthSquared()); }//!< Returns the length of the vector. void Normalize() { *this /= Length(); }//!< Normalizes the vector, such that its length becomes 1. Point3 GetNormalized() const { return *this / Length(); }//!< Returns a normalized copy of the vector. TYPE Sum() const { return x + y + z; }//!< Returns the sum of its components bool IsZero() const { return x == TYPE(0) && y == TYPE(0) && z == TYPE(0); }//!< Returns true if all components are exactly zero TYPE Min() const { return x < y ? (x < z ? x : z) : (y < z ? y : z); } TYPE Max() const { return x > y ? (x > z ? x : z) : (y > z ? y : z); } int MinID() const { return x < y ? (x < z ? 0 : 2) : (y < z ? 1 : 2); } int MaxID() const { return x > y ? (x > z ? 0 : 2) : (y > z ? 1 : 2); } //!@name Limit methods void Clamp(const TYPE& minValue, const TYPE& maxValue) { ClampMin(minValue); ClampMax(maxValue); } void ClampMin(const TYPE& v) { x = (x < v) ? v : x; y = (y < v) ? v : y; z = (z < v) ? v : z; } void ClampMax(const TYPE& v) { x = (x > v) ? v : x; y = (y > v) ? v : y; z = (z > v) ? v : z; } void Abs() { x = cyAbs(x); y = cyAbs(y); z = cyAbs(z); }//!< Converts all negative components to positive values //!@name Unary operators Point3 operator-() const { Point3 r; r.x = -x; r.y = -y; r.z = -z; return r; } //!@name Binary operators Point3 operator+(const Point3& p) const { Point3 r; r.x = x + p.x; r.y = y + p.y; r.z = z + p.z; return r; } Point3 operator-(const Point3& p) const { Point3 r; r.x = x - p.x; r.y = y - p.y; r.z = z - p.z; return r; } Point3 operator*(const Point3& p) const { Point3 r; r.x = x * p.x; r.y = y * p.y; r.z = z * p.z; return r; } Point3 operator/(const Point3& p) const { Point3 r; r.x = x / p.x; r.y = y / p.y; r.z = z / p.z; return r; } Point3 operator+(const TYPE& v) const { Point3 r; r.x = x + v; r.y = y + v; r.z = z + v; return r; } Point3 operator-(const TYPE& v) const { Point3 r; r.x = x - v; r.y = y - v; r.z = z - v; return r; } Point3 operator*(const TYPE& v) const { Point3 r; r.x = x * v; r.y = y * v; r.z = z * v; return r; } Point3 operator/(const TYPE& v) const { Point3 r; r.x = x / v; r.y = y / v; r.z = z / v; return r; } //!@name Assignment operators const Point3& operator=(const Point3& p) { x = p.x; y = p.y; z = p.z; return *this; } const Point3& operator+=(const Point3& p) { x += p.x; y += p.y; z += p.z; return *this; } const Point3& operator-=(const Point3& p) { x -= p.x; y -= p.y; z -= p.z; return *this; } const Point3& operator*=(const Point3& p) { x *= p.x; y *= p.y; z *= p.z; return *this; } const Point3& operator/=(const Point3& p) { x /= p.x; y /= p.y; z /= p.z; return *this; } const Point3& operator+=(const TYPE& v) { x += v; y += v; z += v; return *this; } const Point3& operator-=(const TYPE& v) { x -= v; y -= v; z -= v; return *this; } const Point3& operator*=(const TYPE& v) { x *= v; y *= v; z *= v; return *this; } const Point3& operator/=(const TYPE& v) { x /= v; y /= v; z /= v; return *this; } //!@name Test operators bool operator==(const Point3& p) const { return x == p.x && y == p.y && z == p.z; } bool operator!=(const Point3& p) const { return x != p.x && y != p.y && z != p.z; } //!@name Access operators TYPE& operator[](int i) { return Element(i); } const TYPE& operator[](int i) const { return Element(i); } TYPE& Element(int i) { return (&x)[i]; } const TYPE& Element(int i) const { return (&x)[i]; } TYPE* Data() { return &x; } const TYPE* Data() const { return &x; } //!@name Cross product and dot product Point3 Cross(const Point3& p) const { return Point3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x); }//!< Cross product Point3 operator^(const Point3& p) const { return Cross(p); }//!< Cross product TYPE Dot(const Point3& p) const { Point3 r = operator*(p); return r.Sum(); }//!< Dot product TYPE operator%(const Point3& p) const { return Dot(p); }//!< Dot product //!@name Conversion Methods Point2 XY() const { return Point2(*this); } }; //------------------------------------------------------------------------------- //! 4D point (vector) class template class Point4 { friend Point4 operator+(const TYPE v, const Point4& p) { return p + v; }//!< Addition with a constant friend Point4 operator-(const TYPE v, const Point4& p) { return -(p - v); }//!< Subtraction from a constant friend Point4 operator*(const TYPE v, const Point4& p) { return p * v; }//!< Multiplication with a constant public: //!@name Components of the point/vector TYPE x, y, z, w; //!@name Constructors Point4() {} Point4(const TYPE& _x, const TYPE& _y, const TYPE& _z, const TYPE& _w) : x(_x) , y(_y) , z(_z) , w(_w) {} Point4(const Point4& p) : x(p.x) , y(p.y) , z(p.z) , w(p.w) {} explicit Point4(const TYPE& v) : x(v) , y(v) , z(v) , w(v) {} explicit Point4(const Point3& p, TYPE _w = 1) : x(p.x) , y(p.y) , z(p.z) , w(_w) {} explicit Point4(const Point2& p, TYPE _z = 0, TYPE _w = 1) : x(p.x) , y(p.y) , z(_z) , w(_w) {} template explicit Point4(const Point4& p) : x(TYPE(p.x)) , y(TYPE(p.y)) , z(TYPE(p.z)) , w(TYPE(p.w)) {} template explicit Point4(const Point3& p, TYPE _w = 1) : x(TYPE(p.x)) , y(TYPE(p.y)) , z(TYPE(p.z)) , w(_w) {} template explicit Point4(const Point2& p, TYPE _z = 0, TYPE _w = 1) : x(TYPE(p.x)) , y(TYPE(p.y)) , z(_z) , w(_w) {} template explicit Point4(const Point& p) { p.CopyData<4>(&x); } template explicit Point4(const Point& p) { p.template ConvertData(&x); } template explicit Point4(const P& p) : x((TYPE) p[0]) , y((TYPE) p[1]) , z((TYPE) p[2]) , w((TYPE) p[3]) {} //!@name Set & Get value methods void Zero() { CY_MEMCLEAR(TYPE, Data(), 4); }//!< Sets the coordinates as zero void Get(TYPE* p) const { ((Point4*) p)->operator=(*this); }//!< Puts the coordinate values into the array void Set(const TYPE* p) { operator=(*((Point4*) p)); }//!< Sets the coordinates using the values in the given array void Set(const TYPE& v) { x = v; y = v; z = v; w = v; }//!< Sets all coordinates using the given value void Set(const TYPE& _x, const TYPE& _y, const TYPE& _z, const TYPE& _w = 1) { x = _x; y = _y; z = _z; w = _w; }//!< Sets the coordinates using the given values //!@name General methods TYPE LengthSquared() const { Point4 p = operator*(*this); return p.Sum(); }//!< Returns the square of the length. Effectively, this is the dot product of the vector with itself. TYPE Length() const { return (TYPE) cySqrt(LengthSquared()); }//!< Returns the length of the vector. void Normalize() { *this /= Length(); }//!< Normalizes the vector, such that its length becomes 1. Point4 GetNormalized() const { return *this / Length(); }//!< Returns a normalized copy of the vector. TYPE Sum() const { return x + y + z + w; }//!< Returns the sum of its components bool IsZero() const { return x == TYPE(0) && y == TYPE(0) && z == TYPE(0) && w == TYPE(0); }//!< Returns true if all components are exactly zero TYPE Min() const { TYPE mxy = x < y ? x : y; TYPE mzw = z < w ? z : w; return mxy < mzw ? mxy : mzw; } TYPE Max() const { TYPE mxy = x > y ? x : y; TYPE mzw = z > w ? z : w; return mxy > mzw ? mxy : mzw; } int MinID() const { int ixy = x < y ? 0 : 1; int izw = z < w ? 2 : 3; return (&x)[ixy] < (&x)[izw] ? ixy : izw; } int MaxID() const { int ixy = x > y ? 0 : 1; int izw = z > w ? 2 : 3; return (&x)[ixy] > (&x)[izw] ? ixy : izw; } //!@name Limit methods void Clamp(const TYPE& minValue, const TYPE& maxValue) { ClampMin(minValue); ClampMax(maxValue); } void ClampMin(const TYPE& v) { x = (x < v) ? v : x; y = (y < v) ? v : y; z = (z < v) ? v : z; w = (w < v) ? v : w; } void ClampMax(const TYPE& v) { x = (x > v) ? v : x; y = (y > v) ? v : y; z = (z > v) ? v : z; w = (w > v) ? v : w; } void Abs() { x = cyAbs(x); y = cyAbs(y); z = cyAbs(z); w = cyAbs(w); }//!< Converts all negative components to positive values //!@name Unary operators Point4 operator-() const { Point4 r; r.x = -x; r.y = -y; r.z = -z; r.w = -w; return r; } //!@name Binary operators Point4 operator+(const Point4& p) const { Point4 r; r.x = x + p.x; r.y = y + p.y; r.z = z + p.z; r.w = w + p.w; return r; } Point4 operator-(const Point4& p) const { Point4 r; r.x = x - p.x; r.y = y - p.y; r.z = z - p.z; r.w = w - p.w; return r; } Point4 operator*(const Point4& p) const { Point4 r; r.x = x * p.x; r.y = y * p.y; r.z = z * p.z; r.w = w * p.w; return r; } Point4 operator/(const Point4& p) const { Point4 r; r.x = x / p.x; r.y = y / p.y; r.z = z / p.z; r.w = w / p.w; return r; } Point4 operator+(const TYPE& v) const { Point4 r; r.x = x + v; r.y = y + v; r.z = z + v; r.w = w + v; return r; } Point4 operator-(const TYPE& v) const { Point4 r; r.x = x - v; r.y = y - v; r.z = z - v; r.w = w - v; return r; } Point4 operator*(const TYPE& v) const { Point4 r; r.x = x * v; r.y = y * v; r.z = z * v; r.w = w * v; return r; } Point4 operator/(const TYPE& v) const { Point4 r; r.x = x / v; r.y = y / v; r.z = z / v; r.w = w / v; return r; } //!@name Assignment operators const Point4& operator=(const Point4& p) { x = p.x; y = p.y; z = p.z; w = p.w; return *this; } const Point4& operator+=(const Point4& p) { x += p.x; y += p.y; z += p.z; w += p.w; return *this; } const Point4& operator-=(const Point4& p) { x -= p.x; y -= p.y; z -= p.z; w -= p.w; return *this; } const Point4& operator*=(const Point4& p) { x *= p.x; y *= p.y; z *= p.z; w *= p.w; return *this; } const Point4& operator/=(const Point4& p) { x /= p.x; y /= p.y; z /= p.z; w /= p.w; return *this; } const Point4& operator+=(const TYPE& v) { x += v; y += v; z += v; w += v; return *this; } const Point4& operator-=(const TYPE& v) { x -= v; y -= v; z -= v; w -= v; return *this; } const Point4& operator*=(const TYPE& v) { x *= v; y *= v; z *= v; w *= v; return *this; } const Point4& operator/=(const TYPE& v) { x /= v; y /= v; z /= v; w /= v; return *this; } //!@name Test operators bool operator==(const Point4& p) const { return x == p.x && y == p.y && z == p.z && w == p.w; } bool operator!=(const Point4& p) const { return x != p.x && y != p.y && z != p.z && w != p.w; } //!@name Access operators TYPE& operator[](int i) { return Element(i); } const TYPE& operator[](int i) const { return Element(i); } TYPE& Element(int i) { return (&x)[i]; } const TYPE& Element(int i) const { return (&x)[i]; } TYPE* Data() { return &x; } const TYPE* Data() const { return &x; } //!@name Dot product TYPE Dot(const Point4& p) const { Point4 r = operator*(p); return r.Sum(); }//!< Dot product TYPE operator%(const Point4& p) const { return Dot(p); }//!< Dot product //!@name Conversion Methods Point2 XY() const { return Point2(*this); } Point3 XYZ() const { return Point3(*this); } Point3 GetNonHomogeneous() const { return Point3(*this) / w; } }; //------------------------------------------------------------------------------- // Definitions of the conversion constructors template Point::Point(const Point2& p) { if(N <= 2) { CY_MEMCOPY(TYPE, data, &p.x, N); } else { CY_MEMCOPY(TYPE, data, &p.x, 2); CY_MEMCLEAR(TYPE, data, N - 2); } } template Point::Point(const Point3& p) { if(N <= 3) { CY_MEMCOPY(TYPE, data, &p.x, N); } else { CY_MEMCOPY(TYPE, data, &p.x, 3); CY_MEMCLEAR(TYPE, data, N - 3); } } template Point::Point(const Point4& p) { if(N <= 4) { CY_MEMCOPY(TYPE, data, &p.x, N); } else { CY_MEMCOPY(TYPE, data, &p.x, 4); CY_MEMCLEAR(TYPE, data, N - 4); } } template template Point::Point(const Point2& p) { if(N <= 2) { CY_MEMCONVERT(TYPE, data, &p.x, N); } else { CY_MEMCONVERT(TYPE, data, &p.x, 2); CY_MEMCLEAR(TYPE, data, N - 2); } } template template Point::Point(const Point3& p) { if(N <= 3) { CY_MEMCONVERT(TYPE, data, &p.x, N); } else { CY_MEMCONVERT(TYPE, data, &p.x, 3); CY_MEMCLEAR(TYPE, data, N - 3); } } template template Point::Point(const Point4& p) { if(N <= 4) { CY_MEMCONVERT(TYPE, data, &p.x, N); } else { CY_MEMCONVERT(TYPE, data, &p.x, 4); CY_MEMCLEAR(TYPE, data, N - 4); } } template Point2::Point2(const Point3& p) : x(p.x) , y(p.y) {} template Point2::Point2(const Point4& p) : x(p.x) , y(p.y) {} template Point3::Point3(const Point4& p) : x(p.x) , y(p.y) , z(p.z) {} template template Point2::Point2(const Point3& p) : x(TYPE(p.x)) , y(TYPE(p.y)) {} template template Point2::Point2(const Point4& p) : x(TYPE(p.x)) , y(TYPE(p.y)) {} template template Point3::Point3(const Point4& p) : x(TYPE(p.x)) , y(TYPE(p.y)) , z(TYPE(p.z)) {} //------------------------------------------------------------------------------- typedef Point2 Point2f;//!< 2D point (vector) class with float type elements typedef Point3 Point3f;//!< 3D point (vector) class with float type elements typedef Point4 Point4f;//!< 4D point (vector) class with float type elements typedef Point2 Point2d;//!< 2D point (vector) class with double type elements typedef Point3 Point3d;//!< 3D point (vector) class with double type elements typedef Point4 Point4d;//!< 4D point (vector) class with double type elements //------------------------------------------------------------------------------- }// namespace cy //------------------------------------------------------------------------------- typedef cy::Point2f cyPoint2f;//!< 2D point (vector) class with float type elements typedef cy::Point3f cyPoint3f;//!< 3D point (vector) class with float type elements typedef cy::Point4f cyPoint4f;//!< 4D point (vector) class with float type elements typedef cy::Point2d cyPoint2d;//!< 2D point (vector) class with double type elements typedef cy::Point3d cyPoint3d;//!< 3D point (vector) class with double type elements typedef cy::Point4d cyPoint4d;//!< 4D point (vector) class with double type elements //------------------------------------------------------------------------------- #endif ================================================ FILE: Library/MnSystem/IO/PoissonDisk/cyPointCloud.h ================================================ // cyCodeBase by Cem Yuksel // [www.cemyuksel.com] //------------------------------------------------------------------------------- //! \file cyPointCloud.h //! \author Cem Yuksel //! //! \brief Point cloud using a k-d tree //! //! This file includes a class that keeps a point cloud as a k-d tree //! for quickly finding n-nearest points to a given location. //! //------------------------------------------------------------------------------- // // Copyright (c) 2016, Cem Yuksel // All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. // //------------------------------------------------------------------------------- #ifndef _CY_POINT_CLOUD_H_INCLUDED_ #define _CY_POINT_CLOUD_H_INCLUDED_ //------------------------------------------------------------------------------- #ifdef max # define _CY_POP_MACRO_max # pragma push_macro("max") # undef max #endif //------------------------------------------------------------------------------- #include #include #include //------------------------------------------------------------------------------- namespace cy { //------------------------------------------------------------------------------- //! A point cloud class that uses a k-d tree for storing points. //! //! The GetPoints and GetClosest methods return the neighboring points to a //! given location. template class PointCloud { public: ///////////////////////////////////////////////////////////////////////////////// //!@name Constructors and Destructor PointCloud() : points(nullptr) , pointCount(0) {} PointCloud(SIZE_TYPE numPts, const PointType* pts, const SIZE_TYPE* customIndices = nullptr) : points(nullptr) , pointCount(0) { Build(numPts, pts, customIndices); } ~PointCloud() { delete[] points; } ///////////////////////////////////////////////////////////////////////////////// //!@ Access to internal data SIZE_TYPE GetPointCount() const { return pointCount - 1; }//!< Returns the point count const PointType& GetPoint(SIZE_TYPE i) const { return points[i + 1].Pos(); }//!< Returns the point at position i SIZE_TYPE GetPointIndex(SIZE_TYPE i) const { return points[i + 1].Index(); }//!< Returns the index of the point at position i ///////////////////////////////////////////////////////////////////////////////// //!@ Initialization //! Builds a k-d tree for the given points. //! The point locations are stored internally, along with the indices to the //! given array. void Build(SIZE_TYPE numPts, const PointType* pts, const SIZE_TYPE* customIndices = nullptr) { if(points) delete[] points; pointCount = numPts; if(pointCount == 0) { points = nullptr; return; } points = new PointData[pointCount + 1]; SIZE_TYPE* order = new SIZE_TYPE[pointCount]; for(SIZE_TYPE i = 0; i < pointCount; i++) order[i] = i; BuildKDTree(pts, customIndices, order, 1, 0, pointCount); delete[] order; } ///////////////////////////////////////////////////////////////////////////////// //!@ General search methods //! Returns all points to the given position within the given radius. //! Calls the given pointFound function for each point found. //! //! The given pointFound function can reduce the radiusSquared value. //! However, increasing the radiusSquared value can have unpredictable //! results. The callback function must be in the following form: //! //! void _CALLBACK(SIZE_TYPE index, const PointType &p, FType distanceSquared, //! FType &radiusSquared) template void GetPoints(const PointType& position, FType radius, _CALLBACK pointFound) { SIZE_TYPE internalNodes = (pointCount + 1) >> 1; SIZE_TYPE stack[60];// deep enough for 2^30 points int stackPos = 0; stack[0] = 1;// root node FType dist2 = radius * radius; while(stackPos >= 0) { SIZE_TYPE ix = stack[stackPos--]; const PointData* p = &points[ix]; const PointType pos = p->Pos(); if(ix < internalNodes) { int axis = p->Plane(); FType d = position[axis] - pos[axis]; if(d > 0) {// if dist1 is positive search right child first stack[++stackPos] = 2 * ix + 1; if(d * d < dist2) stack[++stackPos] = 2 * ix; } else {// dist1 is negative, search left child first stack[++stackPos] = 2 * ix; if(d * d < dist2) stack[++stackPos] = 2 * ix + 1; } } FType d2 = (pos - position).LengthSquared(); if(d2 < dist2) pointFound(p->Index(), pos, d2, dist2); } if((pointCount & SIZE_TYPE(1)) == 0) { const PointData* p = &points[pointCount]; FType d2 = (p->Pos() - position).LengthSquared(); if(d2 < dist2) pointFound(p->Index(), p->Pos(), d2, dist2); } } //! Used by one of the PointCloud::GetPoints() methods. //! //! Keeps the point index, position, and distance squared to a given search //! position. Used by one of the GetPoints methods. struct PointInfo { SIZE_TYPE index; //!< The index of the point PointType pos; //!< The position of the point FType distanceSquared;//!< Squared distance from the search position bool operator<(const PointInfo& b) const { return distanceSquared < b.distanceSquared; }//!< Comparison operator }; //! Returns the closest points to the given position within the given radius. //! It returns the number of points found. int GetPoints(const PointType& position, FType radius, SIZE_TYPE maxCount, PointInfo* closestPoints) { bool tooManyPoints = false; int pointsFound = 0; GetPoints(position, radius, [&](SIZE_TYPE i, const PointType& p, FType d2, FType& r2) { if(pointsFound == maxCount) { if(!tooManyPoints) { std::make_heap(closestPoints, closestPoints + maxCount); } std::pop_heap(closestPoints, closestPoints + maxCount); closestPoints[maxCount - 1].index = i; closestPoints[maxCount - 1].pos = p; closestPoints[maxCount - 1].distanceSquared = d2; std::push_heap(closestPoints, closestPoints + maxCount); r2 = closestPoints[0].distanceSquared; } else { closestPoints[pointsFound].index = i; closestPoints[pointsFound].pos = p; closestPoints[pointsFound].distanceSquared = d2; pointsFound++; } }); return pointsFound; } //! Returns the closest points to the given position. //! It returns the number of points found. int GetPoints(const PointType& position, SIZE_TYPE maxCount, PointInfo* closestPoints) { return GetPoints(position, std::numeric_limits::max(), maxCount, closestPoints); } ///////////////////////////////////////////////////////////////////////////////// //!@name Closest point methods //! Returns the closest point to the given position within the given radius. //! It returns true, if a point is found. bool GetClosest(const PointType& position, FType radius, SIZE_TYPE& closestIndex, PointType& closestPosition, FType& closestDistanceSquared) { bool found = false; GetPoints(position, radius, [&](SIZE_TYPE i, const PointType& p, FType d2, FType& r2) { found = true; closestIndex = i; closestPosition = p; closestDistanceSquared = d2; r2 = d2; }); return found; } //! Returns the closest point to the given position. //! It returns true, if a point is found. bool GetClosest(const PointType& position, SIZE_TYPE& closestIndex, PointType& closestPosition, FType& closestDistanceSquared) { return GetClosest(position, std::numeric_limits::max(), closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point index and position to the given position within //! the given index. It returns true, if a point is found. bool GetClosest(const PointType& position, FType radius, SIZE_TYPE& closestIndex, PointType& closestPosition) { FType closestDistanceSquared; return GetClosest(position, radius, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point index and position to the given position. //! It returns true, if a point is found. bool GetClosest(const PointType& position, SIZE_TYPE& closestIndex, PointType& closestPosition) { FType closestDistanceSquared; return GetClosest(position, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point index to the given position within the given //! radius. It returns true, if a point is found. bool GetClosestIndex(const PointType& position, FType radius, SIZE_TYPE& closestIndex) { FType closestDistanceSquared; PointType closestPosition; return GetClosest(position, radius, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point index to the given position. //! It returns true, if a point is found. bool GetClosestIndex(const PointType& position, SIZE_TYPE& closestIndex) { FType closestDistanceSquared; PointType closestPosition; return GetClosest(position, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point position to the given position within the given //! radius. It returns true, if a point is found. bool GetClosestPosition(const PointType& position, FType radius, PointType& closestPosition) { SIZE_TYPE closestIndex; FType closestDistanceSquared; return GetClosest(position, radius, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point position to the given position. //! It returns true, if a point is found. bool GetClosestPosition(const PointType& position, PointType& closestPosition) { SIZE_TYPE closestIndex; FType closestDistanceSquared; return GetClosest(position, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point distance squared to the given position within //! the given radius. It returns true, if a point is found. bool GetClosestDistanceSquared(const PointType& position, FType radius, FType& closestDistanceSquared) { SIZE_TYPE closestIndex; PointType closestPosition; return GetClosest(position, radius, closestIndex, closestPosition, closestDistanceSquared); } //! Returns the closest point distance squared to the given position. //! It returns true, if a point is found. bool GetClosestDistanceSquared(const PointType& position, FType& closestDistanceSquared) { SIZE_TYPE closestIndex; PointType closestPosition; return GetClosest(position, closestIndex, closestPosition, closestDistanceSquared); } ///////////////////////////////////////////////////////////////////////////////// private: ///////////////////////////////////////////////////////////////////////////////// //!@name Internal Structures and Methods class PointData { private: SIZE_TYPE indexAndSplitPlane;// first NBits bits indicates the splitting plane, // the rest of the bits store the point index. PointType p; // point position public: void Set(const PointType& pt, SIZE_TYPE index, uint32_t plane = 0) { p = pt; indexAndSplitPlane = (index << NBits()) | (plane & ((1 << NBits()) - 1)); } int Plane() const { return indexAndSplitPlane & ((1 << NBits()) - 1); } SIZE_TYPE Index() const { return indexAndSplitPlane >> NBits(); } const PointType& Pos() const { return p; } private: #if defined(__cpp_constexpr) || (defined(_MSC_VER) && _MSC_VER >= 1900) constexpr int NBits(uint32_t v = DIMENSIONS) const { return v < 2 ? v : 1 + NBits(v >> 1); } #else int NBits() const { int v = DIMENSIONS - 1, r, s; r = (v > 0xF) << 2; v >>= r; s = (v > 0x3) << 1; v >>= s; r |= s | (v >> 1); return r + 1; }// Supports up to 256 dimensions #endif }; PointData* points; // Keeps the points as a k-d tree. SIZE_TYPE pointCount;// Keeps the point count. // The main method for recursively building the k-d tree. void BuildKDTree(const PointType* pts, const SIZE_TYPE* indices, SIZE_TYPE* order, SIZE_TYPE kdIndex, SIZE_TYPE ixStart, SIZE_TYPE ixEnd) { SIZE_TYPE n = ixEnd - ixStart; if(n <= 1) { if(n > 0) { SIZE_TYPE ix = order[ixStart]; if(indices) points[kdIndex].Set(pts[ix], indices[ix]); else points[kdIndex].Set(pts[ix], ix); } } else { int axis = SplitAxis(pts, order, ixStart, ixEnd); SIZE_TYPE leftSize = LeftSize(n); SIZE_TYPE ixMid = ixStart + leftSize; std::nth_element(order + ixStart, order + ixMid, order + ixEnd, [&pts, axis](const int& a, const int& b) { return pts[a][axis] < pts[b][axis]; }); SIZE_TYPE ix = order[ixMid]; if(indices) points[kdIndex].Set(pts[ix], indices[ix], axis); else points[kdIndex].Set(pts[ix], ix, axis); BuildKDTree(pts, indices, order, kdIndex * 2, ixStart, ixMid); BuildKDTree(pts, indices, order, kdIndex * 2 + 1, ixMid + 1, ixEnd); } } // Returns the total number of nodes on the left sub-tree of a complete k-d // tree of size n. SIZE_TYPE LeftSize(SIZE_TYPE n) { SIZE_TYPE f = n;// Size of the full tree for(SIZE_TYPE s = 1; s < (SIZE_TYPE) (8 * sizeof(SIZE_TYPE)); s *= 2) f |= f >> s; SIZE_TYPE l = f >> 1;// Size of the full left child SIZE_TYPE r = l >> 1;// Size of the full right child without leaf nodes return (l + r + 1 <= n) ? l : n - r - 1; } // Returns axis with the largest span, used as the splitting axis for building // the k-d tree int SplitAxis(const PointType* pts, SIZE_TYPE* indices, SIZE_TYPE ixStart, SIZE_TYPE ixEnd) { PointType box_min = pts[indices[ixStart]]; PointType box_max = box_min; for(SIZE_TYPE i = ixStart + 1; i < ixEnd; i++) { PointType p = pts[indices[i]]; for(SIZE_TYPE d = 0; d < (SIZE_TYPE) DIMENSIONS; d++) { if(box_min[d] > p[d]) box_min[d] = p[d]; if(box_max[d] < p[d]) box_max[d] = p[d]; } } int axis = 0; { FType axisSize = box_max[0] - box_min[0]; for(SIZE_TYPE d = 1; d < (SIZE_TYPE) DIMENSIONS; d++) { FType s = box_max[d] - box_min[d]; if(axisSize < s) { axis = d; axisSize = s; } } } return axis; } ///////////////////////////////////////////////////////////////////////////////// }; //------------------------------------------------------------------------------- #ifdef _CY_POINT_H_INCLUDED_ template _CY_TEMPLATE_ALIAS(PointCloud2, (PointCloud, TYPE, 2>) );//!< A 2D point cloud using a k-d tree template _CY_TEMPLATE_ALIAS(PointCloud3, (PointCloud, TYPE, 3>) );//!< A 3D point cloud using a k-d tree template _CY_TEMPLATE_ALIAS(PointCloud4, (PointCloud, TYPE, 4>) );//!< A 4D point cloud using a k-d tree typedef PointCloud PointCloud2f;//!< A 2D point cloud using a k-d tree with float type //!< elements typedef PointCloud PointCloud3f;//!< A 3D point cloud using a k-d tree with float type //!< elements typedef PointCloud PointCloud4f;//!< A 4D point cloud using a k-d tree with float type //!< elements typedef PointCloud PointCloud2d;//!< A 2D point cloud using a k-d tree with double type //!< elements typedef PointCloud PointCloud3d;//!< A 3D point cloud using a k-d tree with double type //!< elements typedef PointCloud PointCloud4d;//!< A 4D point cloud using a k-d tree with double type //!< elements template _CY_TEMPLATE_ALIAS( PointCloudN, (PointCloud< Point, TYPE, DIMENSIONS>) ); //!< A multi-dimensional point //!< cloud using a k-d tree template _CY_TEMPLATE_ALIAS(PointCloudNf, (PointCloudN) );//!< A multi-dimensional point cloud //!< using a k-d tree with single //!< precision (float) template _CY_TEMPLATE_ALIAS(PointCloudNd, (PointCloudN) );//!< A multi-dimensional point cloud //!< using a k-d tree with double //!< precision (double) #endif //------------------------------------------------------------------------------- }// namespace cy //------------------------------------------------------------------------------- #ifdef _CY_POINT_H_INCLUDED_ template _CY_TEMPLATE_ALIAS( cyPointCloud2, (cy::PointCloud< cy::Point2, TYPE, 2>) );//!< A 2D point cloud using a k-d tree template _CY_TEMPLATE_ALIAS( cyPointCloud3, (cy::PointCloud< cy::Point3, TYPE, 3>) );//!< A 3D point cloud using a k-d tree template _CY_TEMPLATE_ALIAS( cyPointCloud4, (cy::PointCloud< cy::Point4, TYPE, 4>) );//!< A 4D point cloud using a k-d tree typedef cy::PointCloud cyPointCloud2f;//!< A 2D point cloud using a k-d tree with float type //!< elements typedef cy::PointCloud cyPointCloud3f;//!< A 3D point cloud using a k-d tree with float type //!< elements typedef cy::PointCloud cyPointCloud4f;//!< A 4D point cloud using a k-d tree with float type //!< elements typedef cy::PointCloud cyPointCloud2d;//!< A 2D point cloud using a k-d tree with double type //!< elements typedef cy::PointCloud cyPointCloud3d;//!< A 3D point cloud using a k-d tree with double type //!< elements typedef cy::PointCloud cyPointCloud4d;//!< A 4D point cloud using a k-d tree with double type //!< elements template _CY_TEMPLATE_ALIAS( cyPointCloudN, (cy::PointCloud< cy::Point, TYPE, DIMENSIONS>) ); //!< A multi-dimensional point //!< cloud using a k-d tree template _CY_TEMPLATE_ALIAS(cyPointCloudNf, (cyPointCloudN) );//!< A multi-dimensional point cloud //!< using a k-d tree with float type //!< elements template _CY_TEMPLATE_ALIAS(cyPointCloudNd, (cyPointCloudN) );//!< A multi-dimensional point cloud //!< using a k-d tree with double type //!< elements #endif //------------------------------------------------------------------------------- #ifdef _CY_POP_MACRO_max # pragma pop_macro("max") # undef _CY_POP_MACRO_max #endif //------------------------------------------------------------------------------- #endif ================================================ FILE: Library/MnSystem/IO/PoissonDisk/cySampleElim.h ================================================ // cyCodeBase by Cem Yuksel // [www.cemyuksel.com] //------------------------------------------------------------------------------- //! \file cySampleElim.h //! \author Cem Yuksel //! //! \brief Implementation of the weighted sample elimination method. //! //! This file includes an implementation of the weighted sample elimination //! method for generating Poisson disk sample sets. //! //! Blue noise (Poisson disk) sample sets produce high-quality sampling. They //! often lead to lower noise and better convergence with Monte Carlo sampling. //! They provide a uniform sample distribution over a sampling domain. Unlike //! regular random sampling, Poisson disk sample sets avoid placing any two //! samples too close together (determined by a Poisson disk radius). //! //! The weighted sample elimination method implemented in this file generates a //! subset of samples with blue noise (Poisson disk) characteristics from a given //! input sample set. The weighted sample elimination method is simple, //! computationally efficient, and suitable for any sampling domain. It produces //! high-quality blue noise sample sets with a relatively large average Poisson //! disk radius without the need for specifying a Poisson disk radius. It also //! allows progressive (adaptive) sampling and it is efficient for high- //! dimensional sampling. However, it does not guarantee maximal coverage. //! //! More details can be found in the original publication: //! //! Cem Yuksel. 2015. Sample Elimination for Generating Poisson Disk Sample Sets. //! Computer Graphics Forum 34, 2 (May 2015), 25-32. //! http://www.cemyuksel.com/research/sampleelimination/ //! //------------------------------------------------------------------------------- // // Copyright (c) 2016, Cem Yuksel // All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. // //------------------------------------------------------------------------------- #ifndef _CY_SAMPLE_ELIM_H_INCLUDED_ #define _CY_SAMPLE_ELIM_H_INCLUDED_ //------------------------------------------------------------------------------- #include "cyCore.h" #include "cyHeap.h" #include "cyPointCloud.h" //------------------------------------------------------------------------------- namespace cy { //------------------------------------------------------------------------------- //! An implementation of the weighted sample elimination method. //! //! Cem Yuksel. 2015. Sample Elimination for Generating Poisson Disk Sample Sets. //! Computer Graphics Forum 34, 2 (May 2015), 25-32. //! http://www.cemyuksel.com/research/sampleelimination/ //! //! This class keeps a number of parameters for the weighted sample elimination algorithm. //! The main algorithm is implemented in the Eliminate method. template class WeightedSampleElimination { public: //! The constructor sets the default parameters. WeightedSampleElimination() { for(int d = 0; d < DIMENSIONS; d++) { boundsMin[d] = FType(0); boundsMax[d] = FType(1); } alpha = FType(8); beta = FType(0.65); gamma = FType(1.5); tiling = false; weightLimiting = true; } //! Tiling determines whether the generated samples are tile-able. //! Tiling is off by default, but it is a good idea to turn it on for box-shaped sampling domains. //! Note that when tiling is off, weighted sample elimination is less likely to eliminate samples //! near the boundaries of the sampling domain. If you turn on tiling, make sure to set the //! correct boundaries for the sampling domain. void SetTiling(bool on = true) { tiling = on; } //! Returns true if the tiling parameter is turned on. bool IsTiling() const { return tiling; } //! Weight limiting is used by the default weight function and it is on by default. //! Using weight limiting typically leads to more pronounced blue noise characteristics; //! therefore, it is recommended. The beta parameter determines the amount of weight limiting. //! Setting the beta parameter to zero effectively turns off weight limiting. void SetWeightLimiting(bool on = true) { weightLimiting = on; } //! Returns true if weight limiting is turned on. bool IsWeightLimiting() const { return weightLimiting; } //! Returns the minimum bounds of the sampling domain. //! The sampling domain boundaries are used for tiling and computing the maximum possible //! Poisson disk radius for the sampling domain. The default boundaries are between 0 and 1. const PointType& GetBoundsMin() const { return boundsMin; } //! Returns the maximum bounds of the sampling domain. //! The sampling domain boundaries are used for tiling and computing the maximum possible //! Poisson disk radius for the sampling domain. The default boundaries are between 0 and 1. const PointType& GetBoundsMax() const { return boundsMax; } //! Sets the minimum bounds of the sampling domain. //! The sampling domain boundaries are used for tiling and computing the maximum possible //! Poisson disk radius for the sampling domain. The default boundaries are between 0 and 1. void SetBoundsMin(const PointType& bmin) { boundsMin = bmin; } //! Sets the maximum bounds of the sampling domain. //! The sampling domain boundaries are used for tiling and computing the maximum possible //! Poisson disk radius for the sampling domain. The default boundaries are between 0 and 1. void SetBoundsMax(const PointType& bmax) { boundsMax = bmax; } //! Sets the alpha parameter that is used by the default weight function. void SetParamAlpha(FType a) { alpha = a; } //! Returns the alpha parameter that is used by the default weight function. FType GetParamAlpha() const { return alpha; } //! Sets the beta parameter that is used by weight limiting for the default weight function. //! Setting the beta parameter to zero effectively turns off weight limiting. //! If weight limiting is off, this parameter has no effect. void SetParamBeta(FType b) { beta = b; } //! Returns the beta parameter that is used by weight limiting for the default weight function. FType GetParamBeta() const { return beta; } //! Sets the gamma parameter that is used by weight limiting for the default weight function. //! The gamma parameter adjusts weight limiting based on the ratio of the input and output counts. //! If weight limiting is off, this parameter has no effect. void SetParamGamma(FType c) { gamma = c; } //! Returns the gamma parameter that is used by weight limiting for the default weight function. FType GetParamGamma() const { return gamma; } //! This is the main method that uses weighted sample elimination for selecting a subset of samples //! with blue noise (Poisson disk) characteristics from a given input sample set (inputPoints). //! The selected samples are copied to outputPoints. The output size must be smaller than the input size. //! //! If the progressive parameter is true, the output sample points are ordered for progressive sampling, //! such that when the samples are introduced one by one in this order, each subset in the sequence //! exhibits blue noise characteristics. //! //! The d_max parameter defines radius within which the weight function is non-zero. //! //! The dimensions parameter specifies the dimensionality of the sampling domain. This parameter //! would typically be equal to the dimensionality of the sampling domain (specified by DIMENSIONS). //! However, smaller values can be used when sampling a low-dimensional manifold in a high-dimensional //! space, such as a surface in 3D. //! //! The weight function is the crucial component of weighted sample elimination. It computes the weight //! of a sample point based on the placement of its neighbors within d_max radius. The weight function //! must have the following form: //! //! FType weightFunction( const PointType &p0, const PointType &p1, FType dist2, FType d_max ) //! //! The arguments p0 and p1 are the two neighboring points, dist2 is the square of the Euclidean distance //! between these two points, and d_max is the current radius for the weight function. //! Note that if the progressive parameter is on, the d_max value sent to the weight function can be //! different than the d_max value passed to this method. template void Eliminate(const PointType* inputPoints, SIZE_TYPE inputSize, PointType* outputPoints, SIZE_TYPE outputSize, bool progressive, FType d_max, int dimensions, WeightFunction weightFunction) const { assert(outputSize < inputSize); assert(dimensions <= DIMENSIONS && dimensions >= 2); if(d_max <= FType(0)) d_max = 2 * GetMaxPoissonDiskRadius(dimensions, outputSize); DoEliminate(inputPoints, inputSize, outputPoints, outputSize, d_max, weightFunction, false); if(progressive) { std::vector tmpPoints(outputSize); PointType* inPts = outputPoints; PointType* outPts = tmpPoints.data(); SIZE_TYPE inSize = outputSize; SIZE_TYPE outSize = 0; while(inSize >= 3) { outSize = inSize / 2; d_max *= ProgressiveRadiusMultiplier(dimensions); DoEliminate(inPts, inSize, outPts, outSize, d_max, weightFunction, true); if(outPts != outputPoints) CY_MEMCOPY(PointType, outputPoints + outSize, outPts + outSize, inSize - outSize); PointType* tmpPts = inPts; inPts = outPts; outPts = tmpPts; inSize = outSize; } if(inPts != outputPoints) CY_MEMCOPY(PointType, outputPoints, inPts, outSize); } } //! This is the main method that uses weighted sample elimination for selecting a subset of samples //! with blue noise (Poisson disk) characteristics from a given input sample set (inputPoints). //! The selected samples are copied to outputPoints. The output size must be smaller than the input size. //! This method uses the default weight function. //! //! If the progressive parameter is true, the output sample points are ordered for progressive sampling, //! such that when the samples are introduced one by one in this order, each subset in the sequence //! exhibits blue noise characteristics. //! //! The d_max parameter defines radius within which the weight function is non-zero. If this parameter //! is zero (or negative), it is automatically computed using the sampling dimensions and the size of //! the output set. //! //! The dimensions parameter specifies the dimensionality of the sampling domain. This parameter //! would typically be equal to the dimensionality of the sampling domain (specified by DIMENSIONS). //! However, smaller values can be used when sampling a low-dimensional manifold in a high-dimensional //! space, such as a surface in 3D. void Eliminate(const PointType* inputPoints, SIZE_TYPE inputSize, PointType* outputPoints, SIZE_TYPE outputSize, bool progressive = false, FType d_max = FType(0), int dimensions = DIMENSIONS) const { if(d_max <= FType(0)) d_max = 2 * GetMaxPoissonDiskRadius(dimensions, outputSize); std::cout << d_max << std::endl; FType alpha = this->alpha; if(weightLimiting) { FType d_min = d_max * GetWeightLimitFraction(inputSize, outputSize); std::cout << d_min << std::endl; Eliminate(inputPoints, inputSize, outputPoints, outputSize, progressive, d_max, dimensions, [d_min, alpha](const PointType&, const PointType&, FType d2, FType d_max) { FType d = cySqrt(d2); if(d < d_min) d = d_min; return cyPow(FType(1) - d / d_max, alpha); }); } else { Eliminate(inputPoints, inputSize, outputPoints, outputSize, progressive, d_max, dimensions, [alpha](const PointType&, const PointType&, FType d2, FType d_max) { FType d = cySqrt(d2); return cyPow(FType(1) - d / d_max, alpha); }); } } //! Returns the maximum possible Poisson disk radius in the given dimensions for the given sampleCount //! to spread over the given domainSize. If the domainSize argument is zero or negative, it is computed //! as the area or N-dimensional volume of the box defined by the minimum and maximum bounds. //! This method is used for the default weight function. FType GetMaxPoissonDiskRadius(int dimensions, SIZE_TYPE sampleCount, FType domainSize = 0) const { assert(dimensions >= 2); if(domainSize <= FType(0)) { domainSize = boundsMax[0] - boundsMin[0]; for(int d = 1; d < DIMENSIONS; d++) { domainSize *= boundsMax[0] - boundsMin[0]; } } FType sampleArea = domainSize / (FType) sampleCount; FType r_max; switch(dimensions) { case 2: r_max = cySqrt(sampleArea / (FType(2) * cySqrt(FType(3)))); break; case 3: r_max = cyPow(sampleArea / (FType(4) * cySqrt(FType(2))), FType(1) / FType(3)); break; default: FType c; int d_start; if((dimensions & 1)) { c = FType(2); d_start = 3; } else { c = cyPi(); d_start = 4; } for(int d = d_start; d <= dimensions; d += 2) c *= FType(2) * cyPi() / FType(d); r_max = cyPow(sampleArea / c, FType(1) / FType(dimensions)); break; } return r_max; } private: PointType boundsMin; // The minimum bounds of the sampling domain. PointType boundsMax; // The maximum bounds of the sampling domain. FType alpha, beta, gamma;// Parameters of the default weight function. bool weightLimiting; // Specifies whether weight limiting is used with the default weight function. bool tiling; // Specifies whether the sampling domain is tiled. // Reflects a point near the bounds of the sampling domain off of all domain bounds for tiling. template void TilePoint(SIZE_TYPE index, const PointType& point, FType d_max, OPERATION operation, int dim = 0) const { for(int d = dim; d < DIMENSIONS; d++) { if(boundsMax[d] - point[d] < d_max) { PointType p = point; p[d] -= boundsMax[d] - boundsMin[d]; operation(index, p); TilePoint(index, p, d_max, operation, d + 1); } if(point[d] - boundsMin[d] < d_max) { PointType p = point; p[d] += boundsMax[d] - boundsMin[d]; operation(index, p); TilePoint(index, p, d_max, operation, d + 1); } } } // This is the method that performs weighted sample elimination. template void DoEliminate(const PointType* inputPoints, SIZE_TYPE inputSize, PointType* outputPoints, SIZE_TYPE outputSize, FType d_max, WeightFunction weightFunction, bool copyEliminated) const { // Build a k-d tree for samples PointCloud kdtree; if(tiling) { std::vector point(inputPoints, inputPoints + inputSize); std::vector index(inputSize); for(SIZE_TYPE i = 0; i < inputSize; i++) index[i] = i; auto AppendPoint = [&](SIZE_TYPE ix, const PointType& pt) { point.push_back(pt); index.push_back(ix); }; for(SIZE_TYPE i = 0; i < inputSize; i++) TilePoint(i, inputPoints[i], d_max, AppendPoint); kdtree.Build(point.size(), point.data(), index.data()); } else { kdtree.Build(inputSize, inputPoints); } // Assign weights to each sample std::vector w(inputSize, FType(0)); auto AddWeights = [&](SIZE_TYPE index, const PointType& point) { kdtree.GetPoints(point, d_max, [&weightFunction, d_max, &w, index, &point, &inputSize](SIZE_TYPE i, const PointType& p, FType d2, FType&) { if(i >= inputSize) return; if(i != index) w[index] += weightFunction(point, p, d2, d_max); }); }; for(SIZE_TYPE i = 0; i < inputSize; i++) AddWeights(i, inputPoints[i]); // Build a heap for the samples using their weights Heap heap; heap.SetDataPointer(w.data(), inputSize); heap.Build(); // While the number of samples is greater than desired auto RemoveWeights = [&](SIZE_TYPE index, const PointType& point) { kdtree.GetPoints(point, d_max, [&weightFunction, d_max, &w, index, &point, &heap, &inputSize](SIZE_TYPE i, const PointType& p, FType d2, FType&) { if(i >= inputSize) return; if(i != index) { w[i] -= weightFunction(point, p, d2, d_max); heap.MoveItemDown(i); } }); }; SIZE_TYPE sampleSize = inputSize; while(sampleSize > outputSize) { // Pull the top sample from heap SIZE_TYPE i = heap.GetTopItemID(); heap.Pop(); // For each sample around it, remove its weight contribution and update the heap RemoveWeights(i, inputPoints[i]); sampleSize--; } // Copy the samples to the output array SIZE_TYPE targetSize = copyEliminated ? inputSize : outputSize; for(SIZE_TYPE i = 0; i < targetSize; i++) { outputPoints[i] = inputPoints[heap.GetIDFromHeap(i)]; } } // Returns the change in weight function radius using half of the number of samples. It is used for progressive sampling. float ProgressiveRadiusMultiplier(int dimensions) const { return dimensions == 2 ? cySqrt(FType(2)) : cyPow(FType(2), FType(1) / FType(dimensions)); } // Returns the minimum radius fraction used by the default weight function. FType GetWeightLimitFraction(SIZE_TYPE inputSize, SIZE_TYPE outputSize) const { FType ratio = FType(outputSize) / FType(inputSize); return (1 - cyPow(ratio, gamma)) * beta; } }; //------------------------------------------------------------------------------- }// namespace cy //------------------------------------------------------------------------------- #endif ================================================ FILE: Library/MnSystem/sourcelist.cmake ================================================ set(CudaSystemSrc ${PROJECT_SOURCE_DIR}/Library/MnSystem/Cuda/Cuda.cu ${PROJECT_SOURCE_DIR}/Library/MnSystem/Cuda/DeviceUtils.cu ${PROJECT_SOURCE_DIR}/Library/MnSystem/Cuda/MemoryUtils.cu ) ================================================ FILE: Projects/CMakeLists.txt ================================================ # borrowed from taichi file(GLOB children RELATIVE ${CMAKE_CURRENT_LIST_DIR} *) foreach(dir ${children}) if(IS_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/${dir}") if (${dir} MATCHES "^_") message("Ignoring project ${dir}. (Starts with '_'.)") else() if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${dir}/CMakeLists.txt") message("Adding project ${dir}:") add_subdirectory(${dir}) else() message("Ignoring project ${dir}. (No CMakeLists.txt.)") endif() endif() endif() message("---------------------------------------------------------------") endforeach() set(MN_PROJECT_LIBRARIES ${MN_PROJECT_LIBRARIES} PARENT_SCOPE) ================================================ FILE: Projects/GMPM/CMakeLists.txt ================================================ if (CUDA_FOUND) add_cuda_executable(gmpm) target_sources(gmpm PRIVATE gmpm.cu ) target_link_libraries(gmpm PRIVATE mnio cxxopts spdlog fmt rapidjson range-v3 ) #Add headers as system headers get_target_property(HEADERS_CXXOPTS cxxopts INTERFACE_INCLUDE_DIRECTORIES) get_target_property(HEADERS_SPDLOGS spdlog INTERFACE_INCLUDE_DIRECTORIES) get_target_property(HEADERS_FMT fmt INTERFACE_SYSTEM_INCLUDE_DIRECTORIES) get_target_property(HEADERS_RAPIDJSON rapidjson INTERFACE_SYSTEM_INCLUDE_DIRECTORIES) get_target_property(HEADERS_RANGE_V3 range-v3 INTERFACE_SYSTEM_INCLUDE_DIRECTORIES) target_include_directories(gmpm SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/Library PRIVATE ${HEADERS_CXXOPTS} PRIVATE ${HEADERS_SPDLOGS} PRIVATE ${HEADERS_FMT} PRIVATE ${HEADERS_RAPIDJSON} PRIVATE ${HEADERS_RANGE_V3} ) #Copy scene files install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/scenes DESTINATION ${CMAKE_INSTALL_BINDIR} #FILES_MATCHING PATTERN "*.json" ) endif() ================================================ FILE: Projects/GMPM/constitutive_models.cuh ================================================ #ifndef CONSTITUTIVE_MODELS_CUH #define CONSTITUTIVE_MODELS_CUH #include #include #include #include "settings.h" //NOLINTNEXTLINE(cppcoreguidelines-macro-usage) Macro usage necessary here for preprocessor if #define USE_JOSH_FRACTURE_PAPER 1//Selects which solve is used namespace mn { //Need this, cause we cannot partially instantiate function templates in current c++ version template struct ComputeStressIntermediate { T bm; T xi; T beta; T msqr; T log_jp; T cohesion; T yield_surface; bool hardening_on; bool volume_correction; }; //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template __forceinline__ __device__ void compute_stress(const T volume, const T mu, const T lambda, std::array& F, std::array& PF, ComputeStressIntermediate& data); //NOLINTEND(readability-magic-numbers, readability-identifier-naming) //TODO: But maybe use names instead for better understanding //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template<> __forceinline__ __device__ void compute_stress(const float volume, const float mu, const float lambda, std::array& F, std::array& PF, ComputeStressIntermediate& data) { (void) data; std::array U = {}; std::array S = {}; std::array V = {}; math::svd(F[0], F[3], F[6], F[1], F[4], F[7], F[2], F[5], F[8], U[0], U[3], U[6], U[1], U[4], U[7], U[2], U[5], U[8], S[0], S[1], S[2], V[0], V[3], V[6], V[1], V[4], V[7], V[2], V[5], V[8]); float J = S[0] * S[1] * S[2]; float scaled_mu = 2.0f * mu; float scaled_lambda = lambda * (J - 1.0f); vec P_hat; P_hat[0] = scaled_mu * (S[0] - 1.f) + scaled_lambda * (S[1] * S[2]); P_hat[1] = scaled_mu * (S[1] - 1.f) + scaled_lambda * (S[0] * S[2]); P_hat[2] = scaled_mu * (S[2] - 1.f) + scaled_lambda * (S[0] * S[1]); vec P; P[0] = P_hat[0] * U[0] * V[0] + P_hat[1] * U[3] * V[3] + P_hat[2] * U[6] * V[6]; P[1] = P_hat[0] * U[1] * V[0] + P_hat[1] * U[4] * V[3] + P_hat[2] * U[7] * V[6]; P[2] = P_hat[0] * U[2] * V[0] + P_hat[1] * U[5] * V[3] + P_hat[2] * U[8] * V[6]; P[3] = P_hat[0] * U[0] * V[1] + P_hat[1] * U[3] * V[4] + P_hat[2] * U[6] * V[7]; P[4] = P_hat[0] * U[1] * V[1] + P_hat[1] * U[4] * V[4] + P_hat[2] * U[7] * V[7]; P[5] = P_hat[0] * U[2] * V[1] + P_hat[1] * U[5] * V[4] + P_hat[2] * U[8] * V[7]; P[6] = P_hat[0] * U[0] * V[2] + P_hat[1] * U[3] * V[5] + P_hat[2] * U[6] * V[8]; P[7] = P_hat[0] * U[1] * V[2] + P_hat[1] * U[4] * V[5] + P_hat[2] * U[7] * V[8]; P[8] = P_hat[0] * U[2] * V[2] + P_hat[1] * U[5] * V[5] + P_hat[2] * U[8] * V[8]; /// PF' PF[0] = (P[0] * F[0] + P[3] * F[3] + P[6] * F[6]) * volume; PF[1] = (P[1] * F[0] + P[4] * F[3] + P[7] * F[6]) * volume; PF[2] = (P[2] * F[0] + P[5] * F[3] + P[8] * F[6]) * volume; PF[3] = (P[0] * F[1] + P[3] * F[4] + P[6] * F[7]) * volume; PF[4] = (P[1] * F[1] + P[4] * F[4] + P[7] * F[7]) * volume; PF[5] = (P[2] * F[1] + P[5] * F[4] + P[8] * F[7]) * volume; PF[6] = (P[0] * F[2] + P[3] * F[5] + P[6] * F[8]) * volume; PF[7] = (P[1] * F[2] + P[4] * F[5] + P[7] * F[8]) * volume; PF[8] = (P[2] * F[2] + P[5] * F[5] + P[8] * F[8]) * volume; } //NOLINTEND(readability-magic-numbers, readability-identifier-naming) //TODO: But maybe use names instead for better understanding //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template<> __forceinline__ __device__ void compute_stress(const float volume, const float mu, const float lambda, std::array& F, std::array& PF, ComputeStressIntermediate& data) { //FIXME: Explodes on impact. Not sure why. J gets very low. Clamping of all J prevents crash, but results are still wrong. (void) lambda; std::array U = {}; std::array S = {}; std::array V = {}; math::svd(F[0], F[3], F[6], F[1], F[4], F[7], F[2], F[5], F[8], U[0], U[3], U[6], U[1], U[4], U[7], U[2], U[5], U[8], S[0], S[1], S[2], V[0], V[3], V[6], V[1], V[4], V[7], V[2], V[5], V[8]); float p0 = data.bm * (static_cast(0.00001) + sinh(data.xi * (-data.log_jp > 0 ? -data.log_jp : 0))); float p_min = -data.beta * p0; float Je_trial = S[0] * S[1] * S[2]; ///< 0). calculate YS std::array B_hat_trial = {S[0] * S[0], S[1] * S[1], S[2] * S[2]}; float trace_B_hat_trial_divdim = (B_hat_trial[0] + B_hat_trial[1] + B_hat_trial[2]) / 3.f; float J_power_neg_2_d_mulmu = mu * powf(Je_trial, -2.f / 3.f);///< J^(-2/dim) * mu std::array s_hat_trial = {J_power_neg_2_d_mulmu * (B_hat_trial[0] - trace_B_hat_trial_divdim), J_power_neg_2_d_mulmu * (B_hat_trial[1] - trace_B_hat_trial_divdim), J_power_neg_2_d_mulmu * (B_hat_trial[2] - trace_B_hat_trial_divdim)}; float psi_kappa_partial_J = data.bm * 0.5f * (Je_trial - 1.f / Je_trial); float p_trial = -psi_kappa_partial_J * Je_trial; float y_s_half_coeff = 3.f / 2.f * (1 + 2.f * data.beta);///< a float y_p_half = (data.msqr * (p_trial - p_min) * (p_trial - p0)); float s_hat_trial_sqrnorm = s_hat_trial[0] * s_hat_trial[0] + s_hat_trial[1] * s_hat_trial[1] + s_hat_trial[2] * s_hat_trial[2]; float y = (y_s_half_coeff * s_hat_trial_sqrnorm) + y_p_half; if( //blockIdx.x == 0 && threadIdx.x == 0 Je_trial < 0.1 ){ //printf("%.32f %.32f %.32f, %.32f %.32f %.32f, %.32f %.32f %.32f # %.32f - ", F[0], F[1], F[2], F[3], F[4], F[5], F[6], F[7], F[8], Je_trial); } //< 1). update strain and hardening alpha(in log_jp) ///< case 1, project to max tip of YS if(p_trial > p0) { float Je_new = sqrtf(-2.f * p0 / data.bm + 1.f); S[0] = S[1] = S[2] = powf(Je_new, 1.f / 3.f); std::array New_F = {}; matmul_mat_diag_mat_t_3d(New_F, U, S, V); #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } if(data.hardening_on) { data.log_jp += logf(Je_trial / Je_new); } }///< case 1 -- end /// case 2, project to min tip of YS else if(p_trial < p_min) { float Je_new = sqrtf(-2.f * p_min / data.bm + 1.f); S[0] = S[1] = S[2] = powf(Je_new, 1.f / 3.f); std::array New_F = {}; matmul_mat_diag_mat_t_3d(New_F, U, S, V); #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } if(data.hardening_on) { data.log_jp += logf(Je_trial / Je_new); } }///< case 2 -- end /// case 3, keep or project to YS by hardening else { ///< outside YS if(y >= 1e-4) { ////< yield surface projection float B_s_coeff = powf(Je_trial, 2.f / 3.f) / mu * sqrtf(-y_p_half / y_s_half_coeff) / sqrtf(s_hat_trial_sqrnorm); #pragma unroll 3 for(int i = 0; i < 3; i++) { S[i] = sqrtf(s_hat_trial[i] * B_s_coeff + trace_B_hat_trial_divdim); } std::array New_F = {}; matmul_mat_diag_mat_t_3d(New_F, U, S, V); #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } ////< hardening if(data.hardening_on && p0 > 1e-4 && p_trial < p0 - 1e-4 && p_trial > 1e-4 + p_min) { float p_center = (static_cast(1.0) - data.beta) * p0 / 2; #if USE_JOSH_FRACTURE_PAPER/// solve in 19 Josh Fracture paper float q_trial = sqrtf(3.f / 2.f * s_hat_trial_sqrnorm); std::array direction = {p_center - p_trial, -q_trial}; float direction_norm = sqrtf(direction[0] * direction[0] + direction[1] * direction[1]); direction[0] /= direction_norm; direction[1] /= direction_norm; float C = data.msqr * (p_center - p_min) * (p_center - p0); float B = data.msqr * direction[0] * (2 * p_center - p0 - p_min); float A = data.msqr * direction[0] * direction[0] + (1 + 2 * data.beta) * direction[1] * direction[1]; float l1 = (-B + sqrtf(B * B - 4 * A * C)) / (2 * A); float l2 = (-B - sqrtf(B * B - 4 * A * C)) / (2 * A); float p1 = p_center + l1 * direction[0]; float p2 = p_center + l2 * direction[0]; #else/// solve in ziran - Compare_With_Physbam float aa = data.msqr * powf(p_trial - p_center, 2) / (y_s_half_coeff * s_hat_trial_sqrnorm); float dd = 1 + aa; float ff = aa * data.beta * p0 - aa * p0 - 2 * p_center; float gg = (p_center * p_center) - aa * data.beta * (p0 * p0); float zz = sqrtf(fabsf(ff * ff - 4 * dd * gg)); float p1 = (-ff + zz) / (2 * dd); float p2 = (-ff - zz) / (2 * dd); #endif float p_fake = (p_trial - p_center) * (p1 - p_center) > 0 ? p1 : p2; float tmp_Je_sqr = (-2 * p_fake / data.bm + 1); float Je_new_fake = sqrtf(tmp_Je_sqr > 0 ? tmp_Je_sqr : -tmp_Je_sqr); if(Je_new_fake > 1e-4) { data.log_jp += logf(Je_trial / Je_new_fake); } } }///< outside YS -- end } ///< case 3 --end //< 2). elasticity ///< known: F(renewed), U, V, S(renewed) ///< unknown: J, dev(FF^T) float J = S[0] * S[1] * S[2]; std::array b_dev = {}; std::array b = {}; matrix_matrix_tranpose_multiplication_3d(F, b); matrix_deviatoric_3d(b, b_dev); //FIXME: Fail-safe test for precision error caused by compiler. Not placed in matrix_deviatoric_3d cause error does not seem to be detectable in there if(b[0] == 1.0f && b[1] == 1.0f && b[2] == 1.0f && (b_dev[0] != 0.0f || b_dev[4] != 0.0f || b_dev[8] != 0.0f)) { //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) Cuda has no other way to print; Numbers are array indices to be printed printf("matrix_deviatoric_3d failed to get things write (probably compiler issue)"); } ///< |f| = P * F^T * Volume float dev_b_coeff = mu * powf(J, -2.f / 3.f); float i_coeff = data.bm * .5f * ((J * J - 1.f) * 0.5f - logf(J)); PF[0] = (dev_b_coeff * b_dev[0] + i_coeff) * volume; PF[1] = (dev_b_coeff * b_dev[1]) * volume; PF[2] = (dev_b_coeff * b_dev[2]) * volume; PF[3] = (dev_b_coeff * b_dev[3]) * volume; PF[4] = (dev_b_coeff * b_dev[4] + i_coeff) * volume; PF[5] = (dev_b_coeff * b_dev[5]) * volume; PF[6] = (dev_b_coeff * b_dev[6]) * volume; PF[7] = (dev_b_coeff * b_dev[7]) * volume; PF[8] = (dev_b_coeff * b_dev[8] + i_coeff) * volume; if( //blockIdx.x == 0 && threadIdx.x == 0 isnan(PF[0]) ){ //printf("%.32f %.32f %.32f, %.32f %.32f %.32f, %.32f %.32f %.32f # %.32f %.32f %.32f, %.32f %.32f %.32f, %.32f %.32f %.32f # %.32f %.32f - ", F[0], F[1], F[2], F[3], F[4], F[5], F[6], F[7], F[8], b_dev[0], b_dev[1], b_dev[2], b_dev[3], b_dev[4], b_dev[5], b_dev[6], b_dev[7], b_dev[8], i_coeff, J); } } //NOLINTEND(readability-magic-numbers, readability-identifier-naming) //TODO: But maybe use names instead for better understanding //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template<> __forceinline__ __device__ void compute_stress(const float volume, const float mu, const float lambda, std::array& F, std::array& PF, ComputeStressIntermediate& data) { std::array U = {}; std::array S = {}; std::array V = {}; math::svd(F[0], F[3], F[6], F[1], F[4], F[7], F[2], F[5], F[8], U[0], U[3], U[6], U[1], U[4], U[7], U[2], U[5], U[8], S[0], S[1], S[2], V[0], V[3], V[6], V[1], V[4], V[7], V[2], V[5], V[8]); float scaled_mu = static_cast(2.0) * mu; std::array epsilon = {}; std::array New_S = {};///< helper std::array New_F = {}; #pragma unroll 3 for(int i = 0; i < 3; i++) { float abs_S = S[i] > 0 ? S[i] : -S[i]; abs_S = abs_S > static_cast(1e-4) ? abs_S : static_cast(1e-4); epsilon[i] = logf(abs_S) - data.cohesion; } float sum_epsilon = epsilon[0] + epsilon[1] + epsilon[2]; float trace_epsilon = sum_epsilon + data.log_jp; std::array epsilon_hat = {}; #pragma unroll 3 for(int i = 0; i < 3; i++) { epsilon_hat[i] = epsilon[i] - (trace_epsilon / static_cast(3.0)); } float epsilon_hat_norm = sqrtf(epsilon_hat[0] * epsilon_hat[0] + epsilon_hat[1] * epsilon_hat[1] + epsilon_hat[2] * epsilon_hat[2]); /* Calculate Plasticiy */ if(trace_epsilon >= static_cast(0.0)) {///< case II: project to the cone tip New_S[0] = New_S[1] = New_S[2] = expf(data.cohesion); matmul_mat_diag_mat_t_3d(New_F, U, New_S, V);// new F_e /* Update F */ #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } if(data.volume_correction) { data.log_jp = data.beta * sum_epsilon + data.log_jp; } } else if(mu != 0) { data.log_jp = 0; float delta_gamma = epsilon_hat_norm + (static_cast(3.0) * lambda + scaled_mu) / scaled_mu * trace_epsilon * data.yield_surface; std::array H = {}; if(delta_gamma <= 0) {///< case I: inside the yield surface cone #pragma unroll 3 for(int i = 0; i < 3; i++) { H[i] = epsilon[i] + data.cohesion; } } else {///< case III: project to the cone surface #pragma unroll 3 for(int i = 0; i < 3; i++) { H[i] = epsilon[i] - (delta_gamma / epsilon_hat_norm) * epsilon_hat[i] + data.cohesion; } } #pragma unroll 3 for(int i = 0; i < 3; i++) { New_S[i] = expf(H[i]); } matmul_mat_diag_mat_t_3d(New_F, U, New_S, V);// new F_e /* Update F */ #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } } else { //TODO: What to do here? Just don't change values? } /* Elasticity -- Calculate Coefficient */ std::array New_S_log = {logf(New_S[0]), logf(New_S[1]), logf(New_S[2])}; std::array P_hat = {}; // float S_inverse[3] = {1.f/S[0], 1.f/S[1], 1.f/S[2]}; // TO CHECK // float S_inverse[3] = {1.f / New_S[0], 1.f / New_S[1], 1.f / New_S[2]}; // TO // CHECK float trace_log_S = New_S_log[0] + New_S_log[1] + New_S_log[2]; #pragma unroll 3 for(int i = 0; i < 3; i++) { P_hat[i] = (scaled_mu * New_S_log[i] + lambda * trace_log_S) / New_S[i]; } std::array P = {}; matmul_mat_diag_mat_t_3d(P, U, P_hat, V); ///< |f| = P * F^T * Volume PF[0] = (P[0] * F[0] + P[3] * F[3] + P[6] * F[6]) * volume; PF[1] = (P[1] * F[0] + P[4] * F[3] + P[7] * F[6]) * volume; PF[2] = (P[2] * F[0] + P[5] * F[3] + P[8] * F[6]) * volume; PF[3] = (P[0] * F[1] + P[3] * F[4] + P[6] * F[7]) * volume; PF[4] = (P[1] * F[1] + P[4] * F[4] + P[7] * F[7]) * volume; PF[5] = (P[2] * F[1] + P[5] * F[4] + P[8] * F[7]) * volume; PF[6] = (P[0] * F[2] + P[3] * F[5] + P[6] * F[8]) * volume; PF[7] = (P[1] * F[2] + P[4] * F[5] + P[7] * F[8]) * volume; PF[8] = (P[2] * F[2] + P[5] * F[5] + P[8] * F[8]) * volume; } //NOLINTEND(readability-magic-numbers, readability-identifier-naming) }// namespace mn #endif ================================================ FILE: Projects/GMPM/gmpm.cu ================================================ #include #include #include #include #include #include #include #include #include #include #include "gmpm_simulator.cuh" namespace fs = std::filesystem; #include #include #include namespace rj = rapidjson; namespace { const std::array K_TYPE_NAMES {"Null", "False", "True", "Object", "Array", "String", "Number"}; }// namespace // dragon_particles.bin, 775196 // cube256_2.bin, 1048576 // two_dragons.bin, 388950 decltype(auto) load_model(std::size_t particle_counts, const std::string& filename) { std::vector> rawpos(particle_counts); auto addr_str = std::string(AssetDirPath) + "MpmParticles/"; FILE* f; fopen_s(&f, (addr_str + filename).c_str(), "rb"); std::fread(rawpos.data(), sizeof(float), rawpos.size() * mn::config::NUM_DIMENSIONS, f); std::fclose(f); return rawpos; } struct SimulatorConfigs { int dim = 0; float dx = NAN; float dx_inv = NAN; int resolution = 0; float gravity = NAN; std::vector offset = {}; } const SIM_CONFIGS; namespace { template inline bool check_member(const T& model, const char* member) { if(!model.HasMember(member)) { fmt::print("Membert not found: {}\n", member); return false; } else { return true; } } }// namespace //NOLINTBEGIN(clang-analyzer-cplusplus.PlacementNew) check_member prevents the error case void parse_scene(const std::string& fn, std::unique_ptr& benchmark) { fs::path p {fn}; if(!p.is_absolute()) { p = fs::relative(p); } if(!fs::exists(p)) { fmt::print("file not exist {}\n", fn); } else { std::size_t size = fs::file_size(p); std::string configs; configs.resize(size); std::ifstream istrm(fn); if(!istrm.is_open()) { fmt::print("cannot open file {}\n", fn); } else { istrm.read(configs.data(), static_cast(configs.size())); } istrm.close(); fmt::print("load the scene file of size {}\n", size); rj::Document doc; doc.Parse(configs.data()); for(rj::Value::ConstMemberIterator itr = doc.MemberBegin(); itr != doc.MemberEnd(); ++itr) { fmt::print("Scene member {} is {}\n", itr->name.GetString(), K_TYPE_NAMES[itr->value.GetType()]); } { auto it = doc.FindMember("simulation"); if(it != doc.MemberEnd()) { auto& sim = it->value; if(sim.IsObject()) { fmt::print(fg(fmt::color::cyan), "simulation: gpuid[{}], defaultDt[{}], fps[{}], frames[{}]\n", sim["gpuid"].GetInt(), sim["default_dt"].GetFloat(), sim["fps"].GetInt(), sim["frames"].GetInt()); benchmark = std::make_unique(sim["gpuid"].GetInt(), mn::Duration(sim["default_dt"].GetFloat()), sim["fps"].GetInt(), sim["frames"].GetInt()); } } }///< end simulation parsing { auto it = doc.FindMember("models"); if(it != doc.MemberEnd()) { if(it->value.IsArray()) { fmt::print("has {} models\n", it->value.Size()); for(auto& model: it->value.GetArray()) { if(!check_member(model, "constitutive") || !check_member(model, "file")) { return; } std::string constitutive {model["constitutive"].GetString()}; fmt::print(fg(fmt::color::green), "model constitutive[{}], file[{}]\n", constitutive, model["file"].GetString()); fs::path p {model["file"].GetString()}; auto init_model = [&](auto& positions, auto& velocity) { if(constitutive == "fixed_corotated") { if(!check_member(model, "rho") || !check_member(model, "volume") || !check_member(model, "youngs_modulus") || !check_member(model, "poisson_ratio")) { return; } benchmark->init_model(positions, velocity); benchmark->update_fr_parameters(model["rho"].GetFloat(), model["volume"].GetFloat(), model["youngs_modulus"].GetFloat(), model["poisson_ratio"].GetFloat()); } else if(constitutive == "jfluid") { if(!check_member(model, "rho") || !check_member(model, "volume") || !check_member(model, "bulk_modulus") || !check_member(model, "gamma") || !check_member(model, "viscosity")) { return; } benchmark->init_model(positions, velocity); benchmark->update_j_fluid_parameters(model["rho"].GetFloat(), model["volume"].GetFloat(), model["bulk_modulus"].GetFloat(), model["gamma"].GetFloat(), model["viscosity"].GetFloat()); } else if(constitutive == "nacc") { if(!check_member(model, "rho") || !check_member(model, "volume") || !check_member(model, "youngs_modulus") || !check_member(model, "poisson_ratio") || !check_member(model, "beta") || !check_member(model, "xi")) { return; } benchmark->init_model(positions, velocity); benchmark->update_nacc_parameters(model["rho"].GetFloat(), model["volume"].GetFloat(), model["youngs_modulus"].GetFloat(), model["poisson_ratio"].GetFloat(), model["beta"].GetFloat(), model["xi"].GetFloat()); } else if(constitutive == "sand") { benchmark->init_model(positions, velocity); } else { fmt::print("Unknown constitutive: {}", constitutive); } }; mn::vec offset; mn::vec span; mn::vec velocity; if(!check_member(model, "offset") || !check_member(model, "span") || !check_member(model, "velocity")) { return; } for(int d = 0; d < mn::config::NUM_DIMENSIONS; ++d) { offset[d] = model["offset"].GetArray()[d].GetFloat(); span[d] = model["span"].GetArray()[d].GetFloat(); velocity[d] = model["velocity"].GetArray()[d].GetFloat(); } if(p.extension() == ".sdf") { auto positions = mn::read_sdf(model["file"].GetString(), mn::config::MODEL_PPC, mn::config::G_DX, mn::config::G_DOMAIN_SIZE, offset, span); mn::IO::insert_job([&]() { mn::write_partio(p.stem().string() + ".bgeo", positions); }); mn::IO::flush(); init_model(positions, velocity); } } } } }///< end models parsing } } //NOLINTEND(clang-analyzer-cplusplus.PlacementNew) int main(int argc, char* argv[]) { mn::Cuda::startup(); cxxopts::Options options("Scene_Loader", "Read simulation scene"); options.add_options()("f,file", "Scene Configuration File", cxxopts::value()->default_value("scenes/scene.json")); auto results = options.parse(argc, argv); auto fn = results["file"].as(); fmt::print("loading scene [{}]\n", fn); std::unique_ptr benchmark; parse_scene(fn, benchmark); /* benchmark = std::make_unique(1, 1e-4, 24, 60); constexpr auto LEN = 46; constexpr auto STRIDE = 56; constexpr auto MODEL_COUNT = 3; for(int did = 0; did < 2; ++did) { std::vector> model; for(int i = 0; i < MODEL_COUNT; ++i) { auto idx = (did * MODEL_COUNT + i); model = sample_uniform_box( gdx, ivec3 {18 + (idx & 1 ? STRIDE : 0), 18, 18}, ivec3 {18 + (idx & 1 ? STRIDE : 0) + LEN, 18 + LEN, 18 + LEN} ); } benchmark->init_model( model, vec {0.f, 0.f, 0.f} ); } */ getchar(); benchmark->main_loop(); /// mn::IO::flush(); benchmark.reset(); /// mn::Cuda::shutdown(); return 0; } ================================================ FILE: Projects/GMPM/gmpm_simulator.cuh ================================================ #ifndef GMPM_SIMULATOR_CUH #define GMPM_SIMULATOR_CUH #include #include #include #include #include #include #include #include #include #include #include #include #include "grid_buffer.cuh" #include "hash_table.cuh" #include "mgmpm_kernels.cuh" #include "particle_buffer.cuh" #include "settings.h" namespace mn { struct GmpmSimulator { static constexpr Duration DEFAULT_DT = Duration(1e-4); static constexpr int DEFAULT_FPS = 24; static constexpr int DEFAULT_FRAMES = 60; static constexpr int DEFAULT_CUDA_BLOCK_SIZE = 256; static constexpr size_t BIN_COUNT = 2; using streamIdx = Cuda::StreamIndex; using eventIdx = Cuda::EventIndex; using host_allocator = HeapAllocator; static_assert(std::is_same_v, "block index type is not int"); struct DeviceAllocator { // hide the global one void* allocate(std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member void* ret = nullptr; check_cuda_errors(cudaMalloc(&ret, bytes)); return ret; } void deallocate(void* p, std::size_t size) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) size; check_cuda_errors(cudaFree(p)); } }; struct Intermediates { void* base; int* d_tmp; int* active_block_marks; int* destinations; int* sources; int* bin_sizes; float* d_max_vel; //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) Current c++ version does not yet support std::span void alloc(size_t max_block_count) { //NOLINTBEGIN(readability-magic-numbers) Magic numbers are variable count check_cuda_errors(cudaMalloc(&base, sizeof(int) * (max_block_count * 5 + 1))); d_tmp = static_cast(base); active_block_marks = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count)); destinations = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 2)); sources = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 3)); bin_sizes = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 4)); d_max_vel = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 5)); //NOLINTEND(readability-magic-numbers) } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) void dealloc() const { cudaDeviceSynchronize(); check_cuda_errors(cudaFree(base)); } void resize(size_t max_block_count) { dealloc(); alloc(max_block_count); } }; /// int gpuid; int nframes; int fps; /// animation runtime settings Duration dt; Duration next_dt; Duration dt_default; Duration cur_time; float max_vel; uint64_t cur_frame; uint64_t cur_step; /// data on device, double buffering std::vector grid_blocks = {}; std::array, BIN_COUNT> particle_bins = {}; std::vector> partitions = {};///< with halo info std::vector particles = {}; Intermediates tmps; /// data on host char rollid; std::size_t cur_num_active_blocks; std::vector cur_num_active_bins = {}; std::array checked_counts = {}; std::vector checked_bin_counts = {}; float max_vels; int partition_block_count; int neighbor_block_count; int exterior_block_count;///< num blocks std::vector bincount = {}; std::vector particle_counts = {};///< num particles std::vector> model = {}; std::vector vel0 = {}; explicit GmpmSimulator(int gpu = 0, Duration dt = DEFAULT_DT, int fps = DEFAULT_FPS, int frames = DEFAULT_FRAMES) : gpuid(gpu) , dt_default(dt) , cur_time(Duration::zero()) , rollid(0) , cur_frame(0) , cur_step(0) , fps(fps) , nframes(frames) , dt() , next_dt() , max_vel() , tmps() , cur_num_active_blocks() , max_vels() , partition_block_count() , neighbor_block_count() , exterior_block_count() { // data initialize(); } ~GmpmSimulator() = default; //TODO: Maybe implement? GmpmSimulator(GmpmSimulator& other) = delete; GmpmSimulator(GmpmSimulator&& other) = delete; GmpmSimulator& operator=(GmpmSimulator& other) = delete; GmpmSimulator& operator=(GmpmSimulator&& other) = delete; void initialize() { auto& cu_dev = Cuda::ref_cuda_context(gpuid); cu_dev.set_context(); //Allocate intermediate data for all blocks tmps.alloc(config::G_MAX_ACTIVE_BLOCK); //Create partitions and grid blocks for(int copyid = 0; copyid < BIN_COUNT; copyid++) { grid_blocks.emplace_back(DeviceAllocator {}); partitions.emplace_back(DeviceAllocator {}, config::G_MAX_ACTIVE_BLOCK); checked_counts[copyid] = 0; } cu_dev.syncStream(); cur_num_active_blocks = config::G_MAX_ACTIVE_BLOCK; } template void init_model(const std::vector>& model, const mn::vec& v0) { auto& cu_dev = Cuda::ref_cuda_context(gpuid); //Create particle buffers and reserve buckets for(int copyid = 0; copyid < BIN_COUNT; ++copyid) { particle_bins[copyid].emplace_back(ParticleBuffer(DeviceAllocator {}, model.size() / config::G_BIN_CAPACITY + config::G_MAX_ACTIVE_BLOCK)); match(particle_bins[copyid].back())([&](auto& particle_buffer) { particle_buffer.reserve_buckets(DeviceAllocator {}, config::G_MAX_ACTIVE_BLOCK); }); } //Set initial velocity vel0.emplace_back(); for(int i = 0; i < config::NUM_DIMENSIONS; ++i) { vel0.back()[i] = v0[i]; } //Create array for initial particles particles.emplace_back(spawn(DeviceAllocator {}, sizeof(float) * config::NUM_DIMENSIONS * model.size())); //Init bin counts cur_num_active_bins.emplace_back(config::G_MAX_PARTICLE_BIN); bincount.emplace_back(0); checked_bin_counts.emplace_back(0); //Init particle counts particle_counts.emplace_back(static_cast(model.size()));//NOTE: Explicic narrowing cast fmt::print("init {}-th model with {} particles\n", particle_bins[0].size() - 1, particle_counts.back()); //Copy particle positions from host to device cudaMemcpyAsync(static_cast(&particles.back().val_1d(_0, 0)), model.data(), sizeof(std::array) * model.size(), cudaMemcpyDefault, cu_dev.stream_compute()); cu_dev.syncStream(); //Write out initial state to file std::string fn = std::string {"model"} + "_id[" + std::to_string(particle_bins[0].size() - 1) + "]_frame[0].bgeo"; IO::insert_job([fn, model]() { write_partio(fn, model); }); IO::flush(); } void update_fr_parameters(float rho, float vol, float ym, float pr) { match(particle_bins[0].back())( [&](auto& particle_buffer) {}, [&](ParticleBuffer& particle_buffer) { particle_buffer.update_parameters(rho, vol, ym, pr); } ); match(particle_bins[1].back())( [&](auto& particle_buffer) {}, [&](ParticleBuffer& particle_buffer) { particle_buffer.update_parameters(rho, vol, ym, pr); } ); } void update_j_fluid_parameters(float rho, float vol, float bulk, float gamma, float viscosity) { match(particle_bins[0].back())( [&](auto& particle_buffer) {}, [&](ParticleBuffer& particle_buffer) { particle_buffer.update_parameters(rho, vol, bulk, gamma, viscosity); } ); match(particle_bins[1].back())( [&](auto& particle_buffer) {}, [&](ParticleBuffer& particle_buffer) { particle_buffer.update_parameters(rho, vol, bulk, gamma, viscosity); } ); } void update_nacc_parameters(float rho, float vol, float ym, float pr, float beta, float xi) { match(particle_bins[0].back())( [&](auto& particle_buffer) {}, [&](ParticleBuffer& particle_buffer) { particle_buffer.update_parameters(rho, vol, ym, pr, beta, xi); } ); match(particle_bins[1].back())( [&](auto& particle_buffer) {}, [&](ParticleBuffer& particle_buffer) { particle_buffer.update_parameters(rho, vol, ym, pr, beta, xi); } ); } //Sum up count values from in and store them in out template void exclusive_scan(int count, int const* const in, int* out, CudaContext& cu_dev) { auto policy = thrust::cuda::par.on(static_cast(cu_dev.stream_compute())); thrust::exclusive_scan(policy, get_device_ptr(in), get_device_ptr(in) + count, get_device_ptr(out)); /* std::size_t temp_storage_bytes = 0; auto plus_op = [] __device__(const int& a, const int& b) { return a + b; }; check_cuda_errors(cub::DeviceScan::ExclusiveScan(nullptr, temp_storage_bytes, in, out, plus_op, 0, count, cu_dev.stream_compute())); void* d_tmp = tmps[cu_dev.get_dev_id()].d_tmp; check_cuda_errors(cub::DeviceScan::ExclusiveScan(d_tmp, temp_storage_bytes, in, out, plus_op, 0, count, cu_dev.stream_compute())); */ } float get_mass(int id = 0) { return match(particle_bins[rollid][id])([&](const auto& particle_buffer) { return particle_buffer.mass; }); } [[nodiscard]] int get_model_count() const noexcept { return static_cast(particle_bins[0].size());//NOTE: Explicit narrowing cast (But we should not have that much models anyway.) } //Increase bin and active block count if too low void check_capacity() { //TODO: Is that right? Maybe create extra parameter for this? //NOLINTBEGIN(readability-magic-numbers) Magic numbers are resize thresholds? if(exterior_block_count > cur_num_active_blocks * config::NUM_DIMENSIONS / 4 && checked_counts[0] == 0) { cur_num_active_blocks = cur_num_active_blocks * config::NUM_DIMENSIONS / 2; checked_counts[0] = 2; fmt::print(fmt::emphasis::bold, "resizing blocks {} -> {}\n", exterior_block_count, cur_num_active_blocks); } for(int i = 0; i < get_model_count(); ++i) { if(bincount[i] > cur_num_active_bins[i] * config::NUM_DIMENSIONS / 4 && checked_bin_counts[i] == 0) { cur_num_active_bins[i] = cur_num_active_bins[i] * config::NUM_DIMENSIONS / 2; checked_bin_counts[i] = 2; fmt::print(fmt::emphasis::bold, "resizing bins {} -> {}\n", bincount[i], cur_num_active_bins[i]); } } //NOLINTEND(readability-magic-numbers) } //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) Current c++ version does not yet support std::span void main_loop() { /// initial const Duration seconds_per_frame(Duration(1) / Duration(fps)); { float max_vel = 0.f; for(int i = 0; i < get_model_count(); ++i) { const float vel_norm = std::sqrt(vel0[i].l2NormSqr()); if(vel_norm > max_vel) { max_vel = vel_norm; } } dt = compute_dt(max_vel, Duration::zero(), seconds_per_frame, dt_default); } fmt::print(fmt::emphasis::bold, "{} --{}--> {}, defaultDt: {}\n", cur_time.count(), dt.count(), seconds_per_frame.count(), dt_default.count()); initial_setup(); cur_time = Duration::zero(); for(cur_frame = 1; cur_frame <= nframes; ++cur_frame) { const Duration next_time = cur_time + seconds_per_frame; for(Duration current_step_time = Duration::zero(); current_step_time < seconds_per_frame; current_step_time += dt, cur_time += dt, cur_step++) { //Calculate maximum grid velocity and update the grid velocity { auto& cu_dev = Cuda::ref_cuda_context(gpuid); /// check capacity check_capacity(); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); float* d_max_vel = tmps.d_max_vel; //Initialize max_vel with 0 check_cuda_errors(cudaMemsetAsync(d_max_vel, 0, sizeof(float), cu_dev.stream_compute())); //Update the grid velocity //floor(neighbor_block_count/G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK); G_NUM_WARPS_PER_CUDA_BLOCK (>= G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK) cu_dev.compute_launch({(neighbor_block_count + config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK - 1) / config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK, config::G_NUM_WARPS_PER_CUDA_BLOCK * config::CUDA_WARP_SIZE * config::G_NUM_WARPS_PER_GRID_BLOCK}, update_grid_velocity_query_max, static_cast(neighbor_block_count), grid_blocks[0], partitions[rollid], dt, d_max_vel); //Copy maximum velocity to host site check_cuda_errors(cudaMemcpyAsync(&max_vels, d_max_vel, sizeof(float), cudaMemcpyDefault, cu_dev.stream_compute())); timer.tock(fmt::format("GPU[{}] frame {} step {} grid_update_query", gpuid, cur_frame, cur_step)); } /// host: compute maxvel & next dt float max_vel = max_vels; // if (max_vels > max_vel) // max_vel = max_vels[id]; //If our maximum velocity is infinity our computation will crash, so we stop here. if(std::isinf(max_vel)) { std::cout << "Maximum velocity is infinity" << std::endl; goto outer_loop_end; } max_vel = std::sqrt(max_vel);// this is a bug, should insert this line next_dt = compute_dt(max_vel, current_step_time, seconds_per_frame, dt_default); fmt::print(fmt::emphasis::bold, "{} --{}--> {}, defaultDt: {}, max_vel: {}\n", cur_time.count(), next_dt.count(), next_time.count(), dt_default.count(), max_vel); /// g2p2g { auto& cu_dev = Cuda::ref_cuda_context(gpuid); CudaTimer timer {cu_dev.stream_compute()}; //Resize particle buffers if we increased the size of active bins //This also removes all particle data of next particle buffer but does not clear it for(int i = 0; i < get_model_count(); ++i) { if(checked_bin_counts[i] > 0) { match(particle_bins[(rollid + 1) % BIN_COUNT][i])([this, &i](auto& particle_buffer) { particle_buffer.resize(DeviceAllocator {}, cur_num_active_bins[i]); }); checked_bin_counts[i]--; } } timer.tick(); //Clear the grid grid_blocks[1].reset(neighbor_block_count, cu_dev); //Perform G2P2G step for(int i = 0; i < get_model_count(); ++i) { //First clear the count of particles per cell for next buffer match(particle_bins[(rollid + 1) % BIN_COUNT][i])([this, &cu_dev](auto& particle_buffer) { check_cuda_errors(cudaMemsetAsync(particle_buffer.cell_particle_counts, 0, sizeof(int) * exterior_block_count * config::G_BLOCKVOLUME, cu_dev.stream_compute())); }); //Perform g2p2g match(particle_bins[rollid][i])([this, &cu_dev, &i](const auto& particle_buffer) { //partition_block_count; G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count, config::G_PARTICLE_BATCH_CAPACITY}, g2p2g, dt, next_dt, particle_buffer, get>(particle_bins[(rollid + 1) % BIN_COUNT][i]), partitions[(rollid + 1) % BIN_COUNT], partitions[rollid], grid_blocks[0], grid_blocks[1]); }); } cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] frame {} step {} g2p2g", gpuid, cur_frame, cur_step)); //Resize partition if we increased the size of active blocks //This also deletes current particle buffer meta data. if(checked_counts[0] > 0) { partitions[(rollid + 1) % BIN_COUNT].resize_partition(DeviceAllocator {}, cur_num_active_blocks); for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[rollid][i])([this, &cu_dev](auto& particle_buffer) { particle_buffer.reserve_buckets(DeviceAllocator {}, cur_num_active_blocks); }); } checked_counts[0]--; } } /// update partition { auto& cu_dev = Cuda::ref_cuda_context(gpuid); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); //Copy cell buckets from partition to next particle buffer for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[(rollid + 1) % BIN_COUNT][i])([this, &cu_dev](auto& particle_buffer) { //First init sizes with 0 check_cuda_errors(cudaMemsetAsync(particle_buffer.particle_bucket_sizes, 0, sizeof(int) * (exterior_block_count + 1), cu_dev.stream_compute())); //exterior_block_count; G_BLOCKVOLUME cu_dev.compute_launch({exterior_block_count, config::G_BLOCKVOLUME}, cell_bucket_to_block, particle_buffer.cell_particle_counts, particle_buffer.cellbuckets, particle_buffer.particle_bucket_sizes, particle_buffer.blockbuckets); // partitions[rollid].buildParticleBuckets(cu_dev, exterior_block_count); }); } int* active_block_marks = tmps.active_block_marks; int* destinations = tmps.destinations; int* sources = tmps.sources; //Clear marks check_cuda_errors(cudaMemsetAsync(active_block_marks, 0, sizeof(int) * neighbor_block_count, cu_dev.stream_compute())); //Mark cells that have mass bigger 0.0 //floor(neighbor_block_count * config::G_BLOCKVOLUME/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({(neighbor_block_count * config::G_BLOCKVOLUME + config::G_PARTICLE_BATCH_CAPACITY - 1) / config::G_PARTICLE_BATCH_CAPACITY, config::G_PARTICLE_BATCH_CAPACITY}, mark_active_grid_blocks, static_cast(neighbor_block_count), grid_blocks[1], active_block_marks); //Clear marks check_cuda_errors(cudaMemsetAsync(sources, 0, sizeof(int) * (exterior_block_count + 1), cu_dev.stream_compute())); //Mark particle buckets that have at least one particle for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[(rollid + 1) % BIN_COUNT][i])([this, &cu_dev, &sources](auto& particle_buffer) { //floor((exterior_block_count + 1)/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({exterior_block_count / config::G_PARTICLE_BATCH_CAPACITY + 1, config::G_PARTICLE_BATCH_CAPACITY}, mark_active_particle_blocks, exterior_block_count + 1, particle_buffer.particle_bucket_sizes, sources); }); } //Sum up number of active buckets and calculate offsets (empty buckets are collapsed exclusive_scan(exterior_block_count + 1, sources, destinations, cu_dev); /// building new partition //Store new bucket count check_cuda_errors(cudaMemcpyAsync(partitions[(rollid + 1) % BIN_COUNT].count, destinations + exterior_block_count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); check_cuda_errors(cudaMemcpyAsync(&partition_block_count, destinations + exterior_block_count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); //Calculate indices of block by position //floor(exterior_block_count/DEFAULT_CUDA_BLOCK_SIZE); DEFAULT_CUDA_BLOCK_SIZE cu_dev.compute_launch({(exterior_block_count + DEFAULT_CUDA_BLOCK_SIZE - 1) / DEFAULT_CUDA_BLOCK_SIZE, DEFAULT_CUDA_BLOCK_SIZE}, exclusive_scan_inverse, exterior_block_count, static_cast(destinations), sources); //Reset partitions partitions[(rollid + 1) % BIN_COUNT].reset_table(cu_dev.stream_compute()); cu_dev.syncStream(); //Check size if(partition_block_count > config::G_MAX_ACTIVE_BLOCK) { std::cerr << "Too much active blocks: " << partition_block_count << std::endl; std::abort(); } //Reinsert buckets //floor(partition_block_count/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({(partition_block_count + config::G_PARTICLE_BATCH_CAPACITY - 1) / config::G_PARTICLE_BATCH_CAPACITY, config::G_PARTICLE_BATCH_CAPACITY}, update_partition, static_cast(partition_block_count), static_cast(sources), partitions[rollid], partitions[(rollid + 1) % BIN_COUNT]); //Copy block buckets and sizes from next particle buffer to current particle buffer for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[(rollid + 1) % BIN_COUNT][i])([this, &cu_dev, &sources, &i](auto& particle_buffer) { auto& next_particle_buffer = get>(particle_bins[rollid][i]); //partition_block_count; G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count, config::G_PARTICLE_BATCH_CAPACITY}, update_buckets, static_cast(partition_block_count), static_cast(sources), particle_buffer, next_particle_buffer); }); } //Compute bin capacities, bin offsets and the summed bin size for current particle buffer int* bin_sizes = tmps.bin_sizes; for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[rollid][i])([this, &cu_dev, &bin_sizes, &i](auto& particle_buffer) { //floor((exterior_block_count + 1)/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count / config::G_PARTICLE_BATCH_CAPACITY + 1, config::G_PARTICLE_BATCH_CAPACITY}, compute_bin_capacity, partition_block_count + 1, static_cast(particle_buffer.particle_bucket_sizes), bin_sizes); //Stores aggregated bin sizes in particle_buffer exclusive_scan(partition_block_count + 1, bin_sizes, particle_buffer.bin_offsets, cu_dev); //Stores last aggregated size == whole size in bincount check_cuda_errors(cudaMemcpyAsync(&bincount[i], particle_buffer.bin_offsets + partition_block_count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); }); } timer.tock(fmt::format("GPU[{}] frame {} step {} update_partition", gpuid, cur_frame, cur_step)); timer.tick(); //Activate blocks near active blocks //floor(partition_block_count/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({(partition_block_count + config::G_PARTICLE_BATCH_CAPACITY - 1) / config::G_PARTICLE_BATCH_CAPACITY, config::G_PARTICLE_BATCH_CAPACITY}, register_neighbor_blocks, static_cast(partition_block_count), partitions[(rollid + 1) % BIN_COUNT]); //Retrieve total count auto prev_neighbor_block_count = neighbor_block_count; check_cuda_errors(cudaMemcpyAsync(&neighbor_block_count, partitions[(rollid + 1) % BIN_COUNT].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); //Check size if(neighbor_block_count > config::G_MAX_ACTIVE_BLOCK) { std::cerr << "Too much neighbour blocks: " << partition_block_count << std::endl; std::abort(); } timer.tock(fmt::format("GPU[{}] frame {} step {} build_partition_for_grid", gpuid, cur_frame, cur_step)); //Resize grid if necessary if(checked_counts[0] > 0) { grid_blocks[0].resize(DeviceAllocator {}, cur_num_active_blocks); } timer.tick(); //Clear the grid grid_blocks[0].reset(exterior_block_count, cu_dev); //Copy values from old grid for active blocks //prev_neighbor_block_count; G_BLOCKVOLUME cu_dev.compute_launch({prev_neighbor_block_count, config::G_BLOCKVOLUME}, copy_selected_grid_blocks, static_cast(partitions[rollid].active_keys), partitions[(rollid + 1) % BIN_COUNT], static_cast(active_block_marks), grid_blocks[1], grid_blocks[0]); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] frame {} step {} copy_grid_blocks", gpuid, cur_frame, cur_step)); //Resize grid if necessary if(checked_counts[0] > 0) { grid_blocks[1].resize(DeviceAllocator {}, cur_num_active_blocks); tmps.resize(cur_num_active_blocks); } } { auto& cu_dev = Cuda::ref_cuda_context(gpuid); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); //Activate blocks near active blocks, including those before that block //floor(partition_block_count/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({(partition_block_count + config::G_PARTICLE_BATCH_CAPACITY - 1) / config::G_PARTICLE_BATCH_CAPACITY, config::G_PARTICLE_BATCH_CAPACITY}, register_exterior_blocks, static_cast(partition_block_count), partitions[(rollid + 1) % BIN_COUNT]); //Retrieve total count check_cuda_errors(cudaMemcpyAsync(&exterior_block_count, partitions[(rollid + 1) % BIN_COUNT].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); //Check size if(exterior_block_count > config::G_MAX_ACTIVE_BLOCK) { std::cerr << "Too much exterior blocks: " << partition_block_count << std::endl; std::abort(); } fmt::print(fmt::emphasis::bold | fg(fmt::color::yellow), "block count on device {}: {}, {}, {} [{}]\n", gpuid, partition_block_count, neighbor_block_count, exterior_block_count, cur_num_active_blocks); for(int i = 0; i < get_model_count(); ++i) { fmt::print(fmt::emphasis::bold | fg(fmt::color::yellow), "bin count on device {}: model {}: {} [{}]\n", gpuid, i, bincount[i], cur_num_active_bins[i]); } timer.tock(fmt::format("GPU[{}] frame {} step {} build_partition_for_particles", gpuid, cur_frame, cur_step)); } rollid = static_cast((rollid + 1) % BIN_COUNT); dt = next_dt; } IO::flush(); output_model(); fmt::print( fmt::emphasis::bold | fg(fmt::color::red), "-----------------------------------------------------------" "-----\n" ); } outer_loop_end: (void) nullptr;//We need a statement to have a valid jump label } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) void output_model() { auto& cu_dev = Cuda::ref_cuda_context(gpuid); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); for(int i = 0; i < get_model_count(); ++i) { int particle_count = 0; int* d_particle_count = static_cast(cu_dev.borrow(sizeof(int))); //Init particle count with 0 check_cuda_errors(cudaMemsetAsync(d_particle_count, 0, sizeof(int), cu_dev.stream_compute())); //Copy particle data to output buffer match(particle_bins[rollid][i])([this, &cu_dev, &i, &d_particle_count](const auto& particle_buffer) { //partition_block_count; G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count, config::G_PARTICLE_BATCH_CAPACITY}, retrieve_particle_buffer, partitions[rollid], partitions[(rollid + 1) % BIN_COUNT], particle_buffer, get>(particle_bins[(rollid + 1) % BIN_COUNT][i]), particles[i], d_particle_count); }); //Retrieve particle count check_cuda_errors(cudaMemcpyAsync(&particle_count, d_particle_count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); fmt::print(fg(fmt::color::red), "total number of particles {}\n", particle_count); //Resize the output model model.resize(particle_count); //Copy the data to the output model check_cuda_errors(cudaMemcpyAsync(model.data(), static_cast(&particles[i].val_1d(_0, 0)), sizeof(std::array) * (particle_count), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); std::string fn = std::string {"model"} + "_id[" + std::to_string(i) + "]_frame[" + std::to_string(cur_frame) + "].bgeo"; //Write back file IO::insert_job([fn, m = model]() { write_partio(fn, m); }); } timer.tock(fmt::format("GPU[{}] frame {} step {} retrieve_particles", gpuid, cur_frame, cur_step)); } //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)Current c++ version does not yet support std::span void initial_setup() { { //TODO: Verify bounds when model offset is too large auto& cu_dev = Cuda::ref_cuda_context(gpuid); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); //Activate blocks that contain particles for(int i = 0; i < get_model_count(); ++i) { //floor(particle_counts[i]/DEFAULT_CUDA_BLOCK_SIZE); DEFAULT_CUDA_BLOCK_SIZE cu_dev.compute_launch({(particle_counts[i] + DEFAULT_CUDA_BLOCK_SIZE - 1) / DEFAULT_CUDA_BLOCK_SIZE, DEFAULT_CUDA_BLOCK_SIZE}, activate_blocks, particle_counts[i], particles[i], partitions[(rollid + 1) % BIN_COUNT]); } //Store count of activated blocks check_cuda_errors(cudaMemcpyAsync(&partition_block_count, partitions[(rollid + 1) % BIN_COUNT].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); timer.tock(fmt::format("GPU[{}] step {} init_table", gpuid, cur_step)); timer.tick(); cu_dev.reset_mem(); //Store particle ids in block cells for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[rollid][i])([this, &cu_dev, &i](auto& particle_buffer) { //floor(particle_counts[i]/DEFAULT_CUDA_BLOCK_SIZE); DEFAULT_CUDA_BLOCK_SIZE cu_dev.compute_launch({(particle_counts[i] + DEFAULT_CUDA_BLOCK_SIZE - 1) / DEFAULT_CUDA_BLOCK_SIZE, DEFAULT_CUDA_BLOCK_SIZE}, build_particle_cell_buckets, particle_counts[i], particles[i], particle_buffer, partitions[(rollid + 1) % BIN_COUNT]); }); } cu_dev.syncStream(); //Check size if(partition_block_count > config::G_MAX_ACTIVE_BLOCK) { std::cerr << "Too much active blocks: " << partition_block_count << std::endl; std::abort(); } //Copy cell buckets from partition to particle buffer for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[rollid][i])([this, &cu_dev](auto& particle_buffer) { //First init sizes with 0 check_cuda_errors(cudaMemsetAsync(particle_buffer.particle_bucket_sizes, 0, sizeof(int) * (partition_block_count + 1), cu_dev.stream_compute())); //partition_block_count; G_BLOCKVOLUME cu_dev.compute_launch({partition_block_count, config::G_BLOCKVOLUME}, cell_bucket_to_block, particle_buffer.cell_particle_counts, particle_buffer.cellbuckets, particle_buffer.particle_bucket_sizes, particle_buffer.blockbuckets); // partitions[(rollid + 1)%BIN_COUNT].buildParticleBuckets(cu_dev, partition_block_count); }); } //Compute bin capacities, bin offsets and the summed bin size //Then initializes the particle buffer int* bin_sizes = tmps.bin_sizes; for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[rollid][i])([this, &cu_dev, &bin_sizes, &i](auto& particle_buffer) { //floor((partition_block_count + 1)/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count / config::G_PARTICLE_BATCH_CAPACITY + 1, config::G_PARTICLE_BATCH_CAPACITY}, compute_bin_capacity, partition_block_count + 1, static_cast(particle_buffer.particle_bucket_sizes), bin_sizes); //Stores aggregated bin sizes in particle_buffer exclusive_scan(partition_block_count + 1, bin_sizes, particle_buffer.bin_offsets, cu_dev); //Stores last aggregated size == whole size in bincount check_cuda_errors(cudaMemcpyAsync(&bincount[i], particle_buffer.bin_offsets + partition_block_count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); //Initialize particle buffer //partition_block_count; G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count, config::G_PARTICLE_BATCH_CAPACITY}, array_to_buffer, particles[i], particle_buffer); }); } //Activate blocks near active blocks //floor(partition_block_count/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({(partition_block_count + config::G_PARTICLE_BATCH_CAPACITY - 1) / config::G_PARTICLE_BATCH_CAPACITY, config::G_PARTICLE_BATCH_CAPACITY}, register_neighbor_blocks, static_cast(partition_block_count), partitions[(rollid + 1) % BIN_COUNT]); //Retrieve total count check_cuda_errors(cudaMemcpyAsync(&neighbor_block_count, partitions[(rollid + 1) % BIN_COUNT].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); //Check size if(neighbor_block_count > config::G_MAX_ACTIVE_BLOCK) { std::cerr << "Too much neighbour blocks: " << partition_block_count << std::endl; std::abort(); } //Activate blocks near active blocks, including those before that block //TODO: Only these with offset -1 are not already activated as neighbours //floor(partition_block_count/G_PARTICLE_BATCH_CAPACITY); G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({(partition_block_count + config::G_PARTICLE_BATCH_CAPACITY - 1) / config::G_PARTICLE_BATCH_CAPACITY, config::G_PARTICLE_BATCH_CAPACITY}, register_exterior_blocks, static_cast(partition_block_count), partitions[(rollid + 1) % BIN_COUNT]); //Retrieve total count check_cuda_errors(cudaMemcpyAsync(&exterior_block_count, partitions[(rollid + 1) % BIN_COUNT].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); //Check size if(exterior_block_count > config::G_MAX_ACTIVE_BLOCK) { std::cerr << "Too much exterior blocks: " << partition_block_count << std::endl; std::abort(); } timer.tock(fmt::format("GPU[{}] step {} init_partition", gpuid, cur_step)); fmt::print(fmt::emphasis::bold | fg(fmt::color::yellow), "block count on device {}: {}, {}, {} [{}]\n", gpuid, partition_block_count, neighbor_block_count, exterior_block_count, cur_num_active_blocks); for(int i = 0; i < get_model_count(); ++i) { fmt::print(fmt::emphasis::bold | fg(fmt::color::yellow), "bin count on device {}: model {}: {} [{}]\n", gpuid, i, bincount[i], cur_num_active_bins[i]); } } { auto& cu_dev = Cuda::ref_cuda_context(gpuid); CudaTimer timer {cu_dev.stream_compute()}; //Copy all blocks to background partition partitions[(rollid + 1) % BIN_COUNT].copy_to(partitions[rollid], exterior_block_count, cu_dev.stream_compute()); check_cuda_errors(cudaMemcpyAsync(partitions[rollid].active_keys, partitions[(rollid + 1) % BIN_COUNT].active_keys, sizeof(ivec3) * exterior_block_count, cudaMemcpyDefault, cu_dev.stream_compute())); //Copy all particle data to background particle buffer for(int i = 0; i < get_model_count(); ++i) { match(particle_bins[rollid][i])([this, &cu_dev, &i](const auto& particle_buffer) { // bin_offsets, particle_bucket_sizes particle_buffer.copy_to(get>(particle_bins[(rollid + 1) % BIN_COUNT][i]), partition_block_count, cu_dev.stream_compute()); }); } cu_dev.syncStream(); timer.tick(); //Clear the grid grid_blocks[0].reset(neighbor_block_count, cu_dev); //Initialize the grid and advection buckets for(int i = 0; i < get_model_count(); ++i) { //Initialize mass and momentum //floor(particle_counts[i]/DEFAULT_CUDA_BLOCK_SIZE); DEFAULT_CUDA_BLOCK_SIZE cu_dev.compute_launch({(particle_counts[i] + DEFAULT_CUDA_BLOCK_SIZE - 1) / DEFAULT_CUDA_BLOCK_SIZE, DEFAULT_CUDA_BLOCK_SIZE}, rasterize, particle_counts[i], particles[i], grid_blocks[0], partitions[rollid], dt, get_mass(i), vel0[i].data_arr()); //Init advection source at offset 0 of destination match(particle_bins[(rollid + 1) % BIN_COUNT][i])([this, &cu_dev](auto& particle_buffer) { //partition_block_count; G_PARTICLE_BATCH_CAPACITY cu_dev.compute_launch({partition_block_count, config::G_PARTICLE_BATCH_CAPACITY}, init_adv_bucket, static_cast(particle_buffer.particle_bucket_sizes), particle_buffer.blockbuckets); }); } cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] step {} init_grid", gpuid, cur_step)); } } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) }; }// namespace mn #endif ================================================ FILE: Projects/GMPM/grid_buffer.cuh ================================================ #ifndef GRID_BUFFER_CUH #define GRID_BUFFER_CUH #include #include "mgmpm_kernels.cuh" #include "settings.h" namespace mn { using namespace placeholder;//NOLINT(google-build-using-namespace) Allow placeholders to be included generally for simplification //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments using grid_block_ = Structural, BlockDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_>; using grid_ = Structural, GridDomain, attrib_layout::AOS, grid_block_>; using grid_buffer_ = Structural, GridBufferDomain, attrib_layout::AOS, grid_block_>; //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) struct GridBuffer : Instance { using base_t = Instance; template explicit GridBuffer(Allocator allocator) : base_t {spawn(allocator)} {} template void check_capacity(Allocator allocator, std::size_t capacity) { if(capacity > this->capacity) { this->resize(allocator, capacity); } } template void reset(int block_count, CudaContext& cu_dev) { //check_cuda_errors(cudaMemsetAsync((void *)&this->val_1d(_0, 0), 0, grid_block_::size * block_count, cu_dev.stream_compute())); cu_dev.compute_launch({block_count, config::G_BLOCKVOLUME}, clear_grid, *this); } }; }// namespace mn #endif ================================================ FILE: Projects/GMPM/hash_table.cuh ================================================ #ifndef HASH_TABLE_CUH #define HASH_TABLE_CUH #include #include #include "settings.h" namespace mn { template struct HaloPartition { template HaloPartition(Allocator allocator, int max_block_count) { (void) allocator; (void) max_block_count; } template void resize_partition(Allocator allocator, std::size_t prev_capacity, std::size_t capacity) {} void copy_to(HaloPartition& other, std::size_t block_count, cudaStream_t stream) {} }; template<> struct HaloPartition<1> { int* halo_count; int h_count; char* halo_marks;///< halo particle blocks int* overlap_marks; ivec3* halo_blocks; template HaloPartition(Allocator allocator, int max_block_count) : h_count(0) { halo_count = static_cast(allocator.allocate(sizeof(char) * max_block_count)); halo_marks = static_cast(allocator.allocate(sizeof(char) * max_block_count)); overlap_marks = static_cast(allocator.allocate(sizeof(int) * max_block_count)); halo_blocks = static_cast(allocator.allocate(sizeof(ivec3) * max_block_count)); } void copy_to(HaloPartition& other, std::size_t block_count, cudaStream_t stream) const { other.h_count = h_count; check_cuda_errors(cudaMemcpyAsync(other.halo_marks, halo_marks, sizeof(char) * block_count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.overlap_marks, overlap_marks, sizeof(int) * block_count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.halo_blocks, halo_blocks, sizeof(ivec3) * block_count, cudaMemcpyDefault, stream)); } template void resize_partition(Allocator allocator, std::size_t prev_capacity, std::size_t capacity) { allocator.deallocate(halo_marks, sizeof(char) * prev_capacity); allocator.deallocate(overlap_marks, sizeof(int) * prev_capacity); allocator.deallocate(halo_blocks, sizeof(ivec3) * prev_capacity); halo_marks = static_cast(allocator.allocate(sizeof(char) * capacity)); overlap_marks = static_cast(allocator.allocate(sizeof(int) * capacity)); halo_blocks = static_cast(allocator.allocate(sizeof(ivec3) * capacity)); } void reset_halo_count(cudaStream_t stream) const { check_cuda_errors(cudaMemsetAsync(halo_count, 0, sizeof(int), stream)); } void reset_overlap_marks(uint32_t neighbor_block_count, cudaStream_t stream) const { check_cuda_errors(cudaMemsetAsync(overlap_marks, 0, sizeof(int) * neighbor_block_count, stream)); } void retrieve_halo_count(cudaStream_t stream) { check_cuda_errors(cudaMemcpyAsync(&h_count, halo_count, sizeof(int), cudaMemcpyDefault, stream)); } }; //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments using block_partition_ = Structural, GridDomain, attrib_layout::AOS, empty_>; //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) Using pointer arithmetics cause library and allocators do so. template struct Partition : Instance , HaloPartition { using base_t = Instance; using halo_base_t = HaloPartition; using block_partition_::key_t; using block_partition_::value_t; static_assert(sentinel_v == (value_t) (-1), "sentinel value not full 1s\n"); template Partition(Allocator allocator, int max_block_count) : halo_base_t {allocator, max_block_count} { allocate_table(allocator, max_block_count); /// init reset(); } ~Partition() = default; Partition(const Partition& other) = default; Partition(Partition&& other) noexcept = default; Partition& operator=(const Partition& other) = default; Partition& operator=(Partition&& other) noexcept = default; template void resize_partition(Allocator allocator, std::size_t capacity) { halo_base_t::resize_partition(allocator, this->capacity, capacity); resize_table(allocator, capacity); } void reset() { check_cuda_errors(cudaMemset(this->Instance::count, 0, sizeof(value_t))); check_cuda_errors(cudaMemset(this->index_table, 0xff, sizeof(value_t) * domain::extent)); } void reset_table(cudaStream_t stream) { check_cuda_errors(cudaMemsetAsync(this->index_table, 0xff, sizeof(value_t) * domain::extent, stream)); } void copy_to(Partition& other, std::size_t block_count, cudaStream_t stream) { halo_base_t::copy_to(other, block_count, stream); check_cuda_errors(cudaMemcpyAsync(other.index_table, this->index_table, sizeof(value_t) * domain::extent, cudaMemcpyDefault, stream)); } //FIXME: passing kjey_t here might cause problems because cuda is buggy __forceinline__ __device__ value_t insert(key_t key) noexcept { value_t tag = atomicCAS(&this->index(key), sentinel_v, 0); if(tag == sentinel_v) { value_t idx = atomicAdd(this->Instance::count, 1); this->index(key) = idx; this->active_keys[idx] = key;///< created a record return idx; } return -1; } //FIXME: passing kjey_t here might cause problems because cuda is buggy __forceinline__ __device__ value_t query(key_t key) const noexcept { return this->index(key); } __forceinline__ __device__ void reinsert(value_t index) { this->index(this->active_keys[index]) = index; } }; //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) }// namespace mn #endif ================================================ FILE: Projects/GMPM/mgmpm_kernels.cuh ================================================ #ifndef MULTI_GMPM_KERNELS_CUH #define MULTI_GMPM_KERNELS_CUH #include #include #include #include "constitutive_models.cuh" #include "particle_buffer.cuh" #include "settings.h" #include "utility_funcs.hpp" namespace mn { using namespace placeholder;//NOLINT(google-build-using-namespace) Allow placeholders to be included generally for simplification //TODO: Make magic numbers to constants where suitable //TODO: Ensure call dimensions and such are small enough to allow narrowing conversations. Or directly use unsigned where possible //TODO: Maybe use names instead of formula signs for better understanding //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers, readability-identifier-naming, misc-definitions-in-headers) CUDA does not yet support std::span; Common names for physical formulas; Cannot declare __global__ functions inline template __global__ void activate_blocks(uint32_t particle_counts, ParticleArray particle_array, Partition partition) { const uint32_t particle_id = blockIdx.x * blockDim.x + threadIdx.x; if(particle_id >= particle_counts) { return; } //Get block id by particle pos const ivec3 coord = get_block_id({particle_array.val(_0, particle_id), particle_array.val(_1, particle_id), particle_array.val(_2, particle_id)}) - 2; const ivec3 blockid = coord / static_cast(config::G_BLOCKSIZE); //Create block in partition partition.insert(blockid); } template __global__ void build_particle_cell_buckets(uint32_t particle_counts, ParticleArray particle_array, ParticleBuffer particle_buffer, Partition partition) { const uint32_t particle_id = blockIdx.x * blockDim.x + threadIdx.x; if(particle_id >= particle_counts) { return; } //Get block id by particle pos const ivec3 coord = get_block_id({particle_array.val(_0, particle_id), particle_array.val(_1, particle_id), particle_array.val(_2, particle_id)}) - 2; const ivec3 blockid = coord / static_cast(config::G_BLOCKSIZE); //Fetch block number auto blockno = partition.query(blockid); //Get cell number in block int cellno = (coord[0] & config::G_BLOCKMASK) * config::G_BLOCKSIZE * config::G_BLOCKSIZE + (coord[1] & config::G_BLOCKMASK) * config::G_BLOCKSIZE + (coord[2] & config::G_BLOCKMASK); //Increase particle count of cell and get id of partzicle in cell auto particle_id_in_cell = atomicAdd(particle_buffer.cell_particle_counts + blockno * config::G_BLOCKVOLUME + cellno, 1); //If no space is left, don't store the particle if(particle_id_in_cell >= config::G_MAX_PARTICLES_IN_CELL) { //Reduce count again atomicSub(particle_buffer.cell_particle_counts + blockno * config::G_BLOCKVOLUME + cellno, 1); #if PRINT_CELL_OVERFLOW printf("No space left in cell: block(%d), cell(%d)\n", blockno, cellno); #endif return; } //Insert particle id in cell bucket particle_buffer.cellbuckets[blockno * config::G_PARTICLE_NUM_PER_BLOCK + cellno * config::G_MAX_PARTICLES_IN_CELL + particle_id_in_cell] = static_cast(particle_id);//NOTE:Explicit narrowing conversation. } __global__ void cell_bucket_to_block(const int* cell_particle_counts, const int* cellbuckets, int* particle_bucket_sizes, int* buckets) { const int cellno = static_cast(threadIdx.x) & (config::G_BLOCKVOLUME - 1); const int particle_counts = cell_particle_counts[blockIdx.x * config::G_BLOCKVOLUME + cellno]; for(int particle_id_in_cell = 0; particle_id_in_cell < config::G_MAX_PARTICLES_IN_CELL; particle_id_in_cell++) { if(particle_id_in_cell < particle_counts) { //Each thread gets its index in the blocks bucket const int particle_id_in_block = atomic_agg_inc(particle_bucket_sizes + blockIdx.x); //Each particle of the source advection buffer (offset + particle id) is assigned to a particle of the current buffer. This should be a 1:1 mapping, though one particle may be mapped to itself or to another particle buckets[blockIdx.x * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block] = cellbuckets[blockIdx.x * config::G_PARTICLE_NUM_PER_BLOCK + cellno * config::G_MAX_PARTICLES_IN_CELL + particle_id_in_cell]; } __syncthreads(); } } __global__ void compute_bin_capacity(uint32_t block_count, int const* particle_bucket_sizes, int* bin_sizes) { const uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } //Bin capacity is the ceiled bucket size divided by the bin max capacity bin_sizes[blockno] = (particle_bucket_sizes[blockno] + config::G_BIN_CAPACITY - 1) / config::G_BIN_CAPACITY; } __global__ void init_adv_bucket(const int* particle_bucket_sizes, int* buckets) { const int particle_counts = particle_bucket_sizes[blockIdx.x]; int* bucket = buckets + static_cast(blockIdx.x) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { //Combine offset of 0 with local index in block bucket[particle_id_in_block] = (dir_offset({0, 0, 0}) * config::G_PARTICLE_NUM_PER_BLOCK) | particle_id_in_block; } } template __global__ void clear_grid(Grid grid) { auto gridblock = grid.ch(_0, blockIdx.x); for(int cell_id_in_block = static_cast(threadIdx.x); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += static_cast(blockDim.x)) { gridblock.val_1d(_0, cell_id_in_block) = 0.0f; gridblock.val_1d(_1, cell_id_in_block) = 0.0f; gridblock.val_1d(_2, cell_id_in_block) = 0.0f; gridblock.val_1d(_3, cell_id_in_block) = 0.0f; } } template __global__ void register_neighbor_blocks(uint32_t block_count, Partition partition) { const uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } //Activate neighbour blocks const auto blockid = partition.active_keys[blockno]; for(char i = 0; i < 2; ++i) { for(char j = 0; j < 2; ++j) { for(char k = 0; k < 2; ++k) { partition.insert(ivec3 {blockid[0] + i, blockid[1] + j, blockid[2] + k}); } } } } template __global__ void register_exterior_blocks(uint32_t block_count, Partition partition) { const uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } //Activate exterior blocks const auto blockid = partition.active_keys[blockno]; for(char i = -1; i < 2; ++i) { for(char j = -1; j < 2; ++j) { for(char k = -1; k < 2; ++k) { partition.insert(ivec3 {blockid[0] + i, blockid[1] + j, blockid[2] + k}); } } } } template __global__ void rasterize(uint32_t particle_counts, const ParticleArray particle_array, Grid grid, const Partition partition, Duration dt, float mass, std::array v0) { (void) dt; const uint32_t particle_id = blockIdx.x * blockDim.x + threadIdx.x; if(particle_id >= particle_counts) { return; } //Fetch particle position and velocity const vec3 global_pos {particle_array.val(_0, particle_id), particle_array.val(_1, particle_id), particle_array.val(_2, particle_id)}; const vec3 vel {v0[0], v0[1], v0[2]}; //vec9 contrib; //vec9 c; //contrib.set(0.f); //c.set(0.f); //contrib = (c * mass - contrib * dt.count()) * config::G_D_INV; //Calculate grid index const ivec3 global_base_index = get_block_id(global_pos.data_arr()) - 1; //Calculate position relative to grid cell const vec3 local_pos = global_pos - global_base_index * config::G_DX; //Calc kernel vec dws; for(int d = 0; d < 3; ++d) { dws[d] = bspline_weight(local_pos[d]); } for(int i = 0; i < 3; ++i) { for(int j = 0; j < 3; ++j) { for(int k = 0; k < 3; ++k) { //Current offset from grid cell const ivec3 offset {i, j, k}; //Global index of grid cell const ivec3 global_index = global_base_index + offset; ivec3 global_index_masked; for(int d = 0; d < 3; ++d) { global_index_masked[d] = global_index[d] & config::G_BLOCKMASK; } //const vec3 xixp = offset * config::G_DX - local_pos; //Kernel weight const float w = dws[0][i] * dws[1][j] * dws[2][k]; //Mass constribution to the grid cell const float wm = mass * w; //Fetch block number const int blockno = partition.query(ivec3 {static_cast(global_index[0] >> config::G_BLOCKBITS), static_cast(global_index[1] >> config::G_BLOCKBITS), static_cast(global_index[2] >> config::G_BLOCKBITS)}); //Fetch grid block and initialize values auto grid_block = grid.ch(_0, blockno); atomicAdd(&grid_block.val(_0, global_index_masked[0], global_index_masked[1], global_index_masked[2]), wm); atomicAdd(&grid_block.val(_1, global_index_masked[0], global_index_masked[1], global_index_masked[2]), wm * vel[0]);// + (contrib[0] * xixp[0] + contrib[3] * xixp[1] + contrib[6] * xixp[2]) * w); atomicAdd(&grid_block.val(_2, global_index_masked[0], global_index_masked[1], global_index_masked[2]), wm * vel[1]);// + (contrib[1] * xixp[0] + contrib[4] * xixp[1] + contrib[7] * xixp[2]) * w); atomicAdd(&grid_block.val(_3, global_index_masked[0], global_index_masked[1], global_index_masked[2]), wm * vel[2]);// + (contrib[2] * xixp[0] + contrib[5] * xixp[1] + contrib[8] * xixp[2]) * w); } } } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer) { const uint32_t blockno = blockIdx.x; const int particle_counts = particle_buffer.particle_bucket_sizes[blockno]; const int* bucket = particle_buffer.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { const int particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, particle_buffer.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// J particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.0f; } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer) { const uint32_t blockno = blockIdx.x; const int particle_counts = particle_buffer.particle_bucket_sizes[blockno]; const int* bucket = particle_buffer.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { const auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, particle_buffer.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// F particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer) { const uint32_t blockno = blockIdx.x; const int particle_counts = particle_buffer.particle_bucket_sizes[blockno]; const int* bucket = particle_buffer.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { const auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, particle_buffer.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// F particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; /// log_jp particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = ParticleBuffer::LOG_JP_0; } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer) { const uint32_t blockno = blockIdx.x; const int particle_counts = particle_buffer.particle_bucket_sizes[blockno]; const int* bucket = particle_buffer.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { const auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, particle_buffer.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// F particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; /// log_jp particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = ParticleBuffer::LOG_JP_0; } } template __global__ void update_grid_velocity_query_max(uint32_t block_count, Grid grid, Partition partition, Duration dt, float* max_vel) { const int boundary_condition = static_cast(std::floor(config::G_BOUNDARY_CONDITION)); constexpr int NUM_WARPS = config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK * config::G_NUM_WARPS_PER_GRID_BLOCK; constexpr unsigned ACTIVE_MASK = 0xffffffff; static constexpr size_t shared_memory_element_count = NUM_WARPS; __shared__ float sh_maxvels[shared_memory_element_count];//NOLINT(modernize-avoid-c-arrays) Cannot declare runtime size shared memory as std::array //Fetch block number and id const int blockno = static_cast(blockIdx.x) * config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK + static_cast(threadIdx.x) / config::CUDA_WARP_SIZE / config::G_NUM_WARPS_PER_GRID_BLOCK; const auto blockid = partition.active_keys[blockno]; //Check if the block is outside of grid bounds const int is_in_bound = ((blockid[0] < boundary_condition || blockid[0] >= config::G_GRID_SIZE - boundary_condition) << 2) | ((blockid[1] < boundary_condition || blockid[1] >= config::G_GRID_SIZE - boundary_condition) << 1) | (blockid[2] < boundary_condition || blockid[2] >= config::G_GRID_SIZE - boundary_condition); //Initialize shared memory if(threadIdx.x < NUM_WARPS) { sh_maxvels[threadIdx.x] = 0.0f; } __syncthreads(); /// within-warp computations if(blockno < block_count) { auto grid_block = grid.ch(_0, blockno); for(int cell_id_in_block = static_cast(threadIdx.x % config::CUDA_WARP_SIZE); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += config::CUDA_WARP_SIZE) { const float mass = grid_block.val_1d(_0, cell_id_in_block); float vel_sqr = 0.0f; vec3 vel; if(mass > 0.0f) { const float mass_inv = 1.f / mass; //int i = (cell_id_in_block >> (config::G_BLOCKBITS << 1)) & config::G_BLOCKMASK; //int j = (cell_id_in_block >> config::G_BLOCKBITS) & config::G_BLOCKMASK; //int k = cell_id_in_block & config::G_BLOCKMASK; //Fetch current velocity vel[0] = grid_block.val_1d(_1, cell_id_in_block); vel[1] = grid_block.val_1d(_2, cell_id_in_block); vel[2] = grid_block.val_1d(_3, cell_id_in_block); //Update velocity. Set to 0 if outside of bounds vel[0] = is_in_bound & 4 ? 0.0f : vel[0] * mass_inv; vel[1] = is_in_bound & 2 ? 0.0f : vel[1] * mass_inv; vel[1] += config::G_GRAVITY * dt.count(); vel[2] = is_in_bound & 1 ? 0.0f : vel[2] * mass_inv; // if (is_in_bound) ///< sticky // vel.set(0.f); //Write back velocity grid_block.val_1d(_1, cell_id_in_block) = vel[0]; grid_block.val_1d(_2, cell_id_in_block) = vel[1]; grid_block.val_1d(_3, cell_id_in_block) = vel[2]; //Calculate squared velocity vel_sqr += vel[0] * vel[0]; vel_sqr += vel[1] * vel[1]; vel_sqr += vel[2] * vel[2]; } //If we have nan values, signalize failure by setting max_vel to inf if(isnan(vel_sqr)) { vel_sqr = std::numeric_limits::infinity(); } // unsigned activeMask = __ballot_sync(0xffffffff, mv[0] != 0.0f); //Calculate max velocity in warp for(int iter = 1; iter % config::CUDA_WARP_SIZE; iter <<= 1) { float tmp = __shfl_down_sync(ACTIVE_MASK, vel_sqr, iter, config::CUDA_WARP_SIZE); if((threadIdx.x % config::CUDA_WARP_SIZE) + iter < config::CUDA_WARP_SIZE) { vel_sqr = tmp > vel_sqr ? tmp : vel_sqr; } } //TODO: Ensure threadIdx.x / config::CUDA_WARP_SIZE is smaller than NUM_WARPS if(vel_sqr > sh_maxvels[threadIdx.x / config::CUDA_WARP_SIZE] && (threadIdx.x % config::CUDA_WARP_SIZE) == 0) { sh_maxvels[threadIdx.x / config::CUDA_WARP_SIZE] = vel_sqr; } } } __syncthreads(); //Calculate global max velocity /// various assumptions for(int interval = NUM_WARPS >> 1; interval > 0; interval >>= 1) { if(threadIdx.x < interval) { if(sh_maxvels[static_cast(threadIdx.x) + interval] > sh_maxvels[threadIdx.x]) { sh_maxvels[threadIdx.x] = sh_maxvels[static_cast(threadIdx.x) + interval]; } } __syncthreads(); } if(threadIdx.x == 0) { atomic_max(max_vel, sh_maxvels[0]); } } //Need this, cause we cannot partially instantiate function templates in current c++ version struct FetchParticleBufferDataIntermediate { vec3 pos; float J; }; template __forceinline__ __device__ void fetch_particle_buffer_data(const ParticleBuffer particle_buffer, int advection_source_blockno, int source_pidib, FetchParticleBufferDataIntermediate& data); template<> __forceinline__ __device__ void fetch_particle_buffer_data(const ParticleBuffer particle_buffer, int advection_source_blockno, int source_pidib, FetchParticleBufferDataIntermediate& data) { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); data.pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); data.pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); data.pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); data.J = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); } template<> __forceinline__ __device__ void fetch_particle_buffer_data(const ParticleBuffer particle_buffer, int advection_source_blockno, int source_pidib, FetchParticleBufferDataIntermediate& data) { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); data.pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); data.pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); data.pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } template<> __forceinline__ __device__ void fetch_particle_buffer_data(const ParticleBuffer particle_buffer, int advection_source_blockno, int source_pidib, FetchParticleBufferDataIntermediate& data) { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); data.pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); data.pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); data.pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } template<> __forceinline__ __device__ void fetch_particle_buffer_data(const ParticleBuffer particle_buffer, int advection_source_blockno, int source_pidib, FetchParticleBufferDataIntermediate& data) { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); data.pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); data.pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); data.pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } //Need this, cause we cannot partially instantiate function templates in current c++ version struct CalculateContributionAndStoreParticleDataIntermediate { vec3 pos; float J; }; template __forceinline__ __device__ void calculate_contribution_and_store_particle_data(const ParticleBuffer particle_buffer, const ParticleBuffer next_particle_buffer, int advection_source_blockno, int source_pidib, int src_blockno, int particle_id_in_block, Duration dt, const std::array& A, std::array& contrib, CalculateContributionAndStoreParticleDataIntermediate& data); template<> __forceinline__ __device__ void calculate_contribution_and_store_particle_data(const ParticleBuffer particle_buffer, const ParticleBuffer next_particle_buffer, int advection_source_blockno, int source_pidib, int src_blockno, int particle_id_in_block, Duration dt, const std::array& A, std::array& contrib, CalculateContributionAndStoreParticleDataIntermediate& data) { (void) advection_source_blockno; (void) source_pidib; //Update determinante of deformation gradiant //Divergence of velocity multiplied with time and transfered to global space data.J += (A[0] + A[4] + A[8]) * dt.count() * config::G_D_INV * data.J; //Too low is bad. clamp to 0.1 //TODO: Maybe make this 0.1 a parameter if(data.J < 0.1) { data.J = 0.1; } //TODO: What is calculated here? { float voln = data.J * particle_buffer.volume; float pressure = particle_buffer.bulk * (powf(data.J, -particle_buffer.gamma) - 1.f); //? - stress; stress = pressure * identity; { contrib[0] = ((A[0] + A[0]) * config::G_D_INV * particle_buffer.viscosity - pressure) * voln; contrib[1] = (A[1] + A[3]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[2] = (A[2] + A[6]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[3] = (A[3] + A[1]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[4] = ((A[4] + A[4]) * config::G_D_INV * particle_buffer.viscosity - pressure) * voln; contrib[5] = (A[5] + A[7]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[6] = (A[6] + A[2]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[7] = (A[7] + A[5]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[8] = ((A[8] + A[8]) * config::G_D_INV * particle_buffer.viscosity - pressure) * voln; } } //Write back particle data { auto particle_bin = next_particle_buffer.ch(_0, next_particle_buffer.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = data.J; } } template<> __forceinline__ __device__ void calculate_contribution_and_store_particle_data(const ParticleBuffer particle_buffer, const ParticleBuffer next_particle_buffer, int advection_source_blockno, int source_pidib, int src_blockno, int particle_id_in_block, Duration dt, const std::array& A, std::array& contrib, CalculateContributionAndStoreParticleDataIntermediate& data) { vec3x3 dws; //((d & 0x3) != 0 ? 0.f : 1.f) is identity matrix #pragma unroll 9 for(int d = 0; d < 9; ++d) { dws.val(d) = A[d] * dt.count() * config::G_D_INV + ((d & 0x3) != 0 ? 0.f : 1.f); } { vec9 F; auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); contrib[0] = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); contrib[1] = source_particle_bin.val(_4, source_pidib % config::G_BIN_CAPACITY); contrib[2] = source_particle_bin.val(_5, source_pidib % config::G_BIN_CAPACITY); contrib[3] = source_particle_bin.val(_6, source_pidib % config::G_BIN_CAPACITY); contrib[4] = source_particle_bin.val(_7, source_pidib % config::G_BIN_CAPACITY); contrib[5] = source_particle_bin.val(_8, source_pidib % config::G_BIN_CAPACITY); contrib[6] = source_particle_bin.val(_9, source_pidib % config::G_BIN_CAPACITY); contrib[7] = source_particle_bin.val(_10, source_pidib % config::G_BIN_CAPACITY); contrib[8] = source_particle_bin.val(_11, source_pidib % config::G_BIN_CAPACITY); matrix_matrix_multiplication_3d(dws.data_arr(), contrib, F.data_arr()); { auto particle_bin = next_particle_buffer.ch(_0, next_particle_buffer.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = F[0]; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = F[1]; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = F[2]; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = F[3]; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = F[4]; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = F[5]; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = F[6]; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = F[7]; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = F[8]; } ComputeStressIntermediate compute_stress_tmp = {}; compute_stress(particle_buffer.volume, particle_buffer.mu, particle_buffer.lambda, F.data_arr(), contrib, compute_stress_tmp); } } template<> __forceinline__ __device__ void calculate_contribution_and_store_particle_data(const ParticleBuffer particle_buffer, const ParticleBuffer next_particle_buffer, int advection_source_blockno, int source_pidib, int src_blockno, int particle_id_in_block, Duration dt, const std::array& A, std::array& contrib, CalculateContributionAndStoreParticleDataIntermediate& data) { vec3x3 dws; //((d & 0x3) != 0 ? 0.f : 1.f) is identity matrix #pragma unroll 9 for(int d = 0; d < 9; ++d) { dws.val(d) = A[d] * dt.count() * config::G_D_INV + ((d & 0x3) != 0 ? 0.f : 1.f); } { vec9 F; float log_jp; auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); contrib[0] = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); contrib[1] = source_particle_bin.val(_4, source_pidib % config::G_BIN_CAPACITY); contrib[2] = source_particle_bin.val(_5, source_pidib % config::G_BIN_CAPACITY); contrib[3] = source_particle_bin.val(_6, source_pidib % config::G_BIN_CAPACITY); contrib[4] = source_particle_bin.val(_7, source_pidib % config::G_BIN_CAPACITY); contrib[5] = source_particle_bin.val(_8, source_pidib % config::G_BIN_CAPACITY); contrib[6] = source_particle_bin.val(_9, source_pidib % config::G_BIN_CAPACITY); contrib[7] = source_particle_bin.val(_10, source_pidib % config::G_BIN_CAPACITY); contrib[8] = source_particle_bin.val(_11, source_pidib % config::G_BIN_CAPACITY); log_jp = source_particle_bin.val(_12, source_pidib % config::G_BIN_CAPACITY); matrix_matrix_multiplication_3d(dws.data_arr(), contrib, F.data_arr()); ComputeStressIntermediate compute_stress_tmp = {}; compute_stress_tmp.cohesion = particle_buffer.cohesion; compute_stress_tmp.beta = particle_buffer.beta; compute_stress_tmp.yield_surface = particle_buffer.yield_surface; compute_stress_tmp.volume_correction = particle_buffer.volume_correction; compute_stress_tmp.log_jp = log_jp; compute_stress(particle_buffer.volume, particle_buffer.mu, particle_buffer.lambda, F.data_arr(), contrib, compute_stress_tmp); log_jp = compute_stress_tmp.log_jp; { auto particle_bin = next_particle_buffer.ch(_0, next_particle_buffer.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = F[0]; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = F[1]; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = F[2]; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = F[3]; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = F[4]; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = F[5]; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = F[6]; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = F[7]; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = F[8]; particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = log_jp; } } } template<> __forceinline__ __device__ void calculate_contribution_and_store_particle_data(const ParticleBuffer particle_buffer, const ParticleBuffer next_particle_buffer, int advection_source_blockno, int source_pidib, int src_blockno, int particle_id_in_block, Duration dt, const std::array& A, std::array& contrib, CalculateContributionAndStoreParticleDataIntermediate& data) { vec3x3 dws; //((d & 0x3) != 0 ? 0.f : 1.f) is identity matrix #pragma unroll 9 for(int d = 0; d < 9; ++d) { dws.val(d) = A[d] * dt.count() * config::G_D_INV + ((d & 0x3) != 0 ? 0.f : 1.f); } { vec9 F; float log_jp; auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); contrib[0] = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); contrib[1] = source_particle_bin.val(_4, source_pidib % config::G_BIN_CAPACITY); contrib[2] = source_particle_bin.val(_5, source_pidib % config::G_BIN_CAPACITY); contrib[3] = source_particle_bin.val(_6, source_pidib % config::G_BIN_CAPACITY); contrib[4] = source_particle_bin.val(_7, source_pidib % config::G_BIN_CAPACITY); contrib[5] = source_particle_bin.val(_8, source_pidib % config::G_BIN_CAPACITY); contrib[6] = source_particle_bin.val(_9, source_pidib % config::G_BIN_CAPACITY); contrib[7] = source_particle_bin.val(_10, source_pidib % config::G_BIN_CAPACITY); contrib[8] = source_particle_bin.val(_11, source_pidib % config::G_BIN_CAPACITY); log_jp = source_particle_bin.val(_12, source_pidib % config::G_BIN_CAPACITY); matrix_matrix_multiplication_3d(dws.data_arr(), contrib, F.data_arr()); ComputeStressIntermediate compute_stress_tmp = {}; compute_stress_tmp.bm = particle_buffer.bm; compute_stress_tmp.xi = particle_buffer.xi; compute_stress_tmp.beta = particle_buffer.beta; compute_stress_tmp.msqr = particle_buffer.msqr; compute_stress_tmp.hardening_on = particle_buffer.hardening_on; compute_stress_tmp.log_jp = log_jp; compute_stress(particle_buffer.volume, particle_buffer.mu, particle_buffer.lambda, F.data_arr(), contrib, compute_stress_tmp); log_jp = compute_stress_tmp.log_jp; { auto particle_bin = next_particle_buffer.ch(_0, next_particle_buffer.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = data.pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = F[0]; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = F[1]; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = F[2]; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = F[3]; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = F[4]; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = F[5]; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = F[6]; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = F[7]; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = F[8]; particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = log_jp; } } } template __global__ void g2p2g(Duration dt, Duration new_dt, const ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer, const Partition prev_partition, Partition partition, const Grid grid, Grid next_grid) { static constexpr uint64_t NUM_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 3; static constexpr uint64_t NUM_VI_IN_ARENA = NUM_VI_PER_BLOCK << 3; static constexpr uint64_t NUM_M_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 4; static constexpr uint64_t NUM_M_VI_IN_ARENA = NUM_M_VI_PER_BLOCK << 3; static constexpr unsigned ARENAMASK = (config::G_BLOCKSIZE << 1) - 1; static constexpr unsigned ARENABITS = config::G_BLOCKBITS + 1; using ViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>*; using ViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>&; using MViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>*; using MViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>&; static constexpr size_t shared_memory_size = static_cast((3 + 4) * (config::G_BLOCKSIZE << 1) * (config::G_BLOCKSIZE << 1) * (config::G_BLOCKSIZE << 1)) * sizeof(float); __shared__ char shmem[shared_memory_size];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here ViArenaRef __restrict__ g2pbuffer = *static_cast(static_cast(static_cast(shmem))); MViArenaRef __restrict__ p2gbuffer = *static_cast(static_cast(static_cast(shmem) + NUM_VI_IN_ARENA * sizeof(float))); //Layout of buffers: 1 dimension is channel. other dimensions range [0, 3] contains current block, range [4, 7] contains next block //The first cell of the next block is handled by the current block only (but may receive values of particles traveling out of next block in negative direction) const int src_blockno = static_cast(blockIdx.x); const auto blockid = partition.active_keys[blockIdx.x]; const int particle_bucket_size = next_particle_buffer.particle_bucket_sizes[src_blockno]; //If we have no particles in the bucket return if(particle_bucket_size == 0) { return; } //Load data from grid to shared memory for(int base = static_cast(threadIdx.x); base < NUM_VI_IN_ARENA; base += static_cast(blockDim.x)) { const char local_block_id = static_cast(base / NUM_VI_PER_BLOCK); const auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); const auto grid_block = grid.ch(_0, blockno); int channelid = static_cast(base % NUM_VI_PER_BLOCK); const char c = static_cast(channelid & 0x3f); const char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; const char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; const char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val; if(channelid == 0) { val = grid_block.val_1d(_1, c); } else if(channelid == 1) { val = grid_block.val_1d(_2, c); } else { val = grid_block.val_1d(_3, c); } g2pbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))] = val; } __syncthreads(); //Clear return buffer for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { int loc = base; const char z = static_cast(loc & ARENAMASK); loc >>= ARENABITS; const char y = static_cast(loc & ARENAMASK); loc >>= ARENABITS; const char x = static_cast(loc & ARENAMASK); p2gbuffer[loc >> ARENABITS][x][y][z] = 0.0f; } __syncthreads(); //Perform update for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_bucket_size; particle_id_in_block += static_cast(blockDim.x)) { //Fetch index of the advection source int advection_source_blockno; int source_pidib; { //Fetch advection (direction at high bits, particle in in cell at low bits) const int advect = next_particle_buffer.blockbuckets[src_blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; //Retrieve the direction (first stripping the particle id by division) ivec3 offset; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, offset.data_arr()); //Retrieve the particle id by AND for lower bits source_pidib = advect & (config::G_PARTICLE_NUM_PER_BLOCK - 1); //Get global index by adding blockid and offset const ivec3 global_advection_index = blockid + offset; //Get block_no from partition const int advection_source_blockno_from_partition = prev_partition.query(global_advection_index); //Get block number in particle bins advection_source_blockno = particle_buffer.bin_offsets[advection_source_blockno_from_partition] + source_pidib / config::G_BIN_CAPACITY; } //Fetch position and determinant of deformation gradient FetchParticleBufferDataIntermediate fetch_particle_buffer_tmp = {}; fetch_particle_buffer_data(particle_buffer, advection_source_blockno, source_pidib, fetch_particle_buffer_tmp); vec3 pos = fetch_particle_buffer_tmp.pos; float J = fetch_particle_buffer_tmp.J; //Get position of grid cell ivec3 global_base_index = get_block_id(pos.data_arr()) - 1; //Get position relative to grid cell vec3 local_pos = pos - global_base_index * config::G_DX; //Save global_base_index ivec3 base_index = global_base_index; //Calculate weights and mask global index vec3x3 dws; #pragma unroll 3 for(int dd = 0; dd < 3; ++dd) { const vec3 weight = bspline_weight(local_pos[dd]); dws(dd, 0) = weight[0]; dws(dd, 1) = weight[1]; dws(dd, 2) = weight[2]; //Calculate (modulo (config::G_BLOCKMASK + 1)) + 1 of index (== (..., -4, -3, -2, -1, 0, 1, 2, 3, 4, ...) -> (..., 4, 1, 2, 3, 4, 1, 2, 3, 4, ...)) global_base_index[dd] = ((base_index[dd] - 1) & config::G_BLOCKMASK) + 1; } //Calculate particle velocity and APIC affine matrix //v_p = sum(i, weight_i_p * v_i) //A = sum(i, weight_i_p * v_i * (x_i - x_p)) vec3 vel; vel.set(0.f); vec9 A;//affine state A.set(0.f); #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { //(x_i - x_p) const vec3 xixp = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; //Weight const float W = dws(0, i) * dws(1, j) * dws(2, k); //Velocity of grid cell const vec3 vi {g2pbuffer[0][static_cast(static_cast(global_base_index[0]) + i)][static_cast(static_cast(global_base_index[1]) + j)][static_cast(static_cast(global_base_index[2]) + k)], g2pbuffer[1][static_cast(static_cast(global_base_index[0]) + i)][static_cast(static_cast(global_base_index[1]) + j)][static_cast(static_cast(global_base_index[2]) + k)], g2pbuffer[2][static_cast(static_cast(global_base_index[0]) + i)][static_cast(static_cast(global_base_index[1]) + j)][static_cast(static_cast(global_base_index[2]) + k)]}; //Calculate velocity vel += W * vi; //Calculate APIC affine matrix A[0] += W * vi[0] * xixp[0]; A[1] += W * vi[1] * xixp[0]; A[2] += W * vi[2] * xixp[0]; A[3] += W * vi[0] * xixp[1]; A[4] += W * vi[1] * xixp[1]; A[5] += W * vi[2] * xixp[1]; A[6] += W * vi[0] * xixp[2]; A[7] += W * vi[1] * xixp[2]; A[8] += W * vi[2] * xixp[2]; } } } //Update particle position pos += vel * dt.count(); CalculateContributionAndStoreParticleDataIntermediate store_particle_buffer_tmp = {}; store_particle_buffer_tmp.pos = pos; store_particle_buffer_tmp.J = J; vec9 contrib; calculate_contribution_and_store_particle_data(particle_buffer, next_particle_buffer, advection_source_blockno, source_pidib, src_blockno, particle_id_in_block, dt, A.data_arr(), contrib.data_arr(), store_particle_buffer_tmp); //Update momentum? //Multiply A with mass to complete it. Then subtract current momentum? //C = A * D^-1 contrib = (A * particle_buffer.mass - contrib * new_dt.count()) * config::G_D_INV; //Calculate grid index after movement ivec3 new_global_base_index = get_block_id(pos.data_arr()) - 1; //Update local position local_pos = pos - new_global_base_index * config::G_DX; //Store index and movement direction { //Calculate direction offset const int dirtag = dir_offset(((base_index - 1) / static_cast(config::G_BLOCKSIZE) - (new_global_base_index - 1) / static_cast(config::G_BLOCKSIZE)).data_arr()); //Store particle in new block next_particle_buffer.add_advection(partition, new_global_base_index - 1, dirtag, particle_id_in_block); // partition.add_advection(new_global_base_index - 1, dirtag, particle_id_in_block); } //Calculate weights and mask global index #pragma unroll 3 for(char dd = 0; dd < 3; ++dd) { const vec3 weight = bspline_weight(local_pos[dd]); dws(dd, 0) = weight[0]; dws(dd, 1) = weight[1]; dws(dd, 2) = weight[2]; //Calculate (modulo (config::G_BLOCKMASK + 1)) + 1 of index (== (..., -4, -3, -2, -1, 0, 1, 2, 3, 4, ...) -> (..., 4, 1, 2, 3, 4, 1, 2, 3, 4, ...)) and add offset (may not be out of range max [-4, 4] min [-1, 1]) new_global_base_index[dd] = (((base_index[dd] - 1) & config::G_BLOCKMASK) + 1) + (new_global_base_index[dd] - base_index[dd]); } //Dim of p2gbuffer is (4, 8, 8, 8). So if values are too big, discard whole particle if(new_global_base_index[0] < 0 || new_global_base_index[1] < 0 || new_global_base_index[2] < 0 || new_global_base_index[0] + 2 >= 8 || new_global_base_index[1] + 2 >= 8 || new_global_base_index[2] + 2 >= 8) { //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) Cuda has no other way to print; Numbers are array indices to be printed printf("new_global_base_index out of range: %d %d %d\n", new_global_base_index[0], new_global_base_index[1], new_global_base_index[2]); return; } //Calculate new gird momentum and mass //m_i * v_i = sum(p, w_i_p * m_p * vel_p + ?) #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { pos = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; const float W = dws(0, i) * dws(1, j) * dws(2, k); const auto wm = particle_buffer.mass * W; atomicAdd(&p2gbuffer[0][static_cast(static_cast(new_global_base_index[0]) + i)][static_cast(static_cast(new_global_base_index[1]) + j)][static_cast(static_cast(new_global_base_index[2]) + k)], wm); atomicAdd(&p2gbuffer[1][static_cast(static_cast(new_global_base_index[0]) + i)][static_cast(static_cast(new_global_base_index[1]) + j)][static_cast(static_cast(new_global_base_index[2]) + k)], wm * vel[0] + (contrib[0] * pos[0] + contrib[3] * pos[1] + contrib[6] * pos[2]) * W); atomicAdd(&p2gbuffer[2][static_cast(static_cast(new_global_base_index[0]) + i)][static_cast(static_cast(new_global_base_index[1]) + j)][static_cast(static_cast(new_global_base_index[2]) + k)], wm * vel[1] + (contrib[1] * pos[0] + contrib[4] * pos[1] + contrib[7] * pos[2]) * W); atomicAdd(&p2gbuffer[3][static_cast(static_cast(new_global_base_index[0]) + i)][static_cast(static_cast(new_global_base_index[1]) + j)][static_cast(static_cast(new_global_base_index[2]) + k)], wm * vel[2] + (contrib[2] * pos[0] + contrib[5] * pos[1] + contrib[8] * pos[2]) * W); } } } } __syncthreads(); //Store data from shared memory to grid for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { const char local_block_id = static_cast(base / NUM_M_VI_PER_BLOCK); const auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); // auto grid_block = next_grid.template ch<0>(blockno); int channelid = static_cast(base & (NUM_M_VI_PER_BLOCK - 1)); const char c = static_cast(channelid % config::G_BLOCKVOLUME); const char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; const char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; const char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val = p2gbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))]; if(channelid == 0) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_0, c), val); } else if(channelid == 1) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_1, c), val); } else if(channelid == 2) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_2, c), val); } else { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_3, c), val); } } } template __global__ void mark_active_grid_blocks(uint32_t block_count, const Grid grid, int* marks) { const auto idx = blockIdx.x * blockDim.x + threadIdx.x; const int blockno = static_cast(idx / config::G_BLOCKVOLUME); const int cellno = static_cast(idx % config::G_BLOCKVOLUME); if(blockno >= block_count) { return; } //If the grid cell has a mass mark it as active if(grid.ch(_0, blockno).val_1d(_0, cellno) != 0.0f) { marks[blockno] = 1; } } __global__ void mark_active_particle_blocks(uint32_t block_count, const int* __restrict__ particle_bucket_sizes, int* marks) { const std::size_t blockno = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } //If the particle bucket has particles marke it as active if(particle_bucket_sizes[blockno] > 0) { marks[blockno] = 1; } } template __global__ void update_partition(uint32_t block_count, const int* __restrict__ source_nos, const Partition partition, Partition next_partition) { const std::size_t blockno = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } const uint32_t source_no = source_nos[blockno]; const auto source_blockid = partition.active_keys[source_no]; next_partition.active_keys[blockno] = source_blockid; next_partition.reinsert(static_cast(blockno)); } template __global__ void update_buckets(uint32_t block_count, const int* __restrict__ source_nos, const ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer) { __shared__ std::size_t source_no[1];//NOLINT(modernize-avoid-c-arrays) Cannot declare shared memory as std::array? const std::size_t blockno = blockIdx.x; if(blockno >= block_count) { return; } //Copy size and set source_no if(threadIdx.x == 0) { //Index of block in old layout source_no[0] = source_nos[blockno]; next_particle_buffer.particle_bucket_sizes[blockno] = particle_buffer.particle_bucket_sizes[source_no[0]]; } __syncthreads(); //Copy buckets const auto particle_counts = next_particle_buffer.particle_bucket_sizes[blockno]; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { next_particle_buffer.blockbuckets[blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block] = particle_buffer.blockbuckets[source_no[0] * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; } } template __global__ void copy_selected_grid_blocks(const ivec3* __restrict__ prev_blockids, const Partition partition, const int* __restrict__ marks, Grid prev_grid, Grid grid) { const auto blockid = prev_blockids[blockIdx.x]; //If the block is marked as active and if it is found in the new partition, copy the values from the old grid if(marks[blockIdx.x]) { const auto blockno = partition.query(blockid); if(blockno == -1) { return; } const auto sourceblock = prev_grid.ch(_0, blockIdx.x); auto targetblock = grid.ch(_0, blockno); targetblock.val_1d(_0, threadIdx.x) = sourceblock.val_1d(_0, threadIdx.x); targetblock.val_1d(_1, threadIdx.x) = sourceblock.val_1d(_1, threadIdx.x); targetblock.val_1d(_2, threadIdx.x) = sourceblock.val_1d(_2, threadIdx.x); targetblock.val_1d(_3, threadIdx.x) = sourceblock.val_1d(_3, threadIdx.x); } } template __global__ void check_table(uint32_t block_count, Partition partition) { uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } auto blockid = partition.active_keys[blockno]; if(partition.query(blockid) != blockno) { printf("FUCK, partition table is wrong!\n"); } } template __global__ void sum_grid_mass(Grid grid, float* sum) { atomicAdd(sum, grid.ch(_0, blockIdx.x).val_1d(_0, threadIdx.x)); } __global__ void sum_particle_counts(uint32_t count, int* __restrict__ counts, int* sum) { auto idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= count) { return; } atomicAdd(sum, counts[idx]); } template __global__ void check_partition(uint32_t block_count, Partition partition) { int idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= block_count) { return; } ivec3 blockid = partition.active_keys[idx]; if(blockid[0] == 0 || blockid[1] == 0 || blockid[2] == 0) { printf("\tDAMN, encountered zero block record\n"); } if(partition.query(blockid) != idx) { int id = partition.query(blockid); ivec3 bid = partition.active_keys[id]; printf( "\t\tcheck partition %d, (%d, %d, %d), feedback index %d, (%d, %d, " "%d)\n", idx, (int) blockid[0], (int) blockid[1], (int) blockid[2], id, bid[0], bid[1], bid[2] ); } } template __global__ void check_partition_domain(uint32_t block_count, int did, Domain const domain, Partition partition) { int idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= block_count) { return; } ivec3 blockid = partition.active_keys[idx]; if(domain.inside(blockid)) { printf("%d-th block (%d, %d, %d) is in domain[%d] (%d, %d, %d)-(%d, %d, %d)\n", idx, blockid[0], blockid[1], blockid[2], did, domain._min[0], domain._min[1], domain._min[2], domain._max[0], domain._max[1], domain._max[2]); } } template __global__ void retrieve_particle_buffer(Partition partition, Partition prev_partition, ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer, ParticleArray particle_array, int* parcount) { const int particle_counts = next_particle_buffer.particle_bucket_sizes[blockIdx.x]; const ivec3 blockid = partition.active_keys[blockIdx.x]; const auto advection_bucket = next_particle_buffer.blockbuckets + blockIdx.x * config::G_PARTICLE_NUM_PER_BLOCK; // auto particle_offset = particle_buffer.bin_offsets[blockIdx.x]; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { //Fetch advection (direction at high bits, particle in in cell at low bits) const auto advect = advection_bucket[particle_id_in_block]; //Retrieve the direction (first stripping the particle id by division) ivec3 source_blockid; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, source_blockid.data_arr()); //Retrieve the particle id by AND for lower bits const auto source_pidib = advect % config::G_PARTICLE_NUM_PER_BLOCK; //Get global index by adding the blockid source_blockid += blockid; //Get block from partition const auto advection_source_blockno_from_partition = prev_partition.query(source_blockid); //Get bin from particle buffer const auto source_bin = particle_buffer.ch(_0, particle_buffer.bin_offsets[advection_source_blockno_from_partition] + source_pidib / config::G_BIN_CAPACITY); //Calculate particle id in destination buffer const auto particle_id = atomicAdd(parcount, 1); //Copy position to destination buffer particle_array.val(_0, particle_id) = source_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); particle_array.val(_1, particle_id) = source_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); particle_array.val(_2, particle_id) = source_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers, readability-identifier-naming, misc-definitions-in-headers) }// namespace mn #endif ================================================ FILE: Projects/GMPM/particle_buffer.cuh ================================================ #ifndef PARTICLE_BUFFER_CUH #define PARTICLE_BUFFER_CUH #include #include #include "hash_table.cuh" #include "mgmpm_kernels.cuh" #include "settings.h" #include "utility_funcs.hpp" //NOLINTNEXTLINE(cppcoreguidelines-macro-usage) Macro usage necessary here for preprocessor if #define PRINT_NEGATIVE_BLOGNOS 1 namespace mn { using ParticleBinDomain = AlignedDomain; using ParticleBufferDomain = CompactDomain; using ParticleArrayDomain = CompactDomain; //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments using particle_bin4_ = Structural, ParticleBinDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_>; ///< J, pos using particle_bin12_ = Structural, ParticleBinDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_>; ///< pos, F using particle_bin13_ = Structural, ParticleBinDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_>;///< pos, F, logJp //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) template struct particle_bin_; template<> struct particle_bin_ : particle_bin4_ {}; template<> struct particle_bin_ : particle_bin12_ {}; template<> struct particle_bin_ : particle_bin13_ {}; template<> struct particle_bin_ : particle_bin13_ {}; //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments template using particle_buffer_ = Structural, ParticleBufferDomain, attrib_layout::AOS, ParticleBin>; using particle_array_ = Structural, ParticleArrayDomain, attrib_layout::AOS, f32_, f32_, f32_>; //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) template struct ParticleBufferImpl : Instance>> { static constexpr MaterialE MATERIAL_TYPE = Mt; using base_t = Instance>>; std::size_t num_active_blocks; int* cell_particle_counts; int* particle_bucket_sizes; int* cellbuckets; int* blockbuckets; int* bin_offsets; template ParticleBufferImpl(Allocator allocator, std::size_t count) : base_t {spawn>, orphan_signature>(allocator, count)} , num_active_blocks {0} , cell_particle_counts {nullptr} , particle_bucket_sizes {nullptr} , cellbuckets {nullptr} , blockbuckets {nullptr} , bin_offsets {nullptr} {} template void check_capacity(Allocator allocator, std::size_t capacity) { if(capacity > this->capacity) { this->resize(allocator, capacity); } } template void reserve_buckets(Allocator allocator, std::size_t num_block_count) { if(bin_offsets) { allocator.deallocate(cell_particle_counts, sizeof(int) * num_active_blocks * config::G_BLOCKVOLUME); allocator.deallocate(particle_bucket_sizes, sizeof(int) * num_active_blocks); allocator.deallocate(cellbuckets, sizeof(int) * num_active_blocks * config::G_BLOCKVOLUME * config::G_MAX_PARTICLES_IN_CELL); allocator.deallocate(blockbuckets, sizeof(int) * num_active_blocks * config::G_PARTICLE_NUM_PER_BLOCK); allocator.deallocate(bin_offsets, sizeof(int) * num_active_blocks); } num_active_blocks = num_block_count; cell_particle_counts = static_cast(allocator.allocate(sizeof(int) * num_active_blocks * config::G_BLOCKVOLUME)); particle_bucket_sizes = static_cast(allocator.allocate(sizeof(int) * num_active_blocks)); cellbuckets = static_cast(allocator.allocate(sizeof(int) * num_active_blocks * config::G_BLOCKVOLUME * config::G_MAX_PARTICLES_IN_CELL)); blockbuckets = static_cast(allocator.allocate(sizeof(int) * num_active_blocks * config::G_PARTICLE_NUM_PER_BLOCK)); bin_offsets = static_cast(allocator.allocate(sizeof(int) * num_active_blocks)); reset_ppcs(); } void reset_ppcs() { check_cuda_errors(cudaMemset(cell_particle_counts, 0, sizeof(int) * num_active_blocks * config::G_BLOCKVOLUME)); } void copy_to(ParticleBufferImpl& other, std::size_t block_count, cudaStream_t stream) const { check_cuda_errors(cudaMemcpyAsync(other.bin_offsets, bin_offsets, sizeof(int) * (block_count + 1), cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.particle_bucket_sizes, particle_bucket_sizes, sizeof(int) * block_count, cudaMemcpyDefault, stream)); } //FIXME: passing kjey_t here might cause problems because cuda is buggy __forceinline__ __device__ void add_advection(Partition<1>& table, Partition<1>::key_t cellid, int dirtag, int particle_id_in_block) noexcept { const Partition<1>::key_t blockid = cellid / static_cast(config::G_BLOCKSIZE); const int blockno = table.query(blockid); //If block does not yet exist, print message and return (particle will be lost). if(blockno == -1) { #if PRINT_NEGATIVE_BLOGNOS std::array offset {}; dir_components(dirtag, offset); //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg, readability-magic-numbers) Cuda has no other way to print; Numbers are array indices to be printed printf("loc(%d, %d, %d) dir(%d, %d, %d) particle_id_in_block(%d)\n", cellid[0], cellid[1], cellid[2], offset[0], offset[1], offset[2], particle_id_in_block); #endif return; } //Store the particle id and its offset in the dst cell bucket //NOLINTNEXTLINE(readability-magic-numbers) Numbers are array indices to be printed const int cellno = ((cellid[0] & config::G_BLOCKMASK) << (config::G_BLOCKBITS << 1)) | ((cellid[1] & config::G_BLOCKMASK) << config::G_BLOCKBITS) | (cellid[2] & config::G_BLOCKMASK); //NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) Cuda does not yet support std::span const int particle_id_in_cell = atomicAdd(cell_particle_counts + static_cast(blockno) * config::G_BLOCKVOLUME + cellno, 1); //If no space is left, don't store the particle if(particle_id_in_cell >= config::G_MAX_PARTICLES_IN_CELL) { //Reduce count again //NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) Cuda does not yet support std::span atomicSub(cell_particle_counts + static_cast(blockno) * config::G_BLOCKVOLUME + cellno, 1); #if PRINT_CELL_OVERFLOW //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg, readability-magic-numbers) Cuda has no other way to print; Numbers are array indices to be printed printf("No space left in cell: block(%d), cell(%d)\n", blockno, cellno); #endif return; } //NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) Cuda does not yet support std::span cellbuckets[blockno * config::G_PARTICLE_NUM_PER_BLOCK + cellno * config::G_MAX_PARTICLES_IN_CELL + particle_id_in_cell] = (dirtag * config::G_PARTICLE_NUM_PER_BLOCK) | particle_id_in_block; } }; //NOTE: In subsequent classes some parameters are actually const and static, but they are nit declared as such to allow consistent access to the members //TODO: Maybe write accessors; Maybe create common baseclass(es) for accessing the parameters template struct ParticleBuffer; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions float rho = config::DENSITY; float volume = (1.0f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float bulk = 4e4; float gamma = 7.15f;//Penalize large deviations from incompressibility float viscosity = 0.01f; void update_parameters(float density, float vol, float b, float g, float v) { rho = density; volume = vol; mass = volume * density; bulk = b; gamma = g; viscosity = v; } //NOLINTEND(readability-magic-numbers) template ParticleBuffer(Allocator allocator, std::size_t count) : base_t {allocator, count} {} }; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions float rho = config::DENSITY; float volume = (10.f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float e = config::YOUNGS_MODULUS; float nu = config::POISSON_RATIO; float lambda = config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)); float mu = config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO)); void update_parameters(float density, float vol, float e, float nu) { rho = density; volume = vol; mass = volume * density; lambda = e * nu / ((1 + nu) * (1 - 2 * nu)); mu = e / (2 * (1 + nu)); } //NOLINTEND(readability-magic-numbers) template ParticleBuffer(Allocator allocator, std::size_t count) : base_t {allocator, count} {} }; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions; consistent naming float rho = config::DENSITY; float volume = (10.f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float r = config::YOUNGS_MODULUS; float nu = config::POISSON_RATIO; float lambda = config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)); float mu = config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO)); static constexpr float LOG_JP_0 = 0.0f; float friction_angle = 30.f; float cohesion = 0.0f; float beta = 1.0f; // std::sqrt(2.f/3.f) * 2.f * std::sin(30.f/180.f*3.141592741f) // / (3.f - // std::sin(30.f/180.f*3.141592741f)) float yield_surface = 0.816496580927726f * 2.f * 0.5f / (3.f - 0.5f); bool volume_correction = true; //NOLINTEND(readability-magic-numbers) template ParticleBuffer(Allocator allocator, std::size_t count) : base_t {allocator, count} {} }; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions float rho = config::DENSITY; float volume = (1.0f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float e = config::YOUNGS_MODULUS; float nu = config::POISSON_RATIO; float lambda = config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)); float mu = config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO)); float friction_angle = 45.f; float bm = 2.f / 3.f * (config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO))) + (config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)));///< bulk modulus, kappa float xi = 0.8f; ///< hardening factor static constexpr float LOG_JP_0 = -0.01f; float beta = 0.5f; float mohr_columb_friction = 0.503599787772409;//< sqrt((T)2 / (T)3) * (T)2 * sin_phi / ((T)3 - sin_phi); float m = 1.850343771924453;//< mohr_columb_friction * (T)dim / sqrt((T)2 / ((T)6 - dim)); float msqr = 3.423772074299613; bool hardening_on = true; void update_parameters(float density, float vol, float e, float nu, float be, float x) { rho = density; volume = vol; mass = volume * density; lambda = e * nu / ((1 + nu) * (1 - 2 * nu)); mu = e / (2 * (1 + nu)); bm = 2.f / 3.f * (e / (2 * (1 + nu))) + (e * nu / ((1 + nu) * (1 - 2 * nu))); beta = be; xi = x; } //NOLINTEND(readability-magic-numbers) template ParticleBuffer(Allocator allocator, std::size_t count) : base_t {allocator, count} {} }; /// conversion /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r3.html using particle_buffer_t = variant, ParticleBuffer, ParticleBuffer, ParticleBuffer>; struct ParticleArray : Instance { using base_t = Instance; ParticleArray() = default; explicit ParticleArray(base_t&& instance)//NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved) Clang say, that std::move has no effect here : base_t(instance) {} }; }// namespace mn #endif ================================================ FILE: Projects/GMPM/partition_domain.h ================================================ #ifndef __PARTITION_DOMAIN_H_ #define __PARTITION_DOMAIN_H_ #include #include namespace mn { template struct partition_domain { using index = Tn[dim]; template constexpr bool inside(Index&& id) const noexcept { return self().inside(std::forward(id)); } template constexpr bool within(Index&& id, Offset&& l, Offset&& u) const noexcept { return self().within(std::forward(id), std::forward(l), std::forward(u)); } protected: auto& self() noexcept { return static_cast(*this); } }; template struct box_domain : partition_domain, Tn, dim> { using base_t = partition_domain, Tn, dim>; using index = typename base_t::index; constexpr box_domain() noexcept {} constexpr box_domain(index lower, index upper) { for(int d = 0; d < dim; ++d) { _min[d] = lower[d]; _max[d] = upper[d]; } } constexpr box_domain(vec lower, vec upper) { for(int d = 0; d < dim; ++d) { _min[d] = lower[d]; _max[d] = upper[d]; } } template constexpr bool inside(Index&& id) const noexcept { for(int d = 0; d < dim; ++d) if(id[d] < _min[d] || id[d] > _max[d]) return false; return true; } template constexpr bool within(Index&& id, Offset&& l, Offset&& u) const noexcept { for(int d = 0; d < dim; ++d) if(id[d] < _min[d] + l[d] || id[d] > _max[d] + u[d]) return false; return true; } index _min, _max; }; }// namespace mn #endif ================================================ FILE: Projects/GMPM/scenes/scene.json ================================================ { "simulation": { "gpuid": 0, "fps": 1200, "frames": 120, "default_dt": 5e-6 }, "models": [ { "type": "particle", "file": "two_dragons.sdf", "constitutive": "jfluid", "volume": 7.4505806e-9, "rho": 1e3, "bulk_modulus": 4e4, "gamma": 7.15, "viscosity": 0.01, "offset": [ 0.1, 0.1, 0.1 ], "span": [ 1.0, 1.0, 1.0 ], "velocity": [ 0.0, -1.0, 0.0 ] }, { "type": "particle", "file": "two_dragons.sdf", "constitutive": "fixed_corotated", "volume": 7.4505806e-9, "rho": 1e3, "youngs_modulus": 1e7, "poisson_ratio": 0.4, "offset": [ 0.2, 0.1, 0.1 ], "span": [ 1.0, 1.0, 1.0 ], "velocity": [ 0.0, -1.0, 0.0 ] }, { "type": "particle", "file": "two_dragons.sdf", "constitutive": "sand", "offset": [ 0.2, 0.1, 0.2 ], "span": [ 1.0, 1.0, 1.0 ], "velocity": [ 0.0, -1.0, 0.0 ] } ] } ================================================ FILE: Projects/GMPM/settings.h ================================================ #ifndef SETTINGS_H #define SETTINGS_H #include #include #include //NOLINTNEXTLINE(cppcoreguidelines-macro-usage) Macro usage necessary here for preprocessor if #define PRINT_CELL_OVERFLOW 0//TODO: Move to another place namespace mn { using ivec3 = vec; using vec3 = vec; using vec9 = vec; using vec3x3 = vec; using vec3x4 = vec; using vec3x3x3 = vec; using Duration = std::chrono::duration; /// sand = Drucker Prager Plasticity, StvkHencky Elasticity enum class MaterialE { J_FLUID = 0, FIXED_COROTATED, SAND, NACC, TOTAL }; /// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html, F.3.16.5 /// benchmark setup namespace config { constexpr int G_DEVICE_COUNT = 1; constexpr MaterialE get_material_type(int did) noexcept { (void) did; return MaterialE::FIXED_COROTATED; } constexpr int G_TOTAL_FRAME_CNT = 60; constexpr int NUM_DIMENSIONS = 3; constexpr int CUDA_WARP_SIZE = 32; constexpr int GBPCB = 16; constexpr int G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK = GBPCB; constexpr int G_NUM_WARPS_PER_GRID_BLOCK = 1; constexpr int G_NUM_WARPS_PER_CUDA_BLOCK = GBPCB;//>= G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK constexpr int G_PARTICLE_BATCH_CAPACITY = 128; constexpr float MODEL_PPC = 8.0f; constexpr float G_MODEL_PPC = MODEL_PPC; constexpr float CFL = 0.5f; // background_grid constexpr float GRID_BLOCK_SPACING = 1.0f; constexpr int BLOCK_BITS = 2; constexpr int DOMAIN_BITS = 8; constexpr float DXINV = (GRID_BLOCK_SPACING * (1 << DOMAIN_BITS)); constexpr int G_DOMAIN_BITS = DOMAIN_BITS; constexpr int G_DOMAIN_SIZE = (1 << DOMAIN_BITS); constexpr float G_BOUNDARY_CONDITION = 2.0; constexpr float G_DX = 1.f / DXINV; constexpr float G_DX_INV = DXINV; constexpr float G_D_INV = 4.f * DXINV * DXINV; constexpr int G_BLOCKBITS = BLOCK_BITS; constexpr int G_BLOCKSIZE = (1 << BLOCK_BITS); constexpr int G_BLOCKMASK = ((1 << BLOCK_BITS) - 1); constexpr int G_BLOCKVOLUME = (1 << (BLOCK_BITS * 3)); constexpr int G_GRID_BITS = (DOMAIN_BITS - BLOCK_BITS); constexpr int G_GRID_SIZE = (1 << (DOMAIN_BITS - BLOCK_BITS)); // particle constexpr int MAX_PARTICLES_IN_CELL = 128; constexpr int G_MAX_PARTICLES_IN_CELL = MAX_PARTICLES_IN_CELL; constexpr int G_BIN_CAPACITY = 32; constexpr int G_PARTICLE_NUM_PER_BLOCK = (MAX_PARTICLES_IN_CELL * (1 << (BLOCK_BITS * 3))); // material parameters constexpr float DENSITY = 1e3; constexpr float YOUNGS_MODULUS = 5e3; constexpr float POISSON_RATIO = 0.4f; constexpr float G_GRAVITY = -9.8f; /// only used on host constexpr int G_MAX_PARTICLE_NUM = 1000000; constexpr int G_MAX_ACTIVE_BLOCK = 10000;/// 62500 bytes for active mask constexpr std::size_t calc_particle_bin_count(std::size_t num_active_blocks) noexcept { return num_active_blocks * (G_MAX_PARTICLES_IN_CELL * G_BLOCKVOLUME / G_BIN_CAPACITY); } constexpr std::size_t G_MAX_PARTICLE_BIN = G_MAX_PARTICLE_NUM / G_BIN_CAPACITY; constexpr std::size_t G_MAX_HALO_BLOCK = 4000; }// namespace config using BlockDomain = CompactDomain; using GridDomain = CompactDomain; using GridBufferDomain = CompactDomain; }// namespace mn #endif ================================================ FILE: Projects/GMPM/utility_funcs.hpp ================================================ #ifndef UTILITY_FUNCS_HPP #define UTILITY_FUNCS_HPP #include "settings.h" namespace mn { //TODO: Maybe create parameters for some of this magic numbers //NOLINTBEGIN(readability-magic-numbers) Magic numbers are formula-specific /// assume p is already within kernel range [-1.5, 1.5] constexpr vec3 bspline_weight(float p) { vec3 dw {0.0f, 0.0f, 0.0f}; float d = p * config::G_DX_INV;///< normalized offset dw[0] = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dw[1] = 0.75f - d * d; d = 0.5f + d; dw[2] = 0.5f * d * d; return dw; } constexpr ivec3 get_block_id(const std::array& position) { return ivec3(static_cast(std::lround(position[0] * config::G_DX_INV)), static_cast(std::lround(position[1] * config::G_DX_INV)), static_cast(std::lround(position[2] * config::G_DX_INV))); } constexpr int dir_offset(const std::array& d) { return (d[0] + 1) * 9 + (d[1] + 1) * 3 + d[2] + 1; } constexpr void dir_components(int dir, std::array& d) { d[2] = (dir % 3) - 1; d[1] = ((dir / 3) % 3) - 1; d[0] = ((dir / 9) % 3) - 1; } //NOLINTEND(readability-magic-numbers) Magic numbers are formula-specific //NOLINTBEGIN(readability-magic-numbers) Magic numbers are formula-specific constexpr Duration compute_dt(float max_vel, const Duration cur_time, const Duration next_time, const Duration dt_default) noexcept { //Choose dt such that particles with maximum velocity cannot move more than G_DX * CFL //This ensures CFL condition is satisfied Duration dt = dt_default; if(max_vel > 0.0f) { const Duration new_dt(config::G_DX * config::CFL / max_vel); dt = std::min(new_dt, dt); } //If next_time - cur_time is smaller as current dt, use this. dt = std::min(dt, next_time - cur_time); return dt; } //NOLINTEND(readability-magic-numbers) Magic numbers are formula-specific }// namespace mn #endif ================================================ FILE: Projects/MGSP/CMakeLists.txt ================================================ if (CUDA_FOUND) add_cuda_executable(mgsp) target_sources(mgsp PRIVATE mgsp.cu ) target_link_libraries(mgsp PRIVATE mnio fmt ) #Add headers as system headers get_target_property(HEADERS_FMT fmt INTERFACE_SYSTEM_INCLUDE_DIRECTORIES) target_include_directories(mgsp SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/Library PRIVATE ${HEADERS_FMT} ) endif() ================================================ FILE: Projects/MGSP/boundary_condition.cuh ================================================ #ifndef BOUNDARY_CONDITION_CUH #define BOUNDARY_CONDITION_CUH #include #include #include #include #include #include "grid_buffer.cuh" #include "settings.h" namespace mn { using block_signed_distance_field_ = Structural, BlockDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_>;///< sdis, gradx, grady, gradz using signed_distance_field_ = Structural, GridDomain, attrib_layout::AOS, block_signed_distance_field_>; enum class BoundaryT { STICKY, SLIP, SEPARATE }; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions and formulas struct SignedDistanceGrid : Instance { using base_t = Instance; vec3x3 rot_mat; vec3 trans; vec3 trans_vel; vec3 omega; float dsdt; float scale; float friction; BoundaryT type; template explicit SignedDistanceGrid(Allocator allocator) : base_t {spawn(allocator)} , dsdt(0.0f) , scale(1.0f) , friction(0.3f) , type(BoundaryT::STICKY) { rot_mat.set(0.0f); rot_mat(0, 0) = rot_mat(1, 1) = rot_mat(2, 2) = 1.f; trans.set(0.f); trans_vel.set(0.f); omega.set(0.f); } void init(base_t& host_data, cudaStream_t stream) { check_cuda_errors(cudaMemcpyAsync(&this->ch(_0, 0, 0, 0).val_1d(_0, 0), &host_data.ch(_0, 0, 0, 0).val_1d(_0, 0), signed_distance_field_::base_t::size, cudaMemcpyDefault, stream)); } constexpr auto& self() noexcept { return static_cast(*this); } constexpr vec3 get_material_velocity(const vec3& x) { vec3 radius = x - trans; vec3 vel {}; vec_cross_mul_vec_3d(vel.data_arr(), omega.data_arr(), radius.data_arr()); vel += trans_vel; return vel; } static __forceinline__ __device__ auto rot_angle_to_matrix(const float omega, const int dim) -> vec3x3 { vec3x3 res; res.set(0.0f); if(dim == 0) { res(0, 0) = 1; res(1, 1) = res(2, 2) = cosf(omega); res(2, 1) = res(1, 2) = sinf(omega); res(1, 2) = -res(1, 2); } else if(dim == 1) { res(1, 1) = 1; res(0, 0) = res(2, 2) = cosf(omega); res(2, 0) = res(0, 2) = sinf(omega); res(2, 0) = -res(2, 0); } else if(dim == 2) { res(2, 2) = 1; res(0, 0) = res(1, 1) = cosf(omega); res(1, 0) = res(0, 1) = sinf(omega); res(0, 1) = -res(0, 1); } else { //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) Cuda has no other way to print printf("Unsupported dimension"); } return res; } static constexpr auto vec3_cross_vec3(vec3 v1, vec3 v2) { vec3 res {v1[1] * v2[2] + v1[2] * v2[1], v1[2] * v2[0] + v1[0] * v2[2], v1[0] * v2[1] + v1[1] * v2[0]}; return res; } //< return signed distance value + set normal __forceinline__ __device__ float get_signed_distance_and_normal(const vec3& x, vec3& normal) { //< g_cid <=> global cell ID ivec3 g_cid = (x / config::G_DX).cast(); // 1. init float sdis_res {0.f}; normal.set(0.f); // 1.1 prepare std::array, 2>, 2> w = {};//< linear interpolation weight { vec3 dis_lb = x - (g_cid.cast() * config::G_DX);//< distance to the left-corner node std::array, 3> w_1d = {}; //< 1d weight, [dim][node] for(int d = 0; d < 3; ++d) { w_1d[d][0] = 1 - dis_lb[d] / config::G_DX; w_1d[d][1] = dis_lb[d] / config::G_DX; } for(int i = 0; i < 2; ++i) { for(int j = 0; j < 2; ++j) { for(int k = 0; k < 2; ++k) { w[i][j][k] = w_1d[0][i] * w_1d[1][j] * w_1d[2][k]; } } } } // 2. compute signed distance and normal for(int i = 0; i < 2; ++i) { for(int j = 0; j < 2; ++j) { for(int k = 0; k < 2; ++k) { sdis_res += w[i][j][k] * (this->ch(_0, ((g_cid[0] + i) / config::G_BLOCKSIZE), ((g_cid[1] + j) / config::G_BLOCKSIZE), ((g_cid[2] + k) / config::G_BLOCKSIZE)).val(_0, (g_cid[0] + i) % config::G_BLOCKSIZE, (g_cid[1] + j) % config::G_BLOCKSIZE, (g_cid[2] + k) % config::G_BLOCKSIZE)); normal[0] += w[i][j][k] * (this->ch(_0, ((g_cid[0] + i) / config::G_BLOCKSIZE), ((g_cid[1] + j) / config::G_BLOCKSIZE), ((g_cid[2] + k) / config::G_BLOCKSIZE)).val(_1, (g_cid[0] + i) % config::G_BLOCKSIZE, (g_cid[1] + j) % config::G_BLOCKSIZE, (g_cid[2] + k) % config::G_BLOCKSIZE)); normal[1] += w[i][j][k] * (this->ch(_0, ((g_cid[0] + i) / config::G_BLOCKSIZE), ((g_cid[1] + j) / config::G_BLOCKSIZE), ((g_cid[2] + k) / config::G_BLOCKSIZE)).val(_2, (g_cid[0] + i) % config::G_BLOCKSIZE, (g_cid[1] + j) % config::G_BLOCKSIZE, (g_cid[2] + k) % config::G_BLOCKSIZE)); normal[2] += w[i][j][k] * (this->ch(_0, ((g_cid[0] + i) / config::G_BLOCKSIZE), ((g_cid[1] + j) / config::G_BLOCKSIZE), ((g_cid[2] + k) / config::G_BLOCKSIZE)).val(_3, (g_cid[0] + i) % config::G_BLOCKSIZE, (g_cid[1] + j) % config::G_BLOCKSIZE, (g_cid[2] + k) % config::G_BLOCKSIZE)); } } } normal /= sqrtf(normal.l2NormSqr()); return sdis_res; } __forceinline__ __device__ bool query_sdf(vec3& normal, const vec3& x) { if(x[0] < config::G_BOUNDARY_CONDITION * config::G_DX * config::G_BLOCKSIZE || x[0] >= (GridDomain::range(_0) - config::G_BOUNDARY_CONDITION) * config::G_BLOCKSIZE * config::G_DX || x[1] < config::G_BOUNDARY_CONDITION * config::G_DX * config::G_BLOCKSIZE || x[1] >= (GridDomain::range(_1) - config::G_BOUNDARY_CONDITION) * config::G_BLOCKSIZE * config::G_DX || x[2] < config::G_BOUNDARY_CONDITION * config::G_DX * config::G_BLOCKSIZE || x[2] >= (GridDomain::range(_2) - config::G_BOUNDARY_CONDITION) * config::G_BLOCKSIZE * config::G_DX) { return false; } return get_signed_distance_and_normal(x, normal) <= 0.f; } //< detect if there is collision with the object, if there is, reset grid // velocity < call this inside grid update kernel /* Takes a position and its velocity, * project the grid velocity, //? [to check] and returns a normal if the * collision happened as a SLIP collsion. * * derivation: * * x = \phi(X,t) = R(t)s(t)X+b(t) * X = \phi^{-1}(x,t) = (1/s) R^{-1} (x-b) * V(X,t) = \frac{\partial \phi}{\partial t} * = R'sX + Rs'X + RsX' + b' * v(x,t) = V(\phi^{-1}(x,t),t) * = R'R^{-1}(x-b) + (s'/s)(x-b) + RsX' + b' * = omega \cross (x-b) + (s'/s)(x-b) + RsV + b'*/ __forceinline__ __device__ void detect_and_resolve_collision(const ivec3 block_id, const ivec3 cell_id, float current_time, vec3& vel) { vec3 x_minustrans = (block_id * config::G_BLOCKSIZE + cell_id).cast() * config::G_DX - (trans + trans_vel * current_time); // material space vec3 x; vec3x3 current_rot_mat = rot_mat; { vec3 x0 = x_minustrans * (1.f / (1.f + dsdt * current_time)); vec3x3 rot_tmp = SignedDistanceGrid::rot_angle_to_matrix(omega[0] * current_time, 0); vec3x3 prev_rot = current_rot_mat; matrix_matrix_multiplication_3d(prev_rot.data_arr(), rot_tmp.data_arr(), current_rot_mat.data_arr()); rot_tmp = SignedDistanceGrid::rot_angle_to_matrix(omega[1] * current_time, 1); prev_rot = current_rot_mat; matrix_matrix_multiplication_3d(prev_rot.data_arr(), rot_tmp.data_arr(), current_rot_mat.data_arr()); rot_tmp = SignedDistanceGrid::rot_angle_to_matrix(omega[2] * current_time, 2); prev_rot = current_rot_mat; matrix_matrix_multiplication_3d(prev_rot.data_arr(), rot_tmp.data_arr(), current_rot_mat.data_arr()); mat_t_mul_vec_3d(x.data_arr(), current_rot_mat.data_arr(), x0.data_arr()); } x = x * scale + trans; //< enforce BC if inside LS vec3 obj_normal; bool hit = query_sdf(obj_normal, x);//< material space normal if(hit) { ///< calculate object velocity in deformation space vec3 v_object = SignedDistanceGrid::vec3_cross_vec3(omega, x_minustrans); v_object += x_minustrans * (dsdt / scale); { vec3 rot_v; matrix_vector_multiplication_3d(current_rot_mat.data_arr(), get_material_velocity(x).data_arr(), rot_v.data_arr()); v_object += rot_v * scale + trans_vel; } vel -= v_object; /// STICKY if(type == BoundaryT::STICKY) { vel.set(0.0f); /// SLIP } else if(type == BoundaryT::SLIP) { { vec3 n; matrix_vector_multiplication_3d(current_rot_mat.data_arr(), obj_normal.data_arr(), n.data_arr()); obj_normal = n; } float v_dot_n = obj_normal.dot(vel); vel -= (obj_normal * v_dot_n); if(friction > 0.0f) { if(v_dot_n < 0) { float vel_norm = sqrtf(vel.l2NormSqr()); if(-v_dot_n * friction < vel_norm) { vel += (vel / vel_norm * (v_dot_n * friction)); } else { vel.set(0.0f); } } } } /// STICKY else if(type == BoundaryT::SEPARATE) { if(obj_normal[0] == 0.0f && obj_normal[1] == 0.0f && obj_normal[2] == 0.0f) { vel.set(0.0f); return; } { vec3 n; matrix_vector_multiplication_3d(current_rot_mat.data_arr(), obj_normal.data_arr(), n.data_arr()); obj_normal = n; } float v_dot_n = obj_normal.dot(vel); if(v_dot_n < 0) { vel -= (obj_normal * v_dot_n); if(friction != 0) { float vel_norm = sqrtf(vel.l2NormSqr()); if(-v_dot_n * friction < vel_norm) { vel += (vel / vel_norm * (v_dot_n * friction)); } else { vel.set(0.0f); } } } } else { //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) Cuda has no other way to print printf("[ERROR] Wrong Boundary Type!\n"); } vel += v_object; } } }; //NOLINTEND(readability-magic-numbers) template inline void fill_signed_distance_field(std::integral_constant chn, const std::vector& s_dis, Instance& host_data) { int inside_node_num = 0; for(auto bx = 0; bx < GridDomain::range(_0); ++bx) { for(auto by = 0; by < GridDomain::range(_1); ++by) { for(auto bz = 0; bz < GridDomain::range(_2); ++bz) { auto sdis_block = host_data.ch(_0, bx, by, bz); for(auto cx = 0; cx < config::G_BLOCKSIZE; ++cx) { auto i = bx * config::G_BLOCKSIZE + cx; for(auto cy = 0; cy < config::G_BLOCKSIZE; ++cy) { auto j = by * config::G_BLOCKSIZE + cy; for(auto cz = 0; cz < config::G_BLOCKSIZE; ++cz) { auto k = bz * config::G_BLOCKSIZE + cz; auto idx = (i * GridDomain::range(_1) * config::G_BLOCKSIZE * GridDomain::range(_2) * config::G_BLOCKSIZE) + (j * GridDomain::range(_2) * config::G_BLOCKSIZE) + k; sdis_block.val(chn, cx, cy, cz) = s_dis[idx]; if(Chn == 0) { if(s_dis[idx] <= 0.0f) { inside_node_num++; } } } } } } } } if(Chn == 0) { fmt::print( "[Collision Object]\n\t[from saved signed_distance_field] " "Finish init signed distance buffer, inside node num = {}.\n", inside_node_num ); } else { fmt::print( "[Collision Object]\n\t[from saved signed_distance_field] " "Finish init signed distance gradient [{}].\n", Chn ); } } inline void init_from_signed_distance_file(const std::string& filename, vec resolution, Instance& host_data) { std::string file_addr = std::string(AssetDirPath) + "vdbSDF/"; std::vector sdisf(resolution.prod()); auto read_file = [&](const std::string& suffix) { std::string file_path; file_path.append(file_addr).append(filename).append(suffix); FILE* fn; fopen_s(&fn, file_path.c_str(), "rb"); std::size_t read_num = std::fread(static_cast(sdisf.data()), sizeof(float), sdisf.size(), fn); if(read_num != static_cast(resolution.prod())) { std::cout << "Error in loading file [" << filename.c_str() << "]: read in " << read_num << " entries, should be " << resolution.prod() << std::endl; throw std::runtime_error("Error occured while loading file"); } std::fclose(fn); }; read_file("_sdf.bin"); fill_signed_distance_field(_0, sdisf, host_data); read_file("_grad_0.bin"); fill_signed_distance_field(_1, sdisf, host_data); read_file("_grad_1.bin"); fill_signed_distance_field(_2, sdisf, host_data); read_file("_grad_2.bin"); fill_signed_distance_field(_3, sdisf, host_data); } }// namespace mn #endif ================================================ FILE: Projects/MGSP/constitutive_models.cuh ================================================ #ifndef CONSTITUTIVE_MODELS_CUH #define CONSTITUTIVE_MODELS_CUH #include #include #include //NOLINTNEXTLINE(cppcoreguidelines-macro-usage) Macro usage necessary here for preprocessor if #define USE_JOSH_FRACTURE_PAPER 1//Selects which solve is used namespace mn { //TODO: But maybe use names instead for better understanding //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template __forceinline__ __device__ void compute_stress_fixed_corotated(T volume, T mu, T lambda, const vec& F, vec& PF) { std::array U = {}; std::array S = {}; std::array V = {}; math::svd(F[0], F[3], F[6], F[1], F[4], F[7], F[2], F[5], F[8], U[0], U[3], U[6], U[1], U[4], U[7], U[2], U[5], U[8], S[0], S[1], S[2], V[0], V[3], V[6], V[1], V[4], V[7], V[2], V[5], V[8]); T J = S[0] * S[1] * S[2]; T scaled_mu = 2.0f * mu; T scaled_lambda = lambda * (J - 10.f); vec P_hat; P_hat[0] = scaled_mu * (S[0] - 1.f) + scaled_lambda * (S[1] * S[2]); P_hat[1] = scaled_mu * (S[1] - 1.f) + scaled_lambda * (S[0] * S[2]); P_hat[2] = scaled_mu * (S[2] - 1.f) + scaled_lambda * (S[0] * S[1]); vec P; P[0] = P_hat[0] * U[0] * V[0] + P_hat[1] * U[3] * V[3] + P_hat[2] * U[6] * V[6]; P[1] = P_hat[0] * U[1] * V[0] + P_hat[1] * U[4] * V[3] + P_hat[2] * U[7] * V[6]; P[2] = P_hat[0] * U[2] * V[0] + P_hat[1] * U[5] * V[3] + P_hat[2] * U[8] * V[6]; P[3] = P_hat[0] * U[0] * V[1] + P_hat[1] * U[3] * V[4] + P_hat[2] * U[6] * V[7]; P[4] = P_hat[0] * U[1] * V[1] + P_hat[1] * U[4] * V[4] + P_hat[2] * U[7] * V[7]; P[5] = P_hat[0] * U[2] * V[1] + P_hat[1] * U[5] * V[4] + P_hat[2] * U[8] * V[7]; P[6] = P_hat[0] * U[0] * V[2] + P_hat[1] * U[3] * V[5] + P_hat[2] * U[6] * V[8]; P[7] = P_hat[0] * U[1] * V[2] + P_hat[1] * U[4] * V[5] + P_hat[2] * U[7] * V[8]; P[8] = P_hat[0] * U[2] * V[2] + P_hat[1] * U[5] * V[5] + P_hat[2] * U[8] * V[8]; /// PF' PF[0] = (P[0] * F[0] + P[3] * F[3] + P[6] * F[6]) * volume; PF[1] = (P[1] * F[0] + P[4] * F[3] + P[7] * F[6]) * volume; PF[2] = (P[2] * F[0] + P[5] * F[3] + P[8] * F[6]) * volume; PF[3] = (P[0] * F[1] + P[3] * F[4] + P[6] * F[7]) * volume; PF[4] = (P[1] * F[1] + P[4] * F[4] + P[7] * F[7]) * volume; PF[5] = (P[2] * F[1] + P[5] * F[4] + P[8] * F[7]) * volume; PF[6] = (P[0] * F[2] + P[3] * F[5] + P[6] * F[8]) * volume; PF[7] = (P[1] * F[2] + P[4] * F[5] + P[7] * F[8]) * volume; PF[8] = (P[2] * F[2] + P[5] * F[5] + P[8] * F[8]) * volume; } //NOLINTEND(readability-magic-numbers, readability-identifier-naming) //TODO: But maybe use names instead for better understanding //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template __forceinline__ __device__ void compute_stress_nacc(T volume, T mu, T lambda, T bm, T xi, T beta, T msqr, bool hardening_on, T& log_jp, vec& F, vec& PF) { (void) lambda; std::array U = {}; std::array S = {}; std::array V = {}; math::svd(F[0], F[3], F[6], F[1], F[4], F[7], F[2], F[5], F[8], U[0], U[3], U[6], U[1], U[4], U[7], U[2], U[5], U[8], S[0], S[1], S[2], V[0], V[3], V[6], V[1], V[4], V[7], V[2], V[5], V[8]); T p0 = bm * (static_cast(0.00001) + sinh(xi * (-log_jp > 0 ? -log_jp : 0))); T p_min = -beta * p0; T Je_trial = S[0] * S[1] * S[2]; ///< 0). calculate YS std::array B_hat_trial = {S[0] * S[0], S[1] * S[1], S[2] * S[2]}; T trace_B_hat_trial_divdim = (B_hat_trial[0] + B_hat_trial[1] + B_hat_trial[2]) / 3.f; T J_power_neg_2_d_mulmu = mu * powf(Je_trial, -2.f / 3.f);///< J^(-2/dim) * mu std::array s_hat_trial = {J_power_neg_2_d_mulmu * (B_hat_trial[0] - trace_B_hat_trial_divdim), J_power_neg_2_d_mulmu * (B_hat_trial[1] - trace_B_hat_trial_divdim), J_power_neg_2_d_mulmu * (B_hat_trial[2] - trace_B_hat_trial_divdim)}; T psi_kappa_partial_J = bm * 0.5f * (Je_trial - 1.f / Je_trial); T p_trial = -psi_kappa_partial_J * Je_trial; T y_s_half_coeff = 3.f / 2.f * (1 + 2.f * beta);///< a T y_p_half = (msqr * (p_trial - p_min) * (p_trial - p0)); T s_hat_trial_sqrnorm = s_hat_trial[0] * s_hat_trial[0] + s_hat_trial[1] * s_hat_trial[1] + s_hat_trial[2] * s_hat_trial[2]; T y = (y_s_half_coeff * s_hat_trial_sqrnorm) + y_p_half; //< 1). update strain and hardening alpha(in log_jp) ///< case 1, project to max tip of YS if(p_trial > p0) { T Je_new = sqrtf(-2.f * p0 / bm + 1.f); S[0] = S[1] = S[2] = powf(Je_new, 1.f / 3.f); std::array New_F = {}; matmul_mat_diag_mat_t_3d(New_F, U, S, V); #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } if(hardening_on) { log_jp += logf(Je_trial / Je_new); } }///< case 1 -- end /// case 2, project to min tip of YS else if(p_trial < p_min) { T Je_new = sqrtf(-2.f * p_min / bm + 1.f); S[0] = S[1] = S[2] = powf(Je_new, 1.f / 3.f); std::array New_F = {}; matmul_mat_diag_mat_t_3d(New_F, U, S, V); #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } if(hardening_on) { log_jp += logf(Je_trial / Je_new); } }///< case 2 -- end /// case 3, keep or project to YS by hardening else { ///< outside YS if(y >= 1e-4) { ////< yield surface projection T B_s_coeff = powf(Je_trial, 2.f / 3.f) / mu * sqrtf(-y_p_half / y_s_half_coeff) / sqrtf(s_hat_trial_sqrnorm); #pragma unroll 3 for(int i = 0; i < 3; i++) { S[i] = sqrtf(s_hat_trial[i] * B_s_coeff + trace_B_hat_trial_divdim); } std::array New_F = {}; matmul_mat_diag_mat_t_3d(New_F, U, S, V); #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } ////< hardening if(hardening_on && p0 > 1e-4 && p_trial < p0 - 1e-4 && p_trial > 1e-4 + p_min) { T p_center = (static_cast(1.0) - beta) * p0 / 2; #if USE_JOSH_FRACTURE_PAPER/// solve in 19 Josh Fracture paper T q_trial = sqrtf(3.f / 2.f * s_hat_trial_sqrnorm); std::array direction = {p_center - p_trial, -q_trial}; T direction_norm = sqrtf(direction[0] * direction[0] + direction[1] * direction[1]); direction[0] /= direction_norm; direction[1] /= direction_norm; T C = msqr * (p_center - p_min) * (p_center - p0); T B = msqr * direction[0] * (2 * p_center - p0 - p_min); T A = msqr * direction[0] * direction[0] + (1 + 2 * beta) * direction[1] * direction[1]; T l1 = (-B + sqrtf(B * B - 4 * A * C)) / (2 * A); T l2 = (-B - sqrtf(B * B - 4 * A * C)) / (2 * A); T p1 = p_center + l1 * direction[0]; T p2 = p_center + l2 * direction[0]; #else/// solve in ziran - Compare_With_Physbam T aa = msqr * powf(p_trial - p_center, 2) / (y_s_half_coeff * s_hat_trial_sqrnorm); T dd = 1 + aa; T ff = aa * beta * p0 - aa * p0 - 2 * p_center; T gg = (p_center * p_center) - aa * beta * (p0 * p0); T zz = sqrtf(fabsf(ff * ff - 4 * dd * gg)); T p1 = (-ff + zz) / (2 * dd); T p2 = (-ff - zz) / (2 * dd); #endif T p_fake = (p_trial - p_center) * (p1 - p_center) > 0 ? p1 : p2; T tmp_Je_sqr = (-2 * p_fake / bm + 1); T Je_new_fake = sqrtf(tmp_Je_sqr > 0 ? tmp_Je_sqr : -tmp_Je_sqr); if(Je_new_fake > 1e-4) { log_jp += logf(Je_trial / Je_new_fake); } } }///< outside YS -- end } ///< case 3 --end //< 2). elasticity ///< known: F(renewed), U, V, S(renewed) ///< unknown: J, dev(FF^T) T J = S[0] * S[1] * S[2]; std::array b_dev = {}; std::array b = {}; matrix_matrix_tranpose_multiplication_3d(F.data_arr(), b); matrix_deviatoric_3d(b, b_dev); ///< |f| = P * F^T * Volume T dev_b_coeff = mu * powf(J, -2.f / 3.f); T i_coeff = bm * .5f * (J * J - 1.f); PF[0] = (dev_b_coeff * b_dev[0] + i_coeff) * volume; PF[1] = (dev_b_coeff * b_dev[1]) * volume; PF[2] = (dev_b_coeff * b_dev[2]) * volume; PF[3] = (dev_b_coeff * b_dev[3]) * volume; PF[4] = (dev_b_coeff * b_dev[4] + i_coeff) * volume; PF[5] = (dev_b_coeff * b_dev[5]) * volume; PF[6] = (dev_b_coeff * b_dev[6]) * volume; PF[7] = (dev_b_coeff * b_dev[7]) * volume; PF[8] = (dev_b_coeff * b_dev[8] + i_coeff) * volume; } //NOLINTEND(readability-magic-numbers, readability-identifier-naming) //TODO: But maybe use names instead for better understanding //NOLINTBEGIN(readability-magic-numbers, readability-identifier-naming) Magic numbers are formula specific; Common naming for this physical formulas template __forceinline__ __device__ void compute_stress_sand(T volume, T mu, T lambda, T cohesion, T beta, T yield_surface, bool vol_correction, T& log_jp, vec& F, vec& PF) { std::array U = {}; std::array S = {}; std::array V = {}; math::svd(F[0], F[3], F[6], F[1], F[4], F[7], F[2], F[5], F[8], U[0], U[3], U[6], U[1], U[4], U[7], U[2], U[5], U[8], S[0], S[1], S[2], V[0], V[3], V[6], V[1], V[4], V[7], V[2], V[5], V[8]); T scaled_mu = static_cast(2.0) * mu; std::array epsilon = {}; std::array New_S = {};///< helper std::array New_F = {}; #pragma unroll 3 for(int i = 0; i < 3; i++) { T abs_S = S[i] > 0 ? S[i] : -S[i]; abs_S = abs_S > static_cast(1e-4) ? abs_S : static_cast(1e-4); epsilon[i] = logf(abs_S) - cohesion; } T sum_epsilon = epsilon[0] + epsilon[1] + epsilon[2]; T trace_epsilon = sum_epsilon + log_jp; std::array epsilon_hat = {}; #pragma unroll 3 for(int i = 0; i < 3; i++) { epsilon_hat[i] = epsilon[i] - (trace_epsilon / static_cast(3.0)); } T epsilon_hat_norm = sqrtf(epsilon_hat[0] * epsilon_hat[0] + epsilon_hat[1] * epsilon_hat[1] + epsilon_hat[2] * epsilon_hat[2]); /* Calculate Plasticiy */ if(trace_epsilon >= static_cast(0.0)) {///< case II: project to the cone tip New_S[0] = New_S[1] = New_S[2] = expf(cohesion); matmul_mat_diag_mat_t_3d(New_F, U, New_S, V);// new F_e /* Update F */ #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } if(vol_correction) { log_jp = beta * sum_epsilon + log_jp; } } else if(mu != 0) { log_jp = 0; T delta_gamma = epsilon_hat_norm + (static_cast(3.0) * lambda + scaled_mu) / scaled_mu * trace_epsilon * yield_surface; std::array H = {}; if(delta_gamma <= 0) {///< case I: inside the yield surface cone #pragma unroll 3 for(int i = 0; i < 3; i++) { H[i] = epsilon[i] + cohesion; } } else {///< case III: project to the cone surface #pragma unroll 3 for(int i = 0; i < 3; i++) { H[i] = epsilon[i] - (delta_gamma / epsilon_hat_norm) * epsilon_hat[i] + cohesion; } } #pragma unroll 3 for(int i = 0; i < 3; i++) { New_S[i] = expf(H[i]); } matmul_mat_diag_mat_t_3d(New_F, U, New_S, V);// new F_e /* Update F */ #pragma unroll 9 for(int i = 0; i < 9; i++) { F[i] = New_F[i]; } } else { //TODO: What to do here? Just don't change values? } /* Elasticity -- Calculate Coefficient */ std::array New_S_log = {logf(New_S[0]), logf(New_S[1]), logf(New_S[2])}; std::array P_hat = {}; // T S_inverse[3] = {1.f/S[0], 1.f/S[1], 1.f/S[2]}; // TO CHECK // T S_inverse[3] = {1.f / New_S[0], 1.f / New_S[1], 1.f / New_S[2]}; // TO // CHECK T trace_log_S = New_S_log[0] + New_S_log[1] + New_S_log[2]; #pragma unroll 3 for(int i = 0; i < 3; i++) { P_hat[i] = (scaled_mu * New_S_log[i] + lambda * trace_log_S) / New_S[i]; } std::array P = {}; matmul_mat_diag_mat_t_3d(P, U, P_hat, V); ///< |f| = P * F^T * Volume PF[0] = (P[0] * F[0] + P[3] * F[3] + P[6] * F[6]) * volume; PF[1] = (P[1] * F[0] + P[4] * F[3] + P[7] * F[6]) * volume; PF[2] = (P[2] * F[0] + P[5] * F[3] + P[8] * F[6]) * volume; PF[3] = (P[0] * F[1] + P[3] * F[4] + P[6] * F[7]) * volume; PF[4] = (P[1] * F[1] + P[4] * F[4] + P[7] * F[7]) * volume; PF[5] = (P[2] * F[1] + P[5] * F[4] + P[8] * F[7]) * volume; PF[6] = (P[0] * F[2] + P[3] * F[5] + P[6] * F[8]) * volume; PF[7] = (P[1] * F[2] + P[4] * F[5] + P[7] * F[8]) * volume; PF[8] = (P[2] * F[2] + P[5] * F[5] + P[8] * F[8]) * volume; } //NOLINTEND(readability-magic-numbers, readability-identifier-naming) }// namespace mn #endif ================================================ FILE: Projects/MGSP/grid_buffer.cuh ================================================ #ifndef GRID_BUFFER_CUH #define GRID_BUFFER_CUH #include #include "mgmpm_kernels.cuh" #include "settings.h" namespace mn { using namespace placeholder;//NOLINT(google-build-using-namespace) Allow placeholders to be included generally for simplification //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments using BlockDomain = CompactDomain; using GridDomain = CompactDomain; using GridBufferDomain = CompactDomain; using grid_block_ = Structural, BlockDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_>; using grid_ = Structural, GridDomain, attrib_layout::AOS, grid_block_>; using grid_buffer_ = Structural, GridBufferDomain, attrib_layout::AOS, grid_block_>; //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) struct GridBuffer : Instance { using base_t = Instance; template explicit GridBuffer(Allocator allocator) : base_t {spawn(allocator)} {} template void check_capacity(Allocator allocator, std::size_t capacity) { if(capacity > this->capacity) { this->resize(allocator, capacity); } } template void reset(int block_count, CudaContext& cu_dev) { //check_cuda_errors(cudaMemsetAsync((void *)&this->val_1d(_0, 0), 0, grid_block_::size * block_count, cu_dev.stream_compute())); cu_dev.compute_launch({block_count, config::G_BLOCKVOLUME}, clear_grid, *this); } }; }// namespace mn #endif ================================================ FILE: Projects/MGSP/halo_buffer.cuh ================================================ #ifndef HALO_BUFFER_CUH #define HALO_BUFFER_CUH #include #include "grid_buffer.cuh" #include "particle_buffer.cuh" #include "settings.h" //#include namespace mn { using HaloGridBlocksDomain = CompactDomain; using halo_grid_blocks_ = Structural, HaloGridBlocksDomain, attrib_layout::SOA, grid_block_>; using grid_block_ = Structural, BlockDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_>; /// halo grid block struct HaloGridBlocks { struct HaloBuffer { Instance grid; ivec3* blockids; }; int num_targets; uint32_t* counts; std::vector h_counts; std::vector buffers; explicit HaloGridBlocks(int num_neighbors) : num_targets {num_neighbors} , counts(nullptr) , h_counts(num_neighbors, 0) { check_cuda_errors(cudaMalloc(&counts, sizeof(uint32_t) * num_targets)); buffers.resize(num_targets); } template void init_blocks(Allocator allocator, uint32_t block_count) { for(int did = 0; did < num_targets; ++did) { buffers[did].blockids = static_cast(allocator.allocate(sizeof(ivec3) * block_count)); } } template void init_buffer(Allocator allocator, std::vector counts) { for(int did = 0; did < num_targets; ++did) { buffers[did].grid.allocate_handle(allocator, counts[did]); } } void reset_counts(cudaStream_t stream) { check_cuda_errors(cudaMemsetAsync(counts, 0, sizeof(uint32_t) * num_targets, stream)); } void retrieve_counts(cudaStream_t stream) { check_cuda_errors(cudaMemcpyAsync(h_counts.data(), counts, sizeof(uint32_t) * num_targets, cudaMemcpyDefault, stream)); } void send(HaloGridBlocks& other, int src, int dst, cudaStream_t stream) { auto count = other.h_counts[src] = h_counts[dst]; //check_cuda_errors(cudaMemcpyAsync( &other.buffers[src].val(_1, 0), &buffers[dst].val(_1, 0), sizeof(ivec3) * count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.buffers[src].blockids, buffers[dst].blockids, sizeof(ivec3) * count, cudaMemcpyDefault, stream)); //check_cuda_errors(cudaMemcpyAsync(&other.buffers[src].grid.ch(_0, 0).val_1d(_0, 0), &buffers[dst].grid.ch(_0, 0).val_1d(_0, 0), grid_block_::size * count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyPeerAsync(&other.buffers[src].grid.ch(_0, 0).val_1d(_0, 0), dst, &buffers[dst].grid.ch(_0, 0).val_1d(_0, 0), src, grid_block_::size * count, stream)); // printf("sending from %d to %d at %llu\n", src, dst, // (unsigned long long)&other.buffers[src].grid.ch(_0, 0).val_1d(_0, // 0)); } }; }// namespace mn #endif ================================================ FILE: Projects/MGSP/halo_kernels.cuh ================================================ #ifndef HALO_KERNELS_CUH #define HALO_KERNELS_CUH #include #include #include #include "constitutive_models.cuh" #include "particle_buffer.cuh" #include "settings.h" #include "utility_funcs.hpp" namespace mn { using namespace placeholder;//NOLINT(google-build-using-namespace) Allow placeholders to be included generally for simplification //TODO: Make magic numbers to constants where suitable //TODO: Ensure call dimensions and such are small enough to allow narrowing conversations. Or directly use unsigned where possible //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers, misc-definitions-in-headers) CUDA does not yet support std::span; Cannot declare __global__ functions inline template __global__ void mark_overlapping_blocks(uint32_t block_count, int otherdid, const ivec3* __restrict__ incoming_block_ids, Partition partition, uint32_t* count, HaloGridBlocks halo_grid_blocks) { uint32_t inc_blockno = blockIdx.x * blockDim.x + threadIdx.x; if(inc_blockno >= block_count) { return; } auto inc_blockid = incoming_block_ids[inc_blockno]; auto blockno = partition.query(inc_blockid); if(blockno >= 0) { atomicOr(partition.overlap_marks + blockno, 1 << otherdid); auto halono = atomicAdd(count, 1); // halo_grid_blocks.val(_1, halono) = inc_blockid; halo_grid_blocks.blockids[halono] = inc_blockid; } } template __global__ void collect_blockids_for_halo_reduction(uint32_t particle_block_count, int did, Partition partition) { (void) did; std::size_t blockno = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; if(blockno >= particle_block_count) { return; } auto blockid = partition.active_keys[blockno]; partition.halo_marks[blockno] = 0; for(char i = 0; i < 2; ++i) { for(char j = 0; j < 2; ++j) { for(char k = 0; k < 2; ++k) { ivec3 neighborid {blockid[0] + i, blockid[1] + j, blockid[2] + k}; int neighborno = partition.query(neighborid); // if (partition.overlap_marks[neighborno] ^ ((HaloIndex)1 << did)) { if(partition.overlap_marks[neighborno]) { partition.halo_marks[blockno] = 1; auto halono = atomicAdd(partition.halo_count, 1); partition.halo_blocks[halono] = blockid; return; } } } } } template __global__ void collect_grid_blocks(Grid grid, Partition partition, HaloGridBlocks halo_grid_blocks) { uint32_t halo_blockno = blockIdx.x; // auto halo_blockid = halo_grid_blocks.grid.val(_1, halo_blockno); auto halo_blockid = halo_grid_blocks.blockids[halo_blockno]; auto blockno = partition.query(halo_blockid); auto halo_gridblock = halo_grid_blocks.grid.ch(_0, halo_blockno); auto gridblock = grid.ch(_0, blockno); for(int cell_id_in_block = static_cast(threadIdx.x); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += static_cast(blockDim.x)) { halo_gridblock.val_1d(_0, cell_id_in_block) = gridblock.val_1d(_0, cell_id_in_block); halo_gridblock.val_1d(_1, cell_id_in_block) = gridblock.val_1d(_1, cell_id_in_block); halo_gridblock.val_1d(_2, cell_id_in_block) = gridblock.val_1d(_2, cell_id_in_block); halo_gridblock.val_1d(_3, cell_id_in_block) = gridblock.val_1d(_3, cell_id_in_block); } } template __global__ void reduce_grid_blocks(Grid grid, Partition partition, HaloGridBlocks halo_grid_blocks) { uint32_t halo_blockno = blockIdx.x; // auto halo_blockid = halo_grid_blocks.grid.val(_1, halo_blockno); auto halo_blockid = halo_grid_blocks.blockids[halo_blockno]; auto blockno = partition.query(halo_blockid); auto halo_gridblock = halo_grid_blocks.grid.ch(_0, halo_blockno); auto gridblock = grid.ch(_0, blockno); for(int cell_id_in_block = static_cast(threadIdx.x); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += static_cast(blockDim.x)) { atomicAdd(&gridblock.val_1d(_0, cell_id_in_block), halo_gridblock.val_1d(_0, cell_id_in_block)); atomicAdd(&gridblock.val_1d(_1, cell_id_in_block), halo_gridblock.val_1d(_1, cell_id_in_block)); atomicAdd(&gridblock.val_1d(_2, cell_id_in_block), halo_gridblock.val_1d(_2, cell_id_in_block)); atomicAdd(&gridblock.val_1d(_3, cell_id_in_block), halo_gridblock.val_1d(_3, cell_id_in_block)); } } template __global__ void mark_migration_grid_blocks(uint32_t block_count, Domain const domain, Partition const partition, uint32_t* count, HaloParticleBlocks halo_particle_blocks, int const* active_grid_block_marks) { uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } if(active_grid_block_marks[blockno]) { auto blockid = partition.active_keys[blockno]; if(domain.within(blockid, ivec3 {0, 0, 0}, ivec3 {1, 1, 1})) { // halo_particle_blocks._binpbs[halono] = 0; auto halono = atomicAdd(count, 1); halo_particle_blocks._gblockids[halono] = blockid; } } } template __global__ void collect_migration_grid_blocks(Grid grid, Partition partition, HaloGridBlocks halo_grid_blocks) { uint32_t halo_blockno = blockIdx.x; auto halo_blockid = halo_grid_blocks._gblockids[halo_blockno]; auto halo_gridblock = halo_grid_blocks._grid.ch(_0, halo_blockno); auto blockno = partition.query(halo_blockid); auto gridblock = grid.ch(_0, blockno); for(int cell_id_in_block = static_cast(threadIdx.x); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += static_cast(blockDim.x)) { halo_gridblock.val_1d(_0, cell_id_in_block) = gridblock.val_1d(_0, cell_id_in_block); halo_gridblock.val_1d(_1, cell_id_in_block) = gridblock.val_1d(_1, cell_id_in_block); halo_gridblock.val_1d(_2, cell_id_in_block) = gridblock.val_1d(_2, cell_id_in_block); halo_gridblock.val_1d(_3, cell_id_in_block) = gridblock.val_1d(_3, cell_id_in_block); } } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers, misc-definitions-in-headers) }// namespace mn #endif ================================================ FILE: Projects/MGSP/hash_table.cuh ================================================ #ifndef HASH_TABLE_CUH #define HASH_TABLE_CUH #include #include "mgmpm_kernels.cuh" #include "settings.h" //NOLINTNEXTLINE(cppcoreguidelines-macro-usage) Macro usage necessary here for preprocessor if #define PRINT_NEGATIVE_BLOGNOS 1 namespace mn { template struct HaloPartition { template HaloPartition(Allocator allocator, int max_block_count) { (void) allocator; (void) max_block_count; } template void resize_partition(Allocator allocator, std::size_t prev_capacity, std::size_t capacity) {} void copy_to(HaloPartition& other, std::size_t block_count, cudaStream_t stream) {} }; template<> struct HaloPartition<1> { int* halo_count; int h_count; char* halo_marks;///< halo particle blocks int* overlap_marks; ivec3* halo_blocks; template HaloPartition(Allocator allocator, int max_block_count) : h_count(0) { halo_count = static_cast(allocator.allocate(sizeof(char) * max_block_count)); halo_marks = static_cast(allocator.allocate(sizeof(char) * max_block_count)); overlap_marks = static_cast(allocator.allocate(sizeof(int) * max_block_count)); halo_blocks = static_cast(allocator.allocate(sizeof(ivec3) * max_block_count)); } void copy_to(HaloPartition& other, std::size_t block_count, cudaStream_t stream) const { other.h_count = h_count; check_cuda_errors(cudaMemcpyAsync(other.halo_marks, halo_marks, sizeof(char) * block_count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.overlap_marks, overlap_marks, sizeof(int) * block_count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.halo_blocks, halo_blocks, sizeof(ivec3) * block_count, cudaMemcpyDefault, stream)); } template void resize_partition(Allocator allocator, std::size_t prev_capacity, std::size_t capacity) { allocator.deallocate(halo_marks, sizeof(char) * prev_capacity); allocator.deallocate(overlap_marks, sizeof(int) * prev_capacity); allocator.deallocate(halo_blocks, sizeof(ivec3) * prev_capacity); halo_marks = static_cast(allocator.allocate(sizeof(char) * capacity)); overlap_marks = static_cast(allocator.allocate(sizeof(int) * capacity)); halo_blocks = static_cast(allocator.allocate(sizeof(ivec3) * capacity)); } void reset_halo_count(cudaStream_t stream) const { check_cuda_errors(cudaMemsetAsync(halo_count, 0, sizeof(int), stream)); } void reset_overlap_marks(uint32_t neighbor_block_count, cudaStream_t stream) const { check_cuda_errors(cudaMemsetAsync(overlap_marks, 0, sizeof(int) * neighbor_block_count, stream)); } void retrieve_halo_count(cudaStream_t stream) { check_cuda_errors(cudaMemcpyAsync(&h_count, halo_count, sizeof(int), cudaMemcpyDefault, stream)); } }; //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments using block_partition_ = Structural, GridDomain, attrib_layout::AOS, empty_>; //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) Using pointer arithmetics cause library and allocators do so. template struct Partition : Instance , HaloPartition { using base_t = Instance; using halo_base_t = HaloPartition; using block_partition_::key_t; using block_partition_::value_t; static_assert(sentinel_v == (value_t) (-1), "sentinel value not full 1s\n"); int* cell_particle_counts; int* particle_bucket_sizes; int* cellbuckets; int* blockbuckets; int* bin_offsets; template Partition(Allocator allocator, int max_block_count) : halo_base_t {allocator, max_block_count} { allocate_table(allocator, max_block_count); cell_particle_counts = static_cast(allocator.allocate(sizeof(int) * max_block_count * config::G_BLOCKVOLUME)); particle_bucket_sizes = static_cast(allocator.allocate(sizeof(int) * max_block_count)); cellbuckets = static_cast(allocator.allocate(sizeof(int) * max_block_count * config::G_BLOCKVOLUME * config::G_MAX_PARTICLES_IN_CELL)); blockbuckets = static_cast(allocator.allocate(sizeof(int) * max_block_count * config::G_PARTICLE_NUM_PER_BLOCK)); bin_offsets = static_cast(allocator.allocate(sizeof(int) * max_block_count)); /// init reset(); } ~Partition() = default; Partition(const Partition& other) = default; Partition(Partition&& other) noexcept = default; Partition& operator=(const Partition& other) = default; Partition& operator=(Partition&& other) noexcept = default; template void resize_partition(Allocator allocator, std::size_t capacity) { halo_base_t::resize_partition(allocator, this->capacity, capacity); allocator.deallocate(cell_particle_counts, sizeof(int) * this->capacity * config::G_BLOCKVOLUME); allocator.deallocate(particle_bucket_sizes, sizeof(int) * this->capacity); allocator.deallocate(cellbuckets, sizeof(int) * this->capacity * config::G_BLOCKVOLUME * config::G_MAX_PARTICLES_IN_CELL); allocator.deallocate(blockbuckets, sizeof(int) * this->capacity * config::G_BLOCKVOLUME); allocator.deallocate(bin_offsets, sizeof(int) * this->capacity); cell_particle_counts = static_cast(allocator.allocate(sizeof(int) * capacity * config::G_BLOCKVOLUME)); particle_bucket_sizes = static_cast(allocator.allocate(sizeof(int) * capacity)); cellbuckets = static_cast(allocator.allocate(sizeof(int) * capacity * config::G_BLOCKVOLUME * config::G_MAX_PARTICLES_IN_CELL)); blockbuckets = static_cast(allocator.allocate(sizeof(int) * capacity * config::G_PARTICLE_NUM_PER_BLOCK)); bin_offsets = static_cast(allocator.allocate(sizeof(int) * capacity)); resize_table(allocator, capacity); } void reset() { check_cuda_errors(cudaMemset(this->Instance::count, 0, sizeof(value_t))); check_cuda_errors(cudaMemset(this->index_table, 0xff, sizeof(value_t) * domain::extent)); check_cuda_errors(cudaMemset(this->cell_particle_counts, 0, sizeof(int) * this->capacity * config::G_BLOCKVOLUME)); } void reset_table(cudaStream_t stream) { check_cuda_errors(cudaMemsetAsync(this->index_table, 0xff, sizeof(value_t) * domain::extent, stream)); } template void build_particle_buckets(CudaContext&& cu_dev, value_t count) { check_cuda_errors(cudaMemsetAsync(this->particle_bucket_sizes, 0, sizeof(int) * (count + 1), cu_dev.stream_compute())); cu_dev.compute_launch({count, config::G_BLOCKVOLUME}, cell_bucket_to_block, cell_particle_counts, cellbuckets, particle_bucket_sizes, blockbuckets); } void copy_to(Partition& other, std::size_t block_count, cudaStream_t stream) { halo_base_t::copy_to(other, block_count, stream); check_cuda_errors(cudaMemcpyAsync(other.index_table, this->index_table, sizeof(value_t) * domain::extent, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.particle_bucket_sizes, this->particle_bucket_sizes, sizeof(int) * block_count, cudaMemcpyDefault, stream)); check_cuda_errors(cudaMemcpyAsync(other.bin_offsets, this->bin_offsets, sizeof(int) * block_count, cudaMemcpyDefault, stream)); } __forceinline__ __device__ value_t insert(key_t key) noexcept { value_t tag = atomicCAS(&this->index(key), sentinel_v, 0); if(tag == sentinel_v) { value_t idx = atomicAdd(this->Instance::count, 1); this->index(key) = idx; this->active_keys[idx] = key;///< created a record return idx; } return -1; } __forceinline__ __device__ value_t query(key_t key) const noexcept { return this->index(key); } __forceinline__ __device__ void reinsert(value_t index) { this->index(this->active_keys[index]) = index; } __forceinline__ __device__ void add_advection(key_t cellid, int dirtag, int particle_id_in_block) noexcept { key_t blockid = cellid / config::G_BLOCKSIZE; value_t blockno = query(blockid); #if PRINT_NEGATIVE_BLOGNOS if(blockno == -1) { ivec3 offset {}; dir_components(dirtag, offset); //NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg, readability-magic-numbers) Cuda has no other way to print; Numbers are array indices to be printed printf("The hell with this! loc(%d, %d, %d) dir(%d, %d, %d) particle_id_in_block(%d)\n", cellid[0], cellid[1], cellid[2], offset[0], offset[1], offset[2], particle_id_in_block); return; } #endif //NOLINTNEXTLINE(readability-magic-numbers) Numbers are array indices to be printed value_t cellno = ((cellid[0] & config::G_BLOCKMASK) << (config::G_BLOCKBITS << 1)) | ((cellid[1] & config::G_BLOCKMASK) << config::G_BLOCKBITS) | (cellid[2] & config::G_BLOCKMASK); int particle_id_in_cell = atomicAdd(cell_particle_counts + static_cast(blockno) * config::G_BLOCKVOLUME + cellno, 1); cellbuckets[blockno * config::G_PARTICLE_NUM_PER_BLOCK + cellno * config::G_MAX_PARTICLES_IN_CELL + particle_id_in_cell] = (dirtag * config::G_PARTICLE_NUM_PER_BLOCK) | particle_id_in_block; } }; //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) }// namespace mn #endif ================================================ FILE: Projects/MGSP/mgmpm_kernels.cuh ================================================ #ifndef MULTI_GMPM_KERNELS_CUH #define MULTI_GMPM_KERNELS_CUH #include #include #include #include "boundary_condition.cuh" #include "constitutive_models.cuh" #include "particle_buffer.cuh" #include "settings.h" #include "utility_funcs.hpp" namespace mn { using namespace placeholder;//NOLINT(google-build-using-namespace) Allow placeholders to be included generally for simplification //TODO: Make magic numbers to constants where suitable //TODO: Ensure call dimensions and such are small enough to allow narrowing conversations. Or directly use unsigned where possible //TODO: Maybe use names instead of formula signs for better understanding //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers, readability-identifier-naming, misc-definitions-in-headers) CUDA does not yet support std::span; Common names for physical formulas; Cannot declare __global__ functions inline template __global__ void activate_blocks(uint32_t particle_counts, ParticleArray particle_array, Partition partition) { uint32_t particle_id = blockIdx.x * blockDim.x + threadIdx.x; if(particle_id >= particle_counts) { return; } ivec3 blockid {static_cast((std::lround(particle_array.val(_0, particle_id) / config::G_DX) - 2) / config::G_BLOCKSIZE), static_cast((std::lround(particle_array.val(_1, particle_id) / config::G_DX) - 2) / config::G_BLOCKSIZE), static_cast((std::lround(particle_array.val(_2, particle_id) / config::G_DX) - 2) / config::G_BLOCKSIZE)}; partition.insert(blockid); } template __global__ void build_particle_cell_buckets(uint32_t particle_counts, ParticleArray particle_array, Partition partition) { uint32_t particle_id = blockIdx.x * blockDim.x + threadIdx.x; if(particle_id >= particle_counts) { return; } ivec3 coord {int(std::lround(particle_array.val(_0, particle_id) / config::G_DX) - 2), int(std::lround(particle_array.val(_1, particle_id) / config::G_DX) - 2), int(std::lround(particle_array.val(_2, particle_id) / config::G_DX) - 2)}; int cellno = (coord[0] & config::G_BLOCKMASK) * config::G_BLOCKSIZE * config::G_BLOCKSIZE + (coord[1] & config::G_BLOCKMASK) * config::G_BLOCKSIZE + (coord[2] & config::G_BLOCKMASK); coord = coord / static_cast(config::G_BLOCKSIZE); auto blockno = partition.query(coord); auto particle_id_in_cell = atomicAdd(partition.cell_particle_counts + blockno * config::G_BLOCKVOLUME + cellno, 1); partition.cellbuckets[blockno * config::G_PARTICLE_NUM_PER_BLOCK + cellno * config::G_MAX_PARTICLES_IN_CELL + particle_id_in_cell] = static_cast(particle_id);//NOTE:Explicit narrowing conversation. } __global__ void cell_bucket_to_block(const int* cell_particle_counts, const int* cellbuckets, int* particle_bucket_sizes, int* buckets) { const int cellno = static_cast(threadIdx.x) & (config::G_BLOCKVOLUME - 1); const int particle_counts = cell_particle_counts[blockIdx.x * config::G_BLOCKVOLUME + cellno]; for(int particle_id_in_cell = 0; particle_id_in_cell < config::G_MAX_PARTICLES_IN_CELL; particle_id_in_cell++) { if(particle_id_in_cell < particle_counts) { auto particle_id_in_block = atomic_agg_inc(particle_bucket_sizes + blockIdx.x); buckets[blockIdx.x * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block] = cellbuckets[blockIdx.x * config::G_PARTICLE_NUM_PER_BLOCK + cellno * config::G_MAX_PARTICLES_IN_CELL + particle_id_in_cell]; } __syncthreads(); } } __global__ void compute_bin_capacity(uint32_t block_count, int const* particle_bucket_sizes, int* bin_sizes) { const uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } bin_sizes[blockno] = (particle_bucket_sizes[blockno] + config::G_BIN_CAPACITY - 1) / config::G_BIN_CAPACITY; } __global__ void init_adv_bucket(const int* particle_bucket_sizes, int* buckets) { int particle_counts = particle_bucket_sizes[blockIdx.x]; int* bucket = buckets + static_cast(blockIdx.x) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { bucket[particle_id_in_block] = (dir_offset(ivec3 {0, 0, 0}) * config::G_PARTICLE_NUM_PER_BLOCK) | particle_id_in_block; } } template __global__ void clear_grid(Grid grid) { auto gridblock = grid.ch(_0, blockIdx.x); for(int cell_id_in_block = static_cast(threadIdx.x); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += static_cast(blockDim.x)) { gridblock.val_1d(_0, cell_id_in_block) = 0.f; gridblock.val_1d(_1, cell_id_in_block) = 0.f; gridblock.val_1d(_2, cell_id_in_block) = 0.f; gridblock.val_1d(_3, cell_id_in_block) = 0.f; } } template __global__ void register_neighbor_blocks(uint32_t block_count, Partition partition) { uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } auto blockid = partition.active_keys[blockno]; for(char i = 0; i < 2; ++i) { for(char j = 0; j < 2; ++j) { for(char k = 0; k < 2; ++k) { partition.insert(ivec3 {blockid[0] + i, blockid[1] + j, blockid[2] + k}); } } } } template __global__ void register_exterior_blocks(uint32_t block_count, Partition partition) { uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } auto blockid = partition.active_keys[blockno]; for(char i = -1; i < 2; ++i) { for(char j = -1; j < 2; ++j) { for(char k = -1; k < 2; ++k) { partition.insert(ivec3 {blockid[0] + i, blockid[1] + j, blockid[2] + k}); } } } } template __global__ void rasterize(uint32_t particle_counts, const ParticleArray particle_array, Grid grid, const Partition partition, float dt, float mass) { uint32_t particle_id = blockIdx.x * blockDim.x + threadIdx.x; if(particle_id >= particle_counts) { return; } vec3 local_pos {particle_array.val(_0, particle_id), particle_array.val(_1, particle_id), particle_array.val(_2, particle_id)}; vec3 vel; vec9 contrib; vec9 c; vel.set(0.0f), contrib.set(0.f), c.set(0.f); contrib = (c * mass - contrib * dt) * config::G_D_INV; ivec3 global_base_index {static_cast(std::lround(local_pos[0] * config::G_DX_INV) - 1), static_cast(std::lround(local_pos[1] * config::G_DX_INV) - 1), static_cast(std::lround(local_pos[2] * config::G_DX_INV) - 1)}; local_pos = local_pos - global_base_index * config::G_DX; vec dws; for(int d = 0; d < 3; ++d) { dws[d] = bspline_weight(local_pos[d]); } for(int i = 0; i < 3; ++i) { for(int j = 0; j < 3; ++j) { for(int k = 0; k < 3; ++k) { ivec3 offset {i, j, k}; vec3 xixp = offset * config::G_DX - local_pos; float w = dws[0][i] * dws[1][j] * dws[2][k]; ivec3 local_index = global_base_index + offset; float wm = mass * w; int blockno = partition.query(ivec3 {static_cast(local_index[0] >> config::G_BLOCKBITS), static_cast(local_index[1] >> config::G_BLOCKBITS), static_cast(local_index[2] >> config::G_BLOCKBITS)}); auto grid_block = grid.ch(_0, blockno); for(int d = 0; d < 3; ++d) { local_index[d] = local_index[d] & config::G_BLOCKMASK; } atomicAdd(&grid_block.val(_0, local_index[0], local_index[1], local_index[2]), wm); atomicAdd(&grid_block.val(_1, local_index[0], local_index[1], local_index[2]), wm * vel[0] + (contrib[0] * xixp[0] + contrib[3] * xixp[1] + contrib[6] * xixp[2]) * w); atomicAdd(&grid_block.val(_2, local_index[0], local_index[1], local_index[2]), wm * vel[1] + (contrib[1] * xixp[0] + contrib[4] * xixp[1] + contrib[7] * xixp[2]) * w); atomicAdd(&grid_block.val(_3, local_index[0], local_index[1], local_index[2]), wm * vel[2] + (contrib[2] * xixp[0] + contrib[5] * xixp[1] + contrib[8] * xixp[2]) * w); } } } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer, Partion partition) { uint32_t blockno = blockIdx.x; int particle_counts = partition.particle_bucket_sizes[blockno]; auto* bucket = partition.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, partition.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// J particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer, Partion partition) { uint32_t blockno = blockIdx.x; int particle_counts = partition.particle_bucket_sizes[blockno]; auto* bucket = partition.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, partition.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// F particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer, Partion partition) { uint32_t blockno = blockIdx.x; int particle_counts = partition.particle_bucket_sizes[blockno]; auto* bucket = partition.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, partition.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// F particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; /// log_jp particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = ParticleBuffer::LOG_JP_0; } } template __global__ void array_to_buffer(ParticleArray particle_array, ParticleBuffer particle_buffer, Partion partition) { uint32_t blockno = blockIdx.x; int particle_counts = partition.particle_bucket_sizes[blockno]; auto* bucket = partition.blockbuckets + static_cast(blockno) * config::G_PARTICLE_NUM_PER_BLOCK; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { auto particle_id = bucket[particle_id_in_block]; auto particle_bin = particle_buffer.ch(_0, partition.bin_offsets[blockno] + particle_id_in_block / config::G_BIN_CAPACITY); /// pos particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_0, particle_id); particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_1, particle_id); particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = particle_array.val(_2, particle_id); /// F particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = 0.f; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = 1.f; /// log_jp particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = ParticleBuffer::LOG_JP_0; } } template __global__ void update_grid_velocity_query_max(uint32_t block_count, Grid grid, Partition partition, float dt, float* max_vel) { const int boundary_condition = static_cast(std::floor(config::G_BOUNDARY_CONDITION)); constexpr int NUM_WARPS = config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK * config::G_NUM_WARPS_PER_GRID_BLOCK; constexpr unsigned ACTIVE_MASK = 0xffffffff; //__shared__ float sh_maxvels[config::G_BLOCKVOLUME * config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK /// 32]; extern __shared__ float sh_maxvels[];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here int blockno = static_cast(blockIdx.x) * config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK + static_cast(threadIdx.x) / 32 / config::G_NUM_WARPS_PER_GRID_BLOCK; auto blockid = partition.active_keys[blockno]; int is_in_bound = ((blockid[0] < boundary_condition || blockid[0] >= config::G_GRID_SIZE - boundary_condition) << 2) | ((blockid[1] < boundary_condition || blockid[1] >= config::G_GRID_SIZE - boundary_condition) << 1) | (blockid[2] < boundary_condition || blockid[2] >= config::G_GRID_SIZE - boundary_condition); if(threadIdx.x < NUM_WARPS) { sh_maxvels[threadIdx.x] = 0.0f; } __syncthreads(); /// within-warp computations if(blockno < block_count) { auto grid_block = grid.ch(_0, blockno); for(int cell_id_in_block = static_cast(threadIdx.x % 32); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += 32) { float mass = grid_block.val_1d(_0, cell_id_in_block); float vel_sqr = 0.0f; vec3 vel; if(mass > 0.0f) { mass = 1.f / mass; //int i = (cell_id_in_block >> (config::G_BLOCKBITS << 1)) & config::G_BLOCKMASK; //int j = (cell_id_in_block >> config::G_BLOCKBITS) & config::G_BLOCKMASK; //int k = cell_id_in_block & config::G_BLOCKMASK; vel[0] = grid_block.val_1d(_1, cell_id_in_block); vel[1] = grid_block.val_1d(_2, cell_id_in_block); vel[2] = grid_block.val_1d(_3, cell_id_in_block); vel[0] = is_in_bound & 4 ? 0.0f : vel[0] * mass; vel[1] = is_in_bound & 2 ? 0.0f : vel[1] * mass; vel[1] += config::G_GRAVITY * dt; vel[2] = is_in_bound & 1 ? 0.0f : vel[2] * mass; // if (is_in_bound) ///< sticky // vel.set(0.f); grid_block.val_1d(_1, cell_id_in_block) = vel[0]; vel_sqr += vel[0] * vel[0]; grid_block.val_1d(_2, cell_id_in_block) = vel[1]; vel_sqr += vel[1] * vel[1]; grid_block.val_1d(_3, cell_id_in_block) = vel[2]; vel_sqr += vel[2] * vel[2]; } // unsigned activeMask = __ballot_sync(0xffffffff, mv[0] != 0.0f); for(int iter = 1; iter % 32; iter <<= 1) { float tmp = __shfl_down_sync(ACTIVE_MASK, vel_sqr, iter, 32); if((threadIdx.x % 32) + iter < 32) { vel_sqr = tmp > vel_sqr ? tmp : vel_sqr; } } if(vel_sqr > sh_maxvels[threadIdx.x / 32] && (threadIdx.x % 32) == 0) { sh_maxvels[threadIdx.x / 32] = vel_sqr; } } } __syncthreads(); /// various assumptions for(int interval = NUM_WARPS >> 1; interval > 0; interval >>= 1) { if(threadIdx.x < interval) { if(sh_maxvels[static_cast(threadIdx.x) + interval] > sh_maxvels[threadIdx.x]) { sh_maxvels[threadIdx.x] = sh_maxvels[static_cast(threadIdx.x) + interval]; } } __syncthreads(); } if(threadIdx.x == 0) { atomic_max(max_vel, sh_maxvels[0]); } } template __global__ void update_grid_velocity_query_max(uint32_t block_count, Grid grid, Partition partition, float dt, Boundary boundary, float* max_vel) { const int boundary_condition = static_cast(std::floor(config::G_BOUNDARY_CONDITION)); constexpr int NUM_WARPS = config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK * config::G_NUM_WARPS_PER_GRID_BLOCK; constexpr unsigned ACTIVE_MASK = 0xffffffff; //__shared__ float sh_maxvels[config::G_BLOCKVOLUME * config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK /// 32]; extern __shared__ float sh_maxvels[];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here int blockno = static_cast(blockIdx.x) * config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK + static_cast(threadIdx.x) / 32 / config::G_NUM_WARPS_PER_GRID_BLOCK; auto blockid = partition.active_keys[blockno]; int is_in_bound = ((blockid[0] < boundary_condition || blockid[0] >= config::G_GRID_SIZE - boundary_condition) << 2) | ((blockid[1] < boundary_condition || blockid[1] >= config::G_GRID_SIZE - boundary_condition) << 1) | (blockid[2] < boundary_condition || blockid[2] >= config::G_GRID_SIZE - boundary_condition); if(threadIdx.x < NUM_WARPS) { sh_maxvels[threadIdx.x] = 0.0f; } __syncthreads(); /// within-warp computations if(blockno < block_count) { auto grid_block = grid.ch(_0, blockno); for(int cell_id_in_block = static_cast(threadIdx.x % 32); cell_id_in_block < config::G_BLOCKVOLUME; cell_id_in_block += 32) { float mass = grid_block.val_1d(_0, cell_id_in_block); float vel_sqr = 0.0f; vec3 vel; if(mass > 0.0f) { mass = 1.f / mass; //int i = (cell_id_in_block >> (config::G_BLOCKBITS << 1)) & config::G_BLOCKMASK; //int j = (cell_id_in_block >> config::G_BLOCKBITS) & config::G_BLOCKMASK; //int k = cell_id_in_block & config::G_BLOCKMASK; vel[0] = grid_block.val_1d(_1, cell_id_in_block); vel[1] = grid_block.val_1d(_2, cell_id_in_block); vel[2] = grid_block.val_1d(_3, cell_id_in_block); vel[0] = is_in_bound & 4 ? 0.0f : vel[0] * mass; vel[1] = is_in_bound & 2 ? 0.0f : vel[1] * mass; vel[1] += config::G_GRAVITY * dt; vel[2] = is_in_bound & 1 ? 0.0f : vel[2] * mass; ivec3 cellid {(cell_id_in_block & 0x30) >> 4, (cell_id_in_block & 0xc) >> 2, cell_id_in_block & 0x3}; boundary.detect_and_resolve_collision(blockid, cellid, 0.f, vel); vel_sqr = vel.dot(vel); grid_block.val_1d(_1, cell_id_in_block) = vel[0]; vel_sqr += vel[0] * vel[0]; grid_block.val_1d(_2, cell_id_in_block) = vel[1]; vel_sqr += vel[1] * vel[1]; grid_block.val_1d(_3, cell_id_in_block) = vel[2]; vel_sqr += vel[2] * vel[2]; } // unsigned activeMask = __ballot_sync(0xffffffff, mv[0] != 0.0f); for(int iter = 1; iter % 32; iter <<= 1) { float tmp = __shfl_down_sync(ACTIVE_MASK, vel_sqr, iter, 32); if((threadIdx.x % 32) + iter < 32) { vel_sqr = tmp > vel_sqr ? tmp : vel_sqr; } } if(vel_sqr > sh_maxvels[threadIdx.x / 32] && (threadIdx.x % 32) == 0) { sh_maxvels[threadIdx.x / 32] = vel_sqr; } } } __syncthreads(); /// various assumptions for(int interval = NUM_WARPS >> 1; interval > 0; interval >>= 1) { if(threadIdx.x < interval) { if(sh_maxvels[static_cast(threadIdx.x) + interval] > sh_maxvels[threadIdx.x]) { sh_maxvels[threadIdx.x] = sh_maxvels[static_cast(threadIdx.x) + interval]; } } __syncthreads(); } if(threadIdx.x == 0) { atomic_max(max_vel, sh_maxvels[0]); } } template __global__ void g2p2g(float dt, float new_dt, const ivec3* __restrict__ blocks, const ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer, const Partition prev_partition, Partition partition, const Grid grid, Grid next_grid) { static constexpr uint64_t NUM_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 3; static constexpr uint64_t NUM_VI_IN_ARENA = NUM_VI_PER_BLOCK << 3; static constexpr uint64_t NUM_M_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 4; static constexpr uint64_t NUM_M_VI_IN_ARENA = NUM_M_VI_PER_BLOCK << 3; static constexpr unsigned ARENAMASK = (config::G_BLOCKSIZE << 1) - 1; static constexpr unsigned ARENABITS = config::G_BLOCKBITS + 1; using ViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>*; using ViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>&; using MViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>*; using MViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>&; extern __shared__ char shmem[];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here ViArenaRef __restrict__ g2pbuffer = *static_cast(static_cast(static_cast(shmem))); MViArenaRef __restrict__ p2gbuffer = *static_cast(static_cast(static_cast(shmem) + NUM_VI_IN_ARENA * sizeof(float))); ivec3 blockid; int src_blockno; if(blocks != nullptr) { blockid = blocks[blockIdx.x]; src_blockno = partition.query(blockid); } else { if(partition.halo_marks[blockIdx.x]) { return; } blockid = partition.active_keys[blockIdx.x]; int src_blockno = static_cast(blockIdx.x); int particle_bucket_size = next_particle_buffer.particle_bucket_sizes[src_blockno]; if(particle_bucket_size == 0) { return; } } for(int base = static_cast(threadIdx.x); base < NUM_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); auto grid_block = grid.ch(_0, blockno); int channelid = static_cast(base % NUM_VI_PER_BLOCK); char c = static_cast(channelid & 0x3f); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val; if(channelid == 0) { val = grid_block.val_1d(_1, c); } else if(channelid == 1) { val = grid_block.val_1d(_2, c); } else { val = grid_block.val_1d(_3, c); } g2pbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))] = val; } __syncthreads(); for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { int loc = base; char z = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char y = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char x = static_cast(loc & ARENAMASK); p2gbuffer[loc >> ARENABITS][x][y][z] = 0.0f; } __syncthreads(); for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < partition.particle_bucket_sizes[src_blockno]; particle_id_in_block += static_cast(blockDim.x)) { int advection_source_blockno; int source_pidib; ivec3 base_index; { int advect = partition.blockbuckets[src_blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, base_index); base_index += blockid; advection_source_blockno = prev_partition.query(base_index); source_pidib = advect & (config::G_PARTICLE_NUM_PER_BLOCK - 1); advection_source_blockno = prev_partition.bin_offsets[advection_source_blockno] + source_pidib / config::G_BIN_CAPACITY; } vec3 pos; float J; { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); J = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); } ivec3 local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; vec3 local_pos = pos - local_base_index * config::G_DX; base_index = local_base_index; vec3x3 dws; #pragma unroll 3 for(int dd = 0; dd < 3; ++dd) { float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = ((local_base_index[dd] - 1) & config::G_BLOCKMASK) + 1; } vec3 vel; vel.set(0.f); vec9 C; C.set(0.f); #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { vec3 xixp = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); vec3 vi {g2pbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)]}; vel += vi * W; C[0] += W * vi[0] * xixp[0]; C[1] += W * vi[1] * xixp[0]; C[2] += W * vi[2] * xixp[0]; C[3] += W * vi[0] * xixp[1]; C[4] += W * vi[1] * xixp[1]; C[5] += W * vi[2] * xixp[1]; C[6] += W * vi[0] * xixp[2]; C[7] += W * vi[1] * xixp[2]; C[8] += W * vi[2] * xixp[2]; } } } pos += vel * dt; J = (1 + (C[0] + C[4] + C[8]) * dt * config::G_D_INV) * J; if(J < 0.1) { J = 0.1; } vec9 contrib; { float voln = J * particle_buffer.volume; float pressure = particle_buffer.bulk * (powf(J, -particle_buffer.gamma) - 1.f); { contrib[0] = ((C[0] + C[0]) * config::G_D_INV * particle_buffer.viscosity - pressure) * voln; contrib[1] = (C[1] + C[3]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[2] = (C[2] + C[6]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[3] = (C[3] + C[1]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[4] = ((C[4] + C[4]) * config::G_D_INV * particle_buffer.viscosity - pressure) * voln; contrib[5] = (C[5] + C[7]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[6] = (C[6] + C[2]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[7] = (C[7] + C[5]) * config::G_D_INV * particle_buffer.viscosity * voln; contrib[8] = ((C[8] + C[8]) * config::G_D_INV * particle_buffer.viscosity - pressure) * voln; } contrib = (C * particle_buffer.mass - contrib * new_dt) * config::G_D_INV; { auto particle_bin = next_particle_buffer.ch(_0, partition.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = J; } } local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; { int dirtag = dir_offset((base_index - 1) / static_cast(config::G_BLOCKSIZE) - (local_base_index - 1) / static_cast(config::G_BLOCKSIZE)); partition.add_advection(local_base_index - 1, dirtag, particle_id_in_block); } // dws[d] = bspline_weight(local_pos[d]); #pragma unroll 3 for(char dd = 0; dd < 3; ++dd) { local_pos[dd] = pos[dd] - static_cast(local_base_index[dd]) * config::G_DX; float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = (((base_index[dd] - 1) & config::G_BLOCKMASK) + 1) + local_base_index[dd] - base_index[dd]; } #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { pos = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); auto wm = particle_buffer.mass * W; atomicAdd(&p2gbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm); atomicAdd(&p2gbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[0] + (contrib[0] * pos[0] + contrib[3] * pos[1] + contrib[6] * pos[2]) * W); atomicAdd(&p2gbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[1] + (contrib[1] * pos[0] + contrib[4] * pos[1] + contrib[7] * pos[2]) * W); atomicAdd(&p2gbuffer[3][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[2] + (contrib[2] * pos[0] + contrib[5] * pos[1] + contrib[8] * pos[2]) * W); } } } } __syncthreads(); /// arena no, channel no, cell no for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_M_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); // auto grid_block = next_grid.template ch<0>(blockno); int channelid = static_cast(base & (NUM_M_VI_PER_BLOCK - 1)); char c = static_cast(channelid % config::G_BLOCKVOLUME); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val = p2gbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))]; if(channelid == 0) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_0, c), val); } else if(channelid == 1) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_1, c), val); } else if(channelid == 2) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_2, c), val); } else { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_3, c), val); } } } template __global__ void g2p2g(float dt, float new_dt, const ivec3* __restrict__ blocks, const ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer, const Partition prev_partition, Partition partition, const Grid grid, Grid next_grid) { static constexpr uint64_t NUM_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 3; static constexpr uint64_t NUM_VI_IN_ARENA = NUM_VI_PER_BLOCK << 3; static constexpr uint64_t NUM_M_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 4; static constexpr uint64_t NUM_M_VI_IN_ARENA = NUM_M_VI_PER_BLOCK << 3; static constexpr unsigned ARENAMASK = (config::G_BLOCKSIZE << 1) - 1; static constexpr unsigned ARENABITS = config::G_BLOCKBITS + 1; using ViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>*; using ViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>&; using MViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>*; using MViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>&; extern __shared__ char shmem[];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here ViArenaRef __restrict__ g2pbuffer = *static_cast(static_cast(static_cast(shmem))); MViArenaRef __restrict__ p2gbuffer = *static_cast(static_cast(static_cast(shmem) + NUM_VI_IN_ARENA * sizeof(float))); ivec3 blockid; int src_blockno; if(blocks != nullptr) { blockid = blocks[blockIdx.x]; src_blockno = partition.query(blockid); } else { if(partition.halo_marks[blockIdx.x]) { return; } blockid = partition.active_keys[blockIdx.x]; int src_blockno = static_cast(blockIdx.x); int particle_bucket_size = next_particle_buffer.particle_bucket_sizes[src_blockno]; if(particle_bucket_size == 0) { return; } } for(int base = static_cast(threadIdx.x); base < NUM_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); auto grid_block = grid.ch(_0, blockno); int channelid = static_cast(base % NUM_VI_PER_BLOCK); char c = static_cast(channelid & 0x3f); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val; if(channelid == 0) { val = grid_block.val_1d(_1, c); } else if(channelid == 1) { val = grid_block.val_1d(_2, c); } else { val = grid_block.val_1d(_3, c); } g2pbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))] = val; } __syncthreads(); for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { int loc = static_cast(base); char z = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char y = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char x = static_cast(loc & ARENAMASK); p2gbuffer[loc >> ARENABITS][x][y][z] = 0.0f; } __syncthreads(); for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < partition.particle_bucket_sizes[src_blockno]; particle_id_in_block += static_cast(blockDim.x)) { int advection_source_blockno; int source_pidib; ivec3 base_index; { int advect = partition.blockbuckets[src_blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, base_index); base_index += blockid; advection_source_blockno = prev_partition.query(base_index); source_pidib = advect & (config::G_PARTICLE_NUM_PER_BLOCK - 1); advection_source_blockno = prev_partition.bin_offsets[advection_source_blockno] + source_pidib / config::G_BIN_CAPACITY; } vec3 pos; { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } ivec3 local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; vec3 local_pos = pos - local_base_index * config::G_DX; base_index = local_base_index; vec3x3 dws; #pragma unroll 3 for(int dd = 0; dd < 3; ++dd) { float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = ((local_base_index[dd] - 1) & config::G_BLOCKMASK) + 1; } vec3 vel; vel.set(0.f); vec9 C; C.set(0.f); #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { vec3 xixp = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); vec3 vi {g2pbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)]}; vel += vi * W; C[0] += W * vi[0] * xixp[0]; C[1] += W * vi[1] * xixp[0]; C[2] += W * vi[2] * xixp[0]; C[3] += W * vi[0] * xixp[1]; C[4] += W * vi[1] * xixp[1]; C[5] += W * vi[2] * xixp[1]; C[6] += W * vi[0] * xixp[2]; C[7] += W * vi[1] * xixp[2]; C[8] += W * vi[2] * xixp[2]; } } } pos += vel * dt; #pragma unroll 9 for(int d = 0; d < 9; ++d) { dws.val(d) = C[d] * dt * config::G_D_INV + ((d & 0x3) ? 0.f : 1.f); } vec9 contrib; { vec9 F; auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); contrib[0] = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); contrib[1] = source_particle_bin.val(_4, source_pidib % config::G_BIN_CAPACITY); contrib[2] = source_particle_bin.val(_5, source_pidib % config::G_BIN_CAPACITY); contrib[3] = source_particle_bin.val(_6, source_pidib % config::G_BIN_CAPACITY); contrib[4] = source_particle_bin.val(_7, source_pidib % config::G_BIN_CAPACITY); contrib[5] = source_particle_bin.val(_8, source_pidib % config::G_BIN_CAPACITY); contrib[6] = source_particle_bin.val(_9, source_pidib % config::G_BIN_CAPACITY); contrib[7] = source_particle_bin.val(_10, source_pidib % config::G_BIN_CAPACITY); contrib[8] = source_particle_bin.val(_11, source_pidib % config::G_BIN_CAPACITY); matrix_matrix_multiplication_3d(dws.data_arr(), contrib.data_arr(), F.data_arr()); { auto particle_bin = next_particle_buffer.ch(_0, partition.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = F[0]; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = F[1]; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = F[2]; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = F[3]; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = F[4]; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = F[5]; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = F[6]; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = F[7]; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = F[8]; } compute_stress_fixed_corotated(particle_buffer.volume, particle_buffer.mu, particle_buffer.lambda, F, contrib); contrib = (C * particle_buffer.mass - contrib * new_dt) * config::G_D_INV; } local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; { int dirtag = dir_offset((base_index - 1) / static_cast(config::G_BLOCKSIZE) - (local_base_index - 1) / static_cast(config::G_BLOCKSIZE)); partition.add_advection(local_base_index - 1, dirtag, particle_id_in_block); } // dws[d] = bspline_weight(local_pos[d]); #pragma unroll 3 for(char dd = 0; dd < 3; ++dd) { local_pos[dd] = pos[dd] - static_cast(local_base_index[dd]) * config::G_DX; float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = (((base_index[dd] - 1) & config::G_BLOCKMASK) + 1) + local_base_index[dd] - base_index[dd]; } #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { pos = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); auto wm = particle_buffer.mass * W; atomicAdd(&p2gbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm); atomicAdd(&p2gbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[0] + (contrib[0] * pos[0] + contrib[3] * pos[1] + contrib[6] * pos[2]) * W); atomicAdd(&p2gbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[1] + (contrib[1] * pos[0] + contrib[4] * pos[1] + contrib[7] * pos[2]) * W); atomicAdd(&p2gbuffer[3][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[2] + (contrib[2] * pos[0] + contrib[5] * pos[1] + contrib[8] * pos[2]) * W); } } } } __syncthreads(); /// arena no, channel no, cell no for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_M_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); // auto grid_block = next_grid.template ch<0>(blockno); int channelid = static_cast(base & (NUM_M_VI_PER_BLOCK - 1)); char c = static_cast(channelid % config::G_BLOCKVOLUME); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val = p2gbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))]; if(channelid == 0) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_0, c), val); } else if(channelid == 1) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_1, c), val); } else if(channelid == 2) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_2, c), val); } else { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_3, c), val); } } } template __global__ void g2p2g(float dt, float new_dt, const ivec3* __restrict__ blocks, const ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer, const Partition prev_partition, Partition partition, const Grid grid, Grid next_grid) { static constexpr uint64_t NUM_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 3; static constexpr uint64_t NUM_VI_IN_ARENA = NUM_VI_PER_BLOCK << 3; static constexpr uint64_t NUM_M_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 4; static constexpr uint64_t NUM_M_VI_IN_ARENA = NUM_M_VI_PER_BLOCK << 3; static constexpr unsigned ARENAMASK = (config::G_BLOCKSIZE << 1) - 1; static constexpr unsigned ARENABITS = config::G_BLOCKBITS + 1; using ViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>*; using ViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>&; using MViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>*; using MViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>&; extern __shared__ char shmem[];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here ViArenaRef __restrict__ g2pbuffer = *static_cast(static_cast(static_cast(shmem))); MViArenaRef __restrict__ p2gbuffer = *static_cast(static_cast(static_cast(shmem) + NUM_VI_IN_ARENA * sizeof(float))); ivec3 blockid; int src_blockno; if(blocks != nullptr) { blockid = blocks[blockIdx.x]; src_blockno = partition.query(blockid); } else { if(partition.halo_marks[blockIdx.x]) { return; } blockid = partition.active_keys[blockIdx.x]; int src_blockno = static_cast(blockIdx.x); int particle_bucket_size = next_particle_buffer.particle_bucket_sizes[src_blockno]; if(particle_bucket_size == 0) { return; } } for(int base = static_cast(threadIdx.x); base < NUM_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); auto grid_block = grid.ch(_0, blockno); int channelid = static_cast(base % NUM_VI_PER_BLOCK); char c = static_cast(channelid & 0x3f); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val; if(channelid == 0) { val = grid_block.val_1d(_1, c); } else if(channelid == 1) { val = grid_block.val_1d(_2, c); } else { val = grid_block.val_1d(_3, c); } g2pbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))] = val; } __syncthreads(); for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { int loc = static_cast(base); char z = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char y = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char x = static_cast(loc & ARENAMASK); p2gbuffer[loc >> ARENABITS][x][y][z] = 0.0f; } __syncthreads(); for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < partition.particle_bucket_sizes[src_blockno]; particle_id_in_block += static_cast(blockDim.x)) { int advection_source_blockno; int source_pidib; ivec3 base_index; { int advect = partition.blockbuckets[src_blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, base_index); base_index += blockid; advection_source_blockno = prev_partition.query(base_index); source_pidib = advect & (config::G_PARTICLE_NUM_PER_BLOCK - 1); advection_source_blockno = prev_partition.bin_offsets[advection_source_blockno] + source_pidib / config::G_BIN_CAPACITY; } vec3 pos; { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } ivec3 local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; vec3 local_pos = pos - local_base_index * config::G_DX; base_index = local_base_index; vec3x3 dws; #pragma unroll 3 for(int dd = 0; dd < 3; ++dd) { float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = ((local_base_index[dd] - 1) & config::G_BLOCKMASK) + 1; } vec3 vel; vel.set(0.f); vec9 C; C.set(0.f); #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { vec3 xixp = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); vec3 vi {g2pbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)]}; vel += vi * W; C[0] += W * vi[0] * xixp[0]; C[1] += W * vi[1] * xixp[0]; C[2] += W * vi[2] * xixp[0]; C[3] += W * vi[0] * xixp[1]; C[4] += W * vi[1] * xixp[1]; C[5] += W * vi[2] * xixp[1]; C[6] += W * vi[0] * xixp[2]; C[7] += W * vi[1] * xixp[2]; C[8] += W * vi[2] * xixp[2]; } } } pos += vel * dt; #pragma unroll 9 for(int d = 0; d < 9; ++d) { dws.val(d) = C[d] * dt * config::G_D_INV + ((d & 0x3) ? 0.f : 1.f); } vec9 contrib; { vec9 F; float log_jp; auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); contrib[0] = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); contrib[1] = source_particle_bin.val(_4, source_pidib % config::G_BIN_CAPACITY); contrib[2] = source_particle_bin.val(_5, source_pidib % config::G_BIN_CAPACITY); contrib[3] = source_particle_bin.val(_6, source_pidib % config::G_BIN_CAPACITY); contrib[4] = source_particle_bin.val(_7, source_pidib % config::G_BIN_CAPACITY); contrib[5] = source_particle_bin.val(_8, source_pidib % config::G_BIN_CAPACITY); contrib[6] = source_particle_bin.val(_9, source_pidib % config::G_BIN_CAPACITY); contrib[7] = source_particle_bin.val(_10, source_pidib % config::G_BIN_CAPACITY); contrib[8] = source_particle_bin.val(_11, source_pidib % config::G_BIN_CAPACITY); log_jp = source_particle_bin.val(_12, source_pidib % config::G_BIN_CAPACITY); matrix_matrix_multiplication_3d(dws.data_arr(), contrib.data_arr(), F.data_arr()); compute_stress_sand(particle_buffer.volume, particle_buffer.mu, particle_buffer.lambda, particle_buffer.cohesion, particle_buffer.beta, particle_buffer.yield_surface, particle_buffer.volume_correction, log_jp, F, contrib); { auto particle_bin = next_particle_buffer.ch(_0, partition.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = F[0]; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = F[1]; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = F[2]; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = F[3]; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = F[4]; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = F[5]; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = F[6]; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = F[7]; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = F[8]; particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = log_jp; } contrib = (C * particle_buffer.mass - contrib * new_dt) * config::G_D_INV; } local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; { int dirtag = dir_offset((base_index - 1) / static_cast(config::G_BLOCKSIZE) - (local_base_index - 1) / static_cast(config::G_BLOCKSIZE)); partition.add_advection(local_base_index - 1, dirtag, particle_id_in_block); } // dws[d] = bspline_weight(local_pos[d]); #pragma unroll 3 for(char dd = 0; dd < 3; ++dd) { local_pos[dd] = pos[dd] - static_cast(local_base_index[dd]) * config::G_DX; float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = (((base_index[dd] - 1) & config::G_BLOCKMASK) + 1) + local_base_index[dd] - base_index[dd]; } #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { pos = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); auto wm = particle_buffer.mass * W; atomicAdd(&p2gbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm); atomicAdd(&p2gbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[0] + (contrib[0] * pos[0] + contrib[3] * pos[1] + contrib[6] * pos[2]) * W); atomicAdd(&p2gbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[1] + (contrib[1] * pos[0] + contrib[4] * pos[1] + contrib[7] * pos[2]) * W); atomicAdd(&p2gbuffer[3][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[2] + (contrib[2] * pos[0] + contrib[5] * pos[1] + contrib[8] * pos[2]) * W); } } } } __syncthreads(); /// arena no, channel no, cell no for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_M_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); // auto grid_block = next_grid.template ch<0>(blockno); int channelid = static_cast(base & (NUM_M_VI_PER_BLOCK - 1)); char c = static_cast(channelid % config::G_BLOCKVOLUME); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val = p2gbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))]; if(channelid == 0) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_0, c), val); } else if(channelid == 1) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_1, c), val); } else if(channelid == 2) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_2, c), val); } else { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_3, c), val); } } } template __global__ void g2p2g(float dt, float new_dt, const ivec3* __restrict__ blocks, const ParticleBuffer particle_buffer, ParticleBuffer next_particle_buffer, const Partition prev_partition, Partition partition, const Grid grid, Grid next_grid) { static constexpr uint64_t NUM_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 3; static constexpr uint64_t NUM_VI_IN_ARENA = NUM_VI_PER_BLOCK << 3; static constexpr uint64_t NUM_M_VI_PER_BLOCK = static_cast(config::G_BLOCKVOLUME) * 4; static constexpr uint64_t NUM_M_VI_IN_ARENA = NUM_M_VI_PER_BLOCK << 3; static constexpr unsigned ARENAMASK = (config::G_BLOCKSIZE << 1) - 1; static constexpr unsigned ARENABITS = config::G_BLOCKBITS + 1; using ViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>*; using ViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 3>&; using MViArena = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>*; using MViArenaRef = std::array, config::G_BLOCKSIZE << 1>, config::G_BLOCKSIZE << 1>, 4>&; extern __shared__ char shmem[];//NOLINT(modernize-avoid-c-arrays, readability-redundant-declaration) Cannot declare runtime size shared memory as std::array; extern has different meaning here ViArenaRef __restrict__ g2pbuffer = *static_cast(static_cast(static_cast(shmem))); MViArenaRef __restrict__ p2gbuffer = *static_cast(static_cast(static_cast(shmem) + NUM_VI_IN_ARENA * sizeof(float))); ivec3 blockid; int src_blockno; if(blocks != nullptr) { blockid = blocks[blockIdx.x]; src_blockno = partition.query(blockid); } else { if(partition.halo_marks[blockIdx.x]) { return; } blockid = partition.active_keys[blockIdx.x]; int src_blockno = static_cast(blockIdx.x); int particle_bucket_size = next_particle_buffer.particle_bucket_sizes[src_blockno]; if(particle_bucket_size == 0) { return; } } for(int base = static_cast(threadIdx.x); base < NUM_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); auto grid_block = grid.ch(_0, blockno); int channelid = static_cast(base % NUM_VI_PER_BLOCK); char c = static_cast(channelid & 0x3f); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val; if(channelid == 0) { val = grid_block.val_1d(_1, c); } else if(channelid == 1) { val = grid_block.val_1d(_2, c); } else { val = grid_block.val_1d(_3, c); } g2pbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))] = val; } __syncthreads(); for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { int loc = static_cast(base); char z = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char y = static_cast(loc & ARENAMASK); loc >>= ARENABITS; char x = static_cast(loc & ARENAMASK); p2gbuffer[loc >> ARENABITS][x][y][z] = 0.0f; } __syncthreads(); for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < partition.particle_bucket_sizes[src_blockno]; particle_id_in_block += static_cast(blockDim.x)) { int advection_source_blockno; int source_pidib; ivec3 base_index; { int advect = partition.blockbuckets[src_blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, base_index); base_index += blockid; advection_source_blockno = prev_partition.query(base_index); source_pidib = advect & (config::G_PARTICLE_NUM_PER_BLOCK - 1); advection_source_blockno = prev_partition.bin_offsets[advection_source_blockno] + source_pidib / config::G_BIN_CAPACITY; } vec3 pos; { auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); pos[0] = source_particle_bin.val(_0, source_pidib % config::G_BIN_CAPACITY); pos[1] = source_particle_bin.val(_1, source_pidib % config::G_BIN_CAPACITY); pos[2] = source_particle_bin.val(_2, source_pidib % config::G_BIN_CAPACITY); } ivec3 local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; vec3 local_pos = pos - local_base_index * config::G_DX; base_index = local_base_index; vec3x3 dws; #pragma unroll 3 for(int dd = 0; dd < 3; ++dd) { float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = ((local_base_index[dd] - 1) & config::G_BLOCKMASK) + 1; } vec3 vel; vel.set(0.f); vec9 C; C.set(0.f); #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { vec3 xixp = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); vec3 vi {g2pbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], g2pbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)]}; vel += vi * W; C[0] += W * vi[0] * xixp[0]; C[1] += W * vi[1] * xixp[0]; C[2] += W * vi[2] * xixp[0]; C[3] += W * vi[0] * xixp[1]; C[4] += W * vi[1] * xixp[1]; C[5] += W * vi[2] * xixp[1]; C[6] += W * vi[0] * xixp[2]; C[7] += W * vi[1] * xixp[2]; C[8] += W * vi[2] * xixp[2]; } } } pos += vel * dt; #pragma unroll 9 for(int d = 0; d < 9; ++d) { dws.val(d) = C[d] * dt * config::G_D_INV + ((d & 0x3) ? 0.f : 1.f); } vec9 contrib; { vec9 F; float log_jp; auto source_particle_bin = particle_buffer.ch(_0, advection_source_blockno); contrib[0] = source_particle_bin.val(_3, source_pidib % config::G_BIN_CAPACITY); contrib[1] = source_particle_bin.val(_4, source_pidib % config::G_BIN_CAPACITY); contrib[2] = source_particle_bin.val(_5, source_pidib % config::G_BIN_CAPACITY); contrib[3] = source_particle_bin.val(_6, source_pidib % config::G_BIN_CAPACITY); contrib[4] = source_particle_bin.val(_7, source_pidib % config::G_BIN_CAPACITY); contrib[5] = source_particle_bin.val(_8, source_pidib % config::G_BIN_CAPACITY); contrib[6] = source_particle_bin.val(_9, source_pidib % config::G_BIN_CAPACITY); contrib[7] = source_particle_bin.val(_10, source_pidib % config::G_BIN_CAPACITY); contrib[8] = source_particle_bin.val(_11, source_pidib % config::G_BIN_CAPACITY); log_jp = source_particle_bin.val(_12, source_pidib % config::G_BIN_CAPACITY); matrix_matrix_multiplication_3d(dws.data_arr(), contrib.data_arr(), F.data_arr()); compute_stress_nacc(particle_buffer.volume, particle_buffer.mu, particle_buffer.lambda, particle_buffer.bm, particle_buffer.xi, particle_buffer.beta, particle_buffer.msqr, particle_buffer.hardening_on, log_jp, F, contrib); { auto particle_bin = next_particle_buffer.ch(_0, partition.bin_offsets[src_blockno] + particle_id_in_block / config::G_BIN_CAPACITY); particle_bin.val(_0, particle_id_in_block % config::G_BIN_CAPACITY) = pos[0]; particle_bin.val(_1, particle_id_in_block % config::G_BIN_CAPACITY) = pos[1]; particle_bin.val(_2, particle_id_in_block % config::G_BIN_CAPACITY) = pos[2]; particle_bin.val(_3, particle_id_in_block % config::G_BIN_CAPACITY) = F[0]; particle_bin.val(_4, particle_id_in_block % config::G_BIN_CAPACITY) = F[1]; particle_bin.val(_5, particle_id_in_block % config::G_BIN_CAPACITY) = F[2]; particle_bin.val(_6, particle_id_in_block % config::G_BIN_CAPACITY) = F[3]; particle_bin.val(_7, particle_id_in_block % config::G_BIN_CAPACITY) = F[4]; particle_bin.val(_8, particle_id_in_block % config::G_BIN_CAPACITY) = F[5]; particle_bin.val(_9, particle_id_in_block % config::G_BIN_CAPACITY) = F[6]; particle_bin.val(_10, particle_id_in_block % config::G_BIN_CAPACITY) = F[7]; particle_bin.val(_11, particle_id_in_block % config::G_BIN_CAPACITY) = F[8]; particle_bin.val(_12, particle_id_in_block % config::G_BIN_CAPACITY) = log_jp; } contrib = (C * particle_buffer.mass - contrib * new_dt) * config::G_D_INV; } local_base_index = (pos * config::G_DX_INV + 0.5f).cast() - 1; { int dirtag = dir_offset((base_index - 1) / static_cast(config::G_BLOCKSIZE) - (local_base_index - 1) / static_cast(config::G_BLOCKSIZE)); partition.add_advection(local_base_index - 1, dirtag, particle_id_in_block); } // dws[d] = bspline_weight(local_pos[d]); #pragma unroll 3 for(char dd = 0; dd < 3; ++dd) { local_pos[dd] = pos[dd] - static_cast(local_base_index[dd]) * config::G_DX; float d = (local_pos[dd] - static_cast(std::floor(local_pos[dd] * config::G_DX_INV + 0.5f) - 1) * config::G_DX) * config::G_DX_INV; dws(dd, 0) = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dws(dd, 1) = 0.75f - d * d; d = 0.5f + d; dws(dd, 2) = 0.5f * d * d; local_base_index[dd] = (((base_index[dd] - 1) & config::G_BLOCKMASK) + 1) + local_base_index[dd] - base_index[dd]; } #pragma unroll 3 for(char i = 0; i < 3; i++) { #pragma unroll 3 for(char j = 0; j < 3; j++) { #pragma unroll 3 for(char k = 0; k < 3; k++) { pos = vec3 {static_cast(i), static_cast(j), static_cast(k)} * config::G_DX - local_pos; float W = dws(0, i) * dws(1, j) * dws(2, k); auto wm = particle_buffer.mass * W; atomicAdd(&p2gbuffer[0][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm); atomicAdd(&p2gbuffer[1][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[0] + (contrib[0] * pos[0] + contrib[3] * pos[1] + contrib[6] * pos[2]) * W); atomicAdd(&p2gbuffer[2][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[1] + (contrib[1] * pos[0] + contrib[4] * pos[1] + contrib[7] * pos[2]) * W); atomicAdd(&p2gbuffer[3][static_cast(static_cast(local_base_index[0]) + i)][static_cast(static_cast(local_base_index[1]) + j)][static_cast(static_cast(local_base_index[2]) + k)], wm * vel[2] + (contrib[2] * pos[0] + contrib[5] * pos[1] + contrib[8] * pos[2]) * W); } } } } __syncthreads(); /// arena no, channel no, cell no for(int base = static_cast(threadIdx.x); base < NUM_M_VI_IN_ARENA; base += static_cast(blockDim.x)) { char local_block_id = static_cast(base / NUM_M_VI_PER_BLOCK); auto blockno = partition.query(ivec3 {blockid[0] + ((local_block_id & 4) != 0 ? 1 : 0), blockid[1] + ((local_block_id & 2) != 0 ? 1 : 0), blockid[2] + ((local_block_id & 1) != 0 ? 1 : 0)}); // auto grid_block = next_grid.template ch<0>(blockno); int channelid = static_cast(base & (NUM_M_VI_PER_BLOCK - 1)); char c = static_cast(channelid % config::G_BLOCKVOLUME); char cz = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cy = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; char cx = static_cast(channelid & config::G_BLOCKMASK); channelid >>= config::G_BLOCKBITS; float val = p2gbuffer[channelid][static_cast(static_cast(cx) + (local_block_id & 4 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cy) + (local_block_id & 2 ? config::G_BLOCKSIZE : 0))][static_cast(static_cast(cz) + (local_block_id & 1 ? config::G_BLOCKSIZE : 0))]; if(channelid == 0) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_0, c), val); } else if(channelid == 1) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_1, c), val); } else if(channelid == 2) { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_2, c), val); } else { atomicAdd(&next_grid.ch(_0, blockno).val_1d(_3, c), val); } } } template __global__ void mark_active_grid_blocks(uint32_t block_count, const Grid grid, int* marks) { auto idx = blockIdx.x * blockDim.x + threadIdx.x; int blockno = static_cast(idx / config::G_BLOCKVOLUME); int cellno = static_cast(idx % config::G_BLOCKVOLUME); if(blockno >= block_count) { return; } if(grid.ch(_0, blockno).val_1d(_0, cellno) != 0.f) { marks[blockno] = 1; } } __global__ void mark_active_particle_blocks(uint32_t block_count, const int* __restrict__ particle_bucket_sizes, int* marks) { const std::size_t blockno = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } marks[blockno] = particle_bucket_sizes[blockno] > 0 ? 1 : 0; } template __global__ void update_partition(uint32_t block_count, const int* __restrict__ source_nos, const Partition partition, Partition next_partition) { __shared__ std::size_t source_no[1];//NOLINT(modernize-avoid-c-arrays) Cannot declare shared memory as std::array? std::size_t blockno = blockIdx.x; if(blockno >= block_count) { return; } if(threadIdx.x == 0) { source_no[0] = source_nos[blockno]; auto source_blockid = partition.active_keys[source_no[0]]; next_partition.active_keys[blockno] = source_blockid; next_partition.reinsert(static_cast(blockno)); next_partition.particle_bucket_sizes[blockno] = partition.particle_bucket_sizes[source_no[0]]; } __syncthreads(); auto particle_counts = next_partition.particle_bucket_sizes[blockno]; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { next_partition.blockbuckets[blockno * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block] = partition.blockbuckets[source_no[0] * config::G_PARTICLE_NUM_PER_BLOCK + particle_id_in_block]; } } template __global__ void copy_selected_grid_blocks(const ivec3* __restrict__ prev_blockids, const Partition partition, const int* __restrict__ marks, Grid prev_grid, Grid grid) { auto blockid = prev_blockids[blockIdx.x]; if(marks[blockIdx.x]) { auto blockno = partition.query(blockid); if(blockno == -1) { return; } auto sourceblock = prev_grid.ch(_0, blockIdx.x); auto targetblock = grid.ch(_0, blockno); targetblock.val_1d(_0, threadIdx.x) = sourceblock.val_1d(_0, threadIdx.x); targetblock.val_1d(_1, threadIdx.x) = sourceblock.val_1d(_1, threadIdx.x); targetblock.val_1d(_2, threadIdx.x) = sourceblock.val_1d(_2, threadIdx.x); targetblock.val_1d(_3, threadIdx.x) = sourceblock.val_1d(_3, threadIdx.x); } } template __global__ void check_table(uint32_t block_count, Partition partition) { uint32_t blockno = blockIdx.x * blockDim.x + threadIdx.x; if(blockno >= block_count) { return; } auto blockid = partition.active_keys[blockno]; if(partition.query(blockid) != blockno) printf("FUCK, partition table is wrong!\n"); } template __global__ void sum_grid_mass(Grid grid, float* sum) { atomicAdd(sum, grid.ch(_0, blockIdx.x).val_1d(_0, threadIdx.x)); } __global__ void sum_particle_counts(uint32_t count, int* __restrict__ counts, int* sum) { auto idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= count) { return; } atomicAdd(sum, counts[idx]); } template __global__ void check_partition(uint32_t block_count, Partition partition) { int idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= block_count) { return; } ivec3 blockid = partition.active_keys[idx]; if(blockid[0] == 0 || blockid[1] == 0 || blockid[2] == 0) { printf("\tDAMN, encountered zero block record\n"); } if(partition.query(blockid) != idx) { int id = partition.query(blockid); ivec3 bid = partition.active_keys[id]; printf( "\t\tcheck partition %d, (%d, %d, %d), feedback index %d, (%d, %d, " "%d)\n", idx, (int) blockid[0], (int) blockid[1], (int) blockid[2], id, bid[0], bid[1], bid[2] ); } } template __global__ void check_partition_domain(uint32_t block_count, int did, Domain const domain, Partition partition) { int idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= block_count) { return; } ivec3 blockid = partition.active_keys[idx]; if(domain.inside(blockid)) { printf("%d-th block (%d, %d, %d) is in domain[%d] (%d, %d, %d)-(%d, %d, %d)\n", idx, blockid[0], blockid[1], blockid[2], did, domain._min[0], domain._min[1], domain._min[2], domain._max[0], domain._max[1], domain._max[2]); } } template __global__ void retrieve_particle_buffer(Partition partition, Partition prev_partition, ParticleBuffer particle_buffer, ParticleArray particle_array, int* parcount) { int particle_counts = partition.particle_bucket_sizes[blockIdx.x]; ivec3 blockid = partition.active_keys[blockIdx.x]; auto advection_bucket = partition.blockbuckets + blockIdx.x * config::G_PARTICLE_NUM_PER_BLOCK; // auto particle_offset = partition.bin_offsets[blockIdx.x]; for(int particle_id_in_block = static_cast(threadIdx.x); particle_id_in_block < particle_counts; particle_id_in_block += static_cast(blockDim.x)) { auto advect = advection_bucket[particle_id_in_block]; ivec3 source_blockid; dir_components(advect / config::G_PARTICLE_NUM_PER_BLOCK, source_blockid); source_blockid += blockid; auto advection_source_blockno = prev_partition.query(source_blockid); auto source_pidib = advect % config::G_PARTICLE_NUM_PER_BLOCK; auto source_bin = particle_buffer.ch(_0, prev_partition.bin_offsets[advection_source_blockno] + source_pidib / config::G_BIN_CAPACITY); auto _source_pidib = source_pidib % config::G_BIN_CAPACITY; auto particle_id = atomicAdd(parcount, 1); /// pos particle_array.val(_0, particle_id) = source_bin.val(_0, _source_pidib); particle_array.val(_1, particle_id) = source_bin.val(_1, _source_pidib); particle_array.val(_2, particle_id) = source_bin.val(_2, _source_pidib); } } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers, readability-identifier-naming, misc-definitions-in-headers) }// namespace mn #endif ================================================ FILE: Projects/MGSP/mgsp.cu ================================================ #include #include #include #include #include #include "mgsp_benchmark.cuh" #include "partition_domain.h" // dragon_particles.bin, 775196 // cube256_2.bin, 1048576 // two_dragons.bin, 388950 constexpr size_t DRAGON_PARTICLES_SIZE = 775196; constexpr size_t CUBE_256_2_SIZE = 1048576; constexpr size_t TWO_DRAGONS_SIZE = 388950; constexpr size_t SCENARIO = 3; decltype(auto) load_model(std::size_t particle_counts, const std::string& filename) { std::vector> rawpos(particle_counts); auto addr_str = std::string(AssetDirPath) + "MpmParticles/"; FILE* f; fopen_s(&f, (addr_str + filename).c_str(), "rb"); std::fread(rawpos.data(), sizeof(float), rawpos.size() * mn::config::NUM_DIMENSIONS, f); std::fclose(f); return rawpos; } //NOLINTBEGIN(readability-magic-numbers) Numbers are scenario parameters // load from analytic levelset // init models void init_models(std::array>, mn::config::G_DEVICE_COUNT> models, int opt = 0) { (void) DRAGON_PARTICLES_SIZE; (void) CUBE_256_2_SIZE; (void) TWO_DRAGONS_SIZE; switch(opt) { case 0: models[0] = load_model(DRAGON_PARTICLES_SIZE, "dragon_particles.bin"); models[1] = read_sdf(std::string {"two_dragons.sdf"}, 8.f, mn::config::G_DX, mn::vec {0.5f, 0.5f, 0.5f}, mn::vec {0.2f, 0.2f, 0.2f}); break; case 1: models[0] = load_model(DRAGON_PARTICLES_SIZE, "dragon_particles.bin"); models[1] = load_model(DRAGON_PARTICLES_SIZE, "dragon_particles.bin"); for(auto& pt: models[1]) { pt[1] -= 0.3f; } break; case 2: { constexpr auto LEN = 54; constexpr auto STRIDE = 56; constexpr auto MODEL_COUNT = 1; for(int did = 0; did < mn::config::G_DEVICE_COUNT; ++did) { models[did].clear(); std::vector> model; for(int i = 0; i < MODEL_COUNT; ++i) { auto idx = (did * MODEL_COUNT + i); model = sample_uniform_box(mn::config::G_DX, mn::ivec3 {18 + ((idx & 1) != 0 ? STRIDE : 0), 18, 18}, mn::ivec3 {18 + ((idx & 1) != 0 ? STRIDE : 0) + LEN, 18 + LEN, 18 + LEN}); models[did].insert(models[did].end(), model.begin(), model.end()); } } } break; case 3: { constexpr auto LEN = 72;// 54; constexpr auto STRIDE = (mn::config::G_DOMAIN_SIZE / 2); constexpr auto MODEL_COUNT = 1; for(int did = 0; did < mn::config::G_DEVICE_COUNT; ++did) { models[did].clear(); std::vector> model; for(int i = 0; i < MODEL_COUNT; ++i) { auto idx = (did * MODEL_COUNT + i); model = sample_uniform_box(mn::config::G_DX, mn::ivec3 {18 + ((idx & 1) != 0 ? STRIDE : 0), 18, 18 + ((idx & 2) != 0 ? STRIDE : 0)}, mn::ivec3 {18 + ((idx & 1) != 0 ? STRIDE : 0) + LEN, 18 + LEN / 3, 18 + ((idx & 2) != 0 ? STRIDE : 0) + LEN}); models[did].insert(models[did].end(), model.begin(), model.end()); } } } break; default: break; } } //NOLINTEND(readability-magic-numbers) int main() { mn::Cuda::startup(); std::array>, mn::config::G_DEVICE_COUNT> models; auto benchmark = std::make_unique(); /// init init_models(models, SCENARIO); for(int did = 0; did < mn::config::G_DEVICE_COUNT; ++did) { benchmark->init_model(did, models[did]); } // benchmark->init_boundary("candy_base"); benchmark->main_loop(); /// mn::IO::flush(); benchmark.reset(); /// mn::Cuda::shutdown(); return 0; } ================================================ FILE: Projects/MGSP/mgsp_benchmark.cuh ================================================ #ifndef MGSP_BENCHMARK_CUH #define MGSP_BENCHMARK_CUH #include #include #include #include #include #include #include #include #include #include #include #include #include "boundary_condition.cuh" #include "grid_buffer.cuh" #include "halo_buffer.cuh" #include "halo_kernels.cuh" #include "hash_table.cuh" #include "mgmpm_kernels.cuh" #include "particle_buffer.cuh" #include "settings.h" namespace mn { struct MgspBenchmark { static constexpr float DEFAULT_DT = 1e-4; static constexpr int DEFAULT_FPS = 24; static constexpr size_t BIN_COUNT = 2; using streamIdx = Cuda::StreamIndex; using eventIdx = Cuda::EventIndex; using host_allocator = HeapAllocator; struct DeviceAllocator { // hide the global one void* allocate(std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member void* ret = nullptr; check_cuda_errors(cudaMalloc(&ret, bytes)); return ret; } void deallocate(void* p, std::size_t size) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) size; check_cuda_errors(cudaFree(p)); } }; struct TempAllocator { int did; explicit TempAllocator(int did) : did {did} {} void* allocate(std::size_t bytes) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member return Cuda::ref_cuda_context(did).borrow(bytes); } void deallocate(void* p, std::size_t size) {//NOLINT(readability-convert-member-functions-to-static) Method is designed to be a non-static class member (void) p; (void) size; } }; struct Intermediates { void* base; int* d_tmp; int* active_block_marks; int* destinations; int* sources; int* bin_sizes; float* d_max_vel; //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) Current c++ version does not yet support std::span void alloc(size_t max_block_count) { //NOLINTBEGIN(readability-magic-numbers) Magic numbers are variable count check_cuda_errors(cudaMalloc(&base, sizeof(int) * (max_block_count * 5 + 1))); d_tmp = static_cast(base); active_block_marks = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count)); destinations = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 2)); sources = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 3)); bin_sizes = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 4)); d_max_vel = static_cast(static_cast(static_cast(base) + sizeof(int) * max_block_count * 5)); //NOLINTEND(readability-magic-numbers) } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) void dealloc() const { cudaDeviceSynchronize(); check_cuda_errors(cudaFree(base)); } void resize(size_t max_block_count) { dealloc(); alloc(max_block_count); } }; /// /// animation runtime settings float dt; float next_dt; float dt_default; float cur_time; float max_vel; uint64_t cur_frame; uint64_t cur_step; uint64_t fps; /// data on device, double buffering std::vector> collision_objs; std::array, BIN_COUNT> grid_blocks; std::array, BIN_COUNT> particle_bins; std::array>, BIN_COUNT> partitions;///< with halo info std::vector input_halo_grid_blocks; std::vector output_halo_grid_blocks; // std::vector inputHaloParticleBlocks, // outputHaloParticleBlocks; vec particles; std::array tmps = {}; // halo data vec halo_block_ids; /// data on host static_assert(std::is_same_v, "block index type is not int"); char rollid; std::array cur_num_active_blocks = {}; std::array cur_num_active_bins = {}; std::array, config::G_DEVICE_COUNT> checked_counts = {}; vec max_vels; vec partition_block_count; vec nbcount; vec exterior_block_count; vec bincount; ///< num blocks vec particle_counts;///< num particles std::array, config::G_DEVICE_COUNT + 1> durations; std::array>, config::G_DEVICE_COUNT> models; Instance host_data; /// control bool b_running; std::array>, config::G_DEVICE_COUNT> jobs; std::array ths;///< thread is not trivial std::mutex mut_slave; std::mutex mut_ctrl; std::condition_variable cv_slave; std::condition_variable cv_ctrl; std::atomic_uint idle_count {0}; /// computations per substep std::vector> init_tasks; std::vector> loop_tasks; MgspBenchmark() : dt() , next_dt() , dt_default(DEFAULT_DT) , cur_time(0.f) , max_vel() , rollid(0) , cur_frame(0) , cur_step(0) , fps(DEFAULT_FPS) , host_data() , b_running(true) { // data host_data = spawn(host_allocator {}); collision_objs.resize(config::G_DEVICE_COUNT); init_particles<0>(); fmt::print( "{} -vs- {}\n", match(particle_bins[0][0])([&](auto& particle_buffer) { return particle_buffer.size; }), match(particle_bins[0][1])([&](auto& particle_buffer) { return particle_buffer.size; }) ); // tasks for(int did = 0; did < config::G_DEVICE_COUNT; ++did) { ths[did] = std::thread( [this](int did) { this->gpu_worker(did); }, did ); } } ~MgspBenchmark() { auto is_empty = [this]() { for(int did = 0; did < config::G_DEVICE_COUNT; ++did) { if(!jobs[did].empty()) { return false; } } return true; }; do { cv_slave.notify_all(); } while(!is_empty()); b_running = false; for(auto& th: ths) { th.join(); } } //TODO: Maybe implement? MgspBenchmark(MgspBenchmark& other) = delete; MgspBenchmark(MgspBenchmark&& other) = delete; MgspBenchmark& operator=(MgspBenchmark& other) = delete; MgspBenchmark& operator=(MgspBenchmark&& other) = delete; template void init_particles() { auto& cu_dev = Cuda::ref_cuda_context(I); cu_dev.set_context(); tmps[I].alloc(config::G_MAX_ACTIVE_BLOCK); for(int copyid = 0; copyid < BIN_COUNT; copyid++) { grid_blocks[copyid].emplace_back(DeviceAllocator {}); particle_bins[copyid].emplace_back(ParticleBuffer {DeviceAllocator {}}); partitions[copyid].emplace_back(DeviceAllocator {}, config::G_MAX_ACTIVE_BLOCK); } cu_dev.syncStream(); input_halo_grid_blocks.emplace_back(config::G_DEVICE_COUNT); output_halo_grid_blocks.emplace_back(config::G_DEVICE_COUNT); particles[I] = static_cast(spawn(DeviceAllocator {})); checked_counts[I][0] = 0; checked_counts[I][1] = 0; cur_num_active_blocks[I] = config::G_MAX_ACTIVE_BLOCK; cur_num_active_bins[I] = config::G_MAX_PARTICLE_BIN; /// tail-recursion optimization if constexpr(I + 1 < config::G_DEVICE_COUNT) { init_particles(); } } void init_model(int devid, const std::vector>& model) { auto& cu_dev = Cuda::ref_cuda_context(devid); cu_dev.set_context(); particle_counts[devid] = model.size(); fmt::print("init model[{}] with {} particles\n", devid, particle_counts[devid]); cudaMemcpyAsync(static_cast(&particles[devid].val_1d(_0, 0)), model.data(), sizeof(std::array) * model.size(), cudaMemcpyDefault, cu_dev.stream_compute()); cu_dev.syncStream(); std::string fn = std::string {"model"} + "_dev[" + std::to_string(devid) + "]_frame[0].bgeo"; IO::insert_job([fn, model]() { write_partio(fn, model); }); IO::flush(); } //TODO: Check magic numbers and replace by constants //NOLINTBEGIN(readability-magic-numbers) void init_boundary(const std::string& fn) { init_from_signed_distance_file(fn, vec {static_cast(1024), static_cast(1024), static_cast(512)}, host_data); for(int did = 0; did < config::G_DEVICE_COUNT; ++did) { auto& cu_dev = Cuda::ref_cuda_context(did); cu_dev.set_context(); collision_objs[did] = SignedDistanceGrid {DeviceAllocator {}}; collision_objs[did]->init(host_data, cu_dev.stream_compute()); cu_dev.syncStream(); } } //NOLINTEND(readability-magic-numbers) template void exclusive_scan(int count, int const* const in, int* out, CudaContext& cu_dev) { //TODO:Not sure, what it does. Maybe remove or create names control macro for activation #if 1//NOLINT(readability-avoid-unconditional-preprocessor-if) auto policy = thrust::cuda::par.on(static_cast(cu_dev.stream_compute())); thrust::exclusive_scan(policy, get_device_ptr(in), get_device_ptr(in) + count, get_device_ptr(out)); #else std::size_t temp_storage_bytes = 0; auto plus_op = [] __device__(const int& a, const int& b) { return a + b; }; check_cuda_errors(cub::DeviceScan::ExclusiveScan(nullptr, temp_storage_bytes, in, out, plus_op, 0, count, cu_dev.stream_compute())); void* d_tmp = tmps[cu_dev.get_dev_id()].d_tmp; check_cuda_errors(cub::DeviceScan::ExclusiveScan(d_tmp, temp_storage_bytes, in, out, plus_op, 0, count, cu_dev.stream_compute())); #endif } float get_mass(int did) { return match(particle_bins[rollid][did])([&](const auto& particle_buffer) { return particle_buffer.mass; }); } void check_capacity(int did) { //TODO: Is that right? Maybe create extra parameter for this? //NOLINTBEGIN(readability-magic-numbers) Magic numbers are resize thresholds? if(exterior_block_count[did] > cur_num_active_blocks[did] * config::NUM_DIMENSIONS / 4 && checked_counts[did][0] == 0) { cur_num_active_blocks[did] = cur_num_active_blocks[did] * config::NUM_DIMENSIONS / 2; checked_counts[did][0] = 2; fmt::print(fmt::emphasis::bold, "resizing blocks {} -> {}\n", exterior_block_count[did], cur_num_active_blocks[did]); } if(bincount[did] > cur_num_active_bins[did] * config::NUM_DIMENSIONS / 4 && checked_counts[did][1] == 0) { cur_num_active_bins[did] = cur_num_active_bins[did] * config::NUM_DIMENSIONS / 2; checked_counts[did][1] = 2; fmt::print(fmt::emphasis::bold, "resizing bins {} -> {}\n", bincount[did], cur_num_active_bins[did]); } //NOLINTEND(readability-magic-numbers) } /// thread local ctrl flow void gpu_worker(int did) { auto wait = [did, this]() { std::unique_lock lk {this->mut_slave}; this->cv_slave.wait(lk, [did, this]() { return !this->b_running || !this->jobs[did].empty(); }); }; auto signal = [this]() { std::unique_lock lk {this->mut_ctrl}; this->idle_count.fetch_add(1); lk.unlock(); this->cv_ctrl.notify_one(); }; auto& cu_dev = Cuda::ref_cuda_context(did); cu_dev.set_context(); fmt::print(fg(fmt::color::light_blue), "{}-th gpu worker operates on GPU {}\n", did, cu_dev.get_dev_id()); while(this->b_running) { wait(); auto job = this->jobs[did].try_pop(); if(job) { (*job)(did); } signal(); } fmt::print(fg(fmt::color::light_blue), "{}-th gpu worker exits\n", did); } void sync() { std::unique_lock lk {mut_ctrl}; cv_ctrl.wait(lk, [this]() { return this->idle_count == config::G_DEVICE_COUNT; }); fmt::print( fmt::emphasis::bold, "-----------------------------------------------------------" "-----\n" ); } void issue(const std::function& job) { std::unique_lock lk {mut_slave}; for(int did = 0; did < config::G_DEVICE_COUNT; ++did) { jobs[did].push(job); } idle_count = 0; lk.unlock(); cv_slave.notify_all(); } //FIXME: no signed integer bitwise operations! (rollid) //TODO: Check magic numbers and replace by constants //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers) Current c++ version does not yet support std::span void main_loop() { /// initial const float initial_next_time = 1.0f / static_cast(fps); dt = compute_dt(0.0f, cur_time, initial_next_time, dt_default); fmt::print(fmt::emphasis::bold, "{} --{}--> {}, defaultDt: {}\n", cur_time, dt, initial_next_time, dt_default); initial_setup(); cur_time = dt; for(cur_frame = 1; cur_frame <= config::G_TOTAL_FRAME_COUNT; ++cur_frame) { const float next_time = static_cast(cur_frame) / static_cast(fps); for(; cur_time < next_time; cur_time += dt, cur_step++) { /// max grid vel issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); /// check capacity check_capacity(did); float* d_max_vel = tmps[did].d_max_vel; CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); check_cuda_errors(cudaMemsetAsync(d_max_vel, 0, sizeof(float), cu_dev.stream_compute())); if(collision_objs[did]) { cu_dev.compute_launch( {(nbcount[did] + config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK - 1) / config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK, config::G_NUM_WARPS_PER_CUDA_BLOCK * 32, config::G_NUM_WARPS_PER_CUDA_BLOCK}, update_grid_velocity_query_max, static_cast(nbcount[did]), // grid_blocks[0][did], partitions[rollid][did], dt, d_max_vel); grid_blocks[0][did], partitions[rollid][did], dt, static_cast(*collision_objs[did]), d_max_vel ); } else { cu_dev.compute_launch( {(nbcount[did] + config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK - 1) / config::G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK, config::G_NUM_WARPS_PER_CUDA_BLOCK * 32, config::G_NUM_WARPS_PER_CUDA_BLOCK}, update_grid_velocity_query_max, static_cast(nbcount[did]), // grid_blocks[0][did], partitions[rollid][did], dt, d_max_vel); grid_blocks[0][did], partitions[rollid][did], dt, d_max_vel ); } check_cuda_errors(cudaMemcpyAsync(&max_vels[did], d_max_vel, sizeof(float), cudaMemcpyDefault, cu_dev.stream_compute())); timer.tock(fmt::format("GPU[{}] frame {} step {} grid_update_query", did, cur_frame, cur_step)); }); sync(); /// host: compute maxvel & next dt float max_vel = 0.f; for(int did = 0; did < config::G_DEVICE_COUNT; ++did) { if(max_vels[did] > max_vel) { max_vel = max_vels[did]; } } max_vel = std::sqrt(max_vel); next_dt = compute_dt(max_vel, cur_time, next_time, dt_default); fmt::print(fmt::emphasis::bold, "{} --{}--> {}, defaultDt: {}, max_vel: {}\n", cur_time, next_dt, next_time, dt_default, max_vel); /// g2p2g issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CudaTimer timer {cu_dev.stream_compute()}; /// check capacity if(checked_counts[did][1] > 0) { match(particle_bins[rollid ^ 1][did])([this, &did](auto& particle_buffer) { particle_buffer.resize(DeviceAllocator {}, cur_num_active_bins[did]); }); checked_counts[did][1]--; } timer.tick(); // grid grid_blocks[1][did].reset(nbcount[did], cu_dev); // adv map check_cuda_errors(cudaMemsetAsync(partitions[rollid][did].cell_particle_counts, 0, sizeof(int) * exterior_block_count[did] * config::G_BLOCKVOLUME, cu_dev.stream_compute())); // g2p2g match(particle_bins[rollid][did])([this, &did, &cu_dev](const auto& particle_buffer) { if(partitions[rollid][did].h_count) { cu_dev.compute_launch({partitions[rollid][did].h_count, 128, (512 * 3 * 4) + (512 * 4 * 4)}, g2p2g, dt, next_dt, static_cast(partitions[rollid][did].halo_blocks), particle_buffer, get>(particle_bins[rollid ^ 1][did]), partitions[rollid ^ 1][did], partitions[rollid][did], grid_blocks[0][did], grid_blocks[1][did]); } }); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] frame {} step {} halo_g2p2g", did, cur_frame, cur_step)); }); sync(); collect_halo_grid_blocks(); issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); match(particle_bins[rollid][did])([this, &did, &cu_dev](const auto& particle_buffer) { cu_dev.compute_launch({partition_block_count[did], 128, (512 * 3 * 4) + (512 * 4 * 4)}, g2p2g, dt, next_dt, static_cast(nullptr), particle_buffer, get>(particle_bins[rollid ^ 1][did]), partitions[rollid ^ 1][did], partitions[rollid][did], grid_blocks[0][did], grid_blocks[1][did]); }); timer.tock(fmt::format("GPU[{}] frame {} step {} non_halo_g2p2g", did, cur_frame, cur_step)); if(checked_counts[did][0] > 0) { partitions[rollid ^ 1][did].resize_partition(DeviceAllocator {}, cur_num_active_blocks[did]); checked_counts[did][0]--; } }); sync(); reduce_halo_grid_blocks(); issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); /// mark particle blocks partitions[rollid][did].build_particle_buckets(cu_dev, exterior_block_count[did]); int* active_block_marks = tmps[did].active_block_marks; int* destinations = tmps[did].destinations; int* sources = tmps[did].sources; check_cuda_errors(cudaMemsetAsync(active_block_marks, 0, sizeof(int) * nbcount[did], cu_dev.stream_compute())); /// mark grid blocks cu_dev.compute_launch({(nbcount[did] * config::G_BLOCKVOLUME + 127) / 128, 128}, mark_active_grid_blocks, static_cast(nbcount[did]), grid_blocks[1][did], active_block_marks); cu_dev.compute_launch({(exterior_block_count[did] + 1 + 127) / 128, 128}, mark_active_particle_blocks, exterior_block_count[did] + 1, partitions[rollid][did].particle_bucket_sizes, sources); exclusive_scan(exterior_block_count[did] + 1, sources, destinations, cu_dev); /// building new partition // block count check_cuda_errors(cudaMemcpyAsync(partitions[rollid ^ 1][did].count, destinations + exterior_block_count[did], sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); check_cuda_errors(cudaMemcpyAsync(&partition_block_count[did], destinations + exterior_block_count[did], sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.compute_launch({(exterior_block_count[did] + 255) / 256, 256}, exclusive_scan_inverse, exterior_block_count[did], static_cast(destinations), sources); // indextable, activeKeys, particle_bucket_size, buckets partitions[rollid ^ 1][did].reset_table(cu_dev.stream_compute()); cu_dev.syncStream(); cu_dev.compute_launch({partition_block_count[did], 128}, update_partition, static_cast(partition_block_count[did]), static_cast(sources), partitions[rollid][did], partitions[rollid ^ 1][did]); // bin_offsets { int* bin_sizes = tmps[did].bin_sizes; cu_dev.compute_launch({(partition_block_count[did] + 1 + 127) / 128, 128}, compute_bin_capacity, partition_block_count[did] + 1, static_cast(partitions[rollid ^ 1][did].particle_bucket_sizes), bin_sizes); exclusive_scan(partition_block_count[did] + 1, bin_sizes, partitions[rollid ^ 1][did].bin_offsets, cu_dev); check_cuda_errors(cudaMemcpyAsync(&bincount[did], partitions[rollid ^ 1][did].bin_offsets + partition_block_count[did], sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); } timer.tock(fmt::format("GPU[{}] frame {} step {} update_partition", did, cur_frame, cur_step)); /// neighboring blocks timer.tick(); cu_dev.compute_launch({(partition_block_count[did] + 127) / 128, 128}, register_neighbor_blocks, static_cast(partition_block_count[did]), partitions[rollid ^ 1][did]); auto prev_neighbor_block_count = nbcount[did]; check_cuda_errors(cudaMemcpyAsync(&nbcount[did], partitions[rollid ^ 1][did].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] frame {} step {} build_partition_for_grid", did, cur_frame, cur_step)); /// check capacity if(checked_counts[did][0] > 0) { grid_blocks[0][did].resize(DeviceAllocator {}, cur_num_active_blocks[did]); } /// rearrange grid blocks timer.tick(); grid_blocks[0][did].reset(exterior_block_count[did], cu_dev); cu_dev.compute_launch({prev_neighbor_block_count, config::G_BLOCKVOLUME}, copy_selected_grid_blocks, static_cast(partitions[rollid][did].active_keys), partitions[rollid ^ 1][did], static_cast(active_block_marks), grid_blocks[1][did], grid_blocks[0][did]); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] frame {} step {} copy_grid_blocks", did, cur_frame, cur_step)); /// check capacity if(checked_counts[did][0] > 0) { grid_blocks[1][did].resize(DeviceAllocator {}, cur_num_active_blocks[did]); tmps[did].resize(cur_num_active_blocks[did]); } }); sync(); /// halo tag halo_tagging(); issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); /// exterior blocks cu_dev.compute_launch({(partition_block_count[did] + 127) / 128, 128}, register_exterior_blocks, static_cast(partition_block_count[did]), partitions[rollid ^ 1][did]); check_cuda_errors(cudaMemcpyAsync(&exterior_block_count[did], partitions[rollid ^ 1][did].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); fmt::print(fmt::emphasis::bold | fg(fmt::color::yellow), "block count on device {}: {}, {}, {} [{}]; {} [{}]\n", did, partition_block_count[did], nbcount[did], exterior_block_count[did], cur_num_active_blocks[did], bincount[did], cur_num_active_bins[did]); timer.tock(fmt::format("GPU[{}] frame {} step {} build_partition_for_particles", did, cur_frame, cur_step)); }); sync(); rollid ^= 1; dt = next_dt; } issue([this](int did) { IO::flush(); output_model(did); }); sync(); fmt::print( fmt::emphasis::bold | fg(fmt::color::red), "-----------------------------------------------------------" "-----\n" ); } } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers) //FIXME: no signed integer bitwise operations! (rollid) //TODO: Check magic numbers and replace by constants //NOLINTBEGIN(readability-magic-numbers) void output_model(int did) { auto& cu_dev = Cuda::ref_cuda_context(did); cu_dev.set_context(); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); int particle_count = 0; int* d_particle_count = static_cast(cu_dev.borrow(sizeof(int))); check_cuda_errors(cudaMemsetAsync(d_particle_count, 0, sizeof(int), cu_dev.stream_compute())); match(particle_bins[rollid][did])([this, &cu_dev, &did, &d_particle_count](const auto& particle_buffer) { cu_dev.compute_launch({partition_block_count[did], 128}, retrieve_particle_buffer, partitions[rollid][did], partitions[rollid ^ 1][did], particle_buffer, particles[did], d_particle_count); }); check_cuda_errors(cudaMemcpyAsync(&particle_count, d_particle_count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); fmt::print(fg(fmt::color::red), "total number of particles {}\n", particle_count); models[did].resize(particle_count); check_cuda_errors(cudaMemcpyAsync(models[did].data(), (void*) &particles[did].val_1d(_0, 0), sizeof(std::array) * (particle_count), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); std::string fn = std::string {"model"} + "_dev[" + std::to_string(did) + "]_frame[" + std::to_string(cur_frame) + "].bgeo"; IO::insert_job([fn, model = models[did]]() { write_partio(fn, model); }); timer.tock(fmt::format("GPU[{}] frame {} step {} retrieve_particles", did, cur_frame, cur_step)); } //NOLINTEND(readability-magic-numbers) //FIXME: no signed integer bitwise operations! (rollid) //TODO: Check magic numbers and replace by constants //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers)Current c++ version does not yet support std::span void initial_setup() { issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); cu_dev.set_context(); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); cu_dev.compute_launch({(particle_counts[did] + 255) / 256, 256}, activate_blocks, particle_counts[did], particles[did], partitions[rollid ^ 1][did]); check_cuda_errors(cudaMemcpyAsync(&partition_block_count[did], partitions[rollid ^ 1][did].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); timer.tock(fmt::format("GPU[{}] step {} init_table", did, cur_step)); timer.tick(); cu_dev.reset_mem(); // particle block cu_dev.compute_launch({(particle_counts[did] + 255) / 256, 256}, build_particle_cell_buckets, particle_counts[did], particles[did], partitions[rollid ^ 1][did]); // bucket, bin_offsets cu_dev.syncStream(); partitions[rollid ^ 1][did].build_particle_buckets(cu_dev, partition_block_count[did]); { int* bin_sizes = tmps[did].bin_sizes; cu_dev.compute_launch({(partition_block_count[did] + 1 + 127) / 128, 128}, compute_bin_capacity, partition_block_count[did] + 1, static_cast(partitions[rollid ^ 1][did].particle_bucket_sizes), bin_sizes); exclusive_scan(partition_block_count[did] + 1, bin_sizes, partitions[rollid ^ 1][did].bin_offsets, cu_dev); check_cuda_errors(cudaMemcpyAsync(&bincount[did], partitions[rollid ^ 1][did].bin_offsets + partition_block_count[did], sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); } match(particle_bins[rollid][did])([this, &cu_dev, &did](const auto& particle_buffer) { cu_dev.compute_launch({partition_block_count[did], 128}, array_to_buffer, particles[did], particle_buffer, partitions[rollid ^ 1][did]); }); // grid block cu_dev.compute_launch({(partition_block_count[did] + 127) / 128, 128}, register_neighbor_blocks, static_cast(partition_block_count[did]), partitions[rollid ^ 1][did]); check_cuda_errors(cudaMemcpyAsync(&nbcount[did], partitions[rollid ^ 1][did].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); cu_dev.compute_launch({(partition_block_count[did] + 127) / 128, 128}, register_exterior_blocks, static_cast(partition_block_count[did]), partitions[rollid ^ 1][did]); check_cuda_errors(cudaMemcpyAsync(&exterior_block_count[did], partitions[rollid ^ 1][did].count, sizeof(int), cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] step {} init_partition", did, cur_step)); fmt::print(fmt::emphasis::bold | fg(fmt::color::yellow), "block count on device {}: {}, {}, {} [{}]; {} [{}]\n", did, partition_block_count[did], nbcount[did], exterior_block_count[did], cur_num_active_blocks[did], bincount[did], cur_num_active_bins[did]); }); sync(); halo_tagging(); issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CudaTimer timer {cu_dev.stream_compute()}; /// need to copy halo tag info as well partitions[rollid ^ 1][did].copy_to(partitions[rollid][did], exterior_block_count[did], cu_dev.stream_compute()); check_cuda_errors(cudaMemcpyAsync(partitions[rollid][did].active_keys, partitions[rollid ^ 1][did].active_keys, sizeof(ivec3) * exterior_block_count[did], cudaMemcpyDefault, cu_dev.stream_compute())); cu_dev.syncStream(); timer.tick(); grid_blocks[0][did].reset(nbcount[did], cu_dev); cu_dev.compute_launch({(particle_counts[did] + 255) / 256, 256}, rasterize, particle_counts[did], particles[did], grid_blocks[0][did], partitions[rollid][did], dt, get_mass(did)); cu_dev.compute_launch({partition_block_count[did], 128}, init_adv_bucket, static_cast(partitions[rollid][did].particle_bucket_sizes), partitions[rollid][did].blockbuckets); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] step {} init_grid", did, cur_step)); }); sync(); collect_halo_grid_blocks(0); reduce_halo_grid_blocks(0); } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers) //FIXME: no signed integer bitwise operations! (rollid) //TODO: Check magic numbers and replace by constants //NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers)Current c++ version does not yet support std::span void halo_tagging() { issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); cu_dev.reset_mem(); for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { if(otherdid != did) { halo_block_ids[did][otherdid] = static_cast(cu_dev.borrow(sizeof(ivec3) * nbcount[otherdid])); } } /// init halo blockids output_halo_grid_blocks[did].init_blocks(TempAllocator {did}, nbcount[did]); input_halo_grid_blocks[did].init_blocks(TempAllocator {did}, nbcount[did]); }); sync(); issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); /// prepare counts output_halo_grid_blocks[did].reset_counts(cu_dev.stream_compute()); cu_dev.syncStream(); /// sharing local active blocks for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { if(otherdid != did) { check_cuda_errors(cudaMemcpyAsync(halo_block_ids[otherdid][did], partitions[rollid ^ 1][did].active_keys, sizeof(ivec3) * nbcount[did], cudaMemcpyDefault, cu_dev.stream_spare(otherdid))); cu_dev.spare_event_record(otherdid); } } }); sync(); issue([this](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CudaTimer timer {cu_dev.stream_compute()}; timer.tick(); /// init overlap marks partitions[rollid ^ 1][did].reset_overlap_marks(nbcount[did], cu_dev.stream_compute()); cu_dev.syncStream(); /// receiving active blocks from other devices for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { if(otherdid != did) { cu_dev.spareStreamWaitForEvent(otherdid, Cuda::ref_cuda_context(otherdid).event_spare(did)); cu_dev.spare_launch(otherdid, {(nbcount[otherdid] + 127) / 128, 128}, mark_overlapping_blocks, static_cast(nbcount[otherdid]), otherdid, static_cast(halo_block_ids[did][otherdid]), partitions[rollid ^ 1][did], output_halo_grid_blocks[did].counts + otherdid, output_halo_grid_blocks[did].buffers[otherdid]); cu_dev.spare_event_record(otherdid); cu_dev.computeStreamWaitForEvent(cu_dev.event_spare(otherdid)); } } // self halo particle block partitions[rollid ^ 1][did].reset_halo_count(cu_dev.stream_compute()); cu_dev.compute_launch({(partition_block_count[did] + 127) / 128, 128}, collect_blockids_for_halo_reduction, static_cast(partition_block_count[did]), did, partitions[rollid ^ 1][did]); /// retrieve counts partitions[rollid ^ 1][did].retrieve_halo_count(cu_dev.stream_compute()); output_halo_grid_blocks[did].retrieve_counts(cu_dev.stream_compute()); cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] step {} halo_tagging", did, cur_step)); fmt::print(fg(fmt::color::green), "halo particle blocks[{}]: {}\n", did, partitions[rollid ^ 1][did].h_count); for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { fmt::print(fg(fmt::color::green), "halo grid blocks[{}][{}]: {}\n", did, otherdid, output_halo_grid_blocks[did].h_counts[otherdid]); } }); sync(); } //NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, readability-magic-numbers) void collect_halo_grid_blocks(int gid = 1) { /// init halo grid blocks issue([this](int did) { std::vector counts(config::G_DEVICE_COUNT); output_halo_grid_blocks[did].init_buffer(TempAllocator {did}, output_halo_grid_blocks[did].h_counts); for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { counts[otherdid] = (otherdid != did) ? output_halo_grid_blocks[otherdid].h_counts[did] : 0; } input_halo_grid_blocks[did].init_buffer(TempAllocator {did}, counts); }); sync(); issue([this, gid](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CppTimer timer {}; timer.tick(); /// sharing local active blocks for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { if(otherdid != did) { if(output_halo_grid_blocks[did].h_counts[otherdid] > 0) { auto& count = output_halo_grid_blocks[did].h_counts[otherdid]; cu_dev.spare_launch(otherdid, {count, config::G_BLOCKVOLUME}, collect_grid_blocks, grid_blocks[gid][did], partitions[rollid][did], output_halo_grid_blocks[did].buffers[otherdid]); output_halo_grid_blocks[did].send(input_halo_grid_blocks[otherdid], did, otherdid, cu_dev.stream_spare(otherdid)); cu_dev.spare_event_record(otherdid); } else { input_halo_grid_blocks[otherdid].h_counts[did] = 0; } } } timer.tock(fmt::format("GPU[{}] step {} collect_send_halo_grid", did, cur_step)); }); sync(); } void reduce_halo_grid_blocks(int gid = 1) { issue([this, gid](int did) { auto& cu_dev = Cuda::ref_cuda_context(did); CppTimer timer {}; timer.tick(); /// receiving active blocks from other devices for(int otherdid = 0; otherdid < config::G_DEVICE_COUNT; otherdid++) { if(otherdid != did) { if(input_halo_grid_blocks[did].h_counts[otherdid] > 0) { cu_dev.spareStreamWaitForEvent(otherdid, Cuda::ref_cuda_context(otherdid).event_spare(did)); cu_dev.spare_launch(otherdid, {input_halo_grid_blocks[did].h_counts[otherdid], config::G_BLOCKVOLUME}, reduce_grid_blocks, grid_blocks[gid][did], partitions[rollid][did], input_halo_grid_blocks[did].buffers[otherdid]); cu_dev.spare_event_record(otherdid); cu_dev.computeStreamWaitForEvent(cu_dev.event_spare(otherdid)); } } } cu_dev.syncStream(); timer.tock(fmt::format("GPU[{}] step {} receive_reduce_halo_grid", did, cur_step)); }); sync(); } }; }// namespace mn #endif ================================================ FILE: Projects/MGSP/particle_buffer.cuh ================================================ #ifndef PARTICLE_BUFFER_CUH #define PARTICLE_BUFFER_CUH #include #include "settings.h" //NOLINTNEXTLINE(cppcoreguidelines-macro-usage) Macro usage necessary here for preprocessor if #define PRINT_NEGATIVE_BLOGNOS 1 namespace mn { using ParticleBinDomain = AlignedDomain; using ParticleBufferDomain = CompactDomain; using ParticleArrayDomain = CompactDomain; //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments using particle_bin4_ = Structural, ParticleBinDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_>; ///< J, pos using particle_bin12_ = Structural, ParticleBinDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_>; ///< pos, F using particle_bin13_ = Structural, ParticleBinDomain, attrib_layout::SOA, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_, f32_>;///< pos, F, logJp //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) template struct particle_bin_; template<> struct particle_bin_ : particle_bin4_ {}; template<> struct particle_bin_ : particle_bin12_ {}; template<> struct particle_bin_ : particle_bin13_ {}; template<> struct particle_bin_ : particle_bin13_ {}; //NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) Check is buggy and reporst variable errors fro template arguments template using particle_buffer_ = Structural, ParticleBufferDomain, attrib_layout::AOS, ParticleBin>; using particle_array_ = Structural, ParticleArrayDomain, attrib_layout::AOS, f32_, f32_, f32_>; //NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables, readability-identifier-naming) template struct ParticleBufferImpl : Instance>> { static constexpr MaterialE MATERIAL_TYPE = Mt; using base_t = Instance>>; std::size_t num_active_blocks; int* cell_particle_counts; int* particle_bucket_sizes; int* cellbuckets; int* blockbuckets; int* bin_offsets; template explicit ParticleBufferImpl(Allocator allocator) : base_t {spawn>, orphan_signature>(allocator)} , num_active_blocks() , cell_particle_counts(nullptr) , particle_bucket_sizes(nullptr) , cellbuckets(nullptr) , blockbuckets(nullptr) , bin_offsets(nullptr) {} template void check_capacity(Allocator allocator, std::size_t capacity) { if(capacity > this->capacity) this->resize(allocator, capacity); } }; //NOTE: In subsequent classes some parameters are actually const and static, but they are nit declared as such to allow consistent access to the members //TODO: Maybe write accessors; Maybe create common baseclass(es) for accessing the parameters template struct ParticleBuffer; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions float rho = config::DENSITY; float volume = (1.0f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float bulk = 4e4; float gamma = 7.15f; float viscosity = 0.01f; void update_parameters(float density, float vol, float b, float g, float v) { rho = density; volume = vol; mass = volume * density; bulk = b; gamma = g; viscosity = v; } //NOLINTEND(readability-magic-numbers) template explicit ParticleBuffer(Allocator allocator) : base_t {allocator} {} }; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions float rho = config::DENSITY; float volume = (10.f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float e = config::YOUNGS_MODULUS; float nu = config::POISSON_RATIO; float lambda = config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)); float mu = config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO)); void update_parameters(float density, float vol, float e, float nu) { rho = density; volume = vol; mass = volume * density; lambda = e * nu / ((1 + nu) * (1 - 2 * nu)); mu = e / (2 * (1 + nu)); } //NOLINTEND(readability-magic-numbers) template explicit ParticleBuffer(Allocator allocator) : base_t {allocator} {} }; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions; consistent naming float rho = config::DENSITY; float volume = (10.f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float r = config::YOUNGS_MODULUS; float nu = config::POISSON_RATIO; float lambda = config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)); float mu = config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO)); static constexpr float LOG_JP_0 = 0.0f; float friction_angle = 30.f; float cohesion = 0.0f; float beta = 1.0f; // std::sqrt(2.f/3.f) * 2.f * std::sin(30.f/180.f*3.141592741f) // / (3.f - // std::sin(30.f/180.f*3.141592741f)) float yield_surface = 0.816496580927726f * 2.f * 0.5f / (3.f - 0.5f); bool volume_correction = true; //NOLINTEND(readability-magic-numbers) template explicit ParticleBuffer(Allocator allocator) : base_t {allocator} {} }; template<> struct ParticleBuffer : ParticleBufferImpl { using base_t = ParticleBufferImpl; //NOLINTBEGIN(readability-magic-numbers) Parameter definitions float rho = config::DENSITY; float volume = (1.0f / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float mass = (config::DENSITY / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / (1u << config::DOMAIN_BITS) / config::MODEL_PPC); float e = config::YOUNGS_MODULUS; float nu = config::POISSON_RATIO; float lambda = config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)); float mu = config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO)); float friction_angle = 45.f; float bm = 2.f / 3.f * (config::YOUNGS_MODULUS / (2 * (1 + config::POISSON_RATIO))) + (config::YOUNGS_MODULUS * config::POISSON_RATIO / ((1 + config::POISSON_RATIO) * (1 - 2 * config::POISSON_RATIO)));///< bulk modulus, kappa float xi = 0.8f; ///< hardening factor static constexpr float LOG_JP_0 = -0.01f; float beta = 0.5f; float mohr_columb_friction = 0.503599787772409;//< sqrt((T)2 / (T)3) * (T)2 * sin_phi / ((T)3 - sin_phi); float m = 1.850343771924453;//< mohr_columb_friction * (T)dim / sqrt((T)2 / ((T)6 - dim)); float msqr = 3.423772074299613; bool hardening_on = true; void update_parameters(float density, float vol, float e, float nu, float be, float x) { rho = density; volume = vol; mass = volume * density; lambda = e * nu / ((1 + nu) * (1 - 2 * nu)); mu = e / (2 * (1 + nu)); bm = 2.f / 3.f * (e / (2 * (1 + nu))) + (e * nu / ((1 + nu) * (1 - 2 * nu))); beta = be; xi = x; } //NOLINTEND(readability-magic-numbers) template explicit ParticleBuffer(Allocator allocator) : base_t {allocator} {} }; /// conversion /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r3.html using particle_buffer_t = variant, ParticleBuffer, ParticleBuffer, ParticleBuffer>; struct ParticleArray : Instance { using base_t = Instance; ParticleArray() = default; explicit ParticleArray(base_t&& instance)//NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved) Clang say, that std::move has no effect here : base_t(instance) {} }; }// namespace mn #endif ================================================ FILE: Projects/MGSP/partition_domain.h ================================================ #ifndef PARTITION_DOMAIN_H #define PARTITION_DOMAIN_H #include #include namespace mn { template struct PartitionDomain { using index = std::array; template constexpr bool inside(Index&& id) const noexcept { return self().inside(std::forward(id)); } template constexpr bool within(Index&& id, Offset&& l, Offset&& u) const noexcept { return self().within(std::forward(id), std::forward(l), std::forward(u)); } protected: auto& self() noexcept { return static_cast(*this); } }; template struct BoxDomain : PartitionDomain, Tn, Dim> { using base_t = PartitionDomain, Tn, Dim>; using index = typename base_t::index; index min; index max; constexpr BoxDomain() noexcept = default; constexpr BoxDomain(index lower, index upper) { for(int d = 0; d < Dim; ++d) { min[d] = lower[d]; max[d] = upper[d]; } } constexpr BoxDomain(vec lower, vec upper) { for(int d = 0; d < Dim; ++d) { min[d] = lower[d]; max[d] = upper[d]; } } template constexpr bool inside(Index&& id) const noexcept { for(int d = 0; d < Dim; ++d) { if(id[d] < min[d] || id[d] > max[d]) { return false; } } return true; } template constexpr bool within(Index&& id, Offset&& l, Offset&& u) const noexcept { for(int d = 0; d < Dim; ++d) { if(id[d] < min[d] + l[d] || id[d] > max[d] + u[d]) { return false; } } return true; } }; }// namespace mn #endif ================================================ FILE: Projects/MGSP/settings.h ================================================ #ifndef SETTINGS_H #define SETTINGS_H #include #include #include #include "partition_domain.h" namespace mn { using ivec3 = vec; using vec3 = vec; using vec9 = vec; using vec3x3 = vec; using vec3x4 = vec; using vec3x3x3 = vec; /// sand = Drucker Prager Plasticity, StvkHencky Elasticity enum class MaterialE { J_FLUID = 0, FIXED_COROTATED, SAND, NACC, TOTAL }; /// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html, F.3.16.5 /// benchmark setup namespace config { constexpr int G_DEVICE_COUNT = 2; constexpr MaterialE get_material_type(int did) noexcept { (void) did; return MaterialE::J_FLUID; } constexpr int G_TOTAL_FRAME_COUNT = 60; constexpr int NUM_DIMENSIONS = 3; constexpr int GBPCB = 16; constexpr int G_NUM_GRID_BLOCKS_PER_CUDA_BLOCK = GBPCB; constexpr int G_NUM_WARPS_PER_GRID_BLOCK = 1; constexpr int G_NUM_WARPS_PER_CUDA_BLOCK = GBPCB; constexpr int G_PARTICLE_BATCH_CAPACITY = 128; constexpr float MODEL_PPC = 8.0f; constexpr float G_MODEL_PPC = MODEL_PPC; constexpr float CFL = 0.5f; // background_grid constexpr int BLOCK_BITS = 2; constexpr int DOMAIN_BITS = 8; constexpr float DXINV = (1.0f * (1u << DOMAIN_BITS)); constexpr int G_DOMAIN_BITS = DOMAIN_BITS; constexpr int G_DOMAIN_SIZE = (1 << DOMAIN_BITS); constexpr float G_BOUNDARY_CONDITION = 2.0; constexpr float G_DX = 1.f / DXINV; constexpr float G_DX_INV = DXINV; constexpr float G_D_INV = 4.f * DXINV * DXINV; constexpr int G_BLOCKBITS = BLOCK_BITS; constexpr int G_BLOCKSIZE = (1 << BLOCK_BITS); constexpr int G_BLOCKMASK = ((1 << BLOCK_BITS) - 1); constexpr int G_BLOCKVOLUME = (1 << (BLOCK_BITS * 3)); constexpr int G_GRID_BITS = (DOMAIN_BITS - BLOCK_BITS); constexpr int G_GRID_SIZE = (1 << (DOMAIN_BITS - BLOCK_BITS)); // partition domains //NOLINTBEGIN(readability-magic-numbers) Numbers are used for dividing domains constexpr BoxDomain get_domain(int did) noexcept { constexpr int LEN = G_GRID_SIZE / 2; BoxDomain domain {}; for(int d = 0; d < NUM_DIMENSIONS; ++d) { domain.min[d] = 0; domain.max[d] = G_GRID_SIZE - 1; } if constexpr(G_DEVICE_COUNT == 1) { /// default } else if(G_DEVICE_COUNT == 2) { if(did == 0) { domain.max[0] = LEN; } else if(did == 1) {//NOLINT(hicpp-multiway-paths-covered) Otherwise unchanged domain.min[0] = LEN + 1; } } else if(G_DEVICE_COUNT <= 4 && G_DEVICE_COUNT >= 3) { domain.min[0] = ((did & 2) != 0) ? LEN + 1 : 0; domain.min[2] = ((did & 1) != 0) ? LEN + 1 : 0; domain.max[0] = ((did & 2) != 0) ? G_GRID_SIZE - 1 : LEN; domain.max[2] = ((did & 1) != 0) ? G_GRID_SIZE - 1 : LEN; } else { domain.max[0] = domain.max[1] = domain.max[2] = -3; } return domain; } //NOLINTEND(readability-magic-numbers) // particle constexpr int MAX_PARTICLES_IN_CELL = 128; constexpr int G_MAX_PARTICLES_IN_CELL = MAX_PARTICLES_IN_CELL; constexpr int G_BIN_CAPACITY = 32; constexpr int G_PARTICLE_NUM_PER_BLOCK = (MAX_PARTICLES_IN_CELL * (1 << (BLOCK_BITS * 3))); // material parameters constexpr float DENSITY = 1e3; constexpr float YOUNGS_MODULUS = 5e3; constexpr float POISSON_RATIO = 0.4f; // constexpr float G_GRAVITY = -9.8f * 0.5f; /// only used on host constexpr int G_MAX_PARTICLE_NUM = 2000000; constexpr int G_MAX_ACTIVE_BLOCK = 12000;/// 62500 bytes for active mask constexpr std::size_t calc_particle_bin_count(std::size_t num_active_blocks) noexcept { return num_active_blocks * (G_MAX_PARTICLES_IN_CELL * G_BLOCKVOLUME / G_BIN_CAPACITY); } constexpr std::size_t G_MAX_PARTICLE_BIN = G_MAX_PARTICLE_NUM / G_BIN_CAPACITY; constexpr std::size_t G_MAX_HALO_BLOCK = 4000; }// namespace config }// namespace mn #endif ================================================ FILE: Projects/MGSP/utility_funcs.hpp ================================================ #ifndef UTILITY_FUNCS_HPP #define UTILITY_FUNCS_HPP #include "settings.h" namespace mn { //TODO: Maybe create parameters fopr some of this magic numbers //NOLINTBEGIN(readability-magic-numbers) Magic numbers are formula-specific /// assume p is already within kernel range [-1.5, 1.5] constexpr vec3 bspline_weight(float p) { vec3 dw {0.0f, 0.0f, 0.0f}; float d = p * config::G_DX_INV;///< normalized offset dw[0] = 0.5f * (1.5f - d) * (1.5f - d); d -= 1.0f; dw[1] = 0.75f - d * d; d = 0.5f + d; dw[2] = 0.5f * d * d; return dw; } constexpr int dir_offset(ivec3 d) { return (d[0] + 1) * 9 + (d[1] + 1) * 3 + d[2] + 1; } constexpr void dir_components(int dir, ivec3& d) { d[2] = (dir % 3) - 1; d[1] = ((dir / 3) % 3) - 1; d[0] = ((dir / 9) % 3) - 1; } //NOLINTEND(readability-magic-numbers) Magic numbers are formula-specific //NOLINTBEGIN(readability-magic-numbers) Magic numbers are formula-specific constexpr float compute_dt(float max_vel, const float cur, const float next, const float dt_default) noexcept { if(next < cur) { return 0.0f; } float dt = dt_default; if(max_vel > 0.0f) { max_vel = config::G_DX * 0.3f / max_vel; if(max_vel < dt_default) { dt = max_vel; } } if(cur + dt >= next) { dt = next - cur; } else { max_vel = (next - cur) * 0.51f; if(max_vel < dt) { dt = max_vel; } } return dt; } //NOLINTEND(readability-magic-numbers) Magic numbers are formula-specific }// namespace mn #endif ================================================ FILE: Projects/TaichiScripts/gmpm.py ================================================ import taichi as ti ti.init(arch=ti.cuda) # sim setup dt = 1e-4 dim = 3 domain_size = 256 dx, inv_dx = 1 / domain_size, float(domain_size) block_size = 4 block_num = domain_size / block_size particle_num = 775196 max_particle_size = 64 # material p_vol, p_rho = (dx * 0.5)**3, 1 p_mass = p_vol * p_rho E, nu = 5e3, 0.2 # Young's modulus and Poisson's ratio mu_0, lambda_0 = E / (2 * (1 + nu)), E * nu / \ ((1+nu) * (1 - 2 * nu)) # Lame parameters # grid layout grid_m = ti.var(dt=ti.f32) grid_v = ti.Vector(3, dt=ti.f32) # particle layout par_pos = ti.Vector(3, dt=ti.f32) par_m = ti.var(ti.f32) par_v = ti.Vector(3, dt=ti.f32) par_F = ti.Matrix(3, 3, dt=ti.f32) # layout define @ti.layout def buffers(): ti.root.dense(ti.ijk, (block_num, block_num, block_num)).dense(ti.ijk, (block_size, block_size, block_size)).place(grid_m) for d in ti.static(range(3)): ti.root.dense(ti.ijk, (block_num, block_num, block_num)).dense(ti.ijk, (block_size, block_size, block_size)).place(grid_v(d)) ti.root.dynamic(ti.i).place(par_pos(d)) ti.root.dense(ti.ijk, (block_num, block_num, block_num)).dense(ti.ijk, (block_size, block_size, block_size)).dynamic(ti.i, max_particle_size).place(par_m) for d in ti.static(range(3)): ti.root.dense(ti.ijk, (block_num, block_num, block_num)).dense(ti.ijk, (block_size, block_size, block_size)).dynamic(ti.i, max_particle_size).place(par_v(d)) for i, j in ti.static(ndrange(3, 3)): ti.root.dense(ti.ijk, (block_num, block_num, block_num)).dense(ti.ijk, (block_size, block_size, block_size)).dynamic(ti.i, max_particle_size).place(par_F(i, j)) @ti.kernel def initialize(): for i in range(particle_num): par_pos[i] = ti.Vector([0, 0, 0]) # with open("twodragons.bin", 'rb') as f: ================================================ FILE: README.md ================================================ # A Massively Parallel and Scalable Multi-GPU Material Point Method ## Description This is the opensource code for the SIGGRAPH 2020 paper: **A Massively Parallel and Scalable Multi-GPU Material Point Method** [page](https://sites.google.com/view/siggraph2020-multigpu)\, [pdf](https://math.ucla.edu/~cffjiang/research/wang2020multigpu/wang2020multigpu.pdf)\, [supp](https://math.ucla.edu/~cffjiang/research/wang2020multigpu/supp.pdf)\, [video](https://vimeo.com/414136257) Authors: [Xinlei Wang](https://github.com/littlemine)\*, [Yuxing Qiu](https://yuxingqiu.github.io/)\*, [Stuart R. Slattery](https://www.ornl.gov/staff-profile/stuart-r-slattery), [Yu Fang](http://squarefk.com/), [Minchen Li](https://www.seas.upenn.edu/~minchenl/), [Song-Chun Zhu](http://www.stat.ucla.edu/~sczhu/), [Yixin Zhu](https://yzhu.io/), [Min Tang](https://min-tang.github.io/home/), [Dinesh Manocha](https://www.cs.umd.edu/people/dmanocha) [Chenfanfu Jiang](https://math.ucla.edu/~cffjiang/) (* Equal contributions)

Harnessing the power of modern multi-GPU architectures, we present a massively parallel simulation system based on the Material Point Method (MPM) for simulating physical behaviors of materials undergoing complex topological changes, self-collision, and large deformations. Our system makes three critical contributions. First, we introduce a new particle data structure that promotes coalesced memory access patterns on the GPU and eliminates the need for complex atomic operations on the memory hierarchy when writing particle data to the grid. Second, we propose a kernel fusion approach using a new Grid-to-Particles-to-Grid (G2P2G) scheme, which efficiently reduces GPU kernel launches, improves latency, and significantly reduces the amount of global memory needed to store particle data. Finally, we introduce optimized algorithmic designs that allow for efficient sparse grids in a shared memory context, enabling us to best utilize modern multi-GPU computational platforms for hybrid Lagrangian-Eulerian computational patterns. We demonstrate the effectiveness of our method with extensive benchmarks, evaluations, and dynamic simulations with elastoplasticity, granular media, and fluid dynamics. In comparisons against an open-source and heavily optimized CPU-based MPM codebase on an elastic sphere colliding scene with particle counts ranging from 5 to 40 million, our GPU MPM achieves over 100X per-time-step speedup on a workstation with an Intel 8086K CPU and a single Quadro P6000 GPU, exposing exciting possibilities for future MPM simulations in computer graphics and computational science. Moreover, compared to the state-of-the-art GPU MPM method, we not only achieve 2X acceleration on a single GPU but our kernel fusion strategy and Array-of-Structs-of-Array (AoSoA) data structure design also generalizes to multi-GPU systems. Our multi-GPU MPM exhibits near-perfect weak and strong scaling with 4 GPUs, enabling performant and large-scale simulations on a 1024x1024x1024 grid with close to 100 million particles with less than 4 minutes per frame on a single 4-GPU workstation and 134 million particles with less than 1 minute per frame on an 8-GPU workstation. ## Compilation This is a cross-platform C++/CUDA cmake project. The minimum version requirement of cmake is 3.15, yet the latest version is generally recommended. The required CUDA version is 10.2 or 11. Currently, *supported OS* includes Windows 10 and Ubuntu (>=18.04), and *tested compilers* includes gcc8.4, msvc v142, clang-9 (includes msvc version). ### Build Run the following command in the *root directory*. Note that adding "--config Release" to the last command is needed when compiling using msvc. ```mkdir build cd build cmake .. cmake --build . ``` Or configure the project using the *CMake Tools* extension in *Visual Studio Code* (recommended). ### Data Currently, binary position data and the level-set (signed distance field) [data](https://github.com/littlemine/Data) are accepted as input files for particles. Uniformly sampling particles from analytic geometries is another viable way for the initialization of models. ### Run Demos The project provides the following GPU-based schemes for MPM: - **GMPM**: improved single-GPU pipeline - **MGSP**: static geometry (particle) partitioning multi-GPU pipeline Go to *Projects/\*\**, run the executable. ## Code Usage > Use the codebase in another cmake c++ project. Directly include the codebase as a submodule, and follow the examples in the *Projects*. > Develop upon the codebase. Create a sub-folder in *Projects* with a cmake file at its root. ## Bibtex Please cite our paper if you use this code for your research: ``` @article{Wang2020multiGMPM, author = {Xinlei Wang* and Yuxing Qiu* and Stuart R. Slattery and Yu Fang and Minchen Li and Song-Chun Zhu and Yixin Zhu and Min Tang and Dinesh Manocha and Chenfanfu Jiang}, title = {A Massively Parallel and Scalable Multi-GPU Material Point Method}, journal = {ACM Transactions on Graphics}, year = {2020}, volume = {39}, number = {4}, articleno = {Article 30} } ``` ## Credits This project draws inspirations from [Taichi](https://github.com/taichi-dev/taichi), [GMPM](https://github.com/kuiwuchn/GPUMPM). ### Acknowledgement We thank [Yuanming Hu](http://taichi.graphics/me/) for useful discussions and proofreading, [Feng Gao](https://fen9.github.io/) for his help on configuring workstations. We appreciate Prof. [Chenfanfu Jiang](https://math.ucla.edu/~cffjiang/) and [Yuanming Hu](http://taichi.graphics/me/) for their insightful advice on the documentation. ### Dependencies The following libraries are adopted in our project development: - [cub](http://nvlabs.github.io/cub/) (now replaced by Thrust) - [fmt](https://fmt.dev/latest/index.html) For particle data IO and generation, we use these two libraries in addition: - [partio](http://partio.us/) - [SDFGen](https://github.com/christopherbatty/SDFGen) Due to the C++ standard requirement (at most C++14) for compiling CUDA (10.2) code, we import these following libraries as well: - [function_ref](https://github.com/TartanLlama/function_ref) - [optional](https://github.com/TartanLlama/optional) - [variant](https://github.com/mpark/variant) ================================================ FILE: docs/benchmark.rst ================================================ Benchmark ================== Settings -------- Benchmark settings of each project are set within its directory (e.g. *Projects/MGSP*) independently. General setup ````````````` Most configurations regarding the simulation are set in *settings.h*. Data structure related setup: - **DOMAIN_BITS**: the resolution of the background grid in each dimension, e.g. 8 refers to a :math:`256 \times 256 \times 256` grid. - **MAX_PPC**: the maximum number of particles held within a cell. - **g_bin_capacity**: the number of particles in each particle bin. - **g_max_particle_num**: the maximum number of particles in each GPU. - **g_max_active_block**: the maximum number of blocks in each GPU. This affects the memory consumption of most important data structures (*particles*, *grid*, *partition*, etc). Physical parameter setup: - **g_gravity**: the gravity constant. - **MODEL_PPC**: particle-per-cell for sampling particles from a SDF model. per-particle-volume is computed from this and the grid resolution. - **DENSITY**: the density constant of particles. - **get_material_type(int did) -> material**: the type of particles for each GPU. Assume each GPU handles only one category of particles. Multi-GPU related setup: - **g_device_num**: the number of GPUs used. - **get_domain(int did) -> domain**: the spatial partition domain for each GPU. It can be set time-dependently. Additional material setup `````````````````````````` In *particle_buffer.cuh*, there are currently four types of particles supported. They are named *JFluid*, *FixedCorotated*, *Sand*, and *NACC*. Within each **ParticleBuffer**, there are various material-dependent constant parameters that could be configured. Initial model setup `````````````````````````` Initial particle models for all GPUs are set in the **init_models** function in *main.cu*. Results -------- Multi-GPU scalability `````````````````````````` The following shows the `strong scalability `_ of our multi-GPU pipeline. .. image:: images/row_strong_speedup.jpg :width: 300px .. image:: images/row_strong_time.jpg :width: 300px The following shows the `weak scalability `_ of our multi-GPU pipeline. .. image:: images/row_weak_speedup.jpg :width: 300px .. image:: images/row_weak_time.jpg :width: 300px ================================================ FILE: docs/compilation.rst ================================================ Compilation ============= This is a cross-platform C++/CUDA cmake project. The minimum version requirement of **CMake** is 3.15, although the latest version is generally recommended. The recommended version of **CUDA** is 10.2. Currently tested C++ compilers (as the host compiler for **NVCC**) on different platforms include: +----------+------------------+ | platform | Compilers | +==========+==================+ | Windows | msvc142, clang-9 | +----------+------------------+ | Linux | gcc8.4, clang-9 | +----------+------------------+ In short, the supported compilers should support **C++14** standard and be in compliance with **NVCC**. Since the future releases of **CUDA** are officially excluded on Mac OS, and there is a more suitable candidate **Metal** developed by **Apple**, the **Mac OS** platform is not discussed. External Dependencies --------------------- These libraries are very helpful in developing this project and save a lot of efforts: - `CUB `_ provides state-of-the-art, reusable software components for every layer of the CUDA programming model including many parallel primitives and utilities. - `fmt `_ is an open-source formatting library for C++. These libraries are used for particle data IO and initialization: - `partio `_ is an open source C++ library for reading, writing and manipulating a variety of standard particle formats (GEO, BGEO, PTC, PDB, PDA). - `SDFGen `_ is a simple commandline utility to generate grid-based signed distance field (level set) from triangle meshes, using code from Robert Bridson's website. Build Commands ------------------- Run the following command in the *root directory*. .. code-block:: bash mkdir build cd build cmake .. cmake --build . --config Release The project can also be configured through other interfaces, e.g. using the *CMake Tools* extension in *Visual Studio Code* (recommended), in *Visual Studio Studio*, or in *CMake GUI*. ================================================ FILE: docs/conf.py ================================================ # -*- coding: utf-8 -*- # # Mn documentation build configuration file, created by # sphinx-quickstart on Wed May 27 06:18:54 2020. # # 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. # 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. # # import os # import sys # sys.path.insert(0, os.path.abspath('.')) # -- 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.githubpages', 'sphinx.ext.mathjax', 'sphinx.ext.imgmath'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The master toctree document. master_doc = 'index' # General information about the project. project = u'Claymore' copyright = u'2020, Xinlei Wang, Yuxing Qiu, Stuart Slattery, Yu Fang, Minchen Li, Song-Chun Zhu, Yixin Zhu, Min Tang, Dinesh Manocha, Chenfanfu Jiang' author = u'Xinlei Wang, Yuxing Qiu, Stuart Slattery, Yu Fang, Minchen Li, Song-Chun Zhu, Yixin Zhu, Min Tang, Dinesh Manocha, Chenfanfu Jiang' # 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. # # The short X.Y version. version = u'1.0' # The full version, including alpha/beta/rc tags. release = u'1.0' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = None # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = [] # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = True # -- 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 = 'sphinx_rtd_theme' # 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 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'] # Custom sidebar templates, must be a dictionary that maps document names # to template names. # # This is required for the alabaster theme # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars html_sidebars = { '**': [ 'relations.html', # needs 'show_related': True theme option to display 'searchbox.html', ] } # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. htmlhelp_basename = 'claymore_doc' # -- 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': '', # Latex figure (float) alignment # # 'figure_align': 'htbp', } # 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 = [ (master_doc, 'Claymore.tex', u'Claymore Documentation', u'Xinlei Wang and Yuxing Qiu and Stuart R. Slattery and Yu Fang and Minchen Li and Song-Chun Zhu and Yixin Zhu and Min Tang and Dinesh Manocha and Chenfanfu Jiang', 'manual'), ] # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'claymore', u'Claymore Documentation', [author], 1) ] # -- 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 = [ (master_doc, 'Claymore', u'Claymore Documentation', author, 'Claymore', 'One line description of project.', 'Miscellaneous'), ] ================================================ FILE: docs/credits.rst ================================================ Acknowledgement =============== We thank Yuanming Hu for useful discussions and proofreading, Feng Gao for his help on configuring workstations. We appreciate Prof. Chenfanfu Jiang and Yuanming Hu for their insightful advice on the documentation. ================================================ FILE: docs/datastructure.rst ================================================ Data Structure ============== Data structures in a MPM simulation usually need to model the particles, the grids and the mappings between them. Correspondingly, we encapsulate these in *Partition*, *Particle Buffer* and *Grid Buffer*. Partition ----------- **Partition** maintains the active elements, i.e. *block* in this context, and the mapping between block coordinates and linear indices through spatial hashing in the current timestep. By *active element*, it means blocks that particles are assgined to, advect to or transfer to as shown below. .. image:: images/partition.jpg It consists of an array to hold all the block coordinates (sparse information), hash tables for spatial hashing and particle buckets for holding particle indices grouped in blocks. In multi-GPU cases, it additionally stores halo tags. Particle Buffer --------------- **Particle Buffer** consists of particle bins from all the blocks that particles belong to. This novel particle data structure is essentially in AoSoA layout similar to `Cabana `_. .. code-block:: cpp using f32_ = StructuralEntity; using Decorator = decorator; using ParticleBinDomain = aligned_domain; using particle_bin4_ = structural; using ParticleBufferDomain = compact_domain; using particle_buffer_ = structural; The memory layout of each particle bin specified above is SoA with a total number of 4 attributes (arrays) for fluid particles and a length that is a multiple of 32 (warp size) for coalesced access. Note that the particle buffer is updated in a delayed fashion according to the particle index buckets in the previous substep. Since the particle buckets are known before *g2p2g*, writing to global memory is generally coalesced. .. image:: images/bin_structure.jpg Grid Buffer ----------- **Grid Buffer** is composed of grid blocks that are currently visible to particles. .. code-block:: cpp using BlockDomain = compact_domain; using grid_block_ = structural; using GridBufferDomain = compact_domain; using grid_buffer_ = structural; This is the same GPU-tailored SPGrid variant for grid structure used in an earlier `GPU implementation of MPM `_. .. note:: For *particle buffer* and *grid buffer*, we store them in the device-local memory. If replaced with the virtual memory (*unified virtual memory* in CUDA), then the *ParticleBufferDomain* and *GridBufferDomain* could be replaced with *compact_domain* for a more straightforward access through block coordinates. However, we encountered unidentified issues utilizing the *unified virtual memory* on Window 10, and the difference between the two resulting performances is trivial. Thus we choose the former scheme which is relatively more robust and controllable. ================================================ FILE: docs/index.rst ================================================ Claymore Documentation ============================== .. toctree:: :caption: Overview :maxdepth: 3 overview compilation .. toctree:: :caption: Infrastructure :maxdepth: 3 philosophy structural sparsity system usage .. toctree:: :caption: GPU MPM :maxdepth: 3 pipeline datastructure multigmpm benchmark .. toctree:: :caption: About :maxdepth: 3 credits ================================================ FILE: docs/multigmpm.rst ================================================ Multi-GPU Design ================ Reduce Memory Overhead ---------------------- To extend from using a single GPU to running on multi-GPUs, we divide the whole simulation domain into partitions (maintained through a list of activated blocks covering all particles) according to the number of devices and assign one partition to one GPU device. An efficient utilization of multi-GPUs for MPM needs to consider the following tasks: - **Halo Block Tagging**: tag the blocks that overlap partitions on other devices (i.e., the halo blocks). - **Halo Block Merging**: share block data in the halo region with other devices after executing the G2P2G kernel, for grid reduction and/or particle migration depending on partitioning strategies. The latency of the memory transfer among GPU devices (required by the above tasks) relies highly on the underneath hardware setup. In most consumer-level machines, multi-GPU devices are connected via the slow PCI-Express x16 Gen 3, which may lead to high communication latency. Fortunately, nearly all CUDA devices with compute capability of 1.1 or higher can concurrently perform the memory copies and computing kernels. Therefore, it is viable and critical to hide the latency by overlapping data transfers with computations for a better performance scalability on multi-GPUs. .. image:: images/masking.jpg Partitioning Methods -------------------- Depending on the dynamics of the simulation, the same partitioning scheme could result in drastically different performances on various scenes. Therefore we introduce detailed designs of two MPM-tailored variations of the most widely adopted partitioning methods, i.e. the *static geometric (particle) partitioning method* and the *static spatial partitioning method*. ================================================ FILE: docs/overview.rst ================================================ Overview ============= This is the opensource code **Claymore** for the SIGGRAPH 2020 paper: **A Massively Parallel and Scalable Multi-GPU Material Point Method** `page `_, `pdf `_, `supp `_, `video `_ Authors: `Xinlei Wang\* `_, `Yuxing Qiu\* `_, `Stuart R. Slattery `_, `Yu Fang `_, `Minchen Li `_, `Song-Chun Zhu `_, `Yixin Zhu `_, `Min Tang `_, `Dinesh Manocha `_, `Chenfanfu Jiang `_ (* Equal contributions) Introduction ------------ Harnessing the power of modern multi-GPU architectures, we present a massively parallel simulation system based on the Material Point Method (MPM) for simulating physical behaviors of materials undergoing complex topological changes, self-collision, and large deformations. Our system makes three critical contributions: - Introduce a new particle data structure that promotes coalesced memory access patterns on the GPU and eliminates the need for complex atomic operations on the memory hierarchy when writing particle data to the grid. - Propose a kernel fusion approach using a new Grid-to-Particles-to-Grid (G2P2G) scheme, which efficiently reduces GPU kernel launches, improves latency, and significantly reduces the amount of global memory needed to store particle data. - Introduce optimized algorithmic designs that allow for efficient sparse grids in a shared memory context, enabling us to best utilize modern multi-GPU computational platforms for hybrid Lagrangian-Eulerian computational patterns. We demonstrate the effectiveness of our method with extensive benchmarks, evaluations, and dynamic simulations with elastoplasticity, granular media, and fluid dynamics. In comparisons against an open-source and heavily optimized CPU-based MPM codebase on an elastic sphere colliding scene with particle counts ranging from 5 to 40 million, our GPU MPM achieves over 100X per-time-step speedup on a workstation with an Intel 8086K CPU and a single Quadro P6000 GPU, exposing exciting possibilities for future MPM simulations in computer graphics and computational science. Moreover, compared to the state-of-the-art GPU MPM method, we not only achieve 2X acceleration on a single GPU but our kernel fusion strategy and Array-of-Structs-of-Array (AoSoA) data structure design also generalizes to multi-GPU systems. Our multi-GPU MPM exhibits near-perfect weak and strong scaling with 4 GPUs, enabling performant and large-scale simulations on a 1024x1024x1024 grid with close to 100 million particles with less than 4 minutes per frame on a single 4-GPU workstation and 134 million particles with less than 1 minute per frame on an 8-GPU workstation. Gallery ------------ .. image:: images/examples.jpg Bibtex ------ Please cite our paper if you use this code for your research: .. code-block:: none @article{Wang2020multiGMPM, author = {Xinlei Wang* and Yuxing Qiu* and Stuart R. Slattery and Yu Fang and Minchen Li and Song-Chun Zhu and Yixin Zhu and Min Tang and Dinesh Manocha and Chenfanfu Jiang}, title = {A Massively Parallel and Scalable Multi-GPU Material Point Method}, journal = {ACM Transactions on Graphics}, year = {2020}, volume = {39}, number = {4}, articleno = {Article 30} } ================================================ FILE: docs/philosophy.rst ================================================ Design Philosophy ================= Data-Oriented Design -------------------- Due to the increased overhead of memory over compute operations, **data-oriented design** philosophy has been widely adopted in software design. It focuses on the data layout that is efficient for certain patterns of memory access. Usually, the optimization is achieved through better utilization of caches. Here are some of the most popular libraries providing efficient data structures. - `OpenVDB `_: OpenVDB is an open source C++ library comprising a novel hierarchical data structure and a large suite of tools for the efficient storage and manipulation of sparse volumetric data discretized on three-dimensional grids. - `SPGrid `_: SPGrid is a new data structure for compact storage and efficient stream processing of sparsely populated uniform Cartesian grids. It leverages the extensive hardware acceleration mechanisms inherent in the x86 Virtual Memory Management system to deliver sequential and stencil access bandwidth comparable to dense uniform grids. - `Cabana `_: As a generalization of SoA (Struct-of-Arrays) and AoS (Array-of-Structs) layouts, AoSoA (Array-of-Structs-of-Arrays), which is adopted by **Cabana**, appears to be a robust choice for both `CPU `_ and `GPU `_ Zero-Overhead Principle ----------------------- By C++ committee, the zero-overhead principle states that: What you don’t use, you don’t pay for (in time or space) and further: What you do use, you couldn’t hand code any better. As Bjarne Stroustrup points out, it requires programming techniques, language features, and implementations to achieve such a zero-overhead abstraction. In C++ language, designing an almost zero-overhead abstraction is sophisticated and difficult. But it is worth working towards this goal. Meanwhile, such abstractions must provide more benefit than cost. Despite all the differences in the interpretations of *cost* (See `Chandler Carruth's talk `_), it is of great importance to reduce both the runtime cost as well as the build time cost (especially for C++). Sometimes there even has to be a trade-off. So we adopt the following practices in our codebase: - Use constexpr if feasible - Avoid recursive template instantiations - Encapsulate reusable units into precompiled libraries - ... ================================================ FILE: docs/pipeline.rst ================================================ Simulator Pipeline ================== Our MPM simulator adopts the explicit time-integration scheme. The conventional MPM pipeline looks like: - **Particles-to-Grid (P2G)**. Transfer mass and momentum from particles to grid nodes: :math:`\{m_p, m_p v_p^n\} \rightarrow \{m_i, m_i v_i^n\}` - **Grid Update**. Update grid velocities with either explicit or implicit time integration: :math:`v_i^{n} \rightarrow v_i^{n+1}` - **Grid-to-Particles (G2P) and Particle Advection**. Transfer velocities from grid nodes to particles, evolve particle strains, and project particle deformation gradients for plasticity (if any). Update the particle positions with their new velocities: :math:`\{v_i^{n+1}\} \rightarrow \{v_p^{n+1}, F_p^{n+1}\}`, :math:`\{p_p^{n}, v_p^{n+1}\} \rightarrow \{p_p^{n+1}\}` - **Partition Update**. Maintain the sparse data structure topology by updating the active-block array and the mapping from block coordinates to array indices. We propose a novel pipeline with a fused **G2P2G** kernel as a substitute for the original **P2G** and **G2P**. It allows less memory footprint for each particle (although in total doubled due to double-buffering required by G2P2G) and a better performance in general. .. image:: images/pipeline.jpg ================================================ FILE: docs/sparsity.rst ================================================ Sparse Data Structures ====================== In many graphics applications, e.g. ray tracing, collision detection, neighborhood search, etc., there exists a large amount of queries upon spatial data structures, and the involved volumetric data is often spatially sparse. Dedicated data structures like `OpenVDB `_ and `SPGrid `_ are introduced to provide efficient access to sparse data for specific operations. However, there is no best universal data structure for different types of sparsity and access patterns. Through the previous **Hierarchy Composition** interface, we can compose and define sparse data structures very easily in order to experiment and identify an appropriate candidate for our need. In our experiences, the sparse data structures can be categorized in terms of their underlying memory resource. - **Utilizing Virtual Memory**: rely on the virtual memory support from the underlying OS, driver and hardware. - **Manually Managing Memory**: manually maintain the sparse data, sometimes including a mapping from the discrete identifiers (e.g. spatial coordinates) to a contiguous sequence of indices. Then, providing allocators of specific memory resources to the **Structural Instance**, we complete defining the variable (instance), the internal structure of which is specified by the **Structural Node**. Here we illustrate two common key aspects. Allocation ---------- Utilizing Virtual Memory ```````````````````````` The automatic management of the virtual memory can help relieve the burden of manual maintenance. By avoiding frequent page-faults, the access to the virtual memory can be as efficient as the heap or global memory (CUDA). Depending on the location of the memory we want to allocate for the instance, the allocation APIs are different. Allocation On Host '''''''''''''''''' - Windows .. code-block:: cpp void* ptr = VirtualAlloc(nullptr, totalBytes, MEM_RESERVE, PAGE_READWRITE); - Linux .. code-block:: cpp void* ptr = mmap(nullptr, totalBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0); Allocation On Device (CUDA) ''''''''''''''''''''''''''' .. code-block:: cpp void* ptr; cudaMallocManaged((void **)&ptr, totalBytes); Manually Managing Memory ```````````````````````` The above method heavily relies on the support from the driver, and the granularity of the data unit should be on the same level as a page in the virtual memory system. Therefore it is often a more robust choice to manually manage the memory. Allocation On Host '''''''''''''''''' .. code-block:: cpp void* ptr = (void *)malloc(totalBytes); Allocation On Device (CUDA) ''''''''''''''''''''''''''' .. code-block:: cpp void* ptr; cudaMalloc((void **)&ptr, totalBytes); Modeling Sparsity ----------------- The underlying memory resource intended for the sparse data structure largely influences the design of the data structure itself. Here we discuss multiple definitions of the *SPGrid-variants* using different strategies. Utilizing Virtual Memory ```````````````````````` The virtual memory system can save the efforts of modeling the sparsity information. Simply defining the grid like a dense grid is sufficient. .. code-block:: cpp // domain using BlockDomain = domain; using GridDomain = domain; // decorator using DefaultDecorator = decorator; // structural node using grid_block_ = structural; using grid_ = structural; Manually Managing Memory ```````````````````````` When adopting this strategy, the programmer should additionally maintain the mapping from spatial block coordinates to a contiguous sequence of indices. Usually we store this mapping through a (spatial) hash table or a lookup table. And the resulting data structure for the *SPGrid-variant* essentially becomes an array of grid blocks. .. code-block:: cpp using GridBufferDomain = domain; using grid_buffer_ = structural; ================================================ FILE: docs/structural.rst ================================================ Hierarchy Composition ===================== Motivation ---------- Following the principle **Data-Oriented Design**, `Yuanming Hu `_ introduces a high-performance programming language, `Taichi `_, wherein dedicated data structures can be developed by assembling components of different properties in static hierarchies. Taichi provides a powerful and easy-to-use toolchain for developing a wide range of high-performance applications. It implements an abstraction to define multi-level spatial data structures and kernel functions through a user-friendly python front-end and a robust LLVM back-end that automatically handles memory, manages executions, and deploys to CPU or GPU. Large-scale simulations are spatially sparse in general, which pose great challenges to develop efficient data structures for specific spatial queries. In MPM simulations, such queries involves grids in the Eulerian domain and particles in the Lagrangian domain. We intend to exploit the aforementioned utility from Taichi for designing data structures. Due to the current lack of support of fully using Taichi in a C++ front-end, a substitute is provided in native CUDA/C++ environment, which is implemented by C++ template meta-programming. Please refer to our `tech doc `_ or read the following sections for more details. Components ---------- The entire infrastructure consists of the four major components: *Domain*, *Decorator*, *Structural Node*, and *Structural Instance*. For more details, please refer to *Library/MnBase/Object* in the opensourced code. Domain `````````````````````````` **Domain** describes the range for the index of a data structure. It maps from multi-dimensional coordinates to a 1D memory span. .. code-block:: cpp template struct domain { template static constexpr Tn offset(Indices&&... indices); }; Decorator `````````````````````````` **Decorator** describes the auxiliary and detailed properties regarding the data structure it decorates. .. code-block:: cpp enum class structural_allocation_policy : std::size_t { full_allocation = 0, on_demand = 1, ... }; enum class structural_padding_policy : std::size_t { compact = 0, align = 1, ... }; enum class attrib_layout : std::size_t { aos = 0, soa = 1, ... }; template struct decorator { static constexpr auto alloc_policy = alloc_policy_; static constexpr auto padding_policy = padding_policy_; static constexpr auto layout = layout_; }; Structural Node `````````````````````````` **Structural Nodes** with particular properties is formed in a hierarchy to compose a multi-level data structure. Currently, we support three types of structural nodes (i.e., hash, dense, and dynamic). We are planning to support tree in future releases. .. code-block:: cpp enum class structural_type : std::size_t { /// leaf sentinel = 0, entity = 1, /// trunk hash = 2, dense = 3, dynamic = 4, ... }; No matter what the internal relationship of elements is within a structure (either contiguous- or node-based), we assume there is at least one contiguous chunk of physical memory to store the data; the size is a multiple of the extent of the Domain and the total size of all the attributes of an element (might be padded for alignment). .. code-block:: cpp /// attribute index of a structural node using attrib_index = placeholder::placeholder_type; /// traits of structural nodes template struct structural_traits { using attribs = type_seq; using self = structural; template using value_type = ...; static constexpr auto attrib_count = sizeof...(Structurals); static constexpr std::size_t element_size = ...; static constexpr std::size_t element_storage_size = ...; /// for allocation static constexpr std::size_t size = domain::extent * element_storage_size; template struct accessor { static constexpr uintptr_t element_stride_in_bytes = ...; static constexpr uintptr_t attrib_base_offset = ...; template static constexpr uintptr_t coord_offset(Indices &&... is) { return attrib_base_offset + Domain::offset(std::forward(is)...) * element_stride_in_bytes; } template static constexpr uintptr_t linear_offset(Index &&i) { return attrib_base_offset + std::forward(i) * element_stride_in_bytes; } }; // manage memory template void allocate_handle(Allocator allocator) { if (self::size != 0) _handle.ptr = allocator.allocate(self::size); else _handle.ptr = nullptr; } template void deallocate(Allocator allocator) { allocator.deallocate(_handle.ptr, self::size); _handle.ptr = nullptr; } // access value template , typename... Indices> constexpr auto &val(std::integral_constant, Indices &&... indices) { return *reinterpret_cast(_handle.ptrval + accessor::coord_offset(std::forward(indices)...)); } template , typename Index> constexpr auto &val_1d(std::integral_constant, Index &&index) { return *reinterpret_cast( _handle.ptrval + accessor::linear_offset(std::forward(index))); } /// data member MemResource _handle; }; /// specializations of different types of structural nodes template struct structural : structural_traits {...}; We also define two special types of *Structural Nodes*, the root node and the leaf node, to form the hierarchy. .. code-block:: cpp /// special structural node template struct root_instance; template struct structural_entity; Structural Instance `````````````````````````` A variable defined by the above **Structural Node** is an **Structural Instance** spawned given an allocator at the run-time. The instance is customizable (e.g. accessing the parent node requires additional data) as it is assembled from selected data components. .. code-block:: cpp enum class structural_component_index : std::size_t { default_handle = 0, parent_scope_handle = 1, ... }; template struct structural_instance_component; /// specializations for each data component template struct structural_instance_component {...}; Besides the data components, the **Structural Instance** also inherits from the **Structural Node** that specifies the properties of itself. .. code-block:: cpp /// traits of structural instance, inherit from structural node template struct structural_instance_traits : parent_instance::attribs::template type<(std::size_t)AttribNo> { using self = typename parent_instance::attribs::type<(std::size_t)AttribNo>; using parent_indexer = typename parent_instance::domain::index; using self_indexer = typename self::domain::index; }; /// structural instance, inherit from all data components and its traits (which is derived from structural node) template struct structural_instance; template struct structural_instance> : structural_instance_traits, structural_instance_component(Cs)>... { using traits = structural_instance_traits; using component_seq = std::integer_sequence; using self_instance = structural_instance; template using accessor = typename traits::template accessor; // hierarchy traverse template constexpr auto chfull(std::integral_constant, Indices &&... indices) const { ... } template constexpr auto ch(std::integral_constant, Indices &&... indices) const { ... } template constexpr auto chptr(std::integral_constant, Indices &&... indices) const { ... } }; Usage ---------- Here, we showcase the usages of the above interface by providing an example of **SPGrid**. Basic Definitions `````````````````````````` To simplify the usage, we define certain types and variables that are frequently used. .. code-block:: cpp /// leaf node using empty_ = structural_entity; using i32_ = structural_entity; using f32_ = structural_entity; /// attribute index namespace placeholder { using placeholder_type = unsigned; constexpr auto _0 = std::integral_constant{}; constexpr auto _1 = std::integral_constant{}; ... } /// default data components for constructing instances using orphan_signature = std::integer_sequence(structural_component_index::default_handle)>; Structural Node Definition `````````````````````````` The following code defines the **SPGrid** used in our pipeline. .. code-block:: cpp // domain using BlockDomain = domain; using GridBufferDomain = domain; // decorator using DefaultDecorator = decorator; // structural node using grid_block_ = structural; using grid_buffer_ = structural; Create Structural Instance `````````````````````````` After defining the internal structure, it still requires an allocator and the list of data components to get the instance. .. code-block:: cpp template using Instance = structural_instance, (attrib_index)0, Signature>; template constexpr auto spawn(Allocator allocator) { auto ret = Instance{}; ret.allocate_handle(allocator); return ret; } auto allocator = ...; auto spgrid = spawn(allocator); Access Interface `````````````````````````` Generally, we need to provide both the attribute and child index to access a child of such an instance. .. code-block:: cpp /// acquire blockno-th grid block auto grid_block = spgrid.ch(_0, blockno); /// access cidib-th cell within this block grid_block.val_1d(_0, cidib); // access 0-th channel (mass) /// access cell within by coordinates grid_block.val(_1, cx, cy, cz); // access 1-th channel (velocity x) Internal Layout --------------- To gain a better insight into the internal layout, we here give another example. .. image:: images/structural.jpg .. code-block:: cpp using Attrib0 = structural_entity; using Attrib1 = structural_entity; using DecoratorA = decorator< structural_allocation_policy::full_allocation, structural_padding_policy::align, attrib_layout:aos>; using DecoratorB = decorator< structural_allocation_policy::full_allocation, structural_padding_policy::align, attrib_layout:soa>; using StructuralA = structural, Attr0, Attr1>; using StructuralB = Structural, Attr0, Attr1>; :caption: Two *structural nodes* are specified with different *decorators*. The arrows connecting all elements indicate the ascending order in a contiguous chunk of memory. The *structural node* can be used as an attribute of another *structural node* to form a multi-level hierarchy. Elements displayed in the grid view are accessed by an attribute index (marked with different colors) and a coordinate within its domain. Note that the memory size of each *structural* is padded to the next power of 2 due to the alignment decoration. ================================================ FILE: docs/system.rst ================================================ System ====== To conveniently reuse the code required for a specific type of tasks, we build a precompiled and customized library, i.e. **system**. It is essentially a **Singleton** class which can be selectively included and utilized by projects. CUDA ---- **CUDA** system provides CUDA related utilities, including - setting up the GPU devices, constructing necessary resources and enabling certain features. - temporary memory pools of various memory type for intermediate computations. - context handles, each corresponding to one GPU, through which programmers launch kernels, synchronize among streams, manage memory, etc. Also, a few helper functions that can be called on the host side or the device side are also included. IO ---- **IO** system currently only provide what is necessary for the MPM project, e.g. reading geometry data and outputting generated particle data asynchronously. ================================================ FILE: docs/usage.rst ================================================ Usage ===== **Q**: Use the codebase in another cmake c++ project. **A**: Directly include the codebase as a submodule, and follow the examples in the *Projects*. **Q**: Develop upon the codebase. **A**: Create a sub-folder in *Projects* with a cmake file at its root. ================================================ FILE: project_info.in ================================================ set(project_version 0.0.0) set(project_description "gpu-based mpm simulator")