From f9ea45e08136f58cdfab5a10e40099fa626e9444 Mon Sep 17 00:00:00 2001 From: coulsonwang Date: Tue, 27 Oct 2020 15:18:33 +0800 Subject: [PATCH] built iOS glslang and spirv-cross (#123) --- ios/CMakeLists.txt | 38 + ios/include/StandAlone/ResourceLimits.h | 57 + ios/include/StandAlone/resource_limits_c.h | 54 + ios/include/glslang/Include/BaseTypes.h | 571 ++++ ios/include/glslang/Include/Common.h | 292 ++ ios/include/glslang/Include/ConstantUnion.h | 974 +++++++ ios/include/glslang/Include/InfoSink.h | 144 + .../glslang/Include/InitializeGlobals.h | 44 + ios/include/glslang/Include/PoolAlloc.h | 316 +++ ios/include/glslang/Include/ResourceLimits.h | 150 + ios/include/glslang/Include/ShHandle.h | 176 ++ ios/include/glslang/Include/Types.h | 2487 +++++++++++++++++ ios/include/glslang/Include/arrays.h | 341 +++ .../glslang/Include/glslang_c_interface.h | 233 ++ .../glslang/Include/glslang_c_shader_types.h | 185 ++ ios/include/glslang/Include/intermediate.h | 1805 ++++++++++++ ios/include/glslang/Include/revision.h | 3 + .../glslang/MachineIndependent/Initialize.h | 112 + .../MachineIndependent/LiveTraverser.h | 138 + .../glslang/MachineIndependent/ParseHelper.h | 532 ++++ .../glslang/MachineIndependent/RemoveTree.h | 41 + ios/include/glslang/MachineIndependent/Scan.h | 276 ++ .../glslang/MachineIndependent/ScanContext.h | 93 + .../glslang/MachineIndependent/SymbolTable.h | 885 ++++++ .../glslang/MachineIndependent/Versions.h | 332 +++ .../glslang/MachineIndependent/attribute.h | 149 + .../glslang/MachineIndependent/gl_types.h | 210 ++ .../MachineIndependent/glslang_tab.cpp.h | 521 ++++ .../glslang/MachineIndependent/iomapper.h | 302 ++ .../MachineIndependent/localintermediate.h | 1030 +++++++ .../MachineIndependent/parseVersions.h | 240 ++ .../preprocessor/PpContext.h | 703 +++++ .../preprocessor/PpTokens.h | 179 ++ .../propagateNoContraction.h | 55 + .../glslang/MachineIndependent/reflection.h | 223 ++ ios/include/glslang/Public/ShaderLang.h | 932 ++++++ ios/include/glslang/SPIRV/GLSL.ext.AMD.h | 108 + ios/include/glslang/SPIRV/GLSL.ext.EXT.h | 39 + ios/include/glslang/SPIRV/GLSL.ext.KHR.h | 51 + ios/include/glslang/SPIRV/GLSL.ext.NV.h | 81 + ios/include/glslang/SPIRV/GLSL.std.450.h | 131 + ios/include/glslang/SPIRV/GlslangToSpv.h | 61 + ios/include/glslang/SPIRV/Logger.h | 83 + .../glslang/SPIRV/NonSemanticDebugPrintf.h | 50 + ios/include/glslang/SPIRV/SPVRemapper.h | 304 ++ ios/include/glslang/SPIRV/SpvBuilder.h | 838 ++++++ ios/include/glslang/SPIRV/SpvTools.h | 82 + ios/include/glslang/SPIRV/bitutils.h | 81 + ios/include/glslang/SPIRV/disassemble.h | 53 + ios/include/glslang/SPIRV/doc.h | 258 ++ ios/include/glslang/SPIRV/hex_float.h | 1078 +++++++ ios/include/glslang/SPIRV/spirv.hpp | 2114 ++++++++++++++ ios/include/glslang/SPIRV/spvIR.h | 485 ++++ ios/include/spirv_cross/GLSL.std.450.h | 131 + ios/include/spirv_cross/spirv.h | 2104 ++++++++++++++ ios/include/spirv_cross/spirv.hpp | 2114 ++++++++++++++ ios/include/spirv_cross/spirv_cfg.hpp | 156 ++ ios/include/spirv_cross/spirv_common.hpp | 1781 ++++++++++++ ios/include/spirv_cross/spirv_cpp.hpp | 86 + ios/include/spirv_cross/spirv_cross.hpp | 1055 +++++++ ios/include/spirv_cross/spirv_cross_c.h | 912 ++++++ .../spirv_cross/spirv_cross_containers.hpp | 734 +++++ .../spirv_cross_error_handling.hpp | 87 + .../spirv_cross/spirv_cross_parsed_ir.hpp | 231 ++ ios/include/spirv_cross/spirv_cross_util.hpp | 30 + ios/include/spirv_cross/spirv_glsl.hpp | 760 +++++ ios/include/spirv_cross/spirv_hlsl.hpp | 329 +++ ios/include/spirv_cross/spirv_msl.hpp | 962 +++++++ ios/include/spirv_cross/spirv_parser.hpp | 93 + ios/include/spirv_cross/spirv_reflect.hpp | 83 + ios/libs/glslang/libOGLCompiler.a | Bin 0 -> 2344 bytes ios/libs/glslang/libOSDependent.a | Bin 0 -> 3272 bytes ios/libs/glslang/libSPIRV.a | Bin 0 -> 663464 bytes .../libglslang-default-resource-limits.a | Bin 0 -> 44792 bytes ios/libs/glslang/libglslang.a | Bin 0 -> 2405368 bytes ios/libs/spirv-cross/libspirv-cross-core.a | Bin 0 -> 570464 bytes ios/libs/spirv-cross/libspirv-cross-glsl.a | Bin 0 -> 1196552 bytes ios/libs/spirv-cross/libspirv-cross-msl.a | Bin 0 -> 1598024 bytes 78 files changed, 32368 insertions(+) create mode 100644 ios/include/StandAlone/ResourceLimits.h create mode 100644 ios/include/StandAlone/resource_limits_c.h create mode 100644 ios/include/glslang/Include/BaseTypes.h create mode 100644 ios/include/glslang/Include/Common.h create mode 100644 ios/include/glslang/Include/ConstantUnion.h create mode 100644 ios/include/glslang/Include/InfoSink.h create mode 100644 ios/include/glslang/Include/InitializeGlobals.h create mode 100644 ios/include/glslang/Include/PoolAlloc.h create mode 100644 ios/include/glslang/Include/ResourceLimits.h create mode 100644 ios/include/glslang/Include/ShHandle.h create mode 100644 ios/include/glslang/Include/Types.h create mode 100644 ios/include/glslang/Include/arrays.h create mode 100644 ios/include/glslang/Include/glslang_c_interface.h create mode 100644 ios/include/glslang/Include/glslang_c_shader_types.h create mode 100644 ios/include/glslang/Include/intermediate.h create mode 100644 ios/include/glslang/Include/revision.h create mode 100644 ios/include/glslang/MachineIndependent/Initialize.h create mode 100644 ios/include/glslang/MachineIndependent/LiveTraverser.h create mode 100644 ios/include/glslang/MachineIndependent/ParseHelper.h create mode 100644 ios/include/glslang/MachineIndependent/RemoveTree.h create mode 100644 ios/include/glslang/MachineIndependent/Scan.h create mode 100644 ios/include/glslang/MachineIndependent/ScanContext.h create mode 100644 ios/include/glslang/MachineIndependent/SymbolTable.h create mode 100644 ios/include/glslang/MachineIndependent/Versions.h create mode 100644 ios/include/glslang/MachineIndependent/attribute.h create mode 100644 ios/include/glslang/MachineIndependent/gl_types.h create mode 100644 ios/include/glslang/MachineIndependent/glslang_tab.cpp.h create mode 100644 ios/include/glslang/MachineIndependent/iomapper.h create mode 100644 ios/include/glslang/MachineIndependent/localintermediate.h create mode 100644 ios/include/glslang/MachineIndependent/parseVersions.h create mode 100644 ios/include/glslang/MachineIndependent/preprocessor/PpContext.h create mode 100644 ios/include/glslang/MachineIndependent/preprocessor/PpTokens.h create mode 100644 ios/include/glslang/MachineIndependent/propagateNoContraction.h create mode 100644 ios/include/glslang/MachineIndependent/reflection.h create mode 100644 ios/include/glslang/Public/ShaderLang.h create mode 100644 ios/include/glslang/SPIRV/GLSL.ext.AMD.h create mode 100644 ios/include/glslang/SPIRV/GLSL.ext.EXT.h create mode 100644 ios/include/glslang/SPIRV/GLSL.ext.KHR.h create mode 100644 ios/include/glslang/SPIRV/GLSL.ext.NV.h create mode 100644 ios/include/glslang/SPIRV/GLSL.std.450.h create mode 100644 ios/include/glslang/SPIRV/GlslangToSpv.h create mode 100644 ios/include/glslang/SPIRV/Logger.h create mode 100644 ios/include/glslang/SPIRV/NonSemanticDebugPrintf.h create mode 100644 ios/include/glslang/SPIRV/SPVRemapper.h create mode 100644 ios/include/glslang/SPIRV/SpvBuilder.h create mode 100644 ios/include/glslang/SPIRV/SpvTools.h create mode 100644 ios/include/glslang/SPIRV/bitutils.h create mode 100644 ios/include/glslang/SPIRV/disassemble.h create mode 100644 ios/include/glslang/SPIRV/doc.h create mode 100644 ios/include/glslang/SPIRV/hex_float.h create mode 100644 ios/include/glslang/SPIRV/spirv.hpp create mode 100644 ios/include/glslang/SPIRV/spvIR.h create mode 100644 ios/include/spirv_cross/GLSL.std.450.h create mode 100644 ios/include/spirv_cross/spirv.h create mode 100644 ios/include/spirv_cross/spirv.hpp create mode 100644 ios/include/spirv_cross/spirv_cfg.hpp create mode 100644 ios/include/spirv_cross/spirv_common.hpp create mode 100644 ios/include/spirv_cross/spirv_cpp.hpp create mode 100644 ios/include/spirv_cross/spirv_cross.hpp create mode 100644 ios/include/spirv_cross/spirv_cross_c.h create mode 100644 ios/include/spirv_cross/spirv_cross_containers.hpp create mode 100644 ios/include/spirv_cross/spirv_cross_error_handling.hpp create mode 100644 ios/include/spirv_cross/spirv_cross_parsed_ir.hpp create mode 100644 ios/include/spirv_cross/spirv_cross_util.hpp create mode 100644 ios/include/spirv_cross/spirv_glsl.hpp create mode 100644 ios/include/spirv_cross/spirv_hlsl.hpp create mode 100644 ios/include/spirv_cross/spirv_msl.hpp create mode 100644 ios/include/spirv_cross/spirv_parser.hpp create mode 100644 ios/include/spirv_cross/spirv_reflect.hpp create mode 100644 ios/libs/glslang/libOGLCompiler.a create mode 100644 ios/libs/glslang/libOSDependent.a create mode 100644 ios/libs/glslang/libSPIRV.a create mode 100644 ios/libs/glslang/libglslang-default-resource-limits.a create mode 100644 ios/libs/glslang/libglslang.a create mode 100644 ios/libs/spirv-cross/libspirv-cross-core.a create mode 100644 ios/libs/spirv-cross/libspirv-cross-glsl.a create mode 100644 ios/libs/spirv-cross/libspirv-cross-msl.a diff --git a/ios/CMakeLists.txt b/ios/CMakeLists.txt index 09a3c180..37260e2b 100644 --- a/ios/CMakeLists.txt +++ b/ios/CMakeLists.txt @@ -94,6 +94,42 @@ if(USE_SE_JSC) set(se_libs_name ${JAVASCRIPT_CORE_LIBRARY}) endif() +add_library(glslang STATIC IMPORTED GLOBAL) +set_target_properties(glslang PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/glslang/libglslang.a +) +add_library(OGLCompiler STATIC IMPORTED GLOBAL) +set_target_properties(OGLCompiler PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/glslang/libOGLCompiler.a +) +add_library(OSDependent STATIC IMPORTED GLOBAL) +set_target_properties(OSDependent PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/glslang/libOSDependent.a +) +add_library(SPIRV STATIC IMPORTED GLOBAL) +set_target_properties(SPIRV PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/glslang/libSPIRV.a +) +add_library(glslang-default-resource-limits STATIC IMPORTED GLOBAL) +set_target_properties(glslang-default-resource-limits PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/glslang/libglslang-default-resource-limits.a +) +set(glslang_libs_name glslang OGLCompiler OSDependent SPIRV glslang-default-resource-limits) + +add_library(spirv-cross-core STATIC IMPORTED GLOBAL) +set_target_properties(spirv-cross-core PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/spirv-cross/libspirv-cross-core.a +) +add_library(spirv-cross-msl STATIC IMPORTED GLOBAL) +set_target_properties(spirv-cross-msl PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/spirv-cross/libspirv-cross-msl.a +) +add_library(spirv-cross-glsl STATIC IMPORTED GLOBAL) +set_target_properties(spirv-cross-glsl PROPERTIES + IMPORTED_LOCATION ${CMAKE_CURRENT_LIST_DIR}/libs/spirv-cross/libspirv-cross-glsl.a +) +set(spirv-cross_libs_name spirv-cross-core spirv-cross-glsl spirv-cross-msl) + list(APPEND CC_EXTERNAL_INCLUDES ${CMAKE_CURRENT_LIST_DIR}/include ) @@ -106,4 +142,6 @@ list(APPEND CC_EXTERNAL_LIBS ${se_libs_name} crypto ssl + ${glslang_libs_name} + ${spirv-cross_libs_name} ) diff --git a/ios/include/StandAlone/ResourceLimits.h b/ios/include/StandAlone/ResourceLimits.h new file mode 100644 index 00000000..736248eb --- /dev/null +++ b/ios/include/StandAlone/ResourceLimits.h @@ -0,0 +1,57 @@ +// +// Copyright (C) 2016 Google, 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. +// +// Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#ifndef _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_ +#define _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_ + +#include + +#include "../glslang/Include/ResourceLimits.h" + +namespace glslang { + +// These are the default resources for TBuiltInResources, used for both +// - parsing this string for the case where the user didn't supply one, +// - dumping out a template for user construction of a config file. +extern const TBuiltInResource DefaultTBuiltInResource; + +// Returns the DefaultTBuiltInResource as a human-readable string. +std::string GetDefaultTBuiltInResourceString(); + +// Decodes the resource limits from |config| to |resources|. +void DecodeResourceLimits(TBuiltInResource* resources, char* config); + +} // end namespace glslang + +#endif // _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_ diff --git a/ios/include/StandAlone/resource_limits_c.h b/ios/include/StandAlone/resource_limits_c.h new file mode 100644 index 00000000..108fd5e2 --- /dev/null +++ b/ios/include/StandAlone/resource_limits_c.h @@ -0,0 +1,54 @@ +/** +BSD 2-Clause License + +Copyright (c) 2020, Travis Fort +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#ifndef _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_ +#define _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_ + +#include "../glslang/Include/glslang_c_interface.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// These are the default resources for TBuiltInResources, used for both +// - parsing this string for the case where the user didn't supply one, +// - dumping out a template for user construction of a config file. +const glslang_resource_t* glslang_default_resource(void); + +// Returns the DefaultTBuiltInResource as a human-readable string. +// NOTE: User is responsible for freeing this string. +const char* glslang_default_resource_string(); + +// Decodes the resource limits from |config| to |resources|. +void glslang_decode_resource_limits(glslang_resource_t* resources, char* config); + +#ifdef __cplusplus +} +#endif + +#endif // _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_ diff --git a/ios/include/glslang/Include/BaseTypes.h b/ios/include/glslang/Include/BaseTypes.h new file mode 100644 index 00000000..b69eaebf --- /dev/null +++ b/ios/include/glslang/Include/BaseTypes.h @@ -0,0 +1,571 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2013 LunarG, Inc. +// Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _BASICTYPES_INCLUDED_ +#define _BASICTYPES_INCLUDED_ + +namespace glslang { + +// +// Basic type. Arrays, vectors, sampler details, etc., are orthogonal to this. +// +enum TBasicType { + EbtVoid, + EbtFloat, + EbtDouble, + EbtFloat16, + EbtInt8, + EbtUint8, + EbtInt16, + EbtUint16, + EbtInt, + EbtUint, + EbtInt64, + EbtUint64, + EbtBool, + EbtAtomicUint, + EbtSampler, + EbtStruct, + EbtBlock, + EbtAccStruct, + EbtReference, + EbtRayQuery, + + // HLSL types that live only temporarily. + EbtString, + + EbtNumTypes +}; + +// +// Storage qualifiers. Should align with different kinds of storage or +// resource or GLSL storage qualifier. Expansion is deprecated. +// +// N.B.: You probably DON'T want to add anything here, but rather just add it +// to the built-in variables. See the comment above TBuiltInVariable. +// +// A new built-in variable will normally be an existing qualifier, like 'in', 'out', etc. +// DO NOT follow the design pattern of, say EvqInstanceId, etc. +// +enum TStorageQualifier { + EvqTemporary, // For temporaries (within a function), read/write + EvqGlobal, // For globals read/write + EvqConst, // User-defined constant values, will be semantically constant and constant folded + EvqVaryingIn, // pipeline input, read only, also supercategory for all built-ins not included in this enum (see TBuiltInVariable) + EvqVaryingOut, // pipeline output, read/write, also supercategory for all built-ins not included in this enum (see TBuiltInVariable) + EvqUniform, // read only, shared with app + EvqBuffer, // read/write, shared with app + EvqShared, // compute shader's read/write 'shared' qualifier + + EvqPayload, + EvqPayloadIn, + EvqHitAttr, + EvqCallableData, + EvqCallableDataIn, + + // parameters + EvqIn, // also, for 'in' in the grammar before we know if it's a pipeline input or an 'in' parameter + EvqOut, // also, for 'out' in the grammar before we know if it's a pipeline output or an 'out' parameter + EvqInOut, + EvqConstReadOnly, // input; also other read-only types having neither a constant value nor constant-value semantics + + // built-ins read by vertex shader + EvqVertexId, + EvqInstanceId, + + // built-ins written by vertex shader + EvqPosition, + EvqPointSize, + EvqClipVertex, + + // built-ins read by fragment shader + EvqFace, + EvqFragCoord, + EvqPointCoord, + + // built-ins written by fragment shader + EvqFragColor, + EvqFragDepth, + + // end of list + EvqLast +}; + +// +// Subcategories of the TStorageQualifier, simply to give a direct mapping +// between built-in variable names and an numerical value (the enum). +// +// For backward compatibility, there is some redundancy between the +// TStorageQualifier and these. Existing members should both be maintained accurately. +// However, any new built-in variable (and any existing non-redundant one) +// must follow the pattern that the specific built-in is here, and only its +// general qualifier is in TStorageQualifier. +// +// Something like gl_Position, which is sometimes 'in' and sometimes 'out' +// shows up as two different built-in variables in a single stage, but +// only has a single enum in TBuiltInVariable, so both the +// TStorageQualifier and the TBuitinVariable are needed to distinguish +// between them. +// +enum TBuiltInVariable { + EbvNone, + EbvNumWorkGroups, + EbvWorkGroupSize, + EbvWorkGroupId, + EbvLocalInvocationId, + EbvGlobalInvocationId, + EbvLocalInvocationIndex, + EbvNumSubgroups, + EbvSubgroupID, + EbvSubGroupSize, + EbvSubGroupInvocation, + EbvSubGroupEqMask, + EbvSubGroupGeMask, + EbvSubGroupGtMask, + EbvSubGroupLeMask, + EbvSubGroupLtMask, + EbvSubgroupSize2, + EbvSubgroupInvocation2, + EbvSubgroupEqMask2, + EbvSubgroupGeMask2, + EbvSubgroupGtMask2, + EbvSubgroupLeMask2, + EbvSubgroupLtMask2, + EbvVertexId, + EbvInstanceId, + EbvVertexIndex, + EbvInstanceIndex, + EbvBaseVertex, + EbvBaseInstance, + EbvDrawId, + EbvPosition, + EbvPointSize, + EbvClipVertex, + EbvClipDistance, + EbvCullDistance, + EbvNormal, + EbvVertex, + EbvMultiTexCoord0, + EbvMultiTexCoord1, + EbvMultiTexCoord2, + EbvMultiTexCoord3, + EbvMultiTexCoord4, + EbvMultiTexCoord5, + EbvMultiTexCoord6, + EbvMultiTexCoord7, + EbvFrontColor, + EbvBackColor, + EbvFrontSecondaryColor, + EbvBackSecondaryColor, + EbvTexCoord, + EbvFogFragCoord, + EbvInvocationId, + EbvPrimitiveId, + EbvLayer, + EbvViewportIndex, + EbvPatchVertices, + EbvTessLevelOuter, + EbvTessLevelInner, + EbvBoundingBox, + EbvTessCoord, + EbvColor, + EbvSecondaryColor, + EbvFace, + EbvFragCoord, + EbvPointCoord, + EbvFragColor, + EbvFragData, + EbvFragDepth, + EbvFragStencilRef, + EbvSampleId, + EbvSamplePosition, + EbvSampleMask, + EbvHelperInvocation, + + EbvBaryCoordNoPersp, + EbvBaryCoordNoPerspCentroid, + EbvBaryCoordNoPerspSample, + EbvBaryCoordSmooth, + EbvBaryCoordSmoothCentroid, + EbvBaryCoordSmoothSample, + EbvBaryCoordPullModel, + + EbvViewIndex, + EbvDeviceIndex, + + EbvFragSizeEXT, + EbvFragInvocationCountEXT, + + EbvSecondaryFragDataEXT, + EbvSecondaryFragColorEXT, + + EbvViewportMaskNV, + EbvSecondaryPositionNV, + EbvSecondaryViewportMaskNV, + EbvPositionPerViewNV, + EbvViewportMaskPerViewNV, + EbvFragFullyCoveredNV, + EbvFragmentSizeNV, + EbvInvocationsPerPixelNV, + // ray tracing + EbvLaunchId, + EbvLaunchSize, + EbvInstanceCustomIndex, + EbvGeometryIndex, + EbvWorldRayOrigin, + EbvWorldRayDirection, + EbvObjectRayOrigin, + EbvObjectRayDirection, + EbvRayTmin, + EbvRayTmax, + EbvHitT, + EbvHitKind, + EbvObjectToWorld, + EbvObjectToWorld3x4, + EbvWorldToObject, + EbvWorldToObject3x4, + EbvIncomingRayFlags, + // barycentrics + EbvBaryCoordNV, + EbvBaryCoordNoPerspNV, + // mesh shaders + EbvTaskCountNV, + EbvPrimitiveCountNV, + EbvPrimitiveIndicesNV, + EbvClipDistancePerViewNV, + EbvCullDistancePerViewNV, + EbvLayerPerViewNV, + EbvMeshViewCountNV, + EbvMeshViewIndicesNV, + + // sm builtins + EbvWarpsPerSM, + EbvSMCount, + EbvWarpID, + EbvSMID, + + // HLSL built-ins that live only temporarily, until they get remapped + // to one of the above. + EbvFragDepthGreater, + EbvFragDepthLesser, + EbvGsOutputStream, + EbvOutputPatch, + EbvInputPatch, + + // structbuffer types + EbvAppendConsume, // no need to differentiate append and consume + EbvRWStructuredBuffer, + EbvStructuredBuffer, + EbvByteAddressBuffer, + EbvRWByteAddressBuffer, + + EbvLast +}; + +// In this enum, order matters; users can assume higher precision is a bigger value +// and EpqNone is 0. +enum TPrecisionQualifier { + EpqNone = 0, + EpqLow, + EpqMedium, + EpqHigh +}; + +#ifdef GLSLANG_WEB +__inline const char* GetStorageQualifierString(TStorageQualifier q) { return ""; } +__inline const char* GetPrecisionQualifierString(TPrecisionQualifier p) { return ""; } +#else +// These will show up in error messages +__inline const char* GetStorageQualifierString(TStorageQualifier q) +{ + switch (q) { + case EvqTemporary: return "temp"; break; + case EvqGlobal: return "global"; break; + case EvqConst: return "const"; break; + case EvqConstReadOnly: return "const (read only)"; break; + case EvqVaryingIn: return "in"; break; + case EvqVaryingOut: return "out"; break; + case EvqUniform: return "uniform"; break; + case EvqBuffer: return "buffer"; break; + case EvqShared: return "shared"; break; + case EvqIn: return "in"; break; + case EvqOut: return "out"; break; + case EvqInOut: return "inout"; break; + case EvqVertexId: return "gl_VertexId"; break; + case EvqInstanceId: return "gl_InstanceId"; break; + case EvqPosition: return "gl_Position"; break; + case EvqPointSize: return "gl_PointSize"; break; + case EvqClipVertex: return "gl_ClipVertex"; break; + case EvqFace: return "gl_FrontFacing"; break; + case EvqFragCoord: return "gl_FragCoord"; break; + case EvqPointCoord: return "gl_PointCoord"; break; + case EvqFragColor: return "fragColor"; break; + case EvqFragDepth: return "gl_FragDepth"; break; + case EvqPayload: return "rayPayloadNV"; break; + case EvqPayloadIn: return "rayPayloadInNV"; break; + case EvqHitAttr: return "hitAttributeNV"; break; + case EvqCallableData: return "callableDataNV"; break; + case EvqCallableDataIn: return "callableDataInNV"; break; + default: return "unknown qualifier"; + } +} + +__inline const char* GetBuiltInVariableString(TBuiltInVariable v) +{ + switch (v) { + case EbvNone: return ""; + case EbvNumWorkGroups: return "NumWorkGroups"; + case EbvWorkGroupSize: return "WorkGroupSize"; + case EbvWorkGroupId: return "WorkGroupID"; + case EbvLocalInvocationId: return "LocalInvocationID"; + case EbvGlobalInvocationId: return "GlobalInvocationID"; + case EbvLocalInvocationIndex: return "LocalInvocationIndex"; + case EbvNumSubgroups: return "NumSubgroups"; + case EbvSubgroupID: return "SubgroupID"; + case EbvSubGroupSize: return "SubGroupSize"; + case EbvSubGroupInvocation: return "SubGroupInvocation"; + case EbvSubGroupEqMask: return "SubGroupEqMask"; + case EbvSubGroupGeMask: return "SubGroupGeMask"; + case EbvSubGroupGtMask: return "SubGroupGtMask"; + case EbvSubGroupLeMask: return "SubGroupLeMask"; + case EbvSubGroupLtMask: return "SubGroupLtMask"; + case EbvSubgroupSize2: return "SubgroupSize"; + case EbvSubgroupInvocation2: return "SubgroupInvocationID"; + case EbvSubgroupEqMask2: return "SubgroupEqMask"; + case EbvSubgroupGeMask2: return "SubgroupGeMask"; + case EbvSubgroupGtMask2: return "SubgroupGtMask"; + case EbvSubgroupLeMask2: return "SubgroupLeMask"; + case EbvSubgroupLtMask2: return "SubgroupLtMask"; + case EbvVertexId: return "VertexId"; + case EbvInstanceId: return "InstanceId"; + case EbvVertexIndex: return "VertexIndex"; + case EbvInstanceIndex: return "InstanceIndex"; + case EbvBaseVertex: return "BaseVertex"; + case EbvBaseInstance: return "BaseInstance"; + case EbvDrawId: return "DrawId"; + case EbvPosition: return "Position"; + case EbvPointSize: return "PointSize"; + case EbvClipVertex: return "ClipVertex"; + case EbvClipDistance: return "ClipDistance"; + case EbvCullDistance: return "CullDistance"; + case EbvNormal: return "Normal"; + case EbvVertex: return "Vertex"; + case EbvMultiTexCoord0: return "MultiTexCoord0"; + case EbvMultiTexCoord1: return "MultiTexCoord1"; + case EbvMultiTexCoord2: return "MultiTexCoord2"; + case EbvMultiTexCoord3: return "MultiTexCoord3"; + case EbvMultiTexCoord4: return "MultiTexCoord4"; + case EbvMultiTexCoord5: return "MultiTexCoord5"; + case EbvMultiTexCoord6: return "MultiTexCoord6"; + case EbvMultiTexCoord7: return "MultiTexCoord7"; + case EbvFrontColor: return "FrontColor"; + case EbvBackColor: return "BackColor"; + case EbvFrontSecondaryColor: return "FrontSecondaryColor"; + case EbvBackSecondaryColor: return "BackSecondaryColor"; + case EbvTexCoord: return "TexCoord"; + case EbvFogFragCoord: return "FogFragCoord"; + case EbvInvocationId: return "InvocationID"; + case EbvPrimitiveId: return "PrimitiveID"; + case EbvLayer: return "Layer"; + case EbvViewportIndex: return "ViewportIndex"; + case EbvPatchVertices: return "PatchVertices"; + case EbvTessLevelOuter: return "TessLevelOuter"; + case EbvTessLevelInner: return "TessLevelInner"; + case EbvBoundingBox: return "BoundingBox"; + case EbvTessCoord: return "TessCoord"; + case EbvColor: return "Color"; + case EbvSecondaryColor: return "SecondaryColor"; + case EbvFace: return "Face"; + case EbvFragCoord: return "FragCoord"; + case EbvPointCoord: return "PointCoord"; + case EbvFragColor: return "FragColor"; + case EbvFragData: return "FragData"; + case EbvFragDepth: return "FragDepth"; + case EbvFragStencilRef: return "FragStencilRef"; + case EbvSampleId: return "SampleId"; + case EbvSamplePosition: return "SamplePosition"; + case EbvSampleMask: return "SampleMaskIn"; + case EbvHelperInvocation: return "HelperInvocation"; + + case EbvBaryCoordNoPersp: return "BaryCoordNoPersp"; + case EbvBaryCoordNoPerspCentroid: return "BaryCoordNoPerspCentroid"; + case EbvBaryCoordNoPerspSample: return "BaryCoordNoPerspSample"; + case EbvBaryCoordSmooth: return "BaryCoordSmooth"; + case EbvBaryCoordSmoothCentroid: return "BaryCoordSmoothCentroid"; + case EbvBaryCoordSmoothSample: return "BaryCoordSmoothSample"; + case EbvBaryCoordPullModel: return "BaryCoordPullModel"; + + case EbvViewIndex: return "ViewIndex"; + case EbvDeviceIndex: return "DeviceIndex"; + + case EbvFragSizeEXT: return "FragSizeEXT"; + case EbvFragInvocationCountEXT: return "FragInvocationCountEXT"; + + case EbvSecondaryFragDataEXT: return "SecondaryFragDataEXT"; + case EbvSecondaryFragColorEXT: return "SecondaryFragColorEXT"; + + case EbvViewportMaskNV: return "ViewportMaskNV"; + case EbvSecondaryPositionNV: return "SecondaryPositionNV"; + case EbvSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; + case EbvPositionPerViewNV: return "PositionPerViewNV"; + case EbvViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; + case EbvFragFullyCoveredNV: return "FragFullyCoveredNV"; + case EbvFragmentSizeNV: return "FragmentSizeNV"; + case EbvInvocationsPerPixelNV: return "InvocationsPerPixelNV"; + case EbvLaunchId: return "LaunchIdNV"; + case EbvLaunchSize: return "LaunchSizeNV"; + case EbvInstanceCustomIndex: return "InstanceCustomIndexNV"; + case EbvGeometryIndex: return "GeometryIndexEXT"; + case EbvWorldRayOrigin: return "WorldRayOriginNV"; + case EbvWorldRayDirection: return "WorldRayDirectionNV"; + case EbvObjectRayOrigin: return "ObjectRayOriginNV"; + case EbvObjectRayDirection: return "ObjectRayDirectionNV"; + case EbvRayTmin: return "ObjectRayTminNV"; + case EbvRayTmax: return "ObjectRayTmaxNV"; + case EbvHitT: return "HitTNV"; + case EbvHitKind: return "HitKindNV"; + case EbvIncomingRayFlags: return "IncomingRayFlagsNV"; + case EbvObjectToWorld: return "ObjectToWorldNV"; + case EbvWorldToObject: return "WorldToObjectNV"; + + case EbvBaryCoordNV: return "BaryCoordNV"; + case EbvBaryCoordNoPerspNV: return "BaryCoordNoPerspNV"; + + case EbvTaskCountNV: return "TaskCountNV"; + case EbvPrimitiveCountNV: return "PrimitiveCountNV"; + case EbvPrimitiveIndicesNV: return "PrimitiveIndicesNV"; + case EbvClipDistancePerViewNV: return "ClipDistancePerViewNV"; + case EbvCullDistancePerViewNV: return "CullDistancePerViewNV"; + case EbvLayerPerViewNV: return "LayerPerViewNV"; + case EbvMeshViewCountNV: return "MeshViewCountNV"; + case EbvMeshViewIndicesNV: return "MeshViewIndicesNV"; + + case EbvWarpsPerSM: return "WarpsPerSMNV"; + case EbvSMCount: return "SMCountNV"; + case EbvWarpID: return "WarpIDNV"; + case EbvSMID: return "SMIDNV"; + + default: return "unknown built-in variable"; + } +} + +__inline const char* GetPrecisionQualifierString(TPrecisionQualifier p) +{ + switch (p) { + case EpqNone: return ""; break; + case EpqLow: return "lowp"; break; + case EpqMedium: return "mediump"; break; + case EpqHigh: return "highp"; break; + default: return "unknown precision qualifier"; + } +} +#endif + +__inline bool isTypeSignedInt(TBasicType type) +{ + switch (type) { + case EbtInt8: + case EbtInt16: + case EbtInt: + case EbtInt64: + return true; + default: + return false; + } +} + +__inline bool isTypeUnsignedInt(TBasicType type) +{ + switch (type) { + case EbtUint8: + case EbtUint16: + case EbtUint: + case EbtUint64: + return true; + default: + return false; + } +} + +__inline bool isTypeInt(TBasicType type) +{ + return isTypeSignedInt(type) || isTypeUnsignedInt(type); +} + +__inline bool isTypeFloat(TBasicType type) +{ + switch (type) { + case EbtFloat: + case EbtDouble: + case EbtFloat16: + return true; + default: + return false; + } +} + +__inline int getTypeRank(TBasicType type) +{ + int res = -1; + switch(type) { + case EbtInt8: + case EbtUint8: + res = 0; + break; + case EbtInt16: + case EbtUint16: + res = 1; + break; + case EbtInt: + case EbtUint: + res = 2; + break; + case EbtInt64: + case EbtUint64: + res = 3; + break; + default: + assert(false); + break; + } + return res; +} + +} // end namespace glslang + +#endif // _BASICTYPES_INCLUDED_ diff --git a/ios/include/glslang/Include/Common.h b/ios/include/glslang/Include/Common.h new file mode 100644 index 00000000..733a790c --- /dev/null +++ b/ios/include/glslang/Include/Common.h @@ -0,0 +1,292 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2013 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _COMMON_INCLUDED_ +#define _COMMON_INCLUDED_ + + +#if defined(__ANDROID__) || (defined(_MSC_VER) && _MSC_VER < 1700) +#include +namespace std { +template +std::string to_string(const T& val) { + std::ostringstream os; + os << val; + return os.str(); +} +} +#endif + +#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/) || defined MINGW_HAS_SECURE_API + #include + #ifndef snprintf + #define snprintf sprintf_s + #endif + #define safe_vsprintf(buf,max,format,args) vsnprintf_s((buf), (max), (max), (format), (args)) +#elif defined (solaris) + #define safe_vsprintf(buf,max,format,args) vsnprintf((buf), (max), (format), (args)) + #include + #define UINT_PTR uintptr_t +#else + #define safe_vsprintf(buf,max,format,args) vsnprintf((buf), (max), (format), (args)) + #include + #define UINT_PTR uintptr_t +#endif + +#if defined(_MSC_VER) && _MSC_VER < 1800 + #include + inline long long int strtoll (const char* str, char** endptr, int base) + { + return _strtoi64(str, endptr, base); + } + inline unsigned long long int strtoull (const char* str, char** endptr, int base) + { + return _strtoui64(str, endptr, base); + } + inline long long int atoll (const char* str) + { + return strtoll(str, NULL, 10); + } +#endif + +#if defined(_MSC_VER) +#define strdup _strdup +#endif + +/* windows only pragma */ +#ifdef _MSC_VER + #pragma warning(disable : 4786) // Don't warn about too long identifiers + #pragma warning(disable : 4514) // unused inline method + #pragma warning(disable : 4201) // nameless union +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "PoolAlloc.h" + +// +// Put POOL_ALLOCATOR_NEW_DELETE in base classes to make them use this scheme. +// +#define POOL_ALLOCATOR_NEW_DELETE(A) \ + void* operator new(size_t s) { return (A).allocate(s); } \ + void* operator new(size_t, void *_Where) { return (_Where); } \ + void operator delete(void*) { } \ + void operator delete(void *, void *) { } \ + void* operator new[](size_t s) { return (A).allocate(s); } \ + void* operator new[](size_t, void *_Where) { return (_Where); } \ + void operator delete[](void*) { } \ + void operator delete[](void *, void *) { } + +namespace glslang { + + // + // Pool version of string. + // + typedef pool_allocator TStringAllocator; + typedef std::basic_string , TStringAllocator> TString; + +} // end namespace glslang + +// Repackage the std::hash for use by unordered map/set with a TString key. +namespace std { + + template<> struct hash { + std::size_t operator()(const glslang::TString& s) const + { + const unsigned _FNV_offset_basis = 2166136261U; + const unsigned _FNV_prime = 16777619U; + unsigned _Val = _FNV_offset_basis; + size_t _Count = s.size(); + const char* _First = s.c_str(); + for (size_t _Next = 0; _Next < _Count; ++_Next) + { + _Val ^= (unsigned)_First[_Next]; + _Val *= _FNV_prime; + } + + return _Val; + } + }; +} + +namespace glslang { + +inline TString* NewPoolTString(const char* s) +{ + void* memory = GetThreadPoolAllocator().allocate(sizeof(TString)); + return new(memory) TString(s); +} + +template inline T* NewPoolObject(T*) +{ + return new(GetThreadPoolAllocator().allocate(sizeof(T))) T; +} + +template inline T* NewPoolObject(T, int instances) +{ + return new(GetThreadPoolAllocator().allocate(instances * sizeof(T))) T[instances]; +} + +// +// Pool allocator versions of vectors, lists, and maps +// +template class TVector : public std::vector > { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + + typedef typename std::vector >::size_type size_type; + TVector() : std::vector >() {} + TVector(const pool_allocator& a) : std::vector >(a) {} + TVector(size_type i) : std::vector >(i) {} + TVector(size_type i, const T& val) : std::vector >(i, val) {} +}; + +template class TList : public std::list > { +}; + +template > +class TMap : public std::map > > { +}; + +template , class PRED = std::equal_to > +class TUnorderedMap : public std::unordered_map > > { +}; + +// +// Persistent string memory. Should only be used for strings that survive +// across compiles/links. +// +typedef std::basic_string TPersistString; + +// +// templatized min and max functions. +// +template T Min(const T a, const T b) { return a < b ? a : b; } +template T Max(const T a, const T b) { return a > b ? a : b; } + +// +// Create a TString object from an integer. +// +#if defined _MSC_VER || defined MINGW_HAS_SECURE_API +inline const TString String(const int i, const int base = 10) +{ + char text[16]; // 32 bit ints are at most 10 digits in base 10 + _itoa_s(i, text, sizeof(text), base); + return text; +} +#else +inline const TString String(const int i, const int /*base*/ = 10) +{ + char text[16]; // 32 bit ints are at most 10 digits in base 10 + + // we assume base 10 for all cases + snprintf(text, sizeof(text), "%d", i); + + return text; +} +#endif + +struct TSourceLoc { + void init() + { + name = nullptr; string = 0; line = 0; column = 0; + } + void init(int stringNum) { init(); string = stringNum; } + // Returns the name if it exists. Otherwise, returns the string number. + std::string getStringNameOrNum(bool quoteStringName = true) const + { + if (name != nullptr) { + TString qstr = quoteStringName ? ("\"" + *name + "\"") : *name; + std::string ret_str(qstr.c_str()); + return ret_str; + } + return std::to_string((long long)string); + } + const char* getFilename() const + { + if (name == nullptr) + return nullptr; + return name->c_str(); + } + const char* getFilenameStr() const { return name == nullptr ? "" : name->c_str(); } + TString* name; // descriptive name for this string, when a textual name is available, otherwise nullptr + int string; + int line; + int column; +}; + +class TPragmaTable : public TMap { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) +}; + +const int MaxTokenLength = 1024; + +template bool IsPow2(T powerOf2) +{ + if (powerOf2 <= 0) + return false; + + return (powerOf2 & (powerOf2 - 1)) == 0; +} + +// Round number up to a multiple of the given powerOf2, which is not +// a power, just a number that must be a power of 2. +template void RoundToPow2(T& number, int powerOf2) +{ + assert(IsPow2(powerOf2)); + number = (number + powerOf2 - 1) & ~(powerOf2 - 1); +} + +template bool IsMultipleOfPow2(T number, int powerOf2) +{ + assert(IsPow2(powerOf2)); + return ! (number & (powerOf2 - 1)); +} + +} // end namespace glslang + +#endif // _COMMON_INCLUDED_ diff --git a/ios/include/glslang/Include/ConstantUnion.h b/ios/include/glslang/Include/ConstantUnion.h new file mode 100644 index 00000000..c4ffb857 --- /dev/null +++ b/ios/include/glslang/Include/ConstantUnion.h @@ -0,0 +1,974 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2013 LunarG, Inc. +// Copyright (C) 2017 ARM Limited. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _CONSTANT_UNION_INCLUDED_ +#define _CONSTANT_UNION_INCLUDED_ + +#include "../Include/Common.h" +#include "../Include/BaseTypes.h" + +namespace glslang { + +class TConstUnion { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + + TConstUnion() : iConst(0), type(EbtInt) { } + + void setI8Const(signed char i) + { + i8Const = i; + type = EbtInt8; + } + + void setU8Const(unsigned char u) + { + u8Const = u; + type = EbtUint8; + } + + void setI16Const(signed short i) + { + i16Const = i; + type = EbtInt16; + } + + void setU16Const(unsigned short u) + { + u16Const = u; + type = EbtUint16; + } + + void setIConst(int i) + { + iConst = i; + type = EbtInt; + } + + void setUConst(unsigned int u) + { + uConst = u; + type = EbtUint; + } + + void setI64Const(long long i64) + { + i64Const = i64; + type = EbtInt64; + } + + void setU64Const(unsigned long long u64) + { + u64Const = u64; + type = EbtUint64; + } + + void setDConst(double d) + { + dConst = d; + type = EbtDouble; + } + + void setBConst(bool b) + { + bConst = b; + type = EbtBool; + } + + void setSConst(const TString* s) + { + sConst = s; + type = EbtString; + } + + signed char getI8Const() const { return i8Const; } + unsigned char getU8Const() const { return u8Const; } + signed short getI16Const() const { return i16Const; } + unsigned short getU16Const() const { return u16Const; } + int getIConst() const { return iConst; } + unsigned int getUConst() const { return uConst; } + long long getI64Const() const { return i64Const; } + unsigned long long getU64Const() const { return u64Const; } + double getDConst() const { return dConst; } + bool getBConst() const { return bConst; } + const TString* getSConst() const { return sConst; } + + bool operator==(const signed char i) const + { + if (i == i8Const) + return true; + + return false; + } + + bool operator==(const unsigned char u) const + { + if (u == u8Const) + return true; + + return false; + } + + bool operator==(const signed short i) const + { + if (i == i16Const) + return true; + + return false; + } + + bool operator==(const unsigned short u) const + { + if (u == u16Const) + return true; + + return false; + } + + bool operator==(const int i) const + { + if (i == iConst) + return true; + + return false; + } + + bool operator==(const unsigned int u) const + { + if (u == uConst) + return true; + + return false; + } + + bool operator==(const long long i64) const + { + if (i64 == i64Const) + return true; + + return false; + } + + bool operator==(const unsigned long long u64) const + { + if (u64 == u64Const) + return true; + + return false; + } + + bool operator==(const double d) const + { + if (d == dConst) + return true; + + return false; + } + + bool operator==(const bool b) const + { + if (b == bConst) + return true; + + return false; + } + + bool operator==(const TConstUnion& constant) const + { + if (constant.type != type) + return false; + + switch (type) { + case EbtInt: + if (constant.iConst == iConst) + return true; + + break; + case EbtUint: + if (constant.uConst == uConst) + return true; + + break; + case EbtBool: + if (constant.bConst == bConst) + return true; + + break; + case EbtDouble: + if (constant.dConst == dConst) + return true; + + break; + +#ifndef GLSLANG_WEB + case EbtInt16: + if (constant.i16Const == i16Const) + return true; + + break; + case EbtUint16: + if (constant.u16Const == u16Const) + return true; + + break; + case EbtInt8: + if (constant.i8Const == i8Const) + return true; + + break; + case EbtUint8: + if (constant.u8Const == u8Const) + return true; + + break; + case EbtInt64: + if (constant.i64Const == i64Const) + return true; + + break; + case EbtUint64: + if (constant.u64Const == u64Const) + return true; + + break; +#endif + default: + assert(false && "Default missing"); + } + + return false; + } + + bool operator!=(const signed char i) const + { + return !operator==(i); + } + + bool operator!=(const unsigned char u) const + { + return !operator==(u); + } + + bool operator!=(const signed short i) const + { + return !operator==(i); + } + + bool operator!=(const unsigned short u) const + { + return !operator==(u); + } + + bool operator!=(const int i) const + { + return !operator==(i); + } + + bool operator!=(const unsigned int u) const + { + return !operator==(u); + } + + bool operator!=(const long long i) const + { + return !operator==(i); + } + + bool operator!=(const unsigned long long u) const + { + return !operator==(u); + } + + bool operator!=(const float f) const + { + return !operator==(f); + } + + bool operator!=(const bool b) const + { + return !operator==(b); + } + + bool operator!=(const TConstUnion& constant) const + { + return !operator==(constant); + } + + bool operator>(const TConstUnion& constant) const + { + assert(type == constant.type); + switch (type) { + case EbtInt: + if (iConst > constant.iConst) + return true; + + return false; + case EbtUint: + if (uConst > constant.uConst) + return true; + + return false; + case EbtDouble: + if (dConst > constant.dConst) + return true; + + return false; +#ifndef GLSLANG_WEB + case EbtInt8: + if (i8Const > constant.i8Const) + return true; + + return false; + case EbtUint8: + if (u8Const > constant.u8Const) + return true; + + return false; + case EbtInt16: + if (i16Const > constant.i16Const) + return true; + + return false; + case EbtUint16: + if (u16Const > constant.u16Const) + return true; + + return false; + case EbtInt64: + if (i64Const > constant.i64Const) + return true; + + return false; + case EbtUint64: + if (u64Const > constant.u64Const) + return true; + + return false; +#endif + default: + assert(false && "Default missing"); + return false; + } + } + + bool operator<(const TConstUnion& constant) const + { + assert(type == constant.type); + switch (type) { +#ifndef GLSLANG_WEB + case EbtInt8: + if (i8Const < constant.i8Const) + return true; + + return false; + case EbtUint8: + if (u8Const < constant.u8Const) + return true; + + return false; + case EbtInt16: + if (i16Const < constant.i16Const) + return true; + + return false; + case EbtUint16: + if (u16Const < constant.u16Const) + return true; + return false; + case EbtInt64: + if (i64Const < constant.i64Const) + return true; + + return false; + case EbtUint64: + if (u64Const < constant.u64Const) + return true; + + return false; +#endif + case EbtDouble: + if (dConst < constant.dConst) + return true; + + return false; + case EbtInt: + if (iConst < constant.iConst) + return true; + + return false; + case EbtUint: + if (uConst < constant.uConst) + return true; + + return false; + default: + assert(false && "Default missing"); + return false; + } + } + + TConstUnion operator+(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst + constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst + constant.uConst); break; + case EbtDouble: returnValue.setDConst(dConst + constant.dConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const + constant.i8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const + constant.i16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const + constant.i64Const); break; + case EbtUint8: returnValue.setU8Const(u8Const + constant.u8Const); break; + case EbtUint16: returnValue.setU16Const(u16Const + constant.u16Const); break; + case EbtUint64: returnValue.setU64Const(u64Const + constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator-(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst - constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst - constant.uConst); break; + case EbtDouble: returnValue.setDConst(dConst - constant.dConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const - constant.i8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const - constant.i16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const - constant.i64Const); break; + case EbtUint8: returnValue.setU8Const(u8Const - constant.u8Const); break; + case EbtUint16: returnValue.setU16Const(u16Const - constant.u16Const); break; + case EbtUint64: returnValue.setU64Const(u64Const - constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator*(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst * constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst * constant.uConst); break; + case EbtDouble: returnValue.setDConst(dConst * constant.dConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const * constant.i8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const * constant.i16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const * constant.i64Const); break; + case EbtUint8: returnValue.setU8Const(u8Const * constant.u8Const); break; + case EbtUint16: returnValue.setU16Const(u16Const * constant.u16Const); break; + case EbtUint64: returnValue.setU64Const(u64Const * constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator%(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst % constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst % constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const % constant.i8Const); break; + case EbtInt16: returnValue.setI8Const(i8Const % constant.i16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const % constant.i64Const); break; + case EbtUint8: returnValue.setU8Const(u8Const % constant.u8Const); break; + case EbtUint16: returnValue.setU16Const(u16Const % constant.u16Const); break; + case EbtUint64: returnValue.setU64Const(u64Const % constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator>>(const TConstUnion& constant) const + { + TConstUnion returnValue; + switch (type) { +#ifndef GLSLANG_WEB + case EbtInt8: + switch (constant.type) { + case EbtInt8: returnValue.setI8Const(i8Const >> constant.i8Const); break; + case EbtUint8: returnValue.setI8Const(i8Const >> constant.u8Const); break; + case EbtInt16: returnValue.setI8Const(i8Const >> constant.i16Const); break; + case EbtUint16: returnValue.setI8Const(i8Const >> constant.u16Const); break; + case EbtInt: returnValue.setI8Const(i8Const >> constant.iConst); break; + case EbtUint: returnValue.setI8Const(i8Const >> constant.uConst); break; + case EbtInt64: returnValue.setI8Const(i8Const >> constant.i64Const); break; + case EbtUint64: returnValue.setI8Const(i8Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint8: + switch (constant.type) { + case EbtInt8: returnValue.setU8Const(u8Const >> constant.i8Const); break; + case EbtUint8: returnValue.setU8Const(u8Const >> constant.u8Const); break; + case EbtInt16: returnValue.setU8Const(u8Const >> constant.i16Const); break; + case EbtUint16: returnValue.setU8Const(u8Const >> constant.u16Const); break; + case EbtInt: returnValue.setU8Const(u8Const >> constant.iConst); break; + case EbtUint: returnValue.setU8Const(u8Const >> constant.uConst); break; + case EbtInt64: returnValue.setU8Const(u8Const >> constant.i64Const); break; + case EbtUint64: returnValue.setU8Const(u8Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtInt16: + switch (constant.type) { + case EbtInt8: returnValue.setI16Const(i16Const >> constant.i8Const); break; + case EbtUint8: returnValue.setI16Const(i16Const >> constant.u8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const >> constant.i16Const); break; + case EbtUint16: returnValue.setI16Const(i16Const >> constant.u16Const); break; + case EbtInt: returnValue.setI16Const(i16Const >> constant.iConst); break; + case EbtUint: returnValue.setI16Const(i16Const >> constant.uConst); break; + case EbtInt64: returnValue.setI16Const(i16Const >> constant.i64Const); break; + case EbtUint64: returnValue.setI16Const(i16Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint16: + switch (constant.type) { + case EbtInt8: returnValue.setU16Const(u16Const >> constant.i8Const); break; + case EbtUint8: returnValue.setU16Const(u16Const >> constant.u8Const); break; + case EbtInt16: returnValue.setU16Const(u16Const >> constant.i16Const); break; + case EbtUint16: returnValue.setU16Const(u16Const >> constant.u16Const); break; + case EbtInt: returnValue.setU16Const(u16Const >> constant.iConst); break; + case EbtUint: returnValue.setU16Const(u16Const >> constant.uConst); break; + case EbtInt64: returnValue.setU16Const(u16Const >> constant.i64Const); break; + case EbtUint64: returnValue.setU16Const(u16Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; +#endif + case EbtInt: + switch (constant.type) { + case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break; + case EbtUint: returnValue.setIConst(iConst >> constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setIConst(iConst >> constant.i8Const); break; + case EbtUint8: returnValue.setIConst(iConst >> constant.u8Const); break; + case EbtInt16: returnValue.setIConst(iConst >> constant.i16Const); break; + case EbtUint16: returnValue.setIConst(iConst >> constant.u16Const); break; + case EbtInt64: returnValue.setIConst(iConst >> constant.i64Const); break; + case EbtUint64: returnValue.setIConst(iConst >> constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + break; + case EbtUint: + switch (constant.type) { + case EbtInt: returnValue.setUConst(uConst >> constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst >> constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setUConst(uConst >> constant.i8Const); break; + case EbtUint8: returnValue.setUConst(uConst >> constant.u8Const); break; + case EbtInt16: returnValue.setUConst(uConst >> constant.i16Const); break; + case EbtUint16: returnValue.setUConst(uConst >> constant.u16Const); break; + case EbtInt64: returnValue.setUConst(uConst >> constant.i64Const); break; + case EbtUint64: returnValue.setUConst(uConst >> constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + break; +#ifndef GLSLANG_WEB + case EbtInt64: + switch (constant.type) { + case EbtInt8: returnValue.setI64Const(i64Const >> constant.i8Const); break; + case EbtUint8: returnValue.setI64Const(i64Const >> constant.u8Const); break; + case EbtInt16: returnValue.setI64Const(i64Const >> constant.i16Const); break; + case EbtUint16: returnValue.setI64Const(i64Const >> constant.u16Const); break; + case EbtInt: returnValue.setI64Const(i64Const >> constant.iConst); break; + case EbtUint: returnValue.setI64Const(i64Const >> constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const >> constant.i64Const); break; + case EbtUint64: returnValue.setI64Const(i64Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint64: + switch (constant.type) { + case EbtInt8: returnValue.setU64Const(u64Const >> constant.i8Const); break; + case EbtUint8: returnValue.setU64Const(u64Const >> constant.u8Const); break; + case EbtInt16: returnValue.setU64Const(u64Const >> constant.i16Const); break; + case EbtUint16: returnValue.setU64Const(u64Const >> constant.u16Const); break; + case EbtInt: returnValue.setU64Const(u64Const >> constant.iConst); break; + case EbtUint: returnValue.setU64Const(u64Const >> constant.uConst); break; + case EbtInt64: returnValue.setU64Const(u64Const >> constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const >> constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator<<(const TConstUnion& constant) const + { + TConstUnion returnValue; + switch (type) { +#ifndef GLSLANG_WEB + case EbtInt8: + switch (constant.type) { + case EbtInt8: returnValue.setI8Const(i8Const << constant.i8Const); break; + case EbtUint8: returnValue.setI8Const(i8Const << constant.u8Const); break; + case EbtInt16: returnValue.setI8Const(i8Const << constant.i16Const); break; + case EbtUint16: returnValue.setI8Const(i8Const << constant.u16Const); break; + case EbtInt: returnValue.setI8Const(i8Const << constant.iConst); break; + case EbtUint: returnValue.setI8Const(i8Const << constant.uConst); break; + case EbtInt64: returnValue.setI8Const(i8Const << constant.i64Const); break; + case EbtUint64: returnValue.setI8Const(i8Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint8: + switch (constant.type) { + case EbtInt8: returnValue.setU8Const(u8Const << constant.i8Const); break; + case EbtUint8: returnValue.setU8Const(u8Const << constant.u8Const); break; + case EbtInt16: returnValue.setU8Const(u8Const << constant.i16Const); break; + case EbtUint16: returnValue.setU8Const(u8Const << constant.u16Const); break; + case EbtInt: returnValue.setU8Const(u8Const << constant.iConst); break; + case EbtUint: returnValue.setU8Const(u8Const << constant.uConst); break; + case EbtInt64: returnValue.setU8Const(u8Const << constant.i64Const); break; + case EbtUint64: returnValue.setU8Const(u8Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtInt16: + switch (constant.type) { + case EbtInt8: returnValue.setI16Const(i16Const << constant.i8Const); break; + case EbtUint8: returnValue.setI16Const(i16Const << constant.u8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const << constant.i16Const); break; + case EbtUint16: returnValue.setI16Const(i16Const << constant.u16Const); break; + case EbtInt: returnValue.setI16Const(i16Const << constant.iConst); break; + case EbtUint: returnValue.setI16Const(i16Const << constant.uConst); break; + case EbtInt64: returnValue.setI16Const(i16Const << constant.i64Const); break; + case EbtUint64: returnValue.setI16Const(i16Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint16: + switch (constant.type) { + case EbtInt8: returnValue.setU16Const(u16Const << constant.i8Const); break; + case EbtUint8: returnValue.setU16Const(u16Const << constant.u8Const); break; + case EbtInt16: returnValue.setU16Const(u16Const << constant.i16Const); break; + case EbtUint16: returnValue.setU16Const(u16Const << constant.u16Const); break; + case EbtInt: returnValue.setU16Const(u16Const << constant.iConst); break; + case EbtUint: returnValue.setU16Const(u16Const << constant.uConst); break; + case EbtInt64: returnValue.setU16Const(u16Const << constant.i64Const); break; + case EbtUint64: returnValue.setU16Const(u16Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtInt64: + switch (constant.type) { + case EbtInt8: returnValue.setI64Const(i64Const << constant.i8Const); break; + case EbtUint8: returnValue.setI64Const(i64Const << constant.u8Const); break; + case EbtInt16: returnValue.setI64Const(i64Const << constant.i16Const); break; + case EbtUint16: returnValue.setI64Const(i64Const << constant.u16Const); break; + case EbtInt: returnValue.setI64Const(i64Const << constant.iConst); break; + case EbtUint: returnValue.setI64Const(i64Const << constant.uConst); break; + case EbtInt64: returnValue.setI64Const(i64Const << constant.i64Const); break; + case EbtUint64: returnValue.setI64Const(i64Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; + case EbtUint64: + switch (constant.type) { + case EbtInt8: returnValue.setU64Const(u64Const << constant.i8Const); break; + case EbtUint8: returnValue.setU64Const(u64Const << constant.u8Const); break; + case EbtInt16: returnValue.setU64Const(u64Const << constant.i16Const); break; + case EbtUint16: returnValue.setU64Const(u64Const << constant.u16Const); break; + case EbtInt: returnValue.setU64Const(u64Const << constant.iConst); break; + case EbtUint: returnValue.setU64Const(u64Const << constant.uConst); break; + case EbtInt64: returnValue.setU64Const(u64Const << constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const << constant.u64Const); break; + default: assert(false && "Default missing"); + } + break; +#endif + case EbtInt: + switch (constant.type) { + case EbtInt: returnValue.setIConst(iConst << constant.iConst); break; + case EbtUint: returnValue.setIConst(iConst << constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setIConst(iConst << constant.i8Const); break; + case EbtUint8: returnValue.setIConst(iConst << constant.u8Const); break; + case EbtInt16: returnValue.setIConst(iConst << constant.i16Const); break; + case EbtUint16: returnValue.setIConst(iConst << constant.u16Const); break; + case EbtInt64: returnValue.setIConst(iConst << constant.i64Const); break; + case EbtUint64: returnValue.setIConst(iConst << constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + break; + case EbtUint: + switch (constant.type) { + case EbtInt: returnValue.setUConst(uConst << constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst << constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setUConst(uConst << constant.i8Const); break; + case EbtUint8: returnValue.setUConst(uConst << constant.u8Const); break; + case EbtInt16: returnValue.setUConst(uConst << constant.i16Const); break; + case EbtUint16: returnValue.setUConst(uConst << constant.u16Const); break; + case EbtInt64: returnValue.setUConst(uConst << constant.i64Const); break; + case EbtUint64: returnValue.setUConst(uConst << constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + break; + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator&(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst & constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst & constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const & constant.i8Const); break; + case EbtUint8: returnValue.setU8Const(u8Const & constant.u8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const & constant.i16Const); break; + case EbtUint16: returnValue.setU16Const(u16Const & constant.u16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const & constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const & constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator|(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst | constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst | constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const | constant.i8Const); break; + case EbtUint8: returnValue.setU8Const(u8Const | constant.u8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const | constant.i16Const); break; + case EbtUint16: returnValue.setU16Const(u16Const | constant.u16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const | constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const | constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator^(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtInt: returnValue.setIConst(iConst ^ constant.iConst); break; + case EbtUint: returnValue.setUConst(uConst ^ constant.uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(i8Const ^ constant.i8Const); break; + case EbtUint8: returnValue.setU8Const(u8Const ^ constant.u8Const); break; + case EbtInt16: returnValue.setI16Const(i16Const ^ constant.i16Const); break; + case EbtUint16: returnValue.setU16Const(u16Const ^ constant.u16Const); break; + case EbtInt64: returnValue.setI64Const(i64Const ^ constant.i64Const); break; + case EbtUint64: returnValue.setU64Const(u64Const ^ constant.u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator~() const + { + TConstUnion returnValue; + switch (type) { + case EbtInt: returnValue.setIConst(~iConst); break; + case EbtUint: returnValue.setUConst(~uConst); break; +#ifndef GLSLANG_WEB + case EbtInt8: returnValue.setI8Const(~i8Const); break; + case EbtUint8: returnValue.setU8Const(~u8Const); break; + case EbtInt16: returnValue.setI16Const(~i16Const); break; + case EbtUint16: returnValue.setU16Const(~u16Const); break; + case EbtInt64: returnValue.setI64Const(~i64Const); break; + case EbtUint64: returnValue.setU64Const(~u64Const); break; +#endif + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator&&(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtBool: returnValue.setBConst(bConst && constant.bConst); break; + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TConstUnion operator||(const TConstUnion& constant) const + { + TConstUnion returnValue; + assert(type == constant.type); + switch (type) { + case EbtBool: returnValue.setBConst(bConst || constant.bConst); break; + default: assert(false && "Default missing"); + } + + return returnValue; + } + + TBasicType getType() const { return type; } + +private: + union { + signed char i8Const; // used for i8vec, scalar int8s + unsigned char u8Const; // used for u8vec, scalar uint8s + signed short i16Const; // used for i16vec, scalar int16s + unsigned short u16Const; // used for u16vec, scalar uint16s + int iConst; // used for ivec, scalar ints + unsigned int uConst; // used for uvec, scalar uints + long long i64Const; // used for i64vec, scalar int64s + unsigned long long u64Const; // used for u64vec, scalar uint64s + bool bConst; // used for bvec, scalar bools + double dConst; // used for vec, dvec, mat, dmat, scalar floats and doubles + const TString* sConst; // string constant + }; + + TBasicType type; +}; + +// Encapsulate having a pointer to an array of TConstUnion, +// which only needs to be allocated if its size is going to be +// bigger than 0. +// +// One convenience is being able to use [] to go inside the array, instead +// of C++ assuming it as an array of pointers to vectors. +// +// General usage is that the size is known up front, and it is +// created once with the proper size. +// +class TConstUnionArray { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + + TConstUnionArray() : unionArray(nullptr) { } + virtual ~TConstUnionArray() { } + + explicit TConstUnionArray(int size) + { + if (size == 0) + unionArray = nullptr; + else + unionArray = new TConstUnionVector(size); + } + TConstUnionArray(const TConstUnionArray& a) = default; + TConstUnionArray(const TConstUnionArray& a, int start, int size) + { + unionArray = new TConstUnionVector(size); + for (int i = 0; i < size; ++i) + (*unionArray)[i] = a[start + i]; + } + + // Use this constructor for a smear operation + TConstUnionArray(int size, const TConstUnion& val) + { + unionArray = new TConstUnionVector(size, val); + } + + int size() const { return unionArray ? (int)unionArray->size() : 0; } + TConstUnion& operator[](size_t index) { return (*unionArray)[index]; } + const TConstUnion& operator[](size_t index) const { return (*unionArray)[index]; } + bool operator==(const TConstUnionArray& rhs) const + { + // this includes the case that both are unallocated + if (unionArray == rhs.unionArray) + return true; + + if (! unionArray || ! rhs.unionArray) + return false; + + return *unionArray == *rhs.unionArray; + } + bool operator!=(const TConstUnionArray& rhs) const { return ! operator==(rhs); } + + double dot(const TConstUnionArray& rhs) + { + assert(rhs.unionArray->size() == unionArray->size()); + double sum = 0.0; + + for (size_t comp = 0; comp < unionArray->size(); ++comp) + sum += (*this)[comp].getDConst() * rhs[comp].getDConst(); + + return sum; + } + + bool empty() const { return unionArray == nullptr; } + +protected: + typedef TVector TConstUnionVector; + TConstUnionVector* unionArray; +}; + +} // end namespace glslang + +#endif // _CONSTANT_UNION_INCLUDED_ diff --git a/ios/include/glslang/Include/InfoSink.h b/ios/include/glslang/Include/InfoSink.h new file mode 100644 index 00000000..dceb603c --- /dev/null +++ b/ios/include/glslang/Include/InfoSink.h @@ -0,0 +1,144 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _INFOSINK_INCLUDED_ +#define _INFOSINK_INCLUDED_ + +#include "../Include/Common.h" +#include + +namespace glslang { + +// +// TPrefixType is used to centralize how info log messages start. +// See below. +// +enum TPrefixType { + EPrefixNone, + EPrefixWarning, + EPrefixError, + EPrefixInternalError, + EPrefixUnimplemented, + EPrefixNote +}; + +enum TOutputStream { + ENull = 0, + EDebugger = 0x01, + EStdOut = 0x02, + EString = 0x04, +}; +// +// Encapsulate info logs for all objects that have them. +// +// The methods are a general set of tools for getting a variety of +// messages and types inserted into the log. +// +class TInfoSinkBase { +public: + TInfoSinkBase() : outputStream(4) {} + void erase() { sink.erase(); } + TInfoSinkBase& operator<<(const TPersistString& t) { append(t); return *this; } + TInfoSinkBase& operator<<(char c) { append(1, c); return *this; } + TInfoSinkBase& operator<<(const char* s) { append(s); return *this; } + TInfoSinkBase& operator<<(int n) { append(String(n)); return *this; } + TInfoSinkBase& operator<<(unsigned int n) { append(String(n)); return *this; } + TInfoSinkBase& operator<<(float n) { const int size = 40; char buf[size]; + snprintf(buf, size, (fabs(n) > 1e-8 && fabs(n) < 1e8) || n == 0.0f ? "%f" : "%g", n); + append(buf); + return *this; } + TInfoSinkBase& operator+(const TPersistString& t) { append(t); return *this; } + TInfoSinkBase& operator+(const TString& t) { append(t); return *this; } + TInfoSinkBase& operator<<(const TString& t) { append(t); return *this; } + TInfoSinkBase& operator+(const char* s) { append(s); return *this; } + const char* c_str() const { return sink.c_str(); } + void prefix(TPrefixType message) { + switch(message) { + case EPrefixNone: break; + case EPrefixWarning: append("WARNING: "); break; + case EPrefixError: append("ERROR: "); break; + case EPrefixInternalError: append("INTERNAL ERROR: "); break; + case EPrefixUnimplemented: append("UNIMPLEMENTED: "); break; + case EPrefixNote: append("NOTE: "); break; + default: append("UNKNOWN ERROR: "); break; + } + } + void location(const TSourceLoc& loc) { + const int maxSize = 24; + char locText[maxSize]; + snprintf(locText, maxSize, ":%d", loc.line); + append(loc.getStringNameOrNum(false).c_str()); + append(locText); + append(": "); + } + void message(TPrefixType message, const char* s) { + prefix(message); + append(s); + append("\n"); + } + void message(TPrefixType message, const char* s, const TSourceLoc& loc) { + prefix(message); + location(loc); + append(s); + append("\n"); + } + + void setOutputStream(int output = 4) + { + outputStream = output; + } + +protected: + void append(const char* s); + + void append(int count, char c); + void append(const TPersistString& t); + void append(const TString& t); + + void checkMem(size_t growth) { if (sink.capacity() < sink.size() + growth + 2) + sink.reserve(sink.capacity() + sink.capacity() / 2); } + void appendToStream(const char* s); + TPersistString sink; + int outputStream; +}; + +} // end namespace glslang + +class TInfoSink { +public: + glslang::TInfoSinkBase info; + glslang::TInfoSinkBase debug; +}; + +#endif // _INFOSINK_INCLUDED_ diff --git a/ios/include/glslang/Include/InitializeGlobals.h b/ios/include/glslang/Include/InitializeGlobals.h new file mode 100644 index 00000000..95d0a40e --- /dev/null +++ b/ios/include/glslang/Include/InitializeGlobals.h @@ -0,0 +1,44 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef __INITIALIZE_GLOBALS_INCLUDED_ +#define __INITIALIZE_GLOBALS_INCLUDED_ + +namespace glslang { + +bool InitializePoolIndex(); + +} // end namespace glslang + +#endif // __INITIALIZE_GLOBALS_INCLUDED_ diff --git a/ios/include/glslang/Include/PoolAlloc.h b/ios/include/glslang/Include/PoolAlloc.h new file mode 100644 index 00000000..b8eccb88 --- /dev/null +++ b/ios/include/glslang/Include/PoolAlloc.h @@ -0,0 +1,316 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2013 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _POOLALLOC_INCLUDED_ +#define _POOLALLOC_INCLUDED_ + +#ifdef _DEBUG +# define GUARD_BLOCKS // define to enable guard block sanity checking +#endif + +// +// This header defines an allocator that can be used to efficiently +// allocate a large number of small requests for heap memory, with the +// intention that they are not individually deallocated, but rather +// collectively deallocated at one time. +// +// This simultaneously +// +// * Makes each individual allocation much more efficient; the +// typical allocation is trivial. +// * Completely avoids the cost of doing individual deallocation. +// * Saves the trouble of tracking down and plugging a large class of leaks. +// +// Individual classes can use this allocator by supplying their own +// new and delete methods. +// +// STL containers can use this allocator by using the pool_allocator +// class as the allocator (second) template argument. +// + +#include +#include +#include + +namespace glslang { + +// If we are using guard blocks, we must track each individual +// allocation. If we aren't using guard blocks, these +// never get instantiated, so won't have any impact. +// + +class TAllocation { +public: + TAllocation(size_t size, unsigned char* mem, TAllocation* prev = 0) : + size(size), mem(mem), prevAlloc(prev) { + // Allocations are bracketed: + // [allocationHeader][initialGuardBlock][userData][finalGuardBlock] + // This would be cleaner with if (guardBlockSize)..., but that + // makes the compiler print warnings about 0 length memsets, + // even with the if() protecting them. +# ifdef GUARD_BLOCKS + memset(preGuard(), guardBlockBeginVal, guardBlockSize); + memset(data(), userDataFill, size); + memset(postGuard(), guardBlockEndVal, guardBlockSize); +# endif + } + + void check() const { + checkGuardBlock(preGuard(), guardBlockBeginVal, "before"); + checkGuardBlock(postGuard(), guardBlockEndVal, "after"); + } + + void checkAllocList() const; + + // Return total size needed to accommodate user buffer of 'size', + // plus our tracking data. + inline static size_t allocationSize(size_t size) { + return size + 2 * guardBlockSize + headerSize(); + } + + // Offset from surrounding buffer to get to user data buffer. + inline static unsigned char* offsetAllocation(unsigned char* m) { + return m + guardBlockSize + headerSize(); + } + +private: + void checkGuardBlock(unsigned char* blockMem, unsigned char val, const char* locText) const; + + // Find offsets to pre and post guard blocks, and user data buffer + unsigned char* preGuard() const { return mem + headerSize(); } + unsigned char* data() const { return preGuard() + guardBlockSize; } + unsigned char* postGuard() const { return data() + size; } + + size_t size; // size of the user data area + unsigned char* mem; // beginning of our allocation (pts to header) + TAllocation* prevAlloc; // prior allocation in the chain + + const static unsigned char guardBlockBeginVal; + const static unsigned char guardBlockEndVal; + const static unsigned char userDataFill; + + const static size_t guardBlockSize; +# ifdef GUARD_BLOCKS + inline static size_t headerSize() { return sizeof(TAllocation); } +# else + inline static size_t headerSize() { return 0; } +# endif +}; + +// +// There are several stacks. One is to track the pushing and popping +// of the user, and not yet implemented. The others are simply a +// repositories of free pages or used pages. +// +// Page stacks are linked together with a simple header at the beginning +// of each allocation obtained from the underlying OS. Multi-page allocations +// are returned to the OS. Individual page allocations are kept for future +// re-use. +// +// The "page size" used is not, nor must it match, the underlying OS +// page size. But, having it be about that size or equal to a set of +// pages is likely most optimal. +// +class TPoolAllocator { +public: + TPoolAllocator(int growthIncrement = 8*1024, int allocationAlignment = 16); + + // + // Don't call the destructor just to free up the memory, call pop() + // + ~TPoolAllocator(); + + // + // Call push() to establish a new place to pop memory too. Does not + // have to be called to get things started. + // + void push(); + + // + // Call pop() to free all memory allocated since the last call to push(), + // or if no last call to push, frees all memory since first allocation. + // + void pop(); + + // + // Call popAll() to free all memory allocated. + // + void popAll(); + + // + // Call allocate() to actually acquire memory. Returns 0 if no memory + // available, otherwise a properly aligned pointer to 'numBytes' of memory. + // + void* allocate(size_t numBytes); + + // + // There is no deallocate. The point of this class is that + // deallocation can be skipped by the user of it, as the model + // of use is to simultaneously deallocate everything at once + // by calling pop(), and to not have to solve memory leak problems. + // + +protected: + friend struct tHeader; + + struct tHeader { + tHeader(tHeader* nextPage, size_t pageCount) : +#ifdef GUARD_BLOCKS + lastAllocation(0), +#endif + nextPage(nextPage), pageCount(pageCount) { } + + ~tHeader() { +#ifdef GUARD_BLOCKS + if (lastAllocation) + lastAllocation->checkAllocList(); +#endif + } + +#ifdef GUARD_BLOCKS + TAllocation* lastAllocation; +#endif + tHeader* nextPage; + size_t pageCount; + }; + + struct tAllocState { + size_t offset; + tHeader* page; + }; + typedef std::vector tAllocStack; + + // Track allocations if and only if we're using guard blocks +#ifndef GUARD_BLOCKS + void* initializeAllocation(tHeader*, unsigned char* memory, size_t) { +#else + void* initializeAllocation(tHeader* block, unsigned char* memory, size_t numBytes) { + new(memory) TAllocation(numBytes, memory, block->lastAllocation); + block->lastAllocation = reinterpret_cast(memory); +#endif + + // This is optimized entirely away if GUARD_BLOCKS is not defined. + return TAllocation::offsetAllocation(memory); + } + + size_t pageSize; // granularity of allocation from the OS + size_t alignment; // all returned allocations will be aligned at + // this granularity, which will be a power of 2 + size_t alignmentMask; + size_t headerSkip; // amount of memory to skip to make room for the + // header (basically, size of header, rounded + // up to make it aligned + size_t currentPageOffset; // next offset in top of inUseList to allocate from + tHeader* freeList; // list of popped memory + tHeader* inUseList; // list of all memory currently being used + tAllocStack stack; // stack of where to allocate from, to partition pool + + int numCalls; // just an interesting statistic + size_t totalBytes; // just an interesting statistic +private: + TPoolAllocator& operator=(const TPoolAllocator&); // don't allow assignment operator + TPoolAllocator(const TPoolAllocator&); // don't allow default copy constructor +}; + +// +// There could potentially be many pools with pops happening at +// different times. But a simple use is to have a global pop +// with everyone using the same global allocator. +// +extern TPoolAllocator& GetThreadPoolAllocator(); +void SetThreadPoolAllocator(TPoolAllocator* poolAllocator); + +// +// This STL compatible allocator is intended to be used as the allocator +// parameter to templatized STL containers, like vector and map. +// +// It will use the pools for allocation, and not +// do any deallocation, but will still do destruction. +// +template +class pool_allocator { +public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T *pointer; + typedef const T *const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef T value_type; + template + struct rebind { + typedef pool_allocator other; + }; + pointer address(reference x) const { return &x; } + const_pointer address(const_reference x) const { return &x; } + + pool_allocator() : allocator(GetThreadPoolAllocator()) { } + pool_allocator(TPoolAllocator& a) : allocator(a) { } + pool_allocator(const pool_allocator& p) : allocator(p.allocator) { } + + template + pool_allocator(const pool_allocator& p) : allocator(p.getAllocator()) { } + + pointer allocate(size_type n) { + return reinterpret_cast(getAllocator().allocate(n * sizeof(T))); } + pointer allocate(size_type n, const void*) { + return reinterpret_cast(getAllocator().allocate(n * sizeof(T))); } + + void deallocate(void*, size_type) { } + void deallocate(pointer, size_type) { } + + pointer _Charalloc(size_t n) { + return reinterpret_cast(getAllocator().allocate(n)); } + + void construct(pointer p, const T& val) { new ((void *)p) T(val); } + void destroy(pointer p) { p->T::~T(); } + + bool operator==(const pool_allocator& rhs) const { return &getAllocator() == &rhs.getAllocator(); } + bool operator!=(const pool_allocator& rhs) const { return &getAllocator() != &rhs.getAllocator(); } + + size_type max_size() const { return static_cast(-1) / sizeof(T); } + size_type max_size(int size) const { return static_cast(-1) / size; } + + TPoolAllocator& getAllocator() const { return allocator; } + +protected: + pool_allocator& operator=(const pool_allocator&) { return *this; } + TPoolAllocator& allocator; +}; + +} // end namespace glslang + +#endif // _POOLALLOC_INCLUDED_ diff --git a/ios/include/glslang/Include/ResourceLimits.h b/ios/include/glslang/Include/ResourceLimits.h new file mode 100644 index 00000000..b670cf16 --- /dev/null +++ b/ios/include/glslang/Include/ResourceLimits.h @@ -0,0 +1,150 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2013 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _RESOURCE_LIMITS_INCLUDED_ +#define _RESOURCE_LIMITS_INCLUDED_ + +struct TLimits { + bool nonInductiveForLoops; + bool whileLoops; + bool doWhileLoops; + bool generalUniformIndexing; + bool generalAttributeMatrixVectorIndexing; + bool generalVaryingIndexing; + bool generalSamplerIndexing; + bool generalVariableIndexing; + bool generalConstantMatrixVectorIndexing; +}; + +struct TBuiltInResource { + int maxLights; + int maxClipPlanes; + int maxTextureUnits; + int maxTextureCoords; + int maxVertexAttribs; + int maxVertexUniformComponents; + int maxVaryingFloats; + int maxVertexTextureImageUnits; + int maxCombinedTextureImageUnits; + int maxTextureImageUnits; + int maxFragmentUniformComponents; + int maxDrawBuffers; + int maxVertexUniformVectors; + int maxVaryingVectors; + int maxFragmentUniformVectors; + int maxVertexOutputVectors; + int maxFragmentInputVectors; + int minProgramTexelOffset; + int maxProgramTexelOffset; + int maxClipDistances; + int maxComputeWorkGroupCountX; + int maxComputeWorkGroupCountY; + int maxComputeWorkGroupCountZ; + int maxComputeWorkGroupSizeX; + int maxComputeWorkGroupSizeY; + int maxComputeWorkGroupSizeZ; + int maxComputeUniformComponents; + int maxComputeTextureImageUnits; + int maxComputeImageUniforms; + int maxComputeAtomicCounters; + int maxComputeAtomicCounterBuffers; + int maxVaryingComponents; + int maxVertexOutputComponents; + int maxGeometryInputComponents; + int maxGeometryOutputComponents; + int maxFragmentInputComponents; + int maxImageUnits; + int maxCombinedImageUnitsAndFragmentOutputs; + int maxCombinedShaderOutputResources; + int maxImageSamples; + int maxVertexImageUniforms; + int maxTessControlImageUniforms; + int maxTessEvaluationImageUniforms; + int maxGeometryImageUniforms; + int maxFragmentImageUniforms; + int maxCombinedImageUniforms; + int maxGeometryTextureImageUnits; + int maxGeometryOutputVertices; + int maxGeometryTotalOutputComponents; + int maxGeometryUniformComponents; + int maxGeometryVaryingComponents; + int maxTessControlInputComponents; + int maxTessControlOutputComponents; + int maxTessControlTextureImageUnits; + int maxTessControlUniformComponents; + int maxTessControlTotalOutputComponents; + int maxTessEvaluationInputComponents; + int maxTessEvaluationOutputComponents; + int maxTessEvaluationTextureImageUnits; + int maxTessEvaluationUniformComponents; + int maxTessPatchComponents; + int maxPatchVertices; + int maxTessGenLevel; + int maxViewports; + int maxVertexAtomicCounters; + int maxTessControlAtomicCounters; + int maxTessEvaluationAtomicCounters; + int maxGeometryAtomicCounters; + int maxFragmentAtomicCounters; + int maxCombinedAtomicCounters; + int maxAtomicCounterBindings; + int maxVertexAtomicCounterBuffers; + int maxTessControlAtomicCounterBuffers; + int maxTessEvaluationAtomicCounterBuffers; + int maxGeometryAtomicCounterBuffers; + int maxFragmentAtomicCounterBuffers; + int maxCombinedAtomicCounterBuffers; + int maxAtomicCounterBufferSize; + int maxTransformFeedbackBuffers; + int maxTransformFeedbackInterleavedComponents; + int maxCullDistances; + int maxCombinedClipAndCullDistances; + int maxSamples; + int maxMeshOutputVerticesNV; + int maxMeshOutputPrimitivesNV; + int maxMeshWorkGroupSizeX_NV; + int maxMeshWorkGroupSizeY_NV; + int maxMeshWorkGroupSizeZ_NV; + int maxTaskWorkGroupSizeX_NV; + int maxTaskWorkGroupSizeY_NV; + int maxTaskWorkGroupSizeZ_NV; + int maxMeshViewCountNV; + int maxDualSourceDrawBuffersEXT; + + TLimits limits; +}; + +#endif // _RESOURCE_LIMITS_INCLUDED_ diff --git a/ios/include/glslang/Include/ShHandle.h b/ios/include/glslang/Include/ShHandle.h new file mode 100644 index 00000000..df07bd8e --- /dev/null +++ b/ios/include/glslang/Include/ShHandle.h @@ -0,0 +1,176 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _SHHANDLE_INCLUDED_ +#define _SHHANDLE_INCLUDED_ + +// +// Machine independent part of the compiler private objects +// sent as ShHandle to the driver. +// +// This should not be included by driver code. +// + +#define SH_EXPORTING +#include "../Public/ShaderLang.h" +#include "../MachineIndependent/Versions.h" +#include "InfoSink.h" + +class TCompiler; +class TLinker; +class TUniformMap; + +// +// The base class used to back handles returned to the driver. +// +class TShHandleBase { +public: + TShHandleBase() { pool = new glslang::TPoolAllocator; } + virtual ~TShHandleBase() { delete pool; } + virtual TCompiler* getAsCompiler() { return 0; } + virtual TLinker* getAsLinker() { return 0; } + virtual TUniformMap* getAsUniformMap() { return 0; } + virtual glslang::TPoolAllocator* getPool() const { return pool; } +private: + glslang::TPoolAllocator* pool; +}; + +// +// The base class for the machine dependent linker to derive from +// for managing where uniforms live. +// +class TUniformMap : public TShHandleBase { +public: + TUniformMap() { } + virtual ~TUniformMap() { } + virtual TUniformMap* getAsUniformMap() { return this; } + virtual int getLocation(const char* name) = 0; + virtual TInfoSink& getInfoSink() { return infoSink; } + TInfoSink infoSink; +}; + +class TIntermNode; + +// +// The base class for the machine dependent compiler to derive from +// for managing object code from the compile. +// +class TCompiler : public TShHandleBase { +public: + TCompiler(EShLanguage l, TInfoSink& sink) : infoSink(sink) , language(l), haveValidObjectCode(false) { } + virtual ~TCompiler() { } + EShLanguage getLanguage() { return language; } + virtual TInfoSink& getInfoSink() { return infoSink; } + + virtual bool compile(TIntermNode* root, int version = 0, EProfile profile = ENoProfile) = 0; + + virtual TCompiler* getAsCompiler() { return this; } + virtual bool linkable() { return haveValidObjectCode; } + + TInfoSink& infoSink; +protected: + TCompiler& operator=(TCompiler&); + + EShLanguage language; + bool haveValidObjectCode; +}; + +// +// Link operations are based on a list of compile results... +// +typedef glslang::TVector TCompilerList; +typedef glslang::TVector THandleList; + +// +// The base class for the machine dependent linker to derive from +// to manage the resulting executable. +// + +class TLinker : public TShHandleBase { +public: + TLinker(EShExecutable e, TInfoSink& iSink) : + infoSink(iSink), + executable(e), + haveReturnableObjectCode(false), + appAttributeBindings(0), + fixedAttributeBindings(0), + excludedAttributes(0), + excludedCount(0), + uniformBindings(0) { } + virtual TLinker* getAsLinker() { return this; } + virtual ~TLinker() { } + virtual bool link(TCompilerList&, TUniformMap*) = 0; + virtual bool link(THandleList&) { return false; } + virtual void setAppAttributeBindings(const ShBindingTable* t) { appAttributeBindings = t; } + virtual void setFixedAttributeBindings(const ShBindingTable* t) { fixedAttributeBindings = t; } + virtual void getAttributeBindings(ShBindingTable const **t) const = 0; + virtual void setExcludedAttributes(const int* attributes, int count) { excludedAttributes = attributes; excludedCount = count; } + virtual ShBindingTable* getUniformBindings() const { return uniformBindings; } + virtual const void* getObjectCode() const { return 0; } // a real compiler would be returning object code here + virtual TInfoSink& getInfoSink() { return infoSink; } + TInfoSink& infoSink; +protected: + TLinker& operator=(TLinker&); + EShExecutable executable; + bool haveReturnableObjectCode; // true when objectCode is acceptable to send to driver + + const ShBindingTable* appAttributeBindings; + const ShBindingTable* fixedAttributeBindings; + const int* excludedAttributes; + int excludedCount; + ShBindingTable* uniformBindings; // created by the linker +}; + +// +// This is the interface between the machine independent code +// and the machine dependent code. +// +// The machine dependent code should derive from the classes +// above. Then Construct*() and Delete*() will create and +// destroy the machine dependent objects, which contain the +// above machine independent information. +// +TCompiler* ConstructCompiler(EShLanguage, int); + +TShHandleBase* ConstructLinker(EShExecutable, int); +TShHandleBase* ConstructBindings(); +void DeleteLinker(TShHandleBase*); +void DeleteBindingList(TShHandleBase* bindingList); + +TUniformMap* ConstructUniformMap(); +void DeleteCompiler(TCompiler*); + +void DeleteUniformMap(TUniformMap*); + +#endif // _SHHANDLE_INCLUDED_ diff --git a/ios/include/glslang/Include/Types.h b/ios/include/glslang/Include/Types.h new file mode 100644 index 00000000..235ea3f1 --- /dev/null +++ b/ios/include/glslang/Include/Types.h @@ -0,0 +1,2487 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2016 LunarG, Inc. +// Copyright (C) 2015-2016 Google, Inc. +// Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _TYPES_INCLUDED +#define _TYPES_INCLUDED + +#include "../Include/Common.h" +#include "../Include/BaseTypes.h" +#include "../Public/ShaderLang.h" +#include "arrays.h" + +#include + +namespace glslang { + +const int GlslangMaxTypeLength = 200; // TODO: need to print block/struct one member per line, so this can stay bounded + +const char* const AnonymousPrefix = "anon@"; // for something like a block whose members can be directly accessed +inline bool IsAnonymous(const TString& name) +{ + return name.compare(0, 5, AnonymousPrefix) == 0; +} + +// +// Details within a sampler type +// +enum TSamplerDim { + EsdNone, + Esd1D, + Esd2D, + Esd3D, + EsdCube, + EsdRect, + EsdBuffer, + EsdSubpass, // goes only with non-sampled image (image is true) + EsdNumDims +}; + +struct TSampler { // misnomer now; includes images, textures without sampler, and textures with sampler + TBasicType type : 8; // type returned by sampler + TSamplerDim dim : 8; + bool arrayed : 1; + bool shadow : 1; + bool ms : 1; + bool image : 1; // image, combined should be false + bool combined : 1; // true means texture is combined with a sampler, false means texture with no sampler + bool sampler : 1; // true means a pure sampler, other fields should be clear() + +#ifdef GLSLANG_WEB + bool is1D() const { return false; } + bool isBuffer() const { return false; } + bool isRect() const { return false; } + bool isSubpass() const { return false; } + bool isCombined() const { return true; } + bool isImage() const { return false; } + bool isImageClass() const { return false; } + bool isMultiSample() const { return false; } + bool isExternal() const { return false; } + void setExternal(bool e) { } + bool isYuv() const { return false; } +#else + unsigned int vectorSize : 3; // vector return type size. + // Some languages support structures as sample results. Storing the whole structure in the + // TSampler is too large, so there is an index to a separate table. + static const unsigned structReturnIndexBits = 4; // number of index bits to use. + static const unsigned structReturnSlots = (1< TTypeList; + +typedef TVector TIdentifierList; + +// +// Following are a series of helper enums for managing layouts and qualifiers, +// used for TPublicType, TType, others. +// + +enum TLayoutPacking { + ElpNone, + ElpShared, // default, but different than saying nothing + ElpStd140, + ElpStd430, + ElpPacked, + ElpScalar, + ElpCount // If expanding, see bitfield width below +}; + +enum TLayoutMatrix { + ElmNone, + ElmRowMajor, + ElmColumnMajor, // default, but different than saying nothing + ElmCount // If expanding, see bitfield width below +}; + +// Union of geometry shader and tessellation shader geometry types. +// They don't go into TType, but rather have current state per shader or +// active parser type (TPublicType). +enum TLayoutGeometry { + ElgNone, + ElgPoints, + ElgLines, + ElgLinesAdjacency, + ElgLineStrip, + ElgTriangles, + ElgTrianglesAdjacency, + ElgTriangleStrip, + ElgQuads, + ElgIsolines, +}; + +enum TVertexSpacing { + EvsNone, + EvsEqual, + EvsFractionalEven, + EvsFractionalOdd +}; + +enum TVertexOrder { + EvoNone, + EvoCw, + EvoCcw +}; + +// Note: order matters, as type of format is done by comparison. +enum TLayoutFormat { + ElfNone, + + // Float image + ElfRgba32f, + ElfRgba16f, + ElfR32f, + ElfRgba8, + ElfRgba8Snorm, + + ElfEsFloatGuard, // to help with comparisons + + ElfRg32f, + ElfRg16f, + ElfR11fG11fB10f, + ElfR16f, + ElfRgba16, + ElfRgb10A2, + ElfRg16, + ElfRg8, + ElfR16, + ElfR8, + ElfRgba16Snorm, + ElfRg16Snorm, + ElfRg8Snorm, + ElfR16Snorm, + ElfR8Snorm, + + ElfFloatGuard, // to help with comparisons + + // Int image + ElfRgba32i, + ElfRgba16i, + ElfRgba8i, + ElfR32i, + + ElfEsIntGuard, // to help with comparisons + + ElfRg32i, + ElfRg16i, + ElfRg8i, + ElfR16i, + ElfR8i, + + ElfIntGuard, // to help with comparisons + + // Uint image + ElfRgba32ui, + ElfRgba16ui, + ElfRgba8ui, + ElfR32ui, + + ElfEsUintGuard, // to help with comparisons + + ElfRg32ui, + ElfRg16ui, + ElfRgb10a2ui, + ElfRg8ui, + ElfR16ui, + ElfR8ui, + + ElfCount +}; + +enum TLayoutDepth { + EldNone, + EldAny, + EldGreater, + EldLess, + EldUnchanged, + + EldCount +}; + +enum TBlendEquationShift { + // No 'EBlendNone': + // These are used as bit-shift amounts. A mask of such shifts will have type 'int', + // and in that space, 0 means no bits set, or none. In this enum, 0 means (1 << 0), a bit is set. + EBlendMultiply, + EBlendScreen, + EBlendOverlay, + EBlendDarken, + EBlendLighten, + EBlendColordodge, + EBlendColorburn, + EBlendHardlight, + EBlendSoftlight, + EBlendDifference, + EBlendExclusion, + EBlendHslHue, + EBlendHslSaturation, + EBlendHslColor, + EBlendHslLuminosity, + EBlendAllEquations, + + EBlendCount +}; + +enum TInterlockOrdering { + EioNone, + EioPixelInterlockOrdered, + EioPixelInterlockUnordered, + EioSampleInterlockOrdered, + EioSampleInterlockUnordered, + EioShadingRateInterlockOrdered, + EioShadingRateInterlockUnordered, + + EioCount, +}; + +enum TShaderInterface +{ + // Includes both uniform blocks and buffer blocks + EsiUniform = 0, + EsiInput, + EsiOutput, + EsiNone, + + EsiCount +}; + + +class TQualifier { +public: + static const int layoutNotSet = -1; + + void clear() + { + precision = EpqNone; + invariant = false; + makeTemporary(); + declaredBuiltIn = EbvNone; +#ifndef GLSLANG_WEB + noContraction = false; +#endif + } + + // drop qualifiers that don't belong in a temporary variable + void makeTemporary() + { + semanticName = nullptr; + storage = EvqTemporary; + builtIn = EbvNone; + clearInterstage(); + clearMemory(); + specConstant = false; + nonUniform = false; + clearLayout(); + } + + void clearInterstage() + { + clearInterpolation(); +#ifndef GLSLANG_WEB + patch = false; + sample = false; +#endif + } + + void clearInterpolation() + { + centroid = false; + smooth = false; + flat = false; +#ifndef GLSLANG_WEB + nopersp = false; + explicitInterp = false; + pervertexNV = false; + perPrimitiveNV = false; + perViewNV = false; + perTaskNV = false; +#endif + } + + void clearMemory() + { +#ifndef GLSLANG_WEB + coherent = false; + devicecoherent = false; + queuefamilycoherent = false; + workgroupcoherent = false; + subgroupcoherent = false; + shadercallcoherent = false; + nonprivate = false; + volatil = false; + restrict = false; + readonly = false; + writeonly = false; +#endif + } + + const char* semanticName; + TStorageQualifier storage : 6; + TBuiltInVariable builtIn : 9; + TBuiltInVariable declaredBuiltIn : 9; + static_assert(EbvLast < 256, "need to increase size of TBuiltInVariable bitfields!"); + TPrecisionQualifier precision : 3; + bool invariant : 1; // require canonical treatment for cross-shader invariance + bool centroid : 1; + bool smooth : 1; + bool flat : 1; + // having a constant_id is not sufficient: expressions have no id, but are still specConstant + bool specConstant : 1; + bool nonUniform : 1; + bool explicitOffset : 1; + +#ifdef GLSLANG_WEB + bool isWriteOnly() const { return false; } + bool isReadOnly() const { return false; } + bool isRestrict() const { return false; } + bool isCoherent() const { return false; } + bool isVolatile() const { return false; } + bool isSample() const { return false; } + bool isMemory() const { return false; } + bool isMemoryQualifierImageAndSSBOOnly() const { return false; } + bool bufferReferenceNeedsVulkanMemoryModel() const { return false; } + bool isInterpolation() const { return flat || smooth; } + bool isExplicitInterpolation() const { return false; } + bool isAuxiliary() const { return centroid; } + bool isPatch() const { return false; } + bool isNoContraction() const { return false; } + void setNoContraction() { } + bool isPervertexNV() const { return false; } +#else + bool noContraction: 1; // prevent contraction and reassociation, e.g., for 'precise' keyword, and expressions it affects + bool nopersp : 1; + bool explicitInterp : 1; + bool pervertexNV : 1; + bool perPrimitiveNV : 1; + bool perViewNV : 1; + bool perTaskNV : 1; + bool patch : 1; + bool sample : 1; + bool restrict : 1; + bool readonly : 1; + bool writeonly : 1; + bool coherent : 1; + bool volatil : 1; + bool devicecoherent : 1; + bool queuefamilycoherent : 1; + bool workgroupcoherent : 1; + bool subgroupcoherent : 1; + bool shadercallcoherent : 1; + bool nonprivate : 1; + bool isWriteOnly() const { return writeonly; } + bool isReadOnly() const { return readonly; } + bool isRestrict() const { return restrict; } + bool isCoherent() const { return coherent; } + bool isVolatile() const { return volatil; } + bool isSample() const { return sample; } + bool isMemory() const + { + return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly || nonprivate; + } + bool isMemoryQualifierImageAndSSBOOnly() const + { + return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly; + } + bool bufferReferenceNeedsVulkanMemoryModel() const + { + // include qualifiers that map to load/store availability/visibility/nonprivate memory access operands + return subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || nonprivate; + } + bool isInterpolation() const + { + return flat || smooth || nopersp || explicitInterp; + } + bool isExplicitInterpolation() const + { + return explicitInterp; + } + bool isAuxiliary() const + { + return centroid || patch || sample || pervertexNV; + } + bool isPatch() const { return patch; } + bool isNoContraction() const { return noContraction; } + void setNoContraction() { noContraction = true; } + bool isPervertexNV() const { return pervertexNV; } +#endif + + bool isPipeInput() const + { + switch (storage) { + case EvqVaryingIn: + case EvqFragCoord: + case EvqPointCoord: + case EvqFace: + case EvqVertexId: + case EvqInstanceId: + return true; + default: + return false; + } + } + + bool isPipeOutput() const + { + switch (storage) { + case EvqPosition: + case EvqPointSize: + case EvqClipVertex: + case EvqVaryingOut: + case EvqFragColor: + case EvqFragDepth: + return true; + default: + return false; + } + } + + bool isParamInput() const + { + switch (storage) { + case EvqIn: + case EvqInOut: + case EvqConstReadOnly: + return true; + default: + return false; + } + } + + bool isParamOutput() const + { + switch (storage) { + case EvqOut: + case EvqInOut: + return true; + default: + return false; + } + } + + bool isUniformOrBuffer() const + { + switch (storage) { + case EvqUniform: + case EvqBuffer: + return true; + default: + return false; + } + } + + bool isIo() const + { + switch (storage) { + case EvqUniform: + case EvqBuffer: + case EvqVaryingIn: + case EvqFragCoord: + case EvqPointCoord: + case EvqFace: + case EvqVertexId: + case EvqInstanceId: + case EvqPosition: + case EvqPointSize: + case EvqClipVertex: + case EvqVaryingOut: + case EvqFragColor: + case EvqFragDepth: + return true; + default: + return false; + } + } + + // non-built-in symbols that might link between compilation units + bool isLinkable() const + { + switch (storage) { + case EvqGlobal: + case EvqVaryingIn: + case EvqVaryingOut: + case EvqUniform: + case EvqBuffer: + case EvqShared: + return true; + default: + return false; + } + } + +#ifdef GLSLANG_WEB + bool isPerView() const { return false; } + bool isTaskMemory() const { return false; } + bool isArrayedIo(EShLanguage language) const { return false; } +#else + bool isPerPrimitive() const { return perPrimitiveNV; } + bool isPerView() const { return perViewNV; } + bool isTaskMemory() const { return perTaskNV; } + + // True if this type of IO is supposed to be arrayed with extra level for per-vertex data + bool isArrayedIo(EShLanguage language) const + { + switch (language) { + case EShLangGeometry: + return isPipeInput(); + case EShLangTessControl: + return ! patch && (isPipeInput() || isPipeOutput()); + case EShLangTessEvaluation: + return ! patch && isPipeInput(); + case EShLangFragment: + return pervertexNV && isPipeInput(); + case EShLangMeshNV: + return ! perTaskNV && isPipeOutput(); + + default: + return false; + } + } +#endif + + // Implementing an embedded layout-qualifier class here, since C++ can't have a real class bitfield + void clearLayout() // all layout + { + clearUniformLayout(); + +#ifndef GLSLANG_WEB + layoutPushConstant = false; + layoutBufferReference = false; + layoutPassthrough = false; + layoutViewportRelative = false; + // -2048 as the default value indicating layoutSecondaryViewportRelative is not set + layoutSecondaryViewportRelativeOffset = -2048; + layoutShaderRecord = false; + layoutBufferReferenceAlign = layoutBufferReferenceAlignEnd; + layoutFormat = ElfNone; +#endif + + clearInterstageLayout(); + + layoutSpecConstantId = layoutSpecConstantIdEnd; + } + void clearInterstageLayout() + { + layoutLocation = layoutLocationEnd; + layoutComponent = layoutComponentEnd; +#ifndef GLSLANG_WEB + layoutIndex = layoutIndexEnd; + clearStreamLayout(); + clearXfbLayout(); +#endif + } + +#ifndef GLSLANG_WEB + void clearStreamLayout() + { + layoutStream = layoutStreamEnd; + } + void clearXfbLayout() + { + layoutXfbBuffer = layoutXfbBufferEnd; + layoutXfbStride = layoutXfbStrideEnd; + layoutXfbOffset = layoutXfbOffsetEnd; + } +#endif + + bool hasNonXfbLayout() const + { + return hasUniformLayout() || + hasAnyLocation() || + hasStream() || + hasFormat() || + isShaderRecord() || + isPushConstant() || + hasBufferReference(); + } + bool hasLayout() const + { + return hasNonXfbLayout() || + hasXfb(); + } + TLayoutMatrix layoutMatrix : 3; + TLayoutPacking layoutPacking : 4; + int layoutOffset; + int layoutAlign; + + unsigned int layoutLocation : 12; + static const unsigned int layoutLocationEnd = 0xFFF; + + unsigned int layoutComponent : 3; + static const unsigned int layoutComponentEnd = 4; + + unsigned int layoutSet : 7; + static const unsigned int layoutSetEnd = 0x3F; + + unsigned int layoutBinding : 16; + static const unsigned int layoutBindingEnd = 0xFFFF; + + unsigned int layoutIndex : 8; + static const unsigned int layoutIndexEnd = 0xFF; + + unsigned int layoutStream : 8; + static const unsigned int layoutStreamEnd = 0xFF; + + unsigned int layoutXfbBuffer : 4; + static const unsigned int layoutXfbBufferEnd = 0xF; + + unsigned int layoutXfbStride : 14; + static const unsigned int layoutXfbStrideEnd = 0x3FFF; + + unsigned int layoutXfbOffset : 13; + static const unsigned int layoutXfbOffsetEnd = 0x1FFF; + + unsigned int layoutAttachment : 8; // for input_attachment_index + static const unsigned int layoutAttachmentEnd = 0XFF; + + unsigned int layoutSpecConstantId : 11; + static const unsigned int layoutSpecConstantIdEnd = 0x7FF; + +#ifndef GLSLANG_WEB + // stored as log2 of the actual alignment value + unsigned int layoutBufferReferenceAlign : 6; + static const unsigned int layoutBufferReferenceAlignEnd = 0x3F; + + TLayoutFormat layoutFormat : 8; + + bool layoutPushConstant; + bool layoutBufferReference; + bool layoutPassthrough; + bool layoutViewportRelative; + int layoutSecondaryViewportRelativeOffset; + bool layoutShaderRecord; +#endif + + bool hasUniformLayout() const + { + return hasMatrix() || + hasPacking() || + hasOffset() || + hasBinding() || + hasSet() || + hasAlign(); + } + void clearUniformLayout() // only uniform specific + { + layoutMatrix = ElmNone; + layoutPacking = ElpNone; + layoutOffset = layoutNotSet; + layoutAlign = layoutNotSet; + + layoutSet = layoutSetEnd; + layoutBinding = layoutBindingEnd; +#ifndef GLSLANG_WEB + layoutAttachment = layoutAttachmentEnd; +#endif + } + + bool hasMatrix() const + { + return layoutMatrix != ElmNone; + } + bool hasPacking() const + { + return layoutPacking != ElpNone; + } + bool hasAlign() const + { + return layoutAlign != layoutNotSet; + } + bool hasAnyLocation() const + { + return hasLocation() || + hasComponent() || + hasIndex(); + } + bool hasLocation() const + { + return layoutLocation != layoutLocationEnd; + } + bool hasSet() const + { + return layoutSet != layoutSetEnd; + } + bool hasBinding() const + { + return layoutBinding != layoutBindingEnd; + } +#ifdef GLSLANG_WEB + bool hasOffset() const { return false; } + bool isNonPerspective() const { return false; } + bool hasIndex() const { return false; } + unsigned getIndex() const { return 0; } + bool hasComponent() const { return false; } + bool hasStream() const { return false; } + bool hasFormat() const { return false; } + bool hasXfb() const { return false; } + bool hasXfbBuffer() const { return false; } + bool hasXfbStride() const { return false; } + bool hasXfbOffset() const { return false; } + bool hasAttachment() const { return false; } + TLayoutFormat getFormat() const { return ElfNone; } + bool isPushConstant() const { return false; } + bool isShaderRecord() const { return false; } + bool hasBufferReference() const { return false; } + bool hasBufferReferenceAlign() const { return false; } + bool isNonUniform() const { return false; } +#else + bool hasOffset() const + { + return layoutOffset != layoutNotSet; + } + bool isNonPerspective() const { return nopersp; } + bool hasIndex() const + { + return layoutIndex != layoutIndexEnd; + } + unsigned getIndex() const { return layoutIndex; } + bool hasComponent() const + { + return layoutComponent != layoutComponentEnd; + } + bool hasStream() const + { + return layoutStream != layoutStreamEnd; + } + bool hasFormat() const + { + return layoutFormat != ElfNone; + } + bool hasXfb() const + { + return hasXfbBuffer() || + hasXfbStride() || + hasXfbOffset(); + } + bool hasXfbBuffer() const + { + return layoutXfbBuffer != layoutXfbBufferEnd; + } + bool hasXfbStride() const + { + return layoutXfbStride != layoutXfbStrideEnd; + } + bool hasXfbOffset() const + { + return layoutXfbOffset != layoutXfbOffsetEnd; + } + bool hasAttachment() const + { + return layoutAttachment != layoutAttachmentEnd; + } + TLayoutFormat getFormat() const { return layoutFormat; } + bool isPushConstant() const { return layoutPushConstant; } + bool isShaderRecord() const { return layoutShaderRecord; } + bool hasBufferReference() const { return layoutBufferReference; } + bool hasBufferReferenceAlign() const + { + return layoutBufferReferenceAlign != layoutBufferReferenceAlignEnd; + } + bool isNonUniform() const + { + return nonUniform; + } +#endif + bool hasSpecConstantId() const + { + // Not the same thing as being a specialization constant, this + // is just whether or not it was declared with an ID. + return layoutSpecConstantId != layoutSpecConstantIdEnd; + } + bool isSpecConstant() const + { + // True if type is a specialization constant, whether or not it + // had a specialization-constant ID, and false if it is not a + // true front-end constant. + return specConstant; + } + bool isFrontEndConstant() const + { + // True if the front-end knows the final constant value. + // This allows front-end constant folding. + return storage == EvqConst && ! specConstant; + } + bool isConstant() const + { + // True if is either kind of constant; specialization or regular. + return isFrontEndConstant() || isSpecConstant(); + } + void makeSpecConstant() + { + storage = EvqConst; + specConstant = true; + } + static const char* getLayoutPackingString(TLayoutPacking packing) + { + switch (packing) { + case ElpStd140: return "std140"; +#ifndef GLSLANG_WEB + case ElpPacked: return "packed"; + case ElpShared: return "shared"; + case ElpStd430: return "std430"; + case ElpScalar: return "scalar"; +#endif + default: return "none"; + } + } + static const char* getLayoutMatrixString(TLayoutMatrix m) + { + switch (m) { + case ElmColumnMajor: return "column_major"; + case ElmRowMajor: return "row_major"; + default: return "none"; + } + } +#ifdef GLSLANG_WEB + static const char* getLayoutFormatString(TLayoutFormat f) { return "none"; } +#else + static const char* getLayoutFormatString(TLayoutFormat f) + { + switch (f) { + case ElfRgba32f: return "rgba32f"; + case ElfRgba16f: return "rgba16f"; + case ElfRg32f: return "rg32f"; + case ElfRg16f: return "rg16f"; + case ElfR11fG11fB10f: return "r11f_g11f_b10f"; + case ElfR32f: return "r32f"; + case ElfR16f: return "r16f"; + case ElfRgba16: return "rgba16"; + case ElfRgb10A2: return "rgb10_a2"; + case ElfRgba8: return "rgba8"; + case ElfRg16: return "rg16"; + case ElfRg8: return "rg8"; + case ElfR16: return "r16"; + case ElfR8: return "r8"; + case ElfRgba16Snorm: return "rgba16_snorm"; + case ElfRgba8Snorm: return "rgba8_snorm"; + case ElfRg16Snorm: return "rg16_snorm"; + case ElfRg8Snorm: return "rg8_snorm"; + case ElfR16Snorm: return "r16_snorm"; + case ElfR8Snorm: return "r8_snorm"; + + case ElfRgba32i: return "rgba32i"; + case ElfRgba16i: return "rgba16i"; + case ElfRgba8i: return "rgba8i"; + case ElfRg32i: return "rg32i"; + case ElfRg16i: return "rg16i"; + case ElfRg8i: return "rg8i"; + case ElfR32i: return "r32i"; + case ElfR16i: return "r16i"; + case ElfR8i: return "r8i"; + + case ElfRgba32ui: return "rgba32ui"; + case ElfRgba16ui: return "rgba16ui"; + case ElfRgba8ui: return "rgba8ui"; + case ElfRg32ui: return "rg32ui"; + case ElfRg16ui: return "rg16ui"; + case ElfRgb10a2ui: return "rgb10_a2ui"; + case ElfRg8ui: return "rg8ui"; + case ElfR32ui: return "r32ui"; + case ElfR16ui: return "r16ui"; + case ElfR8ui: return "r8ui"; + default: return "none"; + } + } + static const char* getLayoutDepthString(TLayoutDepth d) + { + switch (d) { + case EldAny: return "depth_any"; + case EldGreater: return "depth_greater"; + case EldLess: return "depth_less"; + case EldUnchanged: return "depth_unchanged"; + default: return "none"; + } + } + static const char* getBlendEquationString(TBlendEquationShift e) + { + switch (e) { + case EBlendMultiply: return "blend_support_multiply"; + case EBlendScreen: return "blend_support_screen"; + case EBlendOverlay: return "blend_support_overlay"; + case EBlendDarken: return "blend_support_darken"; + case EBlendLighten: return "blend_support_lighten"; + case EBlendColordodge: return "blend_support_colordodge"; + case EBlendColorburn: return "blend_support_colorburn"; + case EBlendHardlight: return "blend_support_hardlight"; + case EBlendSoftlight: return "blend_support_softlight"; + case EBlendDifference: return "blend_support_difference"; + case EBlendExclusion: return "blend_support_exclusion"; + case EBlendHslHue: return "blend_support_hsl_hue"; + case EBlendHslSaturation: return "blend_support_hsl_saturation"; + case EBlendHslColor: return "blend_support_hsl_color"; + case EBlendHslLuminosity: return "blend_support_hsl_luminosity"; + case EBlendAllEquations: return "blend_support_all_equations"; + default: return "unknown"; + } + } + static const char* getGeometryString(TLayoutGeometry geometry) + { + switch (geometry) { + case ElgPoints: return "points"; + case ElgLines: return "lines"; + case ElgLinesAdjacency: return "lines_adjacency"; + case ElgLineStrip: return "line_strip"; + case ElgTriangles: return "triangles"; + case ElgTrianglesAdjacency: return "triangles_adjacency"; + case ElgTriangleStrip: return "triangle_strip"; + case ElgQuads: return "quads"; + case ElgIsolines: return "isolines"; + default: return "none"; + } + } + static const char* getVertexSpacingString(TVertexSpacing spacing) + { + switch (spacing) { + case EvsEqual: return "equal_spacing"; + case EvsFractionalEven: return "fractional_even_spacing"; + case EvsFractionalOdd: return "fractional_odd_spacing"; + default: return "none"; + } + } + static const char* getVertexOrderString(TVertexOrder order) + { + switch (order) { + case EvoCw: return "cw"; + case EvoCcw: return "ccw"; + default: return "none"; + } + } + static int mapGeometryToSize(TLayoutGeometry geometry) + { + switch (geometry) { + case ElgPoints: return 1; + case ElgLines: return 2; + case ElgLinesAdjacency: return 4; + case ElgTriangles: return 3; + case ElgTrianglesAdjacency: return 6; + default: return 0; + } + } + static const char* getInterlockOrderingString(TInterlockOrdering order) + { + switch (order) { + case EioPixelInterlockOrdered: return "pixel_interlock_ordered"; + case EioPixelInterlockUnordered: return "pixel_interlock_unordered"; + case EioSampleInterlockOrdered: return "sample_interlock_ordered"; + case EioSampleInterlockUnordered: return "sample_interlock_unordered"; + case EioShadingRateInterlockOrdered: return "shading_rate_interlock_ordered"; + case EioShadingRateInterlockUnordered: return "shading_rate_interlock_unordered"; + default: return "none"; + } + } +#endif +}; + +// Qualifiers that don't need to be keep per object. They have shader scope, not object scope. +// So, they will not be part of TType, TQualifier, etc. +struct TShaderQualifiers { + TLayoutGeometry geometry; // geometry/tessellation shader in/out primitives + bool pixelCenterInteger; // fragment shader + bool originUpperLeft; // fragment shader + int invocations; + int vertices; // for tessellation "vertices", geometry & mesh "max_vertices" + TVertexSpacing spacing; + TVertexOrder order; + bool pointMode; + int localSize[3]; // compute shader + bool localSizeNotDefault[3]; // compute shader + int localSizeSpecId[3]; // compute shader specialization id for gl_WorkGroupSize +#ifndef GLSLANG_WEB + bool earlyFragmentTests; // fragment input + bool postDepthCoverage; // fragment input + TLayoutDepth layoutDepth; + bool blendEquation; // true if any blend equation was specified + int numViews; // multiview extenstions + TInterlockOrdering interlockOrdering; + bool layoutOverrideCoverage; // true if layout override_coverage set + bool layoutDerivativeGroupQuads; // true if layout derivative_group_quadsNV set + bool layoutDerivativeGroupLinear; // true if layout derivative_group_linearNV set + int primitives; // mesh shader "max_primitives"DerivativeGroupLinear; // true if layout derivative_group_linearNV set + bool layoutPrimitiveCulling; // true if layout primitive_culling set + TLayoutDepth getDepth() const { return layoutDepth; } +#else + TLayoutDepth getDepth() const { return EldNone; } +#endif + + void init() + { + geometry = ElgNone; + originUpperLeft = false; + pixelCenterInteger = false; + invocations = TQualifier::layoutNotSet; + vertices = TQualifier::layoutNotSet; + spacing = EvsNone; + order = EvoNone; + pointMode = false; + localSize[0] = 1; + localSize[1] = 1; + localSize[2] = 1; + localSizeNotDefault[0] = false; + localSizeNotDefault[1] = false; + localSizeNotDefault[2] = false; + localSizeSpecId[0] = TQualifier::layoutNotSet; + localSizeSpecId[1] = TQualifier::layoutNotSet; + localSizeSpecId[2] = TQualifier::layoutNotSet; +#ifndef GLSLANG_WEB + earlyFragmentTests = false; + postDepthCoverage = false; + layoutDepth = EldNone; + blendEquation = false; + numViews = TQualifier::layoutNotSet; + layoutOverrideCoverage = false; + layoutDerivativeGroupQuads = false; + layoutDerivativeGroupLinear = false; + layoutPrimitiveCulling = false; + primitives = TQualifier::layoutNotSet; + interlockOrdering = EioNone; +#endif + } + +#ifdef GLSLANG_WEB + bool hasBlendEquation() const { return false; } +#else + bool hasBlendEquation() const { return blendEquation; } +#endif + + // Merge in characteristics from the 'src' qualifier. They can override when + // set, but never erase when not set. + void merge(const TShaderQualifiers& src) + { + if (src.geometry != ElgNone) + geometry = src.geometry; + if (src.pixelCenterInteger) + pixelCenterInteger = src.pixelCenterInteger; + if (src.originUpperLeft) + originUpperLeft = src.originUpperLeft; + if (src.invocations != TQualifier::layoutNotSet) + invocations = src.invocations; + if (src.vertices != TQualifier::layoutNotSet) + vertices = src.vertices; + if (src.spacing != EvsNone) + spacing = src.spacing; + if (src.order != EvoNone) + order = src.order; + if (src.pointMode) + pointMode = true; + for (int i = 0; i < 3; ++i) { + if (src.localSize[i] > 1) + localSize[i] = src.localSize[i]; + } + for (int i = 0; i < 3; ++i) { + localSizeNotDefault[i] = src.localSizeNotDefault[i] || localSizeNotDefault[i]; + } + for (int i = 0; i < 3; ++i) { + if (src.localSizeSpecId[i] != TQualifier::layoutNotSet) + localSizeSpecId[i] = src.localSizeSpecId[i]; + } +#ifndef GLSLANG_WEB + if (src.earlyFragmentTests) + earlyFragmentTests = true; + if (src.postDepthCoverage) + postDepthCoverage = true; + if (src.layoutDepth) + layoutDepth = src.layoutDepth; + if (src.blendEquation) + blendEquation = src.blendEquation; + if (src.numViews != TQualifier::layoutNotSet) + numViews = src.numViews; + if (src.layoutOverrideCoverage) + layoutOverrideCoverage = src.layoutOverrideCoverage; + if (src.layoutDerivativeGroupQuads) + layoutDerivativeGroupQuads = src.layoutDerivativeGroupQuads; + if (src.layoutDerivativeGroupLinear) + layoutDerivativeGroupLinear = src.layoutDerivativeGroupLinear; + if (src.primitives != TQualifier::layoutNotSet) + primitives = src.primitives; + if (src.interlockOrdering != EioNone) + interlockOrdering = src.interlockOrdering; + if (src.layoutPrimitiveCulling) + layoutPrimitiveCulling = src.layoutPrimitiveCulling; +#endif + } +}; + +// +// TPublicType is just temporarily used while parsing and not quite the same +// information kept per node in TType. Due to the bison stack, it can't have +// types that it thinks have non-trivial constructors. It should +// just be used while recognizing the grammar, not anything else. +// Once enough is known about the situation, the proper information +// moved into a TType, or the parse context, etc. +// +class TPublicType { +public: + TBasicType basicType; + TSampler sampler; + TQualifier qualifier; + TShaderQualifiers shaderQualifiers; + int vectorSize : 4; + int matrixCols : 4; + int matrixRows : 4; + bool coopmat : 1; + TArraySizes* arraySizes; + const TType* userDef; + TSourceLoc loc; + TArraySizes* typeParameters; + +#ifdef GLSLANG_WEB + bool isCoopmat() const { return false; } +#else + bool isCoopmat() const { return coopmat; } +#endif + + void initType(const TSourceLoc& l) + { + basicType = EbtVoid; + vectorSize = 1; + matrixRows = 0; + matrixCols = 0; + arraySizes = nullptr; + userDef = nullptr; + loc = l; + typeParameters = nullptr; + coopmat = false; + } + + void initQualifiers(bool global = false) + { + qualifier.clear(); + if (global) + qualifier.storage = EvqGlobal; + } + + void init(const TSourceLoc& l, bool global = false) + { + initType(l); + sampler.clear(); + initQualifiers(global); + shaderQualifiers.init(); + } + + void setVector(int s) + { + matrixRows = 0; + matrixCols = 0; + vectorSize = s; + } + + void setMatrix(int c, int r) + { + matrixRows = r; + matrixCols = c; + vectorSize = 0; + } + + bool isScalar() const + { + return matrixCols == 0 && vectorSize == 1 && arraySizes == nullptr && userDef == nullptr; + } + + // "Image" is a superset of "Subpass" + bool isImage() const { return basicType == EbtSampler && sampler.isImage(); } + bool isSubpass() const { return basicType == EbtSampler && sampler.isSubpass(); } +}; + +// +// Base class for things that have a type. +// +class TType { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + + // for "empty" type (no args) or simple scalar/vector/matrix + explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0, + bool isVector = false) : + basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false), + arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr) + { + sampler.clear(); + qualifier.clear(); + qualifier.storage = q; + assert(!(isMatrix() && vectorSize != 0)); // prevent vectorSize != 0 on matrices + } + // for explicit precision qualifier + TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0, + bool isVector = false) : + basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), vector1(isVector && vs == 1), coopmat(false), + arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr) + { + sampler.clear(); + qualifier.clear(); + qualifier.storage = q; + qualifier.precision = p; + assert(p >= EpqNone && p <= EpqHigh); + assert(!(isMatrix() && vectorSize != 0)); // prevent vectorSize != 0 on matrices + } + // for turning a TPublicType into a TType, using a shallow copy + explicit TType(const TPublicType& p) : + basicType(p.basicType), + vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmat(p.coopmat), + arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters) + { + if (basicType == EbtSampler) + sampler = p.sampler; + else + sampler.clear(); + qualifier = p.qualifier; + if (p.userDef) { + if (p.userDef->basicType == EbtReference) { + basicType = EbtReference; + referentType = p.userDef->referentType; + } else { + structure = p.userDef->getWritableStruct(); // public type is short-lived; there are no sharing issues + } + typeName = NewPoolTString(p.userDef->getTypeName().c_str()); + } + if (p.isCoopmat() && p.typeParameters && p.typeParameters->getNumDims() > 0) { + int numBits = p.typeParameters->getDimSize(0); + if (p.basicType == EbtFloat && numBits == 16) { + basicType = EbtFloat16; + qualifier.precision = EpqNone; + } else if (p.basicType == EbtUint && numBits == 8) { + basicType = EbtUint8; + qualifier.precision = EpqNone; + } else if (p.basicType == EbtInt && numBits == 8) { + basicType = EbtInt8; + qualifier.precision = EpqNone; + } + } + } + // for construction of sampler types + TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) : + basicType(EbtSampler), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false), + arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr), + sampler(sampler), typeParameters(nullptr) + { + qualifier.clear(); + qualifier.storage = q; + } + // to efficiently make a dereferenced type + // without ever duplicating the outer structure that will be thrown away + // and using only shallow copy + TType(const TType& type, int derefIndex, bool rowMajor = false) + { + if (type.isArray()) { + shallowCopy(type); + if (type.getArraySizes()->getNumDims() == 1) { + arraySizes = nullptr; + } else { + // want our own copy of the array, so we can edit it + arraySizes = new TArraySizes; + arraySizes->copyDereferenced(*type.arraySizes); + } + } else if (type.basicType == EbtStruct || type.basicType == EbtBlock) { + // do a structure dereference + const TTypeList& memberList = *type.getStruct(); + shallowCopy(*memberList[derefIndex].type); + return; + } else { + // do a vector/matrix dereference + shallowCopy(type); + if (matrixCols > 0) { + // dereference from matrix to vector + if (rowMajor) + vectorSize = matrixCols; + else + vectorSize = matrixRows; + matrixCols = 0; + matrixRows = 0; + if (vectorSize == 1) + vector1 = true; + } else if (isVector()) { + // dereference from vector to scalar + vectorSize = 1; + vector1 = false; + } else if (isCoopMat()) { + coopmat = false; + typeParameters = nullptr; + } + } + } + // for making structures, ... + TType(TTypeList* userDef, const TString& n) : + basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false), + arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr) + { + sampler.clear(); + qualifier.clear(); + typeName = NewPoolTString(n.c_str()); + } + // For interface blocks + TType(TTypeList* userDef, const TString& n, const TQualifier& q) : + basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmat(false), + qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr) + { + sampler.clear(); + typeName = NewPoolTString(n.c_str()); + } + // for block reference (first parameter must be EbtReference) + explicit TType(TBasicType t, const TType &p, const TString& n) : + basicType(t), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), + arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr) + { + assert(t == EbtReference); + typeName = NewPoolTString(n.c_str()); + qualifier.clear(); + qualifier.storage = p.qualifier.storage; + referentType = p.clone(); + } + virtual ~TType() {} + + // Not for use across pool pops; it will cause multiple instances of TType to point to the same information. + // This only works if that information (like a structure's list of types) does not change and + // the instances are sharing the same pool. + void shallowCopy(const TType& copyOf) + { + basicType = copyOf.basicType; + sampler = copyOf.sampler; + qualifier = copyOf.qualifier; + vectorSize = copyOf.vectorSize; + matrixCols = copyOf.matrixCols; + matrixRows = copyOf.matrixRows; + vector1 = copyOf.vector1; + arraySizes = copyOf.arraySizes; // copying the pointer only, not the contents + fieldName = copyOf.fieldName; + typeName = copyOf.typeName; + if (isStruct()) { + structure = copyOf.structure; + } else { + referentType = copyOf.referentType; + } + typeParameters = copyOf.typeParameters; + coopmat = copyOf.isCoopMat(); + } + + // Make complete copy of the whole type graph rooted at 'copyOf'. + void deepCopy(const TType& copyOf) + { + TMap copied; // to enable copying a type graph as a graph, not a tree + deepCopy(copyOf, copied); + } + + // Recursively make temporary + void makeTemporary() + { + getQualifier().makeTemporary(); + + if (isStruct()) + for (unsigned int i = 0; i < structure->size(); ++i) + (*structure)[i].type->makeTemporary(); + } + + TType* clone() const + { + TType *newType = new TType(); + newType->deepCopy(*this); + + return newType; + } + + void makeVector() { vector1 = true; } + + virtual void hideMember() { basicType = EbtVoid; vectorSize = 1; } + virtual bool hiddenMember() const { return basicType == EbtVoid; } + + virtual void setFieldName(const TString& n) { fieldName = NewPoolTString(n.c_str()); } + virtual const TString& getTypeName() const + { + assert(typeName); + return *typeName; + } + + virtual const TString& getFieldName() const + { + assert(fieldName); + return *fieldName; + } + TShaderInterface getShaderInterface() const + { + if (basicType != EbtBlock) + return EsiNone; + + switch (qualifier.storage) { + default: + return EsiNone; + case EvqVaryingIn: + return EsiInput; + case EvqVaryingOut: + return EsiOutput; + case EvqUniform: + case EvqBuffer: + return EsiUniform; + } + } + + virtual TBasicType getBasicType() const { return basicType; } + virtual const TSampler& getSampler() const { return sampler; } + virtual TSampler& getSampler() { return sampler; } + + virtual TQualifier& getQualifier() { return qualifier; } + virtual const TQualifier& getQualifier() const { return qualifier; } + + virtual int getVectorSize() const { return vectorSize; } // returns 1 for either scalar or vector of size 1, valid for both + virtual int getMatrixCols() const { return matrixCols; } + virtual int getMatrixRows() const { return matrixRows; } + virtual int getOuterArraySize() const { return arraySizes->getOuterSize(); } + virtual TIntermTyped* getOuterArrayNode() const { return arraySizes->getOuterNode(); } + virtual int getCumulativeArraySize() const { return arraySizes->getCumulativeSize(); } +#ifdef GLSLANG_WEB + bool isArrayOfArrays() const { return false; } +#else + bool isArrayOfArrays() const { return arraySizes != nullptr && arraySizes->getNumDims() > 1; } +#endif + virtual int getImplicitArraySize() const { return arraySizes->getImplicitSize(); } + virtual const TArraySizes* getArraySizes() const { return arraySizes; } + virtual TArraySizes* getArraySizes() { return arraySizes; } + virtual TType* getReferentType() const { return referentType; } + virtual const TArraySizes* getTypeParameters() const { return typeParameters; } + virtual TArraySizes* getTypeParameters() { return typeParameters; } + + virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray(); } + virtual bool isScalarOrVec1() const { return isScalar() || vector1; } + virtual bool isVector() const { return vectorSize > 1 || vector1; } + virtual bool isMatrix() const { return matrixCols ? true : false; } + virtual bool isArray() const { return arraySizes != nullptr; } + virtual bool isSizedArray() const { return isArray() && arraySizes->isSized(); } + virtual bool isUnsizedArray() const { return isArray() && !arraySizes->isSized(); } + virtual bool isArrayVariablyIndexed() const { assert(isArray()); return arraySizes->isVariablyIndexed(); } + virtual void setArrayVariablyIndexed() { assert(isArray()); arraySizes->setVariablyIndexed(); } + virtual void updateImplicitArraySize(int size) { assert(isArray()); arraySizes->updateImplicitSize(size); } + virtual bool isStruct() const { return basicType == EbtStruct || basicType == EbtBlock; } + virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16; } + virtual bool isIntegerDomain() const + { + switch (basicType) { + case EbtInt8: + case EbtUint8: + case EbtInt16: + case EbtUint16: + case EbtInt: + case EbtUint: + case EbtInt64: + case EbtUint64: + case EbtAtomicUint: + return true; + default: + break; + } + return false; + } + virtual bool isOpaque() const { return basicType == EbtSampler +#ifndef GLSLANG_WEB + || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery +#endif + ; } + virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; } + + // "Image" is a superset of "Subpass" + virtual bool isImage() const { return basicType == EbtSampler && getSampler().isImage(); } + virtual bool isSubpass() const { return basicType == EbtSampler && getSampler().isSubpass(); } + virtual bool isTexture() const { return basicType == EbtSampler && getSampler().isTexture(); } + // Check the block-name convention of creating a block without populating it's members: + virtual bool isUnusableName() const { return isStruct() && structure == nullptr; } + virtual bool isParameterized() const { return typeParameters != nullptr; } +#ifdef GLSLANG_WEB + bool isAtomic() const { return false; } + bool isCoopMat() const { return false; } + bool isReference() const { return false; } +#else + bool isAtomic() const { return basicType == EbtAtomicUint; } + bool isCoopMat() const { return coopmat; } + bool isReference() const { return getBasicType() == EbtReference; } +#endif + + // return true if this type contains any subtype which satisfies the given predicate. + template + bool contains(P predicate) const + { + if (predicate(this)) + return true; + + const auto hasa = [predicate](const TTypeLoc& tl) { return tl.type->contains(predicate); }; + + return isStruct() && std::any_of(structure->begin(), structure->end(), hasa); + } + + // Recursively checks if the type contains the given basic type + virtual bool containsBasicType(TBasicType checkType) const + { + return contains([checkType](const TType* t) { return t->basicType == checkType; } ); + } + + // Recursively check the structure for any arrays, needed for some error checks + virtual bool containsArray() const + { + return contains([](const TType* t) { return t->isArray(); } ); + } + + // Check the structure for any structures, needed for some error checks + virtual bool containsStructure() const + { + return contains([this](const TType* t) { return t != this && t->isStruct(); } ); + } + + // Recursively check the structure for any unsized arrays, needed for triggering a copyUp(). + virtual bool containsUnsizedArray() const + { + return contains([](const TType* t) { return t->isUnsizedArray(); } ); + } + + virtual bool containsOpaque() const + { + return contains([](const TType* t) { return t->isOpaque(); } ); + } + + // Recursively checks if the type contains a built-in variable + virtual bool containsBuiltIn() const + { + return contains([](const TType* t) { return t->isBuiltIn(); } ); + } + + virtual bool containsNonOpaque() const + { + const auto nonOpaque = [](const TType* t) { + switch (t->basicType) { + case EbtVoid: + case EbtFloat: + case EbtDouble: + case EbtFloat16: + case EbtInt8: + case EbtUint8: + case EbtInt16: + case EbtUint16: + case EbtInt: + case EbtUint: + case EbtInt64: + case EbtUint64: + case EbtBool: + case EbtReference: + return true; + default: + return false; + } + }; + + return contains(nonOpaque); + } + + virtual bool containsSpecializationSize() const + { + return contains([](const TType* t) { return t->isArray() && t->arraySizes->isOuterSpecialization(); } ); + } + +#ifdef GLSLANG_WEB + bool containsDouble() const { return false; } + bool contains16BitFloat() const { return false; } + bool contains64BitInt() const { return false; } + bool contains16BitInt() const { return false; } + bool contains8BitInt() const { return false; } + bool containsCoopMat() const { return false; } + bool containsReference() const { return false; } +#else + bool containsDouble() const + { + return containsBasicType(EbtDouble); + } + bool contains16BitFloat() const + { + return containsBasicType(EbtFloat16); + } + bool contains64BitInt() const + { + return containsBasicType(EbtInt64) || containsBasicType(EbtUint64); + } + bool contains16BitInt() const + { + return containsBasicType(EbtInt16) || containsBasicType(EbtUint16); + } + bool contains8BitInt() const + { + return containsBasicType(EbtInt8) || containsBasicType(EbtUint8); + } + bool containsCoopMat() const + { + return contains([](const TType* t) { return t->coopmat; } ); + } + bool containsReference() const + { + return containsBasicType(EbtReference); + } +#endif + + // Array editing methods. Array descriptors can be shared across + // type instances. This allows all uses of the same array + // to be updated at once. E.g., all nodes can be explicitly sized + // by tracking and correcting one implicit size. Or, all nodes + // can get the explicit size on a redeclaration that gives size. + // + // N.B.: Don't share with the shared symbol tables (symbols are + // marked as isReadOnly(). Such symbols with arrays that will be + // edited need to copyUp() on first use, so that + // A) the edits don't effect the shared symbol table, and + // B) the edits are shared across all users. + void updateArraySizes(const TType& type) + { + // For when we may already be sharing existing array descriptors, + // keeping the pointers the same, just updating the contents. + assert(arraySizes != nullptr); + assert(type.arraySizes != nullptr); + *arraySizes = *type.arraySizes; + } + void copyArraySizes(const TArraySizes& s) + { + // For setting a fresh new set of array sizes, not yet worrying about sharing. + arraySizes = new TArraySizes; + *arraySizes = s; + } + void transferArraySizes(TArraySizes* s) + { + // For setting an already allocated set of sizes that this type can use + // (no copy made). + arraySizes = s; + } + void clearArraySizes() + { + arraySizes = nullptr; + } + + // Add inner array sizes, to any existing sizes, via copy; the + // sizes passed in can still be reused for other purposes. + void copyArrayInnerSizes(const TArraySizes* s) + { + if (s != nullptr) { + if (arraySizes == nullptr) + copyArraySizes(*s); + else + arraySizes->addInnerSizes(*s); + } + } + void changeOuterArraySize(int s) { arraySizes->changeOuterSize(s); } + + // Recursively make the implicit array size the explicit array size. + // Expicit arrays are compile-time or link-time sized, never run-time sized. + // Sometimes, policy calls for an array to be run-time sized even if it was + // never variably indexed: Don't turn a 'skipNonvariablyIndexed' array into + // an explicit array. + void adoptImplicitArraySizes(bool skipNonvariablyIndexed) + { + if (isUnsizedArray() && !(skipNonvariablyIndexed || isArrayVariablyIndexed())) + changeOuterArraySize(getImplicitArraySize()); + // For multi-dim per-view arrays, set unsized inner dimension size to 1 + if (qualifier.isPerView() && arraySizes && arraySizes->isInnerUnsized()) + arraySizes->clearInnerUnsized(); + if (isStruct() && structure->size() > 0) { + int lastMember = (int)structure->size() - 1; + for (int i = 0; i < lastMember; ++i) + (*structure)[i].type->adoptImplicitArraySizes(false); + // implement the "last member of an SSBO" policy + (*structure)[lastMember].type->adoptImplicitArraySizes(getQualifier().storage == EvqBuffer); + } + } + + + void updateTypeParameters(const TType& type) + { + // For when we may already be sharing existing array descriptors, + // keeping the pointers the same, just updating the contents. + assert(typeParameters != nullptr); + assert(type.typeParameters != nullptr); + *typeParameters = *type.typeParameters; + } + void copyTypeParameters(const TArraySizes& s) + { + // For setting a fresh new set of type parameters, not yet worrying about sharing. + typeParameters = new TArraySizes; + *typeParameters = s; + } + void transferTypeParameters(TArraySizes* s) + { + // For setting an already allocated set of sizes that this type can use + // (no copy made). + typeParameters = s; + } + void clearTypeParameters() + { + typeParameters = nullptr; + } + + // Add inner array sizes, to any existing sizes, via copy; the + // sizes passed in can still be reused for other purposes. + void copyTypeParametersInnerSizes(const TArraySizes* s) + { + if (s != nullptr) { + if (typeParameters == nullptr) + copyTypeParameters(*s); + else + typeParameters->addInnerSizes(*s); + } + } + + + + const char* getBasicString() const + { + return TType::getBasicString(basicType); + } + + static const char* getBasicString(TBasicType t) + { + switch (t) { + case EbtFloat: return "float"; + case EbtInt: return "int"; + case EbtUint: return "uint"; + case EbtSampler: return "sampler/image"; +#ifndef GLSLANG_WEB + case EbtVoid: return "void"; + case EbtDouble: return "double"; + case EbtFloat16: return "float16_t"; + case EbtInt8: return "int8_t"; + case EbtUint8: return "uint8_t"; + case EbtInt16: return "int16_t"; + case EbtUint16: return "uint16_t"; + case EbtInt64: return "int64_t"; + case EbtUint64: return "uint64_t"; + case EbtBool: return "bool"; + case EbtAtomicUint: return "atomic_uint"; + case EbtStruct: return "structure"; + case EbtBlock: return "block"; + case EbtAccStruct: return "accelerationStructureNV"; + case EbtRayQuery: return "rayQueryEXT"; + case EbtReference: return "reference"; +#endif + default: return "unknown type"; + } + } + +#ifdef GLSLANG_WEB + TString getCompleteString() const { return ""; } + const char* getStorageQualifierString() const { return ""; } + const char* getBuiltInVariableString() const { return ""; } + const char* getPrecisionQualifierString() const { return ""; } + TString getBasicTypeString() const { return ""; } +#else + TString getCompleteString() const + { + TString typeString; + + const auto appendStr = [&](const char* s) { typeString.append(s); }; + const auto appendUint = [&](unsigned int u) { typeString.append(std::to_string(u).c_str()); }; + const auto appendInt = [&](int i) { typeString.append(std::to_string(i).c_str()); }; + + if (qualifier.hasLayout()) { + // To reduce noise, skip this if the only layout is an xfb_buffer + // with no triggering xfb_offset. + TQualifier noXfbBuffer = qualifier; + noXfbBuffer.layoutXfbBuffer = TQualifier::layoutXfbBufferEnd; + if (noXfbBuffer.hasLayout()) { + appendStr("layout("); + if (qualifier.hasAnyLocation()) { + appendStr(" location="); + appendUint(qualifier.layoutLocation); + if (qualifier.hasComponent()) { + appendStr(" component="); + appendUint(qualifier.layoutComponent); + } + if (qualifier.hasIndex()) { + appendStr(" index="); + appendUint(qualifier.layoutIndex); + } + } + if (qualifier.hasSet()) { + appendStr(" set="); + appendUint(qualifier.layoutSet); + } + if (qualifier.hasBinding()) { + appendStr(" binding="); + appendUint(qualifier.layoutBinding); + } + if (qualifier.hasStream()) { + appendStr(" stream="); + appendUint(qualifier.layoutStream); + } + if (qualifier.hasMatrix()) { + appendStr(" "); + appendStr(TQualifier::getLayoutMatrixString(qualifier.layoutMatrix)); + } + if (qualifier.hasPacking()) { + appendStr(" "); + appendStr(TQualifier::getLayoutPackingString(qualifier.layoutPacking)); + } + if (qualifier.hasOffset()) { + appendStr(" offset="); + appendInt(qualifier.layoutOffset); + } + if (qualifier.hasAlign()) { + appendStr(" align="); + appendInt(qualifier.layoutAlign); + } + if (qualifier.hasFormat()) { + appendStr(" "); + appendStr(TQualifier::getLayoutFormatString(qualifier.layoutFormat)); + } + if (qualifier.hasXfbBuffer() && qualifier.hasXfbOffset()) { + appendStr(" xfb_buffer="); + appendUint(qualifier.layoutXfbBuffer); + } + if (qualifier.hasXfbOffset()) { + appendStr(" xfb_offset="); + appendUint(qualifier.layoutXfbOffset); + } + if (qualifier.hasXfbStride()) { + appendStr(" xfb_stride="); + appendUint(qualifier.layoutXfbStride); + } + if (qualifier.hasAttachment()) { + appendStr(" input_attachment_index="); + appendUint(qualifier.layoutAttachment); + } + if (qualifier.hasSpecConstantId()) { + appendStr(" constant_id="); + appendUint(qualifier.layoutSpecConstantId); + } + if (qualifier.layoutPushConstant) + appendStr(" push_constant"); + if (qualifier.layoutBufferReference) + appendStr(" buffer_reference"); + if (qualifier.hasBufferReferenceAlign()) { + appendStr(" buffer_reference_align="); + appendUint(1u << qualifier.layoutBufferReferenceAlign); + } + + if (qualifier.layoutPassthrough) + appendStr(" passthrough"); + if (qualifier.layoutViewportRelative) + appendStr(" layoutViewportRelative"); + if (qualifier.layoutSecondaryViewportRelativeOffset != -2048) { + appendStr(" layoutSecondaryViewportRelativeOffset="); + appendInt(qualifier.layoutSecondaryViewportRelativeOffset); + } + if (qualifier.layoutShaderRecord) + appendStr(" shaderRecordNV"); + + appendStr(")"); + } + } + + if (qualifier.invariant) + appendStr(" invariant"); + if (qualifier.noContraction) + appendStr(" noContraction"); + if (qualifier.centroid) + appendStr(" centroid"); + if (qualifier.smooth) + appendStr(" smooth"); + if (qualifier.flat) + appendStr(" flat"); + if (qualifier.nopersp) + appendStr(" noperspective"); + if (qualifier.explicitInterp) + appendStr(" __explicitInterpAMD"); + if (qualifier.pervertexNV) + appendStr(" pervertexNV"); + if (qualifier.perPrimitiveNV) + appendStr(" perprimitiveNV"); + if (qualifier.perViewNV) + appendStr(" perviewNV"); + if (qualifier.perTaskNV) + appendStr(" taskNV"); + if (qualifier.patch) + appendStr(" patch"); + if (qualifier.sample) + appendStr(" sample"); + if (qualifier.coherent) + appendStr(" coherent"); + if (qualifier.devicecoherent) + appendStr(" devicecoherent"); + if (qualifier.queuefamilycoherent) + appendStr(" queuefamilycoherent"); + if (qualifier.workgroupcoherent) + appendStr(" workgroupcoherent"); + if (qualifier.subgroupcoherent) + appendStr(" subgroupcoherent"); + if (qualifier.shadercallcoherent) + appendStr(" shadercallcoherent"); + if (qualifier.nonprivate) + appendStr(" nonprivate"); + if (qualifier.volatil) + appendStr(" volatile"); + if (qualifier.restrict) + appendStr(" restrict"); + if (qualifier.readonly) + appendStr(" readonly"); + if (qualifier.writeonly) + appendStr(" writeonly"); + if (qualifier.specConstant) + appendStr(" specialization-constant"); + if (qualifier.nonUniform) + appendStr(" nonuniform"); + appendStr(" "); + appendStr(getStorageQualifierString()); + if (isArray()) { + for(int i = 0; i < (int)arraySizes->getNumDims(); ++i) { + int size = arraySizes->getDimSize(i); + if (size == UnsizedArraySize && i == 0 && arraySizes->isVariablyIndexed()) + appendStr(" runtime-sized array of"); + else { + if (size == UnsizedArraySize) { + appendStr(" unsized"); + if (i == 0) { + appendStr(" "); + appendInt(arraySizes->getImplicitSize()); + } + } else { + appendStr(" "); + appendInt(arraySizes->getDimSize(i)); + } + appendStr("-element array of"); + } + } + } + if (isParameterized()) { + appendStr("<"); + for(int i = 0; i < (int)typeParameters->getNumDims(); ++i) { + appendInt(typeParameters->getDimSize(i)); + if (i != (int)typeParameters->getNumDims() - 1) + appendStr(", "); + } + appendStr(">"); + } + if (qualifier.precision != EpqNone) { + appendStr(" "); + appendStr(getPrecisionQualifierString()); + } + if (isMatrix()) { + appendStr(" "); + appendInt(matrixCols); + appendStr("X"); + appendInt(matrixRows); + appendStr(" matrix of"); + } else if (isVector()) { + appendStr(" "); + appendInt(vectorSize); + appendStr("-component vector of"); + } + + appendStr(" "); + typeString.append(getBasicTypeString()); + + if (qualifier.builtIn != EbvNone) { + appendStr(" "); + appendStr(getBuiltInVariableString()); + } + + // Add struct/block members + if (isStruct() && structure) { + appendStr("{"); + bool hasHiddenMember = true; + for (size_t i = 0; i < structure->size(); ++i) { + if (! (*structure)[i].type->hiddenMember()) { + if (!hasHiddenMember) + appendStr(", "); + typeString.append((*structure)[i].type->getCompleteString()); + typeString.append(" "); + typeString.append((*structure)[i].type->getFieldName()); + hasHiddenMember = false; + } + } + appendStr("}"); + } + + return typeString; + } + + TString getBasicTypeString() const + { + if (basicType == EbtSampler) + return sampler.getString(); + else + return getBasicString(); + } + + const char* getStorageQualifierString() const { return GetStorageQualifierString(qualifier.storage); } + const char* getBuiltInVariableString() const { return GetBuiltInVariableString(qualifier.builtIn); } + const char* getPrecisionQualifierString() const { return GetPrecisionQualifierString(qualifier.precision); } +#endif + + const TTypeList* getStruct() const { assert(isStruct()); return structure; } + void setStruct(TTypeList* s) { assert(isStruct()); structure = s; } + TTypeList* getWritableStruct() const { assert(isStruct()); return structure; } // This should only be used when known to not be sharing with other threads + void setBasicType(const TBasicType& t) { basicType = t; } + + int computeNumComponents() const + { + int components = 0; + + if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) { + for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++) + components += ((*tl).type)->computeNumComponents(); + } else if (matrixCols) + components = matrixCols * matrixRows; + else + components = vectorSize; + + if (arraySizes != nullptr) { + components *= arraySizes->getCumulativeSize(); + } + + return components; + } + + // append this type's mangled name to the passed in 'name' + void appendMangledName(TString& name) const + { + buildMangledName(name); + name += ';' ; + } + + // Do two structure types match? They could be declared independently, + // in different places, but still might satisfy the definition of matching. + // From the spec: + // + // "Structures must have the same name, sequence of type names, and + // type definitions, and member names to be considered the same type. + // This rule applies recursively for nested or embedded types." + // + bool sameStructType(const TType& right) const + { + // Most commonly, they are both nullptr, or the same pointer to the same actual structure + if ((!isStruct() && !right.isStruct()) || + (isStruct() && right.isStruct() && structure == right.structure)) + return true; + + // Both being nullptr was caught above, now they both have to be structures of the same number of elements + if (!isStruct() || !right.isStruct() || + structure->size() != right.structure->size()) + return false; + + // Structure names have to match + if (*typeName != *right.typeName) + return false; + + // Compare the names and types of all the members, which have to match + for (unsigned int i = 0; i < structure->size(); ++i) { + if ((*structure)[i].type->getFieldName() != (*right.structure)[i].type->getFieldName()) + return false; + + if (*(*structure)[i].type != *(*right.structure)[i].type) + return false; + } + + return true; + } + + bool sameReferenceType(const TType& right) const + { + if (isReference() != right.isReference()) + return false; + + if (!isReference() && !right.isReference()) + return true; + + assert(referentType != nullptr); + assert(right.referentType != nullptr); + + if (referentType == right.referentType) + return true; + + return *referentType == *right.referentType; + } + + // See if two types match, in all aspects except arrayness + bool sameElementType(const TType& right) const + { + return basicType == right.basicType && sameElementShape(right); + } + + // See if two type's arrayness match + bool sameArrayness(const TType& right) const + { + return ((arraySizes == nullptr && right.arraySizes == nullptr) || + (arraySizes != nullptr && right.arraySizes != nullptr && *arraySizes == *right.arraySizes)); + } + + // See if two type's arrayness match in everything except their outer dimension + bool sameInnerArrayness(const TType& right) const + { + assert(arraySizes != nullptr && right.arraySizes != nullptr); + return arraySizes->sameInnerArrayness(*right.arraySizes); + } + + // See if two type's parameters match + bool sameTypeParameters(const TType& right) const + { + return ((typeParameters == nullptr && right.typeParameters == nullptr) || + (typeParameters != nullptr && right.typeParameters != nullptr && *typeParameters == *right.typeParameters)); + } + + // See if two type's elements match in all ways except basic type + bool sameElementShape(const TType& right) const + { + return sampler == right.sampler && + vectorSize == right.vectorSize && + matrixCols == right.matrixCols && + matrixRows == right.matrixRows && + vector1 == right.vector1 && + isCoopMat() == right.isCoopMat() && + sameStructType(right) && + sameReferenceType(right); + } + + // See if a cooperative matrix type parameter with unspecified parameters is + // an OK function parameter + bool coopMatParameterOK(const TType& right) const + { + return isCoopMat() && right.isCoopMat() && (getBasicType() == right.getBasicType()) && + typeParameters == nullptr && right.typeParameters != nullptr; + } + + bool sameCoopMatBaseType(const TType &right) const { + bool rv = coopmat && right.coopmat; + if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16) + rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16; + else if (getBasicType() == EbtUint || getBasicType() == EbtUint8) + rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8; + else if (getBasicType() == EbtInt || getBasicType() == EbtInt8) + rv = right.getBasicType() == EbtInt || right.getBasicType() == EbtInt8; + else + rv = false; + return rv; + } + + + // See if two types match in all ways (just the actual type, not qualification) + bool operator==(const TType& right) const + { + return sameElementType(right) && sameArrayness(right) && sameTypeParameters(right); + } + + bool operator!=(const TType& right) const + { + return ! operator==(right); + } + + unsigned int getBufferReferenceAlignment() const + { +#ifndef GLSLANG_WEB + if (getBasicType() == glslang::EbtReference) { + return getReferentType()->getQualifier().hasBufferReferenceAlign() ? + (1u << getReferentType()->getQualifier().layoutBufferReferenceAlign) : 16u; + } +#endif + return 0; + } + +protected: + // Require consumer to pick between deep copy and shallow copy. + TType(const TType& type); + TType& operator=(const TType& type); + + // Recursively copy a type graph, while preserving the graph-like + // quality. That is, don't make more than one copy of a structure that + // gets reused multiple times in the type graph. + void deepCopy(const TType& copyOf, TMap& copiedMap) + { + shallowCopy(copyOf); + + if (copyOf.arraySizes) { + arraySizes = new TArraySizes; + *arraySizes = *copyOf.arraySizes; + } + + if (copyOf.typeParameters) { + typeParameters = new TArraySizes; + *typeParameters = *copyOf.typeParameters; + } + + if (copyOf.isStruct() && copyOf.structure) { + auto prevCopy = copiedMap.find(copyOf.structure); + if (prevCopy != copiedMap.end()) + structure = prevCopy->second; + else { + structure = new TTypeList; + copiedMap[copyOf.structure] = structure; + for (unsigned int i = 0; i < copyOf.structure->size(); ++i) { + TTypeLoc typeLoc; + typeLoc.loc = (*copyOf.structure)[i].loc; + typeLoc.type = new TType(); + typeLoc.type->deepCopy(*(*copyOf.structure)[i].type, copiedMap); + structure->push_back(typeLoc); + } + } + } + + if (copyOf.fieldName) + fieldName = NewPoolTString(copyOf.fieldName->c_str()); + if (copyOf.typeName) + typeName = NewPoolTString(copyOf.typeName->c_str()); + } + + + void buildMangledName(TString&) const; + + TBasicType basicType : 8; + int vectorSize : 4; // 1 means either scalar or 1-component vector; see vector1 to disambiguate. + int matrixCols : 4; + int matrixRows : 4; + bool vector1 : 1; // Backward-compatible tracking of a 1-component vector distinguished from a scalar. + // GLSL 4.5 never has a 1-component vector; so this will always be false until such + // functionality is added. + // HLSL does have a 1-component vectors, so this will be true to disambiguate + // from a scalar. + bool coopmat : 1; + TQualifier qualifier; + + TArraySizes* arraySizes; // nullptr unless an array; can be shared across types + // A type can't be both a structure (EbtStruct/EbtBlock) and a reference (EbtReference), so + // conserve space by making these a union + union { + TTypeList* structure; // invalid unless this is a struct; can be shared across types + TType *referentType; // invalid unless this is an EbtReference + }; + TString *fieldName; // for structure field names + TString *typeName; // for structure type name + TSampler sampler; + TArraySizes* typeParameters;// nullptr unless a parameterized type; can be shared across types +}; + +} // end namespace glslang + +#endif // _TYPES_INCLUDED_ diff --git a/ios/include/glslang/Include/arrays.h b/ios/include/glslang/Include/arrays.h new file mode 100644 index 00000000..7f047d9f --- /dev/null +++ b/ios/include/glslang/Include/arrays.h @@ -0,0 +1,341 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2013 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +// +// Implement types for tracking GLSL arrays, arrays of arrays, etc. +// + +#ifndef _ARRAYS_INCLUDED +#define _ARRAYS_INCLUDED + +#include + +namespace glslang { + +// This is used to mean there is no size yet (unsized), it is waiting to get a size from somewhere else. +const int UnsizedArraySize = 0; + +class TIntermTyped; +extern bool SameSpecializationConstants(TIntermTyped*, TIntermTyped*); + +// Specialization constants need both a nominal size and a node that defines +// the specialization constant being used. Array types are the same when their +// size and specialization constant nodes are the same. +struct TArraySize { + unsigned int size; + TIntermTyped* node; // nullptr means no specialization constant node + bool operator==(const TArraySize& rhs) const + { + if (size != rhs.size) + return false; + if (node == nullptr || rhs.node == nullptr) + return node == rhs.node; + + return SameSpecializationConstants(node, rhs.node); + } +}; + +// +// TSmallArrayVector is used as the container for the set of sizes in TArraySizes. +// It has generic-container semantics, while TArraySizes has array-of-array semantics. +// That is, TSmallArrayVector should be more focused on mechanism and TArraySizes on policy. +// +struct TSmallArrayVector { + // + // TODO: memory: TSmallArrayVector is intended to be smaller. + // Almost all arrays could be handled by two sizes each fitting + // in 16 bits, needing a real vector only in the cases where there + // are more than 3 sizes or a size needing more than 16 bits. + // + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + + TSmallArrayVector() : sizes(nullptr) { } + virtual ~TSmallArrayVector() { dealloc(); } + + // For breaking into two non-shared copies, independently modifiable. + TSmallArrayVector& operator=(const TSmallArrayVector& from) + { + if (from.sizes == nullptr) + sizes = nullptr; + else { + alloc(); + *sizes = *from.sizes; + } + + return *this; + } + + int size() const + { + if (sizes == nullptr) + return 0; + return (int)sizes->size(); + } + + unsigned int frontSize() const + { + assert(sizes != nullptr && sizes->size() > 0); + return sizes->front().size; + } + + TIntermTyped* frontNode() const + { + assert(sizes != nullptr && sizes->size() > 0); + return sizes->front().node; + } + + void changeFront(unsigned int s) + { + assert(sizes != nullptr); + // this should only happen for implicitly sized arrays, not specialization constants + assert(sizes->front().node == nullptr); + sizes->front().size = s; + } + + void push_back(unsigned int e, TIntermTyped* n) + { + alloc(); + TArraySize pair = { e, n }; + sizes->push_back(pair); + } + + void push_back(const TSmallArrayVector& newDims) + { + alloc(); + sizes->insert(sizes->end(), newDims.sizes->begin(), newDims.sizes->end()); + } + + void pop_front() + { + assert(sizes != nullptr && sizes->size() > 0); + if (sizes->size() == 1) + dealloc(); + else + sizes->erase(sizes->begin()); + } + + // 'this' should currently not be holding anything, and copyNonFront + // will make it hold a copy of all but the first element of rhs. + // (This would be useful for making a type that is dereferenced by + // one dimension.) + void copyNonFront(const TSmallArrayVector& rhs) + { + assert(sizes == nullptr); + if (rhs.size() > 1) { + alloc(); + sizes->insert(sizes->begin(), rhs.sizes->begin() + 1, rhs.sizes->end()); + } + } + + unsigned int getDimSize(int i) const + { + assert(sizes != nullptr && (int)sizes->size() > i); + return (*sizes)[i].size; + } + + void setDimSize(int i, unsigned int size) const + { + assert(sizes != nullptr && (int)sizes->size() > i); + assert((*sizes)[i].node == nullptr); + (*sizes)[i].size = size; + } + + TIntermTyped* getDimNode(int i) const + { + assert(sizes != nullptr && (int)sizes->size() > i); + return (*sizes)[i].node; + } + + bool operator==(const TSmallArrayVector& rhs) const + { + if (sizes == nullptr && rhs.sizes == nullptr) + return true; + if (sizes == nullptr || rhs.sizes == nullptr) + return false; + return *sizes == *rhs.sizes; + } + bool operator!=(const TSmallArrayVector& rhs) const { return ! operator==(rhs); } + +protected: + TSmallArrayVector(const TSmallArrayVector&); + + void alloc() + { + if (sizes == nullptr) + sizes = new TVector; + } + void dealloc() + { + delete sizes; + sizes = nullptr; + } + + TVector* sizes; // will either hold such a pointer, or in the future, hold the two array sizes +}; + +// +// Represent an array, or array of arrays, to arbitrary depth. This is not +// done through a hierarchy of types in a type tree, rather all contiguous arrayness +// in the type hierarchy is localized into this single cumulative object. +// +// The arrayness in TTtype is a pointer, so that it can be non-allocated and zero +// for the vast majority of types that are non-array types. +// +// Order Policy: these are all identical: +// - left to right order within a contiguous set of ...[..][..][..]... in the source language +// - index order 0, 1, 2, ... within the 'sizes' member below +// - outer-most to inner-most +// +struct TArraySizes { + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + + TArraySizes() : implicitArraySize(1), variablyIndexed(false) { } + + // For breaking into two non-shared copies, independently modifiable. + TArraySizes& operator=(const TArraySizes& from) + { + implicitArraySize = from.implicitArraySize; + variablyIndexed = from.variablyIndexed; + sizes = from.sizes; + + return *this; + } + + // translate from array-of-array semantics to container semantics + int getNumDims() const { return sizes.size(); } + int getDimSize(int dim) const { return sizes.getDimSize(dim); } + TIntermTyped* getDimNode(int dim) const { return sizes.getDimNode(dim); } + void setDimSize(int dim, int size) { sizes.setDimSize(dim, size); } + int getOuterSize() const { return sizes.frontSize(); } + TIntermTyped* getOuterNode() const { return sizes.frontNode(); } + int getCumulativeSize() const + { + int size = 1; + for (int d = 0; d < sizes.size(); ++d) { + // this only makes sense in paths that have a known array size + assert(sizes.getDimSize(d) != UnsizedArraySize); + size *= sizes.getDimSize(d); + } + return size; + } + void addInnerSize() { addInnerSize((unsigned)UnsizedArraySize); } + void addInnerSize(int s) { addInnerSize((unsigned)s, nullptr); } + void addInnerSize(int s, TIntermTyped* n) { sizes.push_back((unsigned)s, n); } + void addInnerSize(TArraySize pair) { + sizes.push_back(pair.size, pair.node); + } + void addInnerSizes(const TArraySizes& s) { sizes.push_back(s.sizes); } + void changeOuterSize(int s) { sizes.changeFront((unsigned)s); } + int getImplicitSize() const { return implicitArraySize; } + void updateImplicitSize(int s) { implicitArraySize = std::max(implicitArraySize, s); } + bool isInnerUnsized() const + { + for (int d = 1; d < sizes.size(); ++d) { + if (sizes.getDimSize(d) == (unsigned)UnsizedArraySize) + return true; + } + + return false; + } + bool clearInnerUnsized() + { + for (int d = 1; d < sizes.size(); ++d) { + if (sizes.getDimSize(d) == (unsigned)UnsizedArraySize) + setDimSize(d, 1); + } + + return false; + } + bool isInnerSpecialization() const + { + for (int d = 1; d < sizes.size(); ++d) { + if (sizes.getDimNode(d) != nullptr) + return true; + } + + return false; + } + bool isOuterSpecialization() + { + return sizes.getDimNode(0) != nullptr; + } + + bool hasUnsized() const { return getOuterSize() == UnsizedArraySize || isInnerUnsized(); } + bool isSized() const { return getOuterSize() != UnsizedArraySize; } + void dereference() { sizes.pop_front(); } + void copyDereferenced(const TArraySizes& rhs) + { + assert(sizes.size() == 0); + if (rhs.sizes.size() > 1) + sizes.copyNonFront(rhs.sizes); + } + + bool sameInnerArrayness(const TArraySizes& rhs) const + { + if (sizes.size() != rhs.sizes.size()) + return false; + + for (int d = 1; d < sizes.size(); ++d) { + if (sizes.getDimSize(d) != rhs.sizes.getDimSize(d) || + sizes.getDimNode(d) != rhs.sizes.getDimNode(d)) + return false; + } + + return true; + } + + void setVariablyIndexed() { variablyIndexed = true; } + bool isVariablyIndexed() const { return variablyIndexed; } + + bool operator==(const TArraySizes& rhs) const { return sizes == rhs.sizes; } + bool operator!=(const TArraySizes& rhs) const { return sizes != rhs.sizes; } + +protected: + TSmallArrayVector sizes; + + TArraySizes(const TArraySizes&); + + // For tracking maximum referenced compile-time constant index. + // Applies only to the outer-most dimension. Potentially becomes + // the implicit size of the array, if not variably indexed and + // otherwise legal. + int implicitArraySize; + bool variablyIndexed; // true if array is indexed with a non compile-time constant +}; + +} // end namespace glslang + +#endif // _ARRAYS_INCLUDED_ diff --git a/ios/include/glslang/Include/glslang_c_interface.h b/ios/include/glslang/Include/glslang_c_interface.h new file mode 100644 index 00000000..50e95b7e --- /dev/null +++ b/ios/include/glslang/Include/glslang_c_interface.h @@ -0,0 +1,233 @@ +/** + This code is based on the glslang_c_interface implementation by Viktor Latypov +**/ + +/** +BSD 2-Clause License + +Copyright (c) 2019, Viktor Latypov +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#ifndef GLSLANG_C_IFACE_H_INCLUDED +#define GLSLANG_C_IFACE_H_INCLUDED + +#include +#include + +#include "glslang_c_shader_types.h" + +typedef struct glslang_shader_s glslang_shader_t; +typedef struct glslang_program_s glslang_program_t; + +/* TLimits counterpart */ +typedef struct glslang_limits_s { + bool non_inductive_for_loops; + bool while_loops; + bool do_while_loops; + bool general_uniform_indexing; + bool general_attribute_matrix_vector_indexing; + bool general_varying_indexing; + bool general_sampler_indexing; + bool general_variable_indexing; + bool general_constant_matrix_vector_indexing; +} glslang_limits_t; + +/* TBuiltInResource counterpart */ +typedef struct glslang_resource_s { + int max_lights; + int max_clip_planes; + int max_texture_units; + int max_texture_coords; + int max_vertex_attribs; + int max_vertex_uniform_components; + int max_varying_floats; + int max_vertex_texture_image_units; + int max_combined_texture_image_units; + int max_texture_image_units; + int max_fragment_uniform_components; + int max_draw_buffers; + int max_vertex_uniform_vectors; + int max_varying_vectors; + int max_fragment_uniform_vectors; + int max_vertex_output_vectors; + int max_fragment_input_vectors; + int min_program_texel_offset; + int max_program_texel_offset; + int max_clip_distances; + int max_compute_work_group_count_x; + int max_compute_work_group_count_y; + int max_compute_work_group_count_z; + int max_compute_work_group_size_x; + int max_compute_work_group_size_y; + int max_compute_work_group_size_z; + int max_compute_uniform_components; + int max_compute_texture_image_units; + int max_compute_image_uniforms; + int max_compute_atomic_counters; + int max_compute_atomic_counter_buffers; + int max_varying_components; + int max_vertex_output_components; + int max_geometry_input_components; + int max_geometry_output_components; + int max_fragment_input_components; + int max_image_units; + int max_combined_image_units_and_fragment_outputs; + int max_combined_shader_output_resources; + int max_image_samples; + int max_vertex_image_uniforms; + int max_tess_control_image_uniforms; + int max_tess_evaluation_image_uniforms; + int max_geometry_image_uniforms; + int max_fragment_image_uniforms; + int max_combined_image_uniforms; + int max_geometry_texture_image_units; + int max_geometry_output_vertices; + int max_geometry_total_output_components; + int max_geometry_uniform_components; + int max_geometry_varying_components; + int max_tess_control_input_components; + int max_tess_control_output_components; + int max_tess_control_texture_image_units; + int max_tess_control_uniform_components; + int max_tess_control_total_output_components; + int max_tess_evaluation_input_components; + int max_tess_evaluation_output_components; + int max_tess_evaluation_texture_image_units; + int max_tess_evaluation_uniform_components; + int max_tess_patch_components; + int max_patch_vertices; + int max_tess_gen_level; + int max_viewports; + int max_vertex_atomic_counters; + int max_tess_control_atomic_counters; + int max_tess_evaluation_atomic_counters; + int max_geometry_atomic_counters; + int max_fragment_atomic_counters; + int max_combined_atomic_counters; + int max_atomic_counter_bindings; + int max_vertex_atomic_counter_buffers; + int max_tess_control_atomic_counter_buffers; + int max_tess_evaluation_atomic_counter_buffers; + int max_geometry_atomic_counter_buffers; + int max_fragment_atomic_counter_buffers; + int max_combined_atomic_counter_buffers; + int max_atomic_counter_buffer_size; + int max_transform_feedback_buffers; + int max_transform_feedback_interleaved_components; + int max_cull_distances; + int max_combined_clip_and_cull_distances; + int max_samples; + int max_mesh_output_vertices_nv; + int max_mesh_output_primitives_nv; + int max_mesh_work_group_size_x_nv; + int max_mesh_work_group_size_y_nv; + int max_mesh_work_group_size_z_nv; + int max_task_work_group_size_x_nv; + int max_task_work_group_size_y_nv; + int max_task_work_group_size_z_nv; + int max_mesh_view_count_nv; + int maxDualSourceDrawBuffersEXT; + + glslang_limits_t limits; +} glslang_resource_t; + +typedef struct glslang_input_s { + glslang_source_t language; + glslang_stage_t stage; + glslang_client_t client; + glslang_target_client_version_t client_version; + glslang_target_language_t target_language; + glslang_target_language_version_t target_language_version; + /** Shader source code */ + const char* code; + int default_version; + glslang_profile_t default_profile; + int force_default_version_and_profile; + int forward_compatible; + glslang_messages_t messages; + const glslang_resource_t* resource; +} glslang_input_t; + +/* Inclusion result structure allocated by C include_local/include_system callbacks */ +typedef struct glsl_include_result_s { + /* Header file name or NULL if inclusion failed */ + const char* header_name; + + /* Header contents or NULL */ + const char* header_data; + size_t header_length; + +} glsl_include_result_t; + +/* Callback for local file inclusion */ +typedef glsl_include_result_t* (*glsl_include_local_func)(void* ctx, const char* header_name, const char* includer_name, + size_t include_depth); + +/* Callback for system file inclusion */ +typedef glsl_include_result_t* (*glsl_include_system_func)(void* ctx, const char* header_name, + const char* includer_name, size_t include_depth); + +/* Callback for include result destruction */ +typedef int (*glsl_free_include_result_func)(void* ctx, glsl_include_result_t* result); + +/* Collection of callbacks for GLSL preprocessor */ +typedef struct glsl_include_callbacks_s { + glsl_include_system_func include_system; + glsl_include_local_func include_local; + glsl_free_include_result_func free_include_result; +} glsl_include_callbacks_t; + +#ifdef __cplusplus +extern "C" { +#endif + +int glslang_initialize_process(); +void glslang_finalize_process(); + +glslang_shader_t* glslang_shader_create(const glslang_input_t* input); +void glslang_shader_delete(glslang_shader_t* shader); +int glslang_shader_preprocess(glslang_shader_t* shader, const glslang_input_t* input); +int glslang_shader_parse(glslang_shader_t* shader, const glslang_input_t* input); +const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader); +const char* glslang_shader_get_info_log(glslang_shader_t* shader); +const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader); + +glslang_program_t* glslang_program_create(); +void glslang_program_delete(glslang_program_t* program); +void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader); +int glslang_program_link(glslang_program_t* program, int messages); // glslang_messages_t +void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage); +size_t glslang_program_SPIRV_get_size(glslang_program_t* program); +void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int*); +unsigned int* glslang_program_SPIRV_get_ptr(glslang_program_t* program); +const char* glslang_program_SPIRV_get_messages(glslang_program_t* program); +const char* glslang_program_get_info_log(glslang_program_t* program); +const char* glslang_program_get_info_debug_log(glslang_program_t* program); + +#ifdef __cplusplus +} +#endif + +#endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */ diff --git a/ios/include/glslang/Include/glslang_c_shader_types.h b/ios/include/glslang/Include/glslang_c_shader_types.h new file mode 100644 index 00000000..d01a115f --- /dev/null +++ b/ios/include/glslang/Include/glslang_c_shader_types.h @@ -0,0 +1,185 @@ +/** + This code is based on the glslang_c_interface implementation by Viktor Latypov +**/ + +/** +BSD 2-Clause License + +Copyright (c) 2019, Viktor Latypov +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#ifndef C_SHADER_TYPES_H_INCLUDED +#define C_SHADER_TYPES_H_INCLUDED + +#define LAST_ELEMENT_MARKER(x) x + +/* EShLanguage counterpart */ +typedef enum { + GLSLANG_STAGE_VERTEX, + GLSLANG_STAGE_TESSCONTROL, + GLSLANG_STAGE_TESSEVALUATION, + GLSLANG_STAGE_GEOMETRY, + GLSLANG_STAGE_FRAGMENT, + GLSLANG_STAGE_COMPUTE, + GLSLANG_STAGE_RAYGEN_NV, + GLSLANG_STAGE_INTERSECT_NV, + GLSLANG_STAGE_ANYHIT_NV, + GLSLANG_STAGE_CLOSESTHIT_NV, + GLSLANG_STAGE_MISS_NV, + GLSLANG_STAGE_CALLABLE_NV, + GLSLANG_STAGE_TASK_NV, + GLSLANG_STAGE_MESH_NV, + LAST_ELEMENT_MARKER(GLSLANG_STAGE_COUNT), +} glslang_stage_t; // would be better as stage, but this is ancient now + +/* EShLanguageMask counterpart */ +typedef enum { + GLSLANG_STAGE_VERTEX_MASK = (1 << GLSLANG_STAGE_VERTEX), + GLSLANG_STAGE_TESSCONTROL_MASK = (1 << GLSLANG_STAGE_TESSCONTROL), + GLSLANG_STAGE_TESSEVALUATION_MASK = (1 << GLSLANG_STAGE_TESSEVALUATION), + GLSLANG_STAGE_GEOMETRY_MASK = (1 << GLSLANG_STAGE_GEOMETRY), + GLSLANG_STAGE_FRAGMENT_MASK = (1 << GLSLANG_STAGE_FRAGMENT), + GLSLANG_STAGE_COMPUTE_MASK = (1 << GLSLANG_STAGE_COMPUTE), + GLSLANG_STAGE_RAYGEN_NV_MASK = (1 << GLSLANG_STAGE_RAYGEN_NV), + GLSLANG_STAGE_INTERSECT_NV_MASK = (1 << GLSLANG_STAGE_INTERSECT_NV), + GLSLANG_STAGE_ANYHIT_NV_MASK = (1 << GLSLANG_STAGE_ANYHIT_NV), + GLSLANG_STAGE_CLOSESTHIT_NV_MASK = (1 << GLSLANG_STAGE_CLOSESTHIT_NV), + GLSLANG_STAGE_MISS_NV_MASK = (1 << GLSLANG_STAGE_MISS_NV), + GLSLANG_STAGE_CALLABLE_NV_MASK = (1 << GLSLANG_STAGE_CALLABLE_NV), + GLSLANG_STAGE_TASK_NV_MASK = (1 << GLSLANG_STAGE_TASK_NV), + GLSLANG_STAGE_MESH_NV_MASK = (1 << GLSLANG_STAGE_MESH_NV), + LAST_ELEMENT_MARKER(GLSLANG_STAGE_MASK_COUNT), +} glslang_stage_mask_t; + +/* EShSource counterpart */ +typedef enum { + GLSLANG_SOURCE_NONE, + GLSLANG_SOURCE_GLSL, + GLSLANG_SOURCE_HLSL, + LAST_ELEMENT_MARKER(GLSLANG_SOURCE_COUNT), +} glslang_source_t; + +/* EShClient counterpart */ +typedef enum { + GLSLANG_CLIENT_NONE, + GLSLANG_CLIENT_VULKAN, + GLSLANG_CLIENT_OPENGL, + LAST_ELEMENT_MARKER(GLSLANG_CLIENT_COUNT), +} glslang_client_t; + +/* EShTargetLanguage counterpart */ +typedef enum { + GLSLANG_TARGET_NONE, + GLSLANG_TARGET_SPV, + LAST_ELEMENT_MARKER(GLSLANG_TARGET_COUNT), +} glslang_target_language_t; + +/* SH_TARGET_ClientVersion counterpart */ +typedef enum { + GLSLANG_TARGET_VULKAN_1_0 = (1 << 22), + GLSLANG_TARGET_VULKAN_1_1 = (1 << 22) | (1 << 12), + GLSLANG_TARGET_OPENGL_450 = 450, + LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT), +} glslang_target_client_version_t; + +/* SH_TARGET_LanguageVersion counterpart */ +typedef enum { + GLSLANG_TARGET_SPV_1_0 = (1 << 16), + GLSLANG_TARGET_SPV_1_1 = (1 << 16) | (1 << 8), + GLSLANG_TARGET_SPV_1_2 = (1 << 16) | (2 << 8), + GLSLANG_TARGET_SPV_1_3 = (1 << 16) | (3 << 8), + GLSLANG_TARGET_SPV_1_4 = (1 << 16) | (4 << 8), + GLSLANG_TARGET_SPV_1_5 = (1 << 16) | (5 << 8), + LAST_ELEMENT_MARKER(GLSLANG_TARGET_LANGUAGE_VERSION_COUNT), +} glslang_target_language_version_t; + +/* EShExecutable counterpart */ +typedef enum { GLSLANG_EX_VERTEX_FRAGMENT, GLSLANG_EX_FRAGMENT } glslang_executable_t; + +/* EShOptimizationLevel counterpart */ +typedef enum { + GLSLANG_OPT_NO_GENERATION, + GLSLANG_OPT_NONE, + GLSLANG_OPT_SIMPLE, + GLSLANG_OPT_FULL, + LAST_ELEMENT_MARKER(GLSLANG_OPT_LEVEL_COUNT), +} glslang_optimization_level_t; + +/* EShTextureSamplerTransformMode counterpart */ +typedef enum { + GLSLANG_TEX_SAMP_TRANS_KEEP, + GLSLANG_TEX_SAMP_TRANS_UPGRADE_TEXTURE_REMOVE_SAMPLER, + LAST_ELEMENT_MARKER(GLSLANG_TEX_SAMP_TRANS_COUNT), +} glslang_texture_sampler_transform_mode_t; + +/* EShMessages counterpart */ +typedef enum { + GLSLANG_MSG_DEFAULT_BIT = 0, + GLSLANG_MSG_RELAXED_ERRORS_BIT = (1 << 0), + GLSLANG_MSG_SUPPRESS_WARNINGS_BIT = (1 << 1), + GLSLANG_MSG_AST_BIT = (1 << 2), + GLSLANG_MSG_SPV_RULES_BIT = (1 << 3), + GLSLANG_MSG_VULKAN_RULES_BIT = (1 << 4), + GLSLANG_MSG_ONLY_PREPROCESSOR_BIT = (1 << 5), + GLSLANG_MSG_READ_HLSL_BIT = (1 << 6), + GLSLANG_MSG_CASCADING_ERRORS_BIT = (1 << 7), + GLSLANG_MSG_KEEP_UNCALLED_BIT = (1 << 8), + GLSLANG_MSG_HLSL_OFFSETS_BIT = (1 << 9), + GLSLANG_MSG_DEBUG_INFO_BIT = (1 << 10), + GLSLANG_MSG_HLSL_ENABLE_16BIT_TYPES_BIT = (1 << 11), + GLSLANG_MSG_HLSL_LEGALIZATION_BIT = (1 << 12), + GLSLANG_MSG_HLSL_DX9_COMPATIBLE_BIT = (1 << 13), + GLSLANG_MSG_BUILTIN_SYMBOL_TABLE_BIT = (1 << 14), + LAST_ELEMENT_MARKER(GLSLANG_MSG_COUNT), +} glslang_messages_t; + +/* EShReflectionOptions counterpart */ +typedef enum { + GLSLANG_REFLECTION_DEFAULT_BIT = 0, + GLSLANG_REFLECTION_STRICT_ARRAY_SUFFIX_BIT = (1 << 0), + GLSLANG_REFLECTION_BASIC_ARRAY_SUFFIX_BIT = (1 << 1), + GLSLANG_REFLECTION_INTERMEDIATE_IOO_BIT = (1 << 2), + GLSLANG_REFLECTION_SEPARATE_BUFFERS_BIT = (1 << 3), + GLSLANG_REFLECTION_ALL_BLOCK_VARIABLES_BIT = (1 << 4), + GLSLANG_REFLECTION_UNWRAP_IO_BLOCKS_BIT = (1 << 5), + GLSLANG_REFLECTION_ALL_IO_VARIABLES_BIT = (1 << 6), + GLSLANG_REFLECTION_SHARED_STD140_SSBO_BIT = (1 << 7), + GLSLANG_REFLECTION_SHARED_STD140_UBO_BIT = (1 << 8), + LAST_ELEMENT_MARKER(GLSLANG_REFLECTION_COUNT), +} glslang_reflection_options_t; + +/* EProfile counterpart (from Versions.h) */ +typedef enum { + GLSLANG_BAD_PROFILE = 0, + GLSLANG_NO_PROFILE = (1 << 0), + GLSLANG_CORE_PROFILE = (1 << 1), + GLSLANG_COMPATIBILITY_PROFILE = (1 << 2), + GLSLANG_ES_PROFILE = (1 << 3), + LAST_ELEMENT_MARKER(GLSLANG_PROFILE_COUNT), +} glslang_profile_t; + +#undef LAST_ELEMENT_MARKER + +#endif diff --git a/ios/include/glslang/Include/intermediate.h b/ios/include/glslang/Include/intermediate.h new file mode 100644 index 00000000..bf12fcf8 --- /dev/null +++ b/ios/include/glslang/Include/intermediate.h @@ -0,0 +1,1805 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2016 LunarG, Inc. +// Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +// +// Definition of the in-memory high-level intermediate representation +// of shaders. This is a tree that parser creates. +// +// Nodes in the tree are defined as a hierarchy of classes derived from +// TIntermNode. Each is a node in a tree. There is no preset branching factor; +// each node can have it's own type of list of children. +// + +#ifndef __INTERMEDIATE_H +#define __INTERMEDIATE_H + +#if defined(_MSC_VER) && _MSC_VER >= 1900 + #pragma warning(disable : 4464) // relative include path contains '..' + #pragma warning(disable : 5026) // 'glslang::TIntermUnary': move constructor was implicitly defined as deleted +#endif + +#include "../Include/Common.h" +#include "../Include/Types.h" +#include "../Include/ConstantUnion.h" + +namespace glslang { + +class TIntermediate; + +// +// Operators used by the high-level (parse tree) representation. +// +enum TOperator { + EOpNull, // if in a node, should only mean a node is still being built + EOpSequence, // denotes a list of statements, or parameters, etc. + EOpLinkerObjects, // for aggregate node of objects the linker may need, if not reference by the rest of the AST + EOpFunctionCall, + EOpFunction, // For function definition + EOpParameters, // an aggregate listing the parameters to a function + + // + // Unary operators + // + + EOpNegative, + EOpLogicalNot, + EOpVectorLogicalNot, + EOpBitwiseNot, + + EOpPostIncrement, + EOpPostDecrement, + EOpPreIncrement, + EOpPreDecrement, + + EOpCopyObject, + + // (u)int* -> bool + EOpConvInt8ToBool, + EOpConvUint8ToBool, + EOpConvInt16ToBool, + EOpConvUint16ToBool, + EOpConvIntToBool, + EOpConvUintToBool, + EOpConvInt64ToBool, + EOpConvUint64ToBool, + + // float* -> bool + EOpConvFloat16ToBool, + EOpConvFloatToBool, + EOpConvDoubleToBool, + + // bool -> (u)int* + EOpConvBoolToInt8, + EOpConvBoolToUint8, + EOpConvBoolToInt16, + EOpConvBoolToUint16, + EOpConvBoolToInt, + EOpConvBoolToUint, + EOpConvBoolToInt64, + EOpConvBoolToUint64, + + // bool -> float* + EOpConvBoolToFloat16, + EOpConvBoolToFloat, + EOpConvBoolToDouble, + + // int8_t -> (u)int* + EOpConvInt8ToInt16, + EOpConvInt8ToInt, + EOpConvInt8ToInt64, + EOpConvInt8ToUint8, + EOpConvInt8ToUint16, + EOpConvInt8ToUint, + EOpConvInt8ToUint64, + + // uint8_t -> (u)int* + EOpConvUint8ToInt8, + EOpConvUint8ToInt16, + EOpConvUint8ToInt, + EOpConvUint8ToInt64, + EOpConvUint8ToUint16, + EOpConvUint8ToUint, + EOpConvUint8ToUint64, + + // int8_t -> float* + EOpConvInt8ToFloat16, + EOpConvInt8ToFloat, + EOpConvInt8ToDouble, + + // uint8_t -> float* + EOpConvUint8ToFloat16, + EOpConvUint8ToFloat, + EOpConvUint8ToDouble, + + // int16_t -> (u)int* + EOpConvInt16ToInt8, + EOpConvInt16ToInt, + EOpConvInt16ToInt64, + EOpConvInt16ToUint8, + EOpConvInt16ToUint16, + EOpConvInt16ToUint, + EOpConvInt16ToUint64, + + // uint16_t -> (u)int* + EOpConvUint16ToInt8, + EOpConvUint16ToInt16, + EOpConvUint16ToInt, + EOpConvUint16ToInt64, + EOpConvUint16ToUint8, + EOpConvUint16ToUint, + EOpConvUint16ToUint64, + + // int16_t -> float* + EOpConvInt16ToFloat16, + EOpConvInt16ToFloat, + EOpConvInt16ToDouble, + + // uint16_t -> float* + EOpConvUint16ToFloat16, + EOpConvUint16ToFloat, + EOpConvUint16ToDouble, + + // int32_t -> (u)int* + EOpConvIntToInt8, + EOpConvIntToInt16, + EOpConvIntToInt64, + EOpConvIntToUint8, + EOpConvIntToUint16, + EOpConvIntToUint, + EOpConvIntToUint64, + + // uint32_t -> (u)int* + EOpConvUintToInt8, + EOpConvUintToInt16, + EOpConvUintToInt, + EOpConvUintToInt64, + EOpConvUintToUint8, + EOpConvUintToUint16, + EOpConvUintToUint64, + + // int32_t -> float* + EOpConvIntToFloat16, + EOpConvIntToFloat, + EOpConvIntToDouble, + + // uint32_t -> float* + EOpConvUintToFloat16, + EOpConvUintToFloat, + EOpConvUintToDouble, + + // int64_t -> (u)int* + EOpConvInt64ToInt8, + EOpConvInt64ToInt16, + EOpConvInt64ToInt, + EOpConvInt64ToUint8, + EOpConvInt64ToUint16, + EOpConvInt64ToUint, + EOpConvInt64ToUint64, + + // uint64_t -> (u)int* + EOpConvUint64ToInt8, + EOpConvUint64ToInt16, + EOpConvUint64ToInt, + EOpConvUint64ToInt64, + EOpConvUint64ToUint8, + EOpConvUint64ToUint16, + EOpConvUint64ToUint, + + // int64_t -> float* + EOpConvInt64ToFloat16, + EOpConvInt64ToFloat, + EOpConvInt64ToDouble, + + // uint64_t -> float* + EOpConvUint64ToFloat16, + EOpConvUint64ToFloat, + EOpConvUint64ToDouble, + + // float16_t -> (u)int* + EOpConvFloat16ToInt8, + EOpConvFloat16ToInt16, + EOpConvFloat16ToInt, + EOpConvFloat16ToInt64, + EOpConvFloat16ToUint8, + EOpConvFloat16ToUint16, + EOpConvFloat16ToUint, + EOpConvFloat16ToUint64, + + // float16_t -> float* + EOpConvFloat16ToFloat, + EOpConvFloat16ToDouble, + + // float -> (u)int* + EOpConvFloatToInt8, + EOpConvFloatToInt16, + EOpConvFloatToInt, + EOpConvFloatToInt64, + EOpConvFloatToUint8, + EOpConvFloatToUint16, + EOpConvFloatToUint, + EOpConvFloatToUint64, + + // float -> float* + EOpConvFloatToFloat16, + EOpConvFloatToDouble, + + // float64 _t-> (u)int* + EOpConvDoubleToInt8, + EOpConvDoubleToInt16, + EOpConvDoubleToInt, + EOpConvDoubleToInt64, + EOpConvDoubleToUint8, + EOpConvDoubleToUint16, + EOpConvDoubleToUint, + EOpConvDoubleToUint64, + + // float64_t -> float* + EOpConvDoubleToFloat16, + EOpConvDoubleToFloat, + + // uint64_t <-> pointer + EOpConvUint64ToPtr, + EOpConvPtrToUint64, + + // uvec2 <-> pointer + EOpConvUvec2ToPtr, + EOpConvPtrToUvec2, + + // + // binary operations + // + + EOpAdd, + EOpSub, + EOpMul, + EOpDiv, + EOpMod, + EOpRightShift, + EOpLeftShift, + EOpAnd, + EOpInclusiveOr, + EOpExclusiveOr, + EOpEqual, + EOpNotEqual, + EOpVectorEqual, + EOpVectorNotEqual, + EOpLessThan, + EOpGreaterThan, + EOpLessThanEqual, + EOpGreaterThanEqual, + EOpComma, + + EOpVectorTimesScalar, + EOpVectorTimesMatrix, + EOpMatrixTimesVector, + EOpMatrixTimesScalar, + + EOpLogicalOr, + EOpLogicalXor, + EOpLogicalAnd, + + EOpIndexDirect, + EOpIndexIndirect, + EOpIndexDirectStruct, + + EOpVectorSwizzle, + + EOpMethod, + EOpScoping, + + // + // Built-in functions mapped to operators + // + + EOpRadians, + EOpDegrees, + EOpSin, + EOpCos, + EOpTan, + EOpAsin, + EOpAcos, + EOpAtan, + EOpSinh, + EOpCosh, + EOpTanh, + EOpAsinh, + EOpAcosh, + EOpAtanh, + + EOpPow, + EOpExp, + EOpLog, + EOpExp2, + EOpLog2, + EOpSqrt, + EOpInverseSqrt, + + EOpAbs, + EOpSign, + EOpFloor, + EOpTrunc, + EOpRound, + EOpRoundEven, + EOpCeil, + EOpFract, + EOpModf, + EOpMin, + EOpMax, + EOpClamp, + EOpMix, + EOpStep, + EOpSmoothStep, + + EOpIsNan, + EOpIsInf, + + EOpFma, + + EOpFrexp, + EOpLdexp, + + EOpFloatBitsToInt, + EOpFloatBitsToUint, + EOpIntBitsToFloat, + EOpUintBitsToFloat, + EOpDoubleBitsToInt64, + EOpDoubleBitsToUint64, + EOpInt64BitsToDouble, + EOpUint64BitsToDouble, + EOpFloat16BitsToInt16, + EOpFloat16BitsToUint16, + EOpInt16BitsToFloat16, + EOpUint16BitsToFloat16, + EOpPackSnorm2x16, + EOpUnpackSnorm2x16, + EOpPackUnorm2x16, + EOpUnpackUnorm2x16, + EOpPackSnorm4x8, + EOpUnpackSnorm4x8, + EOpPackUnorm4x8, + EOpUnpackUnorm4x8, + EOpPackHalf2x16, + EOpUnpackHalf2x16, + EOpPackDouble2x32, + EOpUnpackDouble2x32, + EOpPackInt2x32, + EOpUnpackInt2x32, + EOpPackUint2x32, + EOpUnpackUint2x32, + EOpPackFloat2x16, + EOpUnpackFloat2x16, + EOpPackInt2x16, + EOpUnpackInt2x16, + EOpPackUint2x16, + EOpUnpackUint2x16, + EOpPackInt4x16, + EOpUnpackInt4x16, + EOpPackUint4x16, + EOpUnpackUint4x16, + EOpPack16, + EOpPack32, + EOpPack64, + EOpUnpack32, + EOpUnpack16, + EOpUnpack8, + + EOpLength, + EOpDistance, + EOpDot, + EOpCross, + EOpNormalize, + EOpFaceForward, + EOpReflect, + EOpRefract, + + EOpMin3, + EOpMax3, + EOpMid3, + + EOpDPdx, // Fragment only + EOpDPdy, // Fragment only + EOpFwidth, // Fragment only + EOpDPdxFine, // Fragment only + EOpDPdyFine, // Fragment only + EOpFwidthFine, // Fragment only + EOpDPdxCoarse, // Fragment only + EOpDPdyCoarse, // Fragment only + EOpFwidthCoarse, // Fragment only + + EOpInterpolateAtCentroid, // Fragment only + EOpInterpolateAtSample, // Fragment only + EOpInterpolateAtOffset, // Fragment only + EOpInterpolateAtVertex, + + EOpMatrixTimesMatrix, + EOpOuterProduct, + EOpDeterminant, + EOpMatrixInverse, + EOpTranspose, + + EOpFtransform, + + EOpNoise, + + EOpEmitVertex, // geometry only + EOpEndPrimitive, // geometry only + EOpEmitStreamVertex, // geometry only + EOpEndStreamPrimitive, // geometry only + + EOpBarrier, + EOpMemoryBarrier, + EOpMemoryBarrierAtomicCounter, + EOpMemoryBarrierBuffer, + EOpMemoryBarrierImage, + EOpMemoryBarrierShared, // compute only + EOpGroupMemoryBarrier, // compute only + + EOpBallot, + EOpReadInvocation, + EOpReadFirstInvocation, + + EOpAnyInvocation, + EOpAllInvocations, + EOpAllInvocationsEqual, + + EOpSubgroupGuardStart, + EOpSubgroupBarrier, + EOpSubgroupMemoryBarrier, + EOpSubgroupMemoryBarrierBuffer, + EOpSubgroupMemoryBarrierImage, + EOpSubgroupMemoryBarrierShared, // compute only + EOpSubgroupElect, + EOpSubgroupAll, + EOpSubgroupAny, + EOpSubgroupAllEqual, + EOpSubgroupBroadcast, + EOpSubgroupBroadcastFirst, + EOpSubgroupBallot, + EOpSubgroupInverseBallot, + EOpSubgroupBallotBitExtract, + EOpSubgroupBallotBitCount, + EOpSubgroupBallotInclusiveBitCount, + EOpSubgroupBallotExclusiveBitCount, + EOpSubgroupBallotFindLSB, + EOpSubgroupBallotFindMSB, + EOpSubgroupShuffle, + EOpSubgroupShuffleXor, + EOpSubgroupShuffleUp, + EOpSubgroupShuffleDown, + EOpSubgroupAdd, + EOpSubgroupMul, + EOpSubgroupMin, + EOpSubgroupMax, + EOpSubgroupAnd, + EOpSubgroupOr, + EOpSubgroupXor, + EOpSubgroupInclusiveAdd, + EOpSubgroupInclusiveMul, + EOpSubgroupInclusiveMin, + EOpSubgroupInclusiveMax, + EOpSubgroupInclusiveAnd, + EOpSubgroupInclusiveOr, + EOpSubgroupInclusiveXor, + EOpSubgroupExclusiveAdd, + EOpSubgroupExclusiveMul, + EOpSubgroupExclusiveMin, + EOpSubgroupExclusiveMax, + EOpSubgroupExclusiveAnd, + EOpSubgroupExclusiveOr, + EOpSubgroupExclusiveXor, + EOpSubgroupClusteredAdd, + EOpSubgroupClusteredMul, + EOpSubgroupClusteredMin, + EOpSubgroupClusteredMax, + EOpSubgroupClusteredAnd, + EOpSubgroupClusteredOr, + EOpSubgroupClusteredXor, + EOpSubgroupQuadBroadcast, + EOpSubgroupQuadSwapHorizontal, + EOpSubgroupQuadSwapVertical, + EOpSubgroupQuadSwapDiagonal, + + EOpSubgroupPartition, + EOpSubgroupPartitionedAdd, + EOpSubgroupPartitionedMul, + EOpSubgroupPartitionedMin, + EOpSubgroupPartitionedMax, + EOpSubgroupPartitionedAnd, + EOpSubgroupPartitionedOr, + EOpSubgroupPartitionedXor, + EOpSubgroupPartitionedInclusiveAdd, + EOpSubgroupPartitionedInclusiveMul, + EOpSubgroupPartitionedInclusiveMin, + EOpSubgroupPartitionedInclusiveMax, + EOpSubgroupPartitionedInclusiveAnd, + EOpSubgroupPartitionedInclusiveOr, + EOpSubgroupPartitionedInclusiveXor, + EOpSubgroupPartitionedExclusiveAdd, + EOpSubgroupPartitionedExclusiveMul, + EOpSubgroupPartitionedExclusiveMin, + EOpSubgroupPartitionedExclusiveMax, + EOpSubgroupPartitionedExclusiveAnd, + EOpSubgroupPartitionedExclusiveOr, + EOpSubgroupPartitionedExclusiveXor, + + EOpSubgroupGuardStop, + + EOpMinInvocations, + EOpMaxInvocations, + EOpAddInvocations, + EOpMinInvocationsNonUniform, + EOpMaxInvocationsNonUniform, + EOpAddInvocationsNonUniform, + EOpMinInvocationsInclusiveScan, + EOpMaxInvocationsInclusiveScan, + EOpAddInvocationsInclusiveScan, + EOpMinInvocationsInclusiveScanNonUniform, + EOpMaxInvocationsInclusiveScanNonUniform, + EOpAddInvocationsInclusiveScanNonUniform, + EOpMinInvocationsExclusiveScan, + EOpMaxInvocationsExclusiveScan, + EOpAddInvocationsExclusiveScan, + EOpMinInvocationsExclusiveScanNonUniform, + EOpMaxInvocationsExclusiveScanNonUniform, + EOpAddInvocationsExclusiveScanNonUniform, + EOpSwizzleInvocations, + EOpSwizzleInvocationsMasked, + EOpWriteInvocation, + EOpMbcnt, + + EOpCubeFaceIndex, + EOpCubeFaceCoord, + EOpTime, + + EOpAtomicAdd, + EOpAtomicMin, + EOpAtomicMax, + EOpAtomicAnd, + EOpAtomicOr, + EOpAtomicXor, + EOpAtomicExchange, + EOpAtomicCompSwap, + EOpAtomicLoad, + EOpAtomicStore, + + EOpAtomicCounterIncrement, // results in pre-increment value + EOpAtomicCounterDecrement, // results in post-decrement value + EOpAtomicCounter, + EOpAtomicCounterAdd, + EOpAtomicCounterSubtract, + EOpAtomicCounterMin, + EOpAtomicCounterMax, + EOpAtomicCounterAnd, + EOpAtomicCounterOr, + EOpAtomicCounterXor, + EOpAtomicCounterExchange, + EOpAtomicCounterCompSwap, + + EOpAny, + EOpAll, + + EOpCooperativeMatrixLoad, + EOpCooperativeMatrixStore, + EOpCooperativeMatrixMulAdd, + + EOpBeginInvocationInterlock, // Fragment only + EOpEndInvocationInterlock, // Fragment only + + EOpIsHelperInvocation, + + EOpDebugPrintf, + + // + // Branch + // + + EOpKill, // Fragment only + EOpReturn, + EOpBreak, + EOpContinue, + EOpCase, + EOpDefault, + EOpDemote, // Fragment only + + // + // Constructors + // + + EOpConstructGuardStart, + EOpConstructInt, // these first scalar forms also identify what implicit conversion is needed + EOpConstructUint, + EOpConstructInt8, + EOpConstructUint8, + EOpConstructInt16, + EOpConstructUint16, + EOpConstructInt64, + EOpConstructUint64, + EOpConstructBool, + EOpConstructFloat, + EOpConstructDouble, + // Keep vector and matrix constructors in a consistent relative order for + // TParseContext::constructBuiltIn, which converts between 8/16/32 bit + // vector constructors + EOpConstructVec2, + EOpConstructVec3, + EOpConstructVec4, + EOpConstructMat2x2, + EOpConstructMat2x3, + EOpConstructMat2x4, + EOpConstructMat3x2, + EOpConstructMat3x3, + EOpConstructMat3x4, + EOpConstructMat4x2, + EOpConstructMat4x3, + EOpConstructMat4x4, + EOpConstructDVec2, + EOpConstructDVec3, + EOpConstructDVec4, + EOpConstructBVec2, + EOpConstructBVec3, + EOpConstructBVec4, + EOpConstructI8Vec2, + EOpConstructI8Vec3, + EOpConstructI8Vec4, + EOpConstructU8Vec2, + EOpConstructU8Vec3, + EOpConstructU8Vec4, + EOpConstructI16Vec2, + EOpConstructI16Vec3, + EOpConstructI16Vec4, + EOpConstructU16Vec2, + EOpConstructU16Vec3, + EOpConstructU16Vec4, + EOpConstructIVec2, + EOpConstructIVec3, + EOpConstructIVec4, + EOpConstructUVec2, + EOpConstructUVec3, + EOpConstructUVec4, + EOpConstructI64Vec2, + EOpConstructI64Vec3, + EOpConstructI64Vec4, + EOpConstructU64Vec2, + EOpConstructU64Vec3, + EOpConstructU64Vec4, + EOpConstructDMat2x2, + EOpConstructDMat2x3, + EOpConstructDMat2x4, + EOpConstructDMat3x2, + EOpConstructDMat3x3, + EOpConstructDMat3x4, + EOpConstructDMat4x2, + EOpConstructDMat4x3, + EOpConstructDMat4x4, + EOpConstructIMat2x2, + EOpConstructIMat2x3, + EOpConstructIMat2x4, + EOpConstructIMat3x2, + EOpConstructIMat3x3, + EOpConstructIMat3x4, + EOpConstructIMat4x2, + EOpConstructIMat4x3, + EOpConstructIMat4x4, + EOpConstructUMat2x2, + EOpConstructUMat2x3, + EOpConstructUMat2x4, + EOpConstructUMat3x2, + EOpConstructUMat3x3, + EOpConstructUMat3x4, + EOpConstructUMat4x2, + EOpConstructUMat4x3, + EOpConstructUMat4x4, + EOpConstructBMat2x2, + EOpConstructBMat2x3, + EOpConstructBMat2x4, + EOpConstructBMat3x2, + EOpConstructBMat3x3, + EOpConstructBMat3x4, + EOpConstructBMat4x2, + EOpConstructBMat4x3, + EOpConstructBMat4x4, + EOpConstructFloat16, + EOpConstructF16Vec2, + EOpConstructF16Vec3, + EOpConstructF16Vec4, + EOpConstructF16Mat2x2, + EOpConstructF16Mat2x3, + EOpConstructF16Mat2x4, + EOpConstructF16Mat3x2, + EOpConstructF16Mat3x3, + EOpConstructF16Mat3x4, + EOpConstructF16Mat4x2, + EOpConstructF16Mat4x3, + EOpConstructF16Mat4x4, + EOpConstructStruct, + EOpConstructTextureSampler, + EOpConstructNonuniform, // expected to be transformed away, not present in final AST + EOpConstructReference, + EOpConstructCooperativeMatrix, + EOpConstructGuardEnd, + + // + // moves + // + + EOpAssign, + EOpAddAssign, + EOpSubAssign, + EOpMulAssign, + EOpVectorTimesMatrixAssign, + EOpVectorTimesScalarAssign, + EOpMatrixTimesScalarAssign, + EOpMatrixTimesMatrixAssign, + EOpDivAssign, + EOpModAssign, + EOpAndAssign, + EOpInclusiveOrAssign, + EOpExclusiveOrAssign, + EOpLeftShiftAssign, + EOpRightShiftAssign, + + // + // Array operators + // + + // Can apply to arrays, vectors, or matrices. + // Can be decomposed to a constant at compile time, but this does not always happen, + // due to link-time effects. So, consumer can expect either a link-time sized or + // run-time sized array. + EOpArrayLength, + + // + // Image operations + // + + EOpImageGuardBegin, + + EOpImageQuerySize, + EOpImageQuerySamples, + EOpImageLoad, + EOpImageStore, + EOpImageLoadLod, + EOpImageStoreLod, + EOpImageAtomicAdd, + EOpImageAtomicMin, + EOpImageAtomicMax, + EOpImageAtomicAnd, + EOpImageAtomicOr, + EOpImageAtomicXor, + EOpImageAtomicExchange, + EOpImageAtomicCompSwap, + EOpImageAtomicLoad, + EOpImageAtomicStore, + + EOpSubpassLoad, + EOpSubpassLoadMS, + EOpSparseImageLoad, + EOpSparseImageLoadLod, + + EOpImageGuardEnd, + + // + // Texture operations + // + + EOpTextureGuardBegin, + + EOpTextureQuerySize, + EOpTextureQueryLod, + EOpTextureQueryLevels, + EOpTextureQuerySamples, + + EOpSamplingGuardBegin, + + EOpTexture, + EOpTextureProj, + EOpTextureLod, + EOpTextureOffset, + EOpTextureFetch, + EOpTextureFetchOffset, + EOpTextureProjOffset, + EOpTextureLodOffset, + EOpTextureProjLod, + EOpTextureProjLodOffset, + EOpTextureGrad, + EOpTextureGradOffset, + EOpTextureProjGrad, + EOpTextureProjGradOffset, + EOpTextureGather, + EOpTextureGatherOffset, + EOpTextureGatherOffsets, + EOpTextureClamp, + EOpTextureOffsetClamp, + EOpTextureGradClamp, + EOpTextureGradOffsetClamp, + EOpTextureGatherLod, + EOpTextureGatherLodOffset, + EOpTextureGatherLodOffsets, + EOpFragmentMaskFetch, + EOpFragmentFetch, + + EOpSparseTextureGuardBegin, + + EOpSparseTexture, + EOpSparseTextureLod, + EOpSparseTextureOffset, + EOpSparseTextureFetch, + EOpSparseTextureFetchOffset, + EOpSparseTextureLodOffset, + EOpSparseTextureGrad, + EOpSparseTextureGradOffset, + EOpSparseTextureGather, + EOpSparseTextureGatherOffset, + EOpSparseTextureGatherOffsets, + EOpSparseTexelsResident, + EOpSparseTextureClamp, + EOpSparseTextureOffsetClamp, + EOpSparseTextureGradClamp, + EOpSparseTextureGradOffsetClamp, + EOpSparseTextureGatherLod, + EOpSparseTextureGatherLodOffset, + EOpSparseTextureGatherLodOffsets, + + EOpSparseTextureGuardEnd, + + EOpImageFootprintGuardBegin, + EOpImageSampleFootprintNV, + EOpImageSampleFootprintClampNV, + EOpImageSampleFootprintLodNV, + EOpImageSampleFootprintGradNV, + EOpImageSampleFootprintGradClampNV, + EOpImageFootprintGuardEnd, + EOpSamplingGuardEnd, + EOpTextureGuardEnd, + + // + // Integer operations + // + + EOpAddCarry, + EOpSubBorrow, + EOpUMulExtended, + EOpIMulExtended, + EOpBitfieldExtract, + EOpBitfieldInsert, + EOpBitFieldReverse, + EOpBitCount, + EOpFindLSB, + EOpFindMSB, + + EOpCountLeadingZeros, + EOpCountTrailingZeros, + EOpAbsDifference, + EOpAddSaturate, + EOpSubSaturate, + EOpAverage, + EOpAverageRounded, + EOpMul32x16, + + EOpTrace, + EOpReportIntersection, + EOpIgnoreIntersection, + EOpTerminateRay, + EOpExecuteCallable, + EOpWritePackedPrimitiveIndices4x8NV, + + // + // GL_EXT_ray_query operations + // + + EOpRayQueryInitialize, + EOpRayQueryTerminate, + EOpRayQueryGenerateIntersection, + EOpRayQueryConfirmIntersection, + EOpRayQueryProceed, + EOpRayQueryGetIntersectionType, + EOpRayQueryGetRayTMin, + EOpRayQueryGetRayFlags, + EOpRayQueryGetIntersectionT, + EOpRayQueryGetIntersectionInstanceCustomIndex, + EOpRayQueryGetIntersectionInstanceId, + EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset, + EOpRayQueryGetIntersectionGeometryIndex, + EOpRayQueryGetIntersectionPrimitiveIndex, + EOpRayQueryGetIntersectionBarycentrics, + EOpRayQueryGetIntersectionFrontFace, + EOpRayQueryGetIntersectionCandidateAABBOpaque, + EOpRayQueryGetIntersectionObjectRayDirection, + EOpRayQueryGetIntersectionObjectRayOrigin, + EOpRayQueryGetWorldRayDirection, + EOpRayQueryGetWorldRayOrigin, + EOpRayQueryGetIntersectionObjectToWorld, + EOpRayQueryGetIntersectionWorldToObject, + + // + // HLSL operations + // + + EOpClip, // discard if input value < 0 + EOpIsFinite, + EOpLog10, // base 10 log + EOpRcp, // 1/x + EOpSaturate, // clamp from 0 to 1 + EOpSinCos, // sin and cos in out parameters + EOpGenMul, // mul(x,y) on any of mat/vec/scalars + EOpDst, // x = 1, y=src0.y * src1.y, z=src0.z, w=src1.w + EOpInterlockedAdd, // atomic ops, but uses [optional] out arg instead of return + EOpInterlockedAnd, // ... + EOpInterlockedCompareExchange, // ... + EOpInterlockedCompareStore, // ... + EOpInterlockedExchange, // ... + EOpInterlockedMax, // ... + EOpInterlockedMin, // ... + EOpInterlockedOr, // ... + EOpInterlockedXor, // ... + EOpAllMemoryBarrierWithGroupSync, // memory barriers without non-hlsl AST equivalents + EOpDeviceMemoryBarrier, // ... + EOpDeviceMemoryBarrierWithGroupSync, // ... + EOpWorkgroupMemoryBarrier, // ... + EOpWorkgroupMemoryBarrierWithGroupSync, // ... + EOpEvaluateAttributeSnapped, // InterpolateAtOffset with int position on 16x16 grid + EOpF32tof16, // HLSL conversion: half of a PackHalf2x16 + EOpF16tof32, // HLSL conversion: half of an UnpackHalf2x16 + EOpLit, // HLSL lighting coefficient vector + EOpTextureBias, // HLSL texture bias: will be lowered to EOpTexture + EOpAsDouble, // slightly different from EOpUint64BitsToDouble + EOpD3DCOLORtoUBYTE4, // convert and swizzle 4-component color to UBYTE4 range + + EOpMethodSample, // Texture object methods. These are translated to existing + EOpMethodSampleBias, // AST methods, and exist to represent HLSL semantics until that + EOpMethodSampleCmp, // translation is performed. See HlslParseContext::decomposeSampleMethods(). + EOpMethodSampleCmpLevelZero, // ... + EOpMethodSampleGrad, // ... + EOpMethodSampleLevel, // ... + EOpMethodLoad, // ... + EOpMethodGetDimensions, // ... + EOpMethodGetSamplePosition, // ... + EOpMethodGather, // ... + EOpMethodCalculateLevelOfDetail, // ... + EOpMethodCalculateLevelOfDetailUnclamped, // ... + + // Load already defined above for textures + EOpMethodLoad2, // Structure buffer object methods. These are translated to existing + EOpMethodLoad3, // AST methods, and exist to represent HLSL semantics until that + EOpMethodLoad4, // translation is performed. See HlslParseContext::decomposeSampleMethods(). + EOpMethodStore, // ... + EOpMethodStore2, // ... + EOpMethodStore3, // ... + EOpMethodStore4, // ... + EOpMethodIncrementCounter, // ... + EOpMethodDecrementCounter, // ... + // EOpMethodAppend is defined for geo shaders below + EOpMethodConsume, + + // SM5 texture methods + EOpMethodGatherRed, // These are covered under the above EOpMethodSample comment about + EOpMethodGatherGreen, // translation to existing AST opcodes. They exist temporarily + EOpMethodGatherBlue, // because HLSL arguments are slightly different. + EOpMethodGatherAlpha, // ... + EOpMethodGatherCmp, // ... + EOpMethodGatherCmpRed, // ... + EOpMethodGatherCmpGreen, // ... + EOpMethodGatherCmpBlue, // ... + EOpMethodGatherCmpAlpha, // ... + + // geometry methods + EOpMethodAppend, // Geometry shader methods + EOpMethodRestartStrip, // ... + + // matrix + EOpMatrixSwizzle, // select multiple matrix components (non-column) + + // SM6 wave ops + EOpWaveGetLaneCount, // Will decompose to gl_SubgroupSize. + EOpWaveGetLaneIndex, // Will decompose to gl_SubgroupInvocationID. + EOpWaveActiveCountBits, // Will decompose to subgroupBallotBitCount(subgroupBallot()). + EOpWavePrefixCountBits, // Will decompose to subgroupBallotInclusiveBitCount(subgroupBallot()). + + // Shader Clock Ops + EOpReadClockSubgroupKHR, + EOpReadClockDeviceKHR, +}; + +class TIntermTraverser; +class TIntermOperator; +class TIntermAggregate; +class TIntermUnary; +class TIntermBinary; +class TIntermConstantUnion; +class TIntermSelection; +class TIntermSwitch; +class TIntermBranch; +class TIntermTyped; +class TIntermMethod; +class TIntermSymbol; +class TIntermLoop; + +} // end namespace glslang + +// +// Base class for the tree nodes +// +// (Put outside the glslang namespace, as it's used as part of the external interface.) +// +class TIntermNode { +public: + POOL_ALLOCATOR_NEW_DELETE(glslang::GetThreadPoolAllocator()) + + TIntermNode() { loc.init(); } + virtual const glslang::TSourceLoc& getLoc() const { return loc; } + virtual void setLoc(const glslang::TSourceLoc& l) { loc = l; } + virtual void traverse(glslang::TIntermTraverser*) = 0; + virtual glslang::TIntermTyped* getAsTyped() { return 0; } + virtual glslang::TIntermOperator* getAsOperator() { return 0; } + virtual glslang::TIntermConstantUnion* getAsConstantUnion() { return 0; } + virtual glslang::TIntermAggregate* getAsAggregate() { return 0; } + virtual glslang::TIntermUnary* getAsUnaryNode() { return 0; } + virtual glslang::TIntermBinary* getAsBinaryNode() { return 0; } + virtual glslang::TIntermSelection* getAsSelectionNode() { return 0; } + virtual glslang::TIntermSwitch* getAsSwitchNode() { return 0; } + virtual glslang::TIntermMethod* getAsMethodNode() { return 0; } + virtual glslang::TIntermSymbol* getAsSymbolNode() { return 0; } + virtual glslang::TIntermBranch* getAsBranchNode() { return 0; } + virtual glslang::TIntermLoop* getAsLoopNode() { return 0; } + + virtual const glslang::TIntermTyped* getAsTyped() const { return 0; } + virtual const glslang::TIntermOperator* getAsOperator() const { return 0; } + virtual const glslang::TIntermConstantUnion* getAsConstantUnion() const { return 0; } + virtual const glslang::TIntermAggregate* getAsAggregate() const { return 0; } + virtual const glslang::TIntermUnary* getAsUnaryNode() const { return 0; } + virtual const glslang::TIntermBinary* getAsBinaryNode() const { return 0; } + virtual const glslang::TIntermSelection* getAsSelectionNode() const { return 0; } + virtual const glslang::TIntermSwitch* getAsSwitchNode() const { return 0; } + virtual const glslang::TIntermMethod* getAsMethodNode() const { return 0; } + virtual const glslang::TIntermSymbol* getAsSymbolNode() const { return 0; } + virtual const glslang::TIntermBranch* getAsBranchNode() const { return 0; } + virtual const glslang::TIntermLoop* getAsLoopNode() const { return 0; } + virtual ~TIntermNode() { } + +protected: + TIntermNode(const TIntermNode&); + TIntermNode& operator=(const TIntermNode&); + glslang::TSourceLoc loc; +}; + +namespace glslang { + +// +// This is just to help yacc. +// +struct TIntermNodePair { + TIntermNode* node1; + TIntermNode* node2; +}; + +// +// Intermediate class for nodes that have a type. +// +class TIntermTyped : public TIntermNode { +public: + TIntermTyped(const TType& t) { type.shallowCopy(t); } + TIntermTyped(TBasicType basicType) { TType bt(basicType); type.shallowCopy(bt); } + virtual TIntermTyped* getAsTyped() { return this; } + virtual const TIntermTyped* getAsTyped() const { return this; } + virtual void setType(const TType& t) { type.shallowCopy(t); } + virtual const TType& getType() const { return type; } + virtual TType& getWritableType() { return type; } + + virtual TBasicType getBasicType() const { return type.getBasicType(); } + virtual TQualifier& getQualifier() { return type.getQualifier(); } + virtual const TQualifier& getQualifier() const { return type.getQualifier(); } + virtual void propagatePrecision(TPrecisionQualifier); + virtual int getVectorSize() const { return type.getVectorSize(); } + virtual int getMatrixCols() const { return type.getMatrixCols(); } + virtual int getMatrixRows() const { return type.getMatrixRows(); } + virtual bool isMatrix() const { return type.isMatrix(); } + virtual bool isArray() const { return type.isArray(); } + virtual bool isVector() const { return type.isVector(); } + virtual bool isScalar() const { return type.isScalar(); } + virtual bool isStruct() const { return type.isStruct(); } + virtual bool isFloatingDomain() const { return type.isFloatingDomain(); } + virtual bool isIntegerDomain() const { return type.isIntegerDomain(); } + bool isAtomic() const { return type.isAtomic(); } + bool isReference() const { return type.isReference(); } + TString getCompleteString() const { return type.getCompleteString(); } + +protected: + TIntermTyped& operator=(const TIntermTyped&); + TType type; +}; + +// +// Handle for, do-while, and while loops. +// +class TIntermLoop : public TIntermNode { +public: + TIntermLoop(TIntermNode* aBody, TIntermTyped* aTest, TIntermTyped* aTerminal, bool testFirst) : + body(aBody), + test(aTest), + terminal(aTerminal), + first(testFirst), + unroll(false), + dontUnroll(false), + dependency(0), + minIterations(0), + maxIterations(iterationsInfinite), + iterationMultiple(1), + peelCount(0), + partialCount(0) + { } + + virtual TIntermLoop* getAsLoopNode() { return this; } + virtual const TIntermLoop* getAsLoopNode() const { return this; } + virtual void traverse(TIntermTraverser*); + TIntermNode* getBody() const { return body; } + TIntermTyped* getTest() const { return test; } + TIntermTyped* getTerminal() const { return terminal; } + bool testFirst() const { return first; } + + void setUnroll() { unroll = true; } + void setDontUnroll() { + dontUnroll = true; + peelCount = 0; + partialCount = 0; + } + bool getUnroll() const { return unroll; } + bool getDontUnroll() const { return dontUnroll; } + + static const unsigned int dependencyInfinite = 0xFFFFFFFF; + static const unsigned int iterationsInfinite = 0xFFFFFFFF; + void setLoopDependency(int d) { dependency = d; } + int getLoopDependency() const { return dependency; } + + void setMinIterations(unsigned int v) { minIterations = v; } + unsigned int getMinIterations() const { return minIterations; } + void setMaxIterations(unsigned int v) { maxIterations = v; } + unsigned int getMaxIterations() const { return maxIterations; } + void setIterationMultiple(unsigned int v) { iterationMultiple = v; } + unsigned int getIterationMultiple() const { return iterationMultiple; } + void setPeelCount(unsigned int v) { + peelCount = v; + dontUnroll = false; + } + unsigned int getPeelCount() const { return peelCount; } + void setPartialCount(unsigned int v) { + partialCount = v; + dontUnroll = false; + } + unsigned int getPartialCount() const { return partialCount; } + +protected: + TIntermNode* body; // code to loop over + TIntermTyped* test; // exit condition associated with loop, could be 0 for 'for' loops + TIntermTyped* terminal; // exists for for-loops + bool first; // true for while and for, not for do-while + bool unroll; // true if unroll requested + bool dontUnroll; // true if request to not unroll + unsigned int dependency; // loop dependency hint; 0 means not set or unknown + unsigned int minIterations; // as per the SPIR-V specification + unsigned int maxIterations; // as per the SPIR-V specification + unsigned int iterationMultiple; // as per the SPIR-V specification + unsigned int peelCount; // as per the SPIR-V specification + unsigned int partialCount; // as per the SPIR-V specification +}; + +// +// Handle case, break, continue, return, and kill. +// +class TIntermBranch : public TIntermNode { +public: + TIntermBranch(TOperator op, TIntermTyped* e) : + flowOp(op), + expression(e) { } + virtual TIntermBranch* getAsBranchNode() { return this; } + virtual const TIntermBranch* getAsBranchNode() const { return this; } + virtual void traverse(TIntermTraverser*); + TOperator getFlowOp() const { return flowOp; } + TIntermTyped* getExpression() const { return expression; } + void setExpression(TIntermTyped* pExpression) { expression = pExpression; } +protected: + TOperator flowOp; + TIntermTyped* expression; +}; + +// +// Represent method names before seeing their calling signature +// or resolving them to operations. Just an expression as the base object +// and a textural name. +// +class TIntermMethod : public TIntermTyped { +public: + TIntermMethod(TIntermTyped* o, const TType& t, const TString& m) : TIntermTyped(t), object(o), method(m) { } + virtual TIntermMethod* getAsMethodNode() { return this; } + virtual const TIntermMethod* getAsMethodNode() const { return this; } + virtual const TString& getMethodName() const { return method; } + virtual TIntermTyped* getObject() const { return object; } + virtual void traverse(TIntermTraverser*); +protected: + TIntermTyped* object; + TString method; +}; + +// +// Nodes that correspond to symbols or constants in the source code. +// +class TIntermSymbol : public TIntermTyped { +public: + // if symbol is initialized as symbol(sym), the memory comes from the pool allocator of sym. If sym comes from + // per process threadPoolAllocator, then it causes increased memory usage per compile + // it is essential to use "symbol = sym" to assign to symbol + TIntermSymbol(int i, const TString& n, const TType& t) + : TIntermTyped(t), id(i), +#ifndef GLSLANG_WEB + flattenSubset(-1), +#endif + constSubtree(nullptr) + { name = n; } + virtual int getId() const { return id; } + virtual void changeId(int i) { id = i; } + virtual const TString& getName() const { return name; } + virtual void traverse(TIntermTraverser*); + virtual TIntermSymbol* getAsSymbolNode() { return this; } + virtual const TIntermSymbol* getAsSymbolNode() const { return this; } + void setConstArray(const TConstUnionArray& c) { constArray = c; } + const TConstUnionArray& getConstArray() const { return constArray; } + void setConstSubtree(TIntermTyped* subtree) { constSubtree = subtree; } + TIntermTyped* getConstSubtree() const { return constSubtree; } +#ifndef GLSLANG_WEB + void setFlattenSubset(int subset) { flattenSubset = subset; } + int getFlattenSubset() const { return flattenSubset; } // -1 means full object +#endif + + // This is meant for cases where a node has already been constructed, and + // later on, it becomes necessary to switch to a different symbol. + virtual void switchId(int newId) { id = newId; } + +protected: + int id; // the unique id of the symbol this node represents +#ifndef GLSLANG_WEB + int flattenSubset; // how deeply the flattened object rooted at id has been dereferenced +#endif + TString name; // the name of the symbol this node represents + TConstUnionArray constArray; // if the symbol is a front-end compile-time constant, this is its value + TIntermTyped* constSubtree; +}; + +class TIntermConstantUnion : public TIntermTyped { +public: + TIntermConstantUnion(const TConstUnionArray& ua, const TType& t) : TIntermTyped(t), constArray(ua), literal(false) { } + const TConstUnionArray& getConstArray() const { return constArray; } + virtual TIntermConstantUnion* getAsConstantUnion() { return this; } + virtual const TIntermConstantUnion* getAsConstantUnion() const { return this; } + virtual void traverse(TIntermTraverser*); + virtual TIntermTyped* fold(TOperator, const TIntermTyped*) const; + virtual TIntermTyped* fold(TOperator, const TType&) const; + void setLiteral() { literal = true; } + void setExpression() { literal = false; } + bool isLiteral() const { return literal; } + +protected: + TIntermConstantUnion& operator=(const TIntermConstantUnion&); + + const TConstUnionArray constArray; + bool literal; // true if node represents a literal in the source code +}; + +// Represent the independent aspects of a texturing TOperator +struct TCrackedTextureOp { + bool query; + bool proj; + bool lod; + bool fetch; + bool offset; + bool offsets; + bool gather; + bool grad; + bool subpass; + bool lodClamp; + bool fragMask; +}; + +// +// Intermediate class for node types that hold operators. +// +class TIntermOperator : public TIntermTyped { +public: + virtual TIntermOperator* getAsOperator() { return this; } + virtual const TIntermOperator* getAsOperator() const { return this; } + TOperator getOp() const { return op; } + void setOp(TOperator newOp) { op = newOp; } + bool modifiesState() const; + bool isConstructor() const; + bool isTexture() const { return op > EOpTextureGuardBegin && op < EOpTextureGuardEnd; } + bool isSampling() const { return op > EOpSamplingGuardBegin && op < EOpSamplingGuardEnd; } +#ifdef GLSLANG_WEB + bool isImage() const { return false; } + bool isSparseTexture() const { return false; } + bool isImageFootprint() const { return false; } + bool isSparseImage() const { return false; } + bool isSubgroup() const { return false; } +#else + bool isImage() const { return op > EOpImageGuardBegin && op < EOpImageGuardEnd; } + bool isSparseTexture() const { return op > EOpSparseTextureGuardBegin && op < EOpSparseTextureGuardEnd; } + bool isImageFootprint() const { return op > EOpImageFootprintGuardBegin && op < EOpImageFootprintGuardEnd; } + bool isSparseImage() const { return op == EOpSparseImageLoad; } + bool isSubgroup() const { return op > EOpSubgroupGuardStart && op < EOpSubgroupGuardStop; } +#endif + + void setOperationPrecision(TPrecisionQualifier p) { operationPrecision = p; } + TPrecisionQualifier getOperationPrecision() const { return operationPrecision != EpqNone ? + operationPrecision : + type.getQualifier().precision; } + TString getCompleteString() const + { + TString cs = type.getCompleteString(); + if (getOperationPrecision() != type.getQualifier().precision) { + cs += ", operation at "; + cs += GetPrecisionQualifierString(getOperationPrecision()); + } + + return cs; + } + + // Crack the op into the individual dimensions of texturing operation. + void crackTexture(TSampler sampler, TCrackedTextureOp& cracked) const + { + cracked.query = false; + cracked.proj = false; + cracked.lod = false; + cracked.fetch = false; + cracked.offset = false; + cracked.offsets = false; + cracked.gather = false; + cracked.grad = false; + cracked.subpass = false; + cracked.lodClamp = false; + cracked.fragMask = false; + + switch (op) { + case EOpImageQuerySize: + case EOpImageQuerySamples: + case EOpTextureQuerySize: + case EOpTextureQueryLod: + case EOpTextureQueryLevels: + case EOpTextureQuerySamples: + case EOpSparseTexelsResident: + cracked.query = true; + break; + case EOpTexture: + case EOpSparseTexture: + break; + case EOpTextureProj: + cracked.proj = true; + break; + case EOpTextureLod: + case EOpSparseTextureLod: + cracked.lod = true; + break; + case EOpTextureOffset: + case EOpSparseTextureOffset: + cracked.offset = true; + break; + case EOpTextureFetch: + case EOpSparseTextureFetch: + cracked.fetch = true; + if (sampler.is1D() || (sampler.dim == Esd2D && ! sampler.isMultiSample()) || sampler.dim == Esd3D) + cracked.lod = true; + break; + case EOpTextureFetchOffset: + case EOpSparseTextureFetchOffset: + cracked.fetch = true; + cracked.offset = true; + if (sampler.is1D() || (sampler.dim == Esd2D && ! sampler.isMultiSample()) || sampler.dim == Esd3D) + cracked.lod = true; + break; + case EOpTextureProjOffset: + cracked.offset = true; + cracked.proj = true; + break; + case EOpTextureLodOffset: + case EOpSparseTextureLodOffset: + cracked.offset = true; + cracked.lod = true; + break; + case EOpTextureProjLod: + cracked.lod = true; + cracked.proj = true; + break; + case EOpTextureProjLodOffset: + cracked.offset = true; + cracked.lod = true; + cracked.proj = true; + break; + case EOpTextureGrad: + case EOpSparseTextureGrad: + cracked.grad = true; + break; + case EOpTextureGradOffset: + case EOpSparseTextureGradOffset: + cracked.grad = true; + cracked.offset = true; + break; + case EOpTextureProjGrad: + cracked.grad = true; + cracked.proj = true; + break; + case EOpTextureProjGradOffset: + cracked.grad = true; + cracked.offset = true; + cracked.proj = true; + break; +#ifndef GLSLANG_WEB + case EOpTextureClamp: + case EOpSparseTextureClamp: + cracked.lodClamp = true; + break; + case EOpTextureOffsetClamp: + case EOpSparseTextureOffsetClamp: + cracked.offset = true; + cracked.lodClamp = true; + break; + case EOpTextureGradClamp: + case EOpSparseTextureGradClamp: + cracked.grad = true; + cracked.lodClamp = true; + break; + case EOpTextureGradOffsetClamp: + case EOpSparseTextureGradOffsetClamp: + cracked.grad = true; + cracked.offset = true; + cracked.lodClamp = true; + break; + case EOpTextureGather: + case EOpSparseTextureGather: + cracked.gather = true; + break; + case EOpTextureGatherOffset: + case EOpSparseTextureGatherOffset: + cracked.gather = true; + cracked.offset = true; + break; + case EOpTextureGatherOffsets: + case EOpSparseTextureGatherOffsets: + cracked.gather = true; + cracked.offsets = true; + break; + case EOpTextureGatherLod: + case EOpSparseTextureGatherLod: + cracked.gather = true; + cracked.lod = true; + break; + case EOpTextureGatherLodOffset: + case EOpSparseTextureGatherLodOffset: + cracked.gather = true; + cracked.offset = true; + cracked.lod = true; + break; + case EOpTextureGatherLodOffsets: + case EOpSparseTextureGatherLodOffsets: + cracked.gather = true; + cracked.offsets = true; + cracked.lod = true; + break; + case EOpImageLoadLod: + case EOpImageStoreLod: + case EOpSparseImageLoadLod: + cracked.lod = true; + break; + case EOpFragmentMaskFetch: + cracked.subpass = sampler.dim == EsdSubpass; + cracked.fragMask = true; + break; + case EOpFragmentFetch: + cracked.subpass = sampler.dim == EsdSubpass; + cracked.fragMask = true; + break; + case EOpImageSampleFootprintNV: + break; + case EOpImageSampleFootprintClampNV: + cracked.lodClamp = true; + break; + case EOpImageSampleFootprintLodNV: + cracked.lod = true; + break; + case EOpImageSampleFootprintGradNV: + cracked.grad = true; + break; + case EOpImageSampleFootprintGradClampNV: + cracked.lodClamp = true; + cracked.grad = true; + break; + case EOpSubpassLoad: + case EOpSubpassLoadMS: + cracked.subpass = true; + break; +#endif + default: + break; + } + } + +protected: + TIntermOperator(TOperator o) : TIntermTyped(EbtFloat), op(o), operationPrecision(EpqNone) {} + TIntermOperator(TOperator o, TType& t) : TIntermTyped(t), op(o), operationPrecision(EpqNone) {} + TOperator op; + // The result precision is in the inherited TType, and is usually meant to be both + // the operation precision and the result precision. However, some more complex things, + // like built-in function calls, distinguish between the two, in which case non-EqpNone + // 'operationPrecision' overrides the result precision as far as operation precision + // is concerned. + TPrecisionQualifier operationPrecision; +}; + +// +// Nodes for all the basic binary math operators. +// +class TIntermBinary : public TIntermOperator { +public: + TIntermBinary(TOperator o) : TIntermOperator(o) {} + virtual void traverse(TIntermTraverser*); + virtual void setLeft(TIntermTyped* n) { left = n; } + virtual void setRight(TIntermTyped* n) { right = n; } + virtual TIntermTyped* getLeft() const { return left; } + virtual TIntermTyped* getRight() const { return right; } + virtual TIntermBinary* getAsBinaryNode() { return this; } + virtual const TIntermBinary* getAsBinaryNode() const { return this; } + virtual void updatePrecision(); +protected: + TIntermTyped* left; + TIntermTyped* right; +}; + +// +// Nodes for unary math operators. +// +class TIntermUnary : public TIntermOperator { +public: + TIntermUnary(TOperator o, TType& t) : TIntermOperator(o, t), operand(0) {} + TIntermUnary(TOperator o) : TIntermOperator(o), operand(0) {} + virtual void traverse(TIntermTraverser*); + virtual void setOperand(TIntermTyped* o) { operand = o; } + virtual TIntermTyped* getOperand() { return operand; } + virtual const TIntermTyped* getOperand() const { return operand; } + virtual TIntermUnary* getAsUnaryNode() { return this; } + virtual const TIntermUnary* getAsUnaryNode() const { return this; } + virtual void updatePrecision(); +protected: + TIntermTyped* operand; +}; + +typedef TVector TIntermSequence; +typedef TVector TQualifierList; +// +// Nodes that operate on an arbitrary sized set of children. +// +class TIntermAggregate : public TIntermOperator { +public: + TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(nullptr) { } + TIntermAggregate(TOperator o) : TIntermOperator(o), pragmaTable(nullptr) { } + ~TIntermAggregate() { delete pragmaTable; } + virtual TIntermAggregate* getAsAggregate() { return this; } + virtual const TIntermAggregate* getAsAggregate() const { return this; } + virtual void setOperator(TOperator o) { op = o; } + virtual TIntermSequence& getSequence() { return sequence; } + virtual const TIntermSequence& getSequence() const { return sequence; } + virtual void setName(const TString& n) { name = n; } + virtual const TString& getName() const { return name; } + virtual void traverse(TIntermTraverser*); + virtual void setUserDefined() { userDefined = true; } + virtual bool isUserDefined() { return userDefined; } + virtual TQualifierList& getQualifierList() { return qualifier; } + virtual const TQualifierList& getQualifierList() const { return qualifier; } + void setOptimize(bool o) { optimize = o; } + void setDebug(bool d) { debug = d; } + bool getOptimize() const { return optimize; } + bool getDebug() const { return debug; } + void setPragmaTable(const TPragmaTable& pTable); + const TPragmaTable& getPragmaTable() const { return *pragmaTable; } +protected: + TIntermAggregate(const TIntermAggregate&); // disallow copy constructor + TIntermAggregate& operator=(const TIntermAggregate&); // disallow assignment operator + TIntermSequence sequence; + TQualifierList qualifier; + TString name; + bool userDefined; // used for user defined function names + bool optimize; + bool debug; + TPragmaTable* pragmaTable; +}; + +// +// For if tests. +// +class TIntermSelection : public TIntermTyped { +public: + TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB) : + TIntermTyped(EbtVoid), condition(cond), trueBlock(trueB), falseBlock(falseB), + shortCircuit(true), + flatten(false), dontFlatten(false) {} + TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB, const TType& type) : + TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB), + shortCircuit(true), + flatten(false), dontFlatten(false) {} + virtual void traverse(TIntermTraverser*); + virtual TIntermTyped* getCondition() const { return condition; } + virtual TIntermNode* getTrueBlock() const { return trueBlock; } + virtual TIntermNode* getFalseBlock() const { return falseBlock; } + virtual TIntermSelection* getAsSelectionNode() { return this; } + virtual const TIntermSelection* getAsSelectionNode() const { return this; } + + void setNoShortCircuit() { shortCircuit = false; } + bool getShortCircuit() const { return shortCircuit; } + + void setFlatten() { flatten = true; } + void setDontFlatten() { dontFlatten = true; } + bool getFlatten() const { return flatten; } + bool getDontFlatten() const { return dontFlatten; } + +protected: + TIntermTyped* condition; + TIntermNode* trueBlock; + TIntermNode* falseBlock; + bool shortCircuit; // normally all if-then-else and all GLSL ?: short-circuit, but HLSL ?: does not + bool flatten; // true if flatten requested + bool dontFlatten; // true if requested to not flatten +}; + +// +// For switch statements. Designed use is that a switch will have sequence of nodes +// that are either case/default nodes or a *single* node that represents all the code +// in between (if any) consecutive case/defaults. So, a traversal need only deal with +// 0 or 1 nodes per case/default statement. +// +class TIntermSwitch : public TIntermNode { +public: + TIntermSwitch(TIntermTyped* cond, TIntermAggregate* b) : condition(cond), body(b), + flatten(false), dontFlatten(false) {} + virtual void traverse(TIntermTraverser*); + virtual TIntermNode* getCondition() const { return condition; } + virtual TIntermAggregate* getBody() const { return body; } + virtual TIntermSwitch* getAsSwitchNode() { return this; } + virtual const TIntermSwitch* getAsSwitchNode() const { return this; } + + void setFlatten() { flatten = true; } + void setDontFlatten() { dontFlatten = true; } + bool getFlatten() const { return flatten; } + bool getDontFlatten() const { return dontFlatten; } + +protected: + TIntermTyped* condition; + TIntermAggregate* body; + bool flatten; // true if flatten requested + bool dontFlatten; // true if requested to not flatten +}; + +enum TVisit +{ + EvPreVisit, + EvInVisit, + EvPostVisit +}; + +// +// For traversing the tree. User should derive from this, +// put their traversal specific data in it, and then pass +// it to a Traverse method. +// +// When using this, just fill in the methods for nodes you want visited. +// Return false from a pre-visit to skip visiting that node's subtree. +// +// Explicitly set postVisit to true if you want post visiting, otherwise, +// filled in methods will only be called at pre-visit time (before processing +// the subtree). Similarly for inVisit for in-order visiting of nodes with +// multiple children. +// +// If you only want post-visits, explicitly turn off preVisit (and inVisit) +// and turn on postVisit. +// +// In general, for the visit*() methods, return true from interior nodes +// to have the traversal continue on to children. +// +// If you process children yourself, or don't want them processed, return false. +// +class TIntermTraverser { +public: + POOL_ALLOCATOR_NEW_DELETE(glslang::GetThreadPoolAllocator()) + TIntermTraverser(bool preVisit = true, bool inVisit = false, bool postVisit = false, bool rightToLeft = false) : + preVisit(preVisit), + inVisit(inVisit), + postVisit(postVisit), + rightToLeft(rightToLeft), + depth(0), + maxDepth(0) { } + virtual ~TIntermTraverser() { } + + virtual void visitSymbol(TIntermSymbol*) { } + virtual void visitConstantUnion(TIntermConstantUnion*) { } + virtual bool visitBinary(TVisit, TIntermBinary*) { return true; } + virtual bool visitUnary(TVisit, TIntermUnary*) { return true; } + virtual bool visitSelection(TVisit, TIntermSelection*) { return true; } + virtual bool visitAggregate(TVisit, TIntermAggregate*) { return true; } + virtual bool visitLoop(TVisit, TIntermLoop*) { return true; } + virtual bool visitBranch(TVisit, TIntermBranch*) { return true; } + virtual bool visitSwitch(TVisit, TIntermSwitch*) { return true; } + + int getMaxDepth() const { return maxDepth; } + + void incrementDepth(TIntermNode *current) + { + depth++; + maxDepth = (std::max)(maxDepth, depth); + path.push_back(current); + } + + void decrementDepth() + { + depth--; + path.pop_back(); + } + + TIntermNode *getParentNode() + { + return path.size() == 0 ? NULL : path.back(); + } + + const bool preVisit; + const bool inVisit; + const bool postVisit; + const bool rightToLeft; + +protected: + TIntermTraverser& operator=(TIntermTraverser&); + + int depth; + int maxDepth; + + // All the nodes from root to the current node's parent during traversing. + TVector path; +}; + +// KHR_vulkan_glsl says "Two arrays sized with specialization constants are the same type only if +// sized with the same symbol, involving no operations" +inline bool SameSpecializationConstants(TIntermTyped* node1, TIntermTyped* node2) +{ + return node1->getAsSymbolNode() && node2->getAsSymbolNode() && + node1->getAsSymbolNode()->getId() == node2->getAsSymbolNode()->getId(); +} + +} // end namespace glslang + +#endif // __INTERMEDIATE_H diff --git a/ios/include/glslang/Include/revision.h b/ios/include/glslang/Include/revision.h new file mode 100644 index 00000000..94c2dd5f --- /dev/null +++ b/ios/include/glslang/Include/revision.h @@ -0,0 +1,3 @@ +// This header is generated by the make-revision script. + +#define GLSLANG_PATCH_LEVEL 3795 diff --git a/ios/include/glslang/MachineIndependent/Initialize.h b/ios/include/glslang/MachineIndependent/Initialize.h new file mode 100644 index 00000000..ac8ec33e --- /dev/null +++ b/ios/include/glslang/MachineIndependent/Initialize.h @@ -0,0 +1,112 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2013-2016 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _INITIALIZE_INCLUDED_ +#define _INITIALIZE_INCLUDED_ + +#include "../Include/ResourceLimits.h" +#include "../Include/Common.h" +#include "../Include/ShHandle.h" +#include "SymbolTable.h" +#include "Versions.h" + +namespace glslang { + +// +// This is made to hold parseable strings for almost all the built-in +// functions and variables for one specific combination of version +// and profile. (Some still need to be added programmatically.) +// This is a base class for language-specific derivations, which +// can be used for language independent builtins. +// +// The strings are organized by +// commonBuiltins: intersection of all stages' built-ins, processed just once +// stageBuiltins[]: anything a stage needs that's not in commonBuiltins +// +class TBuiltInParseables { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + TBuiltInParseables(); + virtual ~TBuiltInParseables(); + virtual void initialize(int version, EProfile, const SpvVersion& spvVersion) = 0; + virtual void initialize(const TBuiltInResource& resources, int version, EProfile, const SpvVersion& spvVersion, EShLanguage) = 0; + virtual const TString& getCommonString() const { return commonBuiltins; } + virtual const TString& getStageString(EShLanguage language) const { return stageBuiltins[language]; } + + virtual void identifyBuiltIns(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language, TSymbolTable& symbolTable) = 0; + virtual void identifyBuiltIns(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language, TSymbolTable& symbolTable, const TBuiltInResource &resources) = 0; + +protected: + TString commonBuiltins; + TString stageBuiltins[EShLangCount]; +}; + +// +// This is a GLSL specific derivation of TBuiltInParseables. To present a stable +// interface and match other similar code, it is called TBuiltIns, rather +// than TBuiltInParseablesGlsl. +// +class TBuiltIns : public TBuiltInParseables { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + TBuiltIns(); + virtual ~TBuiltIns(); + void initialize(int version, EProfile, const SpvVersion& spvVersion); + void initialize(const TBuiltInResource& resources, int version, EProfile, const SpvVersion& spvVersion, EShLanguage); + + void identifyBuiltIns(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language, TSymbolTable& symbolTable); + void identifyBuiltIns(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language, TSymbolTable& symbolTable, const TBuiltInResource &resources); + +protected: + void addTabledBuiltins(int version, EProfile profile, const SpvVersion& spvVersion); + void relateTabledBuiltins(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage, TSymbolTable&); + void add2ndGenerationSamplingImaging(int version, EProfile profile, const SpvVersion& spvVersion); + void addSubpassSampling(TSampler, const TString& typeName, int version, EProfile profile); + void addQueryFunctions(TSampler, const TString& typeName, int version, EProfile profile); + void addImageFunctions(TSampler, const TString& typeName, int version, EProfile profile); + void addSamplingFunctions(TSampler, const TString& typeName, int version, EProfile profile); + void addGatherFunctions(TSampler, const TString& typeName, int version, EProfile profile); + + // Helpers for making textual representations of the permutations + // of texturing/imaging functions. + const char* postfixes[5]; + const char* prefixes[EbtNumTypes]; + int dimMap[EsdNumDims]; +}; + +} // end namespace glslang + +#endif // _INITIALIZE_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/LiveTraverser.h b/ios/include/glslang/MachineIndependent/LiveTraverser.h new file mode 100644 index 00000000..7333bc96 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/LiveTraverser.h @@ -0,0 +1,138 @@ +// +// Copyright (C) 2016 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#pragma once + +#include "../Include/Common.h" +#include "reflection.h" +#include "localintermediate.h" + +#include "gl_types.h" + +#include +#include + +namespace glslang { + +// +// The traverser: mostly pass through, except +// - processing function-call nodes to push live functions onto the stack of functions to process +// - processing selection nodes to trim semantically dead code +// +// This is in the glslang namespace directly so it can be a friend of TReflection. +// This can be derived from to implement reflection database traversers or +// binding mappers: anything that wants to traverse the live subset of the tree. +// + +class TLiveTraverser : public TIntermTraverser { +public: + TLiveTraverser(const TIntermediate& i, bool traverseAll = false, + bool preVisit = true, bool inVisit = false, bool postVisit = false) : + TIntermTraverser(preVisit, inVisit, postVisit), + intermediate(i), traverseAll(traverseAll) + { } + + // + // Given a function name, find its subroot in the tree, and push it onto the stack of + // functions left to process. + // + void pushFunction(const TString& name) + { + TIntermSequence& globals = intermediate.getTreeRoot()->getAsAggregate()->getSequence(); + for (unsigned int f = 0; f < globals.size(); ++f) { + TIntermAggregate* candidate = globals[f]->getAsAggregate(); + if (candidate && candidate->getOp() == EOpFunction && candidate->getName() == name) { + functions.push_back(candidate); + break; + } + } + } + + typedef std::list TFunctionStack; + TFunctionStack functions; + +protected: + // To catch which function calls are not dead, and hence which functions must be visited. + virtual bool visitAggregate(TVisit, TIntermAggregate* node) + { + if (!traverseAll) + if (node->getOp() == EOpFunctionCall) + addFunctionCall(node); + + return true; // traverse this subtree + } + + // To prune semantically dead paths. + virtual bool visitSelection(TVisit /* visit */, TIntermSelection* node) + { + if (traverseAll) + return true; // traverse all code + + TIntermConstantUnion* constant = node->getCondition()->getAsConstantUnion(); + if (constant) { + // cull the path that is dead + if (constant->getConstArray()[0].getBConst() == true && node->getTrueBlock()) + node->getTrueBlock()->traverse(this); + if (constant->getConstArray()[0].getBConst() == false && node->getFalseBlock()) + node->getFalseBlock()->traverse(this); + + return false; // don't traverse any more, we did it all above + } else + return true; // traverse the whole subtree + } + + // Track live functions as well as uniforms, so that we don't visit dead functions + // and only visit each function once. + void addFunctionCall(TIntermAggregate* call) + { + // // just use the map to ensure we process each function at most once + if (liveFunctions.find(call->getName()) == liveFunctions.end()) { + liveFunctions.insert(call->getName()); + pushFunction(call->getName()); + } + } + + const TIntermediate& intermediate; + typedef std::unordered_set TLiveFunctions; + TLiveFunctions liveFunctions; + bool traverseAll; + +private: + // prevent copy & copy construct + TLiveTraverser(TLiveTraverser&); + TLiveTraverser& operator=(TLiveTraverser&); +}; + +} // namespace glslang diff --git a/ios/include/glslang/MachineIndependent/ParseHelper.h b/ios/include/glslang/MachineIndependent/ParseHelper.h new file mode 100644 index 00000000..8b262c94 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/ParseHelper.h @@ -0,0 +1,532 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2013 LunarG, Inc. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +// +// This header defines a two-level parse-helper hierarchy, derived from +// TParseVersions: +// - TParseContextBase: sharable across multiple parsers +// - TParseContext: GLSL specific helper +// + +#ifndef _PARSER_HELPER_INCLUDED_ +#define _PARSER_HELPER_INCLUDED_ + +#include +#include + +#include "parseVersions.h" +#include "../Include/ShHandle.h" +#include "SymbolTable.h" +#include "localintermediate.h" +#include "Scan.h" +#include "attribute.h" + +namespace glslang { + +struct TPragma { + TPragma(bool o, bool d) : optimize(o), debug(d) { } + bool optimize; + bool debug; + TPragmaTable pragmaTable; +}; + +class TScanContext; +class TPpContext; + +typedef std::set TIdSetType; +typedef std::map> TStructRecord; + +// +// Sharable code (as well as what's in TParseVersions) across +// parse helpers. +// +class TParseContextBase : public TParseVersions { +public: + TParseContextBase(TSymbolTable& symbolTable, TIntermediate& interm, bool parsingBuiltins, int version, + EProfile profile, const SpvVersion& spvVersion, EShLanguage language, + TInfoSink& infoSink, bool forwardCompatible, EShMessages messages, + const TString* entryPoint = nullptr) + : TParseVersions(interm, version, profile, spvVersion, language, infoSink, forwardCompatible, messages), + scopeMangler("::"), + symbolTable(symbolTable), + statementNestingLevel(0), loopNestingLevel(0), structNestingLevel(0), controlFlowNestingLevel(0), + postEntryPointReturn(false), + contextPragma(true, false), + beginInvocationInterlockCount(0), endInvocationInterlockCount(0), + parsingBuiltins(parsingBuiltins), scanContext(nullptr), ppContext(nullptr), + limits(resources.limits), + globalUniformBlock(nullptr), + globalUniformBinding(TQualifier::layoutBindingEnd), + globalUniformSet(TQualifier::layoutSetEnd) + { + if (entryPoint != nullptr) + sourceEntryPointName = *entryPoint; + } + virtual ~TParseContextBase() { } + +#if !defined(GLSLANG_WEB) || defined(GLSLANG_WEB_DEVEL) + virtual void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...); + virtual void C_DECL warn(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...); + virtual void C_DECL ppError(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...); + virtual void C_DECL ppWarn(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...); +#endif + + virtual void setLimits(const TBuiltInResource&) = 0; + + void checkIndex(const TSourceLoc&, const TType&, int& index); + + EShLanguage getLanguage() const { return language; } + void setScanContext(TScanContext* c) { scanContext = c; } + TScanContext* getScanContext() const { return scanContext; } + void setPpContext(TPpContext* c) { ppContext = c; } + TPpContext* getPpContext() const { return ppContext; } + + virtual void setLineCallback(const std::function& func) { lineCallback = func; } + virtual void setExtensionCallback(const std::function& func) { extensionCallback = func; } + virtual void setVersionCallback(const std::function& func) { versionCallback = func; } + virtual void setPragmaCallback(const std::function&)>& func) { pragmaCallback = func; } + virtual void setErrorCallback(const std::function& func) { errorCallback = func; } + + virtual void reservedPpErrorCheck(const TSourceLoc&, const char* name, const char* op) = 0; + virtual bool lineContinuationCheck(const TSourceLoc&, bool endOfComment) = 0; + virtual bool lineDirectiveShouldSetNextLine() const = 0; + virtual void handlePragma(const TSourceLoc&, const TVector&) = 0; + + virtual bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) = 0; + + virtual void notifyVersion(int line, int version, const char* type_string) + { + if (versionCallback) + versionCallback(line, version, type_string); + } + virtual void notifyErrorDirective(int line, const char* error_message) + { + if (errorCallback) + errorCallback(line, error_message); + } + virtual void notifyLineDirective(int curLineNo, int newLineNo, bool hasSource, int sourceNum, const char* sourceName) + { + if (lineCallback) + lineCallback(curLineNo, newLineNo, hasSource, sourceNum, sourceName); + } + virtual void notifyExtensionDirective(int line, const char* extension, const char* behavior) + { + if (extensionCallback) + extensionCallback(line, extension, behavior); + } + +#ifdef ENABLE_HLSL + // Manage the global uniform block (default uniforms in GLSL, $Global in HLSL) + virtual void growGlobalUniformBlock(const TSourceLoc&, TType&, const TString& memberName, TTypeList* typeList = nullptr); +#endif + + // Potentially rename shader entry point function + void renameShaderFunction(TString*& name) const + { + // Replace the entry point name given in the shader with the real entry point name, + // if there is a substitution. + if (name != nullptr && *name == sourceEntryPointName && intermediate.getEntryPointName().size() > 0) + name = NewPoolTString(intermediate.getEntryPointName().c_str()); + } + + virtual bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*); + virtual void rValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*); + + const char* const scopeMangler; + + // Basic parsing state, easily accessible to the grammar + + TSymbolTable& symbolTable; // symbol table that goes with the current language, version, and profile + int statementNestingLevel; // 0 if outside all flow control or compound statements + int loopNestingLevel; // 0 if outside all loops + int structNestingLevel; // 0 if outside blocks and structures + int controlFlowNestingLevel; // 0 if outside all flow control + const TType* currentFunctionType; // the return type of the function that's currently being parsed + bool functionReturnsValue; // true if a non-void function has a return + // if inside a function, true if the function is the entry point and this is after a return statement + bool postEntryPointReturn; + // case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting + TList switchSequenceStack; + // the statementNestingLevel the current switch statement is at, which must match the level of its case statements + TList switchLevel; + struct TPragma contextPragma; + int beginInvocationInterlockCount; + int endInvocationInterlockCount; + +protected: + TParseContextBase(TParseContextBase&); + TParseContextBase& operator=(TParseContextBase&); + + const bool parsingBuiltins; // true if parsing built-in symbols/functions + TVector linkageSymbols; // will be transferred to 'linkage', after all editing is done, order preserving + TScanContext* scanContext; + TPpContext* ppContext; + TBuiltInResource resources; + TLimits& limits; + TString sourceEntryPointName; + + // These, if set, will be called when a line, pragma ... is preprocessed. + // They will be called with any parameters to the original directive. + std::function lineCallback; + std::function&)> pragmaCallback; + std::function versionCallback; + std::function extensionCallback; + std::function errorCallback; + + // see implementation for detail + const TFunction* selectFunction(const TVector, const TFunction&, + std::function, + std::function, + /* output */ bool& tie); + + virtual void parseSwizzleSelector(const TSourceLoc&, const TString&, int size, + TSwizzleSelectors&); + + // Manage the global uniform block (default uniforms in GLSL, $Global in HLSL) + TVariable* globalUniformBlock; // the actual block, inserted into the symbol table + unsigned int globalUniformBinding; // the block's binding number + unsigned int globalUniformSet; // the block's set number + int firstNewMember; // the index of the first member not yet inserted into the symbol table + // override this to set the language-specific name + virtual const char* getGlobalUniformBlockName() const { return ""; } + virtual void setUniformBlockDefaults(TType&) const { } + virtual void finalizeGlobalUniformBlockLayout(TVariable&) { } + virtual void outputMessage(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, TPrefixType prefix, + va_list args); + virtual void trackLinkage(TSymbol& symbol); + virtual void makeEditable(TSymbol*&); + virtual TVariable* getEditableVariable(const char* name); + virtual void finish(); +}; + +// +// Manage the state for when to respect precision qualifiers and when to warn about +// the defaults being different than might be expected. +// +class TPrecisionManager { +public: + TPrecisionManager() : obey(false), warn(false), explicitIntDefault(false), explicitFloatDefault(false){ } + virtual ~TPrecisionManager() {} + + void respectPrecisionQualifiers() { obey = true; } + bool respectingPrecisionQualifiers() const { return obey; } + bool shouldWarnAboutDefaults() const { return warn; } + void defaultWarningGiven() { warn = false; } + void warnAboutDefaults() { warn = true; } + void explicitIntDefaultSeen() + { + explicitIntDefault = true; + if (explicitFloatDefault) + warn = false; + } + void explicitFloatDefaultSeen() + { + explicitFloatDefault = true; + if (explicitIntDefault) + warn = false; + } + +protected: + bool obey; // respect precision qualifiers + bool warn; // need to give a warning about the defaults + bool explicitIntDefault; // user set the default for int/uint + bool explicitFloatDefault; // user set the default for float +}; + +// +// GLSL-specific parse helper. Should have GLSL in the name, but that's +// too big of a change for comparing branches at the moment, and perhaps +// impacts downstream consumers as well. +// +class TParseContext : public TParseContextBase { +public: + TParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins, int version, EProfile, const SpvVersion& spvVersion, EShLanguage, TInfoSink&, + bool forwardCompatible = false, EShMessages messages = EShMsgDefault, + const TString* entryPoint = nullptr); + virtual ~TParseContext(); + + bool obeyPrecisionQualifiers() const { return precisionManager.respectingPrecisionQualifiers(); } + void setPrecisionDefaults(); + + void setLimits(const TBuiltInResource&) override; + bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) override; + void parserError(const char* s); // for bison's yyerror + + void reservedErrorCheck(const TSourceLoc&, const TString&); + void reservedPpErrorCheck(const TSourceLoc&, const char* name, const char* op) override; + bool lineContinuationCheck(const TSourceLoc&, bool endOfComment) override; + bool lineDirectiveShouldSetNextLine() const override; + bool builtInName(const TString&); + + void handlePragma(const TSourceLoc&, const TVector&) override; + TIntermTyped* handleVariable(const TSourceLoc&, TSymbol* symbol, const TString* string); + TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index); + void handleIndexLimits(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index); + +#ifndef GLSLANG_WEB + void makeEditable(TSymbol*&) override; + void ioArrayCheck(const TSourceLoc&, const TType&, const TString& identifier); +#endif + bool isIoResizeArray(const TType&) const; + void fixIoArraySize(const TSourceLoc&, TType&); + void handleIoResizeArrayAccess(const TSourceLoc&, TIntermTyped* base); + void checkIoArraysConsistency(const TSourceLoc&, bool tailOnly = false); + int getIoArrayImplicitSize(const TQualifier&, TString* featureString = nullptr) const; + void checkIoArrayConsistency(const TSourceLoc&, int requiredSize, const char* feature, TType&, const TString&); + + TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right); + TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode); + TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field); + TIntermTyped* handleDotSwizzle(const TSourceLoc&, TIntermTyped* base, const TString& field); + void blockMemberExtensionCheck(const TSourceLoc&, const TIntermTyped* base, int member, const TString& memberName); + TFunction* handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype); + TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&); + TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermNode*); + TIntermTyped* handleBuiltInFunctionCall(TSourceLoc, TIntermNode* arguments, const TFunction& function); + void computeBuiltinPrecisions(TIntermTyped&, const TFunction&); + TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*); + void checkLocation(const TSourceLoc&, TOperator); + TIntermTyped* handleLengthMethod(const TSourceLoc&, TFunction*, TIntermNode*); + void addInputArgumentConversions(const TFunction&, TIntermNode*&) const; + TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermAggregate&) const; + void builtInOpCheck(const TSourceLoc&, const TFunction&, TIntermOperator&); + void nonOpBuiltInCheck(const TSourceLoc&, const TFunction&, TIntermAggregate&); + void userFunctionCallCheck(const TSourceLoc&, TIntermAggregate&); + void samplerConstructorLocationCheck(const TSourceLoc&, const char* token, TIntermNode*); + TFunction* handleConstructorCall(const TSourceLoc&, const TPublicType&); + void handlePrecisionQualifier(const TSourceLoc&, TQualifier&, TPrecisionQualifier); + void checkPrecisionQualifier(const TSourceLoc&, TPrecisionQualifier); + void memorySemanticsCheck(const TSourceLoc&, const TFunction&, const TIntermOperator& callNode); + + void assignError(const TSourceLoc&, const char* op, TString left, TString right); + void unaryOpError(const TSourceLoc&, const char* op, TString operand); + void binaryOpError(const TSourceLoc&, const char* op, TString left, TString right); + void variableCheck(TIntermTyped*& nodePtr); + bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override; + void rValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override; + void constantValueCheck(TIntermTyped* node, const char* token); + void integerCheck(const TIntermTyped* node, const char* token); + void globalCheck(const TSourceLoc&, const char* token); + bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&); + bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&); + void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType); + bool arrayQualifierError(const TSourceLoc&, const TQualifier&); + bool arrayError(const TSourceLoc&, const TType&); + void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&); + void structArrayCheck(const TSourceLoc&, const TType& structure); + void arraySizesCheck(const TSourceLoc&, const TQualifier&, TArraySizes*, const TIntermTyped* initializer, bool lastMember); + void arrayOfArrayVersionCheck(const TSourceLoc&, const TArraySizes*); + bool voidErrorCheck(const TSourceLoc&, const TString&, TBasicType); + void boolCheck(const TSourceLoc&, const TIntermTyped*); + void boolCheck(const TSourceLoc&, const TPublicType&); + void samplerCheck(const TSourceLoc&, const TType&, const TString& identifier, TIntermTyped* initializer); + void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier); + void accStructCheck(const TSourceLoc & loc, const TType & type, const TString & identifier); + void transparentOpaqueCheck(const TSourceLoc&, const TType&, const TString& identifier); + void memberQualifierCheck(glslang::TPublicType&); + void globalQualifierFixCheck(const TSourceLoc&, TQualifier&); + void globalQualifierTypeCheck(const TSourceLoc&, const TQualifier&, const TPublicType&); + bool structQualifierErrorCheck(const TSourceLoc&, const TPublicType& pType); + void mergeQualifiers(const TSourceLoc&, TQualifier& dst, const TQualifier& src, bool force); + void setDefaultPrecision(const TSourceLoc&, TPublicType&, TPrecisionQualifier); + int computeSamplerTypeIndex(TSampler&); + TPrecisionQualifier getDefaultPrecision(TPublicType&); + void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&); + void parameterTypeCheck(const TSourceLoc&, TStorageQualifier qualifier, const TType& type); + bool containsFieldWithBasicType(const TType& type ,TBasicType basicType); + TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&); + void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes); + void paramCheckFixStorage(const TSourceLoc&, const TStorageQualifier&, TType& type); + void paramCheckFix(const TSourceLoc&, const TQualifier&, TType& type); + void nestedBlockCheck(const TSourceLoc&); + void nestedStructCheck(const TSourceLoc&); + void arrayObjectCheck(const TSourceLoc&, const TType&, const char* op); + void opaqueCheck(const TSourceLoc&, const TType&, const char* op); + void referenceCheck(const TSourceLoc&, const TType&, const char* op); + void storage16BitAssignmentCheck(const TSourceLoc&, const TType&, const char* op); + void specializationCheck(const TSourceLoc&, const TType&, const char* op); + void structTypeCheck(const TSourceLoc&, TPublicType&); + void inductiveLoopCheck(const TSourceLoc&, TIntermNode* init, TIntermLoop* loop); + void arrayLimitCheck(const TSourceLoc&, const TString&, int size); + void limitCheck(const TSourceLoc&, int value, const char* limit, const char* feature); + + void inductiveLoopBodyCheck(TIntermNode*, int loopIndexId, TSymbolTable&); + void constantIndexExpressionCheck(TIntermNode*); + + void setLayoutQualifier(const TSourceLoc&, TPublicType&, TString&); + void setLayoutQualifier(const TSourceLoc&, TPublicType&, TString&, const TIntermTyped*); + void mergeObjectLayoutQualifiers(TQualifier& dest, const TQualifier& src, bool inheritOnly); + void layoutObjectCheck(const TSourceLoc&, const TSymbol&); + void layoutMemberLocationArrayCheck(const TSourceLoc&, bool memberWithLocation, TArraySizes* arraySizes); + void layoutTypeCheck(const TSourceLoc&, const TType&); + void layoutQualifierCheck(const TSourceLoc&, const TQualifier&); + void checkNoShaderLayouts(const TSourceLoc&, const TShaderQualifiers&); + void fixOffset(const TSourceLoc&, TSymbol&); + + const TFunction* findFunction(const TSourceLoc& loc, const TFunction& call, bool& builtIn); + const TFunction* findFunctionExact(const TSourceLoc& loc, const TFunction& call, bool& builtIn); + const TFunction* findFunction120(const TSourceLoc& loc, const TFunction& call, bool& builtIn); + const TFunction* findFunction400(const TSourceLoc& loc, const TFunction& call, bool& builtIn); + const TFunction* findFunctionExplicitTypes(const TSourceLoc& loc, const TFunction& call, bool& builtIn); + void declareTypeDefaults(const TSourceLoc&, const TPublicType&); + TIntermNode* declareVariable(const TSourceLoc&, TString& identifier, const TPublicType&, TArraySizes* typeArray = 0, TIntermTyped* initializer = 0); + TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, const TType&); + TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&); + TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset); + void inheritMemoryQualifiers(const TQualifier& from, TQualifier& to); + void declareBlock(const TSourceLoc&, TTypeList& typeList, const TString* instanceName = 0, TArraySizes* arraySizes = 0); + void blockStageIoCheck(const TSourceLoc&, const TQualifier&); + void blockQualifierCheck(const TSourceLoc&, const TQualifier&, bool instanceName); + void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation); + void fixXfbOffsets(TQualifier&, TTypeList&); + void fixBlockUniformOffsets(TQualifier&, TTypeList&); + void fixBlockUniformLayoutMatrix(TQualifier&, TTypeList*, TTypeList*); + void fixBlockUniformLayoutPacking(TQualifier&, TTypeList*, TTypeList*); + void addQualifierToExisting(const TSourceLoc&, TQualifier, const TString& identifier); + void addQualifierToExisting(const TSourceLoc&, TQualifier, TIdentifierList&); + void invariantCheck(const TSourceLoc&, const TQualifier&); + void updateStandaloneQualifierDefaults(const TSourceLoc&, const TPublicType&); + void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode); + TIntermNode* addSwitch(const TSourceLoc&, TIntermTyped* expression, TIntermAggregate* body); + const TTypeList* recordStructCopy(TStructRecord&, const TType*, const TType*); + +#ifndef GLSLANG_WEB + TAttributeType attributeFromName(const TString& name) const; + TAttributes* makeAttributes(const TString& identifier) const; + TAttributes* makeAttributes(const TString& identifier, TIntermNode* node) const; + TAttributes* mergeAttributes(TAttributes*, TAttributes*) const; + + // Determine selection control from attributes + void handleSelectionAttributes(const TAttributes& attributes, TIntermNode*); + void handleSwitchAttributes(const TAttributes& attributes, TIntermNode*); + // Determine loop control from attributes + void handleLoopAttributes(const TAttributes& attributes, TIntermNode*); +#endif + + void checkAndResizeMeshViewDim(const TSourceLoc&, TType&, bool isBlockMember); + +protected: + void nonInitConstCheck(const TSourceLoc&, TString& identifier, TType& type); + void inheritGlobalDefaults(TQualifier& dst) const; + TVariable* makeInternalVariable(const char* name, const TType&) const; + TVariable* declareNonArray(const TSourceLoc&, const TString& identifier, const TType&); + void declareArray(const TSourceLoc&, const TString& identifier, const TType&, TSymbol*&); + void checkRuntimeSizable(const TSourceLoc&, const TIntermTyped&); + bool isRuntimeLength(const TIntermTyped&) const; + TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable); + TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer); +#ifndef GLSLANG_WEB + void finish() override; +#endif + +public: + // + // Generally, bison productions, the scanner, and the PP need read/write access to these; just give them direct access + // + + // Current state of parsing + bool inMain; // if inside a function, true if the function is main + const TString* blockName; + TQualifier currentBlockQualifier; + TPrecisionQualifier defaultPrecision[EbtNumTypes]; + TBuiltInResource resources; + TLimits& limits; + +protected: + TParseContext(TParseContext&); + TParseContext& operator=(TParseContext&); + + static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2 * 2 * 2)); // see computeSamplerTypeIndex() + TPrecisionQualifier defaultSamplerPrecision[maxSamplerIndex]; + TPrecisionManager precisionManager; + TQualifier globalBufferDefaults; + TQualifier globalUniformDefaults; + TQualifier globalInputDefaults; + TQualifier globalOutputDefaults; + TString currentCaller; // name of last function body entered (not valid when at global scope) +#ifndef GLSLANG_WEB + int* atomicUintOffsets; // to become an array of the right size to hold an offset per binding point + bool anyIndexLimits; + TIdSetType inductiveLoopIds; + TVector needsIndexLimitationChecking; + TStructRecord matrixFixRecord; + TStructRecord packingFixRecord; + + // + // Geometry shader input arrays: + // - array sizing is based on input primitive and/or explicit size + // + // Tessellation control output arrays: + // - array sizing is based on output layout(vertices=...) and/or explicit size + // + // Both: + // - array sizing is retroactive + // - built-in block redeclarations interact with this + // + // Design: + // - use a per-context "resize-list", a list of symbols whose array sizes + // can be fixed + // + // - the resize-list starts empty at beginning of user-shader compilation, it does + // not have built-ins in it + // + // - on built-in array use: copyUp() symbol and add it to the resize-list + // + // - on user array declaration: add it to the resize-list + // + // - on block redeclaration: copyUp() symbol and add it to the resize-list + // * note, that appropriately gives an error if redeclaring a block that + // was already used and hence already copied-up + // + // - on seeing a layout declaration that sizes the array, fix everything in the + // resize-list, giving errors for mismatch + // + // - on seeing an array size declaration, give errors on mismatch between it and previous + // array-sizing declarations + // + TVector ioArraySymbolResizeList; +#endif +}; + +} // end namespace glslang + +#endif // _PARSER_HELPER_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/RemoveTree.h b/ios/include/glslang/MachineIndependent/RemoveTree.h new file mode 100644 index 00000000..1ed01562 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/RemoveTree.h @@ -0,0 +1,41 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#pragma once + +namespace glslang { + +void RemoveAllTreeNodes(TIntermNode*); + +} // end namespace glslang diff --git a/ios/include/glslang/MachineIndependent/Scan.h b/ios/include/glslang/MachineIndependent/Scan.h new file mode 100644 index 00000000..24b75cf7 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/Scan.h @@ -0,0 +1,276 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2013 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +#ifndef _GLSLANG_SCAN_INCLUDED_ +#define _GLSLANG_SCAN_INCLUDED_ + +#include "Versions.h" + +namespace glslang { + +// Use a global end-of-input character, so no translation is needed across +// layers of encapsulation. Characters are all 8 bit, and positive, so there is +// no aliasing of character 255 onto -1, for example. +const int EndOfInput = -1; + +// +// A character scanner that seamlessly, on read-only strings, reads across an +// array of strings without assuming null termination. +// +class TInputScanner { +public: + TInputScanner(int n, const char* const s[], size_t L[], const char* const* names = nullptr, + int b = 0, int f = 0, bool single = false) : + numSources(n), + // up to this point, common usage is "char*", but now we need positive 8-bit characters + sources(reinterpret_cast(s)), + lengths(L), currentSource(0), currentChar(0), stringBias(b), finale(f), singleLogical(single), + endOfFileReached(false) + { + loc = new TSourceLoc[numSources]; + for (int i = 0; i < numSources; ++i) { + loc[i].init(i - stringBias); + } + if (names != nullptr) { + for (int i = 0; i < numSources; ++i) + loc[i].name = names[i] != nullptr ? NewPoolTString(names[i]) : nullptr; + } + loc[currentSource].line = 1; + logicalSourceLoc.init(1); + logicalSourceLoc.name = loc[0].name; + } + + virtual ~TInputScanner() + { + delete [] loc; + } + + // retrieve the next character and advance one character + int get() + { + int ret = peek(); + if (ret == EndOfInput) + return ret; + ++loc[currentSource].column; + ++logicalSourceLoc.column; + if (ret == '\n') { + ++loc[currentSource].line; + ++logicalSourceLoc.line; + logicalSourceLoc.column = 0; + loc[currentSource].column = 0; + } + advance(); + + return ret; + } + + // retrieve the next character, no advance + int peek() + { + if (currentSource >= numSources) { + endOfFileReached = true; + return EndOfInput; + } + // Make sure we do not read off the end of a string. + // N.B. Sources can have a length of 0. + int sourceToRead = currentSource; + size_t charToRead = currentChar; + while(charToRead >= lengths[sourceToRead]) { + charToRead = 0; + sourceToRead += 1; + if (sourceToRead >= numSources) { + return EndOfInput; + } + } + + // Here, we care about making negative valued characters positive + return sources[sourceToRead][charToRead]; + } + + // go back one character + void unget() + { + // Do not roll back once we've reached the end of the file. + if (endOfFileReached) + return; + + if (currentChar > 0) { + --currentChar; + --loc[currentSource].column; + --logicalSourceLoc.column; + if (loc[currentSource].column < 0) { + // We've moved back past a new line. Find the + // previous newline (or start of the file) to compute + // the column count on the now current line. + size_t chIndex = currentChar; + while (chIndex > 0) { + if (sources[currentSource][chIndex] == '\n') { + break; + } + --chIndex; + } + logicalSourceLoc.column = (int)(currentChar - chIndex); + loc[currentSource].column = (int)(currentChar - chIndex); + } + } else { + do { + --currentSource; + } while (currentSource > 0 && lengths[currentSource] == 0); + if (lengths[currentSource] == 0) { + // set to 0 if we've backed up to the start of an empty string + currentChar = 0; + } else + currentChar = lengths[currentSource] - 1; + } + if (peek() == '\n') { + --loc[currentSource].line; + --logicalSourceLoc.line; + } + } + + // for #line override + void setLine(int newLine) + { + logicalSourceLoc.line = newLine; + loc[getLastValidSourceIndex()].line = newLine; + } + + // for #line override in filename based parsing + void setFile(const char* filename) + { + TString* fn_tstr = NewPoolTString(filename); + logicalSourceLoc.name = fn_tstr; + loc[getLastValidSourceIndex()].name = fn_tstr; + } + + void setFile(const char* filename, int i) + { + TString* fn_tstr = NewPoolTString(filename); + if (i == getLastValidSourceIndex()) { + logicalSourceLoc.name = fn_tstr; + } + loc[i].name = fn_tstr; + } + + void setString(int newString) + { + logicalSourceLoc.string = newString; + loc[getLastValidSourceIndex()].string = newString; + logicalSourceLoc.name = nullptr; + loc[getLastValidSourceIndex()].name = nullptr; + } + + // for #include content indentation + void setColumn(int col) + { + logicalSourceLoc.column = col; + loc[getLastValidSourceIndex()].column = col; + } + + void setEndOfInput() + { + endOfFileReached = true; + currentSource = numSources; + } + + bool atEndOfInput() const { return endOfFileReached; } + + const TSourceLoc& getSourceLoc() const + { + if (singleLogical) { + return logicalSourceLoc; + } else { + return loc[std::max(0, std::min(currentSource, numSources - finale - 1))]; + } + } + // Returns the index (starting from 0) of the most recent valid source string we are reading from. + int getLastValidSourceIndex() const { return std::min(currentSource, numSources - 1); } + + void consumeWhiteSpace(bool& foundNonSpaceTab); + bool consumeComment(); + void consumeWhitespaceComment(bool& foundNonSpaceTab); + bool scanVersion(int& version, EProfile& profile, bool& notFirstToken); + +protected: + + // advance one character + void advance() + { + ++currentChar; + if (currentChar >= lengths[currentSource]) { + ++currentSource; + if (currentSource < numSources) { + loc[currentSource].string = loc[currentSource - 1].string + 1; + loc[currentSource].line = 1; + loc[currentSource].column = 0; + } + while (currentSource < numSources && lengths[currentSource] == 0) { + ++currentSource; + if (currentSource < numSources) { + loc[currentSource].string = loc[currentSource - 1].string + 1; + loc[currentSource].line = 1; + loc[currentSource].column = 0; + } + } + currentChar = 0; + } + } + + int numSources; // number of strings in source + const unsigned char* const *sources; // array of strings; must be converted to positive values on use, to avoid aliasing with -1 as EndOfInput + const size_t *lengths; // length of each string + int currentSource; + size_t currentChar; + + // This is for reporting what string/line an error occurred on, and can be overridden by #line. + // It remembers the last state of each source string as it is left for the next one, so unget() + // can restore that state. + TSourceLoc* loc; // an array + + int stringBias; // the first string that is the user's string number 0 + int finale; // number of internal strings after user's last string + + TSourceLoc logicalSourceLoc; + bool singleLogical; // treats the strings as a single logical string. + // locations will be reported from the first string. + + // Set to true once peek() returns EndOfFile, so that we won't roll back + // once we've reached EndOfFile. + bool endOfFileReached; +}; + +} // end namespace glslang + +#endif // _GLSLANG_SCAN_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/ScanContext.h b/ios/include/glslang/MachineIndependent/ScanContext.h new file mode 100644 index 00000000..74b2b3c7 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/ScanContext.h @@ -0,0 +1,93 @@ +// +// Copyright (C) 2013 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +// +// This holds context specific to the GLSL scanner, which +// sits between the preprocessor scanner and parser. +// + +#pragma once + +#include "ParseHelper.h" + +namespace glslang { + +class TPpContext; +class TPpToken; +class TParserToken; + +class TScanContext { +public: + explicit TScanContext(TParseContextBase& pc) : + parseContext(pc), + afterType(false), afterStruct(false), + field(false), afterBuffer(false) { } + virtual ~TScanContext() { } + + static void fillInKeywordMap(); + static void deleteKeywordMap(); + + int tokenize(TPpContext*, TParserToken&); + +protected: + TScanContext(TScanContext&); + TScanContext& operator=(TScanContext&); + + int tokenizeIdentifier(); + int identifierOrType(); + int reservedWord(); + int identifierOrReserved(bool reserved); + int es30ReservedFromGLSL(int version); + int nonreservedKeyword(int esVersion, int nonEsVersion); + int precisionKeyword(); + int matNxM(); + int dMat(); + int firstGenerationImage(bool inEs310); + int secondGenerationImage(); + + TParseContextBase& parseContext; + bool afterType; // true if we've recognized a type, so can only be looking for an identifier + bool afterStruct; // true if we've recognized the STRUCT keyword, so can only be looking for an identifier + bool field; // true if we're on a field, right after a '.' + bool afterBuffer; // true if we've recognized the BUFFER keyword + TSourceLoc loc; + TParserToken* parserToken; + TPpToken* ppToken; + + const char* tokenText; + int keyword; +}; + +} // end namespace glslang diff --git a/ios/include/glslang/MachineIndependent/SymbolTable.h b/ios/include/glslang/MachineIndependent/SymbolTable.h new file mode 100644 index 00000000..40ca3da5 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/SymbolTable.h @@ -0,0 +1,885 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2013 LunarG, Inc. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _SYMBOL_TABLE_INCLUDED_ +#define _SYMBOL_TABLE_INCLUDED_ + +// +// Symbol table for parsing. Has these design characteristics: +// +// * Same symbol table can be used to compile many shaders, to preserve +// effort of creating and loading with the large numbers of built-in +// symbols. +// +// --> This requires a copy mechanism, so initial pools used to create +// the shared information can be popped. Done through "clone" +// methods. +// +// * Name mangling will be used to give each function a unique name +// so that symbol table lookups are never ambiguous. This allows +// a simpler symbol table structure. +// +// * Pushing and popping of scope, so symbol table will really be a stack +// of symbol tables. Searched from the top, with new inserts going into +// the top. +// +// * Constants: Compile time constant symbols will keep their values +// in the symbol table. The parser can substitute constants at parse +// time, including doing constant folding and constant propagation. +// +// * No temporaries: Temporaries made from operations (+, --, .xy, etc.) +// are tracked in the intermediate representation, not the symbol table. +// + +#include "../Include/Common.h" +#include "../Include/intermediate.h" +#include "../Include/InfoSink.h" + +namespace glslang { + +// +// Symbol base class. (Can build functions or variables out of these...) +// + +class TVariable; +class TFunction; +class TAnonMember; + +typedef TVector TExtensionList; + +class TSymbol { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + explicit TSymbol(const TString *n) : name(n), extensions(0), writable(true) { } + virtual TSymbol* clone() const = 0; + virtual ~TSymbol() { } // rely on all symbol owned memory coming from the pool + + virtual const TString& getName() const { return *name; } + virtual void changeName(const TString* newName) { name = newName; } + virtual void addPrefix(const char* prefix) + { + TString newName(prefix); + newName.append(*name); + changeName(NewPoolTString(newName.c_str())); + } + virtual const TString& getMangledName() const { return getName(); } + virtual TFunction* getAsFunction() { return 0; } + virtual const TFunction* getAsFunction() const { return 0; } + virtual TVariable* getAsVariable() { return 0; } + virtual const TVariable* getAsVariable() const { return 0; } + virtual const TAnonMember* getAsAnonMember() const { return 0; } + virtual const TType& getType() const = 0; + virtual TType& getWritableType() = 0; + virtual void setUniqueId(int id) { uniqueId = id; } + virtual int getUniqueId() const { return uniqueId; } + virtual void setExtensions(int numExts, const char* const exts[]) + { + assert(extensions == 0); + assert(numExts > 0); + extensions = NewPoolObject(extensions); + for (int e = 0; e < numExts; ++e) + extensions->push_back(exts[e]); + } + virtual int getNumExtensions() const { return extensions == nullptr ? 0 : (int)extensions->size(); } + virtual const char** getExtensions() const { return extensions->data(); } + +#ifndef GLSLANG_WEB + virtual void dump(TInfoSink& infoSink, bool complete = false) const = 0; + void dumpExtensions(TInfoSink& infoSink) const; +#endif + + virtual bool isReadOnly() const { return ! writable; } + virtual void makeReadOnly() { writable = false; } + +protected: + explicit TSymbol(const TSymbol&); + TSymbol& operator=(const TSymbol&); + + const TString *name; + unsigned int uniqueId; // For cross-scope comparing during code generation + + // For tracking what extensions must be present + // (don't use if correct version/profile is present). + TExtensionList* extensions; // an array of pointers to existing constant char strings + + // + // N.B.: Non-const functions that will be generally used should assert on this, + // to avoid overwriting shared symbol-table information. + // + bool writable; +}; + +// +// Variable class, meaning a symbol that's not a function. +// +// There could be a separate class hierarchy for Constant variables; +// Only one of int, bool, or float, (or none) is correct for +// any particular use, but it's easy to do this way, and doesn't +// seem worth having separate classes, and "getConst" can't simply return +// different values for different types polymorphically, so this is +// just simple and pragmatic. +// +class TVariable : public TSymbol { +public: + TVariable(const TString *name, const TType& t, bool uT = false ) + : TSymbol(name), + userType(uT), + constSubtree(nullptr), + memberExtensions(nullptr), + anonId(-1) + { type.shallowCopy(t); } + virtual TVariable* clone() const; + virtual ~TVariable() { } + + virtual TVariable* getAsVariable() { return this; } + virtual const TVariable* getAsVariable() const { return this; } + virtual const TType& getType() const { return type; } + virtual TType& getWritableType() { assert(writable); return type; } + virtual bool isUserType() const { return userType; } + virtual const TConstUnionArray& getConstArray() const { return constArray; } + virtual TConstUnionArray& getWritableConstArray() { assert(writable); return constArray; } + virtual void setConstArray(const TConstUnionArray& array) { constArray = array; } + virtual void setConstSubtree(TIntermTyped* subtree) { constSubtree = subtree; } + virtual TIntermTyped* getConstSubtree() const { return constSubtree; } + virtual void setAnonId(int i) { anonId = i; } + virtual int getAnonId() const { return anonId; } + + virtual void setMemberExtensions(int member, int numExts, const char* const exts[]) + { + assert(type.isStruct()); + assert(numExts > 0); + if (memberExtensions == nullptr) { + memberExtensions = NewPoolObject(memberExtensions); + memberExtensions->resize(type.getStruct()->size()); + } + for (int e = 0; e < numExts; ++e) + (*memberExtensions)[member].push_back(exts[e]); + } + virtual bool hasMemberExtensions() const { return memberExtensions != nullptr; } + virtual int getNumMemberExtensions(int member) const + { + return memberExtensions == nullptr ? 0 : (int)(*memberExtensions)[member].size(); + } + virtual const char** getMemberExtensions(int member) const { return (*memberExtensions)[member].data(); } + +#ifndef GLSLANG_WEB + virtual void dump(TInfoSink& infoSink, bool complete = false) const; +#endif + +protected: + explicit TVariable(const TVariable&); + TVariable& operator=(const TVariable&); + + TType type; + bool userType; + + // we are assuming that Pool Allocator will free the memory allocated to unionArray + // when this object is destroyed + + TConstUnionArray constArray; // for compile-time constant value + TIntermTyped* constSubtree; // for specialization constant computation + TVector* memberExtensions; // per-member extension list, allocated only when needed + int anonId; // the ID used for anonymous blocks: TODO: see if uniqueId could serve a dual purpose +}; + +// +// The function sub-class of symbols and the parser will need to +// share this definition of a function parameter. +// +struct TParameter { + TString *name; + TType* type; + TIntermTyped* defaultValue; + void copyParam(const TParameter& param) + { + if (param.name) + name = NewPoolTString(param.name->c_str()); + else + name = 0; + type = param.type->clone(); + defaultValue = param.defaultValue; + } + TBuiltInVariable getDeclaredBuiltIn() const { return type->getQualifier().declaredBuiltIn; } +}; + +// +// The function sub-class of a symbol. +// +class TFunction : public TSymbol { +public: + explicit TFunction(TOperator o) : + TSymbol(0), + op(o), + defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0) { } + TFunction(const TString *name, const TType& retType, TOperator tOp = EOpNull) : + TSymbol(name), + mangledName(*name + '('), + op(tOp), + defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0) + { + returnType.shallowCopy(retType); + declaredBuiltIn = retType.getQualifier().builtIn; + } + virtual TFunction* clone() const override; + virtual ~TFunction(); + + virtual TFunction* getAsFunction() override { return this; } + virtual const TFunction* getAsFunction() const override { return this; } + + // Install 'p' as the (non-'this') last parameter. + // Non-'this' parameters are reflected in both the list of parameters and the + // mangled name. + virtual void addParameter(TParameter& p) + { + assert(writable); + parameters.push_back(p); + p.type->appendMangledName(mangledName); + + if (p.defaultValue != nullptr) + defaultParamCount++; + } + + // Install 'this' as the first parameter. + // 'this' is reflected in the list of parameters, but not the mangled name. + virtual void addThisParameter(TType& type, const char* name) + { + TParameter p = { NewPoolTString(name), new TType, nullptr }; + p.type->shallowCopy(type); + parameters.insert(parameters.begin(), p); + } + + virtual void addPrefix(const char* prefix) override + { + TSymbol::addPrefix(prefix); + mangledName.insert(0, prefix); + } + + virtual void removePrefix(const TString& prefix) + { + assert(mangledName.compare(0, prefix.size(), prefix) == 0); + mangledName.erase(0, prefix.size()); + } + + virtual const TString& getMangledName() const override { return mangledName; } + virtual const TType& getType() const override { return returnType; } + virtual TBuiltInVariable getDeclaredBuiltInType() const { return declaredBuiltIn; } + virtual TType& getWritableType() override { return returnType; } + virtual void relateToOperator(TOperator o) { assert(writable); op = o; } + virtual TOperator getBuiltInOp() const { return op; } + virtual void setDefined() { assert(writable); defined = true; } + virtual bool isDefined() const { return defined; } + virtual void setPrototyped() { assert(writable); prototyped = true; } + virtual bool isPrototyped() const { return prototyped; } + virtual void setImplicitThis() { assert(writable); implicitThis = true; } + virtual bool hasImplicitThis() const { return implicitThis; } + virtual void setIllegalImplicitThis() { assert(writable); illegalImplicitThis = true; } + virtual bool hasIllegalImplicitThis() const { return illegalImplicitThis; } + + // Return total number of parameters + virtual int getParamCount() const { return static_cast(parameters.size()); } + // Return number of parameters with default values. + virtual int getDefaultParamCount() const { return defaultParamCount; } + // Return number of fixed parameters (without default values) + virtual int getFixedParamCount() const { return getParamCount() - getDefaultParamCount(); } + + virtual TParameter& operator[](int i) { assert(writable); return parameters[i]; } + virtual const TParameter& operator[](int i) const { return parameters[i]; } + +#ifndef GLSLANG_WEB + virtual void dump(TInfoSink& infoSink, bool complete = false) const override; +#endif + +protected: + explicit TFunction(const TFunction&); + TFunction& operator=(const TFunction&); + + typedef TVector TParamList; + TParamList parameters; + TType returnType; + TBuiltInVariable declaredBuiltIn; + + TString mangledName; + TOperator op; + bool defined; + bool prototyped; + bool implicitThis; // True if this function is allowed to see all members of 'this' + bool illegalImplicitThis; // True if this function is not supposed to have access to dynamic members of 'this', + // even if it finds member variables in the symbol table. + // This is important for a static member function that has member variables in scope, + // but is not allowed to use them, or see hidden symbols instead. + int defaultParamCount; +}; + +// +// Members of anonymous blocks are a kind of TSymbol. They are not hidden in +// the symbol table behind a container; rather they are visible and point to +// their anonymous container. (The anonymous container is found through the +// member, not the other way around.) +// +class TAnonMember : public TSymbol { +public: + TAnonMember(const TString* n, unsigned int m, TVariable& a, int an) : TSymbol(n), anonContainer(a), memberNumber(m), anonId(an) { } + virtual TAnonMember* clone() const override; + virtual ~TAnonMember() { } + + virtual const TAnonMember* getAsAnonMember() const override { return this; } + virtual const TVariable& getAnonContainer() const { return anonContainer; } + virtual unsigned int getMemberNumber() const { return memberNumber; } + + virtual const TType& getType() const override + { + const TTypeList& types = *anonContainer.getType().getStruct(); + return *types[memberNumber].type; + } + + virtual TType& getWritableType() override + { + assert(writable); + const TTypeList& types = *anonContainer.getType().getStruct(); + return *types[memberNumber].type; + } + + virtual void setExtensions(int numExts, const char* const exts[]) override + { + anonContainer.setMemberExtensions(memberNumber, numExts, exts); + } + virtual int getNumExtensions() const override { return anonContainer.getNumMemberExtensions(memberNumber); } + virtual const char** getExtensions() const override { return anonContainer.getMemberExtensions(memberNumber); } + + virtual int getAnonId() const { return anonId; } +#ifndef GLSLANG_WEB + virtual void dump(TInfoSink& infoSink, bool complete = false) const override; +#endif + +protected: + explicit TAnonMember(const TAnonMember&); + TAnonMember& operator=(const TAnonMember&); + + TVariable& anonContainer; + unsigned int memberNumber; + int anonId; +}; + +class TSymbolTableLevel { +public: + POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) + TSymbolTableLevel() : defaultPrecision(0), anonId(0), thisLevel(false) { } + ~TSymbolTableLevel(); + + bool insert(TSymbol& symbol, bool separateNameSpaces) + { + // + // returning true means symbol was added to the table with no semantic errors + // + const TString& name = symbol.getName(); + if (name == "") { + symbol.getAsVariable()->setAnonId(anonId++); + // An empty name means an anonymous container, exposing its members to the external scope. + // Give it a name and insert its members in the symbol table, pointing to the container. + char buf[20]; + snprintf(buf, 20, "%s%d", AnonymousPrefix, symbol.getAsVariable()->getAnonId()); + symbol.changeName(NewPoolTString(buf)); + + return insertAnonymousMembers(symbol, 0); + } else { + // Check for redefinition errors: + // - STL itself will tell us if there is a direct name collision, with name mangling, at this level + // - additionally, check for function-redefining-variable name collisions + const TString& insertName = symbol.getMangledName(); + if (symbol.getAsFunction()) { + // make sure there isn't a variable of this name + if (! separateNameSpaces && level.find(name) != level.end()) + return false; + + // insert, and whatever happens is okay + level.insert(tLevelPair(insertName, &symbol)); + + return true; + } else + return level.insert(tLevelPair(insertName, &symbol)).second; + } + } + + // Add more members to an already inserted aggregate object + bool amend(TSymbol& symbol, int firstNewMember) + { + // See insert() for comments on basic explanation of insert. + // This operates similarly, but more simply. + // Only supporting amend of anonymous blocks so far. + if (IsAnonymous(symbol.getName())) + return insertAnonymousMembers(symbol, firstNewMember); + else + return false; + } + + bool insertAnonymousMembers(TSymbol& symbol, int firstMember) + { + const TTypeList& types = *symbol.getAsVariable()->getType().getStruct(); + for (unsigned int m = firstMember; m < types.size(); ++m) { + TAnonMember* member = new TAnonMember(&types[m].type->getFieldName(), m, *symbol.getAsVariable(), symbol.getAsVariable()->getAnonId()); + if (! level.insert(tLevelPair(member->getMangledName(), member)).second) + return false; + } + + return true; + } + + TSymbol* find(const TString& name) const + { + tLevel::const_iterator it = level.find(name); + if (it == level.end()) + return 0; + else + return (*it).second; + } + + void findFunctionNameList(const TString& name, TVector& list) + { + size_t parenAt = name.find_first_of('('); + TString base(name, 0, parenAt + 1); + + tLevel::const_iterator begin = level.lower_bound(base); + base[parenAt] = ')'; // assume ')' is lexically after '(' + tLevel::const_iterator end = level.upper_bound(base); + for (tLevel::const_iterator it = begin; it != end; ++it) + list.push_back(it->second->getAsFunction()); + } + + // See if there is already a function in the table having the given non-function-style name. + bool hasFunctionName(const TString& name) const + { + tLevel::const_iterator candidate = level.lower_bound(name); + if (candidate != level.end()) { + const TString& candidateName = (*candidate).first; + TString::size_type parenAt = candidateName.find_first_of('('); + if (parenAt != candidateName.npos && candidateName.compare(0, parenAt, name) == 0) + + return true; + } + + return false; + } + + // See if there is a variable at this level having the given non-function-style name. + // Return true if name is found, and set variable to true if the name was a variable. + bool findFunctionVariableName(const TString& name, bool& variable) const + { + tLevel::const_iterator candidate = level.lower_bound(name); + if (candidate != level.end()) { + const TString& candidateName = (*candidate).first; + TString::size_type parenAt = candidateName.find_first_of('('); + if (parenAt == candidateName.npos) { + // not a mangled name + if (candidateName == name) { + // found a variable name match + variable = true; + return true; + } + } else { + // a mangled name + if (candidateName.compare(0, parenAt, name) == 0) { + // found a function name match + variable = false; + return true; + } + } + } + + return false; + } + + // Use this to do a lazy 'push' of precision defaults the first time + // a precision statement is seen in a new scope. Leave it at 0 for + // when no push was needed. Thus, it is not the current defaults, + // it is what to restore the defaults to when popping a level. + void setPreviousDefaultPrecisions(const TPrecisionQualifier *p) + { + // can call multiple times at one scope, will only latch on first call, + // as we're tracking the previous scope's values, not the current values + if (defaultPrecision != 0) + return; + + defaultPrecision = new TPrecisionQualifier[EbtNumTypes]; + for (int t = 0; t < EbtNumTypes; ++t) + defaultPrecision[t] = p[t]; + } + + void getPreviousDefaultPrecisions(TPrecisionQualifier *p) + { + // can be called for table level pops that didn't set the + // defaults + if (defaultPrecision == 0 || p == 0) + return; + + for (int t = 0; t < EbtNumTypes; ++t) + p[t] = defaultPrecision[t]; + } + + void relateToOperator(const char* name, TOperator op); + void setFunctionExtensions(const char* name, int num, const char* const extensions[]); +#ifndef GLSLANG_WEB + void dump(TInfoSink& infoSink, bool complete = false) const; +#endif + TSymbolTableLevel* clone() const; + void readOnly(); + + void setThisLevel() { thisLevel = true; } + bool isThisLevel() const { return thisLevel; } + +protected: + explicit TSymbolTableLevel(TSymbolTableLevel&); + TSymbolTableLevel& operator=(TSymbolTableLevel&); + + typedef std::map, pool_allocator > > tLevel; + typedef const tLevel::value_type tLevelPair; + typedef std::pair tInsertResult; + + tLevel level; // named mappings + TPrecisionQualifier *defaultPrecision; + int anonId; + bool thisLevel; // True if this level of the symbol table is a structure scope containing member function + // that are supposed to see anonymous access to member variables. +}; + +class TSymbolTable { +public: + TSymbolTable() : uniqueId(0), noBuiltInRedeclarations(false), separateNameSpaces(false), adoptedLevels(0) + { + // + // This symbol table cannot be used until push() is called. + // + } + ~TSymbolTable() + { + // this can be called explicitly; safest to code it so it can be called multiple times + + // don't deallocate levels passed in from elsewhere + while (table.size() > adoptedLevels) + pop(0); + } + + void adoptLevels(TSymbolTable& symTable) + { + for (unsigned int level = 0; level < symTable.table.size(); ++level) { + table.push_back(symTable.table[level]); + ++adoptedLevels; + } + uniqueId = symTable.uniqueId; + noBuiltInRedeclarations = symTable.noBuiltInRedeclarations; + separateNameSpaces = symTable.separateNameSpaces; + } + + // + // While level adopting is generic, the methods below enact a the following + // convention for levels: + // 0: common built-ins shared across all stages, all compiles, only one copy for all symbol tables + // 1: per-stage built-ins, shared across all compiles, but a different copy per stage + // 2: built-ins specific to a compile, like resources that are context-dependent, or redeclared built-ins + // 3: user-shader globals + // +protected: + static const int globalLevel = 3; + bool isSharedLevel(int level) { return level <= 1; } // exclude all per-compile levels + bool isBuiltInLevel(int level) { return level <= 2; } // exclude user globals + bool isGlobalLevel(int level) { return level <= globalLevel; } // include user globals +public: + bool isEmpty() { return table.size() == 0; } + bool atBuiltInLevel() { return isBuiltInLevel(currentLevel()); } + bool atGlobalLevel() { return isGlobalLevel(currentLevel()); } + + void setNoBuiltInRedeclarations() { noBuiltInRedeclarations = true; } + void setSeparateNameSpaces() { separateNameSpaces = true; } + + void push() + { + table.push_back(new TSymbolTableLevel); + } + + // Make a new symbol-table level to represent the scope introduced by a structure + // containing member functions, such that the member functions can find anonymous + // references to member variables. + // + // 'thisSymbol' should have a name of "" to trigger anonymous structure-member + // symbol finds. + void pushThis(TSymbol& thisSymbol) + { + assert(thisSymbol.getName().size() == 0); + table.push_back(new TSymbolTableLevel); + table.back()->setThisLevel(); + insert(thisSymbol); + } + + void pop(TPrecisionQualifier *p) + { + table[currentLevel()]->getPreviousDefaultPrecisions(p); + delete table.back(); + table.pop_back(); + } + + // + // Insert a visible symbol into the symbol table so it can + // be found later by name. + // + // Returns false if the was a name collision. + // + bool insert(TSymbol& symbol) + { + symbol.setUniqueId(++uniqueId); + + // make sure there isn't a function of this variable name + if (! separateNameSpaces && ! symbol.getAsFunction() && table[currentLevel()]->hasFunctionName(symbol.getName())) + return false; + + // check for not overloading or redefining a built-in function + if (noBuiltInRedeclarations) { + if (atGlobalLevel() && currentLevel() > 0) { + if (table[0]->hasFunctionName(symbol.getName())) + return false; + if (currentLevel() > 1 && table[1]->hasFunctionName(symbol.getName())) + return false; + } + } + + return table[currentLevel()]->insert(symbol, separateNameSpaces); + } + + // Add more members to an already inserted aggregate object + bool amend(TSymbol& symbol, int firstNewMember) + { + // See insert() for comments on basic explanation of insert. + // This operates similarly, but more simply. + return table[currentLevel()]->amend(symbol, firstNewMember); + } + + // + // To allocate an internal temporary, which will need to be uniquely + // identified by the consumer of the AST, but never need to + // found by doing a symbol table search by name, hence allowed an + // arbitrary name in the symbol with no worry of collision. + // + void makeInternalVariable(TSymbol& symbol) + { + symbol.setUniqueId(++uniqueId); + } + + // + // Copy a variable or anonymous member's structure from a shared level so that + // it can be added (soon after return) to the symbol table where it can be + // modified without impacting other users of the shared table. + // + TSymbol* copyUpDeferredInsert(TSymbol* shared) + { + if (shared->getAsVariable()) { + TSymbol* copy = shared->clone(); + copy->setUniqueId(shared->getUniqueId()); + return copy; + } else { + const TAnonMember* anon = shared->getAsAnonMember(); + assert(anon); + TVariable* container = anon->getAnonContainer().clone(); + container->changeName(NewPoolTString("")); + container->setUniqueId(anon->getAnonContainer().getUniqueId()); + return container; + } + } + + TSymbol* copyUp(TSymbol* shared) + { + TSymbol* copy = copyUpDeferredInsert(shared); + table[globalLevel]->insert(*copy, separateNameSpaces); + if (shared->getAsVariable()) + return copy; + else { + // return the copy of the anonymous member + return table[globalLevel]->find(shared->getName()); + } + } + + // Normal find of a symbol, that can optionally say whether the symbol was found + // at a built-in level or the current top-scope level. + TSymbol* find(const TString& name, bool* builtIn = 0, bool* currentScope = 0, int* thisDepthP = 0) + { + int level = currentLevel(); + TSymbol* symbol; + int thisDepth = 0; + do { + if (table[level]->isThisLevel()) + ++thisDepth; + symbol = table[level]->find(name); + --level; + } while (symbol == nullptr && level >= 0); + level++; + if (builtIn) + *builtIn = isBuiltInLevel(level); + if (currentScope) + *currentScope = isGlobalLevel(currentLevel()) || level == currentLevel(); // consider shared levels as "current scope" WRT user globals + if (thisDepthP != nullptr) { + if (! table[level]->isThisLevel()) + thisDepth = 0; + *thisDepthP = thisDepth; + } + + return symbol; + } + + // Find of a symbol that returns how many layers deep of nested + // structures-with-member-functions ('this' scopes) deep the symbol was + // found in. + TSymbol* find(const TString& name, int& thisDepth) + { + int level = currentLevel(); + TSymbol* symbol; + thisDepth = 0; + do { + if (table[level]->isThisLevel()) + ++thisDepth; + symbol = table[level]->find(name); + --level; + } while (symbol == 0 && level >= 0); + + if (! table[level + 1]->isThisLevel()) + thisDepth = 0; + + return symbol; + } + + bool isFunctionNameVariable(const TString& name) const + { + if (separateNameSpaces) + return false; + + int level = currentLevel(); + do { + bool variable; + bool found = table[level]->findFunctionVariableName(name, variable); + if (found) + return variable; + --level; + } while (level >= 0); + + return false; + } + + void findFunctionNameList(const TString& name, TVector& list, bool& builtIn) + { + // For user levels, return the set found in the first scope with a match + builtIn = false; + int level = currentLevel(); + do { + table[level]->findFunctionNameList(name, list); + --level; + } while (list.empty() && level >= globalLevel); + + if (! list.empty()) + return; + + // Gather across all built-in levels; they don't hide each other + builtIn = true; + do { + table[level]->findFunctionNameList(name, list); + --level; + } while (level >= 0); + } + + void relateToOperator(const char* name, TOperator op) + { + for (unsigned int level = 0; level < table.size(); ++level) + table[level]->relateToOperator(name, op); + } + + void setFunctionExtensions(const char* name, int num, const char* const extensions[]) + { + for (unsigned int level = 0; level < table.size(); ++level) + table[level]->setFunctionExtensions(name, num, extensions); + } + + void setVariableExtensions(const char* name, int numExts, const char* const extensions[]) + { + TSymbol* symbol = find(TString(name)); + if (symbol == nullptr) + return; + + symbol->setExtensions(numExts, extensions); + } + + void setVariableExtensions(const char* blockName, const char* name, int numExts, const char* const extensions[]) + { + TSymbol* symbol = find(TString(blockName)); + if (symbol == nullptr) + return; + TVariable* variable = symbol->getAsVariable(); + assert(variable != nullptr); + + const TTypeList& structure = *variable->getAsVariable()->getType().getStruct(); + for (int member = 0; member < (int)structure.size(); ++member) { + if (structure[member].type->getFieldName().compare(name) == 0) { + variable->setMemberExtensions(member, numExts, extensions); + return; + } + } + } + + int getMaxSymbolId() { return uniqueId; } +#ifndef GLSLANG_WEB + void dump(TInfoSink& infoSink, bool complete = false) const; +#endif + void copyTable(const TSymbolTable& copyOf); + + void setPreviousDefaultPrecisions(TPrecisionQualifier *p) { table[currentLevel()]->setPreviousDefaultPrecisions(p); } + + void readOnly() + { + for (unsigned int level = 0; level < table.size(); ++level) + table[level]->readOnly(); + } + +protected: + TSymbolTable(TSymbolTable&); + TSymbolTable& operator=(TSymbolTableLevel&); + + int currentLevel() const { return static_cast(table.size()) - 1; } + + std::vector table; + int uniqueId; // for unique identification in code generation + bool noBuiltInRedeclarations; + bool separateNameSpaces; + unsigned int adoptedLevels; +}; + +} // end namespace glslang + +#endif // _SYMBOL_TABLE_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/Versions.h b/ios/include/glslang/MachineIndependent/Versions.h new file mode 100644 index 00000000..c90db966 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/Versions.h @@ -0,0 +1,332 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2012-2013 LunarG, Inc. +// Copyright (C) 2017 ARM Limited. +// Copyright (C) 2015-2018 Google, Inc. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _VERSIONS_INCLUDED_ +#define _VERSIONS_INCLUDED_ + +#define LAST_ELEMENT_MARKER(x) x + +// +// Help manage multiple profiles, versions, extensions etc. +// + +// +// Profiles are set up for masking operations, so queries can be done on multiple +// profiles at the same time. +// +// Don't maintain an ordinal set of enums (0,1,2,3...) to avoid all possible +// defects from mixing the two different forms. +// +typedef enum : unsigned { + EBadProfile = 0, + ENoProfile = (1 << 0), // only for desktop, before profiles showed up + ECoreProfile = (1 << 1), + ECompatibilityProfile = (1 << 2), + EEsProfile = (1 << 3), + LAST_ELEMENT_MARKER(EProfileCount), +} EProfile; + +namespace glslang { + +// +// Map from profile enum to externally readable text name. +// +inline const char* ProfileName(EProfile profile) +{ + switch (profile) { + case ENoProfile: return "none"; + case ECoreProfile: return "core"; + case ECompatibilityProfile: return "compatibility"; + case EEsProfile: return "es"; + default: return "unknown profile"; + } +} + +// +// What source rules, validation rules, target language, etc. are needed or +// desired for SPIR-V? +// +// 0 means a target or rule set is not enabled (ignore rules from that entity). +// Non-0 means to apply semantic rules arising from that version of its rule set. +// The union of all requested rule sets will be applied. +// +struct SpvVersion { + SpvVersion() : spv(0), vulkanGlsl(0), vulkan(0), openGl(0) {} + unsigned int spv; // the version of SPIR-V to target, as defined by "word 1" of the SPIR-V binary header + int vulkanGlsl; // the version of GLSL semantics for Vulkan, from GL_KHR_vulkan_glsl, for "#define VULKAN XXX" + int vulkan; // the version of Vulkan, for which SPIR-V execution environment rules to use + int openGl; // the version of GLSL semantics for OpenGL, from GL_ARB_gl_spirv, for "#define GL_SPIRV XXX" +}; + +// +// The behaviors from the GLSL "#extension extension_name : behavior" +// +typedef enum { + EBhMissing = 0, + EBhRequire, + EBhEnable, + EBhWarn, + EBhDisable, + EBhDisablePartial // use as initial state of an extension that is only partially implemented +} TExtensionBehavior; + +// +// Symbolic names for extensions. Strings may be directly used when calling the +// functions, but better to have the compiler do spelling checks. +// +const char* const E_GL_OES_texture_3D = "GL_OES_texture_3D"; +const char* const E_GL_OES_standard_derivatives = "GL_OES_standard_derivatives"; +const char* const E_GL_EXT_frag_depth = "GL_EXT_frag_depth"; +const char* const E_GL_OES_EGL_image_external = "GL_OES_EGL_image_external"; +const char* const E_GL_OES_EGL_image_external_essl3 = "GL_OES_EGL_image_external_essl3"; +const char* const E_GL_EXT_YUV_target = "GL_EXT_YUV_target"; +const char* const E_GL_EXT_shader_texture_lod = "GL_EXT_shader_texture_lod"; +const char* const E_GL_EXT_shadow_samplers = "GL_EXT_shadow_samplers"; + +const char* const E_GL_ARB_texture_rectangle = "GL_ARB_texture_rectangle"; +const char* const E_GL_3DL_array_objects = "GL_3DL_array_objects"; +const char* const E_GL_ARB_shading_language_420pack = "GL_ARB_shading_language_420pack"; +const char* const E_GL_ARB_texture_gather = "GL_ARB_texture_gather"; +const char* const E_GL_ARB_gpu_shader5 = "GL_ARB_gpu_shader5"; +const char* const E_GL_ARB_separate_shader_objects = "GL_ARB_separate_shader_objects"; +const char* const E_GL_ARB_compute_shader = "GL_ARB_compute_shader"; +const char* const E_GL_ARB_tessellation_shader = "GL_ARB_tessellation_shader"; +const char* const E_GL_ARB_enhanced_layouts = "GL_ARB_enhanced_layouts"; +const char* const E_GL_ARB_texture_cube_map_array = "GL_ARB_texture_cube_map_array"; +const char* const E_GL_ARB_texture_multisample = "GL_ARB_texture_multisample"; +const char* const E_GL_ARB_shader_texture_lod = "GL_ARB_shader_texture_lod"; +const char* const E_GL_ARB_explicit_attrib_location = "GL_ARB_explicit_attrib_location"; +const char* const E_GL_ARB_explicit_uniform_location = "GL_ARB_explicit_uniform_location"; +const char* const E_GL_ARB_shader_image_load_store = "GL_ARB_shader_image_load_store"; +const char* const E_GL_ARB_shader_atomic_counters = "GL_ARB_shader_atomic_counters"; +const char* const E_GL_ARB_shader_draw_parameters = "GL_ARB_shader_draw_parameters"; +const char* const E_GL_ARB_shader_group_vote = "GL_ARB_shader_group_vote"; +const char* const E_GL_ARB_derivative_control = "GL_ARB_derivative_control"; +const char* const E_GL_ARB_shader_texture_image_samples = "GL_ARB_shader_texture_image_samples"; +const char* const E_GL_ARB_viewport_array = "GL_ARB_viewport_array"; +const char* const E_GL_ARB_gpu_shader_int64 = "GL_ARB_gpu_shader_int64"; +const char* const E_GL_ARB_gpu_shader_fp64 = "GL_ARB_gpu_shader_fp64"; +const char* const E_GL_ARB_shader_ballot = "GL_ARB_shader_ballot"; +const char* const E_GL_ARB_sparse_texture2 = "GL_ARB_sparse_texture2"; +const char* const E_GL_ARB_sparse_texture_clamp = "GL_ARB_sparse_texture_clamp"; +const char* const E_GL_ARB_shader_stencil_export = "GL_ARB_shader_stencil_export"; +// const char* const E_GL_ARB_cull_distance = "GL_ARB_cull_distance"; // present for 4.5, but need extension control over block members +const char* const E_GL_ARB_post_depth_coverage = "GL_ARB_post_depth_coverage"; +const char* const E_GL_ARB_shader_viewport_layer_array = "GL_ARB_shader_viewport_layer_array"; +const char* const E_GL_ARB_fragment_shader_interlock = "GL_ARB_fragment_shader_interlock"; +const char* const E_GL_ARB_shader_clock = "GL_ARB_shader_clock"; +const char* const E_GL_ARB_uniform_buffer_object = "GL_ARB_uniform_buffer_object"; +const char* const E_GL_ARB_sample_shading = "GL_ARB_sample_shading"; +const char* const E_GL_ARB_shader_bit_encoding = "GL_ARB_shader_bit_encoding"; +const char* const E_GL_ARB_shader_image_size = "GL_ARB_shader_image_size"; +const char* const E_GL_ARB_shader_storage_buffer_object = "GL_ARB_shader_storage_buffer_object"; +const char* const E_GL_ARB_shading_language_packing = "GL_ARB_shading_language_packing"; +const char* const E_GL_ARB_texture_query_lod = "GL_ARB_texture_query_lod"; +const char* const E_GL_ARB_vertex_attrib_64bit = "GL_ARB_vertex_attrib_64bit"; + +const char* const E_GL_KHR_shader_subgroup_basic = "GL_KHR_shader_subgroup_basic"; +const char* const E_GL_KHR_shader_subgroup_vote = "GL_KHR_shader_subgroup_vote"; +const char* const E_GL_KHR_shader_subgroup_arithmetic = "GL_KHR_shader_subgroup_arithmetic"; +const char* const E_GL_KHR_shader_subgroup_ballot = "GL_KHR_shader_subgroup_ballot"; +const char* const E_GL_KHR_shader_subgroup_shuffle = "GL_KHR_shader_subgroup_shuffle"; +const char* const E_GL_KHR_shader_subgroup_shuffle_relative = "GL_KHR_shader_subgroup_shuffle_relative"; +const char* const E_GL_KHR_shader_subgroup_clustered = "GL_KHR_shader_subgroup_clustered"; +const char* const E_GL_KHR_shader_subgroup_quad = "GL_KHR_shader_subgroup_quad"; +const char* const E_GL_KHR_memory_scope_semantics = "GL_KHR_memory_scope_semantics"; + +const char* const E_GL_EXT_shader_atomic_int64 = "GL_EXT_shader_atomic_int64"; + +const char* const E_GL_EXT_shader_non_constant_global_initializers = "GL_EXT_shader_non_constant_global_initializers"; +const char* const E_GL_EXT_shader_image_load_formatted = "GL_EXT_shader_image_load_formatted"; + +const char* const E_GL_EXT_shader_16bit_storage = "GL_EXT_shader_16bit_storage"; +const char* const E_GL_EXT_shader_8bit_storage = "GL_EXT_shader_8bit_storage"; + + +// EXT extensions +const char* const E_GL_EXT_device_group = "GL_EXT_device_group"; +const char* const E_GL_EXT_multiview = "GL_EXT_multiview"; +const char* const E_GL_EXT_post_depth_coverage = "GL_EXT_post_depth_coverage"; +const char* const E_GL_EXT_control_flow_attributes = "GL_EXT_control_flow_attributes"; +const char* const E_GL_EXT_nonuniform_qualifier = "GL_EXT_nonuniform_qualifier"; +const char* const E_GL_EXT_samplerless_texture_functions = "GL_EXT_samplerless_texture_functions"; +const char* const E_GL_EXT_scalar_block_layout = "GL_EXT_scalar_block_layout"; +const char* const E_GL_EXT_fragment_invocation_density = "GL_EXT_fragment_invocation_density"; +const char* const E_GL_EXT_buffer_reference = "GL_EXT_buffer_reference"; +const char* const E_GL_EXT_buffer_reference2 = "GL_EXT_buffer_reference2"; +const char* const E_GL_EXT_buffer_reference_uvec2 = "GL_EXT_buffer_reference_uvec2"; +const char* const E_GL_EXT_demote_to_helper_invocation = "GL_EXT_demote_to_helper_invocation"; +const char* const E_GL_EXT_shader_realtime_clock = "GL_EXT_shader_realtime_clock"; +const char* const E_GL_EXT_debug_printf = "GL_EXT_debug_printf"; +const char* const E_GL_EXT_ray_tracing = "GL_EXT_ray_tracing"; +const char* const E_GL_EXT_ray_query = "GL_EXT_ray_query"; +const char* const E_GL_EXT_ray_flags_primitive_culling = "GL_EXT_ray_flags_primitive_culling"; +const char* const E_GL_EXT_blend_func_extended = "GL_EXT_blend_func_extended"; +const char* const E_GL_EXT_shader_implicit_conversions = "GL_EXT_shader_implicit_conversions"; + +// Arrays of extensions for the above viewportEXTs duplications + +const char* const post_depth_coverageEXTs[] = { E_GL_ARB_post_depth_coverage, E_GL_EXT_post_depth_coverage }; +const int Num_post_depth_coverageEXTs = sizeof(post_depth_coverageEXTs) / sizeof(post_depth_coverageEXTs[0]); + +// OVR extensions +const char* const E_GL_OVR_multiview = "GL_OVR_multiview"; +const char* const E_GL_OVR_multiview2 = "GL_OVR_multiview2"; + +const char* const OVR_multiview_EXTs[] = { E_GL_OVR_multiview, E_GL_OVR_multiview2 }; +const int Num_OVR_multiview_EXTs = sizeof(OVR_multiview_EXTs) / sizeof(OVR_multiview_EXTs[0]); + +// #line and #include +const char* const E_GL_GOOGLE_cpp_style_line_directive = "GL_GOOGLE_cpp_style_line_directive"; +const char* const E_GL_GOOGLE_include_directive = "GL_GOOGLE_include_directive"; + +const char* const E_GL_AMD_shader_ballot = "GL_AMD_shader_ballot"; +const char* const E_GL_AMD_shader_trinary_minmax = "GL_AMD_shader_trinary_minmax"; +const char* const E_GL_AMD_shader_explicit_vertex_parameter = "GL_AMD_shader_explicit_vertex_parameter"; +const char* const E_GL_AMD_gcn_shader = "GL_AMD_gcn_shader"; +const char* const E_GL_AMD_gpu_shader_half_float = "GL_AMD_gpu_shader_half_float"; +const char* const E_GL_AMD_texture_gather_bias_lod = "GL_AMD_texture_gather_bias_lod"; +const char* const E_GL_AMD_gpu_shader_int16 = "GL_AMD_gpu_shader_int16"; +const char* const E_GL_AMD_shader_image_load_store_lod = "GL_AMD_shader_image_load_store_lod"; +const char* const E_GL_AMD_shader_fragment_mask = "GL_AMD_shader_fragment_mask"; +const char* const E_GL_AMD_gpu_shader_half_float_fetch = "GL_AMD_gpu_shader_half_float_fetch"; + +const char* const E_GL_INTEL_shader_integer_functions2 = "GL_INTEL_shader_integer_functions2"; + +const char* const E_GL_NV_sample_mask_override_coverage = "GL_NV_sample_mask_override_coverage"; +const char* const E_SPV_NV_geometry_shader_passthrough = "GL_NV_geometry_shader_passthrough"; +const char* const E_GL_NV_viewport_array2 = "GL_NV_viewport_array2"; +const char* const E_GL_NV_stereo_view_rendering = "GL_NV_stereo_view_rendering"; +const char* const E_GL_NVX_multiview_per_view_attributes = "GL_NVX_multiview_per_view_attributes"; +const char* const E_GL_NV_shader_atomic_int64 = "GL_NV_shader_atomic_int64"; +const char* const E_GL_NV_conservative_raster_underestimation = "GL_NV_conservative_raster_underestimation"; +const char* const E_GL_NV_shader_noperspective_interpolation = "GL_NV_shader_noperspective_interpolation"; +const char* const E_GL_NV_shader_subgroup_partitioned = "GL_NV_shader_subgroup_partitioned"; +const char* const E_GL_NV_shading_rate_image = "GL_NV_shading_rate_image"; +const char* const E_GL_NV_ray_tracing = "GL_NV_ray_tracing"; +const char* const E_GL_NV_fragment_shader_barycentric = "GL_NV_fragment_shader_barycentric"; +const char* const E_GL_NV_compute_shader_derivatives = "GL_NV_compute_shader_derivatives"; +const char* const E_GL_NV_shader_texture_footprint = "GL_NV_shader_texture_footprint"; +const char* const E_GL_NV_mesh_shader = "GL_NV_mesh_shader"; + +// Arrays of extensions for the above viewportEXTs duplications + +const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_NV_viewport_array2 }; +const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]); + +const char* const E_GL_NV_cooperative_matrix = "GL_NV_cooperative_matrix"; +const char* const E_GL_NV_shader_sm_builtins = "GL_NV_shader_sm_builtins"; +const char* const E_GL_NV_integer_cooperative_matrix = "GL_NV_integer_cooperative_matrix"; + +// AEP +const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a"; +const char* const E_GL_KHR_blend_equation_advanced = "GL_KHR_blend_equation_advanced"; +const char* const E_GL_OES_sample_variables = "GL_OES_sample_variables"; +const char* const E_GL_OES_shader_image_atomic = "GL_OES_shader_image_atomic"; +const char* const E_GL_OES_shader_multisample_interpolation = "GL_OES_shader_multisample_interpolation"; +const char* const E_GL_OES_texture_storage_multisample_2d_array = "GL_OES_texture_storage_multisample_2d_array"; +const char* const E_GL_EXT_geometry_shader = "GL_EXT_geometry_shader"; +const char* const E_GL_EXT_geometry_point_size = "GL_EXT_geometry_point_size"; +const char* const E_GL_EXT_gpu_shader5 = "GL_EXT_gpu_shader5"; +const char* const E_GL_EXT_primitive_bounding_box = "GL_EXT_primitive_bounding_box"; +const char* const E_GL_EXT_shader_io_blocks = "GL_EXT_shader_io_blocks"; +const char* const E_GL_EXT_tessellation_shader = "GL_EXT_tessellation_shader"; +const char* const E_GL_EXT_tessellation_point_size = "GL_EXT_tessellation_point_size"; +const char* const E_GL_EXT_texture_buffer = "GL_EXT_texture_buffer"; +const char* const E_GL_EXT_texture_cube_map_array = "GL_EXT_texture_cube_map_array"; +const char* const E_GL_EXT_shader_integer_mix = "GL_EXT_shader_integer_mix"; + +// OES matching AEP +const char* const E_GL_OES_geometry_shader = "GL_OES_geometry_shader"; +const char* const E_GL_OES_geometry_point_size = "GL_OES_geometry_point_size"; +const char* const E_GL_OES_gpu_shader5 = "GL_OES_gpu_shader5"; +const char* const E_GL_OES_primitive_bounding_box = "GL_OES_primitive_bounding_box"; +const char* const E_GL_OES_shader_io_blocks = "GL_OES_shader_io_blocks"; +const char* const E_GL_OES_tessellation_shader = "GL_OES_tessellation_shader"; +const char* const E_GL_OES_tessellation_point_size = "GL_OES_tessellation_point_size"; +const char* const E_GL_OES_texture_buffer = "GL_OES_texture_buffer"; +const char* const E_GL_OES_texture_cube_map_array = "GL_OES_texture_cube_map_array"; + +// EXT +const char* const E_GL_EXT_shader_explicit_arithmetic_types = "GL_EXT_shader_explicit_arithmetic_types"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_int8 = "GL_EXT_shader_explicit_arithmetic_types_int8"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_int16 = "GL_EXT_shader_explicit_arithmetic_types_int16"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_int32 = "GL_EXT_shader_explicit_arithmetic_types_int32"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_int64 = "GL_EXT_shader_explicit_arithmetic_types_int64"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_float16 = "GL_EXT_shader_explicit_arithmetic_types_float16"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_float32 = "GL_EXT_shader_explicit_arithmetic_types_float32"; +const char* const E_GL_EXT_shader_explicit_arithmetic_types_float64 = "GL_EXT_shader_explicit_arithmetic_types_float64"; + +const char* const E_GL_EXT_shader_subgroup_extended_types_int8 = "GL_EXT_shader_subgroup_extended_types_int8"; +const char* const E_GL_EXT_shader_subgroup_extended_types_int16 = "GL_EXT_shader_subgroup_extended_types_int16"; +const char* const E_GL_EXT_shader_subgroup_extended_types_int64 = "GL_EXT_shader_subgroup_extended_types_int64"; +const char* const E_GL_EXT_shader_subgroup_extended_types_float16 = "GL_EXT_shader_subgroup_extended_types_float16"; + +// Arrays of extensions for the above AEP duplications + +const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader }; +const int Num_AEP_geometry_shader = sizeof(AEP_geometry_shader)/sizeof(AEP_geometry_shader[0]); + +const char* const AEP_geometry_point_size[] = { E_GL_EXT_geometry_point_size, E_GL_OES_geometry_point_size }; +const int Num_AEP_geometry_point_size = sizeof(AEP_geometry_point_size)/sizeof(AEP_geometry_point_size[0]); + +const char* const AEP_gpu_shader5[] = { E_GL_EXT_gpu_shader5, E_GL_OES_gpu_shader5 }; +const int Num_AEP_gpu_shader5 = sizeof(AEP_gpu_shader5)/sizeof(AEP_gpu_shader5[0]); + +const char* const AEP_primitive_bounding_box[] = { E_GL_EXT_primitive_bounding_box, E_GL_OES_primitive_bounding_box }; +const int Num_AEP_primitive_bounding_box = sizeof(AEP_primitive_bounding_box)/sizeof(AEP_primitive_bounding_box[0]); + +const char* const AEP_shader_io_blocks[] = { E_GL_EXT_shader_io_blocks, E_GL_OES_shader_io_blocks }; +const int Num_AEP_shader_io_blocks = sizeof(AEP_shader_io_blocks)/sizeof(AEP_shader_io_blocks[0]); + +const char* const AEP_tessellation_shader[] = { E_GL_EXT_tessellation_shader, E_GL_OES_tessellation_shader }; +const int Num_AEP_tessellation_shader = sizeof(AEP_tessellation_shader)/sizeof(AEP_tessellation_shader[0]); + +const char* const AEP_tessellation_point_size[] = { E_GL_EXT_tessellation_point_size, E_GL_OES_tessellation_point_size }; +const int Num_AEP_tessellation_point_size = sizeof(AEP_tessellation_point_size)/sizeof(AEP_tessellation_point_size[0]); + +const char* const AEP_texture_buffer[] = { E_GL_EXT_texture_buffer, E_GL_OES_texture_buffer }; +const int Num_AEP_texture_buffer = sizeof(AEP_texture_buffer)/sizeof(AEP_texture_buffer[0]); + +const char* const AEP_texture_cube_map_array[] = { E_GL_EXT_texture_cube_map_array, E_GL_OES_texture_cube_map_array }; +const int Num_AEP_texture_cube_map_array = sizeof(AEP_texture_cube_map_array)/sizeof(AEP_texture_cube_map_array[0]); + +} // end namespace glslang + +#endif // _VERSIONS_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/attribute.h b/ios/include/glslang/MachineIndependent/attribute.h new file mode 100644 index 00000000..38a943d2 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/attribute.h @@ -0,0 +1,149 @@ +// +// Copyright (C) 2017 LunarG, Inc. +// Copyright (C) 2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _ATTRIBUTE_INCLUDED_ +#define _ATTRIBUTE_INCLUDED_ + +#include "../Include/Common.h" +#include "../Include/ConstantUnion.h" + +namespace glslang { + + enum TAttributeType { + EatNone, + EatAllow_uav_condition, + EatBranch, + EatCall, + EatDomain, + EatEarlyDepthStencil, + EatFastOpt, + EatFlatten, + EatForceCase, + EatInstance, + EatMaxTessFactor, + EatNumThreads, + EatMaxVertexCount, + EatOutputControlPoints, + EatOutputTopology, + EatPartitioning, + EatPatchConstantFunc, + EatPatchSize, + EatUnroll, + EatLoop, + EatBinding, + EatGlobalBinding, + EatLocation, + EatInputAttachment, + EatBuiltIn, + EatPushConstant, + EatConstantId, + EatDependencyInfinite, + EatDependencyLength, + EatMinIterations, + EatMaxIterations, + EatIterationMultiple, + EatPeelCount, + EatPartialCount, + EatFormatRgba32f, + EatFormatRgba16f, + EatFormatR32f, + EatFormatRgba8, + EatFormatRgba8Snorm, + EatFormatRg32f, + EatFormatRg16f, + EatFormatR11fG11fB10f, + EatFormatR16f, + EatFormatRgba16, + EatFormatRgb10A2, + EatFormatRg16, + EatFormatRg8, + EatFormatR16, + EatFormatR8, + EatFormatRgba16Snorm, + EatFormatRg16Snorm, + EatFormatRg8Snorm, + EatFormatR16Snorm, + EatFormatR8Snorm, + EatFormatRgba32i, + EatFormatRgba16i, + EatFormatRgba8i, + EatFormatR32i, + EatFormatRg32i, + EatFormatRg16i, + EatFormatRg8i, + EatFormatR16i, + EatFormatR8i, + EatFormatRgba32ui, + EatFormatRgba16ui, + EatFormatRgba8ui, + EatFormatR32ui, + EatFormatRgb10a2ui, + EatFormatRg32ui, + EatFormatRg16ui, + EatFormatRg8ui, + EatFormatR16ui, + EatFormatR8ui, + EatFormatUnknown, + EatNonWritable, + EatNonReadable + }; + + class TIntermAggregate; + + struct TAttributeArgs { + TAttributeType name; + const TIntermAggregate* args; + + // Obtain attribute as integer + // Return false if it cannot be obtained + bool getInt(int& value, int argNum = 0) const; + + // Obtain attribute as string, with optional to-lower transform + // Return false if it cannot be obtained + bool getString(TString& value, int argNum = 0, bool convertToLower = true) const; + + // How many arguments were provided to the attribute? + int size() const; + + protected: + const TConstUnion* getConstUnion(TBasicType basicType, int argNum) const; + }; + + typedef TList TAttributes; + +} // end namespace glslang + +#endif // _ATTRIBUTE_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/gl_types.h b/ios/include/glslang/MachineIndependent/gl_types.h new file mode 100644 index 00000000..b6f613bc --- /dev/null +++ b/ios/include/glslang/MachineIndependent/gl_types.h @@ -0,0 +1,210 @@ +/* +** Copyright (c) 2013 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are 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 Materials. +** +** THE MATERIALS ARE 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 +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#pragma once + +#define GL_FLOAT 0x1406 +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 + +#define GL_DOUBLE 0x140A +#define GL_DOUBLE_VEC2 0x8FFC +#define GL_DOUBLE_VEC3 0x8FFD +#define GL_DOUBLE_VEC4 0x8FFE + +#define GL_INT 0x1404 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 + +#define GL_UNSIGNED_INT 0x1405 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 + +#define GL_INT64_ARB 0x140E +#define GL_INT64_VEC2_ARB 0x8FE9 +#define GL_INT64_VEC3_ARB 0x8FEA +#define GL_INT64_VEC4_ARB 0x8FEB + +#define GL_UNSIGNED_INT64_ARB 0x140F +#define GL_UNSIGNED_INT64_VEC2_ARB 0x8FE5 +#define GL_UNSIGNED_INT64_VEC3_ARB 0x8FE6 +#define GL_UNSIGNED_INT64_VEC4_ARB 0x8FE7 + +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 + +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A + +#define GL_DOUBLE_MAT2 0x8F46 +#define GL_DOUBLE_MAT3 0x8F47 +#define GL_DOUBLE_MAT4 0x8F48 +#define GL_DOUBLE_MAT2x3 0x8F49 +#define GL_DOUBLE_MAT2x4 0x8F4A +#define GL_DOUBLE_MAT3x2 0x8F4B +#define GL_DOUBLE_MAT3x4 0x8F4C +#define GL_DOUBLE_MAT4x2 0x8F4D +#define GL_DOUBLE_MAT4x3 0x8F4E + +// Those constants are borrowed from extension NV_gpu_shader5 +#define GL_FLOAT16_NV 0x8FF8 +#define GL_FLOAT16_VEC2_NV 0x8FF9 +#define GL_FLOAT16_VEC3_NV 0x8FFA +#define GL_FLOAT16_VEC4_NV 0x8FFB + +#define GL_FLOAT16_MAT2_AMD 0x91C5 +#define GL_FLOAT16_MAT3_AMD 0x91C6 +#define GL_FLOAT16_MAT4_AMD 0x91C7 +#define GL_FLOAT16_MAT2x3_AMD 0x91C8 +#define GL_FLOAT16_MAT2x4_AMD 0x91C9 +#define GL_FLOAT16_MAT3x2_AMD 0x91CA +#define GL_FLOAT16_MAT3x4_AMD 0x91CB +#define GL_FLOAT16_MAT4x2_AMD 0x91CC +#define GL_FLOAT16_MAT4x3_AMD 0x91CD + +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_SAMPLER_CUBE_MAP_ARRAY 0x900C +#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D +#define GL_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900C +#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB 0x900D + +#define GL_FLOAT16_SAMPLER_1D_AMD 0x91CE +#define GL_FLOAT16_SAMPLER_2D_AMD 0x91CF +#define GL_FLOAT16_SAMPLER_3D_AMD 0x91D0 +#define GL_FLOAT16_SAMPLER_CUBE_AMD 0x91D1 +#define GL_FLOAT16_SAMPLER_2D_RECT_AMD 0x91D2 +#define GL_FLOAT16_SAMPLER_1D_ARRAY_AMD 0x91D3 +#define GL_FLOAT16_SAMPLER_2D_ARRAY_AMD 0x91D4 +#define GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD 0x91D5 +#define GL_FLOAT16_SAMPLER_BUFFER_AMD 0x91D6 +#define GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD 0x91D7 +#define GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD 0x91D8 + +#define GL_FLOAT16_SAMPLER_1D_SHADOW_AMD 0x91D9 +#define GL_FLOAT16_SAMPLER_2D_SHADOW_AMD 0x91DA +#define GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD 0x91DB +#define GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD 0x91DC +#define GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD 0x91DD +#define GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD 0x91DE +#define GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD 0x91DF + +#define GL_FLOAT16_IMAGE_1D_AMD 0x91E0 +#define GL_FLOAT16_IMAGE_2D_AMD 0x91E1 +#define GL_FLOAT16_IMAGE_3D_AMD 0x91E2 +#define GL_FLOAT16_IMAGE_2D_RECT_AMD 0x91E3 +#define GL_FLOAT16_IMAGE_CUBE_AMD 0x91E4 +#define GL_FLOAT16_IMAGE_1D_ARRAY_AMD 0x91E5 +#define GL_FLOAT16_IMAGE_2D_ARRAY_AMD 0x91E6 +#define GL_FLOAT16_IMAGE_CUBE_MAP_ARRAY_AMD 0x91E7 +#define GL_FLOAT16_IMAGE_BUFFER_AMD 0x91E8 +#define GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD 0x91E9 +#define GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD 0x91EA + +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E +#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900E + +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F +#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900F +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A + +#define GL_IMAGE_1D 0x904C +#define GL_IMAGE_2D 0x904D +#define GL_IMAGE_3D 0x904E +#define GL_IMAGE_2D_RECT 0x904F +#define GL_IMAGE_CUBE 0x9050 +#define GL_IMAGE_BUFFER 0x9051 +#define GL_IMAGE_1D_ARRAY 0x9052 +#define GL_IMAGE_2D_ARRAY 0x9053 +#define GL_IMAGE_CUBE_MAP_ARRAY 0x9054 +#define GL_IMAGE_2D_MULTISAMPLE 0x9055 +#define GL_IMAGE_2D_MULTISAMPLE_ARRAY 0x9056 +#define GL_INT_IMAGE_1D 0x9057 +#define GL_INT_IMAGE_2D 0x9058 +#define GL_INT_IMAGE_3D 0x9059 +#define GL_INT_IMAGE_2D_RECT 0x905A +#define GL_INT_IMAGE_CUBE 0x905B +#define GL_INT_IMAGE_BUFFER 0x905C +#define GL_INT_IMAGE_1D_ARRAY 0x905D +#define GL_INT_IMAGE_2D_ARRAY 0x905E +#define GL_INT_IMAGE_CUBE_MAP_ARRAY 0x905F +#define GL_INT_IMAGE_2D_MULTISAMPLE 0x9060 +#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x9061 +#define GL_UNSIGNED_INT_IMAGE_1D 0x9062 +#define GL_UNSIGNED_INT_IMAGE_2D 0x9063 +#define GL_UNSIGNED_INT_IMAGE_3D 0x9064 +#define GL_UNSIGNED_INT_IMAGE_2D_RECT 0x9065 +#define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066 +#define GL_UNSIGNED_INT_IMAGE_BUFFER 0x9067 +#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY 0x9068 +#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069 +#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE 0x906B +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x906C + +#define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB diff --git a/ios/include/glslang/MachineIndependent/glslang_tab.cpp.h b/ios/include/glslang/MachineIndependent/glslang_tab.cpp.h new file mode 100644 index 00000000..31c8f902 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/glslang_tab.cpp.h @@ -0,0 +1,521 @@ +/* A Bison parser, made by GNU Bison 3.0.4. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED +# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 1 +#endif +#if YYDEBUG +extern int yydebug; +#endif + +/* Token type. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + CONST = 258, + BOOL = 259, + INT = 260, + UINT = 261, + FLOAT = 262, + BVEC2 = 263, + BVEC3 = 264, + BVEC4 = 265, + IVEC2 = 266, + IVEC3 = 267, + IVEC4 = 268, + UVEC2 = 269, + UVEC3 = 270, + UVEC4 = 271, + VEC2 = 272, + VEC3 = 273, + VEC4 = 274, + MAT2 = 275, + MAT3 = 276, + MAT4 = 277, + MAT2X2 = 278, + MAT2X3 = 279, + MAT2X4 = 280, + MAT3X2 = 281, + MAT3X3 = 282, + MAT3X4 = 283, + MAT4X2 = 284, + MAT4X3 = 285, + MAT4X4 = 286, + SAMPLER2D = 287, + SAMPLER3D = 288, + SAMPLERCUBE = 289, + SAMPLER2DSHADOW = 290, + SAMPLERCUBESHADOW = 291, + SAMPLER2DARRAY = 292, + SAMPLER2DARRAYSHADOW = 293, + ISAMPLER2D = 294, + ISAMPLER3D = 295, + ISAMPLERCUBE = 296, + ISAMPLER2DARRAY = 297, + USAMPLER2D = 298, + USAMPLER3D = 299, + USAMPLERCUBE = 300, + USAMPLER2DARRAY = 301, + SAMPLER = 302, + SAMPLERSHADOW = 303, + TEXTURE2D = 304, + TEXTURE3D = 305, + TEXTURECUBE = 306, + TEXTURE2DARRAY = 307, + ITEXTURE2D = 308, + ITEXTURE3D = 309, + ITEXTURECUBE = 310, + ITEXTURE2DARRAY = 311, + UTEXTURE2D = 312, + UTEXTURE3D = 313, + UTEXTURECUBE = 314, + UTEXTURE2DARRAY = 315, + ATTRIBUTE = 316, + VARYING = 317, + FLOAT16_T = 318, + FLOAT32_T = 319, + DOUBLE = 320, + FLOAT64_T = 321, + INT64_T = 322, + UINT64_T = 323, + INT32_T = 324, + UINT32_T = 325, + INT16_T = 326, + UINT16_T = 327, + INT8_T = 328, + UINT8_T = 329, + I64VEC2 = 330, + I64VEC3 = 331, + I64VEC4 = 332, + U64VEC2 = 333, + U64VEC3 = 334, + U64VEC4 = 335, + I32VEC2 = 336, + I32VEC3 = 337, + I32VEC4 = 338, + U32VEC2 = 339, + U32VEC3 = 340, + U32VEC4 = 341, + I16VEC2 = 342, + I16VEC3 = 343, + I16VEC4 = 344, + U16VEC2 = 345, + U16VEC3 = 346, + U16VEC4 = 347, + I8VEC2 = 348, + I8VEC3 = 349, + I8VEC4 = 350, + U8VEC2 = 351, + U8VEC3 = 352, + U8VEC4 = 353, + DVEC2 = 354, + DVEC3 = 355, + DVEC4 = 356, + DMAT2 = 357, + DMAT3 = 358, + DMAT4 = 359, + F16VEC2 = 360, + F16VEC3 = 361, + F16VEC4 = 362, + F16MAT2 = 363, + F16MAT3 = 364, + F16MAT4 = 365, + F32VEC2 = 366, + F32VEC3 = 367, + F32VEC4 = 368, + F32MAT2 = 369, + F32MAT3 = 370, + F32MAT4 = 371, + F64VEC2 = 372, + F64VEC3 = 373, + F64VEC4 = 374, + F64MAT2 = 375, + F64MAT3 = 376, + F64MAT4 = 377, + DMAT2X2 = 378, + DMAT2X3 = 379, + DMAT2X4 = 380, + DMAT3X2 = 381, + DMAT3X3 = 382, + DMAT3X4 = 383, + DMAT4X2 = 384, + DMAT4X3 = 385, + DMAT4X4 = 386, + F16MAT2X2 = 387, + F16MAT2X3 = 388, + F16MAT2X4 = 389, + F16MAT3X2 = 390, + F16MAT3X3 = 391, + F16MAT3X4 = 392, + F16MAT4X2 = 393, + F16MAT4X3 = 394, + F16MAT4X4 = 395, + F32MAT2X2 = 396, + F32MAT2X3 = 397, + F32MAT2X4 = 398, + F32MAT3X2 = 399, + F32MAT3X3 = 400, + F32MAT3X4 = 401, + F32MAT4X2 = 402, + F32MAT4X3 = 403, + F32MAT4X4 = 404, + F64MAT2X2 = 405, + F64MAT2X3 = 406, + F64MAT2X4 = 407, + F64MAT3X2 = 408, + F64MAT3X3 = 409, + F64MAT3X4 = 410, + F64MAT4X2 = 411, + F64MAT4X3 = 412, + F64MAT4X4 = 413, + ATOMIC_UINT = 414, + ACCSTRUCTNV = 415, + ACCSTRUCTEXT = 416, + RAYQUERYEXT = 417, + FCOOPMATNV = 418, + ICOOPMATNV = 419, + UCOOPMATNV = 420, + SAMPLERCUBEARRAY = 421, + SAMPLERCUBEARRAYSHADOW = 422, + ISAMPLERCUBEARRAY = 423, + USAMPLERCUBEARRAY = 424, + SAMPLER1D = 425, + SAMPLER1DARRAY = 426, + SAMPLER1DARRAYSHADOW = 427, + ISAMPLER1D = 428, + SAMPLER1DSHADOW = 429, + SAMPLER2DRECT = 430, + SAMPLER2DRECTSHADOW = 431, + ISAMPLER2DRECT = 432, + USAMPLER2DRECT = 433, + SAMPLERBUFFER = 434, + ISAMPLERBUFFER = 435, + USAMPLERBUFFER = 436, + SAMPLER2DMS = 437, + ISAMPLER2DMS = 438, + USAMPLER2DMS = 439, + SAMPLER2DMSARRAY = 440, + ISAMPLER2DMSARRAY = 441, + USAMPLER2DMSARRAY = 442, + SAMPLEREXTERNALOES = 443, + SAMPLEREXTERNAL2DY2YEXT = 444, + ISAMPLER1DARRAY = 445, + USAMPLER1D = 446, + USAMPLER1DARRAY = 447, + F16SAMPLER1D = 448, + F16SAMPLER2D = 449, + F16SAMPLER3D = 450, + F16SAMPLER2DRECT = 451, + F16SAMPLERCUBE = 452, + F16SAMPLER1DARRAY = 453, + F16SAMPLER2DARRAY = 454, + F16SAMPLERCUBEARRAY = 455, + F16SAMPLERBUFFER = 456, + F16SAMPLER2DMS = 457, + F16SAMPLER2DMSARRAY = 458, + F16SAMPLER1DSHADOW = 459, + F16SAMPLER2DSHADOW = 460, + F16SAMPLER1DARRAYSHADOW = 461, + F16SAMPLER2DARRAYSHADOW = 462, + F16SAMPLER2DRECTSHADOW = 463, + F16SAMPLERCUBESHADOW = 464, + F16SAMPLERCUBEARRAYSHADOW = 465, + IMAGE1D = 466, + IIMAGE1D = 467, + UIMAGE1D = 468, + IMAGE2D = 469, + IIMAGE2D = 470, + UIMAGE2D = 471, + IMAGE3D = 472, + IIMAGE3D = 473, + UIMAGE3D = 474, + IMAGE2DRECT = 475, + IIMAGE2DRECT = 476, + UIMAGE2DRECT = 477, + IMAGECUBE = 478, + IIMAGECUBE = 479, + UIMAGECUBE = 480, + IMAGEBUFFER = 481, + IIMAGEBUFFER = 482, + UIMAGEBUFFER = 483, + IMAGE1DARRAY = 484, + IIMAGE1DARRAY = 485, + UIMAGE1DARRAY = 486, + IMAGE2DARRAY = 487, + IIMAGE2DARRAY = 488, + UIMAGE2DARRAY = 489, + IMAGECUBEARRAY = 490, + IIMAGECUBEARRAY = 491, + UIMAGECUBEARRAY = 492, + IMAGE2DMS = 493, + IIMAGE2DMS = 494, + UIMAGE2DMS = 495, + IMAGE2DMSARRAY = 496, + IIMAGE2DMSARRAY = 497, + UIMAGE2DMSARRAY = 498, + F16IMAGE1D = 499, + F16IMAGE2D = 500, + F16IMAGE3D = 501, + F16IMAGE2DRECT = 502, + F16IMAGECUBE = 503, + F16IMAGE1DARRAY = 504, + F16IMAGE2DARRAY = 505, + F16IMAGECUBEARRAY = 506, + F16IMAGEBUFFER = 507, + F16IMAGE2DMS = 508, + F16IMAGE2DMSARRAY = 509, + TEXTURECUBEARRAY = 510, + ITEXTURECUBEARRAY = 511, + UTEXTURECUBEARRAY = 512, + TEXTURE1D = 513, + ITEXTURE1D = 514, + UTEXTURE1D = 515, + TEXTURE1DARRAY = 516, + ITEXTURE1DARRAY = 517, + UTEXTURE1DARRAY = 518, + TEXTURE2DRECT = 519, + ITEXTURE2DRECT = 520, + UTEXTURE2DRECT = 521, + TEXTUREBUFFER = 522, + ITEXTUREBUFFER = 523, + UTEXTUREBUFFER = 524, + TEXTURE2DMS = 525, + ITEXTURE2DMS = 526, + UTEXTURE2DMS = 527, + TEXTURE2DMSARRAY = 528, + ITEXTURE2DMSARRAY = 529, + UTEXTURE2DMSARRAY = 530, + F16TEXTURE1D = 531, + F16TEXTURE2D = 532, + F16TEXTURE3D = 533, + F16TEXTURE2DRECT = 534, + F16TEXTURECUBE = 535, + F16TEXTURE1DARRAY = 536, + F16TEXTURE2DARRAY = 537, + F16TEXTURECUBEARRAY = 538, + F16TEXTUREBUFFER = 539, + F16TEXTURE2DMS = 540, + F16TEXTURE2DMSARRAY = 541, + SUBPASSINPUT = 542, + SUBPASSINPUTMS = 543, + ISUBPASSINPUT = 544, + ISUBPASSINPUTMS = 545, + USUBPASSINPUT = 546, + USUBPASSINPUTMS = 547, + F16SUBPASSINPUT = 548, + F16SUBPASSINPUTMS = 549, + LEFT_OP = 550, + RIGHT_OP = 551, + INC_OP = 552, + DEC_OP = 553, + LE_OP = 554, + GE_OP = 555, + EQ_OP = 556, + NE_OP = 557, + AND_OP = 558, + OR_OP = 559, + XOR_OP = 560, + MUL_ASSIGN = 561, + DIV_ASSIGN = 562, + ADD_ASSIGN = 563, + MOD_ASSIGN = 564, + LEFT_ASSIGN = 565, + RIGHT_ASSIGN = 566, + AND_ASSIGN = 567, + XOR_ASSIGN = 568, + OR_ASSIGN = 569, + SUB_ASSIGN = 570, + STRING_LITERAL = 571, + LEFT_PAREN = 572, + RIGHT_PAREN = 573, + LEFT_BRACKET = 574, + RIGHT_BRACKET = 575, + LEFT_BRACE = 576, + RIGHT_BRACE = 577, + DOT = 578, + COMMA = 579, + COLON = 580, + EQUAL = 581, + SEMICOLON = 582, + BANG = 583, + DASH = 584, + TILDE = 585, + PLUS = 586, + STAR = 587, + SLASH = 588, + PERCENT = 589, + LEFT_ANGLE = 590, + RIGHT_ANGLE = 591, + VERTICAL_BAR = 592, + CARET = 593, + AMPERSAND = 594, + QUESTION = 595, + INVARIANT = 596, + HIGH_PRECISION = 597, + MEDIUM_PRECISION = 598, + LOW_PRECISION = 599, + PRECISION = 600, + PACKED = 601, + RESOURCE = 602, + SUPERP = 603, + FLOATCONSTANT = 604, + INTCONSTANT = 605, + UINTCONSTANT = 606, + BOOLCONSTANT = 607, + IDENTIFIER = 608, + TYPE_NAME = 609, + CENTROID = 610, + IN = 611, + OUT = 612, + INOUT = 613, + STRUCT = 614, + VOID = 615, + WHILE = 616, + BREAK = 617, + CONTINUE = 618, + DO = 619, + ELSE = 620, + FOR = 621, + IF = 622, + DISCARD = 623, + RETURN = 624, + SWITCH = 625, + CASE = 626, + DEFAULT = 627, + UNIFORM = 628, + SHARED = 629, + BUFFER = 630, + FLAT = 631, + SMOOTH = 632, + LAYOUT = 633, + DOUBLECONSTANT = 634, + INT16CONSTANT = 635, + UINT16CONSTANT = 636, + FLOAT16CONSTANT = 637, + INT32CONSTANT = 638, + UINT32CONSTANT = 639, + INT64CONSTANT = 640, + UINT64CONSTANT = 641, + SUBROUTINE = 642, + DEMOTE = 643, + PAYLOADNV = 644, + PAYLOADINNV = 645, + HITATTRNV = 646, + CALLDATANV = 647, + CALLDATAINNV = 648, + PAYLOADEXT = 649, + PAYLOADINEXT = 650, + HITATTREXT = 651, + CALLDATAEXT = 652, + CALLDATAINEXT = 653, + PATCH = 654, + SAMPLE = 655, + NONUNIFORM = 656, + COHERENT = 657, + VOLATILE = 658, + RESTRICT = 659, + READONLY = 660, + WRITEONLY = 661, + DEVICECOHERENT = 662, + QUEUEFAMILYCOHERENT = 663, + WORKGROUPCOHERENT = 664, + SUBGROUPCOHERENT = 665, + NONPRIVATE = 666, + SHADERCALLCOHERENT = 667, + NOPERSPECTIVE = 668, + EXPLICITINTERPAMD = 669, + PERVERTEXNV = 670, + PERPRIMITIVENV = 671, + PERVIEWNV = 672, + PERTASKNV = 673, + PRECISE = 674 + }; +#endif + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED + +union YYSTYPE +{ +#line 97 "glslang.y" /* yacc.c:1909 */ + + struct { + glslang::TSourceLoc loc; + union { + glslang::TString *string; + int i; + unsigned int u; + long long i64; + unsigned long long u64; + bool b; + double d; + }; + glslang::TSymbol* symbol; + } lex; + struct { + glslang::TSourceLoc loc; + glslang::TOperator op; + union { + TIntermNode* intermNode; + glslang::TIntermNodePair nodePair; + glslang::TIntermTyped* intermTypedNode; + glslang::TAttributes* attributes; + }; + union { + glslang::TPublicType type; + glslang::TFunction* function; + glslang::TParameter param; + glslang::TTypeLoc typeLine; + glslang::TTypeList* typeList; + glslang::TArraySizes* arraySizes; + glslang::TIdentifierList* identifierList; + }; + glslang::TArraySizes* typeParameters; + } interm; + +#line 510 "glslang_tab.cpp.h" /* yacc.c:1909 */ +}; + +typedef union YYSTYPE YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + + +int yyparse (glslang::TParseContext* pParseContext); + +#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED */ diff --git a/ios/include/glslang/MachineIndependent/iomapper.h b/ios/include/glslang/MachineIndependent/iomapper.h new file mode 100644 index 00000000..7ca18b8a --- /dev/null +++ b/ios/include/glslang/MachineIndependent/iomapper.h @@ -0,0 +1,302 @@ +// +// Copyright (C) 2016 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef GLSLANG_WEB + +#ifndef _IOMAPPER_INCLUDED +#define _IOMAPPER_INCLUDED + +#include +#include "LiveTraverser.h" +#include +#include +// +// A reflection database and its interface, consistent with the OpenGL API reflection queries. +// + +class TInfoSink; + +namespace glslang { + +class TIntermediate; +struct TVarEntryInfo { + int id; + TIntermSymbol* symbol; + bool live; + int newBinding; + int newSet; + int newLocation; + int newComponent; + int newIndex; + EShLanguage stage; + struct TOrderById { + inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) { return l.id < r.id; } + }; + + struct TOrderByPriority { + // ordering: + // 1) has both binding and set + // 2) has binding but no set + // 3) has no binding but set + // 4) has no binding and no set + inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) { + const TQualifier& lq = l.symbol->getQualifier(); + const TQualifier& rq = r.symbol->getQualifier(); + + // simple rules: + // has binding gives 2 points + // has set gives 1 point + // who has the most points is more important. + int lPoints = (lq.hasBinding() ? 2 : 0) + (lq.hasSet() ? 1 : 0); + int rPoints = (rq.hasBinding() ? 2 : 0) + (rq.hasSet() ? 1 : 0); + + if (lPoints == rPoints) + return l.id < r.id; + return lPoints > rPoints; + } + }; +}; + +// Base class for shared TIoMapResolver services, used by several derivations. +struct TDefaultIoResolverBase : public glslang::TIoMapResolver { +public: + TDefaultIoResolverBase(const TIntermediate& intermediate); + typedef std::vector TSlotSet; + typedef std::unordered_map TSlotSetMap; + + // grow the reflection stage by stage + void notifyBinding(EShLanguage, TVarEntryInfo& /*ent*/) override {} + void notifyInOut(EShLanguage, TVarEntryInfo& /*ent*/) override {} + void beginNotifications(EShLanguage) override {} + void endNotifications(EShLanguage) override {} + void beginResolve(EShLanguage) override {} + void endResolve(EShLanguage) override {} + void beginCollect(EShLanguage) override {} + void endCollect(EShLanguage) override {} + void reserverResourceSlot(TVarEntryInfo& /*ent*/, TInfoSink& /*infoSink*/) override {} + void reserverStorageSlot(TVarEntryInfo& /*ent*/, TInfoSink& /*infoSink*/) override {} + int getBaseBinding(TResourceType res, unsigned int set) const; + const std::vector& getResourceSetBinding() const; + virtual TResourceType getResourceType(const glslang::TType& type) = 0; + bool doAutoBindingMapping() const; + bool doAutoLocationMapping() const; + TSlotSet::iterator findSlot(int set, int slot); + bool checkEmpty(int set, int slot); + bool validateInOut(EShLanguage /*stage*/, TVarEntryInfo& /*ent*/) override { return true; } + int reserveSlot(int set, int slot, int size = 1); + int getFreeSlot(int set, int base, int size = 1); + int resolveSet(EShLanguage /*stage*/, TVarEntryInfo& ent) override; + int resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) override; + int resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) override; + int resolveInOutComponent(EShLanguage /*stage*/, TVarEntryInfo& ent) override; + int resolveInOutIndex(EShLanguage /*stage*/, TVarEntryInfo& ent) override; + void addStage(EShLanguage stage) override { + if (stage < EShLangCount) + stageMask[stage] = true; + } + uint32_t computeTypeLocationSize(const TType& type, EShLanguage stage); + + TSlotSetMap slots; + bool hasError = false; + +protected: + TDefaultIoResolverBase(TDefaultIoResolverBase&); + TDefaultIoResolverBase& operator=(TDefaultIoResolverBase&); + const TIntermediate& intermediate; + int nextUniformLocation; + int nextInputLocation; + int nextOutputLocation; + bool stageMask[EShLangCount + 1]; + // Return descriptor set specific base if there is one, and the generic base otherwise. + int selectBaseBinding(int base, int descriptorSetBase) const { + return descriptorSetBase != -1 ? descriptorSetBase : base; + } + + static int getLayoutSet(const glslang::TType& type) { + if (type.getQualifier().hasSet()) + return type.getQualifier().layoutSet; + else + return 0; + } + + static bool isSamplerType(const glslang::TType& type) { + return type.getBasicType() == glslang::EbtSampler && type.getSampler().isPureSampler(); + } + + static bool isTextureType(const glslang::TType& type) { + return (type.getBasicType() == glslang::EbtSampler && + (type.getSampler().isTexture() || type.getSampler().isSubpass())); + } + + static bool isUboType(const glslang::TType& type) { + return type.getQualifier().storage == EvqUniform; + } + + static bool isImageType(const glslang::TType& type) { + return type.getBasicType() == glslang::EbtSampler && type.getSampler().isImage(); + } + + static bool isSsboType(const glslang::TType& type) { + return type.getQualifier().storage == EvqBuffer; + } + + // Return true if this is a SRV (shader resource view) type: + static bool isSrvType(const glslang::TType& type) { + return isTextureType(type) || type.getQualifier().storage == EvqBuffer; + } + + // Return true if this is a UAV (unordered access view) type: + static bool isUavType(const glslang::TType& type) { + if (type.getQualifier().isReadOnly()) + return false; + return (type.getBasicType() == glslang::EbtSampler && type.getSampler().isImage()) || + (type.getQualifier().storage == EvqBuffer); + } +}; + +// Defaulf I/O resolver for OpenGL +struct TDefaultGlslIoResolver : public TDefaultIoResolverBase { +public: + typedef std::map TVarSlotMap; // + typedef std::map TSlotMap; // + TDefaultGlslIoResolver(const TIntermediate& intermediate); + bool validateBinding(EShLanguage /*stage*/, TVarEntryInfo& /*ent*/) override { return true; } + TResourceType getResourceType(const glslang::TType& type) override; + int resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) override; + int resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) override; + int resolveBinding(EShLanguage /*stage*/, TVarEntryInfo& ent) override; + void beginResolve(EShLanguage /*stage*/) override; + void endResolve(EShLanguage stage) override; + void beginCollect(EShLanguage) override; + void endCollect(EShLanguage) override; + void reserverStorageSlot(TVarEntryInfo& ent, TInfoSink& infoSink) override; + void reserverResourceSlot(TVarEntryInfo& ent, TInfoSink& infoSink) override; + const TString& getAccessName(const TIntermSymbol*); + // in/out symbol and uniform symbol are stored in the same resourceSlotMap, the storage key is used to identify each type of symbol. + // We use stage and storage qualifier to construct a storage key. it can help us identify the same storage resource used in different stage. + // if a resource is a program resource and we don't need know it usage stage, we can use same stage to build storage key. + // Note: both stage and type must less then 0xffff. + int buildStorageKey(EShLanguage stage, TStorageQualifier type) { + assert(static_cast(stage) <= 0x0000ffff && static_cast(type) <= 0x0000ffff); + return (stage << 16) | type; + } + +protected: + // Use for mark pre stage, to get more interface symbol information. + EShLanguage preStage; + // Use for mark current shader stage for resolver + EShLanguage currentStage; + // Slot map for storage resource(location of uniform and interface symbol) It's a program share slot + TSlotMap resourceSlotMap; + // Slot map for other resource(image, ubo, ssbo), It's a program share slot. + TSlotMap storageSlotMap; +}; + +typedef std::map TVarLiveMap; + +// override function "operator=", if a vector being sort, +// when use vc++, the sort function will call : +// pair& operator=(const pair<_Other1, _Other2>& _Right) +// { +// first = _Right.first; +// second = _Right.second; +// return (*this); +// } +// that will make a const type handing on left. +// override this function can avoid a compiler error. +// In the future, if the vc++ compiler can handle such a situation, +// this part of the code will be removed. +struct TVarLivePair : std::pair { + TVarLivePair(const std::pair& _Right) : pair(_Right.first, _Right.second) {} + TVarLivePair& operator=(const TVarLivePair& _Right) { + const_cast(first) = _Right.first; + second = _Right.second; + return (*this); + } + TVarLivePair(const TVarLivePair& src) : pair(src) { } +}; +typedef std::vector TVarLiveVector; + +// I/O mapper +class TIoMapper { +public: + TIoMapper() {} + virtual ~TIoMapper() {} + // grow the reflection stage by stage + bool virtual addStage(EShLanguage, TIntermediate&, TInfoSink&, TIoMapResolver*); + bool virtual doMap(TIoMapResolver*, TInfoSink&) { return true; } +}; + +// I/O mapper for OpenGL +class TGlslIoMapper : public TIoMapper { +public: + TGlslIoMapper() { + memset(inVarMaps, 0, sizeof(TVarLiveMap*) * EShLangCount); + memset(outVarMaps, 0, sizeof(TVarLiveMap*) * EShLangCount); + memset(uniformVarMap, 0, sizeof(TVarLiveMap*) * EShLangCount); + memset(intermediates, 0, sizeof(TIntermediate*) * EShLangCount); + } + virtual ~TGlslIoMapper() { + for (size_t stage = 0; stage < EShLangCount; stage++) { + if (inVarMaps[stage] != nullptr) { + delete inVarMaps[stage]; + inVarMaps[stage] = nullptr; + } + if (outVarMaps[stage] != nullptr) { + delete outVarMaps[stage]; + outVarMaps[stage] = nullptr; + } + if (uniformVarMap[stage] != nullptr) { + delete uniformVarMap[stage]; + uniformVarMap[stage] = nullptr; + } + if (intermediates[stage] != nullptr) + intermediates[stage] = nullptr; + } + } + // grow the reflection stage by stage + bool addStage(EShLanguage, TIntermediate&, TInfoSink&, TIoMapResolver*) override; + bool doMap(TIoMapResolver*, TInfoSink&) override; + TVarLiveMap *inVarMaps[EShLangCount], *outVarMaps[EShLangCount], + *uniformVarMap[EShLangCount]; + TIntermediate* intermediates[EShLangCount]; + bool hadError = false; +}; + +} // end namespace glslang + +#endif // _IOMAPPER_INCLUDED + +#endif // GLSLANG_WEB diff --git a/ios/include/glslang/MachineIndependent/localintermediate.h b/ios/include/glslang/MachineIndependent/localintermediate.h new file mode 100644 index 00000000..a3ff8868 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/localintermediate.h @@ -0,0 +1,1030 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2016 LunarG, Inc. +// Copyright (C) 2017 ARM Limited. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _LOCAL_INTERMEDIATE_INCLUDED_ +#define _LOCAL_INTERMEDIATE_INCLUDED_ + +#include "../Include/intermediate.h" +#include "../Public/ShaderLang.h" +#include "Versions.h" + +#include +#include +#include +#include +#include + +class TInfoSink; + +namespace glslang { + +struct TMatrixSelector { + int coord1; // stay agnostic about column/row; this is parse order + int coord2; +}; + +typedef int TVectorSelector; + +const int MaxSwizzleSelectors = 4; + +template +class TSwizzleSelectors { +public: + TSwizzleSelectors() : size_(0) { } + + void push_back(selectorType comp) + { + if (size_ < MaxSwizzleSelectors) + components[size_++] = comp; + } + void resize(int s) + { + assert(s <= size_); + size_ = s; + } + int size() const { return size_; } + selectorType operator[](int i) const + { + assert(i < MaxSwizzleSelectors); + return components[i]; + } + +private: + int size_; + selectorType components[MaxSwizzleSelectors]; +}; + +// +// Some helper structures for TIntermediate. Their contents are encapsulated +// by TIntermediate. +// + +// Used for call-graph algorithms for detecting recursion, missing bodies, and dead bodies. +// A "call" is a pair: . +// There can be duplicates. General assumption is the list is small. +struct TCall { + TCall(const TString& pCaller, const TString& pCallee) : caller(pCaller), callee(pCallee) { } + TString caller; + TString callee; + bool visited; + bool currentPath; + bool errorGiven; + int calleeBodyPosition; +}; + +// A generic 1-D range. +struct TRange { + TRange(int start, int last) : start(start), last(last) { } + bool overlap(const TRange& rhs) const + { + return last >= rhs.start && start <= rhs.last; + } + int start; + int last; +}; + +// An IO range is a 3-D rectangle; the set of (location, component, index) triples all lying +// within the same location range, component range, and index value. Locations don't alias unless +// all other dimensions of their range overlap. +struct TIoRange { + TIoRange(TRange location, TRange component, TBasicType basicType, int index) + : location(location), component(component), basicType(basicType), index(index) { } + bool overlap(const TIoRange& rhs) const + { + return location.overlap(rhs.location) && component.overlap(rhs.component) && index == rhs.index; + } + TRange location; + TRange component; + TBasicType basicType; + int index; +}; + +// An offset range is a 2-D rectangle; the set of (binding, offset) pairs all lying +// within the same binding and offset range. +struct TOffsetRange { + TOffsetRange(TRange binding, TRange offset) + : binding(binding), offset(offset) { } + bool overlap(const TOffsetRange& rhs) const + { + return binding.overlap(rhs.binding) && offset.overlap(rhs.offset); + } + TRange binding; + TRange offset; +}; + +#ifndef GLSLANG_WEB +// Things that need to be tracked per xfb buffer. +struct TXfbBuffer { + TXfbBuffer() : stride(TQualifier::layoutXfbStrideEnd), implicitStride(0), contains64BitType(false), + contains32BitType(false), contains16BitType(false) { } + std::vector ranges; // byte offsets that have already been assigned + unsigned int stride; + unsigned int implicitStride; + bool contains64BitType; + bool contains32BitType; + bool contains16BitType; +}; +#endif + +// Track a set of strings describing how the module was processed. +// This includes command line options, transforms, etc., ideally inclusive enough +// to reproduce the steps used to transform the input source to the output. +// E.g., see SPIR-V OpModuleProcessed. +// Each "process" or "transform" uses is expressed in the form: +// process arg0 arg1 arg2 ... +// process arg0 arg1 arg2 ... +// where everything is textual, and there can be zero or more arguments +class TProcesses { +public: + TProcesses() {} + ~TProcesses() {} + + void addProcess(const char* process) + { + processes.push_back(process); + } + void addProcess(const std::string& process) + { + processes.push_back(process); + } + void addArgument(int arg) + { + processes.back().append(" "); + std::string argString = std::to_string(arg); + processes.back().append(argString); + } + void addArgument(const char* arg) + { + processes.back().append(" "); + processes.back().append(arg); + } + void addArgument(const std::string& arg) + { + processes.back().append(" "); + processes.back().append(arg); + } + void addIfNonZero(const char* process, int value) + { + if (value != 0) { + addProcess(process); + addArgument(value); + } + } + + const std::vector& getProcesses() const { return processes; } + +private: + std::vector processes; +}; + +class TSymbolTable; +class TSymbol; +class TVariable; + +// +// Texture and Sampler transformation mode. +// +enum ComputeDerivativeMode { + LayoutDerivativeNone, // default layout as SPV_NV_compute_shader_derivatives not enabled + LayoutDerivativeGroupQuads, // derivative_group_quadsNV + LayoutDerivativeGroupLinear, // derivative_group_linearNV +}; + +class TIdMaps { +public: + TMap& operator[](int i) { return maps[i]; } + const TMap& operator[](int i) const { return maps[i]; } +private: + TMap maps[EsiCount]; +}; + + +// +// Set of helper functions to help parse and build the tree. +// +class TIntermediate { +public: + explicit TIntermediate(EShLanguage l, int v = 0, EProfile p = ENoProfile) : + language(l), + profile(p), version(v), treeRoot(0), + numEntryPoints(0), numErrors(0), numPushConstants(0), recursive(false), + invertY(false), + useStorageBuffer(false), + nanMinMaxClamp(false), + depthReplacing(false) +#ifndef GLSLANG_WEB + , + implicitThisName("@this"), implicitCounterName("@count"), + source(EShSourceNone), + useVulkanMemoryModel(false), + invocations(TQualifier::layoutNotSet), vertices(TQualifier::layoutNotSet), + inputPrimitive(ElgNone), outputPrimitive(ElgNone), + pixelCenterInteger(false), originUpperLeft(false), + vertexSpacing(EvsNone), vertexOrder(EvoNone), interlockOrdering(EioNone), pointMode(false), earlyFragmentTests(false), + postDepthCoverage(false), depthLayout(EldNone), + hlslFunctionality1(false), + blendEquations(0), xfbMode(false), multiStream(false), + layoutOverrideCoverage(false), + geoPassthroughEXT(false), + numShaderRecordBlocks(0), + computeDerivativeMode(LayoutDerivativeNone), + primitives(TQualifier::layoutNotSet), + numTaskNVBlocks(0), + layoutPrimitiveCulling(false), + autoMapBindings(false), + autoMapLocations(false), + flattenUniformArrays(false), + useUnknownFormat(false), + hlslOffsets(false), + hlslIoMapping(false), + useVariablePointers(false), + textureSamplerTransformMode(EShTexSampTransKeep), + needToLegalize(false), + binaryDoubleOutput(false), + usePhysicalStorageBuffer(false), + uniformLocationBase(0) +#endif + { + localSize[0] = 1; + localSize[1] = 1; + localSize[2] = 1; + localSizeNotDefault[0] = false; + localSizeNotDefault[1] = false; + localSizeNotDefault[2] = false; + localSizeSpecId[0] = TQualifier::layoutNotSet; + localSizeSpecId[1] = TQualifier::layoutNotSet; + localSizeSpecId[2] = TQualifier::layoutNotSet; +#ifndef GLSLANG_WEB + xfbBuffers.resize(TQualifier::layoutXfbBufferEnd); + shiftBinding.fill(0); +#endif + } + + void setVersion(int v) { version = v; } + int getVersion() const { return version; } + void setProfile(EProfile p) { profile = p; } + EProfile getProfile() const { return profile; } + void setSpv(const SpvVersion& s) + { + spvVersion = s; + + // client processes + if (spvVersion.vulkan > 0) + processes.addProcess("client vulkan100"); + if (spvVersion.openGl > 0) + processes.addProcess("client opengl100"); + + // target SPV + switch (spvVersion.spv) { + case 0: + break; + case EShTargetSpv_1_0: + break; + case EShTargetSpv_1_1: + processes.addProcess("target-env spirv1.1"); + break; + case EShTargetSpv_1_2: + processes.addProcess("target-env spirv1.2"); + break; + case EShTargetSpv_1_3: + processes.addProcess("target-env spirv1.3"); + break; + case EShTargetSpv_1_4: + processes.addProcess("target-env spirv1.4"); + break; + case EShTargetSpv_1_5: + processes.addProcess("target-env spirv1.5"); + break; + default: + processes.addProcess("target-env spirvUnknown"); + break; + } + + // target-environment processes + switch (spvVersion.vulkan) { + case 0: + break; + case EShTargetVulkan_1_0: + processes.addProcess("target-env vulkan1.0"); + break; + case EShTargetVulkan_1_1: + processes.addProcess("target-env vulkan1.1"); + break; + case EShTargetVulkan_1_2: + processes.addProcess("target-env vulkan1.2"); + break; + default: + processes.addProcess("target-env vulkanUnknown"); + break; + } + if (spvVersion.openGl > 0) + processes.addProcess("target-env opengl"); + } + const SpvVersion& getSpv() const { return spvVersion; } + EShLanguage getStage() const { return language; } + void updateRequestedExtension(const char* extension, TExtensionBehavior behavior) { + if(requestedExtensions.find(extension) != requestedExtensions.end()) { + requestedExtensions[extension] = behavior; + } else { + requestedExtensions.insert(std::make_pair(extension, behavior)); + } + } + + const std::map& getRequestedExtensions() const { return requestedExtensions; } + + void setTreeRoot(TIntermNode* r) { treeRoot = r; } + TIntermNode* getTreeRoot() const { return treeRoot; } + void incrementEntryPointCount() { ++numEntryPoints; } + int getNumEntryPoints() const { return numEntryPoints; } + int getNumErrors() const { return numErrors; } + void addPushConstantCount() { ++numPushConstants; } + void setLimits(const TBuiltInResource& r) { resources = r; } + + bool postProcess(TIntermNode*, EShLanguage); + void removeTree(); + + void setEntryPointName(const char* ep) + { + entryPointName = ep; + processes.addProcess("entry-point"); + processes.addArgument(entryPointName); + } + void setEntryPointMangledName(const char* ep) { entryPointMangledName = ep; } + const std::string& getEntryPointName() const { return entryPointName; } + const std::string& getEntryPointMangledName() const { return entryPointMangledName; } + + void setInvertY(bool invert) + { + invertY = invert; + if (invertY) + processes.addProcess("invert-y"); + } + bool getInvertY() const { return invertY; } + +#ifdef ENABLE_HLSL + void setSource(EShSource s) { source = s; } + EShSource getSource() const { return source; } +#else + void setSource(EShSource s) { assert(s == EShSourceGlsl); (void)s; } + EShSource getSource() const { return EShSourceGlsl; } +#endif + + bool isRecursive() const { return recursive; } + + TIntermSymbol* addSymbol(const TVariable&); + TIntermSymbol* addSymbol(const TVariable&, const TSourceLoc&); + TIntermSymbol* addSymbol(const TType&, const TSourceLoc&); + TIntermSymbol* addSymbol(const TIntermSymbol&); + TIntermTyped* addConversion(TOperator, const TType&, TIntermTyped*); + std::tuple addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* node1); + TIntermTyped* addUniShapeConversion(TOperator, const TType&, TIntermTyped*); + TIntermTyped* addConversion(TBasicType convertTo, TIntermTyped* node) const; + void addBiShapeConversion(TOperator, TIntermTyped*& lhsNode, TIntermTyped*& rhsNode); + TIntermTyped* addShapeConversion(const TType&, TIntermTyped*); + TIntermTyped* addBinaryMath(TOperator, TIntermTyped* left, TIntermTyped* right, TSourceLoc); + TIntermTyped* addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc); + TIntermTyped* addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, TSourceLoc); + TIntermTyped* addUnaryMath(TOperator, TIntermTyped* child, TSourceLoc); + TIntermTyped* addBuiltInFunctionCall(const TSourceLoc& line, TOperator, bool unary, TIntermNode*, const TType& returnType); + bool canImplicitlyPromote(TBasicType from, TBasicType to, TOperator op = EOpNull) const; + bool isIntegralPromotion(TBasicType from, TBasicType to) const; + bool isFPPromotion(TBasicType from, TBasicType to) const; + bool isIntegralConversion(TBasicType from, TBasicType to) const; + bool isFPConversion(TBasicType from, TBasicType to) const; + bool isFPIntegralConversion(TBasicType from, TBasicType to) const; + TOperator mapTypeToConstructorOp(const TType&) const; + TIntermAggregate* growAggregate(TIntermNode* left, TIntermNode* right); + TIntermAggregate* growAggregate(TIntermNode* left, TIntermNode* right, const TSourceLoc&); + TIntermAggregate* makeAggregate(TIntermNode* node); + TIntermAggregate* makeAggregate(TIntermNode* node, const TSourceLoc&); + TIntermAggregate* makeAggregate(const TSourceLoc&); + TIntermTyped* setAggregateOperator(TIntermNode*, TOperator, const TType& type, TSourceLoc); + bool areAllChildConst(TIntermAggregate* aggrNode); + TIntermSelection* addSelection(TIntermTyped* cond, TIntermNodePair code, const TSourceLoc&); + TIntermTyped* addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, const TSourceLoc&); + TIntermTyped* addComma(TIntermTyped* left, TIntermTyped* right, const TSourceLoc&); + TIntermTyped* addMethod(TIntermTyped*, const TType&, const TString*, const TSourceLoc&); + TIntermConstantUnion* addConstantUnion(const TConstUnionArray&, const TType&, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(signed char, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(unsigned char, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(signed short, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(unsigned short, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(int, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(unsigned int, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(long long, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(unsigned long long, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(bool, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(double, TBasicType, const TSourceLoc&, bool literal = false) const; + TIntermConstantUnion* addConstantUnion(const TString*, const TSourceLoc&, bool literal = false) const; + TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) const; + bool parseConstTree(TIntermNode*, TConstUnionArray, TOperator, const TType&, bool singleConstantParam = false); + TIntermLoop* addLoop(TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst, const TSourceLoc&); + TIntermAggregate* addForLoop(TIntermNode*, TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst, + const TSourceLoc&, TIntermLoop*&); + TIntermBranch* addBranch(TOperator, const TSourceLoc&); + TIntermBranch* addBranch(TOperator, TIntermTyped*, const TSourceLoc&); + template TIntermTyped* addSwizzle(TSwizzleSelectors&, const TSourceLoc&); + + // Low level functions to add nodes (no conversions or other higher level transformations) + // If a type is provided, the node's type will be set to it. + TIntermBinary* addBinaryNode(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc) const; + TIntermBinary* addBinaryNode(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc, const TType&) const; + TIntermUnary* addUnaryNode(TOperator op, TIntermTyped* child, TSourceLoc) const; + TIntermUnary* addUnaryNode(TOperator op, TIntermTyped* child, TSourceLoc, const TType&) const; + + // Constant folding (in Constant.cpp) + TIntermTyped* fold(TIntermAggregate* aggrNode); + TIntermTyped* foldConstructor(TIntermAggregate* aggrNode); + TIntermTyped* foldDereference(TIntermTyped* node, int index, const TSourceLoc&); + TIntermTyped* foldSwizzle(TIntermTyped* node, TSwizzleSelectors& fields, const TSourceLoc&); + + // Tree ops + static const TIntermTyped* findLValueBase(const TIntermTyped*, bool swizzleOkay); + + // Linkage related + void addSymbolLinkageNodes(TIntermAggregate*& linkage, EShLanguage, TSymbolTable&); + void addSymbolLinkageNode(TIntermAggregate*& linkage, const TSymbol&); + + void setUseStorageBuffer() + { + useStorageBuffer = true; + processes.addProcess("use-storage-buffer"); + } + bool usingStorageBuffer() const { return useStorageBuffer; } + void setDepthReplacing() { depthReplacing = true; } + bool isDepthReplacing() const { return depthReplacing; } + bool setLocalSize(int dim, int size) + { + if (localSizeNotDefault[dim]) + return size == localSize[dim]; + localSizeNotDefault[dim] = true; + localSize[dim] = size; + return true; + } + unsigned int getLocalSize(int dim) const { return localSize[dim]; } + bool setLocalSizeSpecId(int dim, int id) + { + if (localSizeSpecId[dim] != TQualifier::layoutNotSet) + return id == localSizeSpecId[dim]; + localSizeSpecId[dim] = id; + return true; + } + int getLocalSizeSpecId(int dim) const { return localSizeSpecId[dim]; } +#ifdef GLSLANG_WEB + void output(TInfoSink&, bool tree) { } + + bool isEsProfile() const { return false; } + bool getXfbMode() const { return false; } + bool isMultiStream() const { return false; } + TLayoutGeometry getOutputPrimitive() const { return ElgNone; } + bool getPostDepthCoverage() const { return false; } + bool getEarlyFragmentTests() const { return false; } + TLayoutDepth getDepth() const { return EldNone; } + bool getPixelCenterInteger() const { return false; } + void setOriginUpperLeft() { } + bool getOriginUpperLeft() const { return true; } + TInterlockOrdering getInterlockOrdering() const { return EioNone; } + + bool getAutoMapBindings() const { return false; } + bool getAutoMapLocations() const { return false; } + int getNumPushConstants() const { return 0; } + void addShaderRecordCount() { } + void addTaskNVCount() { } + void setUseVulkanMemoryModel() { } + bool usingVulkanMemoryModel() const { return false; } + bool usingPhysicalStorageBuffer() const { return false; } + bool usingVariablePointers() const { return false; } + unsigned getXfbStride(int buffer) const { return 0; } + bool hasLayoutDerivativeModeNone() const { return false; } + ComputeDerivativeMode getLayoutDerivativeModeNone() const { return LayoutDerivativeNone; } +#else + void output(TInfoSink&, bool tree); + + bool isEsProfile() const { return profile == EEsProfile; } + + void setShiftBinding(TResourceType res, unsigned int shift) + { + shiftBinding[res] = shift; + + const char* name = getResourceName(res); + if (name != nullptr) + processes.addIfNonZero(name, shift); + } + + unsigned int getShiftBinding(TResourceType res) const { return shiftBinding[res]; } + + void setShiftBindingForSet(TResourceType res, unsigned int shift, unsigned int set) + { + if (shift == 0) // ignore if there's no shift: it's a no-op. + return; + + shiftBindingForSet[res][set] = shift; + + const char* name = getResourceName(res); + if (name != nullptr) { + processes.addProcess(name); + processes.addArgument(shift); + processes.addArgument(set); + } + } + + int getShiftBindingForSet(TResourceType res, unsigned int set) const + { + const auto shift = shiftBindingForSet[res].find(set); + return shift == shiftBindingForSet[res].end() ? -1 : shift->second; + } + bool hasShiftBindingForSet(TResourceType res) const { return !shiftBindingForSet[res].empty(); } + + void setResourceSetBinding(const std::vector& shift) + { + resourceSetBinding = shift; + if (shift.size() > 0) { + processes.addProcess("resource-set-binding"); + for (int s = 0; s < (int)shift.size(); ++s) + processes.addArgument(shift[s]); + } + } + const std::vector& getResourceSetBinding() const { return resourceSetBinding; } + void setAutoMapBindings(bool map) + { + autoMapBindings = map; + if (autoMapBindings) + processes.addProcess("auto-map-bindings"); + } + bool getAutoMapBindings() const { return autoMapBindings; } + void setAutoMapLocations(bool map) + { + autoMapLocations = map; + if (autoMapLocations) + processes.addProcess("auto-map-locations"); + } + bool getAutoMapLocations() const { return autoMapLocations; } + +#ifdef ENABLE_HLSL + void setFlattenUniformArrays(bool flatten) + { + flattenUniformArrays = flatten; + if (flattenUniformArrays) + processes.addProcess("flatten-uniform-arrays"); + } + bool getFlattenUniformArrays() const { return flattenUniformArrays; } +#endif + void setNoStorageFormat(bool b) + { + useUnknownFormat = b; + if (useUnknownFormat) + processes.addProcess("no-storage-format"); + } + bool getNoStorageFormat() const { return useUnknownFormat; } + void setUseVulkanMemoryModel() + { + useVulkanMemoryModel = true; + processes.addProcess("use-vulkan-memory-model"); + } + bool usingVulkanMemoryModel() const { return useVulkanMemoryModel; } + void setUsePhysicalStorageBuffer() + { + usePhysicalStorageBuffer = true; + } + bool usingPhysicalStorageBuffer() const { return usePhysicalStorageBuffer; } + void setUseVariablePointers() + { + useVariablePointers = true; + processes.addProcess("use-variable-pointers"); + } + bool usingVariablePointers() const { return useVariablePointers; } + +#ifdef ENABLE_HLSL + template T addCounterBufferName(const T& name) const { return name + implicitCounterName; } + bool hasCounterBufferName(const TString& name) const { + size_t len = strlen(implicitCounterName); + return name.size() > len && + name.compare(name.size() - len, len, implicitCounterName) == 0; + } +#endif + + void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode) { textureSamplerTransformMode = mode; } + int getNumPushConstants() const { return numPushConstants; } + void addShaderRecordCount() { ++numShaderRecordBlocks; } + void addTaskNVCount() { ++numTaskNVBlocks; } + + bool setInvocations(int i) + { + if (invocations != TQualifier::layoutNotSet) + return invocations == i; + invocations = i; + return true; + } + int getInvocations() const { return invocations; } + bool setVertices(int m) + { + if (vertices != TQualifier::layoutNotSet) + return vertices == m; + vertices = m; + return true; + } + int getVertices() const { return vertices; } + bool setInputPrimitive(TLayoutGeometry p) + { + if (inputPrimitive != ElgNone) + return inputPrimitive == p; + inputPrimitive = p; + return true; + } + TLayoutGeometry getInputPrimitive() const { return inputPrimitive; } + bool setVertexSpacing(TVertexSpacing s) + { + if (vertexSpacing != EvsNone) + return vertexSpacing == s; + vertexSpacing = s; + return true; + } + TVertexSpacing getVertexSpacing() const { return vertexSpacing; } + bool setVertexOrder(TVertexOrder o) + { + if (vertexOrder != EvoNone) + return vertexOrder == o; + vertexOrder = o; + return true; + } + TVertexOrder getVertexOrder() const { return vertexOrder; } + void setPointMode() { pointMode = true; } + bool getPointMode() const { return pointMode; } + + bool setInterlockOrdering(TInterlockOrdering o) + { + if (interlockOrdering != EioNone) + return interlockOrdering == o; + interlockOrdering = o; + return true; + } + TInterlockOrdering getInterlockOrdering() const { return interlockOrdering; } + + void setXfbMode() { xfbMode = true; } + bool getXfbMode() const { return xfbMode; } + void setMultiStream() { multiStream = true; } + bool isMultiStream() const { return multiStream; } + bool setOutputPrimitive(TLayoutGeometry p) + { + if (outputPrimitive != ElgNone) + return outputPrimitive == p; + outputPrimitive = p; + return true; + } + TLayoutGeometry getOutputPrimitive() const { return outputPrimitive; } + void setPostDepthCoverage() { postDepthCoverage = true; } + bool getPostDepthCoverage() const { return postDepthCoverage; } + void setEarlyFragmentTests() { earlyFragmentTests = true; } + bool getEarlyFragmentTests() const { return earlyFragmentTests; } + bool setDepth(TLayoutDepth d) + { + if (depthLayout != EldNone) + return depthLayout == d; + depthLayout = d; + return true; + } + TLayoutDepth getDepth() const { return depthLayout; } + void setOriginUpperLeft() { originUpperLeft = true; } + bool getOriginUpperLeft() const { return originUpperLeft; } + void setPixelCenterInteger() { pixelCenterInteger = true; } + bool getPixelCenterInteger() const { return pixelCenterInteger; } + void addBlendEquation(TBlendEquationShift b) { blendEquations |= (1 << b); } + unsigned int getBlendEquations() const { return blendEquations; } + bool setXfbBufferStride(int buffer, unsigned stride) + { + if (xfbBuffers[buffer].stride != TQualifier::layoutXfbStrideEnd) + return xfbBuffers[buffer].stride == stride; + xfbBuffers[buffer].stride = stride; + return true; + } + unsigned getXfbStride(int buffer) const { return xfbBuffers[buffer].stride; } + int addXfbBufferOffset(const TType&); + unsigned int computeTypeXfbSize(const TType&, bool& contains64BitType, bool& contains32BitType, bool& contains16BitType) const; + unsigned int computeTypeXfbSize(const TType&, bool& contains64BitType) const; + void setLayoutOverrideCoverage() { layoutOverrideCoverage = true; } + bool getLayoutOverrideCoverage() const { return layoutOverrideCoverage; } + void setGeoPassthroughEXT() { geoPassthroughEXT = true; } + bool getGeoPassthroughEXT() const { return geoPassthroughEXT; } + void setLayoutDerivativeMode(ComputeDerivativeMode mode) { computeDerivativeMode = mode; } + bool hasLayoutDerivativeModeNone() const { return computeDerivativeMode != LayoutDerivativeNone; } + ComputeDerivativeMode getLayoutDerivativeModeNone() const { return computeDerivativeMode; } + void setLayoutPrimitiveCulling() { layoutPrimitiveCulling = true; } + bool getLayoutPrimitiveCulling() const { return layoutPrimitiveCulling; } + bool setPrimitives(int m) + { + if (primitives != TQualifier::layoutNotSet) + return primitives == m; + primitives = m; + return true; + } + int getPrimitives() const { return primitives; } + const char* addSemanticName(const TString& name) + { + return semanticNameSet.insert(name).first->c_str(); + } + void addUniformLocationOverride(const char* nameStr, int location) + { + std::string name = nameStr; + uniformLocationOverrides[name] = location; + } + + int getUniformLocationOverride(const char* nameStr) const + { + std::string name = nameStr; + auto pos = uniformLocationOverrides.find(name); + if (pos == uniformLocationOverrides.end()) + return -1; + else + return pos->second; + } + + void setUniformLocationBase(int base) { uniformLocationBase = base; } + int getUniformLocationBase() const { return uniformLocationBase; } + + void setNeedsLegalization() { needToLegalize = true; } + bool needsLegalization() const { return needToLegalize; } + + void setBinaryDoubleOutput() { binaryDoubleOutput = true; } + bool getBinaryDoubleOutput() { return binaryDoubleOutput; } +#endif // GLSLANG_WEB + +#ifdef ENABLE_HLSL + void setHlslFunctionality1() { hlslFunctionality1 = true; } + bool getHlslFunctionality1() const { return hlslFunctionality1; } + void setHlslOffsets() + { + hlslOffsets = true; + if (hlslOffsets) + processes.addProcess("hlsl-offsets"); + } + bool usingHlslOffsets() const { return hlslOffsets; } + void setHlslIoMapping(bool b) + { + hlslIoMapping = b; + if (hlslIoMapping) + processes.addProcess("hlsl-iomap"); + } + bool usingHlslIoMapping() { return hlslIoMapping; } +#else + bool getHlslFunctionality1() const { return false; } + bool usingHlslOffsets() const { return false; } + bool usingHlslIoMapping() { return false; } +#endif + + void addToCallGraph(TInfoSink&, const TString& caller, const TString& callee); + void merge(TInfoSink&, TIntermediate&); + void finalCheck(TInfoSink&, bool keepUncalled); + + bool buildConvertOp(TBasicType dst, TBasicType src, TOperator& convertOp) const; + TIntermTyped* createConversion(TBasicType convertTo, TIntermTyped* node) const; + + void addIoAccessed(const TString& name) { ioAccessed.insert(name); } + bool inIoAccessed(const TString& name) const { return ioAccessed.find(name) != ioAccessed.end(); } + + int addUsedLocation(const TQualifier&, const TType&, bool& typeCollision); + int checkLocationRange(int set, const TIoRange& range, const TType&, bool& typeCollision); + int addUsedOffsets(int binding, int offset, int numOffsets); + bool addUsedConstantId(int id); + static int computeTypeLocationSize(const TType&, EShLanguage); + static int computeTypeUniformLocationSize(const TType&); + + static int getBaseAlignmentScalar(const TType&, int& size); + static int getBaseAlignment(const TType&, int& size, int& stride, TLayoutPacking layoutPacking, bool rowMajor); + static int getScalarAlignment(const TType&, int& size, int& stride, bool rowMajor); + static int getMemberAlignment(const TType&, int& size, int& stride, TLayoutPacking layoutPacking, bool rowMajor); + static bool improperStraddle(const TType& type, int size, int offset); + static void updateOffset(const TType& parentType, const TType& memberType, int& offset, int& memberSize); + static int getOffset(const TType& type, int index); + static int getBlockSize(const TType& blockType); + static int computeBufferReferenceTypeSize(const TType&); + bool promote(TIntermOperator*); + void setNanMinMaxClamp(bool setting) { nanMinMaxClamp = setting; } + bool getNanMinMaxClamp() const { return nanMinMaxClamp; } + + void setSourceFile(const char* file) { if (file != nullptr) sourceFile = file; } + const std::string& getSourceFile() const { return sourceFile; } + void addSourceText(const char* text, size_t len) { sourceText.append(text, len); } + const std::string& getSourceText() const { return sourceText; } + const std::map& getIncludeText() const { return includeText; } + void addIncludeText(const char* name, const char* text, size_t len) { includeText[name].assign(text,len); } + void addProcesses(const std::vector& p) + { + for (int i = 0; i < (int)p.size(); ++i) + processes.addProcess(p[i]); + } + void addProcess(const std::string& process) { processes.addProcess(process); } + void addProcessArgument(const std::string& arg) { processes.addArgument(arg); } + const std::vector& getProcesses() const { return processes.getProcesses(); } + + // Certain explicit conversions are allowed conditionally +#ifdef GLSLANG_WEB + bool getArithemeticInt8Enabled() const { return false; } + bool getArithemeticInt16Enabled() const { return false; } + bool getArithemeticFloat16Enabled() const { return false; } +#else + bool getArithemeticInt8Enabled() const { + return extensionRequested(E_GL_EXT_shader_explicit_arithmetic_types) || + extensionRequested(E_GL_EXT_shader_explicit_arithmetic_types_int8); + } + bool getArithemeticInt16Enabled() const { + return extensionRequested(E_GL_EXT_shader_explicit_arithmetic_types) || + extensionRequested(E_GL_AMD_gpu_shader_int16) || + extensionRequested(E_GL_EXT_shader_explicit_arithmetic_types_int16); + } + + bool getArithemeticFloat16Enabled() const { + return extensionRequested(E_GL_EXT_shader_explicit_arithmetic_types) || + extensionRequested(E_GL_AMD_gpu_shader_half_float) || + extensionRequested(E_GL_EXT_shader_explicit_arithmetic_types_float16); + } +#endif + +protected: + TIntermSymbol* addSymbol(int Id, const TString&, const TType&, const TConstUnionArray&, TIntermTyped* subtree, const TSourceLoc&); + void error(TInfoSink& infoSink, const char*); + void warn(TInfoSink& infoSink, const char*); + void mergeCallGraphs(TInfoSink&, TIntermediate&); + void mergeModes(TInfoSink&, TIntermediate&); + void mergeTrees(TInfoSink&, TIntermediate&); + void seedIdMap(TIdMaps& idMaps, int& maxId); + void remapIds(const TIdMaps& idMaps, int idShift, TIntermediate&); + void mergeBodies(TInfoSink&, TIntermSequence& globals, const TIntermSequence& unitGlobals); + void mergeLinkerObjects(TInfoSink&, TIntermSequence& linkerObjects, const TIntermSequence& unitLinkerObjects); + void mergeImplicitArraySizes(TType&, const TType&); + void mergeErrorCheck(TInfoSink&, const TIntermSymbol&, const TIntermSymbol&, bool crossStage); + void checkCallGraphCycles(TInfoSink&); + void checkCallGraphBodies(TInfoSink&, bool keepUncalled); + void inOutLocationCheck(TInfoSink&); + TIntermAggregate* findLinkerObjects() const; + bool userOutputUsed() const; + bool isSpecializationOperation(const TIntermOperator&) const; + bool isNonuniformPropagating(TOperator) const; + bool promoteUnary(TIntermUnary&); + bool promoteBinary(TIntermBinary&); + void addSymbolLinkageNode(TIntermAggregate*& linkage, TSymbolTable&, const TString&); + bool promoteAggregate(TIntermAggregate&); + void pushSelector(TIntermSequence&, const TVectorSelector&, const TSourceLoc&); + void pushSelector(TIntermSequence&, const TMatrixSelector&, const TSourceLoc&); + bool specConstantPropagates(const TIntermTyped&, const TIntermTyped&); + void performTextureUpgradeAndSamplerRemovalTransformation(TIntermNode* root); + bool isConversionAllowed(TOperator op, TIntermTyped* node) const; + std::tuple getConversionDestinatonType(TBasicType type0, TBasicType type1, TOperator op) const; + + // JohnK: I think this function should go away. + // This data structure is just a log to pass on to back ends. + // Versioning and extensions are handled in Version.cpp, with a rich + // set of functions for querying stages, versions, extension enable/disabled, etc. +#ifdef GLSLANG_WEB + bool extensionRequested(const char *extension) const { return false; } +#else + bool extensionRequested(const char *extension) const { + auto it = requestedExtensions.find(extension); + if (it != requestedExtensions.end()) { + return (it->second == EBhDisable) ? false : true; + } + return false; + } +#endif + + static const char* getResourceName(TResourceType); + + const EShLanguage language; // stage, known at construction time + std::string entryPointName; + std::string entryPointMangledName; + typedef std::list TGraph; + TGraph callGraph; + + EProfile profile; // source profile + int version; // source version + SpvVersion spvVersion; + TIntermNode* treeRoot; + std::map requestedExtensions; // cumulation of all enabled or required extensions; not connected to what subset of the shader used them + TBuiltInResource resources; + int numEntryPoints; + int numErrors; + int numPushConstants; + bool recursive; + bool invertY; + bool useStorageBuffer; + bool nanMinMaxClamp; // true if desiring min/max/clamp to favor non-NaN over NaN + bool depthReplacing; + int localSize[3]; + bool localSizeNotDefault[3]; + int localSizeSpecId[3]; +#ifndef GLSLANG_WEB +public: + const char* const implicitThisName; + const char* const implicitCounterName; +protected: + EShSource source; // source language, known a bit later + bool useVulkanMemoryModel; + int invocations; + int vertices; + TLayoutGeometry inputPrimitive; + TLayoutGeometry outputPrimitive; + bool pixelCenterInteger; + bool originUpperLeft; + TVertexSpacing vertexSpacing; + TVertexOrder vertexOrder; + TInterlockOrdering interlockOrdering; + bool pointMode; + bool earlyFragmentTests; + bool postDepthCoverage; + TLayoutDepth depthLayout; + bool hlslFunctionality1; + int blendEquations; // an 'or'ing of masks of shifts of TBlendEquationShift + bool xfbMode; + std::vector xfbBuffers; // all the data we need to track per xfb buffer + bool multiStream; + bool layoutOverrideCoverage; + bool geoPassthroughEXT; + int numShaderRecordBlocks; + ComputeDerivativeMode computeDerivativeMode; + int primitives; + int numTaskNVBlocks; + bool layoutPrimitiveCulling; + + // Base shift values + std::array shiftBinding; + + // Per-descriptor-set shift values + std::array, EResCount> shiftBindingForSet; + + std::vector resourceSetBinding; + bool autoMapBindings; + bool autoMapLocations; + bool flattenUniformArrays; + bool useUnknownFormat; + bool hlslOffsets; + bool hlslIoMapping; + bool useVariablePointers; + + std::set semanticNameSet; + + EShTextureSamplerTransformMode textureSamplerTransformMode; + + bool needToLegalize; + bool binaryDoubleOutput; + bool usePhysicalStorageBuffer; + + std::unordered_map uniformLocationOverrides; + int uniformLocationBase; +#endif + + std::unordered_set usedConstantId; // specialization constant ids used + std::vector usedAtomics; // sets of bindings used by atomic counters + std::vector usedIo[4]; // sets of used locations, one for each of in, out, uniform, and buffers + // set of names of statically read/written I/O that might need extra checking + std::set ioAccessed; + // source code of shader, useful as part of debug information + std::string sourceFile; + std::string sourceText; + + // Included text. First string is a name, second is the included text + std::map includeText; + + // for OpModuleProcessed, or equivalent + TProcesses processes; + +private: + void operator=(TIntermediate&); // prevent assignments +}; + +} // end namespace glslang + +#endif // _LOCAL_INTERMEDIATE_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/parseVersions.h b/ios/include/glslang/MachineIndependent/parseVersions.h new file mode 100644 index 00000000..0d006a71 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/parseVersions.h @@ -0,0 +1,240 @@ +// +// Copyright (C) 2015-2018 Google, Inc. +// Copyright (C) 2017 ARM Limited. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +// This is implemented in Versions.cpp + +#ifndef _PARSE_VERSIONS_INCLUDED_ +#define _PARSE_VERSIONS_INCLUDED_ + +#include "../Public/ShaderLang.h" +#include "../Include/InfoSink.h" +#include "Scan.h" + +#include + +namespace glslang { + +// +// Base class for parse helpers. +// This just has version-related information and checking. +// This class should be sufficient for preprocessing. +// +class TParseVersions { +public: + TParseVersions(TIntermediate& interm, int version, EProfile profile, + const SpvVersion& spvVersion, EShLanguage language, TInfoSink& infoSink, + bool forwardCompatible, EShMessages messages) + : +#ifndef GLSLANG_WEB + forwardCompatible(forwardCompatible), + profile(profile), +#endif + infoSink(infoSink), version(version), + language(language), + spvVersion(spvVersion), + intermediate(interm), messages(messages), numErrors(0), currentScanner(0) { } + virtual ~TParseVersions() { } + void requireStage(const TSourceLoc&, EShLanguageMask, const char* featureDesc); + void requireStage(const TSourceLoc&, EShLanguage, const char* featureDesc); +#ifdef GLSLANG_WEB + const EProfile profile = EEsProfile; + bool isEsProfile() const { return true; } + void requireProfile(const TSourceLoc& loc, int profileMask, const char* featureDesc) + { + if (! (EEsProfile & profileMask)) + error(loc, "not supported with this profile:", featureDesc, ProfileName(profile)); + } + void profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, int numExtensions, + const char* const extensions[], const char* featureDesc) + { + if ((EEsProfile & profileMask) && (minVersion == 0 || version < minVersion)) + error(loc, "not supported for this version or the enabled extensions", featureDesc, ""); + } + void profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, const char* extension, + const char* featureDesc) + { + profileRequires(loc, profileMask, minVersion, extension ? 1 : 0, &extension, featureDesc); + } + void initializeExtensionBehavior() { } + void checkDeprecated(const TSourceLoc&, int queryProfiles, int depVersion, const char* featureDesc) { } + void requireNotRemoved(const TSourceLoc&, int queryProfiles, int removedVersion, const char* featureDesc) { } + void requireExtensions(const TSourceLoc&, int numExtensions, const char* const extensions[], + const char* featureDesc) { } + void ppRequireExtensions(const TSourceLoc&, int numExtensions, const char* const extensions[], + const char* featureDesc) { } + TExtensionBehavior getExtensionBehavior(const char*) { return EBhMissing; } + bool extensionTurnedOn(const char* const extension) { return false; } + bool extensionsTurnedOn(int numExtensions, const char* const extensions[]) { return false; } + void updateExtensionBehavior(int line, const char* const extension, const char* behavior) { } + void updateExtensionBehavior(const char* const extension, TExtensionBehavior) { } + void checkExtensionStage(const TSourceLoc&, const char* const extension) { } + void extensionRequires(const TSourceLoc&, const char* const extension, const char* behavior) { } + void fullIntegerCheck(const TSourceLoc&, const char* op) { } + void doubleCheck(const TSourceLoc&, const char* op) { } + bool float16Arithmetic() { return false; } + void requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc) { } + bool int16Arithmetic() { return false; } + void requireInt16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc) { } + bool int8Arithmetic() { return false; } + void requireInt8Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc) { } + void int64Check(const TSourceLoc&, const char* op, bool builtIn = false) { } + void explicitFloat32Check(const TSourceLoc&, const char* op, bool builtIn = false) { } + void explicitFloat64Check(const TSourceLoc&, const char* op, bool builtIn = false) { } + bool relaxedErrors() const { return false; } + bool suppressWarnings() const { return true; } + bool isForwardCompatible() const { return false; } +#else + bool forwardCompatible; // true if errors are to be given for use of deprecated features + EProfile profile; // the declared profile in the shader (core by default) + bool isEsProfile() const { return profile == EEsProfile; } + void requireProfile(const TSourceLoc& loc, int profileMask, const char* featureDesc); + void profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, int numExtensions, + const char* const extensions[], const char* featureDesc); + void profileRequires(const TSourceLoc& loc, int profileMask, int minVersion, const char* extension, + const char* featureDesc); + virtual void initializeExtensionBehavior(); + virtual void checkDeprecated(const TSourceLoc&, int queryProfiles, int depVersion, const char* featureDesc); + virtual void requireNotRemoved(const TSourceLoc&, int queryProfiles, int removedVersion, const char* featureDesc); + virtual void requireExtensions(const TSourceLoc&, int numExtensions, const char* const extensions[], + const char* featureDesc); + virtual void ppRequireExtensions(const TSourceLoc&, int numExtensions, const char* const extensions[], + const char* featureDesc); + virtual TExtensionBehavior getExtensionBehavior(const char*); + virtual bool extensionTurnedOn(const char* const extension); + virtual bool extensionsTurnedOn(int numExtensions, const char* const extensions[]); + virtual void updateExtensionBehavior(int line, const char* const extension, const char* behavior); + virtual void updateExtensionBehavior(const char* const extension, TExtensionBehavior); + virtual bool checkExtensionsRequested(const TSourceLoc&, int numExtensions, const char* const extensions[], + const char* featureDesc); + virtual void checkExtensionStage(const TSourceLoc&, const char* const extension); + virtual void extensionRequires(const TSourceLoc&, const char* const extension, const char* behavior); + virtual void fullIntegerCheck(const TSourceLoc&, const char* op); + + virtual void unimplemented(const TSourceLoc&, const char* featureDesc); + virtual void doubleCheck(const TSourceLoc&, const char* op); + virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void float16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual bool float16Arithmetic(); + virtual void requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc); + virtual void int16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual bool int16Arithmetic(); + virtual void requireInt16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc); + virtual void int8ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual bool int8Arithmetic(); + virtual void requireInt8Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc); + virtual void float16OpaqueCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void int64Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void explicitInt8Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void explicitInt16Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void explicitInt32Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void explicitFloat32Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void explicitFloat64Check(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void fcoopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void intcoopmatCheck(const TSourceLoc&, const char *op, bool builtIn = false); + bool relaxedErrors() const { return (messages & EShMsgRelaxedErrors) != 0; } + bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; } + bool isForwardCompatible() const { return forwardCompatible; } +#endif // GLSLANG_WEB + virtual void spvRemoved(const TSourceLoc&, const char* op); + virtual void vulkanRemoved(const TSourceLoc&, const char* op); + virtual void requireVulkan(const TSourceLoc&, const char* op); + virtual void requireSpv(const TSourceLoc&, const char* op); + virtual void requireSpv(const TSourceLoc&, const char *op, unsigned int version); + + +#if defined(GLSLANG_WEB) && !defined(GLSLANG_WEB_DEVEL) + void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) { addError(); } + void C_DECL warn(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) { } + void C_DECL ppError(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) { addError(); } + void C_DECL ppWarn(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) { } +#else + virtual void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) = 0; + virtual void C_DECL warn(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) = 0; + virtual void C_DECL ppError(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) = 0; + virtual void C_DECL ppWarn(const TSourceLoc&, const char* szReason, const char* szToken, + const char* szExtraInfoFormat, ...) = 0; +#endif + + void addError() { ++numErrors; } + int getNumErrors() const { return numErrors; } + + void setScanner(TInputScanner* scanner) { currentScanner = scanner; } + TInputScanner* getScanner() const { return currentScanner; } + const TSourceLoc& getCurrentLoc() const { return currentScanner->getSourceLoc(); } + void setCurrentLine(int line) { currentScanner->setLine(line); } + void setCurrentColumn(int col) { currentScanner->setColumn(col); } + void setCurrentSourceName(const char* name) { currentScanner->setFile(name); } + void setCurrentString(int string) { currentScanner->setString(string); } + + void getPreamble(std::string&); +#ifdef ENABLE_HLSL + bool isReadingHLSL() const { return (messages & EShMsgReadHlsl) == EShMsgReadHlsl; } + bool hlslEnable16BitTypes() const { return (messages & EShMsgHlslEnable16BitTypes) != 0; } + bool hlslDX9Compatible() const { return (messages & EShMsgHlslDX9Compatible) != 0; } +#else + bool isReadingHLSL() const { return false; } +#endif + + TInfoSink& infoSink; + + // compilation mode + int version; // version, updated by #version in the shader + EShLanguage language; // really the stage + SpvVersion spvVersion; + TIntermediate& intermediate; // helper for making and hooking up pieces of the parse tree + +protected: + TMap extensionBehavior; // for each extension string, what its current behavior is set to + TMap extensionMinSpv; // for each extension string, store minimum spirv required + EShMessages messages; // errors/warnings/rule-sets + int numErrors; // number of compile-time errors encountered + TInputScanner* currentScanner; + +private: + explicit TParseVersions(const TParseVersions&); + TParseVersions& operator=(const TParseVersions&); +}; + +} // end namespace glslang + +#endif // _PARSE_VERSIONS_INCLUDED_ diff --git a/ios/include/glslang/MachineIndependent/preprocessor/PpContext.h b/ios/include/glslang/MachineIndependent/preprocessor/PpContext.h new file mode 100644 index 00000000..714b5ead --- /dev/null +++ b/ios/include/glslang/MachineIndependent/preprocessor/PpContext.h @@ -0,0 +1,703 @@ +// +// Copyright (C) 2013 LunarG, Inc. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +/****************************************************************************\ +Copyright (c) 2002, NVIDIA Corporation. + +NVIDIA Corporation("NVIDIA") supplies this software to you in +consideration of your agreement to the following terms, and your use, +installation, modification or redistribution of this NVIDIA software +constitutes acceptance of these terms. If you do not agree with these +terms, please do not use, install, modify or redistribute this NVIDIA +software. + +In consideration of your agreement to abide by the following terms, and +subject to these terms, NVIDIA grants you a personal, non-exclusive +license, under NVIDIA's copyrights in this original NVIDIA software (the +"NVIDIA Software"), to use, reproduce, modify and redistribute the +NVIDIA Software, with or without modifications, in source and/or binary +forms; provided that if you redistribute the NVIDIA Software, you must +retain the copyright notice of NVIDIA, this notice and the following +text and disclaimers in all such redistributions of the NVIDIA Software. +Neither the name, trademarks, service marks nor logos of NVIDIA +Corporation may be used to endorse or promote products derived from the +NVIDIA Software without specific prior written permission from NVIDIA. +Except as expressly stated in this notice, no other rights or licenses +express or implied, are granted by NVIDIA herein, including but not +limited to any patent rights that may be infringed by your derivative +works or by other works in which the NVIDIA Software may be +incorporated. No hardware is licensed hereunder. + +THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, +INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR +ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER +PRODUCTS. + +IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, +INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY +OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE +NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, +TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF +NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +\****************************************************************************/ + +#ifndef PPCONTEXT_H +#define PPCONTEXT_H + +#include +#include +#include + +#include "../ParseHelper.h" +#include "PpTokens.h" + +/* windows only pragma */ +#ifdef _MSC_VER + #pragma warning(disable : 4127) +#endif + +namespace glslang { + +class TPpToken { +public: + TPpToken() { clear(); } + void clear() + { + space = false; + i64val = 0; + loc.init(); + name[0] = 0; + } + + // Used for comparing macro definitions, so checks what is relevant for that. + bool operator==(const TPpToken& right) const + { + return space == right.space && + ival == right.ival && dval == right.dval && i64val == right.i64val && + strncmp(name, right.name, MaxTokenLength) == 0; + } + bool operator!=(const TPpToken& right) const { return ! operator==(right); } + + TSourceLoc loc; + // True if a space (for white space or a removed comment) should also be + // recognized, in front of the token returned: + bool space; + // Numeric value of the token: + union { + int ival; + double dval; + long long i64val; + }; + // Text string of the token: + char name[MaxTokenLength + 1]; +}; + +class TStringAtomMap { +// +// Implementation is in PpAtom.cpp +// +// Maintain a bi-directional mapping between relevant preprocessor strings and +// "atoms" which a unique integers (small, contiguous, not hash-like) per string. +// +public: + TStringAtomMap(); + + // Map string -> atom. + // Return 0 if no existing string. + int getAtom(const char* s) const + { + auto it = atomMap.find(s); + return it == atomMap.end() ? 0 : it->second; + } + + // Map a new or existing string -> atom, inventing a new atom if necessary. + int getAddAtom(const char* s) + { + int atom = getAtom(s); + if (atom == 0) { + atom = nextAtom++; + addAtomFixed(s, atom); + } + return atom; + } + + // Map atom -> string. + const char* getString(int atom) const { return stringMap[atom]->c_str(); } + +protected: + TStringAtomMap(TStringAtomMap&); + TStringAtomMap& operator=(TStringAtomMap&); + + TUnorderedMap atomMap; + TVector stringMap; // these point into the TString in atomMap + int nextAtom; + + // Bad source characters can lead to bad atoms, so gracefully handle those by + // pre-filling the table with them (to avoid if tests later). + TString badToken; + + // Add bi-directional mappings: + // - string -> atom + // - atom -> string + void addAtomFixed(const char* s, int atom) + { + auto it = atomMap.insert(std::pair(s, atom)).first; + if (stringMap.size() < (size_t)atom + 1) + stringMap.resize(atom + 100, &badToken); + stringMap[atom] = &it->first; + } +}; + +class TInputScanner; + +enum MacroExpandResult { + MacroExpandNotStarted, // macro not expanded, which might not be an error + MacroExpandError, // a clear error occurred while expanding, no expansion + MacroExpandStarted, // macro expansion process has started + MacroExpandUndef // macro is undefined and will be expanded +}; + +// This class is the result of turning a huge pile of C code communicating through globals +// into a class. This was done to allowing instancing to attain thread safety. +// Don't expect too much in terms of OO design. +class TPpContext { +public: + TPpContext(TParseContextBase&, const std::string& rootFileName, TShader::Includer&); + virtual ~TPpContext(); + + void setPreamble(const char* preamble, size_t length); + + int tokenize(TPpToken& ppToken); + int tokenPaste(int token, TPpToken&); + + class tInput { + public: + tInput(TPpContext* p) : done(false), pp(p) { } + virtual ~tInput() { } + + virtual int scan(TPpToken*) = 0; + virtual int getch() = 0; + virtual void ungetch() = 0; + virtual bool peekPasting() { return false; } // true when about to see ## + virtual bool peekContinuedPasting(int) { return false; } // true when non-spaced tokens can paste + virtual bool endOfReplacementList() { return false; } // true when at the end of a macro replacement list (RHS of #define) + virtual bool isMacroInput() { return false; } + + // Will be called when we start reading tokens from this instance + virtual void notifyActivated() {} + // Will be called when we do not read tokens from this instance anymore + virtual void notifyDeleted() {} + protected: + bool done; + TPpContext* pp; + }; + + void setInput(TInputScanner& input, bool versionWillBeError); + + void pushInput(tInput* in) + { + inputStack.push_back(in); + in->notifyActivated(); + } + void popInput() + { + inputStack.back()->notifyDeleted(); + delete inputStack.back(); + inputStack.pop_back(); + } + + // + // From PpTokens.cpp + // + + // Capture the needed parts of a token stream for macro recording/playback. + class TokenStream { + public: + // Manage a stream of these 'Token', which capture the relevant parts + // of a TPpToken, plus its atom. + class Token { + public: + Token(int atom, const TPpToken& ppToken) : + atom(atom), + space(ppToken.space), + i64val(ppToken.i64val), + name(ppToken.name) { } + int get(TPpToken& ppToken) + { + ppToken.clear(); + ppToken.space = space; + ppToken.i64val = i64val; + snprintf(ppToken.name, sizeof(ppToken.name), "%s", name.c_str()); + return atom; + } + bool isAtom(int a) const { return atom == a; } + int getAtom() const { return atom; } + bool nonSpaced() const { return !space; } + protected: + Token() {} + int atom; + bool space; // did a space precede the token? + long long i64val; + TString name; + }; + + TokenStream() : currentPos(0) { } + + void putToken(int token, TPpToken* ppToken); + bool peekToken(int atom) { return !atEnd() && stream[currentPos].isAtom(atom); } + bool peekContinuedPasting(int atom) + { + // This is basically necessary because, for example, the PP + // tokenizer only accepts valid numeric-literals plus suffixes, so + // separates numeric-literals plus bad suffix into two tokens, which + // should get both pasted together as one token when token pasting. + // + // The following code is a bit more generalized than the above example. + if (!atEnd() && atom == PpAtomIdentifier && stream[currentPos].nonSpaced()) { + switch(stream[currentPos].getAtom()) { + case PpAtomConstInt: + case PpAtomConstUint: + case PpAtomConstInt64: + case PpAtomConstUint64: + case PpAtomConstInt16: + case PpAtomConstUint16: + case PpAtomConstFloat: + case PpAtomConstDouble: + case PpAtomConstFloat16: + case PpAtomConstString: + case PpAtomIdentifier: + return true; + default: + break; + } + } + + return false; + } + int getToken(TParseContextBase&, TPpToken*); + bool atEnd() { return currentPos >= stream.size(); } + bool peekTokenizedPasting(bool lastTokenPastes); + bool peekUntokenizedPasting(); + void reset() { currentPos = 0; } + + protected: + TVector stream; + size_t currentPos; + }; + + // + // From Pp.cpp + // + + struct MacroSymbol { + MacroSymbol() : functionLike(0), busy(0), undef(0) { } + TVector args; + TokenStream body; + unsigned functionLike : 1; // 0 means object-like, 1 means function-like + unsigned busy : 1; + unsigned undef : 1; + }; + + typedef TMap TSymbolMap; + TSymbolMap macroDefs; // map atoms to macro definitions + MacroSymbol* lookupMacroDef(int atom) + { + auto existingMacroIt = macroDefs.find(atom); + return (existingMacroIt == macroDefs.end()) ? nullptr : &(existingMacroIt->second); + } + void addMacroDef(int atom, MacroSymbol& macroDef) { macroDefs[atom] = macroDef; } + +protected: + TPpContext(TPpContext&); + TPpContext& operator=(TPpContext&); + + TStringAtomMap atomStrings; + char* preamble; // string to parse, all before line 1 of string 0, it is 0 if no preamble + int preambleLength; + char** strings; // official strings of shader, starting a string 0 line 1 + size_t* lengths; + int numStrings; // how many official strings there are + int currentString; // which string we're currently parsing (-1 for preamble) + + // Scanner data: + int previous_token; + TParseContextBase& parseContext; + + // Get the next token from *stack* of input sources, popping input sources + // that are out of tokens, down until an input source is found that has a token. + // Return EndOfInput when there are no more tokens to be found by doing this. + int scanToken(TPpToken* ppToken) + { + int token = EndOfInput; + + while (! inputStack.empty()) { + token = inputStack.back()->scan(ppToken); + if (token != EndOfInput || inputStack.empty()) + break; + popInput(); + } + + return token; + } + int getChar() { return inputStack.back()->getch(); } + void ungetChar() { inputStack.back()->ungetch(); } + bool peekPasting() { return !inputStack.empty() && inputStack.back()->peekPasting(); } + bool peekContinuedPasting(int a) + { + return !inputStack.empty() && inputStack.back()->peekContinuedPasting(a); + } + bool endOfReplacementList() { return inputStack.empty() || inputStack.back()->endOfReplacementList(); } + bool isMacroInput() { return inputStack.size() > 0 && inputStack.back()->isMacroInput(); } + + static const int maxIfNesting = 65; + + int ifdepth; // current #if-#else-#endif nesting in the cpp.c file (pre-processor) + bool elseSeen[maxIfNesting]; // Keep a track of whether an else has been seen at a particular depth + int elsetracker; // #if-#else and #endif constructs...Counter. + + class tMacroInput : public tInput { + public: + tMacroInput(TPpContext* pp) : tInput(pp), prepaste(false), postpaste(false) { } + virtual ~tMacroInput() + { + for (size_t i = 0; i < args.size(); ++i) + delete args[i]; + for (size_t i = 0; i < expandedArgs.size(); ++i) + delete expandedArgs[i]; + } + + virtual int scan(TPpToken*) override; + virtual int getch() override { assert(0); return EndOfInput; } + virtual void ungetch() override { assert(0); } + bool peekPasting() override { return prepaste; } + bool peekContinuedPasting(int a) override { return mac->body.peekContinuedPasting(a); } + bool endOfReplacementList() override { return mac->body.atEnd(); } + bool isMacroInput() override { return true; } + + MacroSymbol *mac; + TVector args; + TVector expandedArgs; + + protected: + bool prepaste; // true if we are just before ## + bool postpaste; // true if we are right after ## + }; + + class tMarkerInput : public tInput { + public: + tMarkerInput(TPpContext* pp) : tInput(pp) { } + virtual int scan(TPpToken*) override + { + if (done) + return EndOfInput; + done = true; + + return marker; + } + virtual int getch() override { assert(0); return EndOfInput; } + virtual void ungetch() override { assert(0); } + static const int marker = -3; + }; + + class tZeroInput : public tInput { + public: + tZeroInput(TPpContext* pp) : tInput(pp) { } + virtual int scan(TPpToken*) override; + virtual int getch() override { assert(0); return EndOfInput; } + virtual void ungetch() override { assert(0); } + }; + + std::vector inputStack; + bool errorOnVersion; + bool versionSeen; + + // + // from Pp.cpp + // + + // Used to obtain #include content. + TShader::Includer& includer; + + int CPPdefine(TPpToken * ppToken); + int CPPundef(TPpToken * ppToken); + int CPPelse(int matchelse, TPpToken * ppToken); + int extraTokenCheck(int atom, TPpToken* ppToken, int token); + int eval(int token, int precedence, bool shortCircuit, int& res, bool& err, TPpToken * ppToken); + int evalToToken(int token, bool shortCircuit, int& res, bool& err, TPpToken * ppToken); + int CPPif (TPpToken * ppToken); + int CPPifdef(int defined, TPpToken * ppToken); + int CPPinclude(TPpToken * ppToken); + int CPPline(TPpToken * ppToken); + int CPPerror(TPpToken * ppToken); + int CPPpragma(TPpToken * ppToken); + int CPPversion(TPpToken * ppToken); + int CPPextension(TPpToken * ppToken); + int readCPPline(TPpToken * ppToken); + int scanHeaderName(TPpToken* ppToken, char delimit); + TokenStream* PrescanMacroArg(TokenStream&, TPpToken*, bool newLineOkay); + MacroExpandResult MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOkay); + + // + // From PpTokens.cpp + // + void pushTokenStreamInput(TokenStream&, bool pasting = false); + void UngetToken(int token, TPpToken*); + + class tTokenInput : public tInput { + public: + tTokenInput(TPpContext* pp, TokenStream* t, bool prepasting) : + tInput(pp), + tokens(t), + lastTokenPastes(prepasting) { } + virtual int scan(TPpToken *ppToken) override { return tokens->getToken(pp->parseContext, ppToken); } + virtual int getch() override { assert(0); return EndOfInput; } + virtual void ungetch() override { assert(0); } + virtual bool peekPasting() override { return tokens->peekTokenizedPasting(lastTokenPastes); } + bool peekContinuedPasting(int a) override { return tokens->peekContinuedPasting(a); } + protected: + TokenStream* tokens; + bool lastTokenPastes; // true if the last token in the input is to be pasted, rather than consumed as a token + }; + + class tUngotTokenInput : public tInput { + public: + tUngotTokenInput(TPpContext* pp, int t, TPpToken* p) : tInput(pp), token(t), lval(*p) { } + virtual int scan(TPpToken *) override; + virtual int getch() override { assert(0); return EndOfInput; } + virtual void ungetch() override { assert(0); } + protected: + int token; + TPpToken lval; + }; + + // + // From PpScanner.cpp + // + class tStringInput : public tInput { + public: + tStringInput(TPpContext* pp, TInputScanner& i) : tInput(pp), input(&i) { } + virtual int scan(TPpToken*) override; + + // Scanner used to get source stream characters. + // - Escaped newlines are handled here, invisibly to the caller. + // - All forms of newline are handled, and turned into just a '\n'. + int getch() override + { + int ch = input->get(); + + if (ch == '\\') { + // Move past escaped newlines, as many as sequentially exist + do { + if (input->peek() == '\r' || input->peek() == '\n') { + bool allowed = pp->parseContext.lineContinuationCheck(input->getSourceLoc(), pp->inComment); + if (! allowed && pp->inComment) + return '\\'; + + // escape one newline now + ch = input->get(); + int nextch = input->get(); + if (ch == '\r' && nextch == '\n') + ch = input->get(); + else + ch = nextch; + } else + return '\\'; + } while (ch == '\\'); + } + + // handle any non-escaped newline + if (ch == '\r' || ch == '\n') { + if (ch == '\r' && input->peek() == '\n') + input->get(); + return '\n'; + } + + return ch; + } + + // Scanner used to backup the source stream characters. Newlines are + // handled here, invisibly to the caller, meaning have to undo exactly + // what getch() above does (e.g., don't leave things in the middle of a + // sequence of escaped newlines). + void ungetch() override + { + input->unget(); + + do { + int ch = input->peek(); + if (ch == '\r' || ch == '\n') { + if (ch == '\n') { + // correct for two-character newline + input->unget(); + if (input->peek() != '\r') + input->get(); + } + // now in front of a complete newline, move past an escape character + input->unget(); + if (input->peek() == '\\') + input->unget(); + else { + input->get(); + break; + } + } else + break; + } while (true); + } + + protected: + TInputScanner* input; + }; + + // Holds a reference to included file data, as well as a + // prologue and an epilogue string. This can be scanned using the tInput + // interface and acts as a single source string. + class TokenizableIncludeFile : public tInput { + public: + // Copies prologue and epilogue. The includedFile must remain valid + // until this TokenizableIncludeFile is no longer used. + TokenizableIncludeFile(const TSourceLoc& startLoc, + const std::string& prologue, + TShader::Includer::IncludeResult* includedFile, + const std::string& epilogue, + TPpContext* pp) + : tInput(pp), + prologue_(prologue), + epilogue_(epilogue), + includedFile_(includedFile), + scanner(3, strings, lengths, nullptr, 0, 0, true), + prevScanner(nullptr), + stringInput(pp, scanner) + { + strings[0] = prologue_.data(); + strings[1] = includedFile_->headerData; + strings[2] = epilogue_.data(); + + lengths[0] = prologue_.size(); + lengths[1] = includedFile_->headerLength; + lengths[2] = epilogue_.size(); + + scanner.setLine(startLoc.line); + scanner.setString(startLoc.string); + + scanner.setFile(startLoc.getFilenameStr(), 0); + scanner.setFile(startLoc.getFilenameStr(), 1); + scanner.setFile(startLoc.getFilenameStr(), 2); + } + + // tInput methods: + int scan(TPpToken* t) override { return stringInput.scan(t); } + int getch() override { return stringInput.getch(); } + void ungetch() override { stringInput.ungetch(); } + + void notifyActivated() override + { + prevScanner = pp->parseContext.getScanner(); + pp->parseContext.setScanner(&scanner); + pp->push_include(includedFile_); + } + + void notifyDeleted() override + { + pp->parseContext.setScanner(prevScanner); + pp->pop_include(); + } + + private: + TokenizableIncludeFile& operator=(const TokenizableIncludeFile&); + + // Stores the prologue for this string. + const std::string prologue_; + + // Stores the epilogue for this string. + const std::string epilogue_; + + // Points to the IncludeResult that this TokenizableIncludeFile represents. + TShader::Includer::IncludeResult* includedFile_; + + // Will point to prologue_, includedFile_->headerData and epilogue_ + // This is passed to scanner constructor. + // These do not own the storage and it must remain valid until this + // object has been destroyed. + const char* strings[3]; + // Length of str_, passed to scanner constructor. + size_t lengths[3]; + // Scans over str_. + TInputScanner scanner; + // The previous effective scanner before the scanner in this instance + // has been activated. + TInputScanner* prevScanner; + // Delegate object implementing the tInput interface. + tStringInput stringInput; + }; + + int ScanFromString(char* s); + void missingEndifCheck(); + int lFloatConst(int len, int ch, TPpToken* ppToken); + int characterLiteral(TPpToken* ppToken); + + void push_include(TShader::Includer::IncludeResult* result) + { + currentSourceFile = result->headerName; + includeStack.push(result); + } + + void pop_include() + { + TShader::Includer::IncludeResult* include = includeStack.top(); + includeStack.pop(); + includer.releaseInclude(include); + if (includeStack.empty()) { + currentSourceFile = rootFileName; + } else { + currentSourceFile = includeStack.top()->headerName; + } + } + + bool inComment; + std::string rootFileName; + std::stack includeStack; + std::string currentSourceFile; + + std::istringstream strtodStream; + bool disableEscapeSequences; +}; + +} // end namespace glslang + +#endif // PPCONTEXT_H diff --git a/ios/include/glslang/MachineIndependent/preprocessor/PpTokens.h b/ios/include/glslang/MachineIndependent/preprocessor/PpTokens.h new file mode 100644 index 00000000..7b0f8155 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/preprocessor/PpTokens.h @@ -0,0 +1,179 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +/****************************************************************************\ +Copyright (c) 2002, NVIDIA Corporation. + +NVIDIA Corporation("NVIDIA") supplies this software to you in +consideration of your agreement to the following terms, and your use, +installation, modification or redistribution of this NVIDIA software +constitutes acceptance of these terms. If you do not agree with these +terms, please do not use, install, modify or redistribute this NVIDIA +software. + +In consideration of your agreement to abide by the following terms, and +subject to these terms, NVIDIA grants you a personal, non-exclusive +license, under NVIDIA's copyrights in this original NVIDIA software (the +"NVIDIA Software"), to use, reproduce, modify and redistribute the +NVIDIA Software, with or without modifications, in source and/or binary +forms; provided that if you redistribute the NVIDIA Software, you must +retain the copyright notice of NVIDIA, this notice and the following +text and disclaimers in all such redistributions of the NVIDIA Software. +Neither the name, trademarks, service marks nor logos of NVIDIA +Corporation may be used to endorse or promote products derived from the +NVIDIA Software without specific prior written permission from NVIDIA. +Except as expressly stated in this notice, no other rights or licenses +express or implied, are granted by NVIDIA herein, including but not +limited to any patent rights that may be infringed by your derivative +works or by other works in which the NVIDIA Software may be +incorporated. No hardware is licensed hereunder. + +THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, +INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR +ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER +PRODUCTS. + +IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, +INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY +OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE +NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, +TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF +NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +\****************************************************************************/ + +#ifndef PARSER_H +#define PARSER_H + +namespace glslang { + +// Multi-character tokens +enum EFixedAtoms { + // single character tokens get their own char value as their token; start here for multi-character tokens + PpAtomMaxSingle = 127, + + // replace bad character tokens with this, to avoid accidental aliasing with the below + PpAtomBadToken, + + // Operators + + PPAtomAddAssign, + PPAtomSubAssign, + PPAtomMulAssign, + PPAtomDivAssign, + PPAtomModAssign, + + PpAtomRight, + PpAtomLeft, + + PpAtomRightAssign, + PpAtomLeftAssign, + PpAtomAndAssign, + PpAtomOrAssign, + PpAtomXorAssign, + + PpAtomAnd, + PpAtomOr, + PpAtomXor, + + PpAtomEQ, + PpAtomNE, + PpAtomGE, + PpAtomLE, + + PpAtomDecrement, + PpAtomIncrement, + + PpAtomColonColon, + + PpAtomPaste, + + // Constants + + PpAtomConstInt, + PpAtomConstUint, + PpAtomConstInt64, + PpAtomConstUint64, + PpAtomConstInt16, + PpAtomConstUint16, + PpAtomConstFloat, + PpAtomConstDouble, + PpAtomConstFloat16, + PpAtomConstString, + + // Identifiers + PpAtomIdentifier, + + // preprocessor "keywords" + + PpAtomDefine, + PpAtomUndef, + + PpAtomIf, + PpAtomIfdef, + PpAtomIfndef, + PpAtomElse, + PpAtomElif, + PpAtomEndif, + + PpAtomLine, + PpAtomPragma, + PpAtomError, + + // #version ... + PpAtomVersion, + PpAtomCore, + PpAtomCompatibility, + PpAtomEs, + + // #extension + PpAtomExtension, + + // __LINE__, __FILE__, __VERSION__ + + PpAtomLineMacro, + PpAtomFileMacro, + PpAtomVersionMacro, + + // #include + PpAtomInclude, + + PpAtomLast, +}; + +} // end namespace glslang + +#endif /* not PARSER_H */ diff --git a/ios/include/glslang/MachineIndependent/propagateNoContraction.h b/ios/include/glslang/MachineIndependent/propagateNoContraction.h new file mode 100644 index 00000000..8521ad7d --- /dev/null +++ b/ios/include/glslang/MachineIndependent/propagateNoContraction.h @@ -0,0 +1,55 @@ +// +// Copyright (C) 2015-2016 Google, 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. +// +// Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// +// Visit the nodes in the glslang intermediate tree representation to +// propagate 'noContraction' qualifier. +// + +#pragma once + +#include "../Include/intermediate.h" + +namespace glslang { + +// Propagates the 'precise' qualifier for objects (objects marked with +// 'noContraction' qualifier) from the shader source specified 'precise' +// variables to all the involved objects, and add 'noContraction' qualifier for +// the involved arithmetic operations. +// Note that the same qualifier: 'noContraction' is used in both object nodes +// and arithmetic operation nodes, but has different meaning. For object nodes, +// 'noContraction' means the object is 'precise'; and for arithmetic operation +// nodes, it means the operation should not be contracted. +void PropagateNoContraction(const glslang::TIntermediate& intermediate); +}; diff --git a/ios/include/glslang/MachineIndependent/reflection.h b/ios/include/glslang/MachineIndependent/reflection.h new file mode 100644 index 00000000..0c33de45 --- /dev/null +++ b/ios/include/glslang/MachineIndependent/reflection.h @@ -0,0 +1,223 @@ +// +// Copyright (C) 2013-2016 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef GLSLANG_WEB + +#ifndef _REFLECTION_INCLUDED +#define _REFLECTION_INCLUDED + +#include "../Public/ShaderLang.h" +#include "../Include/Types.h" + +#include +#include + +// +// A reflection database and its interface, consistent with the OpenGL API reflection queries. +// + +namespace glslang { + +class TIntermediate; +class TIntermAggregate; +class TReflectionTraverser; + +// The full reflection database +class TReflection { +public: + TReflection(EShReflectionOptions opts, EShLanguage first, EShLanguage last) + : options(opts), firstStage(first), lastStage(last), badReflection(TObjectReflection::badReflection()) + { + for (int dim=0; dim<3; ++dim) + localSize[dim] = 0; + } + + virtual ~TReflection() {} + + // grow the reflection stage by stage + bool addStage(EShLanguage, const TIntermediate&); + + // for mapping a uniform index to a uniform object's description + int getNumUniforms() { return (int)indexToUniform.size(); } + const TObjectReflection& getUniform(int i) const + { + if (i >= 0 && i < (int)indexToUniform.size()) + return indexToUniform[i]; + else + return badReflection; + } + + // for mapping a block index to the block's description + int getNumUniformBlocks() const { return (int)indexToUniformBlock.size(); } + const TObjectReflection& getUniformBlock(int i) const + { + if (i >= 0 && i < (int)indexToUniformBlock.size()) + return indexToUniformBlock[i]; + else + return badReflection; + } + + // for mapping an pipeline input index to the input's description + int getNumPipeInputs() { return (int)indexToPipeInput.size(); } + const TObjectReflection& getPipeInput(int i) const + { + if (i >= 0 && i < (int)indexToPipeInput.size()) + return indexToPipeInput[i]; + else + return badReflection; + } + + // for mapping an pipeline output index to the output's description + int getNumPipeOutputs() { return (int)indexToPipeOutput.size(); } + const TObjectReflection& getPipeOutput(int i) const + { + if (i >= 0 && i < (int)indexToPipeOutput.size()) + return indexToPipeOutput[i]; + else + return badReflection; + } + + // for mapping from an atomic counter to the uniform index + int getNumAtomicCounters() const { return (int)atomicCounterUniformIndices.size(); } + const TObjectReflection& getAtomicCounter(int i) const + { + if (i >= 0 && i < (int)atomicCounterUniformIndices.size()) + return getUniform(atomicCounterUniformIndices[i]); + else + return badReflection; + } + + // for mapping a buffer variable index to a buffer variable object's description + int getNumBufferVariables() { return (int)indexToBufferVariable.size(); } + const TObjectReflection& getBufferVariable(int i) const + { + if (i >= 0 && i < (int)indexToBufferVariable.size()) + return indexToBufferVariable[i]; + else + return badReflection; + } + + // for mapping a storage block index to the storage block's description + int getNumStorageBuffers() const { return (int)indexToBufferBlock.size(); } + const TObjectReflection& getStorageBufferBlock(int i) const + { + if (i >= 0 && i < (int)indexToBufferBlock.size()) + return indexToBufferBlock[i]; + else + return badReflection; + } + + // for mapping any name to its index (block names, uniform names and input/output names) + int getIndex(const char* name) const + { + TNameToIndex::const_iterator it = nameToIndex.find(name); + if (it == nameToIndex.end()) + return -1; + else + return it->second; + } + + // see getIndex(const char*) + int getIndex(const TString& name) const { return getIndex(name.c_str()); } + + + // for mapping any name to its index (only pipe input/output names) + int getPipeIOIndex(const char* name, const bool inOrOut) const + { + TNameToIndex::const_iterator it = inOrOut ? pipeInNameToIndex.find(name) : pipeOutNameToIndex.find(name); + if (it == (inOrOut ? pipeInNameToIndex.end() : pipeOutNameToIndex.end())) + return -1; + else + return it->second; + } + + // see gePipeIOIndex(const char*, const bool) + int getPipeIOIndex(const TString& name, const bool inOrOut) const { return getPipeIOIndex(name.c_str(), inOrOut); } + + // Thread local size + unsigned getLocalSize(int dim) const { return dim <= 2 ? localSize[dim] : 0; } + + void dump(); + +protected: + friend class glslang::TReflectionTraverser; + + void buildCounterIndices(const TIntermediate&); + void buildUniformStageMask(const TIntermediate& intermediate); + void buildAttributeReflection(EShLanguage, const TIntermediate&); + + // Need a TString hash: typedef std::unordered_map TNameToIndex; + typedef std::map TNameToIndex; + typedef std::vector TMapIndexToReflection; + typedef std::vector TIndices; + + TMapIndexToReflection& GetBlockMapForStorage(TStorageQualifier storage) + { + if ((options & EShReflectionSeparateBuffers) && storage == EvqBuffer) + return indexToBufferBlock; + return indexToUniformBlock; + } + TMapIndexToReflection& GetVariableMapForStorage(TStorageQualifier storage) + { + if ((options & EShReflectionSeparateBuffers) && storage == EvqBuffer) + return indexToBufferVariable; + return indexToUniform; + } + + EShReflectionOptions options; + + EShLanguage firstStage; + EShLanguage lastStage; + + TObjectReflection badReflection; // return for queries of -1 or generally out of range; has expected descriptions with in it for this + TNameToIndex nameToIndex; // maps names to indexes; can hold all types of data: uniform/buffer and which function names have been processed + TNameToIndex pipeInNameToIndex; // maps pipe in names to indexes, this is a fix to seperate pipe I/O from uniforms and buffers. + TNameToIndex pipeOutNameToIndex; // maps pipe out names to indexes, this is a fix to seperate pipe I/O from uniforms and buffers. + TMapIndexToReflection indexToUniform; + TMapIndexToReflection indexToUniformBlock; + TMapIndexToReflection indexToBufferVariable; + TMapIndexToReflection indexToBufferBlock; + TMapIndexToReflection indexToPipeInput; + TMapIndexToReflection indexToPipeOutput; + TIndices atomicCounterUniformIndices; + + unsigned int localSize[3]; +}; + +} // end namespace glslang + +#endif // _REFLECTION_INCLUDED + +#endif // GLSLANG_WEB diff --git a/ios/include/glslang/Public/ShaderLang.h b/ios/include/glslang/Public/ShaderLang.h new file mode 100644 index 00000000..7905b3d1 --- /dev/null +++ b/ios/include/glslang/Public/ShaderLang.h @@ -0,0 +1,932 @@ +// +// Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +// Copyright (C) 2013-2016 LunarG, Inc. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +#ifndef _COMPILER_INTERFACE_INCLUDED_ +#define _COMPILER_INTERFACE_INCLUDED_ + +#include "../Include/ResourceLimits.h" +#include "../MachineIndependent/Versions.h" + +#include +#include + +#ifdef _WIN32 +#define C_DECL __cdecl +//#ifdef SH_EXPORTING +// #define SH_IMPORT_EXPORT __declspec(dllexport) +//#else +// #define SH_IMPORT_EXPORT __declspec(dllimport) +//#endif +#define SH_IMPORT_EXPORT +#else +#define SH_IMPORT_EXPORT +#define C_DECL +#endif + +// +// This is the platform independent interface between an OGL driver +// and the shading language compiler/linker. +// + +#ifdef __cplusplus + extern "C" { +#endif + +// This should always increase, as some paths to do not consume +// a more major number. +// It should increment by one when new functionality is added. +#define GLSLANG_MINOR_VERSION 14 + +// +// Call before doing any other compiler/linker operations. +// +// (Call once per process, not once per thread.) +// +SH_IMPORT_EXPORT int ShInitialize(); + +// +// Call this at process shutdown to clean up memory. +// +SH_IMPORT_EXPORT int ShFinalize(); + +// +// Types of languages the compiler can consume. +// +typedef enum { + EShLangVertex, + EShLangTessControl, + EShLangTessEvaluation, + EShLangGeometry, + EShLangFragment, + EShLangCompute, + EShLangRayGen, + EShLangRayGenNV = EShLangRayGen, + EShLangIntersect, + EShLangIntersectNV = EShLangIntersect, + EShLangAnyHit, + EShLangAnyHitNV = EShLangAnyHit, + EShLangClosestHit, + EShLangClosestHitNV = EShLangClosestHit, + EShLangMiss, + EShLangMissNV = EShLangMiss, + EShLangCallable, + EShLangCallableNV = EShLangCallable, + EShLangTaskNV, + EShLangMeshNV, + LAST_ELEMENT_MARKER(EShLangCount), +} EShLanguage; // would be better as stage, but this is ancient now + +typedef enum : unsigned { + EShLangVertexMask = (1 << EShLangVertex), + EShLangTessControlMask = (1 << EShLangTessControl), + EShLangTessEvaluationMask = (1 << EShLangTessEvaluation), + EShLangGeometryMask = (1 << EShLangGeometry), + EShLangFragmentMask = (1 << EShLangFragment), + EShLangComputeMask = (1 << EShLangCompute), + EShLangRayGenMask = (1 << EShLangRayGen), + EShLangRayGenNVMask = EShLangRayGenMask, + EShLangIntersectMask = (1 << EShLangIntersect), + EShLangIntersectNVMask = EShLangIntersectMask, + EShLangAnyHitMask = (1 << EShLangAnyHit), + EShLangAnyHitNVMask = EShLangAnyHitMask, + EShLangClosestHitMask = (1 << EShLangClosestHit), + EShLangClosestHitNVMask = EShLangClosestHitMask, + EShLangMissMask = (1 << EShLangMiss), + EShLangMissNVMask = EShLangMissMask, + EShLangCallableMask = (1 << EShLangCallable), + EShLangCallableNVMask = EShLangCallableMask, + EShLangTaskNVMask = (1 << EShLangTaskNV), + EShLangMeshNVMask = (1 << EShLangMeshNV), + LAST_ELEMENT_MARKER(EShLanguageMaskCount), +} EShLanguageMask; + +namespace glslang { + +class TType; + +typedef enum { + EShSourceNone, + EShSourceGlsl, // GLSL, includes ESSL (OpenGL ES GLSL) + EShSourceHlsl, // HLSL + LAST_ELEMENT_MARKER(EShSourceCount), +} EShSource; // if EShLanguage were EShStage, this could be EShLanguage instead + +typedef enum { + EShClientNone, // use when there is no client, e.g. for validation + EShClientVulkan, + EShClientOpenGL, + LAST_ELEMENT_MARKER(EShClientCount), +} EShClient; + +typedef enum { + EShTargetNone, + EShTargetSpv, // SPIR-V (preferred spelling) + EshTargetSpv = EShTargetSpv, // legacy spelling + LAST_ELEMENT_MARKER(EShTargetCount), +} EShTargetLanguage; + +typedef enum { + EShTargetVulkan_1_0 = (1 << 22), // Vulkan 1.0 + EShTargetVulkan_1_1 = (1 << 22) | (1 << 12), // Vulkan 1.1 + EShTargetVulkan_1_2 = (1 << 22) | (2 << 12), // Vulkan 1.2 + EShTargetOpenGL_450 = 450, // OpenGL + LAST_ELEMENT_MARKER(EShTargetClientVersionCount), +} EShTargetClientVersion; + +typedef EShTargetClientVersion EshTargetClientVersion; + +typedef enum { + EShTargetSpv_1_0 = (1 << 16), // SPIR-V 1.0 + EShTargetSpv_1_1 = (1 << 16) | (1 << 8), // SPIR-V 1.1 + EShTargetSpv_1_2 = (1 << 16) | (2 << 8), // SPIR-V 1.2 + EShTargetSpv_1_3 = (1 << 16) | (3 << 8), // SPIR-V 1.3 + EShTargetSpv_1_4 = (1 << 16) | (4 << 8), // SPIR-V 1.4 + EShTargetSpv_1_5 = (1 << 16) | (5 << 8), // SPIR-V 1.5 + LAST_ELEMENT_MARKER(EShTargetLanguageVersionCount), +} EShTargetLanguageVersion; + +struct TInputLanguage { + EShSource languageFamily; // redundant information with other input, this one overrides when not EShSourceNone + EShLanguage stage; // redundant information with other input, this one overrides when not EShSourceNone + EShClient dialect; + int dialectVersion; // version of client's language definition, not the client (when not EShClientNone) +}; + +struct TClient { + EShClient client; + EShTargetClientVersion version; // version of client itself (not the client's input dialect) +}; + +struct TTarget { + EShTargetLanguage language; + EShTargetLanguageVersion version; // version to target, if SPIR-V, defined by "word 1" of the SPIR-V header + bool hlslFunctionality1; // can target hlsl_functionality1 extension(s) +}; + +// All source/client/target versions and settings. +// Can override previous methods of setting, when items are set here. +// Expected to grow, as more are added, rather than growing parameter lists. +struct TEnvironment { + TInputLanguage input; // definition of the input language + TClient client; // what client is the overall compilation being done for? + TTarget target; // what to generate +}; + +const char* StageName(EShLanguage); + +} // end namespace glslang + +// +// Types of output the linker will create. +// +typedef enum { + EShExVertexFragment, + EShExFragment +} EShExecutable; + +// +// Optimization level for the compiler. +// +typedef enum { + EShOptNoGeneration, + EShOptNone, + EShOptSimple, // Optimizations that can be done quickly + EShOptFull, // Optimizations that will take more time + LAST_ELEMENT_MARKER(EshOptLevelCount), +} EShOptimizationLevel; + +// +// Texture and Sampler transformation mode. +// +typedef enum { + EShTexSampTransKeep, // keep textures and samplers as is (default) + EShTexSampTransUpgradeTextureRemoveSampler, // change texture w/o embeded sampler into sampled texture and throw away all samplers + LAST_ELEMENT_MARKER(EShTexSampTransCount), +} EShTextureSamplerTransformMode; + +// +// Message choices for what errors and warnings are given. +// +enum EShMessages : unsigned { + EShMsgDefault = 0, // default is to give all required errors and extra warnings + EShMsgRelaxedErrors = (1 << 0), // be liberal in accepting input + EShMsgSuppressWarnings = (1 << 1), // suppress all warnings, except those required by the specification + EShMsgAST = (1 << 2), // print the AST intermediate representation + EShMsgSpvRules = (1 << 3), // issue messages for SPIR-V generation + EShMsgVulkanRules = (1 << 4), // issue messages for Vulkan-requirements of GLSL for SPIR-V + EShMsgOnlyPreprocessor = (1 << 5), // only print out errors produced by the preprocessor + EShMsgReadHlsl = (1 << 6), // use HLSL parsing rules and semantics + EShMsgCascadingErrors = (1 << 7), // get cascading errors; risks error-recovery issues, instead of an early exit + EShMsgKeepUncalled = (1 << 8), // for testing, don't eliminate uncalled functions + EShMsgHlslOffsets = (1 << 9), // allow block offsets to follow HLSL rules instead of GLSL rules + EShMsgDebugInfo = (1 << 10), // save debug information + EShMsgHlslEnable16BitTypes = (1 << 11), // enable use of 16-bit types in SPIR-V for HLSL + EShMsgHlslLegalization = (1 << 12), // enable HLSL Legalization messages + EShMsgHlslDX9Compatible = (1 << 13), // enable HLSL DX9 compatible mode (for samplers and semantics) + EShMsgBuiltinSymbolTable = (1 << 14), // print the builtin symbol table + LAST_ELEMENT_MARKER(EShMsgCount), +}; + +// +// Options for building reflection +// +typedef enum { + EShReflectionDefault = 0, // default is original behaviour before options were added + EShReflectionStrictArraySuffix = (1 << 0), // reflection will follow stricter rules for array-of-structs suffixes + EShReflectionBasicArraySuffix = (1 << 1), // arrays of basic types will be appended with [0] as in GL reflection + EShReflectionIntermediateIO = (1 << 2), // reflect inputs and outputs to program, even with no vertex shader + EShReflectionSeparateBuffers = (1 << 3), // buffer variables and buffer blocks are reflected separately + EShReflectionAllBlockVariables = (1 << 4), // reflect all variables in blocks, even if they are inactive + EShReflectionUnwrapIOBlocks = (1 << 5), // unwrap input/output blocks the same as with uniform blocks + EShReflectionAllIOVariables = (1 << 6), // reflect all input/output variables, even if they are inactive + EShReflectionSharedStd140SSBO = (1 << 7), // Apply std140/shared rules for ubo to ssbo + EShReflectionSharedStd140UBO = (1 << 8), // Apply std140/shared rules for ubo to ssbo + LAST_ELEMENT_MARKER(EShReflectionCount), +} EShReflectionOptions; + +// +// Build a table for bindings. This can be used for locating +// attributes, uniforms, globals, etc., as needed. +// +typedef struct { + const char* name; + int binding; +} ShBinding; + +typedef struct { + int numBindings; + ShBinding* bindings; // array of bindings +} ShBindingTable; + +// +// ShHandle held by but opaque to the driver. It is allocated, +// managed, and de-allocated by the compiler/linker. It's contents +// are defined by and used by the compiler and linker. For example, +// symbol table information and object code passed from the compiler +// to the linker can be stored where ShHandle points. +// +// If handle creation fails, 0 will be returned. +// +typedef void* ShHandle; + +// +// Driver calls these to create and destroy compiler/linker +// objects. +// +SH_IMPORT_EXPORT ShHandle ShConstructCompiler(const EShLanguage, int debugOptions); // one per shader +SH_IMPORT_EXPORT ShHandle ShConstructLinker(const EShExecutable, int debugOptions); // one per shader pair +SH_IMPORT_EXPORT ShHandle ShConstructUniformMap(); // one per uniform namespace (currently entire program object) +SH_IMPORT_EXPORT void ShDestruct(ShHandle); + +// +// The return value of ShCompile is boolean, non-zero indicating +// success. +// +// The info-log should be written by ShCompile into +// ShHandle, so it can answer future queries. +// +SH_IMPORT_EXPORT int ShCompile( + const ShHandle, + const char* const shaderStrings[], + const int numStrings, + const int* lengths, + const EShOptimizationLevel, + const TBuiltInResource *resources, + int debugOptions, + int defaultVersion = 110, // use 100 for ES environment, overridden by #version in shader + bool forwardCompatible = false, // give errors for use of deprecated features + EShMessages messages = EShMsgDefault // warnings and errors + ); + +SH_IMPORT_EXPORT int ShLinkExt( + const ShHandle, // linker object + const ShHandle h[], // compiler objects to link together + const int numHandles); + +// +// ShSetEncrpytionMethod is a place-holder for specifying +// how source code is encrypted. +// +SH_IMPORT_EXPORT void ShSetEncryptionMethod(ShHandle); + +// +// All the following return 0 if the information is not +// available in the object passed down, or the object is bad. +// +SH_IMPORT_EXPORT const char* ShGetInfoLog(const ShHandle); +SH_IMPORT_EXPORT const void* ShGetExecutable(const ShHandle); +SH_IMPORT_EXPORT int ShSetVirtualAttributeBindings(const ShHandle, const ShBindingTable*); // to detect user aliasing +SH_IMPORT_EXPORT int ShSetFixedAttributeBindings(const ShHandle, const ShBindingTable*); // to force any physical mappings +// +// Tell the linker to never assign a vertex attribute to this list of physical attributes +// +SH_IMPORT_EXPORT int ShExcludeAttributes(const ShHandle, int *attributes, int count); + +// +// Returns the location ID of the named uniform. +// Returns -1 if error. +// +SH_IMPORT_EXPORT int ShGetUniformLocation(const ShHandle uniformMap, const char* name); + +#ifdef __cplusplus + } // end extern "C" +#endif + +//////////////////////////////////////////////////////////////////////////////////////////// +// +// Deferred-Lowering C++ Interface +// ----------------------------------- +// +// Below is a new alternate C++ interface, which deprecates the above +// opaque handle-based interface. +// +// The below is further designed to handle multiple compilation units per stage, where +// the intermediate results, including the parse tree, are preserved until link time, +// rather than the above interface which is designed to have each compilation unit +// lowered at compile time. In the above model, linking occurs on the lowered results, +// whereas in this model intra-stage linking can occur at the parse tree +// (treeRoot in TIntermediate) level, and then a full stage can be lowered. +// + +#include +#include +#include + +class TCompiler; +class TInfoSink; + +namespace glslang { + +const char* GetEsslVersionString(); +const char* GetGlslVersionString(); +int GetKhronosToolId(); + +class TIntermediate; +class TProgram; +class TPoolAllocator; + +// Call this exactly once per process before using anything else +bool InitializeProcess(); + +// Call once per process to tear down everything +void FinalizeProcess(); + +// Resource type for IO resolver +enum TResourceType { + EResSampler, + EResTexture, + EResImage, + EResUbo, + EResSsbo, + EResUav, + EResCount +}; + + +// Make one TShader per shader that you will link into a program. Then +// - provide the shader through setStrings() or setStringsWithLengths() +// - optionally call setEnv*(), see below for more detail +// - optionally use setPreamble() to set a special shader string that will be +// processed before all others but won't affect the validity of #version +// - optionally call addProcesses() for each setting/transform, +// see comment for class TProcesses +// - call parse(): source language and target environment must be selected +// either by correct setting of EShMessages sent to parse(), or by +// explicitly calling setEnv*() +// - query the info logs +// +// N.B.: Does not yet support having the same TShader instance being linked into +// multiple programs. +// +// N.B.: Destruct a linked program *before* destructing the shaders linked into it. +// +class TShader { +public: + explicit TShader(EShLanguage); + virtual ~TShader(); + void setStrings(const char* const* s, int n); + void setStringsWithLengths(const char* const* s, const int* l, int n); + void setStringsWithLengthsAndNames( + const char* const* s, const int* l, const char* const* names, int n); + void setPreamble(const char* s) { preamble = s; } + void setEntryPoint(const char* entryPoint); + void setSourceEntryPoint(const char* sourceEntryPointName); + void addProcesses(const std::vector&); + + // IO resolver binding data: see comments in ShaderLang.cpp + void setShiftBinding(TResourceType res, unsigned int base); + void setShiftSamplerBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftTextureBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftImageBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftUboBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftUavBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftCbufferBinding(unsigned int base); // synonym for setShiftUboBinding + void setShiftSsboBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftBindingForSet(TResourceType res, unsigned int base, unsigned int set); + void setResourceSetBinding(const std::vector& base); + void setAutoMapBindings(bool map); + void setAutoMapLocations(bool map); + void addUniformLocationOverride(const char* name, int loc); + void setUniformLocationBase(int base); + void setInvertY(bool invert); +#ifdef ENABLE_HLSL + void setHlslIoMapping(bool hlslIoMap); + void setFlattenUniformArrays(bool flatten); +#endif + void setNoStorageFormat(bool useUnknownFormat); + void setNanMinMaxClamp(bool nanMinMaxClamp); + void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode); + + // For setting up the environment (cleared to nothingness in the constructor). + // These must be called so that parsing is done for the right source language and + // target environment, either indirectly through TranslateEnvironment() based on + // EShMessages et. al., or directly by the user. + // + // setEnvInput: The input source language and stage. If generating code for a + // specific client, the input client semantics to use and the + // version of the that client's input semantics to use, otherwise + // use EShClientNone and version of 0, e.g. for validation mode. + // Note 'version' does not describe the target environment, + // just the version of the source dialect to compile under. + // + // See the definitions of TEnvironment, EShSource, EShLanguage, + // and EShClient for choices and more detail. + // + // setEnvClient: The client that will be hosting the execution, and it's version. + // Note 'version' is not the version of the languages involved, but + // the version of the client environment. + // Use EShClientNone and version of 0 if there is no client, e.g. + // for validation mode. + // + // See EShTargetClientVersion for choices. + // + // setEnvTarget: The language to translate to when generating code, and that + // language's version. + // Use EShTargetNone and version of 0 if there is no client, e.g. + // for validation mode. + // + void setEnvInput(EShSource lang, EShLanguage envStage, EShClient client, int version) + { + environment.input.languageFamily = lang; + environment.input.stage = envStage; + environment.input.dialect = client; + environment.input.dialectVersion = version; + } + void setEnvClient(EShClient client, EShTargetClientVersion version) + { + environment.client.client = client; + environment.client.version = version; + } + void setEnvTarget(EShTargetLanguage lang, EShTargetLanguageVersion version) + { + environment.target.language = lang; + environment.target.version = version; + } + + void getStrings(const char* const* &s, int& n) { s = strings; n = numStrings; } + +#ifdef ENABLE_HLSL + void setEnvTargetHlslFunctionality1() { environment.target.hlslFunctionality1 = true; } + bool getEnvTargetHlslFunctionality1() const { return environment.target.hlslFunctionality1; } +#else + bool getEnvTargetHlslFunctionality1() const { return false; } +#endif + + // Interface to #include handlers. + // + // To support #include, a client of Glslang does the following: + // 1. Call setStringsWithNames to set the source strings and associated + // names. For example, the names could be the names of the files + // containing the shader sources. + // 2. Call parse with an Includer. + // + // When the Glslang parser encounters an #include directive, it calls + // the Includer's include method with the requested include name + // together with the current string name. The returned IncludeResult + // contains the fully resolved name of the included source, together + // with the source text that should replace the #include directive + // in the source stream. After parsing that source, Glslang will + // release the IncludeResult object. + class Includer { + public: + // An IncludeResult contains the resolved name and content of a source + // inclusion. + struct IncludeResult { + IncludeResult(const std::string& headerName, const char* const headerData, const size_t headerLength, void* userData) : + headerName(headerName), headerData(headerData), headerLength(headerLength), userData(userData) { } + // For a successful inclusion, the fully resolved name of the requested + // include. For example, in a file system-based includer, full resolution + // should convert a relative path name into an absolute path name. + // For a failed inclusion, this is an empty string. + const std::string headerName; + // The content and byte length of the requested inclusion. The + // Includer producing this IncludeResult retains ownership of the + // storage. + // For a failed inclusion, the header + // field points to a string containing error details. + const char* const headerData; + const size_t headerLength; + // Include resolver's context. + void* userData; + protected: + IncludeResult& operator=(const IncludeResult&); + IncludeResult(); + }; + + // For both include methods below: + // + // Resolves an inclusion request by name, current source name, + // and include depth. + // On success, returns an IncludeResult containing the resolved name + // and content of the include. + // On failure, returns a nullptr, or an IncludeResult + // with an empty string for the headerName and error details in the + // header field. + // The Includer retains ownership of the contents + // of the returned IncludeResult value, and those contents must + // remain valid until the releaseInclude method is called on that + // IncludeResult object. + // + // Note "local" vs. "system" is not an "either/or": "local" is an + // extra thing to do over "system". Both might get called, as per + // the C++ specification. + + // For the "system" or <>-style includes; search the "system" paths. + virtual IncludeResult* includeSystem(const char* /*headerName*/, + const char* /*includerName*/, + size_t /*inclusionDepth*/) { return nullptr; } + + // For the "local"-only aspect of a "" include. Should not search in the + // "system" paths, because on returning a failure, the parser will + // call includeSystem() to look in the "system" locations. + virtual IncludeResult* includeLocal(const char* /*headerName*/, + const char* /*includerName*/, + size_t /*inclusionDepth*/) { return nullptr; } + + // Signals that the parser will no longer use the contents of the + // specified IncludeResult. + virtual void releaseInclude(IncludeResult*) = 0; + virtual ~Includer() {} + }; + + // Fail all Includer searches + class ForbidIncluder : public Includer { + public: + virtual void releaseInclude(IncludeResult*) override { } + }; + + bool parse(const TBuiltInResource*, int defaultVersion, EProfile defaultProfile, bool forceDefaultVersionAndProfile, + bool forwardCompatible, EShMessages, Includer&); + + bool parse(const TBuiltInResource* res, int defaultVersion, EProfile defaultProfile, bool forceDefaultVersionAndProfile, + bool forwardCompatible, EShMessages messages) + { + TShader::ForbidIncluder includer; + return parse(res, defaultVersion, defaultProfile, forceDefaultVersionAndProfile, forwardCompatible, messages, includer); + } + + // Equivalent to parse() without a default profile and without forcing defaults. + bool parse(const TBuiltInResource* builtInResources, int defaultVersion, bool forwardCompatible, EShMessages messages) + { + return parse(builtInResources, defaultVersion, ENoProfile, false, forwardCompatible, messages); + } + + bool parse(const TBuiltInResource* builtInResources, int defaultVersion, bool forwardCompatible, EShMessages messages, + Includer& includer) + { + return parse(builtInResources, defaultVersion, ENoProfile, false, forwardCompatible, messages, includer); + } + + // NOTE: Doing just preprocessing to obtain a correct preprocessed shader string + // is not an officially supported or fully working path. + bool preprocess(const TBuiltInResource* builtInResources, + int defaultVersion, EProfile defaultProfile, bool forceDefaultVersionAndProfile, + bool forwardCompatible, EShMessages message, std::string* outputString, + Includer& includer); + + const char* getInfoLog(); + const char* getInfoDebugLog(); + EShLanguage getStage() const { return stage; } + TIntermediate* getIntermediate() const { return intermediate; } + +protected: + TPoolAllocator* pool; + EShLanguage stage; + TCompiler* compiler; + TIntermediate* intermediate; + TInfoSink* infoSink; + // strings and lengths follow the standard for glShaderSource: + // strings is an array of numStrings pointers to string data. + // lengths can be null, but if not it is an array of numStrings + // integers containing the length of the associated strings. + // if lengths is null or lengths[n] < 0 the associated strings[n] is + // assumed to be null-terminated. + // stringNames is the optional names for all the strings. If stringNames + // is null, then none of the strings has name. If a certain element in + // stringNames is null, then the corresponding string does not have name. + const char* const* strings; // explicit code to compile, see previous comment + const int* lengths; + const char* const* stringNames; + int numStrings; // size of the above arrays + const char* preamble; // string of implicit code to compile before the explicitly provided code + + // a function in the source string can be renamed FROM this TO the name given in setEntryPoint. + std::string sourceEntryPointName; + + TEnvironment environment; + + friend class TProgram; + +private: + TShader& operator=(TShader&); +}; + +#ifndef GLSLANG_WEB + +// +// A reflection database and its interface, consistent with the OpenGL API reflection queries. +// + +// Data needed for just a single object at the granularity exchanged by the reflection API +class TObjectReflection { +public: + TObjectReflection(const std::string& pName, const TType& pType, int pOffset, int pGLDefineType, int pSize, int pIndex); + + const TType* getType() const { return type; } + int getBinding() const; + void dump() const; + static TObjectReflection badReflection() { return TObjectReflection(); } + + std::string name; + int offset; + int glDefineType; + int size; // data size in bytes for a block, array size for a (non-block) object that's an array + int index; + int counterIndex; + int numMembers; + int arrayStride; // stride of an array variable + int topLevelArraySize; // size of the top-level variable in a storage buffer member + int topLevelArrayStride; // stride of the top-level variable in a storage buffer member + EShLanguageMask stages; + +protected: + TObjectReflection() + : offset(-1), glDefineType(-1), size(-1), index(-1), counterIndex(-1), numMembers(-1), arrayStride(0), + topLevelArrayStride(0), stages(EShLanguageMask(0)), type(nullptr) + { + } + + const TType* type; +}; + +class TReflection; +class TIoMapper; +struct TVarEntryInfo; + +// Allows to customize the binding layout after linking. +// All used uniform variables will invoke at least validateBinding. +// If validateBinding returned true then the other resolveBinding, +// resolveSet, and resolveLocation are invoked to resolve the binding +// and descriptor set index respectively. +// +// Invocations happen in a particular order: +// 1) all shader inputs +// 2) all shader outputs +// 3) all uniforms with binding and set already defined +// 4) all uniforms with binding but no set defined +// 5) all uniforms with set but no binding defined +// 6) all uniforms with no binding and no set defined +// +// mapIO will use this resolver in two phases. The first +// phase is a notification phase, calling the corresponging +// notifiy callbacks, this phase ends with a call to endNotifications. +// Phase two starts directly after the call to endNotifications +// and calls all other callbacks to validate and to get the +// bindings, sets, locations, component and color indices. +// +// NOTE: that still limit checks are applied to bindings and sets +// and may result in an error. +class TIoMapResolver +{ +public: + virtual ~TIoMapResolver() {} + + // Should return true if the resulting/current binding would be okay. + // Basic idea is to do aliasing binding checks with this. + virtual bool validateBinding(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return a value >= 0 if the current binding should be overridden. + // Return -1 if the current binding (including no binding) should be kept. + virtual int resolveBinding(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return a value >= 0 if the current set should be overridden. + // Return -1 if the current set (including no set) should be kept. + virtual int resolveSet(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return a value >= 0 if the current location should be overridden. + // Return -1 if the current location (including no location) should be kept. + virtual int resolveUniformLocation(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return true if the resulting/current setup would be okay. + // Basic idea is to do aliasing checks and reject invalid semantic names. + virtual bool validateInOut(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return a value >= 0 if the current location should be overridden. + // Return -1 if the current location (including no location) should be kept. + virtual int resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return a value >= 0 if the current component index should be overridden. + // Return -1 if the current component index (including no index) should be kept. + virtual int resolveInOutComponent(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Should return a value >= 0 if the current color index should be overridden. + // Return -1 if the current color index (including no index) should be kept. + virtual int resolveInOutIndex(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Notification of a uniform variable + virtual void notifyBinding(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Notification of a in or out variable + virtual void notifyInOut(EShLanguage stage, TVarEntryInfo& ent) = 0; + // Called by mapIO when it starts its notify pass for the given stage + virtual void beginNotifications(EShLanguage stage) = 0; + // Called by mapIO when it has finished the notify pass + virtual void endNotifications(EShLanguage stage) = 0; + // Called by mipIO when it starts its resolve pass for the given stage + virtual void beginResolve(EShLanguage stage) = 0; + // Called by mapIO when it has finished the resolve pass + virtual void endResolve(EShLanguage stage) = 0; + // Called by mapIO when it starts its symbol collect for teh given stage + virtual void beginCollect(EShLanguage stage) = 0; + // Called by mapIO when it has finished the symbol collect + virtual void endCollect(EShLanguage stage) = 0; + // Called by TSlotCollector to resolve storage locations or bindings + virtual void reserverStorageSlot(TVarEntryInfo& ent, TInfoSink& infoSink) = 0; + // Called by TSlotCollector to resolve resource locations or bindings + virtual void reserverResourceSlot(TVarEntryInfo& ent, TInfoSink& infoSink) = 0; + // Called by mapIO.addStage to set shader stage mask to mark a stage be added to this pipeline + virtual void addStage(EShLanguage stage) = 0; +}; + +#endif // GLSLANG_WEB + +// Make one TProgram per set of shaders that will get linked together. Add all +// the shaders that are to be linked together. After calling shader.parse() +// for all shaders, call link(). +// +// N.B.: Destruct a linked program *before* destructing the shaders linked into it. +// +class TProgram { +public: + TProgram(); + virtual ~TProgram(); + void addShader(TShader* shader) { stages[shader->stage].push_back(shader); } + std::list& getShaders(EShLanguage stage) { return stages[stage]; } + // Link Validation interface + bool link(EShMessages); + const char* getInfoLog(); + const char* getInfoDebugLog(); + + TIntermediate* getIntermediate(EShLanguage stage) const { return intermediate[stage]; } + +#ifndef GLSLANG_WEB + + // Reflection Interface + + // call first, to do liveness analysis, index mapping, etc.; returns false on failure + bool buildReflection(int opts = EShReflectionDefault); + unsigned getLocalSize(int dim) const; // return dim'th local size + int getReflectionIndex(const char *name) const; + int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const; + int getNumUniformVariables() const; + const TObjectReflection& getUniform(int index) const; + int getNumUniformBlocks() const; + const TObjectReflection& getUniformBlock(int index) const; + int getNumPipeInputs() const; + const TObjectReflection& getPipeInput(int index) const; + int getNumPipeOutputs() const; + const TObjectReflection& getPipeOutput(int index) const; + int getNumBufferVariables() const; + const TObjectReflection& getBufferVariable(int index) const; + int getNumBufferBlocks() const; + const TObjectReflection& getBufferBlock(int index) const; + int getNumAtomicCounters() const; + const TObjectReflection& getAtomicCounter(int index) const; + + // Legacy Reflection Interface - expressed in terms of above interface + + // can be used for glGetProgramiv(GL_ACTIVE_UNIFORMS) + int getNumLiveUniformVariables() const { return getNumUniformVariables(); } + + // can be used for glGetProgramiv(GL_ACTIVE_UNIFORM_BLOCKS) + int getNumLiveUniformBlocks() const { return getNumUniformBlocks(); } + + // can be used for glGetProgramiv(GL_ACTIVE_ATTRIBUTES) + int getNumLiveAttributes() const { return getNumPipeInputs(); } + + // can be used for glGetUniformIndices() + int getUniformIndex(const char *name) const { return getReflectionIndex(name); } + + int getPipeIOIndex(const char *name, const bool inOrOut) const + { return getReflectionPipeIOIndex(name, inOrOut); } + + // can be used for "name" part of glGetActiveUniform() + const char *getUniformName(int index) const { return getUniform(index).name.c_str(); } + + // returns the binding number + int getUniformBinding(int index) const { return getUniform(index).getBinding(); } + + // returns Shaders Stages where a Uniform is present + EShLanguageMask getUniformStages(int index) const { return getUniform(index).stages; } + + // can be used for glGetActiveUniformsiv(GL_UNIFORM_BLOCK_INDEX) + int getUniformBlockIndex(int index) const { return getUniform(index).index; } + + // can be used for glGetActiveUniformsiv(GL_UNIFORM_TYPE) + int getUniformType(int index) const { return getUniform(index).glDefineType; } + + // can be used for glGetActiveUniformsiv(GL_UNIFORM_OFFSET) + int getUniformBufferOffset(int index) const { return getUniform(index).offset; } + + // can be used for glGetActiveUniformsiv(GL_UNIFORM_SIZE) + int getUniformArraySize(int index) const { return getUniform(index).size; } + + // returns a TType* + const TType *getUniformTType(int index) const { return getUniform(index).getType(); } + + // can be used for glGetActiveUniformBlockName() + const char *getUniformBlockName(int index) const { return getUniformBlock(index).name.c_str(); } + + // can be used for glGetActiveUniformBlockiv(UNIFORM_BLOCK_DATA_SIZE) + int getUniformBlockSize(int index) const { return getUniformBlock(index).size; } + + // returns the block binding number + int getUniformBlockBinding(int index) const { return getUniformBlock(index).getBinding(); } + + // returns block index of associated counter. + int getUniformBlockCounterIndex(int index) const { return getUniformBlock(index).counterIndex; } + + // returns a TType* + const TType *getUniformBlockTType(int index) const { return getUniformBlock(index).getType(); } + + // can be used for glGetActiveAttrib() + const char *getAttributeName(int index) const { return getPipeInput(index).name.c_str(); } + + // can be used for glGetActiveAttrib() + int getAttributeType(int index) const { return getPipeInput(index).glDefineType; } + + // returns a TType* + const TType *getAttributeTType(int index) const { return getPipeInput(index).getType(); } + + void dumpReflection(); + // I/O mapping: apply base offsets and map live unbound variables + // If resolver is not provided it uses the previous approach + // and respects auto assignment and offsets. + bool mapIO(TIoMapResolver* pResolver = nullptr, TIoMapper* pIoMapper = nullptr); +#endif + +protected: + bool linkStage(EShLanguage, EShMessages); + + TPoolAllocator* pool; + std::list stages[EShLangCount]; + TIntermediate* intermediate[EShLangCount]; + bool newedIntermediate[EShLangCount]; // track which intermediate were "new" versus reusing a singleton unit in a stage + TInfoSink* infoSink; +#ifndef GLSLANG_WEB + TReflection* reflection; +#endif + bool linked; + +private: + TProgram(TProgram&); + TProgram& operator=(TProgram&); +}; + +} // end namespace glslang + +#endif // _COMPILER_INTERFACE_INCLUDED_ diff --git a/ios/include/glslang/SPIRV/GLSL.ext.AMD.h b/ios/include/glslang/SPIRV/GLSL.ext.AMD.h new file mode 100644 index 00000000..009d2f1c --- /dev/null +++ b/ios/include/glslang/SPIRV/GLSL.ext.AMD.h @@ -0,0 +1,108 @@ +/* +** Copyright (c) 2014-2016 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +#ifndef GLSLextAMD_H +#define GLSLextAMD_H + +static const int GLSLextAMDVersion = 100; +static const int GLSLextAMDRevision = 7; + +// SPV_AMD_shader_ballot +static const char* const E_SPV_AMD_shader_ballot = "SPV_AMD_shader_ballot"; + +enum ShaderBallotAMD { + ShaderBallotBadAMD = 0, // Don't use + + SwizzleInvocationsAMD = 1, + SwizzleInvocationsMaskedAMD = 2, + WriteInvocationAMD = 3, + MbcntAMD = 4, + + ShaderBallotCountAMD +}; + +// SPV_AMD_shader_trinary_minmax +static const char* const E_SPV_AMD_shader_trinary_minmax = "SPV_AMD_shader_trinary_minmax"; + +enum ShaderTrinaryMinMaxAMD { + ShaderTrinaryMinMaxBadAMD = 0, // Don't use + + FMin3AMD = 1, + UMin3AMD = 2, + SMin3AMD = 3, + FMax3AMD = 4, + UMax3AMD = 5, + SMax3AMD = 6, + FMid3AMD = 7, + UMid3AMD = 8, + SMid3AMD = 9, + + ShaderTrinaryMinMaxCountAMD +}; + +// SPV_AMD_shader_explicit_vertex_parameter +static const char* const E_SPV_AMD_shader_explicit_vertex_parameter = "SPV_AMD_shader_explicit_vertex_parameter"; + +enum ShaderExplicitVertexParameterAMD { + ShaderExplicitVertexParameterBadAMD = 0, // Don't use + + InterpolateAtVertexAMD = 1, + + ShaderExplicitVertexParameterCountAMD +}; + +// SPV_AMD_gcn_shader +static const char* const E_SPV_AMD_gcn_shader = "SPV_AMD_gcn_shader"; + +enum GcnShaderAMD { + GcnShaderBadAMD = 0, // Don't use + + CubeFaceIndexAMD = 1, + CubeFaceCoordAMD = 2, + TimeAMD = 3, + + GcnShaderCountAMD +}; + +// SPV_AMD_gpu_shader_half_float +static const char* const E_SPV_AMD_gpu_shader_half_float = "SPV_AMD_gpu_shader_half_float"; + +// SPV_AMD_texture_gather_bias_lod +static const char* const E_SPV_AMD_texture_gather_bias_lod = "SPV_AMD_texture_gather_bias_lod"; + +// SPV_AMD_gpu_shader_int16 +static const char* const E_SPV_AMD_gpu_shader_int16 = "SPV_AMD_gpu_shader_int16"; + +// SPV_AMD_shader_image_load_store_lod +static const char* const E_SPV_AMD_shader_image_load_store_lod = "SPV_AMD_shader_image_load_store_lod"; + +// SPV_AMD_shader_fragment_mask +static const char* const E_SPV_AMD_shader_fragment_mask = "SPV_AMD_shader_fragment_mask"; + +// SPV_AMD_gpu_shader_half_float_fetch +static const char* const E_SPV_AMD_gpu_shader_half_float_fetch = "SPV_AMD_gpu_shader_half_float_fetch"; + +#endif // #ifndef GLSLextAMD_H diff --git a/ios/include/glslang/SPIRV/GLSL.ext.EXT.h b/ios/include/glslang/SPIRV/GLSL.ext.EXT.h new file mode 100644 index 00000000..40164b61 --- /dev/null +++ b/ios/include/glslang/SPIRV/GLSL.ext.EXT.h @@ -0,0 +1,39 @@ +/* +** Copyright (c) 2014-2016 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +#ifndef GLSLextEXT_H +#define GLSLextEXT_H + +static const int GLSLextEXTVersion = 100; +static const int GLSLextEXTRevision = 2; + +static const char* const E_SPV_EXT_shader_stencil_export = "SPV_EXT_shader_stencil_export"; +static const char* const E_SPV_EXT_shader_viewport_index_layer = "SPV_EXT_shader_viewport_index_layer"; +static const char* const E_SPV_EXT_fragment_fully_covered = "SPV_EXT_fragment_fully_covered"; +static const char* const E_SPV_EXT_fragment_invocation_density = "SPV_EXT_fragment_invocation_density"; +static const char* const E_SPV_EXT_demote_to_helper_invocation = "SPV_EXT_demote_to_helper_invocation"; + +#endif // #ifndef GLSLextEXT_H diff --git a/ios/include/glslang/SPIRV/GLSL.ext.KHR.h b/ios/include/glslang/SPIRV/GLSL.ext.KHR.h new file mode 100644 index 00000000..d783a8f2 --- /dev/null +++ b/ios/include/glslang/SPIRV/GLSL.ext.KHR.h @@ -0,0 +1,51 @@ +/* +** Copyright (c) 2014-2020 The Khronos Group Inc. +** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +#ifndef GLSLextKHR_H +#define GLSLextKHR_H + +static const int GLSLextKHRVersion = 100; +static const int GLSLextKHRRevision = 2; + +static const char* const E_SPV_KHR_shader_ballot = "SPV_KHR_shader_ballot"; +static const char* const E_SPV_KHR_subgroup_vote = "SPV_KHR_subgroup_vote"; +static const char* const E_SPV_KHR_device_group = "SPV_KHR_device_group"; +static const char* const E_SPV_KHR_multiview = "SPV_KHR_multiview"; +static const char* const E_SPV_KHR_shader_draw_parameters = "SPV_KHR_shader_draw_parameters"; +static const char* const E_SPV_KHR_16bit_storage = "SPV_KHR_16bit_storage"; +static const char* const E_SPV_KHR_8bit_storage = "SPV_KHR_8bit_storage"; +static const char* const E_SPV_KHR_storage_buffer_storage_class = "SPV_KHR_storage_buffer_storage_class"; +static const char* const E_SPV_KHR_post_depth_coverage = "SPV_KHR_post_depth_coverage"; +static const char* const E_SPV_KHR_vulkan_memory_model = "SPV_KHR_vulkan_memory_model"; +static const char* const E_SPV_EXT_physical_storage_buffer = "SPV_EXT_physical_storage_buffer"; +static const char* const E_SPV_KHR_physical_storage_buffer = "SPV_KHR_physical_storage_buffer"; +static const char* const E_SPV_EXT_fragment_shader_interlock = "SPV_EXT_fragment_shader_interlock"; +static const char* const E_SPV_KHR_shader_clock = "SPV_KHR_shader_clock"; +static const char* const E_SPV_KHR_non_semantic_info = "SPV_KHR_non_semantic_info"; +static const char* const E_SPV_KHR_ray_tracing = "SPV_KHR_ray_tracing"; +static const char* const E_SPV_KHR_ray_query = "SPV_KHR_ray_query"; +#endif // #ifndef GLSLextKHR_H diff --git a/ios/include/glslang/SPIRV/GLSL.ext.NV.h b/ios/include/glslang/SPIRV/GLSL.ext.NV.h new file mode 100644 index 00000000..50146da1 --- /dev/null +++ b/ios/include/glslang/SPIRV/GLSL.ext.NV.h @@ -0,0 +1,81 @@ +/* +** Copyright (c) 2014-2017 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +#ifndef GLSLextNV_H +#define GLSLextNV_H + +enum BuiltIn; +enum Decoration; +enum Op; +enum Capability; + +static const int GLSLextNVVersion = 100; +static const int GLSLextNVRevision = 11; + +//SPV_NV_sample_mask_override_coverage +const char* const E_SPV_NV_sample_mask_override_coverage = "SPV_NV_sample_mask_override_coverage"; + +//SPV_NV_geometry_shader_passthrough +const char* const E_SPV_NV_geometry_shader_passthrough = "SPV_NV_geometry_shader_passthrough"; + +//SPV_NV_viewport_array2 +const char* const E_SPV_NV_viewport_array2 = "SPV_NV_viewport_array2"; +const char* const E_ARB_shader_viewport_layer_array = "SPV_ARB_shader_viewport_layer_array"; + +//SPV_NV_stereo_view_rendering +const char* const E_SPV_NV_stereo_view_rendering = "SPV_NV_stereo_view_rendering"; + +//SPV_NVX_multiview_per_view_attributes +const char* const E_SPV_NVX_multiview_per_view_attributes = "SPV_NVX_multiview_per_view_attributes"; + +//SPV_NV_shader_subgroup_partitioned +const char* const E_SPV_NV_shader_subgroup_partitioned = "SPV_NV_shader_subgroup_partitioned"; + +//SPV_NV_fragment_shader_barycentric +const char* const E_SPV_NV_fragment_shader_barycentric = "SPV_NV_fragment_shader_barycentric"; + +//SPV_NV_compute_shader_derivatives +const char* const E_SPV_NV_compute_shader_derivatives = "SPV_NV_compute_shader_derivatives"; + +//SPV_NV_shader_image_footprint +const char* const E_SPV_NV_shader_image_footprint = "SPV_NV_shader_image_footprint"; + +//SPV_NV_mesh_shader +const char* const E_SPV_NV_mesh_shader = "SPV_NV_mesh_shader"; + +//SPV_NV_raytracing +const char* const E_SPV_NV_ray_tracing = "SPV_NV_ray_tracing"; + +//SPV_NV_shading_rate +const char* const E_SPV_NV_shading_rate = "SPV_NV_shading_rate"; + +//SPV_NV_cooperative_matrix +const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix"; + +//SPV_NV_shader_sm_builtins +const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins"; + +#endif // #ifndef GLSLextNV_H diff --git a/ios/include/glslang/SPIRV/GLSL.std.450.h b/ios/include/glslang/SPIRV/GLSL.std.450.h new file mode 100644 index 00000000..df31092b --- /dev/null +++ b/ios/include/glslang/SPIRV/GLSL.std.450.h @@ -0,0 +1,131 @@ +/* +** Copyright (c) 2014-2016 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +#ifndef GLSLstd450_H +#define GLSLstd450_H + +static const int GLSLstd450Version = 100; +static const int GLSLstd450Revision = 1; + +enum GLSLstd450 { + GLSLstd450Bad = 0, // Don't use + + GLSLstd450Round = 1, + GLSLstd450RoundEven = 2, + GLSLstd450Trunc = 3, + GLSLstd450FAbs = 4, + GLSLstd450SAbs = 5, + GLSLstd450FSign = 6, + GLSLstd450SSign = 7, + GLSLstd450Floor = 8, + GLSLstd450Ceil = 9, + GLSLstd450Fract = 10, + + GLSLstd450Radians = 11, + GLSLstd450Degrees = 12, + GLSLstd450Sin = 13, + GLSLstd450Cos = 14, + GLSLstd450Tan = 15, + GLSLstd450Asin = 16, + GLSLstd450Acos = 17, + GLSLstd450Atan = 18, + GLSLstd450Sinh = 19, + GLSLstd450Cosh = 20, + GLSLstd450Tanh = 21, + GLSLstd450Asinh = 22, + GLSLstd450Acosh = 23, + GLSLstd450Atanh = 24, + GLSLstd450Atan2 = 25, + + GLSLstd450Pow = 26, + GLSLstd450Exp = 27, + GLSLstd450Log = 28, + GLSLstd450Exp2 = 29, + GLSLstd450Log2 = 30, + GLSLstd450Sqrt = 31, + GLSLstd450InverseSqrt = 32, + + GLSLstd450Determinant = 33, + GLSLstd450MatrixInverse = 34, + + GLSLstd450Modf = 35, // second operand needs an OpVariable to write to + GLSLstd450ModfStruct = 36, // no OpVariable operand + GLSLstd450FMin = 37, + GLSLstd450UMin = 38, + GLSLstd450SMin = 39, + GLSLstd450FMax = 40, + GLSLstd450UMax = 41, + GLSLstd450SMax = 42, + GLSLstd450FClamp = 43, + GLSLstd450UClamp = 44, + GLSLstd450SClamp = 45, + GLSLstd450FMix = 46, + GLSLstd450IMix = 47, // Reserved + GLSLstd450Step = 48, + GLSLstd450SmoothStep = 49, + + GLSLstd450Fma = 50, + GLSLstd450Frexp = 51, // second operand needs an OpVariable to write to + GLSLstd450FrexpStruct = 52, // no OpVariable operand + GLSLstd450Ldexp = 53, + + GLSLstd450PackSnorm4x8 = 54, + GLSLstd450PackUnorm4x8 = 55, + GLSLstd450PackSnorm2x16 = 56, + GLSLstd450PackUnorm2x16 = 57, + GLSLstd450PackHalf2x16 = 58, + GLSLstd450PackDouble2x32 = 59, + GLSLstd450UnpackSnorm2x16 = 60, + GLSLstd450UnpackUnorm2x16 = 61, + GLSLstd450UnpackHalf2x16 = 62, + GLSLstd450UnpackSnorm4x8 = 63, + GLSLstd450UnpackUnorm4x8 = 64, + GLSLstd450UnpackDouble2x32 = 65, + + GLSLstd450Length = 66, + GLSLstd450Distance = 67, + GLSLstd450Cross = 68, + GLSLstd450Normalize = 69, + GLSLstd450FaceForward = 70, + GLSLstd450Reflect = 71, + GLSLstd450Refract = 72, + + GLSLstd450FindILsb = 73, + GLSLstd450FindSMsb = 74, + GLSLstd450FindUMsb = 75, + + GLSLstd450InterpolateAtCentroid = 76, + GLSLstd450InterpolateAtSample = 77, + GLSLstd450InterpolateAtOffset = 78, + + GLSLstd450NMin = 79, + GLSLstd450NMax = 80, + GLSLstd450NClamp = 81, + + GLSLstd450Count +}; + +#endif // #ifndef GLSLstd450_H diff --git a/ios/include/glslang/SPIRV/GlslangToSpv.h b/ios/include/glslang/SPIRV/GlslangToSpv.h new file mode 100644 index 00000000..3907be43 --- /dev/null +++ b/ios/include/glslang/SPIRV/GlslangToSpv.h @@ -0,0 +1,61 @@ +// +// Copyright (C) 2014 LunarG, Inc. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#pragma once + +#if defined(_MSC_VER) && _MSC_VER >= 1900 + #pragma warning(disable : 4464) // relative include path contains '..' +#endif + +#include "SpvTools.h" +#include "glslang/Include/intermediate.h" + +#include +#include + +#include "Logger.h" + +namespace glslang { + +void GetSpirvVersion(std::string&); +int GetSpirvGeneratorVersion(); +void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector& spirv, + SpvOptions* options = nullptr); +void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector& spirv, + spv::SpvBuildLogger* logger, SpvOptions* options = nullptr); +void OutputSpvBin(const std::vector& spirv, const char* baseName); +void OutputSpvHex(const std::vector& spirv, const char* baseName, const char* varName); + +} diff --git a/ios/include/glslang/SPIRV/Logger.h b/ios/include/glslang/SPIRV/Logger.h new file mode 100644 index 00000000..411367c0 --- /dev/null +++ b/ios/include/glslang/SPIRV/Logger.h @@ -0,0 +1,83 @@ +// +// Copyright (C) 2016 Google, 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. +// +// Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +#ifndef GLSLANG_SPIRV_LOGGER_H +#define GLSLANG_SPIRV_LOGGER_H + +#include +#include + +namespace spv { + +// A class for holding all SPIR-V build status messages, including +// missing/TBD functionalities, warnings, and errors. +class SpvBuildLogger { +public: + SpvBuildLogger() {} + +#ifdef GLSLANG_WEB + void tbdFunctionality(const std::string& f) { } + void missingFunctionality(const std::string& f) { } + void warning(const std::string& w) { } + void error(const std::string& e) { errors.push_back(e); } + std::string getAllMessages() { return ""; } +#else + + // Registers a TBD functionality. + void tbdFunctionality(const std::string& f); + // Registers a missing functionality. + void missingFunctionality(const std::string& f); + + // Logs a warning. + void warning(const std::string& w) { warnings.push_back(w); } + // Logs an error. + void error(const std::string& e) { errors.push_back(e); } + + // Returns all messages accumulated in the order of: + // TBD functionalities, missing functionalities, warnings, errors. + std::string getAllMessages() const; +#endif + +private: + SpvBuildLogger(const SpvBuildLogger&); + + std::vector tbdFeatures; + std::vector missingFeatures; + std::vector warnings; + std::vector errors; +}; + +} // end spv namespace + +#endif // GLSLANG_SPIRV_LOGGER_H diff --git a/ios/include/glslang/SPIRV/NonSemanticDebugPrintf.h b/ios/include/glslang/SPIRV/NonSemanticDebugPrintf.h new file mode 100644 index 00000000..83796d75 --- /dev/null +++ b/ios/include/glslang/SPIRV/NonSemanticDebugPrintf.h @@ -0,0 +1,50 @@ +// Copyright (c) 2020 The Khronos Group Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and/or associated documentation files (the +// "Materials"), to deal in the Materials without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Materials, and to +// permit persons to whom the Materials are 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 Materials. +// +// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS +// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS +// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT +// https://www.khronos.org/registry/ +// +// THE MATERIALS ARE 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 +// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +// + +#ifndef SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_ +#define SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + NonSemanticDebugPrintfRevision = 1, + NonSemanticDebugPrintfRevision_BitWidthPadding = 0x7fffffff +}; + +enum NonSemanticDebugPrintfInstructions { + NonSemanticDebugPrintfDebugPrintf = 1, + NonSemanticDebugPrintfInstructionsMax = 0x7fffffff +}; + + +#ifdef __cplusplus +} +#endif + +#endif // SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_ diff --git a/ios/include/glslang/SPIRV/SPVRemapper.h b/ios/include/glslang/SPIRV/SPVRemapper.h new file mode 100644 index 00000000..d6b9c346 --- /dev/null +++ b/ios/include/glslang/SPIRV/SPVRemapper.h @@ -0,0 +1,304 @@ +// +// Copyright (C) 2015 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef SPIRVREMAPPER_H +#define SPIRVREMAPPER_H + +#include +#include +#include +#include + +namespace spv { + +// MSVC defines __cplusplus as an older value, even when it supports almost all of 11. +// We handle that here by making our own symbol. +#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1700) +# define use_cpp11 1 +#endif + +class spirvbin_base_t +{ +public: + enum Options { + NONE = 0, + STRIP = (1<<0), + MAP_TYPES = (1<<1), + MAP_NAMES = (1<<2), + MAP_FUNCS = (1<<3), + DCE_FUNCS = (1<<4), + DCE_VARS = (1<<5), + DCE_TYPES = (1<<6), + OPT_LOADSTORE = (1<<7), + OPT_FWD_LS = (1<<8), // EXPERIMENTAL: PRODUCES INVALID SCHEMA-0 SPIRV + MAP_ALL = (MAP_TYPES | MAP_NAMES | MAP_FUNCS), + DCE_ALL = (DCE_FUNCS | DCE_VARS | DCE_TYPES), + OPT_ALL = (OPT_LOADSTORE), + + ALL_BUT_STRIP = (MAP_ALL | DCE_ALL | OPT_ALL), + DO_EVERYTHING = (STRIP | ALL_BUT_STRIP) + }; +}; + +} // namespace SPV + +#if !defined (use_cpp11) +#include +#include + +namespace spv { +class spirvbin_t : public spirvbin_base_t +{ +public: + spirvbin_t(int /*verbose = 0*/) { } + + void remap(std::vector& /*spv*/, unsigned int /*opts = 0*/) + { + printf("Tool not compiled for C++11, which is required for SPIR-V remapping.\n"); + exit(5); + } +}; + +} // namespace SPV + +#else // defined (use_cpp11) + +#include +#include +#include +#include +#include +#include +#include + +#include "spirv.hpp" +#include "spvIR.h" + +namespace spv { + +// class to hold SPIR-V binary data for remapping, DCE, and debug stripping +class spirvbin_t : public spirvbin_base_t +{ +public: + spirvbin_t(int verbose = 0) : entryPoint(spv::NoResult), largestNewId(0), verbose(verbose), errorLatch(false) + { } + + virtual ~spirvbin_t() { } + + // remap on an existing binary in memory + void remap(std::vector& spv, std::uint32_t opts = DO_EVERYTHING); + + // Type for error/log handler functions + typedef std::function errorfn_t; + typedef std::function logfn_t; + + // Register error/log handling functions (can be lambda fn / functor / etc) + static void registerErrorHandler(errorfn_t handler) { errorHandler = handler; } + static void registerLogHandler(logfn_t handler) { logHandler = handler; } + +protected: + // This can be overridden to provide other message behavior if needed + virtual void msg(int minVerbosity, int indent, const std::string& txt) const; + +private: + // Local to global, or global to local ID map + typedef std::unordered_map idmap_t; + typedef std::unordered_set idset_t; + typedef std::unordered_map blockmap_t; + + void remap(std::uint32_t opts = DO_EVERYTHING); + + // Map of names to IDs + typedef std::unordered_map namemap_t; + + typedef std::uint32_t spirword_t; + + typedef std::pair range_t; + typedef std::function idfn_t; + typedef std::function instfn_t; + + // Special Values for ID map: + static const spv::Id unmapped; // unchanged from default value + static const spv::Id unused; // unused ID + static const int header_size; // SPIR header = 5 words + + class id_iterator_t; + + // For mapping type entries between different shaders + typedef std::vector typeentry_t; + typedef std::map globaltypes_t; + + // A set that preserves position order, and a reverse map + typedef std::set posmap_t; + typedef std::unordered_map posmap_rev_t; + + // Maps and ID to the size of its base type, if known. + typedef std::unordered_map typesize_map_t; + + // handle error + void error(const std::string& txt) const { errorLatch = true; errorHandler(txt); } + + bool isConstOp(spv::Op opCode) const; + bool isTypeOp(spv::Op opCode) const; + bool isStripOp(spv::Op opCode) const; + bool isFlowCtrl(spv::Op opCode) const; + range_t literalRange(spv::Op opCode) const; + range_t typeRange(spv::Op opCode) const; + range_t constRange(spv::Op opCode) const; + unsigned typeSizeInWords(spv::Id id) const; + unsigned idTypeSizeInWords(spv::Id id) const; + + spv::Id& asId(unsigned word) { return spv[word]; } + const spv::Id& asId(unsigned word) const { return spv[word]; } + spv::Op asOpCode(unsigned word) const { return opOpCode(spv[word]); } + std::uint32_t asOpCodeHash(unsigned word); + spv::Decoration asDecoration(unsigned word) const { return spv::Decoration(spv[word]); } + unsigned asWordCount(unsigned word) const { return opWordCount(spv[word]); } + spv::Id asTypeConstId(unsigned word) const { return asId(word + (isTypeOp(asOpCode(word)) ? 1 : 2)); } + unsigned idPos(spv::Id id) const; + + static unsigned opWordCount(spirword_t data) { return data >> spv::WordCountShift; } + static spv::Op opOpCode(spirword_t data) { return spv::Op(data & spv::OpCodeMask); } + + // Header access & set methods + spirword_t magic() const { return spv[0]; } // return magic number + spirword_t bound() const { return spv[3]; } // return Id bound from header + spirword_t bound(spirword_t b) { return spv[3] = b; } + spirword_t genmagic() const { return spv[2]; } // generator magic + spirword_t genmagic(spirword_t m) { return spv[2] = m; } + spirword_t schemaNum() const { return spv[4]; } // schema number from header + + // Mapping fns: get + spv::Id localId(spv::Id id) const { return idMapL[id]; } + + // Mapping fns: set + inline spv::Id localId(spv::Id id, spv::Id newId); + void countIds(spv::Id id); + + // Return next unused new local ID. + // NOTE: boost::dynamic_bitset would be more efficient due to find_next(), + // which std::vector doens't have. + inline spv::Id nextUnusedId(spv::Id id); + + void buildLocalMaps(); + std::string literalString(unsigned word) const; // Return literal as a std::string + int literalStringWords(const std::string& str) const { return (int(str.size())+4)/4; } + + bool isNewIdMapped(spv::Id newId) const { return isMapped(newId); } + bool isOldIdUnmapped(spv::Id oldId) const { return localId(oldId) == unmapped; } + bool isOldIdUnused(spv::Id oldId) const { return localId(oldId) == unused; } + bool isOldIdMapped(spv::Id oldId) const { return !isOldIdUnused(oldId) && !isOldIdUnmapped(oldId); } + bool isFunction(spv::Id oldId) const { return fnPos.find(oldId) != fnPos.end(); } + + // bool matchType(const globaltypes_t& globalTypes, spv::Id lt, spv::Id gt) const; + // spv::Id findType(const globaltypes_t& globalTypes, spv::Id lt) const; + std::uint32_t hashType(unsigned typeStart) const; + + spirvbin_t& process(instfn_t, idfn_t, unsigned begin = 0, unsigned end = 0); + int processInstruction(unsigned word, instfn_t, idfn_t); + + void validate() const; + void mapTypeConst(); + void mapFnBodies(); + void optLoadStore(); + void dceFuncs(); + void dceVars(); + void dceTypes(); + void mapNames(); + void foldIds(); // fold IDs to smallest space + void forwardLoadStores(); // load store forwarding (EXPERIMENTAL) + void offsetIds(); // create relative offset IDs + + void applyMap(); // remap per local name map + void mapRemainder(); // map any IDs we haven't touched yet + void stripDebug(); // strip all debug info + void stripDeadRefs(); // strips debug info for now-dead references after DCE + void strip(); // remove debug symbols + + std::vector spv; // SPIR words + + namemap_t nameMap; // ID names from OpName + + // Since we want to also do binary ops, we can't use std::vector. we could use + // boost::dynamic_bitset, but we're trying to avoid a boost dependency. + typedef std::uint64_t bits_t; + std::vector mapped; // which new IDs have been mapped + static const int mBits = sizeof(bits_t) * 4; + + bool isMapped(spv::Id id) const { return id < maxMappedId() && ((mapped[id/mBits] & (1LL<<(id%mBits))) != 0); } + void setMapped(spv::Id id) { resizeMapped(id); mapped[id/mBits] |= (1LL<<(id%mBits)); } + void resizeMapped(spv::Id id) { if (id >= maxMappedId()) mapped.resize(id/mBits+1, 0); } + size_t maxMappedId() const { return mapped.size() * mBits; } + + // Add a strip range for a given instruction starting at 'start' + // Note: avoiding brace initializers to please older versions os MSVC. + void stripInst(unsigned start) { stripRange.push_back(range_t(start, start + asWordCount(start))); } + + // Function start and end. use unordered_map because we'll have + // many fewer functions than IDs. + std::unordered_map fnPos; + + // Which functions are called, anywhere in the module, with a call count + std::unordered_map fnCalls; + + posmap_t typeConstPos; // word positions that define types & consts (ordered) + posmap_rev_t idPosR; // reverse map from IDs to positions + typesize_map_t idTypeSizeMap; // maps each ID to its type size, if known. + + std::vector idMapL; // ID {M}ap from {L}ocal to {G}lobal IDs + + spv::Id entryPoint; // module entry point + spv::Id largestNewId; // biggest new ID we have mapped anything to + + // Sections of the binary to strip, given as [begin,end) + std::vector stripRange; + + // processing options: + std::uint32_t options; + int verbose; // verbosity level + + // Error latch: this is set if the error handler is ever executed. It would be better to + // use a try/catch block and throw, but that's not desired for certain environments, so + // this is the alternative. + mutable bool errorLatch; + + static errorfn_t errorHandler; + static logfn_t logHandler; +}; + +} // namespace SPV + +#endif // defined (use_cpp11) +#endif // SPIRVREMAPPER_H diff --git a/ios/include/glslang/SPIRV/SpvBuilder.h b/ios/include/glslang/SPIRV/SpvBuilder.h new file mode 100644 index 00000000..71b90d60 --- /dev/null +++ b/ios/include/glslang/SPIRV/SpvBuilder.h @@ -0,0 +1,838 @@ +// +// Copyright (C) 2014-2015 LunarG, Inc. +// Copyright (C) 2015-2020 Google, Inc. +// Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// +// "Builder" is an interface to fully build SPIR-V IR. Allocate one of +// these to build (a thread safe) internal SPIR-V representation (IR), +// and then dump it as a binary stream according to the SPIR-V specification. +// +// A Builder has a 1:1 relationship with a SPIR-V module. +// + +#pragma once +#ifndef SpvBuilder_H +#define SpvBuilder_H + +#include "Logger.h" +#include "spirv.hpp" +#include "spvIR.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace spv { + +typedef enum { + Spv_1_0 = (1 << 16), + Spv_1_1 = (1 << 16) | (1 << 8), + Spv_1_2 = (1 << 16) | (2 << 8), + Spv_1_3 = (1 << 16) | (3 << 8), + Spv_1_4 = (1 << 16) | (4 << 8), + Spv_1_5 = (1 << 16) | (5 << 8), +} SpvVersion; + +class Builder { +public: + Builder(unsigned int spvVersion, unsigned int userNumber, SpvBuildLogger* logger); + virtual ~Builder(); + + static const int maxMatrixSize = 4; + + unsigned int getSpvVersion() const { return spvVersion; } + + void setSource(spv::SourceLanguage lang, int version) + { + source = lang; + sourceVersion = version; + } + spv::Id getStringId(const std::string& str) + { + auto sItr = stringIds.find(str); + if (sItr != stringIds.end()) + return sItr->second; + spv::Id strId = getUniqueId(); + Instruction* fileString = new Instruction(strId, NoType, OpString); + const char* file_c_str = str.c_str(); + fileString->addStringOperand(file_c_str); + strings.push_back(std::unique_ptr(fileString)); + module.mapInstruction(fileString); + stringIds[file_c_str] = strId; + return strId; + } + void setSourceFile(const std::string& file) + { + sourceFileStringId = getStringId(file); + } + void setSourceText(const std::string& text) { sourceText = text; } + void addSourceExtension(const char* ext) { sourceExtensions.push_back(ext); } + void addModuleProcessed(const std::string& p) { moduleProcesses.push_back(p.c_str()); } + void setEmitOpLines() { emitOpLines = true; } + void addExtension(const char* ext) { extensions.insert(ext); } + void removeExtension(const char* ext) + { + extensions.erase(ext); + } + void addIncorporatedExtension(const char* ext, SpvVersion incorporatedVersion) + { + if (getSpvVersion() < static_cast(incorporatedVersion)) + addExtension(ext); + } + void promoteIncorporatedExtension(const char* baseExt, const char* promoExt, SpvVersion incorporatedVersion) + { + removeExtension(baseExt); + addIncorporatedExtension(promoExt, incorporatedVersion); + } + void addInclude(const std::string& name, const std::string& text) + { + spv::Id incId = getStringId(name); + includeFiles[incId] = &text; + } + Id import(const char*); + void setMemoryModel(spv::AddressingModel addr, spv::MemoryModel mem) + { + addressModel = addr; + memoryModel = mem; + } + + void addCapability(spv::Capability cap) { capabilities.insert(cap); } + + // To get a new for anything needing a new one. + Id getUniqueId() { return ++uniqueId; } + + // To get a set of new s, e.g., for a set of function parameters + Id getUniqueIds(int numIds) + { + Id id = uniqueId + 1; + uniqueId += numIds; + return id; + } + + // Generate OpLine for non-filename-based #line directives (ie no filename + // seen yet): Log the current line, and if different than the last one, + // issue a new OpLine using the new line and current source file name. + void setLine(int line); + + // If filename null, generate OpLine for non-filename-based line directives, + // else do filename-based: Log the current line and file, and if different + // than the last one, issue a new OpLine using the new line and file + // name. + void setLine(int line, const char* filename); + // Low-level OpLine. See setLine() for a layered helper. + void addLine(Id fileName, int line, int column); + + // For creating new types (will return old type if the requested one was already made). + Id makeVoidType(); + Id makeBoolType(); + Id makePointer(StorageClass, Id pointee); + Id makeForwardPointer(StorageClass); + Id makePointerFromForwardPointer(StorageClass, Id forwardPointerType, Id pointee); + Id makeIntegerType(int width, bool hasSign); // generic + Id makeIntType(int width) { return makeIntegerType(width, true); } + Id makeUintType(int width) { return makeIntegerType(width, false); } + Id makeFloatType(int width); + Id makeStructType(const std::vector& members, const char*); + Id makeStructResultType(Id type0, Id type1); + Id makeVectorType(Id component, int size); + Id makeMatrixType(Id component, int cols, int rows); + Id makeArrayType(Id element, Id sizeId, int stride); // 0 stride means no stride decoration + Id makeRuntimeArray(Id element); + Id makeFunctionType(Id returnType, const std::vector& paramTypes); + Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format); + Id makeSamplerType(); + Id makeSampledImageType(Id imageType); + Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols); + + // accelerationStructureNV type + Id makeAccelerationStructureType(); + // rayQueryEXT type + Id makeRayQueryType(); + + // For querying about types. + Id getTypeId(Id resultId) const { return module.getTypeId(resultId); } + Id getDerefTypeId(Id resultId) const; + Op getOpCode(Id id) const { return module.getInstruction(id)->getOpCode(); } + Op getTypeClass(Id typeId) const { return getOpCode(typeId); } + Op getMostBasicTypeClass(Id typeId) const; + int getNumComponents(Id resultId) const { return getNumTypeComponents(getTypeId(resultId)); } + int getNumTypeConstituents(Id typeId) const; + int getNumTypeComponents(Id typeId) const { return getNumTypeConstituents(typeId); } + Id getScalarTypeId(Id typeId) const; + Id getContainedTypeId(Id typeId) const; + Id getContainedTypeId(Id typeId, int) const; + StorageClass getTypeStorageClass(Id typeId) const { return module.getStorageClass(typeId); } + ImageFormat getImageTypeFormat(Id typeId) const + { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); } + + bool isPointer(Id resultId) const { return isPointerType(getTypeId(resultId)); } + bool isScalar(Id resultId) const { return isScalarType(getTypeId(resultId)); } + bool isVector(Id resultId) const { return isVectorType(getTypeId(resultId)); } + bool isMatrix(Id resultId) const { return isMatrixType(getTypeId(resultId)); } + bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); } + bool isAggregate(Id resultId) const { return isAggregateType(getTypeId(resultId)); } + bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); } + + bool isBoolType(Id typeId) + { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); } + bool isIntType(Id typeId) const + { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; } + bool isUintType(Id typeId) const + { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; } + bool isFloatType(Id typeId) const { return getTypeClass(typeId) == OpTypeFloat; } + bool isPointerType(Id typeId) const { return getTypeClass(typeId) == OpTypePointer; } + bool isScalarType(Id typeId) const + { return getTypeClass(typeId) == OpTypeFloat || getTypeClass(typeId) == OpTypeInt || + getTypeClass(typeId) == OpTypeBool; } + bool isVectorType(Id typeId) const { return getTypeClass(typeId) == OpTypeVector; } + bool isMatrixType(Id typeId) const { return getTypeClass(typeId) == OpTypeMatrix; } + bool isStructType(Id typeId) const { return getTypeClass(typeId) == OpTypeStruct; } + bool isArrayType(Id typeId) const { return getTypeClass(typeId) == OpTypeArray; } +#ifdef GLSLANG_WEB + bool isCooperativeMatrixType(Id typeId)const { return false; } +#else + bool isCooperativeMatrixType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeMatrixNV; } +#endif + bool isAggregateType(Id typeId) const + { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); } + bool isImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeImage; } + bool isSamplerType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampler; } + bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; } + bool containsType(Id typeId, Op typeOp, unsigned int width) const; + bool containsPhysicalStorageBufferOrArray(Id typeId) const; + + bool isConstantOpCode(Op opcode) const; + bool isSpecConstantOpCode(Op opcode) const; + bool isConstant(Id resultId) const { return isConstantOpCode(getOpCode(resultId)); } + bool isConstantScalar(Id resultId) const { return getOpCode(resultId) == OpConstant; } + bool isSpecConstant(Id resultId) const { return isSpecConstantOpCode(getOpCode(resultId)); } + unsigned int getConstantScalar(Id resultId) const + { return module.getInstruction(resultId)->getImmediateOperand(0); } + StorageClass getStorageClass(Id resultId) const { return getTypeStorageClass(getTypeId(resultId)); } + + int getScalarTypeWidth(Id typeId) const + { + Id scalarTypeId = getScalarTypeId(typeId); + assert(getTypeClass(scalarTypeId) == OpTypeInt || getTypeClass(scalarTypeId) == OpTypeFloat); + return module.getInstruction(scalarTypeId)->getImmediateOperand(0); + } + + int getTypeNumColumns(Id typeId) const + { + assert(isMatrixType(typeId)); + return getNumTypeConstituents(typeId); + } + int getNumColumns(Id resultId) const { return getTypeNumColumns(getTypeId(resultId)); } + int getTypeNumRows(Id typeId) const + { + assert(isMatrixType(typeId)); + return getNumTypeComponents(getContainedTypeId(typeId)); + } + int getNumRows(Id resultId) const { return getTypeNumRows(getTypeId(resultId)); } + + Dim getTypeDimensionality(Id typeId) const + { + assert(isImageType(typeId)); + return (Dim)module.getInstruction(typeId)->getImmediateOperand(1); + } + Id getImageType(Id resultId) const + { + Id typeId = getTypeId(resultId); + assert(isImageType(typeId) || isSampledImageType(typeId)); + return isSampledImageType(typeId) ? module.getInstruction(typeId)->getIdOperand(0) : typeId; + } + bool isArrayedImageType(Id typeId) const + { + assert(isImageType(typeId)); + return module.getInstruction(typeId)->getImmediateOperand(3) != 0; + } + + // For making new constants (will return old constant if the requested one was already made). + Id makeBoolConstant(bool b, bool specConstant = false); + Id makeInt8Constant(int i, bool specConstant = false) + { return makeIntConstant(makeIntType(8), (unsigned)i, specConstant); } + Id makeUint8Constant(unsigned u, bool specConstant = false) + { return makeIntConstant(makeUintType(8), u, specConstant); } + Id makeInt16Constant(int i, bool specConstant = false) + { return makeIntConstant(makeIntType(16), (unsigned)i, specConstant); } + Id makeUint16Constant(unsigned u, bool specConstant = false) + { return makeIntConstant(makeUintType(16), u, specConstant); } + Id makeIntConstant(int i, bool specConstant = false) + { return makeIntConstant(makeIntType(32), (unsigned)i, specConstant); } + Id makeUintConstant(unsigned u, bool specConstant = false) + { return makeIntConstant(makeUintType(32), u, specConstant); } + Id makeInt64Constant(long long i, bool specConstant = false) + { return makeInt64Constant(makeIntType(64), (unsigned long long)i, specConstant); } + Id makeUint64Constant(unsigned long long u, bool specConstant = false) + { return makeInt64Constant(makeUintType(64), u, specConstant); } + Id makeFloatConstant(float f, bool specConstant = false); + Id makeDoubleConstant(double d, bool specConstant = false); + Id makeFloat16Constant(float f16, bool specConstant = false); + Id makeFpConstant(Id type, double d, bool specConstant = false); + + // Turn the array of constants into a proper spv constant of the requested type. + Id makeCompositeConstant(Id type, const std::vector& comps, bool specConst = false); + + // Methods for adding information outside the CFG. + Instruction* addEntryPoint(ExecutionModel, Function*, const char* name); + void addExecutionMode(Function*, ExecutionMode mode, int value1 = -1, int value2 = -1, int value3 = -1); + void addName(Id, const char* name); + void addMemberName(Id, int member, const char* name); + void addDecoration(Id, Decoration, int num = -1); + void addDecoration(Id, Decoration, const char*); + void addDecorationId(Id id, Decoration, Id idDecoration); + void addMemberDecoration(Id, unsigned int member, Decoration, int num = -1); + void addMemberDecoration(Id, unsigned int member, Decoration, const char*); + + // At the end of what block do the next create*() instructions go? + void setBuildPoint(Block* bp) { buildPoint = bp; } + Block* getBuildPoint() const { return buildPoint; } + + // Make the entry-point function. The returned pointer is only valid + // for the lifetime of this builder. + Function* makeEntryPoint(const char*); + + // Make a shader-style function, and create its entry block if entry is non-zero. + // Return the function, pass back the entry. + // The returned pointer is only valid for the lifetime of this builder. + Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name, + const std::vector& paramTypes, const std::vector>& precisions, Block **entry = 0); + + // Create a return. An 'implicit' return is one not appearing in the source + // code. In the case of an implicit return, no post-return block is inserted. + void makeReturn(bool implicit, Id retVal = 0); + + // Generate all the code needed to finish up a function. + void leaveFunction(); + + // Create a discard. + void makeDiscard(); + + // Create a global or function local or IO variable. + Id createVariable(StorageClass, Id type, const char* name = 0, Id initializer = NoResult); + + // Create an intermediate with an undefined value. + Id createUndefined(Id type); + + // Store into an Id and return the l-value + void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, + spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0); + + // Load from an Id and return it + Id createLoad(Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, + spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0); + + // Create an OpAccessChain instruction + Id createAccessChain(StorageClass, Id base, const std::vector& offsets); + + // Create an OpArrayLength instruction + Id createArrayLength(Id base, unsigned int member); + + // Create an OpCooperativeMatrixLengthNV instruction + Id createCooperativeMatrixLength(Id type); + + // Create an OpCompositeExtract instruction + Id createCompositeExtract(Id composite, Id typeId, unsigned index); + Id createCompositeExtract(Id composite, Id typeId, const std::vector& indexes); + Id createCompositeInsert(Id object, Id composite, Id typeId, unsigned index); + Id createCompositeInsert(Id object, Id composite, Id typeId, const std::vector& indexes); + + Id createVectorExtractDynamic(Id vector, Id typeId, Id componentIndex); + Id createVectorInsertDynamic(Id vector, Id typeId, Id component, Id componentIndex); + + void createNoResultOp(Op); + void createNoResultOp(Op, Id operand); + void createNoResultOp(Op, const std::vector& operands); + void createNoResultOp(Op, const std::vector& operands); + void createControlBarrier(Scope execution, Scope memory, MemorySemanticsMask); + void createMemoryBarrier(unsigned executionScope, unsigned memorySemantics); + Id createUnaryOp(Op, Id typeId, Id operand); + Id createBinOp(Op, Id typeId, Id operand1, Id operand2); + Id createTriOp(Op, Id typeId, Id operand1, Id operand2, Id operand3); + Id createOp(Op, Id typeId, const std::vector& operands); + Id createOp(Op, Id typeId, const std::vector& operands); + Id createFunctionCall(spv::Function*, const std::vector&); + Id createSpecConstantOp(Op, Id typeId, const std::vector& operands, const std::vector& literals); + + // Take an rvalue (source) and a set of channels to extract from it to + // make a new rvalue, which is returned. + Id createRvalueSwizzle(Decoration precision, Id typeId, Id source, const std::vector& channels); + + // Take a copy of an lvalue (target) and a source of components, and set the + // source components into the lvalue where the 'channels' say to put them. + // An updated version of the target is returned. + // (No true lvalue or stores are used.) + Id createLvalueSwizzle(Id typeId, Id target, Id source, const std::vector& channels); + + // If both the id and precision are valid, the id + // gets tagged with the requested precision. + // The passed in id is always the returned id, to simplify use patterns. + Id setPrecision(Id id, Decoration precision) + { + if (precision != NoPrecision && id != NoResult) + addDecoration(id, precision); + + return id; + } + + // Can smear a scalar to a vector for the following forms: + // - promoteScalar(scalar, vector) // smear scalar to width of vector + // - promoteScalar(vector, scalar) // smear scalar to width of vector + // - promoteScalar(pointer, scalar) // smear scalar to width of what pointer points to + // - promoteScalar(scalar, scalar) // do nothing + // Other forms are not allowed. + // + // Generally, the type of 'scalar' does not need to be the same type as the components in 'vector'. + // The type of the created vector is a vector of components of the same type as the scalar. + // + // Note: One of the arguments will change, with the result coming back that way rather than + // through the return value. + void promoteScalar(Decoration precision, Id& left, Id& right); + + // Make a value by smearing the scalar to fill the type. + // vectorType should be the correct type for making a vector of scalarVal. + // (No conversions are done.) + Id smearScalar(Decoration precision, Id scalarVal, Id vectorType); + + // Create a call to a built-in function. + Id createBuiltinCall(Id resultType, Id builtins, int entryPoint, const std::vector& args); + + // List of parameters used to create a texture operation + struct TextureParameters { + Id sampler; + Id coords; + Id bias; + Id lod; + Id Dref; + Id offset; + Id offsets; + Id gradX; + Id gradY; + Id sample; + Id component; + Id texelOut; + Id lodClamp; + Id granularity; + Id coarse; + bool nonprivate; + bool volatil; + }; + + // Select the correct texture operation based on all inputs, and emit the correct instruction + Id createTextureCall(Decoration precision, Id resultType, bool sparse, bool fetch, bool proj, bool gather, + bool noImplicit, const TextureParameters&, ImageOperandsMask); + + // Emit the OpTextureQuery* instruction that was passed in. + // Figure out the right return value and type, and return it. + Id createTextureQueryCall(Op, const TextureParameters&, bool isUnsignedResult); + + Id createSamplePositionCall(Decoration precision, Id, Id); + + Id createBitFieldExtractCall(Decoration precision, Id, Id, Id, bool isSigned); + Id createBitFieldInsertCall(Decoration precision, Id, Id, Id, Id); + + // Reduction comparison for composites: For equal and not-equal resulting in a scalar. + Id createCompositeCompare(Decoration precision, Id, Id, bool /* true if for equal, false if for not-equal */); + + // OpCompositeConstruct + Id createCompositeConstruct(Id typeId, const std::vector& constituents); + + // vector or scalar constructor + Id createConstructor(Decoration precision, const std::vector& sources, Id resultTypeId); + + // matrix constructor + Id createMatrixConstructor(Decoration precision, const std::vector& sources, Id constructee); + + // Helper to use for building nested control flow with if-then-else. + class If { + public: + If(Id condition, unsigned int ctrl, Builder& builder); + ~If() {} + + void makeBeginElse(); + void makeEndIf(); + + private: + If(const If&); + If& operator=(If&); + + Builder& builder; + Id condition; + unsigned int control; + Function* function; + Block* headerBlock; + Block* thenBlock; + Block* elseBlock; + Block* mergeBlock; + }; + + // Make a switch statement. A switch has 'numSegments' of pieces of code, not containing + // any case/default labels, all separated by one or more case/default labels. Each possible + // case value v is a jump to the caseValues[v] segment. The defaultSegment is also in this + // number space. How to compute the value is given by 'condition', as in switch(condition). + // + // The SPIR-V Builder will maintain the stack of post-switch merge blocks for nested switches. + // + // Use a defaultSegment < 0 if there is no default segment (to branch to post switch). + // + // Returns the right set of basic blocks to start each code segment with, so that the caller's + // recursion stack can hold the memory for it. + // + void makeSwitch(Id condition, unsigned int control, int numSegments, const std::vector& caseValues, + const std::vector& valueToSegment, int defaultSegment, std::vector& segmentBB); + + // Add a branch to the innermost switch's merge block. + void addSwitchBreak(); + + // Move to the next code segment, passing in the return argument in makeSwitch() + void nextSwitchSegment(std::vector& segmentBB, int segment); + + // Finish off the innermost switch. + void endSwitch(std::vector& segmentBB); + + struct LoopBlocks { + LoopBlocks(Block& head, Block& body, Block& merge, Block& continue_target) : + head(head), body(body), merge(merge), continue_target(continue_target) { } + Block &head, &body, &merge, &continue_target; + private: + LoopBlocks(); + LoopBlocks& operator=(const LoopBlocks&) = delete; + }; + + // Start a new loop and prepare the builder to generate code for it. Until + // closeLoop() is called for this loop, createLoopContinue() and + // createLoopExit() will target its corresponding blocks. + LoopBlocks& makeNewLoop(); + + // Create a new block in the function containing the build point. Memory is + // owned by the function object. + Block& makeNewBlock(); + + // Add a branch to the continue_target of the current (innermost) loop. + void createLoopContinue(); + + // Add an exit (e.g. "break") from the innermost loop that we're currently + // in. + void createLoopExit(); + + // Close the innermost loop that you're in + void closeLoop(); + + // + // Access chain design for an R-Value vs. L-Value: + // + // There is a single access chain the builder is building at + // any particular time. Such a chain can be used to either to a load or + // a store, when desired. + // + // Expressions can be r-values, l-values, or both, or only r-values: + // a[b.c].d = .... // l-value + // ... = a[b.c].d; // r-value, that also looks like an l-value + // ++a[b.c].d; // r-value and l-value + // (x + y)[2]; // r-value only, can't possibly be l-value + // + // Computing an r-value means generating code. Hence, + // r-values should only be computed when they are needed, not speculatively. + // + // Computing an l-value means saving away information for later use in the compiler, + // no code is generated until the l-value is later dereferenced. It is okay + // to speculatively generate an l-value, just not okay to speculatively dereference it. + // + // The base of the access chain (the left-most variable or expression + // from which everything is based) can be set either as an l-value + // or as an r-value. Most efficient would be to set an l-value if one + // is available. If an expression was evaluated, the resulting r-value + // can be set as the chain base. + // + // The users of this single access chain can save and restore if they + // want to nest or manage multiple chains. + // + + struct AccessChain { + Id base; // for l-values, pointer to the base object, for r-values, the base object + std::vector indexChain; + Id instr; // cache the instruction that generates this access chain + std::vector swizzle; // each std::vector element selects the next GLSL component number + Id component; // a dynamic component index, can coexist with a swizzle, + // done after the swizzle, NoResult if not present + Id preSwizzleBaseType; // dereferenced type, before swizzle or component is applied; + // NoType unless a swizzle or component is present + bool isRValue; // true if 'base' is an r-value, otherwise, base is an l-value + unsigned int alignment; // bitwise OR of alignment values passed in. Accumulates worst alignment. + // Only tracks base and (optional) component selection alignment. + + // Accumulate whether anything in the chain of structures has coherent decorations. + struct CoherentFlags { + CoherentFlags() { clear(); } +#ifdef GLSLANG_WEB + void clear() { } + bool isVolatile() const { return false; } + CoherentFlags operator |=(const CoherentFlags &other) { return *this; } +#else + bool isVolatile() const { return volatil; } + bool anyCoherent() const { + return coherent || devicecoherent || queuefamilycoherent || workgroupcoherent || + subgroupcoherent || shadercallcoherent; + } + + unsigned coherent : 1; + unsigned devicecoherent : 1; + unsigned queuefamilycoherent : 1; + unsigned workgroupcoherent : 1; + unsigned subgroupcoherent : 1; + unsigned shadercallcoherent : 1; + unsigned nonprivate : 1; + unsigned volatil : 1; + unsigned isImage : 1; + + void clear() { + coherent = 0; + devicecoherent = 0; + queuefamilycoherent = 0; + workgroupcoherent = 0; + subgroupcoherent = 0; + shadercallcoherent = 0; + nonprivate = 0; + volatil = 0; + isImage = 0; + } + + CoherentFlags operator |=(const CoherentFlags &other) { + coherent |= other.coherent; + devicecoherent |= other.devicecoherent; + queuefamilycoherent |= other.queuefamilycoherent; + workgroupcoherent |= other.workgroupcoherent; + subgroupcoherent |= other.subgroupcoherent; + shadercallcoherent |= other.shadercallcoherent; + nonprivate |= other.nonprivate; + volatil |= other.volatil; + isImage |= other.isImage; + return *this; + } +#endif + }; + CoherentFlags coherentFlags; + }; + + // + // the SPIR-V builder maintains a single active chain that + // the following methods operate on + // + + // for external save and restore + AccessChain getAccessChain() { return accessChain; } + void setAccessChain(AccessChain newChain) { accessChain = newChain; } + + // clear accessChain + void clearAccessChain(); + + // set new base as an l-value base + void setAccessChainLValue(Id lValue) + { + assert(isPointer(lValue)); + accessChain.base = lValue; + } + + // set new base value as an r-value + void setAccessChainRValue(Id rValue) + { + accessChain.isRValue = true; + accessChain.base = rValue; + } + + // push offset onto the end of the chain + void accessChainPush(Id offset, AccessChain::CoherentFlags coherentFlags, unsigned int alignment) + { + accessChain.indexChain.push_back(offset); + accessChain.coherentFlags |= coherentFlags; + accessChain.alignment |= alignment; + } + + // push new swizzle onto the end of any existing swizzle, merging into a single swizzle + void accessChainPushSwizzle(std::vector& swizzle, Id preSwizzleBaseType, + AccessChain::CoherentFlags coherentFlags, unsigned int alignment); + + // push a dynamic component selection onto the access chain, only applicable with a + // non-trivial swizzle or no swizzle + void accessChainPushComponent(Id component, Id preSwizzleBaseType, AccessChain::CoherentFlags coherentFlags, + unsigned int alignment) + { + if (accessChain.swizzle.size() != 1) { + accessChain.component = component; + if (accessChain.preSwizzleBaseType == NoType) + accessChain.preSwizzleBaseType = preSwizzleBaseType; + } + accessChain.coherentFlags |= coherentFlags; + accessChain.alignment |= alignment; + } + + // use accessChain and swizzle to store value + void accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, + spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0); + + // use accessChain and swizzle to load an r-value + Id accessChainLoad(Decoration precision, Decoration nonUniform, Id ResultType, + spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax, + unsigned int alignment = 0); + + // Return whether or not the access chain can be represented in SPIR-V + // as an l-value. + // E.g., a[3].yx cannot be, while a[3].y and a[3].y[x] can be. + bool isSpvLvalue() const { return accessChain.swizzle.size() <= 1; } + + // get the direct pointer for an l-value + Id accessChainGetLValue(); + + // Get the inferred SPIR-V type of the result of the current access chain, + // based on the type of the base and the chain of dereferences. + Id accessChainGetInferredType(); + + // Add capabilities, extensions, remove unneeded decorations, etc., + // based on the resulting SPIR-V. + void postProcess(); + + // Prune unreachable blocks in the CFG and remove unneeded decorations. + void postProcessCFG(); + +#ifndef GLSLANG_WEB + // Add capabilities, extensions based on instructions in the module. + void postProcessFeatures(); + // Hook to visit each instruction in a block in a function + void postProcess(Instruction&); + // Hook to visit each non-32-bit sized float/int operation in a block. + void postProcessType(const Instruction&, spv::Id typeId); +#endif + + void dump(std::vector&) const; + + void createBranch(Block* block); + void createConditionalBranch(Id condition, Block* thenBlock, Block* elseBlock); + void createLoopMerge(Block* mergeBlock, Block* continueBlock, unsigned int control, + const std::vector& operands); + + // Sets to generate opcode for specialization constants. + void setToSpecConstCodeGenMode() { generatingOpCodeForSpecConst = true; } + // Sets to generate opcode for non-specialization constants (normal mode). + void setToNormalCodeGenMode() { generatingOpCodeForSpecConst = false; } + // Check if the builder is generating code for spec constants. + bool isInSpecConstCodeGenMode() { return generatingOpCodeForSpecConst; } + + protected: + Id makeIntConstant(Id typeId, unsigned value, bool specConstant); + Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant); + Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value); + Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2); + Id findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps); + Id findStructConstant(Id typeId, const std::vector& comps); + Id collapseAccessChain(); + void remapDynamicSwizzle(); + void transferAccessChainSwizzle(bool dynamic); + void simplifyAccessChainSwizzle(); + void createAndSetNoPredecessorBlock(const char*); + void createSelectionMerge(Block* mergeBlock, unsigned int control); + void dumpSourceInstructions(std::vector&) const; + void dumpSourceInstructions(const spv::Id fileId, const std::string& text, std::vector&) const; + void dumpInstructions(std::vector&, const std::vector >&) const; + void dumpModuleProcesses(std::vector&) const; + spv::MemoryAccessMask sanitizeMemoryAccessForStorageClass(spv::MemoryAccessMask memoryAccess, StorageClass sc) + const; + + unsigned int spvVersion; // the version of SPIR-V to emit in the header + SourceLanguage source; + int sourceVersion; + spv::Id sourceFileStringId; + std::string sourceText; + int currentLine; + const char* currentFile; + bool emitOpLines; + std::set extensions; + std::vector sourceExtensions; + std::vector moduleProcesses; + AddressingModel addressModel; + MemoryModel memoryModel; + std::set capabilities; + int builderNumber; + Module module; + Block* buildPoint; + Id uniqueId; + Function* entryPointFunction; + bool generatingOpCodeForSpecConst; + AccessChain accessChain; + + // special blocks of instructions for output + std::vector > strings; + std::vector > imports; + std::vector > entryPoints; + std::vector > executionModes; + std::vector > names; + std::vector > decorations; + std::vector > constantsTypesGlobals; + std::vector > externals; + std::vector > functions; + + // not output, internally used for quick & dirty canonical (unique) creation + + // map type opcodes to constant inst. + std::unordered_map> groupedConstants; + // map struct-id to constant instructions + std::unordered_map> groupedStructConstants; + // map type opcodes to type instructions + std::unordered_map> groupedTypes; + + // stack of switches + std::stack switchMerges; + + // Our loop stack. + std::stack loops; + + // map from strings to their string ids + std::unordered_map stringIds; + + // map from include file name ids to their contents + std::map includeFiles; + + // The stream for outputting warnings and errors. + SpvBuildLogger* logger; +}; // end Builder class + +}; // end spv namespace + +#endif // SpvBuilder_H diff --git a/ios/include/glslang/SPIRV/SpvTools.h b/ios/include/glslang/SPIRV/SpvTools.h new file mode 100644 index 00000000..59c914da --- /dev/null +++ b/ios/include/glslang/SPIRV/SpvTools.h @@ -0,0 +1,82 @@ +// +// Copyright (C) 2014-2016 LunarG, Inc. +// Copyright (C) 2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// +// Call into SPIRV-Tools to disassemble, validate, and optimize. +// + +#pragma once +#ifndef GLSLANG_SPV_TOOLS_H +#define GLSLANG_SPV_TOOLS_H + +#ifdef ENABLE_OPT +#include +#include +#endif + +#include "glslang/MachineIndependent/localintermediate.h" +#include "Logger.h" + +namespace glslang { + +struct SpvOptions { + SpvOptions() : generateDebugInfo(false), disableOptimizer(true), + optimizeSize(false), disassemble(false), validate(false) { } + bool generateDebugInfo; + bool disableOptimizer; + bool optimizeSize; + bool disassemble; + bool validate; +}; + +#ifdef ENABLE_OPT + +// Use the SPIRV-Tools disassembler to print SPIR-V. +void SpirvToolsDisassemble(std::ostream& out, const std::vector& spirv); + +// Apply the SPIRV-Tools validator to generated SPIR-V. +void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector& spirv, + spv::SpvBuildLogger*, bool prelegalization); + +// Apply the SPIRV-Tools optimizer to generated SPIR-V, for the purpose of +// legalizing HLSL SPIR-V. +void SpirvToolsLegalize(const glslang::TIntermediate& intermediate, std::vector& spirv, + spv::SpvBuildLogger*, const SpvOptions*); + +#endif + +} // end namespace glslang + +#endif // GLSLANG_SPV_TOOLS_H diff --git a/ios/include/glslang/SPIRV/bitutils.h b/ios/include/glslang/SPIRV/bitutils.h new file mode 100644 index 00000000..22e44cec --- /dev/null +++ b/ios/include/glslang/SPIRV/bitutils.h @@ -0,0 +1,81 @@ +// Copyright (c) 2015-2016 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef LIBSPIRV_UTIL_BITUTILS_H_ +#define LIBSPIRV_UTIL_BITUTILS_H_ + +#include +#include + +namespace spvutils { + +// Performs a bitwise copy of source to the destination type Dest. +template +Dest BitwiseCast(Src source) { + Dest dest; + static_assert(sizeof(source) == sizeof(dest), + "BitwiseCast: Source and destination must have the same size"); + std::memcpy(static_cast(&dest), &source, sizeof(dest)); + return dest; +} + +// SetBits returns an integer of type with bits set +// for position through , counting from the least +// significant bit. In particular when Num == 0, no positions are set to 1. +// A static assert will be triggered if First + Num > sizeof(T) * 8, that is, +// a bit that will not fit in the underlying type is set. +template +struct SetBits { + static_assert(First < sizeof(T) * 8, + "Tried to set a bit that is shifted too far."); + const static T get = (T(1) << First) | SetBits::get; +}; + +template +struct SetBits { + const static T get = T(0); +}; + +// This is all compile-time so we can put our tests right here. +static_assert(SetBits::get == uint32_t(0x00000000), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x00000001), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x80000000), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x00000006), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0xc0000000), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x7FFFFFFF), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0xFFFFFFFF), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0xFFFF0000), + "SetBits failed"); + +static_assert(SetBits::get == uint64_t(0x0000000000000001LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0x8000000000000000LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0xc000000000000000LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0x0000000080000000LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0x00000000FFFF0000LL), + "SetBits failed"); + +} // namespace spvutils + +#endif // LIBSPIRV_UTIL_BITUTILS_H_ diff --git a/ios/include/glslang/SPIRV/disassemble.h b/ios/include/glslang/SPIRV/disassemble.h new file mode 100644 index 00000000..b6a46357 --- /dev/null +++ b/ios/include/glslang/SPIRV/disassemble.h @@ -0,0 +1,53 @@ +// +// Copyright (C) 2014-2015 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// +// Disassembler for SPIR-V. +// + +#pragma once +#ifndef disassembler_H +#define disassembler_H + +#include +#include + +namespace spv { + + // disassemble with glslang custom disassembler + void Disassemble(std::ostream& out, const std::vector&); + +} // end namespace spv + +#endif // disassembler_H diff --git a/ios/include/glslang/SPIRV/doc.h b/ios/include/glslang/SPIRV/doc.h new file mode 100644 index 00000000..293256a2 --- /dev/null +++ b/ios/include/glslang/SPIRV/doc.h @@ -0,0 +1,258 @@ +// +// Copyright (C) 2014-2015 LunarG, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// +// Parameterize the SPIR-V enumerants. +// + +#pragma once + +#include "spirv.hpp" + +#include + +namespace spv { + +// Fill in all the parameters +void Parameterize(); + +// Return the English names of all the enums. +const char* SourceString(int); +const char* AddressingString(int); +const char* MemoryString(int); +const char* ExecutionModelString(int); +const char* ExecutionModeString(int); +const char* StorageClassString(int); +const char* DecorationString(int); +const char* BuiltInString(int); +const char* DimensionString(int); +const char* SelectControlString(int); +const char* LoopControlString(int); +const char* FunctionControlString(int); +const char* SamplerAddressingModeString(int); +const char* SamplerFilterModeString(int); +const char* ImageFormatString(int); +const char* ImageChannelOrderString(int); +const char* ImageChannelTypeString(int); +const char* ImageChannelDataTypeString(int type); +const char* ImageOperandsString(int format); +const char* ImageOperands(int); +const char* FPFastMathString(int); +const char* FPRoundingModeString(int); +const char* LinkageTypeString(int); +const char* FuncParamAttrString(int); +const char* AccessQualifierString(int); +const char* MemorySemanticsString(int); +const char* MemoryAccessString(int); +const char* ExecutionScopeString(int); +const char* GroupOperationString(int); +const char* KernelEnqueueFlagsString(int); +const char* KernelProfilingInfoString(int); +const char* CapabilityString(int); +const char* OpcodeString(int); +const char* ScopeString(int mem); + +// For grouping opcodes into subsections +enum OpcodeClass { + OpClassMisc, + OpClassDebug, + OpClassAnnotate, + OpClassExtension, + OpClassMode, + OpClassType, + OpClassConstant, + OpClassMemory, + OpClassFunction, + OpClassImage, + OpClassConvert, + OpClassComposite, + OpClassArithmetic, + OpClassBit, + OpClassRelationalLogical, + OpClassDerivative, + OpClassFlowControl, + OpClassAtomic, + OpClassPrimitive, + OpClassBarrier, + OpClassGroup, + OpClassDeviceSideEnqueue, + OpClassPipe, + + OpClassCount, + OpClassMissing // all instructions start out as missing +}; + +// For parameterizing operands. +enum OperandClass { + OperandNone, + OperandId, + OperandVariableIds, + OperandOptionalLiteral, + OperandOptionalLiteralString, + OperandVariableLiterals, + OperandVariableIdLiteral, + OperandVariableLiteralId, + OperandLiteralNumber, + OperandLiteralString, + OperandSource, + OperandExecutionModel, + OperandAddressing, + OperandMemory, + OperandExecutionMode, + OperandStorage, + OperandDimensionality, + OperandSamplerAddressingMode, + OperandSamplerFilterMode, + OperandSamplerImageFormat, + OperandImageChannelOrder, + OperandImageChannelDataType, + OperandImageOperands, + OperandFPFastMath, + OperandFPRoundingMode, + OperandLinkageType, + OperandAccessQualifier, + OperandFuncParamAttr, + OperandDecoration, + OperandBuiltIn, + OperandSelect, + OperandLoop, + OperandFunction, + OperandMemorySemantics, + OperandMemoryAccess, + OperandScope, + OperandGroupOperation, + OperandKernelEnqueueFlags, + OperandKernelProfilingInfo, + OperandCapability, + + OperandOpcode, + + OperandCount +}; + +// Any specific enum can have a set of capabilities that allow it: +typedef std::vector EnumCaps; + +// Parameterize a set of operands with their OperandClass(es) and descriptions. +class OperandParameters { +public: + OperandParameters() { } + void push(OperandClass oc, const char* d, bool opt = false) + { + opClass.push_back(oc); + desc.push_back(d); + optional.push_back(opt); + } + void setOptional(); + OperandClass getClass(int op) const { return opClass[op]; } + const char* getDesc(int op) const { return desc[op]; } + bool isOptional(int op) const { return optional[op]; } + int getNum() const { return (int)opClass.size(); } + +protected: + std::vector opClass; + std::vector desc; + std::vector optional; +}; + +// Parameterize an enumerant +class EnumParameters { +public: + EnumParameters() : desc(0) { } + const char* desc; +}; + +// Parameterize a set of enumerants that form an enum +class EnumDefinition : public EnumParameters { +public: + EnumDefinition() : + ceiling(0), bitmask(false), getName(0), enumParams(0), operandParams(0) { } + void set(int ceil, const char* (*name)(int), EnumParameters* ep, bool mask = false) + { + ceiling = ceil; + getName = name; + bitmask = mask; + enumParams = ep; + } + void setOperands(OperandParameters* op) { operandParams = op; } + int ceiling; // ceiling of enumerants + bool bitmask; // true if these enumerants combine into a bitmask + const char* (*getName)(int); // a function that returns the name for each enumerant value (or shift) + EnumParameters* enumParams; // parameters for each individual enumerant + OperandParameters* operandParams; // sets of operands +}; + +// Parameterize an instruction's logical format, including its known set of operands, +// per OperandParameters above. +class InstructionParameters { +public: + InstructionParameters() : + opDesc("TBD"), + opClass(OpClassMissing), + typePresent(true), // most normal, only exceptions have to be spelled out + resultPresent(true) // most normal, only exceptions have to be spelled out + { } + + void setResultAndType(bool r, bool t) + { + resultPresent = r; + typePresent = t; + } + + bool hasResult() const { return resultPresent != 0; } + bool hasType() const { return typePresent != 0; } + + const char* opDesc; + OpcodeClass opClass; + OperandParameters operands; + +protected: + int typePresent : 1; + int resultPresent : 1; +}; + +// The set of objects that hold all the instruction/operand +// parameterization information. +extern InstructionParameters InstructionDesc[]; + +// These hold definitions of the enumerants used for operands +extern EnumDefinition OperandClassParams[]; + +const char* GetOperandDesc(OperandClass operand); +void PrintImmediateRow(int imm, const char* name, const EnumParameters* enumParams, bool caps, bool hex = false); +const char* AccessQualifierString(int attr); + +void PrintOperands(const OperandParameters& operands, int reservedOperands); + +} // end namespace spv diff --git a/ios/include/glslang/SPIRV/hex_float.h b/ios/include/glslang/SPIRV/hex_float.h new file mode 100644 index 00000000..8be8e9f7 --- /dev/null +++ b/ios/include/glslang/SPIRV/hex_float.h @@ -0,0 +1,1078 @@ +// Copyright (c) 2015-2016 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef LIBSPIRV_UTIL_HEX_FLOAT_H_ +#define LIBSPIRV_UTIL_HEX_FLOAT_H_ + +#include +#include +#include +#include +#include +#include +#include + +#if defined(_MSC_VER) && _MSC_VER < 1800 +namespace std { +bool isnan(double f) +{ + return ::_isnan(f) != 0; +} +bool isinf(double f) +{ + return ::_finite(f) == 0; +} +} +#endif + +#include "bitutils.h" + +namespace spvutils { + +class Float16 { + public: + Float16(uint16_t v) : val(v) {} + Float16() {} + static bool isNan(const Float16& val) { + return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) != 0); + } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(const Float16& val) { + return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) == 0); + } + Float16(const Float16& other) { val = other.val; } + uint16_t get_value() const { return val; } + + // Returns the maximum normal value. + static Float16 max() { return Float16(0x7bff); } + // Returns the lowest normal value. + static Float16 lowest() { return Float16(0xfbff); } + + private: + uint16_t val; +}; + +// To specialize this type, you must override uint_type to define +// an unsigned integer that can fit your floating point type. +// You must also add a isNan function that returns true if +// a value is Nan. +template +struct FloatProxyTraits { + typedef void uint_type; +}; + +template <> +struct FloatProxyTraits { + typedef uint32_t uint_type; + static bool isNan(float f) { return std::isnan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(float f) { return std::isinf(f); } + // Returns the maximum normal value. + static float max() { return std::numeric_limits::max(); } + // Returns the lowest normal value. + static float lowest() { return std::numeric_limits::lowest(); } +}; + +template <> +struct FloatProxyTraits { + typedef uint64_t uint_type; + static bool isNan(double f) { return std::isnan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(double f) { return std::isinf(f); } + // Returns the maximum normal value. + static double max() { return std::numeric_limits::max(); } + // Returns the lowest normal value. + static double lowest() { return std::numeric_limits::lowest(); } +}; + +template <> +struct FloatProxyTraits { + typedef uint16_t uint_type; + static bool isNan(Float16 f) { return Float16::isNan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(Float16 f) { return Float16::isInfinity(f); } + // Returns the maximum normal value. + static Float16 max() { return Float16::max(); } + // Returns the lowest normal value. + static Float16 lowest() { return Float16::lowest(); } +}; + +// Since copying a floating point number (especially if it is NaN) +// does not guarantee that bits are preserved, this class lets us +// store the type and use it as a float when necessary. +template +class FloatProxy { + public: + typedef typename FloatProxyTraits::uint_type uint_type; + + // Since this is to act similar to the normal floats, + // do not initialize the data by default. + FloatProxy() {} + + // Intentionally non-explicit. This is a proxy type so + // implicit conversions allow us to use it more transparently. + FloatProxy(T val) { data_ = BitwiseCast(val); } + + // Intentionally non-explicit. This is a proxy type so + // implicit conversions allow us to use it more transparently. + FloatProxy(uint_type val) { data_ = val; } + + // This is helpful to have and is guaranteed not to stomp bits. + FloatProxy operator-() const { + return static_cast(data_ ^ + (uint_type(0x1) << (sizeof(T) * 8 - 1))); + } + + // Returns the data as a floating point value. + T getAsFloat() const { return BitwiseCast(data_); } + + // Returns the raw data. + uint_type data() const { return data_; } + + // Returns true if the value represents any type of NaN. + bool isNan() { return FloatProxyTraits::isNan(getAsFloat()); } + // Returns true if the value represents any type of infinity. + bool isInfinity() { return FloatProxyTraits::isInfinity(getAsFloat()); } + + // Returns the maximum normal value. + static FloatProxy max() { + return FloatProxy(FloatProxyTraits::max()); + } + // Returns the lowest normal value. + static FloatProxy lowest() { + return FloatProxy(FloatProxyTraits::lowest()); + } + + private: + uint_type data_; +}; + +template +bool operator==(const FloatProxy& first, const FloatProxy& second) { + return first.data() == second.data(); +} + +// Reads a FloatProxy value as a normal float from a stream. +template +std::istream& operator>>(std::istream& is, FloatProxy& value) { + T float_val; + is >> float_val; + value = FloatProxy(float_val); + return is; +} + +// This is an example traits. It is not meant to be used in practice, but will +// be the default for any non-specialized type. +template +struct HexFloatTraits { + // Integer type that can store this hex-float. + typedef void uint_type; + // Signed integer type that can store this hex-float. + typedef void int_type; + // The numerical type that this HexFloat represents. + typedef void underlying_type; + // The type needed to construct the underlying type. + typedef void native_type; + // The number of bits that are actually relevant in the uint_type. + // This allows us to deal with, for example, 24-bit values in a 32-bit + // integer. + static const uint32_t num_used_bits = 0; + // Number of bits that represent the exponent. + static const uint32_t num_exponent_bits = 0; + // Number of bits that represent the fractional part. + static const uint32_t num_fraction_bits = 0; + // The bias of the exponent. (How much we need to subtract from the stored + // value to get the correct value.) + static const uint32_t exponent_bias = 0; +}; + +// Traits for IEEE float. +// 1 sign bit, 8 exponent bits, 23 fractional bits. +template <> +struct HexFloatTraits> { + typedef uint32_t uint_type; + typedef int32_t int_type; + typedef FloatProxy underlying_type; + typedef float native_type; + static const uint_type num_used_bits = 32; + static const uint_type num_exponent_bits = 8; + static const uint_type num_fraction_bits = 23; + static const uint_type exponent_bias = 127; +}; + +// Traits for IEEE double. +// 1 sign bit, 11 exponent bits, 52 fractional bits. +template <> +struct HexFloatTraits> { + typedef uint64_t uint_type; + typedef int64_t int_type; + typedef FloatProxy underlying_type; + typedef double native_type; + static const uint_type num_used_bits = 64; + static const uint_type num_exponent_bits = 11; + static const uint_type num_fraction_bits = 52; + static const uint_type exponent_bias = 1023; +}; + +// Traits for IEEE half. +// 1 sign bit, 5 exponent bits, 10 fractional bits. +template <> +struct HexFloatTraits> { + typedef uint16_t uint_type; + typedef int16_t int_type; + typedef uint16_t underlying_type; + typedef uint16_t native_type; + static const uint_type num_used_bits = 16; + static const uint_type num_exponent_bits = 5; + static const uint_type num_fraction_bits = 10; + static const uint_type exponent_bias = 15; +}; + +enum round_direction { + kRoundToZero, + kRoundToNearestEven, + kRoundToPositiveInfinity, + kRoundToNegativeInfinity +}; + +// Template class that houses a floating pointer number. +// It exposes a number of constants based on the provided traits to +// assist in interpreting the bits of the value. +template > +class HexFloat { + public: + typedef typename Traits::uint_type uint_type; + typedef typename Traits::int_type int_type; + typedef typename Traits::underlying_type underlying_type; + typedef typename Traits::native_type native_type; + + explicit HexFloat(T f) : value_(f) {} + + T value() const { return value_; } + void set_value(T f) { value_ = f; } + + // These are all written like this because it is convenient to have + // compile-time constants for all of these values. + + // Pass-through values to save typing. + static const uint32_t num_used_bits = Traits::num_used_bits; + static const uint32_t exponent_bias = Traits::exponent_bias; + static const uint32_t num_exponent_bits = Traits::num_exponent_bits; + static const uint32_t num_fraction_bits = Traits::num_fraction_bits; + + // Number of bits to shift left to set the highest relevant bit. + static const uint32_t top_bit_left_shift = num_used_bits - 1; + // How many nibbles (hex characters) the fractional part takes up. + static const uint32_t fraction_nibbles = (num_fraction_bits + 3) / 4; + // If the fractional part does not fit evenly into a hex character (4-bits) + // then we have to left-shift to get rid of leading 0s. This is the amount + // we have to shift (might be 0). + static const uint32_t num_overflow_bits = + fraction_nibbles * 4 - num_fraction_bits; + + // The representation of the fraction, not the actual bits. This + // includes the leading bit that is usually implicit. + static const uint_type fraction_represent_mask = + spvutils::SetBits::get; + + // The topmost bit in the nibble-aligned fraction. + static const uint_type fraction_top_bit = + uint_type(1) << (num_fraction_bits + num_overflow_bits - 1); + + // The least significant bit in the exponent, which is also the bit + // immediately to the left of the significand. + static const uint_type first_exponent_bit = uint_type(1) + << (num_fraction_bits); + + // The mask for the encoded fraction. It does not include the + // implicit bit. + static const uint_type fraction_encode_mask = + spvutils::SetBits::get; + + // The bit that is used as a sign. + static const uint_type sign_mask = uint_type(1) << top_bit_left_shift; + + // The bits that represent the exponent. + static const uint_type exponent_mask = + spvutils::SetBits::get; + + // How far left the exponent is shifted. + static const uint32_t exponent_left_shift = num_fraction_bits; + + // How far from the right edge the fraction is shifted. + static const uint32_t fraction_right_shift = + static_cast(sizeof(uint_type) * 8) - num_fraction_bits; + + // The maximum representable unbiased exponent. + static const int_type max_exponent = + (exponent_mask >> num_fraction_bits) - exponent_bias; + // The minimum representable exponent for normalized numbers. + static const int_type min_exponent = -static_cast(exponent_bias); + + // Returns the bits associated with the value. + uint_type getBits() const { return spvutils::BitwiseCast(value_); } + + // Returns the bits associated with the value, without the leading sign bit. + uint_type getUnsignedBits() const { + return static_cast(spvutils::BitwiseCast(value_) & + ~sign_mask); + } + + // Returns the bits associated with the exponent, shifted to start at the + // lsb of the type. + const uint_type getExponentBits() const { + return static_cast((getBits() & exponent_mask) >> + num_fraction_bits); + } + + // Returns the exponent in unbiased form. This is the exponent in the + // human-friendly form. + const int_type getUnbiasedExponent() const { + return static_cast(getExponentBits() - exponent_bias); + } + + // Returns just the significand bits from the value. + const uint_type getSignificandBits() const { + return getBits() & fraction_encode_mask; + } + + // If the number was normalized, returns the unbiased exponent. + // If the number was denormal, normalize the exponent first. + const int_type getUnbiasedNormalizedExponent() const { + if ((getBits() & ~sign_mask) == 0) { // special case if everything is 0 + return 0; + } + int_type exp = getUnbiasedExponent(); + if (exp == min_exponent) { // We are in denorm land. + uint_type significand_bits = getSignificandBits(); + while ((significand_bits & (first_exponent_bit >> 1)) == 0) { + significand_bits = static_cast(significand_bits << 1); + exp = static_cast(exp - 1); + } + significand_bits &= fraction_encode_mask; + } + return exp; + } + + // Returns the signficand after it has been normalized. + const uint_type getNormalizedSignificand() const { + int_type unbiased_exponent = getUnbiasedNormalizedExponent(); + uint_type significand = getSignificandBits(); + for (int_type i = unbiased_exponent; i <= min_exponent; ++i) { + significand = static_cast(significand << 1); + } + significand &= fraction_encode_mask; + return significand; + } + + // Returns true if this number represents a negative value. + bool isNegative() const { return (getBits() & sign_mask) != 0; } + + // Sets this HexFloat from the individual components. + // Note this assumes EVERY significand is normalized, and has an implicit + // leading one. This means that the only way that this method will set 0, + // is if you set a number so denormalized that it underflows. + // Do not use this method with raw bits extracted from a subnormal number, + // since subnormals do not have an implicit leading 1 in the significand. + // The significand is also expected to be in the + // lowest-most num_fraction_bits of the uint_type. + // The exponent is expected to be unbiased, meaning an exponent of + // 0 actually means 0. + // If underflow_round_up is set, then on underflow, if a number is non-0 + // and would underflow, we round up to the smallest denorm. + void setFromSignUnbiasedExponentAndNormalizedSignificand( + bool negative, int_type exponent, uint_type significand, + bool round_denorm_up) { + bool significand_is_zero = significand == 0; + + if (exponent <= min_exponent) { + // If this was denormalized, then we have to shift the bit on, meaning + // the significand is not zero. + significand_is_zero = false; + significand |= first_exponent_bit; + significand = static_cast(significand >> 1); + } + + while (exponent < min_exponent) { + significand = static_cast(significand >> 1); + ++exponent; + } + + if (exponent == min_exponent) { + if (significand == 0 && !significand_is_zero && round_denorm_up) { + significand = static_cast(0x1); + } + } + + uint_type new_value = 0; + if (negative) { + new_value = static_cast(new_value | sign_mask); + } + exponent = static_cast(exponent + exponent_bias); + assert(exponent >= 0); + + // put it all together + exponent = static_cast((exponent << exponent_left_shift) & + exponent_mask); + significand = static_cast(significand & fraction_encode_mask); + new_value = static_cast(new_value | (exponent | significand)); + value_ = BitwiseCast(new_value); + } + + // Increments the significand of this number by the given amount. + // If this would spill the significand into the implicit bit, + // carry is set to true and the significand is shifted to fit into + // the correct location, otherwise carry is set to false. + // All significands and to_increment are assumed to be within the bounds + // for a valid significand. + static uint_type incrementSignificand(uint_type significand, + uint_type to_increment, bool* carry) { + significand = static_cast(significand + to_increment); + *carry = false; + if (significand & first_exponent_bit) { + *carry = true; + // The implicit 1-bit will have carried, so we should zero-out the + // top bit and shift back. + significand = static_cast(significand & ~first_exponent_bit); + significand = static_cast(significand >> 1); + } + return significand; + } + + // These exist because MSVC throws warnings on negative right-shifts + // even if they are not going to be executed. Eg: + // constant_number < 0? 0: constant_number + // These convert the negative left-shifts into right shifts. + + template + uint_type negatable_left_shift(int_type N, uint_type val) + { + if(N >= 0) + return val << N; + + return val >> -N; + } + + template + uint_type negatable_right_shift(int_type N, uint_type val) + { + if(N >= 0) + return val >> N; + + return val << -N; + } + + // Returns the significand, rounded to fit in a significand in + // other_T. This is shifted so that the most significant + // bit of the rounded number lines up with the most significant bit + // of the returned significand. + template + typename other_T::uint_type getRoundedNormalizedSignificand( + round_direction dir, bool* carry_bit) { + typedef typename other_T::uint_type other_uint_type; + static const int_type num_throwaway_bits = + static_cast(num_fraction_bits) - + static_cast(other_T::num_fraction_bits); + + static const uint_type last_significant_bit = + (num_throwaway_bits < 0) + ? 0 + : negatable_left_shift(num_throwaway_bits, 1u); + static const uint_type first_rounded_bit = + (num_throwaway_bits < 1) + ? 0 + : negatable_left_shift(num_throwaway_bits - 1, 1u); + + static const uint_type throwaway_mask_bits = + num_throwaway_bits > 0 ? num_throwaway_bits : 0; + static const uint_type throwaway_mask = + spvutils::SetBits::get; + + *carry_bit = false; + other_uint_type out_val = 0; + uint_type significand = getNormalizedSignificand(); + // If we are up-casting, then we just have to shift to the right location. + if (num_throwaway_bits <= 0) { + out_val = static_cast(significand); + uint_type shift_amount = static_cast(-num_throwaway_bits); + out_val = static_cast(out_val << shift_amount); + return out_val; + } + + // If every non-representable bit is 0, then we don't have any casting to + // do. + if ((significand & throwaway_mask) == 0) { + return static_cast( + negatable_right_shift(num_throwaway_bits, significand)); + } + + bool round_away_from_zero = false; + // We actually have to narrow the significand here, so we have to follow the + // rounding rules. + switch (dir) { + case kRoundToZero: + break; + case kRoundToPositiveInfinity: + round_away_from_zero = !isNegative(); + break; + case kRoundToNegativeInfinity: + round_away_from_zero = isNegative(); + break; + case kRoundToNearestEven: + // Have to round down, round bit is 0 + if ((first_rounded_bit & significand) == 0) { + break; + } + if (((significand & throwaway_mask) & ~first_rounded_bit) != 0) { + // If any subsequent bit of the rounded portion is non-0 then we round + // up. + round_away_from_zero = true; + break; + } + // We are exactly half-way between 2 numbers, pick even. + if ((significand & last_significant_bit) != 0) { + // 1 for our last bit, round up. + round_away_from_zero = true; + break; + } + break; + } + + if (round_away_from_zero) { + return static_cast( + negatable_right_shift(num_throwaway_bits, incrementSignificand( + significand, last_significant_bit, carry_bit))); + } else { + return static_cast( + negatable_right_shift(num_throwaway_bits, significand)); + } + } + + // Casts this value to another HexFloat. If the cast is widening, + // then round_dir is ignored. If the cast is narrowing, then + // the result is rounded in the direction specified. + // This number will retain Nan and Inf values. + // It will also saturate to Inf if the number overflows, and + // underflow to (0 or min depending on rounding) if the number underflows. + template + void castTo(other_T& other, round_direction round_dir) { + other = other_T(static_cast(0)); + bool negate = isNegative(); + if (getUnsignedBits() == 0) { + if (negate) { + other.set_value(-other.value()); + } + return; + } + uint_type significand = getSignificandBits(); + bool carried = false; + typename other_T::uint_type rounded_significand = + getRoundedNormalizedSignificand(round_dir, &carried); + + int_type exponent = getUnbiasedExponent(); + if (exponent == min_exponent) { + // If we are denormal, normalize the exponent, so that we can encode + // easily. + exponent = static_cast(exponent + 1); + for (uint_type check_bit = first_exponent_bit >> 1; check_bit != 0; + check_bit = static_cast(check_bit >> 1)) { + exponent = static_cast(exponent - 1); + if (check_bit & significand) break; + } + } + + bool is_nan = + (getBits() & exponent_mask) == exponent_mask && significand != 0; + bool is_inf = + !is_nan && + ((exponent + carried) > static_cast(other_T::exponent_bias) || + (significand == 0 && (getBits() & exponent_mask) == exponent_mask)); + + // If we are Nan or Inf we should pass that through. + if (is_inf) { + other.set_value(BitwiseCast( + static_cast( + (negate ? other_T::sign_mask : 0) | other_T::exponent_mask))); + return; + } + if (is_nan) { + typename other_T::uint_type shifted_significand; + shifted_significand = static_cast( + negatable_left_shift( + static_cast(other_T::num_fraction_bits) - + static_cast(num_fraction_bits), significand)); + + // We are some sort of Nan. We try to keep the bit-pattern of the Nan + // as close as possible. If we had to shift off bits so we are 0, then we + // just set the last bit. + other.set_value(BitwiseCast( + static_cast( + (negate ? other_T::sign_mask : 0) | other_T::exponent_mask | + (shifted_significand == 0 ? 0x1 : shifted_significand)))); + return; + } + + bool round_underflow_up = + isNegative() ? round_dir == kRoundToNegativeInfinity + : round_dir == kRoundToPositiveInfinity; + typedef typename other_T::int_type other_int_type; + // setFromSignUnbiasedExponentAndNormalizedSignificand will + // zero out any underflowing value (but retain the sign). + other.setFromSignUnbiasedExponentAndNormalizedSignificand( + negate, static_cast(exponent), rounded_significand, + round_underflow_up); + return; + } + + private: + T value_; + + static_assert(num_used_bits == + Traits::num_exponent_bits + Traits::num_fraction_bits + 1, + "The number of bits do not fit"); + static_assert(sizeof(T) == sizeof(uint_type), "The type sizes do not match"); +}; + +// Returns 4 bits represented by the hex character. +inline uint8_t get_nibble_from_character(int character) { + const char* dec = "0123456789"; + const char* lower = "abcdef"; + const char* upper = "ABCDEF"; + const char* p = nullptr; + if ((p = strchr(dec, character))) { + return static_cast(p - dec); + } else if ((p = strchr(lower, character))) { + return static_cast(p - lower + 0xa); + } else if ((p = strchr(upper, character))) { + return static_cast(p - upper + 0xa); + } + + assert(false && "This was called with a non-hex character"); + return 0; +} + +// Outputs the given HexFloat to the stream. +template +std::ostream& operator<<(std::ostream& os, const HexFloat& value) { + typedef HexFloat HF; + typedef typename HF::uint_type uint_type; + typedef typename HF::int_type int_type; + + static_assert(HF::num_used_bits != 0, + "num_used_bits must be non-zero for a valid float"); + static_assert(HF::num_exponent_bits != 0, + "num_exponent_bits must be non-zero for a valid float"); + static_assert(HF::num_fraction_bits != 0, + "num_fractin_bits must be non-zero for a valid float"); + + const uint_type bits = spvutils::BitwiseCast(value.value()); + const char* const sign = (bits & HF::sign_mask) ? "-" : ""; + const uint_type exponent = static_cast( + (bits & HF::exponent_mask) >> HF::num_fraction_bits); + + uint_type fraction = static_cast((bits & HF::fraction_encode_mask) + << HF::num_overflow_bits); + + const bool is_zero = exponent == 0 && fraction == 0; + const bool is_denorm = exponent == 0 && !is_zero; + + // exponent contains the biased exponent we have to convert it back into + // the normal range. + int_type int_exponent = static_cast(exponent - HF::exponent_bias); + // If the number is all zeros, then we actually have to NOT shift the + // exponent. + int_exponent = is_zero ? 0 : int_exponent; + + // If we are denorm, then start shifting, and decreasing the exponent until + // our leading bit is 1. + + if (is_denorm) { + while ((fraction & HF::fraction_top_bit) == 0) { + fraction = static_cast(fraction << 1); + int_exponent = static_cast(int_exponent - 1); + } + // Since this is denormalized, we have to consume the leading 1 since it + // will end up being implicit. + fraction = static_cast(fraction << 1); // eat the leading 1 + fraction &= HF::fraction_represent_mask; + } + + uint_type fraction_nibbles = HF::fraction_nibbles; + // We do not have to display any trailing 0s, since this represents the + // fractional part. + while (fraction_nibbles > 0 && (fraction & 0xF) == 0) { + // Shift off any trailing values; + fraction = static_cast(fraction >> 4); + --fraction_nibbles; + } + + const auto saved_flags = os.flags(); + const auto saved_fill = os.fill(); + + os << sign << "0x" << (is_zero ? '0' : '1'); + if (fraction_nibbles) { + // Make sure to keep the leading 0s in place, since this is the fractional + // part. + os << "." << std::setw(static_cast(fraction_nibbles)) + << std::setfill('0') << std::hex << fraction; + } + os << "p" << std::dec << (int_exponent >= 0 ? "+" : "") << int_exponent; + + os.flags(saved_flags); + os.fill(saved_fill); + + return os; +} + +// Returns true if negate_value is true and the next character on the +// input stream is a plus or minus sign. In that case we also set the fail bit +// on the stream and set the value to the zero value for its type. +template +inline bool RejectParseDueToLeadingSign(std::istream& is, bool negate_value, + HexFloat& value) { + if (negate_value) { + auto next_char = is.peek(); + if (next_char == '-' || next_char == '+') { + // Fail the parse. Emulate standard behaviour by setting the value to + // the zero value, and set the fail bit on the stream. + value = HexFloat(typename HexFloat::uint_type(0)); + is.setstate(std::ios_base::failbit); + return true; + } + } + return false; +} + +// Parses a floating point number from the given stream and stores it into the +// value parameter. +// If negate_value is true then the number may not have a leading minus or +// plus, and if it successfully parses, then the number is negated before +// being stored into the value parameter. +// If the value cannot be correctly parsed or overflows the target floating +// point type, then set the fail bit on the stream. +// TODO(dneto): Promise C++11 standard behavior in how the value is set in +// the error case, but only after all target platforms implement it correctly. +// In particular, the Microsoft C++ runtime appears to be out of spec. +template +inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value, + HexFloat& value) { + if (RejectParseDueToLeadingSign(is, negate_value, value)) { + return is; + } + T val; + is >> val; + if (negate_value) { + val = -val; + } + value.set_value(val); + // In the failure case, map -0.0 to 0.0. + if (is.fail() && value.getUnsignedBits() == 0u) { + value = HexFloat(typename HexFloat::uint_type(0)); + } + if (val.isInfinity()) { + // Fail the parse. Emulate standard behaviour by setting the value to + // the closest normal value, and set the fail bit on the stream. + value.set_value((value.isNegative() || negate_value) ? T::lowest() + : T::max()); + is.setstate(std::ios_base::failbit); + } + return is; +} + +// Specialization of ParseNormalFloat for FloatProxy values. +// This will parse the float as it were a 32-bit floating point number, +// and then round it down to fit into a Float16 value. +// The number is rounded towards zero. +// If negate_value is true then the number may not have a leading minus or +// plus, and if it successfully parses, then the number is negated before +// being stored into the value parameter. +// If the value cannot be correctly parsed or overflows the target floating +// point type, then set the fail bit on the stream. +// TODO(dneto): Promise C++11 standard behavior in how the value is set in +// the error case, but only after all target platforms implement it correctly. +// In particular, the Microsoft C++ runtime appears to be out of spec. +template <> +inline std::istream& +ParseNormalFloat, HexFloatTraits>>( + std::istream& is, bool negate_value, + HexFloat, HexFloatTraits>>& value) { + // First parse as a 32-bit float. + HexFloat> float_val(0.0f); + ParseNormalFloat(is, negate_value, float_val); + + // Then convert to 16-bit float, saturating at infinities, and + // rounding toward zero. + float_val.castTo(value, kRoundToZero); + + // Overflow on 16-bit behaves the same as for 32- and 64-bit: set the + // fail bit and set the lowest or highest value. + if (Float16::isInfinity(value.value().getAsFloat())) { + value.set_value(value.isNegative() ? Float16::lowest() : Float16::max()); + is.setstate(std::ios_base::failbit); + } + return is; +} + +// Reads a HexFloat from the given stream. +// If the float is not encoded as a hex-float then it will be parsed +// as a regular float. +// This may fail if your stream does not support at least one unget. +// Nan values can be encoded with "0x1.p+exponent_bias". +// This would normally overflow a float and round to +// infinity but this special pattern is the exact representation for a NaN, +// and therefore is actually encoded as the correct NaN. To encode inf, +// either 0x0p+exponent_bias can be specified or any exponent greater than +// exponent_bias. +// Examples using IEEE 32-bit float encoding. +// 0x1.0p+128 (+inf) +// -0x1.0p-128 (-inf) +// +// 0x1.1p+128 (+Nan) +// -0x1.1p+128 (-Nan) +// +// 0x1p+129 (+inf) +// -0x1p+129 (-inf) +template +std::istream& operator>>(std::istream& is, HexFloat& value) { + using HF = HexFloat; + using uint_type = typename HF::uint_type; + using int_type = typename HF::int_type; + + value.set_value(static_cast(0.f)); + + if (is.flags() & std::ios::skipws) { + // If the user wants to skip whitespace , then we should obey that. + while (std::isspace(is.peek())) { + is.get(); + } + } + + auto next_char = is.peek(); + bool negate_value = false; + + if (next_char != '-' && next_char != '0') { + return ParseNormalFloat(is, negate_value, value); + } + + if (next_char == '-') { + negate_value = true; + is.get(); + next_char = is.peek(); + } + + if (next_char == '0') { + is.get(); // We may have to unget this. + auto maybe_hex_start = is.peek(); + if (maybe_hex_start != 'x' && maybe_hex_start != 'X') { + is.unget(); + return ParseNormalFloat(is, negate_value, value); + } else { + is.get(); // Throw away the 'x'; + } + } else { + return ParseNormalFloat(is, negate_value, value); + } + + // This "looks" like a hex-float so treat it as one. + bool seen_p = false; + bool seen_dot = false; + uint_type fraction_index = 0; + + uint_type fraction = 0; + int_type exponent = HF::exponent_bias; + + // Strip off leading zeros so we don't have to special-case them later. + while ((next_char = is.peek()) == '0') { + is.get(); + } + + bool is_denorm = + true; // Assume denorm "representation" until we hear otherwise. + // NB: This does not mean the value is actually denorm, + // it just means that it was written 0. + bool bits_written = false; // Stays false until we write a bit. + while (!seen_p && !seen_dot) { + // Handle characters that are left of the fractional part. + if (next_char == '.') { + seen_dot = true; + } else if (next_char == 'p') { + seen_p = true; + } else if (::isxdigit(next_char)) { + // We know this is not denormalized since we have stripped all leading + // zeroes and we are not a ".". + is_denorm = false; + int number = get_nibble_from_character(next_char); + for (int i = 0; i < 4; ++i, number <<= 1) { + uint_type write_bit = (number & 0x8) ? 0x1 : 0x0; + if (bits_written) { + // If we are here the bits represented belong in the fractional + // part of the float, and we have to adjust the exponent accordingly. + fraction = static_cast( + fraction | + static_cast( + write_bit << (HF::top_bit_left_shift - fraction_index++))); + exponent = static_cast(exponent + 1); + } + bits_written |= write_bit != 0; + } + } else { + // We have not found our exponent yet, so we have to fail. + is.setstate(std::ios::failbit); + return is; + } + is.get(); + next_char = is.peek(); + } + bits_written = false; + while (seen_dot && !seen_p) { + // Handle only fractional parts now. + if (next_char == 'p') { + seen_p = true; + } else if (::isxdigit(next_char)) { + int number = get_nibble_from_character(next_char); + for (int i = 0; i < 4; ++i, number <<= 1) { + uint_type write_bit = (number & 0x8) ? 0x01 : 0x00; + bits_written |= write_bit != 0; + if (is_denorm && !bits_written) { + // Handle modifying the exponent here this way we can handle + // an arbitrary number of hex values without overflowing our + // integer. + exponent = static_cast(exponent - 1); + } else { + fraction = static_cast( + fraction | + static_cast( + write_bit << (HF::top_bit_left_shift - fraction_index++))); + } + } + } else { + // We still have not found our 'p' exponent yet, so this is not a valid + // hex-float. + is.setstate(std::ios::failbit); + return is; + } + is.get(); + next_char = is.peek(); + } + + bool seen_sign = false; + int8_t exponent_sign = 1; + int_type written_exponent = 0; + while (true) { + if ((next_char == '-' || next_char == '+')) { + if (seen_sign) { + is.setstate(std::ios::failbit); + return is; + } + seen_sign = true; + exponent_sign = (next_char == '-') ? -1 : 1; + } else if (::isdigit(next_char)) { + // Hex-floats express their exponent as decimal. + written_exponent = static_cast(written_exponent * 10); + written_exponent = + static_cast(written_exponent + (next_char - '0')); + } else { + break; + } + is.get(); + next_char = is.peek(); + } + + written_exponent = static_cast(written_exponent * exponent_sign); + exponent = static_cast(exponent + written_exponent); + + bool is_zero = is_denorm && (fraction == 0); + if (is_denorm && !is_zero) { + fraction = static_cast(fraction << 1); + exponent = static_cast(exponent - 1); + } else if (is_zero) { + exponent = 0; + } + + if (exponent <= 0 && !is_zero) { + fraction = static_cast(fraction >> 1); + fraction |= static_cast(1) << HF::top_bit_left_shift; + } + + fraction = (fraction >> HF::fraction_right_shift) & HF::fraction_encode_mask; + + const int_type max_exponent = + SetBits::get; + + // Handle actual denorm numbers + while (exponent < 0 && !is_zero) { + fraction = static_cast(fraction >> 1); + exponent = static_cast(exponent + 1); + + fraction &= HF::fraction_encode_mask; + if (fraction == 0) { + // We have underflowed our fraction. We should clamp to zero. + is_zero = true; + exponent = 0; + } + } + + // We have overflowed so we should be inf/-inf. + if (exponent > max_exponent) { + exponent = max_exponent; + fraction = 0; + } + + uint_type output_bits = static_cast( + static_cast(negate_value ? 1 : 0) << HF::top_bit_left_shift); + output_bits |= fraction; + + uint_type shifted_exponent = static_cast( + static_cast(exponent << HF::exponent_left_shift) & + HF::exponent_mask); + output_bits |= shifted_exponent; + + T output_float = spvutils::BitwiseCast(output_bits); + value.set_value(output_float); + + return is; +} + +// Writes a FloatProxy value to a stream. +// Zero and normal numbers are printed in the usual notation, but with +// enough digits to fully reproduce the value. Other values (subnormal, +// NaN, and infinity) are printed as a hex float. +template +std::ostream& operator<<(std::ostream& os, const FloatProxy& value) { + auto float_val = value.getAsFloat(); + switch (std::fpclassify(float_val)) { + case FP_ZERO: + case FP_NORMAL: { + auto saved_precision = os.precision(); + os.precision(std::numeric_limits::digits10); + os << float_val; + os.precision(saved_precision); + } break; + default: + os << HexFloat>(value); + break; + } + return os; +} + +template <> +inline std::ostream& operator<<(std::ostream& os, + const FloatProxy& value) { + os << HexFloat>(value); + return os; +} +} + +#endif // LIBSPIRV_UTIL_HEX_FLOAT_H_ diff --git a/ios/include/glslang/SPIRV/spirv.hpp b/ios/include/glslang/SPIRV/spirv.hpp new file mode 100644 index 00000000..dae36cf2 --- /dev/null +++ b/ios/include/glslang/SPIRV/spirv.hpp @@ -0,0 +1,2114 @@ +// Copyright (c) 2014-2020 The Khronos Group Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and/or associated documentation files (the "Materials"), +// to deal in the Materials without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Materials, and to permit persons to whom the +// Materials are 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 Materials. +// +// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +// +// THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +// IN THE MATERIALS. + +// This header is automatically generated by the same tool that creates +// the Binary Section of the SPIR-V specification. + +// Enumeration tokens for SPIR-V, in various styles: +// C, C++, C++11, JSON, Lua, Python, C#, D +// +// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL +// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL +// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL +// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL +// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] +// - C# will use enum classes in the Specification class located in the "Spv" namespace, +// e.g.: Spv.Specification.SourceLanguage.GLSL +// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL +// +// Some tokens act like mask values, which can be OR'd together, +// while others are mutually exclusive. The mask-like ones have +// "Mask" in their name, and a parallel enum that has the shift +// amount (1 << x) for each corresponding enumerant. + +#ifndef spirv_HPP +#define spirv_HPP + +namespace spv { + +typedef unsigned int Id; + +#define SPV_VERSION 0x10500 +#define SPV_REVISION 3 + +static const unsigned int MagicNumber = 0x07230203; +static const unsigned int Version = 0x00010500; +static const unsigned int Revision = 3; +static const unsigned int OpCodeMask = 0xffff; +static const unsigned int WordCountShift = 16; + +enum SourceLanguage { + SourceLanguageUnknown = 0, + SourceLanguageESSL = 1, + SourceLanguageGLSL = 2, + SourceLanguageOpenCL_C = 3, + SourceLanguageOpenCL_CPP = 4, + SourceLanguageHLSL = 5, + SourceLanguageMax = 0x7fffffff, +}; + +enum ExecutionModel { + ExecutionModelVertex = 0, + ExecutionModelTessellationControl = 1, + ExecutionModelTessellationEvaluation = 2, + ExecutionModelGeometry = 3, + ExecutionModelFragment = 4, + ExecutionModelGLCompute = 5, + ExecutionModelKernel = 6, + ExecutionModelTaskNV = 5267, + ExecutionModelMeshNV = 5268, + ExecutionModelRayGenerationKHR = 5313, + ExecutionModelRayGenerationNV = 5313, + ExecutionModelIntersectionKHR = 5314, + ExecutionModelIntersectionNV = 5314, + ExecutionModelAnyHitKHR = 5315, + ExecutionModelAnyHitNV = 5315, + ExecutionModelClosestHitKHR = 5316, + ExecutionModelClosestHitNV = 5316, + ExecutionModelMissKHR = 5317, + ExecutionModelMissNV = 5317, + ExecutionModelCallableKHR = 5318, + ExecutionModelCallableNV = 5318, + ExecutionModelMax = 0x7fffffff, +}; + +enum AddressingModel { + AddressingModelLogical = 0, + AddressingModelPhysical32 = 1, + AddressingModelPhysical64 = 2, + AddressingModelPhysicalStorageBuffer64 = 5348, + AddressingModelPhysicalStorageBuffer64EXT = 5348, + AddressingModelMax = 0x7fffffff, +}; + +enum MemoryModel { + MemoryModelSimple = 0, + MemoryModelGLSL450 = 1, + MemoryModelOpenCL = 2, + MemoryModelVulkan = 3, + MemoryModelVulkanKHR = 3, + MemoryModelMax = 0x7fffffff, +}; + +enum ExecutionMode { + ExecutionModeInvocations = 0, + ExecutionModeSpacingEqual = 1, + ExecutionModeSpacingFractionalEven = 2, + ExecutionModeSpacingFractionalOdd = 3, + ExecutionModeVertexOrderCw = 4, + ExecutionModeVertexOrderCcw = 5, + ExecutionModePixelCenterInteger = 6, + ExecutionModeOriginUpperLeft = 7, + ExecutionModeOriginLowerLeft = 8, + ExecutionModeEarlyFragmentTests = 9, + ExecutionModePointMode = 10, + ExecutionModeXfb = 11, + ExecutionModeDepthReplacing = 12, + ExecutionModeDepthGreater = 14, + ExecutionModeDepthLess = 15, + ExecutionModeDepthUnchanged = 16, + ExecutionModeLocalSize = 17, + ExecutionModeLocalSizeHint = 18, + ExecutionModeInputPoints = 19, + ExecutionModeInputLines = 20, + ExecutionModeInputLinesAdjacency = 21, + ExecutionModeTriangles = 22, + ExecutionModeInputTrianglesAdjacency = 23, + ExecutionModeQuads = 24, + ExecutionModeIsolines = 25, + ExecutionModeOutputVertices = 26, + ExecutionModeOutputPoints = 27, + ExecutionModeOutputLineStrip = 28, + ExecutionModeOutputTriangleStrip = 29, + ExecutionModeVecTypeHint = 30, + ExecutionModeContractionOff = 31, + ExecutionModeInitializer = 33, + ExecutionModeFinalizer = 34, + ExecutionModeSubgroupSize = 35, + ExecutionModeSubgroupsPerWorkgroup = 36, + ExecutionModeSubgroupsPerWorkgroupId = 37, + ExecutionModeLocalSizeId = 38, + ExecutionModeLocalSizeHintId = 39, + ExecutionModePostDepthCoverage = 4446, + ExecutionModeDenormPreserve = 4459, + ExecutionModeDenormFlushToZero = 4460, + ExecutionModeSignedZeroInfNanPreserve = 4461, + ExecutionModeRoundingModeRTE = 4462, + ExecutionModeRoundingModeRTZ = 4463, + ExecutionModeStencilRefReplacingEXT = 5027, + ExecutionModeOutputLinesNV = 5269, + ExecutionModeOutputPrimitivesNV = 5270, + ExecutionModeDerivativeGroupQuadsNV = 5289, + ExecutionModeDerivativeGroupLinearNV = 5290, + ExecutionModeOutputTrianglesNV = 5298, + ExecutionModePixelInterlockOrderedEXT = 5366, + ExecutionModePixelInterlockUnorderedEXT = 5367, + ExecutionModeSampleInterlockOrderedEXT = 5368, + ExecutionModeSampleInterlockUnorderedEXT = 5369, + ExecutionModeShadingRateInterlockOrderedEXT = 5370, + ExecutionModeShadingRateInterlockUnorderedEXT = 5371, + ExecutionModeMax = 0x7fffffff, +}; + +enum StorageClass { + StorageClassUniformConstant = 0, + StorageClassInput = 1, + StorageClassUniform = 2, + StorageClassOutput = 3, + StorageClassWorkgroup = 4, + StorageClassCrossWorkgroup = 5, + StorageClassPrivate = 6, + StorageClassFunction = 7, + StorageClassGeneric = 8, + StorageClassPushConstant = 9, + StorageClassAtomicCounter = 10, + StorageClassImage = 11, + StorageClassStorageBuffer = 12, + StorageClassCallableDataKHR = 5328, + StorageClassCallableDataNV = 5328, + StorageClassIncomingCallableDataKHR = 5329, + StorageClassIncomingCallableDataNV = 5329, + StorageClassRayPayloadKHR = 5338, + StorageClassRayPayloadNV = 5338, + StorageClassHitAttributeKHR = 5339, + StorageClassHitAttributeNV = 5339, + StorageClassIncomingRayPayloadKHR = 5342, + StorageClassIncomingRayPayloadNV = 5342, + StorageClassShaderRecordBufferKHR = 5343, + StorageClassShaderRecordBufferNV = 5343, + StorageClassPhysicalStorageBuffer = 5349, + StorageClassPhysicalStorageBufferEXT = 5349, + StorageClassMax = 0x7fffffff, +}; + +enum Dim { + Dim1D = 0, + Dim2D = 1, + Dim3D = 2, + DimCube = 3, + DimRect = 4, + DimBuffer = 5, + DimSubpassData = 6, + DimMax = 0x7fffffff, +}; + +enum SamplerAddressingMode { + SamplerAddressingModeNone = 0, + SamplerAddressingModeClampToEdge = 1, + SamplerAddressingModeClamp = 2, + SamplerAddressingModeRepeat = 3, + SamplerAddressingModeRepeatMirrored = 4, + SamplerAddressingModeMax = 0x7fffffff, +}; + +enum SamplerFilterMode { + SamplerFilterModeNearest = 0, + SamplerFilterModeLinear = 1, + SamplerFilterModeMax = 0x7fffffff, +}; + +enum ImageFormat { + ImageFormatUnknown = 0, + ImageFormatRgba32f = 1, + ImageFormatRgba16f = 2, + ImageFormatR32f = 3, + ImageFormatRgba8 = 4, + ImageFormatRgba8Snorm = 5, + ImageFormatRg32f = 6, + ImageFormatRg16f = 7, + ImageFormatR11fG11fB10f = 8, + ImageFormatR16f = 9, + ImageFormatRgba16 = 10, + ImageFormatRgb10A2 = 11, + ImageFormatRg16 = 12, + ImageFormatRg8 = 13, + ImageFormatR16 = 14, + ImageFormatR8 = 15, + ImageFormatRgba16Snorm = 16, + ImageFormatRg16Snorm = 17, + ImageFormatRg8Snorm = 18, + ImageFormatR16Snorm = 19, + ImageFormatR8Snorm = 20, + ImageFormatRgba32i = 21, + ImageFormatRgba16i = 22, + ImageFormatRgba8i = 23, + ImageFormatR32i = 24, + ImageFormatRg32i = 25, + ImageFormatRg16i = 26, + ImageFormatRg8i = 27, + ImageFormatR16i = 28, + ImageFormatR8i = 29, + ImageFormatRgba32ui = 30, + ImageFormatRgba16ui = 31, + ImageFormatRgba8ui = 32, + ImageFormatR32ui = 33, + ImageFormatRgb10a2ui = 34, + ImageFormatRg32ui = 35, + ImageFormatRg16ui = 36, + ImageFormatRg8ui = 37, + ImageFormatR16ui = 38, + ImageFormatR8ui = 39, + ImageFormatMax = 0x7fffffff, +}; + +enum ImageChannelOrder { + ImageChannelOrderR = 0, + ImageChannelOrderA = 1, + ImageChannelOrderRG = 2, + ImageChannelOrderRA = 3, + ImageChannelOrderRGB = 4, + ImageChannelOrderRGBA = 5, + ImageChannelOrderBGRA = 6, + ImageChannelOrderARGB = 7, + ImageChannelOrderIntensity = 8, + ImageChannelOrderLuminance = 9, + ImageChannelOrderRx = 10, + ImageChannelOrderRGx = 11, + ImageChannelOrderRGBx = 12, + ImageChannelOrderDepth = 13, + ImageChannelOrderDepthStencil = 14, + ImageChannelOrdersRGB = 15, + ImageChannelOrdersRGBx = 16, + ImageChannelOrdersRGBA = 17, + ImageChannelOrdersBGRA = 18, + ImageChannelOrderABGR = 19, + ImageChannelOrderMax = 0x7fffffff, +}; + +enum ImageChannelDataType { + ImageChannelDataTypeSnormInt8 = 0, + ImageChannelDataTypeSnormInt16 = 1, + ImageChannelDataTypeUnormInt8 = 2, + ImageChannelDataTypeUnormInt16 = 3, + ImageChannelDataTypeUnormShort565 = 4, + ImageChannelDataTypeUnormShort555 = 5, + ImageChannelDataTypeUnormInt101010 = 6, + ImageChannelDataTypeSignedInt8 = 7, + ImageChannelDataTypeSignedInt16 = 8, + ImageChannelDataTypeSignedInt32 = 9, + ImageChannelDataTypeUnsignedInt8 = 10, + ImageChannelDataTypeUnsignedInt16 = 11, + ImageChannelDataTypeUnsignedInt32 = 12, + ImageChannelDataTypeHalfFloat = 13, + ImageChannelDataTypeFloat = 14, + ImageChannelDataTypeUnormInt24 = 15, + ImageChannelDataTypeUnormInt101010_2 = 16, + ImageChannelDataTypeMax = 0x7fffffff, +}; + +enum ImageOperandsShift { + ImageOperandsBiasShift = 0, + ImageOperandsLodShift = 1, + ImageOperandsGradShift = 2, + ImageOperandsConstOffsetShift = 3, + ImageOperandsOffsetShift = 4, + ImageOperandsConstOffsetsShift = 5, + ImageOperandsSampleShift = 6, + ImageOperandsMinLodShift = 7, + ImageOperandsMakeTexelAvailableShift = 8, + ImageOperandsMakeTexelAvailableKHRShift = 8, + ImageOperandsMakeTexelVisibleShift = 9, + ImageOperandsMakeTexelVisibleKHRShift = 9, + ImageOperandsNonPrivateTexelShift = 10, + ImageOperandsNonPrivateTexelKHRShift = 10, + ImageOperandsVolatileTexelShift = 11, + ImageOperandsVolatileTexelKHRShift = 11, + ImageOperandsSignExtendShift = 12, + ImageOperandsZeroExtendShift = 13, + ImageOperandsMax = 0x7fffffff, +}; + +enum ImageOperandsMask { + ImageOperandsMaskNone = 0, + ImageOperandsBiasMask = 0x00000001, + ImageOperandsLodMask = 0x00000002, + ImageOperandsGradMask = 0x00000004, + ImageOperandsConstOffsetMask = 0x00000008, + ImageOperandsOffsetMask = 0x00000010, + ImageOperandsConstOffsetsMask = 0x00000020, + ImageOperandsSampleMask = 0x00000040, + ImageOperandsMinLodMask = 0x00000080, + ImageOperandsMakeTexelAvailableMask = 0x00000100, + ImageOperandsMakeTexelAvailableKHRMask = 0x00000100, + ImageOperandsMakeTexelVisibleMask = 0x00000200, + ImageOperandsMakeTexelVisibleKHRMask = 0x00000200, + ImageOperandsNonPrivateTexelMask = 0x00000400, + ImageOperandsNonPrivateTexelKHRMask = 0x00000400, + ImageOperandsVolatileTexelMask = 0x00000800, + ImageOperandsVolatileTexelKHRMask = 0x00000800, + ImageOperandsSignExtendMask = 0x00001000, + ImageOperandsZeroExtendMask = 0x00002000, +}; + +enum FPFastMathModeShift { + FPFastMathModeNotNaNShift = 0, + FPFastMathModeNotInfShift = 1, + FPFastMathModeNSZShift = 2, + FPFastMathModeAllowRecipShift = 3, + FPFastMathModeFastShift = 4, + FPFastMathModeMax = 0x7fffffff, +}; + +enum FPFastMathModeMask { + FPFastMathModeMaskNone = 0, + FPFastMathModeNotNaNMask = 0x00000001, + FPFastMathModeNotInfMask = 0x00000002, + FPFastMathModeNSZMask = 0x00000004, + FPFastMathModeAllowRecipMask = 0x00000008, + FPFastMathModeFastMask = 0x00000010, +}; + +enum FPRoundingMode { + FPRoundingModeRTE = 0, + FPRoundingModeRTZ = 1, + FPRoundingModeRTP = 2, + FPRoundingModeRTN = 3, + FPRoundingModeMax = 0x7fffffff, +}; + +enum LinkageType { + LinkageTypeExport = 0, + LinkageTypeImport = 1, + LinkageTypeMax = 0x7fffffff, +}; + +enum AccessQualifier { + AccessQualifierReadOnly = 0, + AccessQualifierWriteOnly = 1, + AccessQualifierReadWrite = 2, + AccessQualifierMax = 0x7fffffff, +}; + +enum FunctionParameterAttribute { + FunctionParameterAttributeZext = 0, + FunctionParameterAttributeSext = 1, + FunctionParameterAttributeByVal = 2, + FunctionParameterAttributeSret = 3, + FunctionParameterAttributeNoAlias = 4, + FunctionParameterAttributeNoCapture = 5, + FunctionParameterAttributeNoWrite = 6, + FunctionParameterAttributeNoReadWrite = 7, + FunctionParameterAttributeMax = 0x7fffffff, +}; + +enum Decoration { + DecorationRelaxedPrecision = 0, + DecorationSpecId = 1, + DecorationBlock = 2, + DecorationBufferBlock = 3, + DecorationRowMajor = 4, + DecorationColMajor = 5, + DecorationArrayStride = 6, + DecorationMatrixStride = 7, + DecorationGLSLShared = 8, + DecorationGLSLPacked = 9, + DecorationCPacked = 10, + DecorationBuiltIn = 11, + DecorationNoPerspective = 13, + DecorationFlat = 14, + DecorationPatch = 15, + DecorationCentroid = 16, + DecorationSample = 17, + DecorationInvariant = 18, + DecorationRestrict = 19, + DecorationAliased = 20, + DecorationVolatile = 21, + DecorationConstant = 22, + DecorationCoherent = 23, + DecorationNonWritable = 24, + DecorationNonReadable = 25, + DecorationUniform = 26, + DecorationUniformId = 27, + DecorationSaturatedConversion = 28, + DecorationStream = 29, + DecorationLocation = 30, + DecorationComponent = 31, + DecorationIndex = 32, + DecorationBinding = 33, + DecorationDescriptorSet = 34, + DecorationOffset = 35, + DecorationXfbBuffer = 36, + DecorationXfbStride = 37, + DecorationFuncParamAttr = 38, + DecorationFPRoundingMode = 39, + DecorationFPFastMathMode = 40, + DecorationLinkageAttributes = 41, + DecorationNoContraction = 42, + DecorationInputAttachmentIndex = 43, + DecorationAlignment = 44, + DecorationMaxByteOffset = 45, + DecorationAlignmentId = 46, + DecorationMaxByteOffsetId = 47, + DecorationNoSignedWrap = 4469, + DecorationNoUnsignedWrap = 4470, + DecorationExplicitInterpAMD = 4999, + DecorationOverrideCoverageNV = 5248, + DecorationPassthroughNV = 5250, + DecorationViewportRelativeNV = 5252, + DecorationSecondaryViewportRelativeNV = 5256, + DecorationPerPrimitiveNV = 5271, + DecorationPerViewNV = 5272, + DecorationPerTaskNV = 5273, + DecorationPerVertexNV = 5285, + DecorationNonUniform = 5300, + DecorationNonUniformEXT = 5300, + DecorationRestrictPointer = 5355, + DecorationRestrictPointerEXT = 5355, + DecorationAliasedPointer = 5356, + DecorationAliasedPointerEXT = 5356, + DecorationCounterBuffer = 5634, + DecorationHlslCounterBufferGOOGLE = 5634, + DecorationHlslSemanticGOOGLE = 5635, + DecorationUserSemantic = 5635, + DecorationUserTypeGOOGLE = 5636, + DecorationMax = 0x7fffffff, +}; + +enum BuiltIn { + BuiltInPosition = 0, + BuiltInPointSize = 1, + BuiltInClipDistance = 3, + BuiltInCullDistance = 4, + BuiltInVertexId = 5, + BuiltInInstanceId = 6, + BuiltInPrimitiveId = 7, + BuiltInInvocationId = 8, + BuiltInLayer = 9, + BuiltInViewportIndex = 10, + BuiltInTessLevelOuter = 11, + BuiltInTessLevelInner = 12, + BuiltInTessCoord = 13, + BuiltInPatchVertices = 14, + BuiltInFragCoord = 15, + BuiltInPointCoord = 16, + BuiltInFrontFacing = 17, + BuiltInSampleId = 18, + BuiltInSamplePosition = 19, + BuiltInSampleMask = 20, + BuiltInFragDepth = 22, + BuiltInHelperInvocation = 23, + BuiltInNumWorkgroups = 24, + BuiltInWorkgroupSize = 25, + BuiltInWorkgroupId = 26, + BuiltInLocalInvocationId = 27, + BuiltInGlobalInvocationId = 28, + BuiltInLocalInvocationIndex = 29, + BuiltInWorkDim = 30, + BuiltInGlobalSize = 31, + BuiltInEnqueuedWorkgroupSize = 32, + BuiltInGlobalOffset = 33, + BuiltInGlobalLinearId = 34, + BuiltInSubgroupSize = 36, + BuiltInSubgroupMaxSize = 37, + BuiltInNumSubgroups = 38, + BuiltInNumEnqueuedSubgroups = 39, + BuiltInSubgroupId = 40, + BuiltInSubgroupLocalInvocationId = 41, + BuiltInVertexIndex = 42, + BuiltInInstanceIndex = 43, + BuiltInSubgroupEqMask = 4416, + BuiltInSubgroupEqMaskKHR = 4416, + BuiltInSubgroupGeMask = 4417, + BuiltInSubgroupGeMaskKHR = 4417, + BuiltInSubgroupGtMask = 4418, + BuiltInSubgroupGtMaskKHR = 4418, + BuiltInSubgroupLeMask = 4419, + BuiltInSubgroupLeMaskKHR = 4419, + BuiltInSubgroupLtMask = 4420, + BuiltInSubgroupLtMaskKHR = 4420, + BuiltInBaseVertex = 4424, + BuiltInBaseInstance = 4425, + BuiltInDrawIndex = 4426, + BuiltInDeviceIndex = 4438, + BuiltInViewIndex = 4440, + BuiltInBaryCoordNoPerspAMD = 4992, + BuiltInBaryCoordNoPerspCentroidAMD = 4993, + BuiltInBaryCoordNoPerspSampleAMD = 4994, + BuiltInBaryCoordSmoothAMD = 4995, + BuiltInBaryCoordSmoothCentroidAMD = 4996, + BuiltInBaryCoordSmoothSampleAMD = 4997, + BuiltInBaryCoordPullModelAMD = 4998, + BuiltInFragStencilRefEXT = 5014, + BuiltInViewportMaskNV = 5253, + BuiltInSecondaryPositionNV = 5257, + BuiltInSecondaryViewportMaskNV = 5258, + BuiltInPositionPerViewNV = 5261, + BuiltInViewportMaskPerViewNV = 5262, + BuiltInFullyCoveredEXT = 5264, + BuiltInTaskCountNV = 5274, + BuiltInPrimitiveCountNV = 5275, + BuiltInPrimitiveIndicesNV = 5276, + BuiltInClipDistancePerViewNV = 5277, + BuiltInCullDistancePerViewNV = 5278, + BuiltInLayerPerViewNV = 5279, + BuiltInMeshViewCountNV = 5280, + BuiltInMeshViewIndicesNV = 5281, + BuiltInBaryCoordNV = 5286, + BuiltInBaryCoordNoPerspNV = 5287, + BuiltInFragSizeEXT = 5292, + BuiltInFragmentSizeNV = 5292, + BuiltInFragInvocationCountEXT = 5293, + BuiltInInvocationsPerPixelNV = 5293, + BuiltInLaunchIdKHR = 5319, + BuiltInLaunchIdNV = 5319, + BuiltInLaunchSizeKHR = 5320, + BuiltInLaunchSizeNV = 5320, + BuiltInWorldRayOriginKHR = 5321, + BuiltInWorldRayOriginNV = 5321, + BuiltInWorldRayDirectionKHR = 5322, + BuiltInWorldRayDirectionNV = 5322, + BuiltInObjectRayOriginKHR = 5323, + BuiltInObjectRayOriginNV = 5323, + BuiltInObjectRayDirectionKHR = 5324, + BuiltInObjectRayDirectionNV = 5324, + BuiltInRayTminKHR = 5325, + BuiltInRayTminNV = 5325, + BuiltInRayTmaxKHR = 5326, + BuiltInRayTmaxNV = 5326, + BuiltInInstanceCustomIndexKHR = 5327, + BuiltInInstanceCustomIndexNV = 5327, + BuiltInObjectToWorldKHR = 5330, + BuiltInObjectToWorldNV = 5330, + BuiltInWorldToObjectKHR = 5331, + BuiltInWorldToObjectNV = 5331, + BuiltInHitTKHR = 5332, + BuiltInHitTNV = 5332, + BuiltInHitKindKHR = 5333, + BuiltInHitKindNV = 5333, + BuiltInIncomingRayFlagsKHR = 5351, + BuiltInIncomingRayFlagsNV = 5351, + BuiltInRayGeometryIndexKHR = 5352, + BuiltInWarpsPerSMNV = 5374, + BuiltInSMCountNV = 5375, + BuiltInWarpIDNV = 5376, + BuiltInSMIDNV = 5377, + BuiltInMax = 0x7fffffff, +}; + +enum SelectionControlShift { + SelectionControlFlattenShift = 0, + SelectionControlDontFlattenShift = 1, + SelectionControlMax = 0x7fffffff, +}; + +enum SelectionControlMask { + SelectionControlMaskNone = 0, + SelectionControlFlattenMask = 0x00000001, + SelectionControlDontFlattenMask = 0x00000002, +}; + +enum LoopControlShift { + LoopControlUnrollShift = 0, + LoopControlDontUnrollShift = 1, + LoopControlDependencyInfiniteShift = 2, + LoopControlDependencyLengthShift = 3, + LoopControlMinIterationsShift = 4, + LoopControlMaxIterationsShift = 5, + LoopControlIterationMultipleShift = 6, + LoopControlPeelCountShift = 7, + LoopControlPartialCountShift = 8, + LoopControlMax = 0x7fffffff, +}; + +enum LoopControlMask { + LoopControlMaskNone = 0, + LoopControlUnrollMask = 0x00000001, + LoopControlDontUnrollMask = 0x00000002, + LoopControlDependencyInfiniteMask = 0x00000004, + LoopControlDependencyLengthMask = 0x00000008, + LoopControlMinIterationsMask = 0x00000010, + LoopControlMaxIterationsMask = 0x00000020, + LoopControlIterationMultipleMask = 0x00000040, + LoopControlPeelCountMask = 0x00000080, + LoopControlPartialCountMask = 0x00000100, +}; + +enum FunctionControlShift { + FunctionControlInlineShift = 0, + FunctionControlDontInlineShift = 1, + FunctionControlPureShift = 2, + FunctionControlConstShift = 3, + FunctionControlMax = 0x7fffffff, +}; + +enum FunctionControlMask { + FunctionControlMaskNone = 0, + FunctionControlInlineMask = 0x00000001, + FunctionControlDontInlineMask = 0x00000002, + FunctionControlPureMask = 0x00000004, + FunctionControlConstMask = 0x00000008, +}; + +enum MemorySemanticsShift { + MemorySemanticsAcquireShift = 1, + MemorySemanticsReleaseShift = 2, + MemorySemanticsAcquireReleaseShift = 3, + MemorySemanticsSequentiallyConsistentShift = 4, + MemorySemanticsUniformMemoryShift = 6, + MemorySemanticsSubgroupMemoryShift = 7, + MemorySemanticsWorkgroupMemoryShift = 8, + MemorySemanticsCrossWorkgroupMemoryShift = 9, + MemorySemanticsAtomicCounterMemoryShift = 10, + MemorySemanticsImageMemoryShift = 11, + MemorySemanticsOutputMemoryShift = 12, + MemorySemanticsOutputMemoryKHRShift = 12, + MemorySemanticsMakeAvailableShift = 13, + MemorySemanticsMakeAvailableKHRShift = 13, + MemorySemanticsMakeVisibleShift = 14, + MemorySemanticsMakeVisibleKHRShift = 14, + MemorySemanticsVolatileShift = 15, + MemorySemanticsMax = 0x7fffffff, +}; + +enum MemorySemanticsMask { + MemorySemanticsMaskNone = 0, + MemorySemanticsAcquireMask = 0x00000002, + MemorySemanticsReleaseMask = 0x00000004, + MemorySemanticsAcquireReleaseMask = 0x00000008, + MemorySemanticsSequentiallyConsistentMask = 0x00000010, + MemorySemanticsUniformMemoryMask = 0x00000040, + MemorySemanticsSubgroupMemoryMask = 0x00000080, + MemorySemanticsWorkgroupMemoryMask = 0x00000100, + MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, + MemorySemanticsAtomicCounterMemoryMask = 0x00000400, + MemorySemanticsImageMemoryMask = 0x00000800, + MemorySemanticsOutputMemoryMask = 0x00001000, + MemorySemanticsOutputMemoryKHRMask = 0x00001000, + MemorySemanticsMakeAvailableMask = 0x00002000, + MemorySemanticsMakeAvailableKHRMask = 0x00002000, + MemorySemanticsMakeVisibleMask = 0x00004000, + MemorySemanticsMakeVisibleKHRMask = 0x00004000, + MemorySemanticsVolatileMask = 0x00008000, +}; + +enum MemoryAccessShift { + MemoryAccessVolatileShift = 0, + MemoryAccessAlignedShift = 1, + MemoryAccessNontemporalShift = 2, + MemoryAccessMakePointerAvailableShift = 3, + MemoryAccessMakePointerAvailableKHRShift = 3, + MemoryAccessMakePointerVisibleShift = 4, + MemoryAccessMakePointerVisibleKHRShift = 4, + MemoryAccessNonPrivatePointerShift = 5, + MemoryAccessNonPrivatePointerKHRShift = 5, + MemoryAccessMax = 0x7fffffff, +}; + +enum MemoryAccessMask { + MemoryAccessMaskNone = 0, + MemoryAccessVolatileMask = 0x00000001, + MemoryAccessAlignedMask = 0x00000002, + MemoryAccessNontemporalMask = 0x00000004, + MemoryAccessMakePointerAvailableMask = 0x00000008, + MemoryAccessMakePointerAvailableKHRMask = 0x00000008, + MemoryAccessMakePointerVisibleMask = 0x00000010, + MemoryAccessMakePointerVisibleKHRMask = 0x00000010, + MemoryAccessNonPrivatePointerMask = 0x00000020, + MemoryAccessNonPrivatePointerKHRMask = 0x00000020, +}; + +enum Scope { + ScopeCrossDevice = 0, + ScopeDevice = 1, + ScopeWorkgroup = 2, + ScopeSubgroup = 3, + ScopeInvocation = 4, + ScopeQueueFamily = 5, + ScopeQueueFamilyKHR = 5, + ScopeShaderCallKHR = 6, + ScopeMax = 0x7fffffff, +}; + +enum GroupOperation { + GroupOperationReduce = 0, + GroupOperationInclusiveScan = 1, + GroupOperationExclusiveScan = 2, + GroupOperationClusteredReduce = 3, + GroupOperationPartitionedReduceNV = 6, + GroupOperationPartitionedInclusiveScanNV = 7, + GroupOperationPartitionedExclusiveScanNV = 8, + GroupOperationMax = 0x7fffffff, +}; + +enum KernelEnqueueFlags { + KernelEnqueueFlagsNoWait = 0, + KernelEnqueueFlagsWaitKernel = 1, + KernelEnqueueFlagsWaitWorkGroup = 2, + KernelEnqueueFlagsMax = 0x7fffffff, +}; + +enum KernelProfilingInfoShift { + KernelProfilingInfoCmdExecTimeShift = 0, + KernelProfilingInfoMax = 0x7fffffff, +}; + +enum KernelProfilingInfoMask { + KernelProfilingInfoMaskNone = 0, + KernelProfilingInfoCmdExecTimeMask = 0x00000001, +}; + +enum Capability { + CapabilityMatrix = 0, + CapabilityShader = 1, + CapabilityGeometry = 2, + CapabilityTessellation = 3, + CapabilityAddresses = 4, + CapabilityLinkage = 5, + CapabilityKernel = 6, + CapabilityVector16 = 7, + CapabilityFloat16Buffer = 8, + CapabilityFloat16 = 9, + CapabilityFloat64 = 10, + CapabilityInt64 = 11, + CapabilityInt64Atomics = 12, + CapabilityImageBasic = 13, + CapabilityImageReadWrite = 14, + CapabilityImageMipmap = 15, + CapabilityPipes = 17, + CapabilityGroups = 18, + CapabilityDeviceEnqueue = 19, + CapabilityLiteralSampler = 20, + CapabilityAtomicStorage = 21, + CapabilityInt16 = 22, + CapabilityTessellationPointSize = 23, + CapabilityGeometryPointSize = 24, + CapabilityImageGatherExtended = 25, + CapabilityStorageImageMultisample = 27, + CapabilityUniformBufferArrayDynamicIndexing = 28, + CapabilitySampledImageArrayDynamicIndexing = 29, + CapabilityStorageBufferArrayDynamicIndexing = 30, + CapabilityStorageImageArrayDynamicIndexing = 31, + CapabilityClipDistance = 32, + CapabilityCullDistance = 33, + CapabilityImageCubeArray = 34, + CapabilitySampleRateShading = 35, + CapabilityImageRect = 36, + CapabilitySampledRect = 37, + CapabilityGenericPointer = 38, + CapabilityInt8 = 39, + CapabilityInputAttachment = 40, + CapabilitySparseResidency = 41, + CapabilityMinLod = 42, + CapabilitySampled1D = 43, + CapabilityImage1D = 44, + CapabilitySampledCubeArray = 45, + CapabilitySampledBuffer = 46, + CapabilityImageBuffer = 47, + CapabilityImageMSArray = 48, + CapabilityStorageImageExtendedFormats = 49, + CapabilityImageQuery = 50, + CapabilityDerivativeControl = 51, + CapabilityInterpolationFunction = 52, + CapabilityTransformFeedback = 53, + CapabilityGeometryStreams = 54, + CapabilityStorageImageReadWithoutFormat = 55, + CapabilityStorageImageWriteWithoutFormat = 56, + CapabilityMultiViewport = 57, + CapabilitySubgroupDispatch = 58, + CapabilityNamedBarrier = 59, + CapabilityPipeStorage = 60, + CapabilityGroupNonUniform = 61, + CapabilityGroupNonUniformVote = 62, + CapabilityGroupNonUniformArithmetic = 63, + CapabilityGroupNonUniformBallot = 64, + CapabilityGroupNonUniformShuffle = 65, + CapabilityGroupNonUniformShuffleRelative = 66, + CapabilityGroupNonUniformClustered = 67, + CapabilityGroupNonUniformQuad = 68, + CapabilityShaderLayer = 69, + CapabilityShaderViewportIndex = 70, + CapabilitySubgroupBallotKHR = 4423, + CapabilityDrawParameters = 4427, + CapabilitySubgroupVoteKHR = 4431, + CapabilityStorageBuffer16BitAccess = 4433, + CapabilityStorageUniformBufferBlock16 = 4433, + CapabilityStorageUniform16 = 4434, + CapabilityUniformAndStorageBuffer16BitAccess = 4434, + CapabilityStoragePushConstant16 = 4435, + CapabilityStorageInputOutput16 = 4436, + CapabilityDeviceGroup = 4437, + CapabilityMultiView = 4439, + CapabilityVariablePointersStorageBuffer = 4441, + CapabilityVariablePointers = 4442, + CapabilityAtomicStorageOps = 4445, + CapabilitySampleMaskPostDepthCoverage = 4447, + CapabilityStorageBuffer8BitAccess = 4448, + CapabilityUniformAndStorageBuffer8BitAccess = 4449, + CapabilityStoragePushConstant8 = 4450, + CapabilityDenormPreserve = 4464, + CapabilityDenormFlushToZero = 4465, + CapabilitySignedZeroInfNanPreserve = 4466, + CapabilityRoundingModeRTE = 4467, + CapabilityRoundingModeRTZ = 4468, + CapabilityRayQueryProvisionalKHR = 4471, + CapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478, + CapabilityFloat16ImageAMD = 5008, + CapabilityImageGatherBiasLodAMD = 5009, + CapabilityFragmentMaskAMD = 5010, + CapabilityStencilExportEXT = 5013, + CapabilityImageReadWriteLodAMD = 5015, + CapabilityShaderClockKHR = 5055, + CapabilitySampleMaskOverrideCoverageNV = 5249, + CapabilityGeometryShaderPassthroughNV = 5251, + CapabilityShaderViewportIndexLayerEXT = 5254, + CapabilityShaderViewportIndexLayerNV = 5254, + CapabilityShaderViewportMaskNV = 5255, + CapabilityShaderStereoViewNV = 5259, + CapabilityPerViewAttributesNV = 5260, + CapabilityFragmentFullyCoveredEXT = 5265, + CapabilityMeshShadingNV = 5266, + CapabilityImageFootprintNV = 5282, + CapabilityFragmentBarycentricNV = 5284, + CapabilityComputeDerivativeGroupQuadsNV = 5288, + CapabilityFragmentDensityEXT = 5291, + CapabilityShadingRateNV = 5291, + CapabilityGroupNonUniformPartitionedNV = 5297, + CapabilityShaderNonUniform = 5301, + CapabilityShaderNonUniformEXT = 5301, + CapabilityRuntimeDescriptorArray = 5302, + CapabilityRuntimeDescriptorArrayEXT = 5302, + CapabilityInputAttachmentArrayDynamicIndexing = 5303, + CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, + CapabilityUniformTexelBufferArrayDynamicIndexing = 5304, + CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, + CapabilityStorageTexelBufferArrayDynamicIndexing = 5305, + CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, + CapabilityUniformBufferArrayNonUniformIndexing = 5306, + CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, + CapabilitySampledImageArrayNonUniformIndexing = 5307, + CapabilitySampledImageArrayNonUniformIndexingEXT = 5307, + CapabilityStorageBufferArrayNonUniformIndexing = 5308, + CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, + CapabilityStorageImageArrayNonUniformIndexing = 5309, + CapabilityStorageImageArrayNonUniformIndexingEXT = 5309, + CapabilityInputAttachmentArrayNonUniformIndexing = 5310, + CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, + CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311, + CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, + CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312, + CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, + CapabilityRayTracingNV = 5340, + CapabilityVulkanMemoryModel = 5345, + CapabilityVulkanMemoryModelKHR = 5345, + CapabilityVulkanMemoryModelDeviceScope = 5346, + CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, + CapabilityPhysicalStorageBufferAddresses = 5347, + CapabilityPhysicalStorageBufferAddressesEXT = 5347, + CapabilityComputeDerivativeGroupLinearNV = 5350, + CapabilityRayTracingProvisionalKHR = 5353, + CapabilityCooperativeMatrixNV = 5357, + CapabilityFragmentShaderSampleInterlockEXT = 5363, + CapabilityFragmentShaderShadingRateInterlockEXT = 5372, + CapabilityShaderSMBuiltinsNV = 5373, + CapabilityFragmentShaderPixelInterlockEXT = 5378, + CapabilityDemoteToHelperInvocationEXT = 5379, + CapabilitySubgroupShuffleINTEL = 5568, + CapabilitySubgroupBufferBlockIOINTEL = 5569, + CapabilitySubgroupImageBlockIOINTEL = 5570, + CapabilitySubgroupImageMediaBlockIOINTEL = 5579, + CapabilityIntegerFunctions2INTEL = 5584, + CapabilitySubgroupAvcMotionEstimationINTEL = 5696, + CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, + CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, + CapabilityMax = 0x7fffffff, +}; + +enum RayFlagsShift { + RayFlagsOpaqueKHRShift = 0, + RayFlagsNoOpaqueKHRShift = 1, + RayFlagsTerminateOnFirstHitKHRShift = 2, + RayFlagsSkipClosestHitShaderKHRShift = 3, + RayFlagsCullBackFacingTrianglesKHRShift = 4, + RayFlagsCullFrontFacingTrianglesKHRShift = 5, + RayFlagsCullOpaqueKHRShift = 6, + RayFlagsCullNoOpaqueKHRShift = 7, + RayFlagsSkipTrianglesKHRShift = 8, + RayFlagsSkipAABBsKHRShift = 9, + RayFlagsMax = 0x7fffffff, +}; + +enum RayFlagsMask { + RayFlagsMaskNone = 0, + RayFlagsOpaqueKHRMask = 0x00000001, + RayFlagsNoOpaqueKHRMask = 0x00000002, + RayFlagsTerminateOnFirstHitKHRMask = 0x00000004, + RayFlagsSkipClosestHitShaderKHRMask = 0x00000008, + RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010, + RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020, + RayFlagsCullOpaqueKHRMask = 0x00000040, + RayFlagsCullNoOpaqueKHRMask = 0x00000080, + RayFlagsSkipTrianglesKHRMask = 0x00000100, + RayFlagsSkipAABBsKHRMask = 0x00000200, +}; + +enum RayQueryIntersection { + RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0, + RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1, + RayQueryIntersectionMax = 0x7fffffff, +}; + +enum RayQueryCommittedIntersectionType { + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0, + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1, + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2, + RayQueryCommittedIntersectionTypeMax = 0x7fffffff, +}; + +enum RayQueryCandidateIntersectionType { + RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0, + RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1, + RayQueryCandidateIntersectionTypeMax = 0x7fffffff, +}; + +enum Op { + OpNop = 0, + OpUndef = 1, + OpSourceContinued = 2, + OpSource = 3, + OpSourceExtension = 4, + OpName = 5, + OpMemberName = 6, + OpString = 7, + OpLine = 8, + OpExtension = 10, + OpExtInstImport = 11, + OpExtInst = 12, + OpMemoryModel = 14, + OpEntryPoint = 15, + OpExecutionMode = 16, + OpCapability = 17, + OpTypeVoid = 19, + OpTypeBool = 20, + OpTypeInt = 21, + OpTypeFloat = 22, + OpTypeVector = 23, + OpTypeMatrix = 24, + OpTypeImage = 25, + OpTypeSampler = 26, + OpTypeSampledImage = 27, + OpTypeArray = 28, + OpTypeRuntimeArray = 29, + OpTypeStruct = 30, + OpTypeOpaque = 31, + OpTypePointer = 32, + OpTypeFunction = 33, + OpTypeEvent = 34, + OpTypeDeviceEvent = 35, + OpTypeReserveId = 36, + OpTypeQueue = 37, + OpTypePipe = 38, + OpTypeForwardPointer = 39, + OpConstantTrue = 41, + OpConstantFalse = 42, + OpConstant = 43, + OpConstantComposite = 44, + OpConstantSampler = 45, + OpConstantNull = 46, + OpSpecConstantTrue = 48, + OpSpecConstantFalse = 49, + OpSpecConstant = 50, + OpSpecConstantComposite = 51, + OpSpecConstantOp = 52, + OpFunction = 54, + OpFunctionParameter = 55, + OpFunctionEnd = 56, + OpFunctionCall = 57, + OpVariable = 59, + OpImageTexelPointer = 60, + OpLoad = 61, + OpStore = 62, + OpCopyMemory = 63, + OpCopyMemorySized = 64, + OpAccessChain = 65, + OpInBoundsAccessChain = 66, + OpPtrAccessChain = 67, + OpArrayLength = 68, + OpGenericPtrMemSemantics = 69, + OpInBoundsPtrAccessChain = 70, + OpDecorate = 71, + OpMemberDecorate = 72, + OpDecorationGroup = 73, + OpGroupDecorate = 74, + OpGroupMemberDecorate = 75, + OpVectorExtractDynamic = 77, + OpVectorInsertDynamic = 78, + OpVectorShuffle = 79, + OpCompositeConstruct = 80, + OpCompositeExtract = 81, + OpCompositeInsert = 82, + OpCopyObject = 83, + OpTranspose = 84, + OpSampledImage = 86, + OpImageSampleImplicitLod = 87, + OpImageSampleExplicitLod = 88, + OpImageSampleDrefImplicitLod = 89, + OpImageSampleDrefExplicitLod = 90, + OpImageSampleProjImplicitLod = 91, + OpImageSampleProjExplicitLod = 92, + OpImageSampleProjDrefImplicitLod = 93, + OpImageSampleProjDrefExplicitLod = 94, + OpImageFetch = 95, + OpImageGather = 96, + OpImageDrefGather = 97, + OpImageRead = 98, + OpImageWrite = 99, + OpImage = 100, + OpImageQueryFormat = 101, + OpImageQueryOrder = 102, + OpImageQuerySizeLod = 103, + OpImageQuerySize = 104, + OpImageQueryLod = 105, + OpImageQueryLevels = 106, + OpImageQuerySamples = 107, + OpConvertFToU = 109, + OpConvertFToS = 110, + OpConvertSToF = 111, + OpConvertUToF = 112, + OpUConvert = 113, + OpSConvert = 114, + OpFConvert = 115, + OpQuantizeToF16 = 116, + OpConvertPtrToU = 117, + OpSatConvertSToU = 118, + OpSatConvertUToS = 119, + OpConvertUToPtr = 120, + OpPtrCastToGeneric = 121, + OpGenericCastToPtr = 122, + OpGenericCastToPtrExplicit = 123, + OpBitcast = 124, + OpSNegate = 126, + OpFNegate = 127, + OpIAdd = 128, + OpFAdd = 129, + OpISub = 130, + OpFSub = 131, + OpIMul = 132, + OpFMul = 133, + OpUDiv = 134, + OpSDiv = 135, + OpFDiv = 136, + OpUMod = 137, + OpSRem = 138, + OpSMod = 139, + OpFRem = 140, + OpFMod = 141, + OpVectorTimesScalar = 142, + OpMatrixTimesScalar = 143, + OpVectorTimesMatrix = 144, + OpMatrixTimesVector = 145, + OpMatrixTimesMatrix = 146, + OpOuterProduct = 147, + OpDot = 148, + OpIAddCarry = 149, + OpISubBorrow = 150, + OpUMulExtended = 151, + OpSMulExtended = 152, + OpAny = 154, + OpAll = 155, + OpIsNan = 156, + OpIsInf = 157, + OpIsFinite = 158, + OpIsNormal = 159, + OpSignBitSet = 160, + OpLessOrGreater = 161, + OpOrdered = 162, + OpUnordered = 163, + OpLogicalEqual = 164, + OpLogicalNotEqual = 165, + OpLogicalOr = 166, + OpLogicalAnd = 167, + OpLogicalNot = 168, + OpSelect = 169, + OpIEqual = 170, + OpINotEqual = 171, + OpUGreaterThan = 172, + OpSGreaterThan = 173, + OpUGreaterThanEqual = 174, + OpSGreaterThanEqual = 175, + OpULessThan = 176, + OpSLessThan = 177, + OpULessThanEqual = 178, + OpSLessThanEqual = 179, + OpFOrdEqual = 180, + OpFUnordEqual = 181, + OpFOrdNotEqual = 182, + OpFUnordNotEqual = 183, + OpFOrdLessThan = 184, + OpFUnordLessThan = 185, + OpFOrdGreaterThan = 186, + OpFUnordGreaterThan = 187, + OpFOrdLessThanEqual = 188, + OpFUnordLessThanEqual = 189, + OpFOrdGreaterThanEqual = 190, + OpFUnordGreaterThanEqual = 191, + OpShiftRightLogical = 194, + OpShiftRightArithmetic = 195, + OpShiftLeftLogical = 196, + OpBitwiseOr = 197, + OpBitwiseXor = 198, + OpBitwiseAnd = 199, + OpNot = 200, + OpBitFieldInsert = 201, + OpBitFieldSExtract = 202, + OpBitFieldUExtract = 203, + OpBitReverse = 204, + OpBitCount = 205, + OpDPdx = 207, + OpDPdy = 208, + OpFwidth = 209, + OpDPdxFine = 210, + OpDPdyFine = 211, + OpFwidthFine = 212, + OpDPdxCoarse = 213, + OpDPdyCoarse = 214, + OpFwidthCoarse = 215, + OpEmitVertex = 218, + OpEndPrimitive = 219, + OpEmitStreamVertex = 220, + OpEndStreamPrimitive = 221, + OpControlBarrier = 224, + OpMemoryBarrier = 225, + OpAtomicLoad = 227, + OpAtomicStore = 228, + OpAtomicExchange = 229, + OpAtomicCompareExchange = 230, + OpAtomicCompareExchangeWeak = 231, + OpAtomicIIncrement = 232, + OpAtomicIDecrement = 233, + OpAtomicIAdd = 234, + OpAtomicISub = 235, + OpAtomicSMin = 236, + OpAtomicUMin = 237, + OpAtomicSMax = 238, + OpAtomicUMax = 239, + OpAtomicAnd = 240, + OpAtomicOr = 241, + OpAtomicXor = 242, + OpPhi = 245, + OpLoopMerge = 246, + OpSelectionMerge = 247, + OpLabel = 248, + OpBranch = 249, + OpBranchConditional = 250, + OpSwitch = 251, + OpKill = 252, + OpReturn = 253, + OpReturnValue = 254, + OpUnreachable = 255, + OpLifetimeStart = 256, + OpLifetimeStop = 257, + OpGroupAsyncCopy = 259, + OpGroupWaitEvents = 260, + OpGroupAll = 261, + OpGroupAny = 262, + OpGroupBroadcast = 263, + OpGroupIAdd = 264, + OpGroupFAdd = 265, + OpGroupFMin = 266, + OpGroupUMin = 267, + OpGroupSMin = 268, + OpGroupFMax = 269, + OpGroupUMax = 270, + OpGroupSMax = 271, + OpReadPipe = 274, + OpWritePipe = 275, + OpReservedReadPipe = 276, + OpReservedWritePipe = 277, + OpReserveReadPipePackets = 278, + OpReserveWritePipePackets = 279, + OpCommitReadPipe = 280, + OpCommitWritePipe = 281, + OpIsValidReserveId = 282, + OpGetNumPipePackets = 283, + OpGetMaxPipePackets = 284, + OpGroupReserveReadPipePackets = 285, + OpGroupReserveWritePipePackets = 286, + OpGroupCommitReadPipe = 287, + OpGroupCommitWritePipe = 288, + OpEnqueueMarker = 291, + OpEnqueueKernel = 292, + OpGetKernelNDrangeSubGroupCount = 293, + OpGetKernelNDrangeMaxSubGroupSize = 294, + OpGetKernelWorkGroupSize = 295, + OpGetKernelPreferredWorkGroupSizeMultiple = 296, + OpRetainEvent = 297, + OpReleaseEvent = 298, + OpCreateUserEvent = 299, + OpIsValidEvent = 300, + OpSetUserEventStatus = 301, + OpCaptureEventProfilingInfo = 302, + OpGetDefaultQueue = 303, + OpBuildNDRange = 304, + OpImageSparseSampleImplicitLod = 305, + OpImageSparseSampleExplicitLod = 306, + OpImageSparseSampleDrefImplicitLod = 307, + OpImageSparseSampleDrefExplicitLod = 308, + OpImageSparseSampleProjImplicitLod = 309, + OpImageSparseSampleProjExplicitLod = 310, + OpImageSparseSampleProjDrefImplicitLod = 311, + OpImageSparseSampleProjDrefExplicitLod = 312, + OpImageSparseFetch = 313, + OpImageSparseGather = 314, + OpImageSparseDrefGather = 315, + OpImageSparseTexelsResident = 316, + OpNoLine = 317, + OpAtomicFlagTestAndSet = 318, + OpAtomicFlagClear = 319, + OpImageSparseRead = 320, + OpSizeOf = 321, + OpTypePipeStorage = 322, + OpConstantPipeStorage = 323, + OpCreatePipeFromPipeStorage = 324, + OpGetKernelLocalSizeForSubgroupCount = 325, + OpGetKernelMaxNumSubgroups = 326, + OpTypeNamedBarrier = 327, + OpNamedBarrierInitialize = 328, + OpMemoryNamedBarrier = 329, + OpModuleProcessed = 330, + OpExecutionModeId = 331, + OpDecorateId = 332, + OpGroupNonUniformElect = 333, + OpGroupNonUniformAll = 334, + OpGroupNonUniformAny = 335, + OpGroupNonUniformAllEqual = 336, + OpGroupNonUniformBroadcast = 337, + OpGroupNonUniformBroadcastFirst = 338, + OpGroupNonUniformBallot = 339, + OpGroupNonUniformInverseBallot = 340, + OpGroupNonUniformBallotBitExtract = 341, + OpGroupNonUniformBallotBitCount = 342, + OpGroupNonUniformBallotFindLSB = 343, + OpGroupNonUniformBallotFindMSB = 344, + OpGroupNonUniformShuffle = 345, + OpGroupNonUniformShuffleXor = 346, + OpGroupNonUniformShuffleUp = 347, + OpGroupNonUniformShuffleDown = 348, + OpGroupNonUniformIAdd = 349, + OpGroupNonUniformFAdd = 350, + OpGroupNonUniformIMul = 351, + OpGroupNonUniformFMul = 352, + OpGroupNonUniformSMin = 353, + OpGroupNonUniformUMin = 354, + OpGroupNonUniformFMin = 355, + OpGroupNonUniformSMax = 356, + OpGroupNonUniformUMax = 357, + OpGroupNonUniformFMax = 358, + OpGroupNonUniformBitwiseAnd = 359, + OpGroupNonUniformBitwiseOr = 360, + OpGroupNonUniformBitwiseXor = 361, + OpGroupNonUniformLogicalAnd = 362, + OpGroupNonUniformLogicalOr = 363, + OpGroupNonUniformLogicalXor = 364, + OpGroupNonUniformQuadBroadcast = 365, + OpGroupNonUniformQuadSwap = 366, + OpCopyLogical = 400, + OpPtrEqual = 401, + OpPtrNotEqual = 402, + OpPtrDiff = 403, + OpSubgroupBallotKHR = 4421, + OpSubgroupFirstInvocationKHR = 4422, + OpSubgroupAllKHR = 4428, + OpSubgroupAnyKHR = 4429, + OpSubgroupAllEqualKHR = 4430, + OpSubgroupReadInvocationKHR = 4432, + OpTypeRayQueryProvisionalKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, + OpRayQueryGenerateIntersectionKHR = 4475, + OpRayQueryConfirmIntersectionKHR = 4476, + OpRayQueryProceedKHR = 4477, + OpRayQueryGetIntersectionTypeKHR = 4479, + OpGroupIAddNonUniformAMD = 5000, + OpGroupFAddNonUniformAMD = 5001, + OpGroupFMinNonUniformAMD = 5002, + OpGroupUMinNonUniformAMD = 5003, + OpGroupSMinNonUniformAMD = 5004, + OpGroupFMaxNonUniformAMD = 5005, + OpGroupUMaxNonUniformAMD = 5006, + OpGroupSMaxNonUniformAMD = 5007, + OpFragmentMaskFetchAMD = 5011, + OpFragmentFetchAMD = 5012, + OpReadClockKHR = 5056, + OpImageSampleFootprintNV = 5283, + OpGroupNonUniformPartitionNV = 5296, + OpWritePackedPrimitiveIndices4x8NV = 5299, + OpReportIntersectionKHR = 5334, + OpReportIntersectionNV = 5334, + OpIgnoreIntersectionKHR = 5335, + OpIgnoreIntersectionNV = 5335, + OpTerminateRayKHR = 5336, + OpTerminateRayNV = 5336, + OpTraceNV = 5337, + OpTraceRayKHR = 5337, + OpTypeAccelerationStructureKHR = 5341, + OpTypeAccelerationStructureNV = 5341, + OpExecuteCallableKHR = 5344, + OpExecuteCallableNV = 5344, + OpTypeCooperativeMatrixNV = 5358, + OpCooperativeMatrixLoadNV = 5359, + OpCooperativeMatrixStoreNV = 5360, + OpCooperativeMatrixMulAddNV = 5361, + OpCooperativeMatrixLengthNV = 5362, + OpBeginInvocationInterlockEXT = 5364, + OpEndInvocationInterlockEXT = 5365, + OpDemoteToHelperInvocationEXT = 5380, + OpIsHelperInvocationEXT = 5381, + OpSubgroupShuffleINTEL = 5571, + OpSubgroupShuffleDownINTEL = 5572, + OpSubgroupShuffleUpINTEL = 5573, + OpSubgroupShuffleXorINTEL = 5574, + OpSubgroupBlockReadINTEL = 5575, + OpSubgroupBlockWriteINTEL = 5576, + OpSubgroupImageBlockReadINTEL = 5577, + OpSubgroupImageBlockWriteINTEL = 5578, + OpSubgroupImageMediaBlockReadINTEL = 5580, + OpSubgroupImageMediaBlockWriteINTEL = 5581, + OpUCountLeadingZerosINTEL = 5585, + OpUCountTrailingZerosINTEL = 5586, + OpAbsISubINTEL = 5587, + OpAbsUSubINTEL = 5588, + OpIAddSatINTEL = 5589, + OpUAddSatINTEL = 5590, + OpIAverageINTEL = 5591, + OpUAverageINTEL = 5592, + OpIAverageRoundedINTEL = 5593, + OpUAverageRoundedINTEL = 5594, + OpISubSatINTEL = 5595, + OpUSubSatINTEL = 5596, + OpIMul32x16INTEL = 5597, + OpUMul32x16INTEL = 5598, + OpDecorateString = 5632, + OpDecorateStringGOOGLE = 5632, + OpMemberDecorateString = 5633, + OpMemberDecorateStringGOOGLE = 5633, + OpVmeImageINTEL = 5699, + OpTypeVmeImageINTEL = 5700, + OpTypeAvcImePayloadINTEL = 5701, + OpTypeAvcRefPayloadINTEL = 5702, + OpTypeAvcSicPayloadINTEL = 5703, + OpTypeAvcMcePayloadINTEL = 5704, + OpTypeAvcMceResultINTEL = 5705, + OpTypeAvcImeResultINTEL = 5706, + OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, + OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, + OpTypeAvcImeSingleReferenceStreaminINTEL = 5709, + OpTypeAvcImeDualReferenceStreaminINTEL = 5710, + OpTypeAvcRefResultINTEL = 5711, + OpTypeAvcSicResultINTEL = 5712, + OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, + OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, + OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, + OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, + OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, + OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, + OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, + OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, + OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, + OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, + OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, + OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, + OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, + OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, + OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, + OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, + OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, + OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, + OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, + OpSubgroupAvcMceConvertToImePayloadINTEL = 5732, + OpSubgroupAvcMceConvertToImeResultINTEL = 5733, + OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, + OpSubgroupAvcMceConvertToRefResultINTEL = 5735, + OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, + OpSubgroupAvcMceConvertToSicResultINTEL = 5737, + OpSubgroupAvcMceGetMotionVectorsINTEL = 5738, + OpSubgroupAvcMceGetInterDistortionsINTEL = 5739, + OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, + OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, + OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, + OpSubgroupAvcMceGetInterDirectionsINTEL = 5743, + OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, + OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, + OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, + OpSubgroupAvcImeInitializeINTEL = 5747, + OpSubgroupAvcImeSetSingleReferenceINTEL = 5748, + OpSubgroupAvcImeSetDualReferenceINTEL = 5749, + OpSubgroupAvcImeRefWindowSizeINTEL = 5750, + OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, + OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, + OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, + OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, + OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, + OpSubgroupAvcImeSetWeightedSadINTEL = 5756, + OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, + OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, + OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, + OpSubgroupAvcImeConvertToMceResultINTEL = 5765, + OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, + OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, + OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, + OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, + OpSubgroupAvcImeGetBorderReachedINTEL = 5776, + OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, + OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, + OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, + OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, + OpSubgroupAvcFmeInitializeINTEL = 5781, + OpSubgroupAvcBmeInitializeINTEL = 5782, + OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, + OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, + OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, + OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, + OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, + OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, + OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, + OpSubgroupAvcRefConvertToMceResultINTEL = 5790, + OpSubgroupAvcSicInitializeINTEL = 5791, + OpSubgroupAvcSicConfigureSkcINTEL = 5792, + OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, + OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, + OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, + OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, + OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, + OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, + OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, + OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, + OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, + OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, + OpSubgroupAvcSicEvaluateIpeINTEL = 5803, + OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, + OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, + OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, + OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, + OpSubgroupAvcSicConvertToMceResultINTEL = 5808, + OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, + OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, + OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, + OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, + OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, + OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, + OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, + OpSubgroupAvcSicGetInterRawSadsINTEL = 5816, + OpRayQueryGetRayTMinKHR = 6016, + OpRayQueryGetRayFlagsKHR = 6017, + OpRayQueryGetIntersectionTKHR = 6018, + OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019, + OpRayQueryGetIntersectionInstanceIdKHR = 6020, + OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021, + OpRayQueryGetIntersectionGeometryIndexKHR = 6022, + OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023, + OpRayQueryGetIntersectionBarycentricsKHR = 6024, + OpRayQueryGetIntersectionFrontFaceKHR = 6025, + OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026, + OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027, + OpRayQueryGetIntersectionObjectRayOriginKHR = 6028, + OpRayQueryGetWorldRayDirectionKHR = 6029, + OpRayQueryGetWorldRayOriginKHR = 6030, + OpRayQueryGetIntersectionObjectToWorldKHR = 6031, + OpRayQueryGetIntersectionWorldToObjectKHR = 6032, + OpMax = 0x7fffffff, +}; + +#ifdef SPV_ENABLE_UTILITY_CODE +inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + *hasResult = *hasResultType = false; + switch (opcode) { + default: /* unknown opcode */ break; + case OpNop: *hasResult = false; *hasResultType = false; break; + case OpUndef: *hasResult = true; *hasResultType = true; break; + case OpSourceContinued: *hasResult = false; *hasResultType = false; break; + case OpSource: *hasResult = false; *hasResultType = false; break; + case OpSourceExtension: *hasResult = false; *hasResultType = false; break; + case OpName: *hasResult = false; *hasResultType = false; break; + case OpMemberName: *hasResult = false; *hasResultType = false; break; + case OpString: *hasResult = true; *hasResultType = false; break; + case OpLine: *hasResult = false; *hasResultType = false; break; + case OpExtension: *hasResult = false; *hasResultType = false; break; + case OpExtInstImport: *hasResult = true; *hasResultType = false; break; + case OpExtInst: *hasResult = true; *hasResultType = true; break; + case OpMemoryModel: *hasResult = false; *hasResultType = false; break; + case OpEntryPoint: *hasResult = false; *hasResultType = false; break; + case OpExecutionMode: *hasResult = false; *hasResultType = false; break; + case OpCapability: *hasResult = false; *hasResultType = false; break; + case OpTypeVoid: *hasResult = true; *hasResultType = false; break; + case OpTypeBool: *hasResult = true; *hasResultType = false; break; + case OpTypeInt: *hasResult = true; *hasResultType = false; break; + case OpTypeFloat: *hasResult = true; *hasResultType = false; break; + case OpTypeVector: *hasResult = true; *hasResultType = false; break; + case OpTypeMatrix: *hasResult = true; *hasResultType = false; break; + case OpTypeImage: *hasResult = true; *hasResultType = false; break; + case OpTypeSampler: *hasResult = true; *hasResultType = false; break; + case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break; + case OpTypeArray: *hasResult = true; *hasResultType = false; break; + case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; + case OpTypeStruct: *hasResult = true; *hasResultType = false; break; + case OpTypeOpaque: *hasResult = true; *hasResultType = false; break; + case OpTypePointer: *hasResult = true; *hasResultType = false; break; + case OpTypeFunction: *hasResult = true; *hasResultType = false; break; + case OpTypeEvent: *hasResult = true; *hasResultType = false; break; + case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; + case OpTypeReserveId: *hasResult = true; *hasResultType = false; break; + case OpTypeQueue: *hasResult = true; *hasResultType = false; break; + case OpTypePipe: *hasResult = true; *hasResultType = false; break; + case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; + case OpConstantTrue: *hasResult = true; *hasResultType = true; break; + case OpConstantFalse: *hasResult = true; *hasResultType = true; break; + case OpConstant: *hasResult = true; *hasResultType = true; break; + case OpConstantComposite: *hasResult = true; *hasResultType = true; break; + case OpConstantSampler: *hasResult = true; *hasResultType = true; break; + case OpConstantNull: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; + case OpSpecConstant: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break; + case OpFunction: *hasResult = true; *hasResultType = true; break; + case OpFunctionParameter: *hasResult = true; *hasResultType = true; break; + case OpFunctionEnd: *hasResult = false; *hasResultType = false; break; + case OpFunctionCall: *hasResult = true; *hasResultType = true; break; + case OpVariable: *hasResult = true; *hasResultType = true; break; + case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break; + case OpLoad: *hasResult = true; *hasResultType = true; break; + case OpStore: *hasResult = false; *hasResultType = false; break; + case OpCopyMemory: *hasResult = false; *hasResultType = false; break; + case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break; + case OpAccessChain: *hasResult = true; *hasResultType = true; break; + case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; + case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case OpArrayLength: *hasResult = true; *hasResultType = true; break; + case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; + case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case OpDecorate: *hasResult = false; *hasResultType = false; break; + case OpMemberDecorate: *hasResult = false; *hasResultType = false; break; + case OpDecorationGroup: *hasResult = true; *hasResultType = false; break; + case OpGroupDecorate: *hasResult = false; *hasResultType = false; break; + case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; + case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; + case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; + case OpVectorShuffle: *hasResult = true; *hasResultType = true; break; + case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break; + case OpCompositeExtract: *hasResult = true; *hasResultType = true; break; + case OpCompositeInsert: *hasResult = true; *hasResultType = true; break; + case OpCopyObject: *hasResult = true; *hasResultType = true; break; + case OpTranspose: *hasResult = true; *hasResultType = true; break; + case OpSampledImage: *hasResult = true; *hasResultType = true; break; + case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageFetch: *hasResult = true; *hasResultType = true; break; + case OpImageGather: *hasResult = true; *hasResultType = true; break; + case OpImageDrefGather: *hasResult = true; *hasResultType = true; break; + case OpImageRead: *hasResult = true; *hasResultType = true; break; + case OpImageWrite: *hasResult = false; *hasResultType = false; break; + case OpImage: *hasResult = true; *hasResultType = true; break; + case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break; + case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySize: *hasResult = true; *hasResultType = true; break; + case OpImageQueryLod: *hasResult = true; *hasResultType = true; break; + case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break; + case OpConvertFToU: *hasResult = true; *hasResultType = true; break; + case OpConvertFToS: *hasResult = true; *hasResultType = true; break; + case OpConvertSToF: *hasResult = true; *hasResultType = true; break; + case OpConvertUToF: *hasResult = true; *hasResultType = true; break; + case OpUConvert: *hasResult = true; *hasResultType = true; break; + case OpSConvert: *hasResult = true; *hasResultType = true; break; + case OpFConvert: *hasResult = true; *hasResultType = true; break; + case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break; + case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break; + case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break; + case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break; + case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break; + case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; + case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; + case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; + case OpBitcast: *hasResult = true; *hasResultType = true; break; + case OpSNegate: *hasResult = true; *hasResultType = true; break; + case OpFNegate: *hasResult = true; *hasResultType = true; break; + case OpIAdd: *hasResult = true; *hasResultType = true; break; + case OpFAdd: *hasResult = true; *hasResultType = true; break; + case OpISub: *hasResult = true; *hasResultType = true; break; + case OpFSub: *hasResult = true; *hasResultType = true; break; + case OpIMul: *hasResult = true; *hasResultType = true; break; + case OpFMul: *hasResult = true; *hasResultType = true; break; + case OpUDiv: *hasResult = true; *hasResultType = true; break; + case OpSDiv: *hasResult = true; *hasResultType = true; break; + case OpFDiv: *hasResult = true; *hasResultType = true; break; + case OpUMod: *hasResult = true; *hasResultType = true; break; + case OpSRem: *hasResult = true; *hasResultType = true; break; + case OpSMod: *hasResult = true; *hasResultType = true; break; + case OpFRem: *hasResult = true; *hasResultType = true; break; + case OpFMod: *hasResult = true; *hasResultType = true; break; + case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; + case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; + case OpOuterProduct: *hasResult = true; *hasResultType = true; break; + case OpDot: *hasResult = true; *hasResultType = true; break; + case OpIAddCarry: *hasResult = true; *hasResultType = true; break; + case OpISubBorrow: *hasResult = true; *hasResultType = true; break; + case OpUMulExtended: *hasResult = true; *hasResultType = true; break; + case OpSMulExtended: *hasResult = true; *hasResultType = true; break; + case OpAny: *hasResult = true; *hasResultType = true; break; + case OpAll: *hasResult = true; *hasResultType = true; break; + case OpIsNan: *hasResult = true; *hasResultType = true; break; + case OpIsInf: *hasResult = true; *hasResultType = true; break; + case OpIsFinite: *hasResult = true; *hasResultType = true; break; + case OpIsNormal: *hasResult = true; *hasResultType = true; break; + case OpSignBitSet: *hasResult = true; *hasResultType = true; break; + case OpLessOrGreater: *hasResult = true; *hasResultType = true; break; + case OpOrdered: *hasResult = true; *hasResultType = true; break; + case OpUnordered: *hasResult = true; *hasResultType = true; break; + case OpLogicalEqual: *hasResult = true; *hasResultType = true; break; + case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; + case OpLogicalOr: *hasResult = true; *hasResultType = true; break; + case OpLogicalAnd: *hasResult = true; *hasResultType = true; break; + case OpLogicalNot: *hasResult = true; *hasResultType = true; break; + case OpSelect: *hasResult = true; *hasResultType = true; break; + case OpIEqual: *hasResult = true; *hasResultType = true; break; + case OpINotEqual: *hasResult = true; *hasResultType = true; break; + case OpUGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpSGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpULessThan: *hasResult = true; *hasResultType = true; break; + case OpSLessThan: *hasResult = true; *hasResultType = true; break; + case OpULessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break; + case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break; + case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break; + case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; + case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; + case OpBitwiseOr: *hasResult = true; *hasResultType = true; break; + case OpBitwiseXor: *hasResult = true; *hasResultType = true; break; + case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case OpNot: *hasResult = true; *hasResultType = true; break; + case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break; + case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; + case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; + case OpBitReverse: *hasResult = true; *hasResultType = true; break; + case OpBitCount: *hasResult = true; *hasResultType = true; break; + case OpDPdx: *hasResult = true; *hasResultType = true; break; + case OpDPdy: *hasResult = true; *hasResultType = true; break; + case OpFwidth: *hasResult = true; *hasResultType = true; break; + case OpDPdxFine: *hasResult = true; *hasResultType = true; break; + case OpDPdyFine: *hasResult = true; *hasResultType = true; break; + case OpFwidthFine: *hasResult = true; *hasResultType = true; break; + case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break; + case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break; + case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break; + case OpEmitVertex: *hasResult = false; *hasResultType = false; break; + case OpEndPrimitive: *hasResult = false; *hasResultType = false; break; + case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; + case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; + case OpControlBarrier: *hasResult = false; *hasResultType = false; break; + case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break; + case OpAtomicLoad: *hasResult = true; *hasResultType = true; break; + case OpAtomicStore: *hasResult = false; *hasResultType = false; break; + case OpAtomicExchange: *hasResult = true; *hasResultType = true; break; + case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; + case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; + case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; + case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; + case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break; + case OpAtomicISub: *hasResult = true; *hasResultType = true; break; + case OpAtomicSMin: *hasResult = true; *hasResultType = true; break; + case OpAtomicUMin: *hasResult = true; *hasResultType = true; break; + case OpAtomicSMax: *hasResult = true; *hasResultType = true; break; + case OpAtomicUMax: *hasResult = true; *hasResultType = true; break; + case OpAtomicAnd: *hasResult = true; *hasResultType = true; break; + case OpAtomicOr: *hasResult = true; *hasResultType = true; break; + case OpAtomicXor: *hasResult = true; *hasResultType = true; break; + case OpPhi: *hasResult = true; *hasResultType = true; break; + case OpLoopMerge: *hasResult = false; *hasResultType = false; break; + case OpSelectionMerge: *hasResult = false; *hasResultType = false; break; + case OpLabel: *hasResult = true; *hasResultType = false; break; + case OpBranch: *hasResult = false; *hasResultType = false; break; + case OpBranchConditional: *hasResult = false; *hasResultType = false; break; + case OpSwitch: *hasResult = false; *hasResultType = false; break; + case OpKill: *hasResult = false; *hasResultType = false; break; + case OpReturn: *hasResult = false; *hasResultType = false; break; + case OpReturnValue: *hasResult = false; *hasResultType = false; break; + case OpUnreachable: *hasResult = false; *hasResultType = false; break; + case OpLifetimeStart: *hasResult = false; *hasResultType = false; break; + case OpLifetimeStop: *hasResult = false; *hasResultType = false; break; + case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; + case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; + case OpGroupAll: *hasResult = true; *hasResultType = true; break; + case OpGroupAny: *hasResult = true; *hasResultType = true; break; + case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupIAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupFAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupFMin: *hasResult = true; *hasResultType = true; break; + case OpGroupUMin: *hasResult = true; *hasResultType = true; break; + case OpGroupSMin: *hasResult = true; *hasResultType = true; break; + case OpGroupFMax: *hasResult = true; *hasResultType = true; break; + case OpGroupUMax: *hasResult = true; *hasResultType = true; break; + case OpGroupSMax: *hasResult = true; *hasResultType = true; break; + case OpReadPipe: *hasResult = true; *hasResultType = true; break; + case OpWritePipe: *hasResult = true; *hasResultType = true; break; + case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break; + case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break; + case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break; + case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break; + case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break; + case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; + case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; + case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; + case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; + case OpRetainEvent: *hasResult = false; *hasResultType = false; break; + case OpReleaseEvent: *hasResult = false; *hasResultType = false; break; + case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break; + case OpIsValidEvent: *hasResult = true; *hasResultType = true; break; + case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; + case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; + case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; + case OpBuildNDRange: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break; + case OpImageSparseGather: *hasResult = true; *hasResultType = true; break; + case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; + case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; + case OpNoLine: *hasResult = false; *hasResultType = false; break; + case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; + case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; + case OpImageSparseRead: *hasResult = true; *hasResultType = true; break; + case OpSizeOf: *hasResult = true; *hasResultType = true; break; + case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break; + case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; + case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; + case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; + case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; + case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; + case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; + case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; + case OpModuleProcessed: *hasResult = false; *hasResultType = false; break; + case OpExecutionModeId: *hasResult = false; *hasResultType = false; break; + case OpDecorateId: *hasResult = false; *hasResultType = false; break; + case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; + case OpCopyLogical: *hasResult = true; *hasResultType = true; break; + case OpPtrEqual: *hasResult = true; *hasResultType = true; break; + case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break; + case OpPtrDiff: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break; + case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; + case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; + case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; + case OpReadClockKHR: *hasResult = true; *hasResultType = true; break; + case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; + case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; + case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case OpTraceNV: *hasResult = false; *hasResultType = false; break; + case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; + case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; + case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; + case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; + case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; + case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case OpDecorateString: *hasResult = false; *hasResultType = false; break; + case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break; + case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; + case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; + } +} +#endif /* SPV_ENABLE_UTILITY_CODE */ + +// Overload operator| for mask bit combining + +inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); } +inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); } +inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); } +inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); } +inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); } +inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); } +inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); } +inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); } +inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); } + +} // end namespace spv + +#endif // #ifndef spirv_HPP + diff --git a/ios/include/glslang/SPIRV/spvIR.h b/ios/include/glslang/SPIRV/spvIR.h new file mode 100644 index 00000000..6523035e --- /dev/null +++ b/ios/include/glslang/SPIRV/spvIR.h @@ -0,0 +1,485 @@ +// +// Copyright (C) 2014 LunarG, Inc. +// Copyright (C) 2015-2018 Google, 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. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. + +// SPIRV-IR +// +// Simple in-memory representation (IR) of SPIRV. Just for holding +// Each function's CFG of blocks. Has this hierarchy: +// - Module, which is a list of +// - Function, which is a list of +// - Block, which is a list of +// - Instruction +// + +#pragma once +#ifndef spvIR_H +#define spvIR_H + +#include "spirv.hpp" + +#include +#include +#include +#include +#include +#include + +namespace spv { + +class Block; +class Function; +class Module; + +const Id NoResult = 0; +const Id NoType = 0; + +const Decoration NoPrecision = DecorationMax; + +#ifdef __GNUC__ +# define POTENTIALLY_UNUSED __attribute__((unused)) +#else +# define POTENTIALLY_UNUSED +#endif + +POTENTIALLY_UNUSED +const MemorySemanticsMask MemorySemanticsAllMemory = + (MemorySemanticsMask)(MemorySemanticsUniformMemoryMask | + MemorySemanticsWorkgroupMemoryMask | + MemorySemanticsAtomicCounterMemoryMask | + MemorySemanticsImageMemoryMask); + +struct IdImmediate { + bool isId; // true if word is an Id, false if word is an immediate + unsigned word; + IdImmediate(bool i, unsigned w) : isId(i), word(w) {} +}; + +// +// SPIR-V IR instruction. +// + +class Instruction { +public: + Instruction(Id resultId, Id typeId, Op opCode) : resultId(resultId), typeId(typeId), opCode(opCode), block(nullptr) { } + explicit Instruction(Op opCode) : resultId(NoResult), typeId(NoType), opCode(opCode), block(nullptr) { } + virtual ~Instruction() {} + void addIdOperand(Id id) { + operands.push_back(id); + idOperand.push_back(true); + } + void addImmediateOperand(unsigned int immediate) { + operands.push_back(immediate); + idOperand.push_back(false); + } + void setImmediateOperand(unsigned idx, unsigned int immediate) { + assert(!idOperand[idx]); + operands[idx] = immediate; + } + + void addStringOperand(const char* str) + { + unsigned int word; + char* wordString = (char*)&word; + char* wordPtr = wordString; + int charCount = 0; + char c; + do { + c = *(str++); + *(wordPtr++) = c; + ++charCount; + if (charCount == 4) { + addImmediateOperand(word); + wordPtr = wordString; + charCount = 0; + } + } while (c != 0); + + // deal with partial last word + if (charCount > 0) { + // pad with 0s + for (; charCount < 4; ++charCount) + *(wordPtr++) = 0; + addImmediateOperand(word); + } + } + bool isIdOperand(int op) const { return idOperand[op]; } + void setBlock(Block* b) { block = b; } + Block* getBlock() const { return block; } + Op getOpCode() const { return opCode; } + int getNumOperands() const + { + assert(operands.size() == idOperand.size()); + return (int)operands.size(); + } + Id getResultId() const { return resultId; } + Id getTypeId() const { return typeId; } + Id getIdOperand(int op) const { + assert(idOperand[op]); + return operands[op]; + } + unsigned int getImmediateOperand(int op) const { + assert(!idOperand[op]); + return operands[op]; + } + + // Write out the binary form. + void dump(std::vector& out) const + { + // Compute the wordCount + unsigned int wordCount = 1; + if (typeId) + ++wordCount; + if (resultId) + ++wordCount; + wordCount += (unsigned int)operands.size(); + + // Write out the beginning of the instruction + out.push_back(((wordCount) << WordCountShift) | opCode); + if (typeId) + out.push_back(typeId); + if (resultId) + out.push_back(resultId); + + // Write out the operands + for (int op = 0; op < (int)operands.size(); ++op) + out.push_back(operands[op]); + } + +protected: + Instruction(const Instruction&); + Id resultId; + Id typeId; + Op opCode; + std::vector operands; // operands, both and immediates (both are unsigned int) + std::vector idOperand; // true for operands that are , false for immediates + Block* block; +}; + +// +// SPIR-V IR block. +// + +class Block { +public: + Block(Id id, Function& parent); + virtual ~Block() + { + } + + Id getId() { return instructions.front()->getResultId(); } + + Function& getParent() const { return parent; } + void addInstruction(std::unique_ptr inst); + void addPredecessor(Block* pred) { predecessors.push_back(pred); pred->successors.push_back(this);} + void addLocalVariable(std::unique_ptr inst) { localVariables.push_back(std::move(inst)); } + const std::vector& getPredecessors() const { return predecessors; } + const std::vector& getSuccessors() const { return successors; } + const std::vector >& getInstructions() const { + return instructions; + } + const std::vector >& getLocalVariables() const { return localVariables; } + void setUnreachable() { unreachable = true; } + bool isUnreachable() const { return unreachable; } + // Returns the block's merge instruction, if one exists (otherwise null). + const Instruction* getMergeInstruction() const { + if (instructions.size() < 2) return nullptr; + const Instruction* nextToLast = (instructions.cend() - 2)->get(); + switch (nextToLast->getOpCode()) { + case OpSelectionMerge: + case OpLoopMerge: + return nextToLast; + default: + return nullptr; + } + return nullptr; + } + + // Change this block into a canonical dead merge block. Delete instructions + // as necessary. A canonical dead merge block has only an OpLabel and an + // OpUnreachable. + void rewriteAsCanonicalUnreachableMerge() { + assert(localVariables.empty()); + // Delete all instructions except for the label. + assert(instructions.size() > 0); + instructions.resize(1); + successors.clear(); + addInstruction(std::unique_ptr(new Instruction(OpUnreachable))); + } + // Change this block into a canonical dead continue target branching to the + // given header ID. Delete instructions as necessary. A canonical dead continue + // target has only an OpLabel and an unconditional branch back to the corresponding + // header. + void rewriteAsCanonicalUnreachableContinue(Block* header) { + assert(localVariables.empty()); + // Delete all instructions except for the label. + assert(instructions.size() > 0); + instructions.resize(1); + successors.clear(); + // Add OpBranch back to the header. + assert(header != nullptr); + Instruction* branch = new Instruction(OpBranch); + branch->addIdOperand(header->getId()); + addInstruction(std::unique_ptr(branch)); + successors.push_back(header); + } + + bool isTerminated() const + { + switch (instructions.back()->getOpCode()) { + case OpBranch: + case OpBranchConditional: + case OpSwitch: + case OpKill: + case OpReturn: + case OpReturnValue: + case OpUnreachable: + return true; + default: + return false; + } + } + + void dump(std::vector& out) const + { + instructions[0]->dump(out); + for (int i = 0; i < (int)localVariables.size(); ++i) + localVariables[i]->dump(out); + for (int i = 1; i < (int)instructions.size(); ++i) + instructions[i]->dump(out); + } + +protected: + Block(const Block&); + Block& operator=(Block&); + + // To enforce keeping parent and ownership in sync: + friend Function; + + std::vector > instructions; + std::vector predecessors, successors; + std::vector > localVariables; + Function& parent; + + // track whether this block is known to be uncreachable (not necessarily + // true for all unreachable blocks, but should be set at least + // for the extraneous ones introduced by the builder). + bool unreachable; +}; + +// The different reasons for reaching a block in the inReadableOrder traversal. +enum ReachReason { + // Reachable from the entry block via transfers of control, i.e. branches. + ReachViaControlFlow = 0, + // A continue target that is not reachable via control flow. + ReachDeadContinue, + // A merge block that is not reachable via control flow. + ReachDeadMerge +}; + +// Traverses the control-flow graph rooted at root in an order suited for +// readable code generation. Invokes callback at every node in the traversal +// order. The callback arguments are: +// - the block, +// - the reason we reached the block, +// - if the reason was that block is an unreachable continue or unreachable merge block +// then the last parameter is the corresponding header block. +void inReadableOrder(Block* root, std::function callback); + +// +// SPIR-V IR Function. +// + +class Function { +public: + Function(Id id, Id resultType, Id functionType, Id firstParam, Module& parent); + virtual ~Function() + { + for (int i = 0; i < (int)parameterInstructions.size(); ++i) + delete parameterInstructions[i]; + + for (int i = 0; i < (int)blocks.size(); ++i) + delete blocks[i]; + } + Id getId() const { return functionInstruction.getResultId(); } + Id getParamId(int p) const { return parameterInstructions[p]->getResultId(); } + Id getParamType(int p) const { return parameterInstructions[p]->getTypeId(); } + + void addBlock(Block* block) { blocks.push_back(block); } + void removeBlock(Block* block) + { + auto found = find(blocks.begin(), blocks.end(), block); + assert(found != blocks.end()); + blocks.erase(found); + delete block; + } + + Module& getParent() const { return parent; } + Block* getEntryBlock() const { return blocks.front(); } + Block* getLastBlock() const { return blocks.back(); } + const std::vector& getBlocks() const { return blocks; } + void addLocalVariable(std::unique_ptr inst); + Id getReturnType() const { return functionInstruction.getTypeId(); } + + void setImplicitThis() { implicitThis = true; } + bool hasImplicitThis() const { return implicitThis; } + + void dump(std::vector& out) const + { + // OpFunction + functionInstruction.dump(out); + + // OpFunctionParameter + for (int p = 0; p < (int)parameterInstructions.size(); ++p) + parameterInstructions[p]->dump(out); + + // Blocks + inReadableOrder(blocks[0], [&out](const Block* b, ReachReason, Block*) { b->dump(out); }); + Instruction end(0, 0, OpFunctionEnd); + end.dump(out); + } + +protected: + Function(const Function&); + Function& operator=(Function&); + + Module& parent; + Instruction functionInstruction; + std::vector parameterInstructions; + std::vector blocks; + bool implicitThis; // true if this is a member function expecting to be passed a 'this' as the first argument +}; + +// +// SPIR-V IR Module. +// + +class Module { +public: + Module() {} + virtual ~Module() + { + // TODO delete things + } + + void addFunction(Function *fun) { functions.push_back(fun); } + + void mapInstruction(Instruction *instruction) + { + spv::Id resultId = instruction->getResultId(); + // map the instruction's result id + if (resultId >= idToInstruction.size()) + idToInstruction.resize(resultId + 16); + idToInstruction[resultId] = instruction; + } + + Instruction* getInstruction(Id id) const { return idToInstruction[id]; } + const std::vector& getFunctions() const { return functions; } + spv::Id getTypeId(Id resultId) const { + return idToInstruction[resultId] == nullptr ? NoType : idToInstruction[resultId]->getTypeId(); + } + StorageClass getStorageClass(Id typeId) const + { + assert(idToInstruction[typeId]->getOpCode() == spv::OpTypePointer); + return (StorageClass)idToInstruction[typeId]->getImmediateOperand(0); + } + + void dump(std::vector& out) const + { + for (int f = 0; f < (int)functions.size(); ++f) + functions[f]->dump(out); + } + +protected: + Module(const Module&); + std::vector functions; + + // map from result id to instruction having that result id + std::vector idToInstruction; + + // map from a result id to its type id +}; + +// +// Implementation (it's here due to circular type definitions). +// + +// Add both +// - the OpFunction instruction +// - all the OpFunctionParameter instructions +__inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, Module& parent) + : parent(parent), functionInstruction(id, resultType, OpFunction), implicitThis(false) +{ + // OpFunction + functionInstruction.addImmediateOperand(FunctionControlMaskNone); + functionInstruction.addIdOperand(functionType); + parent.mapInstruction(&functionInstruction); + parent.addFunction(this); + + // OpFunctionParameter + Instruction* typeInst = parent.getInstruction(functionType); + int numParams = typeInst->getNumOperands() - 1; + for (int p = 0; p < numParams; ++p) { + Instruction* param = new Instruction(firstParamId + p, typeInst->getIdOperand(p + 1), OpFunctionParameter); + parent.mapInstruction(param); + parameterInstructions.push_back(param); + } +} + +__inline void Function::addLocalVariable(std::unique_ptr inst) +{ + Instruction* raw_instruction = inst.get(); + blocks[0]->addLocalVariable(std::move(inst)); + parent.mapInstruction(raw_instruction); +} + +__inline Block::Block(Id id, Function& parent) : parent(parent), unreachable(false) +{ + instructions.push_back(std::unique_ptr(new Instruction(id, NoType, OpLabel))); + instructions.back()->setBlock(this); + parent.getParent().mapInstruction(instructions.back().get()); +} + +__inline void Block::addInstruction(std::unique_ptr inst) +{ + Instruction* raw_instruction = inst.get(); + instructions.push_back(std::move(inst)); + raw_instruction->setBlock(this); + if (raw_instruction->getResultId()) + parent.getParent().mapInstruction(raw_instruction); +} + +} // end spv namespace + +#endif // spvIR_H diff --git a/ios/include/spirv_cross/GLSL.std.450.h b/ios/include/spirv_cross/GLSL.std.450.h new file mode 100644 index 00000000..54cc00e9 --- /dev/null +++ b/ios/include/spirv_cross/GLSL.std.450.h @@ -0,0 +1,131 @@ +/* +** Copyright (c) 2014-2016 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +#ifndef GLSLstd450_H +#define GLSLstd450_H + +static const int GLSLstd450Version = 100; +static const int GLSLstd450Revision = 3; + +enum GLSLstd450 { + GLSLstd450Bad = 0, // Don't use + + GLSLstd450Round = 1, + GLSLstd450RoundEven = 2, + GLSLstd450Trunc = 3, + GLSLstd450FAbs = 4, + GLSLstd450SAbs = 5, + GLSLstd450FSign = 6, + GLSLstd450SSign = 7, + GLSLstd450Floor = 8, + GLSLstd450Ceil = 9, + GLSLstd450Fract = 10, + + GLSLstd450Radians = 11, + GLSLstd450Degrees = 12, + GLSLstd450Sin = 13, + GLSLstd450Cos = 14, + GLSLstd450Tan = 15, + GLSLstd450Asin = 16, + GLSLstd450Acos = 17, + GLSLstd450Atan = 18, + GLSLstd450Sinh = 19, + GLSLstd450Cosh = 20, + GLSLstd450Tanh = 21, + GLSLstd450Asinh = 22, + GLSLstd450Acosh = 23, + GLSLstd450Atanh = 24, + GLSLstd450Atan2 = 25, + + GLSLstd450Pow = 26, + GLSLstd450Exp = 27, + GLSLstd450Log = 28, + GLSLstd450Exp2 = 29, + GLSLstd450Log2 = 30, + GLSLstd450Sqrt = 31, + GLSLstd450InverseSqrt = 32, + + GLSLstd450Determinant = 33, + GLSLstd450MatrixInverse = 34, + + GLSLstd450Modf = 35, // second operand needs an OpVariable to write to + GLSLstd450ModfStruct = 36, // no OpVariable operand + GLSLstd450FMin = 37, + GLSLstd450UMin = 38, + GLSLstd450SMin = 39, + GLSLstd450FMax = 40, + GLSLstd450UMax = 41, + GLSLstd450SMax = 42, + GLSLstd450FClamp = 43, + GLSLstd450UClamp = 44, + GLSLstd450SClamp = 45, + GLSLstd450FMix = 46, + GLSLstd450IMix = 47, // Reserved + GLSLstd450Step = 48, + GLSLstd450SmoothStep = 49, + + GLSLstd450Fma = 50, + GLSLstd450Frexp = 51, // second operand needs an OpVariable to write to + GLSLstd450FrexpStruct = 52, // no OpVariable operand + GLSLstd450Ldexp = 53, + + GLSLstd450PackSnorm4x8 = 54, + GLSLstd450PackUnorm4x8 = 55, + GLSLstd450PackSnorm2x16 = 56, + GLSLstd450PackUnorm2x16 = 57, + GLSLstd450PackHalf2x16 = 58, + GLSLstd450PackDouble2x32 = 59, + GLSLstd450UnpackSnorm2x16 = 60, + GLSLstd450UnpackUnorm2x16 = 61, + GLSLstd450UnpackHalf2x16 = 62, + GLSLstd450UnpackSnorm4x8 = 63, + GLSLstd450UnpackUnorm4x8 = 64, + GLSLstd450UnpackDouble2x32 = 65, + + GLSLstd450Length = 66, + GLSLstd450Distance = 67, + GLSLstd450Cross = 68, + GLSLstd450Normalize = 69, + GLSLstd450FaceForward = 70, + GLSLstd450Reflect = 71, + GLSLstd450Refract = 72, + + GLSLstd450FindILsb = 73, + GLSLstd450FindSMsb = 74, + GLSLstd450FindUMsb = 75, + + GLSLstd450InterpolateAtCentroid = 76, + GLSLstd450InterpolateAtSample = 77, + GLSLstd450InterpolateAtOffset = 78, + + GLSLstd450NMin = 79, + GLSLstd450NMax = 80, + GLSLstd450NClamp = 81, + + GLSLstd450Count +}; + +#endif // #ifndef GLSLstd450_H diff --git a/ios/include/spirv_cross/spirv.h b/ios/include/spirv_cross/spirv.h new file mode 100644 index 00000000..92b34c38 --- /dev/null +++ b/ios/include/spirv_cross/spirv.h @@ -0,0 +1,2104 @@ +/* +** Copyright (c) 2014-2020 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a copy +** of this software and/or associated documentation files (the "Materials"), +** to deal in the Materials without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Materials, and to permit persons to whom the +** Materials are 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 Materials. +** +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** +** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +** IN THE MATERIALS. +*/ + +/* +** This header is automatically generated by the same tool that creates +** the Binary Section of the SPIR-V specification. +*/ + +/* +** Enumeration tokens for SPIR-V, in various styles: +** C, C++, C++11, JSON, Lua, Python, C#, D +** +** - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL +** - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL +** - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL +** - Lua will use tables, e.g.: spv.SourceLanguage.GLSL +** - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] +** - C# will use enum classes in the Specification class located in the "Spv" namespace, +** e.g.: Spv.Specification.SourceLanguage.GLSL +** - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL +** +** Some tokens act like mask values, which can be OR'd together, +** while others are mutually exclusive. The mask-like ones have +** "Mask" in their name, and a parallel enum that has the shift +** amount (1 << x) for each corresponding enumerant. +*/ + +#ifndef spirv_H +#define spirv_H + +typedef unsigned int SpvId; + +#define SPV_VERSION 0x10500 +#define SPV_REVISION 1 + +static const unsigned int SpvMagicNumber = 0x07230203; +static const unsigned int SpvVersion = 0x00010500; +static const unsigned int SpvRevision = 1; +static const unsigned int SpvOpCodeMask = 0xffff; +static const unsigned int SpvWordCountShift = 16; + +typedef enum SpvSourceLanguage_ { + SpvSourceLanguageUnknown = 0, + SpvSourceLanguageESSL = 1, + SpvSourceLanguageGLSL = 2, + SpvSourceLanguageOpenCL_C = 3, + SpvSourceLanguageOpenCL_CPP = 4, + SpvSourceLanguageHLSL = 5, + SpvSourceLanguageMax = 0x7fffffff, +} SpvSourceLanguage; + +typedef enum SpvExecutionModel_ { + SpvExecutionModelVertex = 0, + SpvExecutionModelTessellationControl = 1, + SpvExecutionModelTessellationEvaluation = 2, + SpvExecutionModelGeometry = 3, + SpvExecutionModelFragment = 4, + SpvExecutionModelGLCompute = 5, + SpvExecutionModelKernel = 6, + SpvExecutionModelTaskNV = 5267, + SpvExecutionModelMeshNV = 5268, + SpvExecutionModelRayGenerationKHR = 5313, + SpvExecutionModelRayGenerationNV = 5313, + SpvExecutionModelIntersectionKHR = 5314, + SpvExecutionModelIntersectionNV = 5314, + SpvExecutionModelAnyHitKHR = 5315, + SpvExecutionModelAnyHitNV = 5315, + SpvExecutionModelClosestHitKHR = 5316, + SpvExecutionModelClosestHitNV = 5316, + SpvExecutionModelMissKHR = 5317, + SpvExecutionModelMissNV = 5317, + SpvExecutionModelCallableKHR = 5318, + SpvExecutionModelCallableNV = 5318, + SpvExecutionModelMax = 0x7fffffff, +} SpvExecutionModel; + +typedef enum SpvAddressingModel_ { + SpvAddressingModelLogical = 0, + SpvAddressingModelPhysical32 = 1, + SpvAddressingModelPhysical64 = 2, + SpvAddressingModelPhysicalStorageBuffer64 = 5348, + SpvAddressingModelPhysicalStorageBuffer64EXT = 5348, + SpvAddressingModelMax = 0x7fffffff, +} SpvAddressingModel; + +typedef enum SpvMemoryModel_ { + SpvMemoryModelSimple = 0, + SpvMemoryModelGLSL450 = 1, + SpvMemoryModelOpenCL = 2, + SpvMemoryModelVulkan = 3, + SpvMemoryModelVulkanKHR = 3, + SpvMemoryModelMax = 0x7fffffff, +} SpvMemoryModel; + +typedef enum SpvExecutionMode_ { + SpvExecutionModeInvocations = 0, + SpvExecutionModeSpacingEqual = 1, + SpvExecutionModeSpacingFractionalEven = 2, + SpvExecutionModeSpacingFractionalOdd = 3, + SpvExecutionModeVertexOrderCw = 4, + SpvExecutionModeVertexOrderCcw = 5, + SpvExecutionModePixelCenterInteger = 6, + SpvExecutionModeOriginUpperLeft = 7, + SpvExecutionModeOriginLowerLeft = 8, + SpvExecutionModeEarlyFragmentTests = 9, + SpvExecutionModePointMode = 10, + SpvExecutionModeXfb = 11, + SpvExecutionModeDepthReplacing = 12, + SpvExecutionModeDepthGreater = 14, + SpvExecutionModeDepthLess = 15, + SpvExecutionModeDepthUnchanged = 16, + SpvExecutionModeLocalSize = 17, + SpvExecutionModeLocalSizeHint = 18, + SpvExecutionModeInputPoints = 19, + SpvExecutionModeInputLines = 20, + SpvExecutionModeInputLinesAdjacency = 21, + SpvExecutionModeTriangles = 22, + SpvExecutionModeInputTrianglesAdjacency = 23, + SpvExecutionModeQuads = 24, + SpvExecutionModeIsolines = 25, + SpvExecutionModeOutputVertices = 26, + SpvExecutionModeOutputPoints = 27, + SpvExecutionModeOutputLineStrip = 28, + SpvExecutionModeOutputTriangleStrip = 29, + SpvExecutionModeVecTypeHint = 30, + SpvExecutionModeContractionOff = 31, + SpvExecutionModeInitializer = 33, + SpvExecutionModeFinalizer = 34, + SpvExecutionModeSubgroupSize = 35, + SpvExecutionModeSubgroupsPerWorkgroup = 36, + SpvExecutionModeSubgroupsPerWorkgroupId = 37, + SpvExecutionModeLocalSizeId = 38, + SpvExecutionModeLocalSizeHintId = 39, + SpvExecutionModePostDepthCoverage = 4446, + SpvExecutionModeDenormPreserve = 4459, + SpvExecutionModeDenormFlushToZero = 4460, + SpvExecutionModeSignedZeroInfNanPreserve = 4461, + SpvExecutionModeRoundingModeRTE = 4462, + SpvExecutionModeRoundingModeRTZ = 4463, + SpvExecutionModeStencilRefReplacingEXT = 5027, + SpvExecutionModeOutputLinesNV = 5269, + SpvExecutionModeOutputPrimitivesNV = 5270, + SpvExecutionModeDerivativeGroupQuadsNV = 5289, + SpvExecutionModeDerivativeGroupLinearNV = 5290, + SpvExecutionModeOutputTrianglesNV = 5298, + SpvExecutionModePixelInterlockOrderedEXT = 5366, + SpvExecutionModePixelInterlockUnorderedEXT = 5367, + SpvExecutionModeSampleInterlockOrderedEXT = 5368, + SpvExecutionModeSampleInterlockUnorderedEXT = 5369, + SpvExecutionModeShadingRateInterlockOrderedEXT = 5370, + SpvExecutionModeShadingRateInterlockUnorderedEXT = 5371, + SpvExecutionModeMax = 0x7fffffff, +} SpvExecutionMode; + +typedef enum SpvStorageClass_ { + SpvStorageClassUniformConstant = 0, + SpvStorageClassInput = 1, + SpvStorageClassUniform = 2, + SpvStorageClassOutput = 3, + SpvStorageClassWorkgroup = 4, + SpvStorageClassCrossWorkgroup = 5, + SpvStorageClassPrivate = 6, + SpvStorageClassFunction = 7, + SpvStorageClassGeneric = 8, + SpvStorageClassPushConstant = 9, + SpvStorageClassAtomicCounter = 10, + SpvStorageClassImage = 11, + SpvStorageClassStorageBuffer = 12, + SpvStorageClassCallableDataKHR = 5328, + SpvStorageClassCallableDataNV = 5328, + SpvStorageClassIncomingCallableDataKHR = 5329, + SpvStorageClassIncomingCallableDataNV = 5329, + SpvStorageClassRayPayloadKHR = 5338, + SpvStorageClassRayPayloadNV = 5338, + SpvStorageClassHitAttributeKHR = 5339, + SpvStorageClassHitAttributeNV = 5339, + SpvStorageClassIncomingRayPayloadKHR = 5342, + SpvStorageClassIncomingRayPayloadNV = 5342, + SpvStorageClassShaderRecordBufferKHR = 5343, + SpvStorageClassShaderRecordBufferNV = 5343, + SpvStorageClassPhysicalStorageBuffer = 5349, + SpvStorageClassPhysicalStorageBufferEXT = 5349, + SpvStorageClassMax = 0x7fffffff, +} SpvStorageClass; + +typedef enum SpvDim_ { + SpvDim1D = 0, + SpvDim2D = 1, + SpvDim3D = 2, + SpvDimCube = 3, + SpvDimRect = 4, + SpvDimBuffer = 5, + SpvDimSubpassData = 6, + SpvDimMax = 0x7fffffff, +} SpvDim; + +typedef enum SpvSamplerAddressingMode_ { + SpvSamplerAddressingModeNone = 0, + SpvSamplerAddressingModeClampToEdge = 1, + SpvSamplerAddressingModeClamp = 2, + SpvSamplerAddressingModeRepeat = 3, + SpvSamplerAddressingModeRepeatMirrored = 4, + SpvSamplerAddressingModeMax = 0x7fffffff, +} SpvSamplerAddressingMode; + +typedef enum SpvSamplerFilterMode_ { + SpvSamplerFilterModeNearest = 0, + SpvSamplerFilterModeLinear = 1, + SpvSamplerFilterModeMax = 0x7fffffff, +} SpvSamplerFilterMode; + +typedef enum SpvImageFormat_ { + SpvImageFormatUnknown = 0, + SpvImageFormatRgba32f = 1, + SpvImageFormatRgba16f = 2, + SpvImageFormatR32f = 3, + SpvImageFormatRgba8 = 4, + SpvImageFormatRgba8Snorm = 5, + SpvImageFormatRg32f = 6, + SpvImageFormatRg16f = 7, + SpvImageFormatR11fG11fB10f = 8, + SpvImageFormatR16f = 9, + SpvImageFormatRgba16 = 10, + SpvImageFormatRgb10A2 = 11, + SpvImageFormatRg16 = 12, + SpvImageFormatRg8 = 13, + SpvImageFormatR16 = 14, + SpvImageFormatR8 = 15, + SpvImageFormatRgba16Snorm = 16, + SpvImageFormatRg16Snorm = 17, + SpvImageFormatRg8Snorm = 18, + SpvImageFormatR16Snorm = 19, + SpvImageFormatR8Snorm = 20, + SpvImageFormatRgba32i = 21, + SpvImageFormatRgba16i = 22, + SpvImageFormatRgba8i = 23, + SpvImageFormatR32i = 24, + SpvImageFormatRg32i = 25, + SpvImageFormatRg16i = 26, + SpvImageFormatRg8i = 27, + SpvImageFormatR16i = 28, + SpvImageFormatR8i = 29, + SpvImageFormatRgba32ui = 30, + SpvImageFormatRgba16ui = 31, + SpvImageFormatRgba8ui = 32, + SpvImageFormatR32ui = 33, + SpvImageFormatRgb10a2ui = 34, + SpvImageFormatRg32ui = 35, + SpvImageFormatRg16ui = 36, + SpvImageFormatRg8ui = 37, + SpvImageFormatR16ui = 38, + SpvImageFormatR8ui = 39, + SpvImageFormatMax = 0x7fffffff, +} SpvImageFormat; + +typedef enum SpvImageChannelOrder_ { + SpvImageChannelOrderR = 0, + SpvImageChannelOrderA = 1, + SpvImageChannelOrderRG = 2, + SpvImageChannelOrderRA = 3, + SpvImageChannelOrderRGB = 4, + SpvImageChannelOrderRGBA = 5, + SpvImageChannelOrderBGRA = 6, + SpvImageChannelOrderARGB = 7, + SpvImageChannelOrderIntensity = 8, + SpvImageChannelOrderLuminance = 9, + SpvImageChannelOrderRx = 10, + SpvImageChannelOrderRGx = 11, + SpvImageChannelOrderRGBx = 12, + SpvImageChannelOrderDepth = 13, + SpvImageChannelOrderDepthStencil = 14, + SpvImageChannelOrdersRGB = 15, + SpvImageChannelOrdersRGBx = 16, + SpvImageChannelOrdersRGBA = 17, + SpvImageChannelOrdersBGRA = 18, + SpvImageChannelOrderABGR = 19, + SpvImageChannelOrderMax = 0x7fffffff, +} SpvImageChannelOrder; + +typedef enum SpvImageChannelDataType_ { + SpvImageChannelDataTypeSnormInt8 = 0, + SpvImageChannelDataTypeSnormInt16 = 1, + SpvImageChannelDataTypeUnormInt8 = 2, + SpvImageChannelDataTypeUnormInt16 = 3, + SpvImageChannelDataTypeUnormShort565 = 4, + SpvImageChannelDataTypeUnormShort555 = 5, + SpvImageChannelDataTypeUnormInt101010 = 6, + SpvImageChannelDataTypeSignedInt8 = 7, + SpvImageChannelDataTypeSignedInt16 = 8, + SpvImageChannelDataTypeSignedInt32 = 9, + SpvImageChannelDataTypeUnsignedInt8 = 10, + SpvImageChannelDataTypeUnsignedInt16 = 11, + SpvImageChannelDataTypeUnsignedInt32 = 12, + SpvImageChannelDataTypeHalfFloat = 13, + SpvImageChannelDataTypeFloat = 14, + SpvImageChannelDataTypeUnormInt24 = 15, + SpvImageChannelDataTypeUnormInt101010_2 = 16, + SpvImageChannelDataTypeMax = 0x7fffffff, +} SpvImageChannelDataType; + +typedef enum SpvImageOperandsShift_ { + SpvImageOperandsBiasShift = 0, + SpvImageOperandsLodShift = 1, + SpvImageOperandsGradShift = 2, + SpvImageOperandsConstOffsetShift = 3, + SpvImageOperandsOffsetShift = 4, + SpvImageOperandsConstOffsetsShift = 5, + SpvImageOperandsSampleShift = 6, + SpvImageOperandsMinLodShift = 7, + SpvImageOperandsMakeTexelAvailableShift = 8, + SpvImageOperandsMakeTexelAvailableKHRShift = 8, + SpvImageOperandsMakeTexelVisibleShift = 9, + SpvImageOperandsMakeTexelVisibleKHRShift = 9, + SpvImageOperandsNonPrivateTexelShift = 10, + SpvImageOperandsNonPrivateTexelKHRShift = 10, + SpvImageOperandsVolatileTexelShift = 11, + SpvImageOperandsVolatileTexelKHRShift = 11, + SpvImageOperandsSignExtendShift = 12, + SpvImageOperandsZeroExtendShift = 13, + SpvImageOperandsMax = 0x7fffffff, +} SpvImageOperandsShift; + +typedef enum SpvImageOperandsMask_ { + SpvImageOperandsMaskNone = 0, + SpvImageOperandsBiasMask = 0x00000001, + SpvImageOperandsLodMask = 0x00000002, + SpvImageOperandsGradMask = 0x00000004, + SpvImageOperandsConstOffsetMask = 0x00000008, + SpvImageOperandsOffsetMask = 0x00000010, + SpvImageOperandsConstOffsetsMask = 0x00000020, + SpvImageOperandsSampleMask = 0x00000040, + SpvImageOperandsMinLodMask = 0x00000080, + SpvImageOperandsMakeTexelAvailableMask = 0x00000100, + SpvImageOperandsMakeTexelAvailableKHRMask = 0x00000100, + SpvImageOperandsMakeTexelVisibleMask = 0x00000200, + SpvImageOperandsMakeTexelVisibleKHRMask = 0x00000200, + SpvImageOperandsNonPrivateTexelMask = 0x00000400, + SpvImageOperandsNonPrivateTexelKHRMask = 0x00000400, + SpvImageOperandsVolatileTexelMask = 0x00000800, + SpvImageOperandsVolatileTexelKHRMask = 0x00000800, + SpvImageOperandsSignExtendMask = 0x00001000, + SpvImageOperandsZeroExtendMask = 0x00002000, +} SpvImageOperandsMask; + +typedef enum SpvFPFastMathModeShift_ { + SpvFPFastMathModeNotNaNShift = 0, + SpvFPFastMathModeNotInfShift = 1, + SpvFPFastMathModeNSZShift = 2, + SpvFPFastMathModeAllowRecipShift = 3, + SpvFPFastMathModeFastShift = 4, + SpvFPFastMathModeMax = 0x7fffffff, +} SpvFPFastMathModeShift; + +typedef enum SpvFPFastMathModeMask_ { + SpvFPFastMathModeMaskNone = 0, + SpvFPFastMathModeNotNaNMask = 0x00000001, + SpvFPFastMathModeNotInfMask = 0x00000002, + SpvFPFastMathModeNSZMask = 0x00000004, + SpvFPFastMathModeAllowRecipMask = 0x00000008, + SpvFPFastMathModeFastMask = 0x00000010, +} SpvFPFastMathModeMask; + +typedef enum SpvFPRoundingMode_ { + SpvFPRoundingModeRTE = 0, + SpvFPRoundingModeRTZ = 1, + SpvFPRoundingModeRTP = 2, + SpvFPRoundingModeRTN = 3, + SpvFPRoundingModeMax = 0x7fffffff, +} SpvFPRoundingMode; + +typedef enum SpvLinkageType_ { + SpvLinkageTypeExport = 0, + SpvLinkageTypeImport = 1, + SpvLinkageTypeMax = 0x7fffffff, +} SpvLinkageType; + +typedef enum SpvAccessQualifier_ { + SpvAccessQualifierReadOnly = 0, + SpvAccessQualifierWriteOnly = 1, + SpvAccessQualifierReadWrite = 2, + SpvAccessQualifierMax = 0x7fffffff, +} SpvAccessQualifier; + +typedef enum SpvFunctionParameterAttribute_ { + SpvFunctionParameterAttributeZext = 0, + SpvFunctionParameterAttributeSext = 1, + SpvFunctionParameterAttributeByVal = 2, + SpvFunctionParameterAttributeSret = 3, + SpvFunctionParameterAttributeNoAlias = 4, + SpvFunctionParameterAttributeNoCapture = 5, + SpvFunctionParameterAttributeNoWrite = 6, + SpvFunctionParameterAttributeNoReadWrite = 7, + SpvFunctionParameterAttributeMax = 0x7fffffff, +} SpvFunctionParameterAttribute; + +typedef enum SpvDecoration_ { + SpvDecorationRelaxedPrecision = 0, + SpvDecorationSpecId = 1, + SpvDecorationBlock = 2, + SpvDecorationBufferBlock = 3, + SpvDecorationRowMajor = 4, + SpvDecorationColMajor = 5, + SpvDecorationArrayStride = 6, + SpvDecorationMatrixStride = 7, + SpvDecorationGLSLShared = 8, + SpvDecorationGLSLPacked = 9, + SpvDecorationCPacked = 10, + SpvDecorationBuiltIn = 11, + SpvDecorationNoPerspective = 13, + SpvDecorationFlat = 14, + SpvDecorationPatch = 15, + SpvDecorationCentroid = 16, + SpvDecorationSample = 17, + SpvDecorationInvariant = 18, + SpvDecorationRestrict = 19, + SpvDecorationAliased = 20, + SpvDecorationVolatile = 21, + SpvDecorationConstant = 22, + SpvDecorationCoherent = 23, + SpvDecorationNonWritable = 24, + SpvDecorationNonReadable = 25, + SpvDecorationUniform = 26, + SpvDecorationUniformId = 27, + SpvDecorationSaturatedConversion = 28, + SpvDecorationStream = 29, + SpvDecorationLocation = 30, + SpvDecorationComponent = 31, + SpvDecorationIndex = 32, + SpvDecorationBinding = 33, + SpvDecorationDescriptorSet = 34, + SpvDecorationOffset = 35, + SpvDecorationXfbBuffer = 36, + SpvDecorationXfbStride = 37, + SpvDecorationFuncParamAttr = 38, + SpvDecorationFPRoundingMode = 39, + SpvDecorationFPFastMathMode = 40, + SpvDecorationLinkageAttributes = 41, + SpvDecorationNoContraction = 42, + SpvDecorationInputAttachmentIndex = 43, + SpvDecorationAlignment = 44, + SpvDecorationMaxByteOffset = 45, + SpvDecorationAlignmentId = 46, + SpvDecorationMaxByteOffsetId = 47, + SpvDecorationNoSignedWrap = 4469, + SpvDecorationNoUnsignedWrap = 4470, + SpvDecorationExplicitInterpAMD = 4999, + SpvDecorationOverrideCoverageNV = 5248, + SpvDecorationPassthroughNV = 5250, + SpvDecorationViewportRelativeNV = 5252, + SpvDecorationSecondaryViewportRelativeNV = 5256, + SpvDecorationPerPrimitiveNV = 5271, + SpvDecorationPerViewNV = 5272, + SpvDecorationPerTaskNV = 5273, + SpvDecorationPerVertexNV = 5285, + SpvDecorationNonUniform = 5300, + SpvDecorationNonUniformEXT = 5300, + SpvDecorationRestrictPointer = 5355, + SpvDecorationRestrictPointerEXT = 5355, + SpvDecorationAliasedPointer = 5356, + SpvDecorationAliasedPointerEXT = 5356, + SpvDecorationCounterBuffer = 5634, + SpvDecorationHlslCounterBufferGOOGLE = 5634, + SpvDecorationHlslSemanticGOOGLE = 5635, + SpvDecorationUserSemantic = 5635, + SpvDecorationUserTypeGOOGLE = 5636, + SpvDecorationMax = 0x7fffffff, +} SpvDecoration; + +typedef enum SpvBuiltIn_ { + SpvBuiltInPosition = 0, + SpvBuiltInPointSize = 1, + SpvBuiltInClipDistance = 3, + SpvBuiltInCullDistance = 4, + SpvBuiltInVertexId = 5, + SpvBuiltInInstanceId = 6, + SpvBuiltInPrimitiveId = 7, + SpvBuiltInInvocationId = 8, + SpvBuiltInLayer = 9, + SpvBuiltInViewportIndex = 10, + SpvBuiltInTessLevelOuter = 11, + SpvBuiltInTessLevelInner = 12, + SpvBuiltInTessCoord = 13, + SpvBuiltInPatchVertices = 14, + SpvBuiltInFragCoord = 15, + SpvBuiltInPointCoord = 16, + SpvBuiltInFrontFacing = 17, + SpvBuiltInSampleId = 18, + SpvBuiltInSamplePosition = 19, + SpvBuiltInSampleMask = 20, + SpvBuiltInFragDepth = 22, + SpvBuiltInHelperInvocation = 23, + SpvBuiltInNumWorkgroups = 24, + SpvBuiltInWorkgroupSize = 25, + SpvBuiltInWorkgroupId = 26, + SpvBuiltInLocalInvocationId = 27, + SpvBuiltInGlobalInvocationId = 28, + SpvBuiltInLocalInvocationIndex = 29, + SpvBuiltInWorkDim = 30, + SpvBuiltInGlobalSize = 31, + SpvBuiltInEnqueuedWorkgroupSize = 32, + SpvBuiltInGlobalOffset = 33, + SpvBuiltInGlobalLinearId = 34, + SpvBuiltInSubgroupSize = 36, + SpvBuiltInSubgroupMaxSize = 37, + SpvBuiltInNumSubgroups = 38, + SpvBuiltInNumEnqueuedSubgroups = 39, + SpvBuiltInSubgroupId = 40, + SpvBuiltInSubgroupLocalInvocationId = 41, + SpvBuiltInVertexIndex = 42, + SpvBuiltInInstanceIndex = 43, + SpvBuiltInSubgroupEqMask = 4416, + SpvBuiltInSubgroupEqMaskKHR = 4416, + SpvBuiltInSubgroupGeMask = 4417, + SpvBuiltInSubgroupGeMaskKHR = 4417, + SpvBuiltInSubgroupGtMask = 4418, + SpvBuiltInSubgroupGtMaskKHR = 4418, + SpvBuiltInSubgroupLeMask = 4419, + SpvBuiltInSubgroupLeMaskKHR = 4419, + SpvBuiltInSubgroupLtMask = 4420, + SpvBuiltInSubgroupLtMaskKHR = 4420, + SpvBuiltInBaseVertex = 4424, + SpvBuiltInBaseInstance = 4425, + SpvBuiltInDrawIndex = 4426, + SpvBuiltInDeviceIndex = 4438, + SpvBuiltInViewIndex = 4440, + SpvBuiltInBaryCoordNoPerspAMD = 4992, + SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993, + SpvBuiltInBaryCoordNoPerspSampleAMD = 4994, + SpvBuiltInBaryCoordSmoothAMD = 4995, + SpvBuiltInBaryCoordSmoothCentroidAMD = 4996, + SpvBuiltInBaryCoordSmoothSampleAMD = 4997, + SpvBuiltInBaryCoordPullModelAMD = 4998, + SpvBuiltInFragStencilRefEXT = 5014, + SpvBuiltInViewportMaskNV = 5253, + SpvBuiltInSecondaryPositionNV = 5257, + SpvBuiltInSecondaryViewportMaskNV = 5258, + SpvBuiltInPositionPerViewNV = 5261, + SpvBuiltInViewportMaskPerViewNV = 5262, + SpvBuiltInFullyCoveredEXT = 5264, + SpvBuiltInTaskCountNV = 5274, + SpvBuiltInPrimitiveCountNV = 5275, + SpvBuiltInPrimitiveIndicesNV = 5276, + SpvBuiltInClipDistancePerViewNV = 5277, + SpvBuiltInCullDistancePerViewNV = 5278, + SpvBuiltInLayerPerViewNV = 5279, + SpvBuiltInMeshViewCountNV = 5280, + SpvBuiltInMeshViewIndicesNV = 5281, + SpvBuiltInBaryCoordNV = 5286, + SpvBuiltInBaryCoordNoPerspNV = 5287, + SpvBuiltInFragSizeEXT = 5292, + SpvBuiltInFragmentSizeNV = 5292, + SpvBuiltInFragInvocationCountEXT = 5293, + SpvBuiltInInvocationsPerPixelNV = 5293, + SpvBuiltInLaunchIdKHR = 5319, + SpvBuiltInLaunchIdNV = 5319, + SpvBuiltInLaunchSizeKHR = 5320, + SpvBuiltInLaunchSizeNV = 5320, + SpvBuiltInWorldRayOriginKHR = 5321, + SpvBuiltInWorldRayOriginNV = 5321, + SpvBuiltInWorldRayDirectionKHR = 5322, + SpvBuiltInWorldRayDirectionNV = 5322, + SpvBuiltInObjectRayOriginKHR = 5323, + SpvBuiltInObjectRayOriginNV = 5323, + SpvBuiltInObjectRayDirectionKHR = 5324, + SpvBuiltInObjectRayDirectionNV = 5324, + SpvBuiltInRayTminKHR = 5325, + SpvBuiltInRayTminNV = 5325, + SpvBuiltInRayTmaxKHR = 5326, + SpvBuiltInRayTmaxNV = 5326, + SpvBuiltInInstanceCustomIndexKHR = 5327, + SpvBuiltInInstanceCustomIndexNV = 5327, + SpvBuiltInObjectToWorldKHR = 5330, + SpvBuiltInObjectToWorldNV = 5330, + SpvBuiltInWorldToObjectKHR = 5331, + SpvBuiltInWorldToObjectNV = 5331, + SpvBuiltInHitTKHR = 5332, + SpvBuiltInHitTNV = 5332, + SpvBuiltInHitKindKHR = 5333, + SpvBuiltInHitKindNV = 5333, + SpvBuiltInIncomingRayFlagsKHR = 5351, + SpvBuiltInIncomingRayFlagsNV = 5351, + SpvBuiltInRayGeometryIndexKHR = 5352, + SpvBuiltInWarpsPerSMNV = 5374, + SpvBuiltInSMCountNV = 5375, + SpvBuiltInWarpIDNV = 5376, + SpvBuiltInSMIDNV = 5377, + SpvBuiltInMax = 0x7fffffff, +} SpvBuiltIn; + +typedef enum SpvSelectionControlShift_ { + SpvSelectionControlFlattenShift = 0, + SpvSelectionControlDontFlattenShift = 1, + SpvSelectionControlMax = 0x7fffffff, +} SpvSelectionControlShift; + +typedef enum SpvSelectionControlMask_ { + SpvSelectionControlMaskNone = 0, + SpvSelectionControlFlattenMask = 0x00000001, + SpvSelectionControlDontFlattenMask = 0x00000002, +} SpvSelectionControlMask; + +typedef enum SpvLoopControlShift_ { + SpvLoopControlUnrollShift = 0, + SpvLoopControlDontUnrollShift = 1, + SpvLoopControlDependencyInfiniteShift = 2, + SpvLoopControlDependencyLengthShift = 3, + SpvLoopControlMinIterationsShift = 4, + SpvLoopControlMaxIterationsShift = 5, + SpvLoopControlIterationMultipleShift = 6, + SpvLoopControlPeelCountShift = 7, + SpvLoopControlPartialCountShift = 8, + SpvLoopControlMax = 0x7fffffff, +} SpvLoopControlShift; + +typedef enum SpvLoopControlMask_ { + SpvLoopControlMaskNone = 0, + SpvLoopControlUnrollMask = 0x00000001, + SpvLoopControlDontUnrollMask = 0x00000002, + SpvLoopControlDependencyInfiniteMask = 0x00000004, + SpvLoopControlDependencyLengthMask = 0x00000008, + SpvLoopControlMinIterationsMask = 0x00000010, + SpvLoopControlMaxIterationsMask = 0x00000020, + SpvLoopControlIterationMultipleMask = 0x00000040, + SpvLoopControlPeelCountMask = 0x00000080, + SpvLoopControlPartialCountMask = 0x00000100, +} SpvLoopControlMask; + +typedef enum SpvFunctionControlShift_ { + SpvFunctionControlInlineShift = 0, + SpvFunctionControlDontInlineShift = 1, + SpvFunctionControlPureShift = 2, + SpvFunctionControlConstShift = 3, + SpvFunctionControlMax = 0x7fffffff, +} SpvFunctionControlShift; + +typedef enum SpvFunctionControlMask_ { + SpvFunctionControlMaskNone = 0, + SpvFunctionControlInlineMask = 0x00000001, + SpvFunctionControlDontInlineMask = 0x00000002, + SpvFunctionControlPureMask = 0x00000004, + SpvFunctionControlConstMask = 0x00000008, +} SpvFunctionControlMask; + +typedef enum SpvMemorySemanticsShift_ { + SpvMemorySemanticsAcquireShift = 1, + SpvMemorySemanticsReleaseShift = 2, + SpvMemorySemanticsAcquireReleaseShift = 3, + SpvMemorySemanticsSequentiallyConsistentShift = 4, + SpvMemorySemanticsUniformMemoryShift = 6, + SpvMemorySemanticsSubgroupMemoryShift = 7, + SpvMemorySemanticsWorkgroupMemoryShift = 8, + SpvMemorySemanticsCrossWorkgroupMemoryShift = 9, + SpvMemorySemanticsAtomicCounterMemoryShift = 10, + SpvMemorySemanticsImageMemoryShift = 11, + SpvMemorySemanticsOutputMemoryShift = 12, + SpvMemorySemanticsOutputMemoryKHRShift = 12, + SpvMemorySemanticsMakeAvailableShift = 13, + SpvMemorySemanticsMakeAvailableKHRShift = 13, + SpvMemorySemanticsMakeVisibleShift = 14, + SpvMemorySemanticsMakeVisibleKHRShift = 14, + SpvMemorySemanticsVolatileShift = 15, + SpvMemorySemanticsMax = 0x7fffffff, +} SpvMemorySemanticsShift; + +typedef enum SpvMemorySemanticsMask_ { + SpvMemorySemanticsMaskNone = 0, + SpvMemorySemanticsAcquireMask = 0x00000002, + SpvMemorySemanticsReleaseMask = 0x00000004, + SpvMemorySemanticsAcquireReleaseMask = 0x00000008, + SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010, + SpvMemorySemanticsUniformMemoryMask = 0x00000040, + SpvMemorySemanticsSubgroupMemoryMask = 0x00000080, + SpvMemorySemanticsWorkgroupMemoryMask = 0x00000100, + SpvMemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, + SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400, + SpvMemorySemanticsImageMemoryMask = 0x00000800, + SpvMemorySemanticsOutputMemoryMask = 0x00001000, + SpvMemorySemanticsOutputMemoryKHRMask = 0x00001000, + SpvMemorySemanticsMakeAvailableMask = 0x00002000, + SpvMemorySemanticsMakeAvailableKHRMask = 0x00002000, + SpvMemorySemanticsMakeVisibleMask = 0x00004000, + SpvMemorySemanticsMakeVisibleKHRMask = 0x00004000, + SpvMemorySemanticsVolatileMask = 0x00008000, +} SpvMemorySemanticsMask; + +typedef enum SpvMemoryAccessShift_ { + SpvMemoryAccessVolatileShift = 0, + SpvMemoryAccessAlignedShift = 1, + SpvMemoryAccessNontemporalShift = 2, + SpvMemoryAccessMakePointerAvailableShift = 3, + SpvMemoryAccessMakePointerAvailableKHRShift = 3, + SpvMemoryAccessMakePointerVisibleShift = 4, + SpvMemoryAccessMakePointerVisibleKHRShift = 4, + SpvMemoryAccessNonPrivatePointerShift = 5, + SpvMemoryAccessNonPrivatePointerKHRShift = 5, + SpvMemoryAccessMax = 0x7fffffff, +} SpvMemoryAccessShift; + +typedef enum SpvMemoryAccessMask_ { + SpvMemoryAccessMaskNone = 0, + SpvMemoryAccessVolatileMask = 0x00000001, + SpvMemoryAccessAlignedMask = 0x00000002, + SpvMemoryAccessNontemporalMask = 0x00000004, + SpvMemoryAccessMakePointerAvailableMask = 0x00000008, + SpvMemoryAccessMakePointerAvailableKHRMask = 0x00000008, + SpvMemoryAccessMakePointerVisibleMask = 0x00000010, + SpvMemoryAccessMakePointerVisibleKHRMask = 0x00000010, + SpvMemoryAccessNonPrivatePointerMask = 0x00000020, + SpvMemoryAccessNonPrivatePointerKHRMask = 0x00000020, +} SpvMemoryAccessMask; + +typedef enum SpvScope_ { + SpvScopeCrossDevice = 0, + SpvScopeDevice = 1, + SpvScopeWorkgroup = 2, + SpvScopeSubgroup = 3, + SpvScopeInvocation = 4, + SpvScopeQueueFamily = 5, + SpvScopeQueueFamilyKHR = 5, + SpvScopeShaderCallKHR = 6, + SpvScopeMax = 0x7fffffff, +} SpvScope; + +typedef enum SpvGroupOperation_ { + SpvGroupOperationReduce = 0, + SpvGroupOperationInclusiveScan = 1, + SpvGroupOperationExclusiveScan = 2, + SpvGroupOperationClusteredReduce = 3, + SpvGroupOperationPartitionedReduceNV = 6, + SpvGroupOperationPartitionedInclusiveScanNV = 7, + SpvGroupOperationPartitionedExclusiveScanNV = 8, + SpvGroupOperationMax = 0x7fffffff, +} SpvGroupOperation; + +typedef enum SpvKernelEnqueueFlags_ { + SpvKernelEnqueueFlagsNoWait = 0, + SpvKernelEnqueueFlagsWaitKernel = 1, + SpvKernelEnqueueFlagsWaitWorkGroup = 2, + SpvKernelEnqueueFlagsMax = 0x7fffffff, +} SpvKernelEnqueueFlags; + +typedef enum SpvKernelProfilingInfoShift_ { + SpvKernelProfilingInfoCmdExecTimeShift = 0, + SpvKernelProfilingInfoMax = 0x7fffffff, +} SpvKernelProfilingInfoShift; + +typedef enum SpvKernelProfilingInfoMask_ { + SpvKernelProfilingInfoMaskNone = 0, + SpvKernelProfilingInfoCmdExecTimeMask = 0x00000001, +} SpvKernelProfilingInfoMask; + +typedef enum SpvCapability_ { + SpvCapabilityMatrix = 0, + SpvCapabilityShader = 1, + SpvCapabilityGeometry = 2, + SpvCapabilityTessellation = 3, + SpvCapabilityAddresses = 4, + SpvCapabilityLinkage = 5, + SpvCapabilityKernel = 6, + SpvCapabilityVector16 = 7, + SpvCapabilityFloat16Buffer = 8, + SpvCapabilityFloat16 = 9, + SpvCapabilityFloat64 = 10, + SpvCapabilityInt64 = 11, + SpvCapabilityInt64Atomics = 12, + SpvCapabilityImageBasic = 13, + SpvCapabilityImageReadWrite = 14, + SpvCapabilityImageMipmap = 15, + SpvCapabilityPipes = 17, + SpvCapabilityGroups = 18, + SpvCapabilityDeviceEnqueue = 19, + SpvCapabilityLiteralSampler = 20, + SpvCapabilityAtomicStorage = 21, + SpvCapabilityInt16 = 22, + SpvCapabilityTessellationPointSize = 23, + SpvCapabilityGeometryPointSize = 24, + SpvCapabilityImageGatherExtended = 25, + SpvCapabilityStorageImageMultisample = 27, + SpvCapabilityUniformBufferArrayDynamicIndexing = 28, + SpvCapabilitySampledImageArrayDynamicIndexing = 29, + SpvCapabilityStorageBufferArrayDynamicIndexing = 30, + SpvCapabilityStorageImageArrayDynamicIndexing = 31, + SpvCapabilityClipDistance = 32, + SpvCapabilityCullDistance = 33, + SpvCapabilityImageCubeArray = 34, + SpvCapabilitySampleRateShading = 35, + SpvCapabilityImageRect = 36, + SpvCapabilitySampledRect = 37, + SpvCapabilityGenericPointer = 38, + SpvCapabilityInt8 = 39, + SpvCapabilityInputAttachment = 40, + SpvCapabilitySparseResidency = 41, + SpvCapabilityMinLod = 42, + SpvCapabilitySampled1D = 43, + SpvCapabilityImage1D = 44, + SpvCapabilitySampledCubeArray = 45, + SpvCapabilitySampledBuffer = 46, + SpvCapabilityImageBuffer = 47, + SpvCapabilityImageMSArray = 48, + SpvCapabilityStorageImageExtendedFormats = 49, + SpvCapabilityImageQuery = 50, + SpvCapabilityDerivativeControl = 51, + SpvCapabilityInterpolationFunction = 52, + SpvCapabilityTransformFeedback = 53, + SpvCapabilityGeometryStreams = 54, + SpvCapabilityStorageImageReadWithoutFormat = 55, + SpvCapabilityStorageImageWriteWithoutFormat = 56, + SpvCapabilityMultiViewport = 57, + SpvCapabilitySubgroupDispatch = 58, + SpvCapabilityNamedBarrier = 59, + SpvCapabilityPipeStorage = 60, + SpvCapabilityGroupNonUniform = 61, + SpvCapabilityGroupNonUniformVote = 62, + SpvCapabilityGroupNonUniformArithmetic = 63, + SpvCapabilityGroupNonUniformBallot = 64, + SpvCapabilityGroupNonUniformShuffle = 65, + SpvCapabilityGroupNonUniformShuffleRelative = 66, + SpvCapabilityGroupNonUniformClustered = 67, + SpvCapabilityGroupNonUniformQuad = 68, + SpvCapabilityShaderLayer = 69, + SpvCapabilityShaderViewportIndex = 70, + SpvCapabilitySubgroupBallotKHR = 4423, + SpvCapabilityDrawParameters = 4427, + SpvCapabilitySubgroupVoteKHR = 4431, + SpvCapabilityStorageBuffer16BitAccess = 4433, + SpvCapabilityStorageUniformBufferBlock16 = 4433, + SpvCapabilityStorageUniform16 = 4434, + SpvCapabilityUniformAndStorageBuffer16BitAccess = 4434, + SpvCapabilityStoragePushConstant16 = 4435, + SpvCapabilityStorageInputOutput16 = 4436, + SpvCapabilityDeviceGroup = 4437, + SpvCapabilityMultiView = 4439, + SpvCapabilityVariablePointersStorageBuffer = 4441, + SpvCapabilityVariablePointers = 4442, + SpvCapabilityAtomicStorageOps = 4445, + SpvCapabilitySampleMaskPostDepthCoverage = 4447, + SpvCapabilityStorageBuffer8BitAccess = 4448, + SpvCapabilityUniformAndStorageBuffer8BitAccess = 4449, + SpvCapabilityStoragePushConstant8 = 4450, + SpvCapabilityDenormPreserve = 4464, + SpvCapabilityDenormFlushToZero = 4465, + SpvCapabilitySignedZeroInfNanPreserve = 4466, + SpvCapabilityRoundingModeRTE = 4467, + SpvCapabilityRoundingModeRTZ = 4468, + SpvCapabilityRayQueryProvisionalKHR = 4471, + SpvCapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478, + SpvCapabilityFloat16ImageAMD = 5008, + SpvCapabilityImageGatherBiasLodAMD = 5009, + SpvCapabilityFragmentMaskAMD = 5010, + SpvCapabilityStencilExportEXT = 5013, + SpvCapabilityImageReadWriteLodAMD = 5015, + SpvCapabilityShaderClockKHR = 5055, + SpvCapabilitySampleMaskOverrideCoverageNV = 5249, + SpvCapabilityGeometryShaderPassthroughNV = 5251, + SpvCapabilityShaderViewportIndexLayerEXT = 5254, + SpvCapabilityShaderViewportIndexLayerNV = 5254, + SpvCapabilityShaderViewportMaskNV = 5255, + SpvCapabilityShaderStereoViewNV = 5259, + SpvCapabilityPerViewAttributesNV = 5260, + SpvCapabilityFragmentFullyCoveredEXT = 5265, + SpvCapabilityMeshShadingNV = 5266, + SpvCapabilityImageFootprintNV = 5282, + SpvCapabilityFragmentBarycentricNV = 5284, + SpvCapabilityComputeDerivativeGroupQuadsNV = 5288, + SpvCapabilityFragmentDensityEXT = 5291, + SpvCapabilityShadingRateNV = 5291, + SpvCapabilityGroupNonUniformPartitionedNV = 5297, + SpvCapabilityShaderNonUniform = 5301, + SpvCapabilityShaderNonUniformEXT = 5301, + SpvCapabilityRuntimeDescriptorArray = 5302, + SpvCapabilityRuntimeDescriptorArrayEXT = 5302, + SpvCapabilityInputAttachmentArrayDynamicIndexing = 5303, + SpvCapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, + SpvCapabilityUniformTexelBufferArrayDynamicIndexing = 5304, + SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, + SpvCapabilityStorageTexelBufferArrayDynamicIndexing = 5305, + SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, + SpvCapabilityUniformBufferArrayNonUniformIndexing = 5306, + SpvCapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, + SpvCapabilitySampledImageArrayNonUniformIndexing = 5307, + SpvCapabilitySampledImageArrayNonUniformIndexingEXT = 5307, + SpvCapabilityStorageBufferArrayNonUniformIndexing = 5308, + SpvCapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, + SpvCapabilityStorageImageArrayNonUniformIndexing = 5309, + SpvCapabilityStorageImageArrayNonUniformIndexingEXT = 5309, + SpvCapabilityInputAttachmentArrayNonUniformIndexing = 5310, + SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, + SpvCapabilityUniformTexelBufferArrayNonUniformIndexing = 5311, + SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, + SpvCapabilityStorageTexelBufferArrayNonUniformIndexing = 5312, + SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, + SpvCapabilityRayTracingNV = 5340, + SpvCapabilityVulkanMemoryModel = 5345, + SpvCapabilityVulkanMemoryModelKHR = 5345, + SpvCapabilityVulkanMemoryModelDeviceScope = 5346, + SpvCapabilityVulkanMemoryModelDeviceScopeKHR = 5346, + SpvCapabilityPhysicalStorageBufferAddresses = 5347, + SpvCapabilityPhysicalStorageBufferAddressesEXT = 5347, + SpvCapabilityComputeDerivativeGroupLinearNV = 5350, + SpvCapabilityRayTracingProvisionalKHR = 5353, + SpvCapabilityCooperativeMatrixNV = 5357, + SpvCapabilityFragmentShaderSampleInterlockEXT = 5363, + SpvCapabilityFragmentShaderShadingRateInterlockEXT = 5372, + SpvCapabilityShaderSMBuiltinsNV = 5373, + SpvCapabilityFragmentShaderPixelInterlockEXT = 5378, + SpvCapabilityDemoteToHelperInvocationEXT = 5379, + SpvCapabilitySubgroupShuffleINTEL = 5568, + SpvCapabilitySubgroupBufferBlockIOINTEL = 5569, + SpvCapabilitySubgroupImageBlockIOINTEL = 5570, + SpvCapabilitySubgroupImageMediaBlockIOINTEL = 5579, + SpvCapabilityIntegerFunctions2INTEL = 5584, + SpvCapabilitySubgroupAvcMotionEstimationINTEL = 5696, + SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, + SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, + SpvCapabilityMax = 0x7fffffff, +} SpvCapability; + +typedef enum SpvRayFlagsShift_ { + SpvRayFlagsOpaqueKHRShift = 0, + SpvRayFlagsNoOpaqueKHRShift = 1, + SpvRayFlagsTerminateOnFirstHitKHRShift = 2, + SpvRayFlagsSkipClosestHitShaderKHRShift = 3, + SpvRayFlagsCullBackFacingTrianglesKHRShift = 4, + SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5, + SpvRayFlagsCullOpaqueKHRShift = 6, + SpvRayFlagsCullNoOpaqueKHRShift = 7, + SpvRayFlagsSkipTrianglesKHRShift = 8, + SpvRayFlagsSkipAABBsKHRShift = 9, + SpvRayFlagsMax = 0x7fffffff, +} SpvRayFlagsShift; + +typedef enum SpvRayFlagsMask_ { + SpvRayFlagsMaskNone = 0, + SpvRayFlagsOpaqueKHRMask = 0x00000001, + SpvRayFlagsNoOpaqueKHRMask = 0x00000002, + SpvRayFlagsTerminateOnFirstHitKHRMask = 0x00000004, + SpvRayFlagsSkipClosestHitShaderKHRMask = 0x00000008, + SpvRayFlagsCullBackFacingTrianglesKHRMask = 0x00000010, + SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020, + SpvRayFlagsCullOpaqueKHRMask = 0x00000040, + SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080, + SpvRayFlagsSkipTrianglesKHRMask = 0x00000100, + SpvRayFlagsSkipAABBsKHRMask = 0x00000200, +} SpvRayFlagsMask; + +typedef enum SpvRayQueryIntersection_ { + SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR = 0, + SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR = 1, + SpvRayQueryIntersectionMax = 0x7fffffff, +} SpvRayQueryIntersection; + +typedef enum SpvRayQueryCommittedIntersectionType_ { + SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0, + SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1, + SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2, + SpvRayQueryCommittedIntersectionTypeMax = 0x7fffffff, +} SpvRayQueryCommittedIntersectionType; + +typedef enum SpvRayQueryCandidateIntersectionType_ { + SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0, + SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1, + SpvRayQueryCandidateIntersectionTypeMax = 0x7fffffff, +} SpvRayQueryCandidateIntersectionType; + +typedef enum SpvOp_ { + SpvOpNop = 0, + SpvOpUndef = 1, + SpvOpSourceContinued = 2, + SpvOpSource = 3, + SpvOpSourceExtension = 4, + SpvOpName = 5, + SpvOpMemberName = 6, + SpvOpString = 7, + SpvOpLine = 8, + SpvOpExtension = 10, + SpvOpExtInstImport = 11, + SpvOpExtInst = 12, + SpvOpMemoryModel = 14, + SpvOpEntryPoint = 15, + SpvOpExecutionMode = 16, + SpvOpCapability = 17, + SpvOpTypeVoid = 19, + SpvOpTypeBool = 20, + SpvOpTypeInt = 21, + SpvOpTypeFloat = 22, + SpvOpTypeVector = 23, + SpvOpTypeMatrix = 24, + SpvOpTypeImage = 25, + SpvOpTypeSampler = 26, + SpvOpTypeSampledImage = 27, + SpvOpTypeArray = 28, + SpvOpTypeRuntimeArray = 29, + SpvOpTypeStruct = 30, + SpvOpTypeOpaque = 31, + SpvOpTypePointer = 32, + SpvOpTypeFunction = 33, + SpvOpTypeEvent = 34, + SpvOpTypeDeviceEvent = 35, + SpvOpTypeReserveId = 36, + SpvOpTypeQueue = 37, + SpvOpTypePipe = 38, + SpvOpTypeForwardPointer = 39, + SpvOpConstantTrue = 41, + SpvOpConstantFalse = 42, + SpvOpConstant = 43, + SpvOpConstantComposite = 44, + SpvOpConstantSampler = 45, + SpvOpConstantNull = 46, + SpvOpSpecConstantTrue = 48, + SpvOpSpecConstantFalse = 49, + SpvOpSpecConstant = 50, + SpvOpSpecConstantComposite = 51, + SpvOpSpecConstantOp = 52, + SpvOpFunction = 54, + SpvOpFunctionParameter = 55, + SpvOpFunctionEnd = 56, + SpvOpFunctionCall = 57, + SpvOpVariable = 59, + SpvOpImageTexelPointer = 60, + SpvOpLoad = 61, + SpvOpStore = 62, + SpvOpCopyMemory = 63, + SpvOpCopyMemorySized = 64, + SpvOpAccessChain = 65, + SpvOpInBoundsAccessChain = 66, + SpvOpPtrAccessChain = 67, + SpvOpArrayLength = 68, + SpvOpGenericPtrMemSemantics = 69, + SpvOpInBoundsPtrAccessChain = 70, + SpvOpDecorate = 71, + SpvOpMemberDecorate = 72, + SpvOpDecorationGroup = 73, + SpvOpGroupDecorate = 74, + SpvOpGroupMemberDecorate = 75, + SpvOpVectorExtractDynamic = 77, + SpvOpVectorInsertDynamic = 78, + SpvOpVectorShuffle = 79, + SpvOpCompositeConstruct = 80, + SpvOpCompositeExtract = 81, + SpvOpCompositeInsert = 82, + SpvOpCopyObject = 83, + SpvOpTranspose = 84, + SpvOpSampledImage = 86, + SpvOpImageSampleImplicitLod = 87, + SpvOpImageSampleExplicitLod = 88, + SpvOpImageSampleDrefImplicitLod = 89, + SpvOpImageSampleDrefExplicitLod = 90, + SpvOpImageSampleProjImplicitLod = 91, + SpvOpImageSampleProjExplicitLod = 92, + SpvOpImageSampleProjDrefImplicitLod = 93, + SpvOpImageSampleProjDrefExplicitLod = 94, + SpvOpImageFetch = 95, + SpvOpImageGather = 96, + SpvOpImageDrefGather = 97, + SpvOpImageRead = 98, + SpvOpImageWrite = 99, + SpvOpImage = 100, + SpvOpImageQueryFormat = 101, + SpvOpImageQueryOrder = 102, + SpvOpImageQuerySizeLod = 103, + SpvOpImageQuerySize = 104, + SpvOpImageQueryLod = 105, + SpvOpImageQueryLevels = 106, + SpvOpImageQuerySamples = 107, + SpvOpConvertFToU = 109, + SpvOpConvertFToS = 110, + SpvOpConvertSToF = 111, + SpvOpConvertUToF = 112, + SpvOpUConvert = 113, + SpvOpSConvert = 114, + SpvOpFConvert = 115, + SpvOpQuantizeToF16 = 116, + SpvOpConvertPtrToU = 117, + SpvOpSatConvertSToU = 118, + SpvOpSatConvertUToS = 119, + SpvOpConvertUToPtr = 120, + SpvOpPtrCastToGeneric = 121, + SpvOpGenericCastToPtr = 122, + SpvOpGenericCastToPtrExplicit = 123, + SpvOpBitcast = 124, + SpvOpSNegate = 126, + SpvOpFNegate = 127, + SpvOpIAdd = 128, + SpvOpFAdd = 129, + SpvOpISub = 130, + SpvOpFSub = 131, + SpvOpIMul = 132, + SpvOpFMul = 133, + SpvOpUDiv = 134, + SpvOpSDiv = 135, + SpvOpFDiv = 136, + SpvOpUMod = 137, + SpvOpSRem = 138, + SpvOpSMod = 139, + SpvOpFRem = 140, + SpvOpFMod = 141, + SpvOpVectorTimesScalar = 142, + SpvOpMatrixTimesScalar = 143, + SpvOpVectorTimesMatrix = 144, + SpvOpMatrixTimesVector = 145, + SpvOpMatrixTimesMatrix = 146, + SpvOpOuterProduct = 147, + SpvOpDot = 148, + SpvOpIAddCarry = 149, + SpvOpISubBorrow = 150, + SpvOpUMulExtended = 151, + SpvOpSMulExtended = 152, + SpvOpAny = 154, + SpvOpAll = 155, + SpvOpIsNan = 156, + SpvOpIsInf = 157, + SpvOpIsFinite = 158, + SpvOpIsNormal = 159, + SpvOpSignBitSet = 160, + SpvOpLessOrGreater = 161, + SpvOpOrdered = 162, + SpvOpUnordered = 163, + SpvOpLogicalEqual = 164, + SpvOpLogicalNotEqual = 165, + SpvOpLogicalOr = 166, + SpvOpLogicalAnd = 167, + SpvOpLogicalNot = 168, + SpvOpSelect = 169, + SpvOpIEqual = 170, + SpvOpINotEqual = 171, + SpvOpUGreaterThan = 172, + SpvOpSGreaterThan = 173, + SpvOpUGreaterThanEqual = 174, + SpvOpSGreaterThanEqual = 175, + SpvOpULessThan = 176, + SpvOpSLessThan = 177, + SpvOpULessThanEqual = 178, + SpvOpSLessThanEqual = 179, + SpvOpFOrdEqual = 180, + SpvOpFUnordEqual = 181, + SpvOpFOrdNotEqual = 182, + SpvOpFUnordNotEqual = 183, + SpvOpFOrdLessThan = 184, + SpvOpFUnordLessThan = 185, + SpvOpFOrdGreaterThan = 186, + SpvOpFUnordGreaterThan = 187, + SpvOpFOrdLessThanEqual = 188, + SpvOpFUnordLessThanEqual = 189, + SpvOpFOrdGreaterThanEqual = 190, + SpvOpFUnordGreaterThanEqual = 191, + SpvOpShiftRightLogical = 194, + SpvOpShiftRightArithmetic = 195, + SpvOpShiftLeftLogical = 196, + SpvOpBitwiseOr = 197, + SpvOpBitwiseXor = 198, + SpvOpBitwiseAnd = 199, + SpvOpNot = 200, + SpvOpBitFieldInsert = 201, + SpvOpBitFieldSExtract = 202, + SpvOpBitFieldUExtract = 203, + SpvOpBitReverse = 204, + SpvOpBitCount = 205, + SpvOpDPdx = 207, + SpvOpDPdy = 208, + SpvOpFwidth = 209, + SpvOpDPdxFine = 210, + SpvOpDPdyFine = 211, + SpvOpFwidthFine = 212, + SpvOpDPdxCoarse = 213, + SpvOpDPdyCoarse = 214, + SpvOpFwidthCoarse = 215, + SpvOpEmitVertex = 218, + SpvOpEndPrimitive = 219, + SpvOpEmitStreamVertex = 220, + SpvOpEndStreamPrimitive = 221, + SpvOpControlBarrier = 224, + SpvOpMemoryBarrier = 225, + SpvOpAtomicLoad = 227, + SpvOpAtomicStore = 228, + SpvOpAtomicExchange = 229, + SpvOpAtomicCompareExchange = 230, + SpvOpAtomicCompareExchangeWeak = 231, + SpvOpAtomicIIncrement = 232, + SpvOpAtomicIDecrement = 233, + SpvOpAtomicIAdd = 234, + SpvOpAtomicISub = 235, + SpvOpAtomicSMin = 236, + SpvOpAtomicUMin = 237, + SpvOpAtomicSMax = 238, + SpvOpAtomicUMax = 239, + SpvOpAtomicAnd = 240, + SpvOpAtomicOr = 241, + SpvOpAtomicXor = 242, + SpvOpPhi = 245, + SpvOpLoopMerge = 246, + SpvOpSelectionMerge = 247, + SpvOpLabel = 248, + SpvOpBranch = 249, + SpvOpBranchConditional = 250, + SpvOpSwitch = 251, + SpvOpKill = 252, + SpvOpReturn = 253, + SpvOpReturnValue = 254, + SpvOpUnreachable = 255, + SpvOpLifetimeStart = 256, + SpvOpLifetimeStop = 257, + SpvOpGroupAsyncCopy = 259, + SpvOpGroupWaitEvents = 260, + SpvOpGroupAll = 261, + SpvOpGroupAny = 262, + SpvOpGroupBroadcast = 263, + SpvOpGroupIAdd = 264, + SpvOpGroupFAdd = 265, + SpvOpGroupFMin = 266, + SpvOpGroupUMin = 267, + SpvOpGroupSMin = 268, + SpvOpGroupFMax = 269, + SpvOpGroupUMax = 270, + SpvOpGroupSMax = 271, + SpvOpReadPipe = 274, + SpvOpWritePipe = 275, + SpvOpReservedReadPipe = 276, + SpvOpReservedWritePipe = 277, + SpvOpReserveReadPipePackets = 278, + SpvOpReserveWritePipePackets = 279, + SpvOpCommitReadPipe = 280, + SpvOpCommitWritePipe = 281, + SpvOpIsValidReserveId = 282, + SpvOpGetNumPipePackets = 283, + SpvOpGetMaxPipePackets = 284, + SpvOpGroupReserveReadPipePackets = 285, + SpvOpGroupReserveWritePipePackets = 286, + SpvOpGroupCommitReadPipe = 287, + SpvOpGroupCommitWritePipe = 288, + SpvOpEnqueueMarker = 291, + SpvOpEnqueueKernel = 292, + SpvOpGetKernelNDrangeSubGroupCount = 293, + SpvOpGetKernelNDrangeMaxSubGroupSize = 294, + SpvOpGetKernelWorkGroupSize = 295, + SpvOpGetKernelPreferredWorkGroupSizeMultiple = 296, + SpvOpRetainEvent = 297, + SpvOpReleaseEvent = 298, + SpvOpCreateUserEvent = 299, + SpvOpIsValidEvent = 300, + SpvOpSetUserEventStatus = 301, + SpvOpCaptureEventProfilingInfo = 302, + SpvOpGetDefaultQueue = 303, + SpvOpBuildNDRange = 304, + SpvOpImageSparseSampleImplicitLod = 305, + SpvOpImageSparseSampleExplicitLod = 306, + SpvOpImageSparseSampleDrefImplicitLod = 307, + SpvOpImageSparseSampleDrefExplicitLod = 308, + SpvOpImageSparseSampleProjImplicitLod = 309, + SpvOpImageSparseSampleProjExplicitLod = 310, + SpvOpImageSparseSampleProjDrefImplicitLod = 311, + SpvOpImageSparseSampleProjDrefExplicitLod = 312, + SpvOpImageSparseFetch = 313, + SpvOpImageSparseGather = 314, + SpvOpImageSparseDrefGather = 315, + SpvOpImageSparseTexelsResident = 316, + SpvOpNoLine = 317, + SpvOpAtomicFlagTestAndSet = 318, + SpvOpAtomicFlagClear = 319, + SpvOpImageSparseRead = 320, + SpvOpSizeOf = 321, + SpvOpTypePipeStorage = 322, + SpvOpConstantPipeStorage = 323, + SpvOpCreatePipeFromPipeStorage = 324, + SpvOpGetKernelLocalSizeForSubgroupCount = 325, + SpvOpGetKernelMaxNumSubgroups = 326, + SpvOpTypeNamedBarrier = 327, + SpvOpNamedBarrierInitialize = 328, + SpvOpMemoryNamedBarrier = 329, + SpvOpModuleProcessed = 330, + SpvOpExecutionModeId = 331, + SpvOpDecorateId = 332, + SpvOpGroupNonUniformElect = 333, + SpvOpGroupNonUniformAll = 334, + SpvOpGroupNonUniformAny = 335, + SpvOpGroupNonUniformAllEqual = 336, + SpvOpGroupNonUniformBroadcast = 337, + SpvOpGroupNonUniformBroadcastFirst = 338, + SpvOpGroupNonUniformBallot = 339, + SpvOpGroupNonUniformInverseBallot = 340, + SpvOpGroupNonUniformBallotBitExtract = 341, + SpvOpGroupNonUniformBallotBitCount = 342, + SpvOpGroupNonUniformBallotFindLSB = 343, + SpvOpGroupNonUniformBallotFindMSB = 344, + SpvOpGroupNonUniformShuffle = 345, + SpvOpGroupNonUniformShuffleXor = 346, + SpvOpGroupNonUniformShuffleUp = 347, + SpvOpGroupNonUniformShuffleDown = 348, + SpvOpGroupNonUniformIAdd = 349, + SpvOpGroupNonUniformFAdd = 350, + SpvOpGroupNonUniformIMul = 351, + SpvOpGroupNonUniformFMul = 352, + SpvOpGroupNonUniformSMin = 353, + SpvOpGroupNonUniformUMin = 354, + SpvOpGroupNonUniformFMin = 355, + SpvOpGroupNonUniformSMax = 356, + SpvOpGroupNonUniformUMax = 357, + SpvOpGroupNonUniformFMax = 358, + SpvOpGroupNonUniformBitwiseAnd = 359, + SpvOpGroupNonUniformBitwiseOr = 360, + SpvOpGroupNonUniformBitwiseXor = 361, + SpvOpGroupNonUniformLogicalAnd = 362, + SpvOpGroupNonUniformLogicalOr = 363, + SpvOpGroupNonUniformLogicalXor = 364, + SpvOpGroupNonUniformQuadBroadcast = 365, + SpvOpGroupNonUniformQuadSwap = 366, + SpvOpCopyLogical = 400, + SpvOpPtrEqual = 401, + SpvOpPtrNotEqual = 402, + SpvOpPtrDiff = 403, + SpvOpSubgroupBallotKHR = 4421, + SpvOpSubgroupFirstInvocationKHR = 4422, + SpvOpSubgroupAllKHR = 4428, + SpvOpSubgroupAnyKHR = 4429, + SpvOpSubgroupAllEqualKHR = 4430, + SpvOpSubgroupReadInvocationKHR = 4432, + SpvOpTypeRayQueryProvisionalKHR = 4472, + SpvOpRayQueryInitializeKHR = 4473, + SpvOpRayQueryTerminateKHR = 4474, + SpvOpRayQueryGenerateIntersectionKHR = 4475, + SpvOpRayQueryConfirmIntersectionKHR = 4476, + SpvOpRayQueryProceedKHR = 4477, + SpvOpRayQueryGetIntersectionTypeKHR = 4479, + SpvOpGroupIAddNonUniformAMD = 5000, + SpvOpGroupFAddNonUniformAMD = 5001, + SpvOpGroupFMinNonUniformAMD = 5002, + SpvOpGroupUMinNonUniformAMD = 5003, + SpvOpGroupSMinNonUniformAMD = 5004, + SpvOpGroupFMaxNonUniformAMD = 5005, + SpvOpGroupUMaxNonUniformAMD = 5006, + SpvOpGroupSMaxNonUniformAMD = 5007, + SpvOpFragmentMaskFetchAMD = 5011, + SpvOpFragmentFetchAMD = 5012, + SpvOpReadClockKHR = 5056, + SpvOpImageSampleFootprintNV = 5283, + SpvOpGroupNonUniformPartitionNV = 5296, + SpvOpWritePackedPrimitiveIndices4x8NV = 5299, + SpvOpReportIntersectionKHR = 5334, + SpvOpReportIntersectionNV = 5334, + SpvOpIgnoreIntersectionKHR = 5335, + SpvOpIgnoreIntersectionNV = 5335, + SpvOpTerminateRayKHR = 5336, + SpvOpTerminateRayNV = 5336, + SpvOpTraceNV = 5337, + SpvOpTraceRayKHR = 5337, + SpvOpTypeAccelerationStructureKHR = 5341, + SpvOpTypeAccelerationStructureNV = 5341, + SpvOpExecuteCallableKHR = 5344, + SpvOpExecuteCallableNV = 5344, + SpvOpTypeCooperativeMatrixNV = 5358, + SpvOpCooperativeMatrixLoadNV = 5359, + SpvOpCooperativeMatrixStoreNV = 5360, + SpvOpCooperativeMatrixMulAddNV = 5361, + SpvOpCooperativeMatrixLengthNV = 5362, + SpvOpBeginInvocationInterlockEXT = 5364, + SpvOpEndInvocationInterlockEXT = 5365, + SpvOpDemoteToHelperInvocationEXT = 5380, + SpvOpIsHelperInvocationEXT = 5381, + SpvOpSubgroupShuffleINTEL = 5571, + SpvOpSubgroupShuffleDownINTEL = 5572, + SpvOpSubgroupShuffleUpINTEL = 5573, + SpvOpSubgroupShuffleXorINTEL = 5574, + SpvOpSubgroupBlockReadINTEL = 5575, + SpvOpSubgroupBlockWriteINTEL = 5576, + SpvOpSubgroupImageBlockReadINTEL = 5577, + SpvOpSubgroupImageBlockWriteINTEL = 5578, + SpvOpSubgroupImageMediaBlockReadINTEL = 5580, + SpvOpSubgroupImageMediaBlockWriteINTEL = 5581, + SpvOpUCountLeadingZerosINTEL = 5585, + SpvOpUCountTrailingZerosINTEL = 5586, + SpvOpAbsISubINTEL = 5587, + SpvOpAbsUSubINTEL = 5588, + SpvOpIAddSatINTEL = 5589, + SpvOpUAddSatINTEL = 5590, + SpvOpIAverageINTEL = 5591, + SpvOpUAverageINTEL = 5592, + SpvOpIAverageRoundedINTEL = 5593, + SpvOpUAverageRoundedINTEL = 5594, + SpvOpISubSatINTEL = 5595, + SpvOpUSubSatINTEL = 5596, + SpvOpIMul32x16INTEL = 5597, + SpvOpUMul32x16INTEL = 5598, + SpvOpDecorateString = 5632, + SpvOpDecorateStringGOOGLE = 5632, + SpvOpMemberDecorateString = 5633, + SpvOpMemberDecorateStringGOOGLE = 5633, + SpvOpVmeImageINTEL = 5699, + SpvOpTypeVmeImageINTEL = 5700, + SpvOpTypeAvcImePayloadINTEL = 5701, + SpvOpTypeAvcRefPayloadINTEL = 5702, + SpvOpTypeAvcSicPayloadINTEL = 5703, + SpvOpTypeAvcMcePayloadINTEL = 5704, + SpvOpTypeAvcMceResultINTEL = 5705, + SpvOpTypeAvcImeResultINTEL = 5706, + SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, + SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, + SpvOpTypeAvcImeSingleReferenceStreaminINTEL = 5709, + SpvOpTypeAvcImeDualReferenceStreaminINTEL = 5710, + SpvOpTypeAvcRefResultINTEL = 5711, + SpvOpTypeAvcSicResultINTEL = 5712, + SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, + SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, + SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, + SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, + SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, + SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, + SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, + SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, + SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, + SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, + SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, + SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, + SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, + SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, + SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, + SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, + SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, + SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, + SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, + SpvOpSubgroupAvcMceConvertToImePayloadINTEL = 5732, + SpvOpSubgroupAvcMceConvertToImeResultINTEL = 5733, + SpvOpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, + SpvOpSubgroupAvcMceConvertToRefResultINTEL = 5735, + SpvOpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, + SpvOpSubgroupAvcMceConvertToSicResultINTEL = 5737, + SpvOpSubgroupAvcMceGetMotionVectorsINTEL = 5738, + SpvOpSubgroupAvcMceGetInterDistortionsINTEL = 5739, + SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, + SpvOpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, + SpvOpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, + SpvOpSubgroupAvcMceGetInterDirectionsINTEL = 5743, + SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, + SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, + SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, + SpvOpSubgroupAvcImeInitializeINTEL = 5747, + SpvOpSubgroupAvcImeSetSingleReferenceINTEL = 5748, + SpvOpSubgroupAvcImeSetDualReferenceINTEL = 5749, + SpvOpSubgroupAvcImeRefWindowSizeINTEL = 5750, + SpvOpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, + SpvOpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, + SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, + SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, + SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, + SpvOpSubgroupAvcImeSetWeightedSadINTEL = 5756, + SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, + SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, + SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, + SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, + SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, + SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, + SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, + SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, + SpvOpSubgroupAvcImeConvertToMceResultINTEL = 5765, + SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, + SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, + SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, + SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, + SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, + SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, + SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, + SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, + SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, + SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, + SpvOpSubgroupAvcImeGetBorderReachedINTEL = 5776, + SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, + SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, + SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, + SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, + SpvOpSubgroupAvcFmeInitializeINTEL = 5781, + SpvOpSubgroupAvcBmeInitializeINTEL = 5782, + SpvOpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, + SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, + SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, + SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, + SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, + SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, + SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, + SpvOpSubgroupAvcRefConvertToMceResultINTEL = 5790, + SpvOpSubgroupAvcSicInitializeINTEL = 5791, + SpvOpSubgroupAvcSicConfigureSkcINTEL = 5792, + SpvOpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, + SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, + SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, + SpvOpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, + SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, + SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, + SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, + SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, + SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, + SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, + SpvOpSubgroupAvcSicEvaluateIpeINTEL = 5803, + SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, + SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, + SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, + SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, + SpvOpSubgroupAvcSicConvertToMceResultINTEL = 5808, + SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, + SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, + SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, + SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, + SpvOpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, + SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, + SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, + SpvOpSubgroupAvcSicGetInterRawSadsINTEL = 5816, + SpvOpRayQueryGetRayTMinKHR = 6016, + SpvOpRayQueryGetRayFlagsKHR = 6017, + SpvOpRayQueryGetIntersectionTKHR = 6018, + SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019, + SpvOpRayQueryGetIntersectionInstanceIdKHR = 6020, + SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021, + SpvOpRayQueryGetIntersectionGeometryIndexKHR = 6022, + SpvOpRayQueryGetIntersectionPrimitiveIndexKHR = 6023, + SpvOpRayQueryGetIntersectionBarycentricsKHR = 6024, + SpvOpRayQueryGetIntersectionFrontFaceKHR = 6025, + SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026, + SpvOpRayQueryGetIntersectionObjectRayDirectionKHR = 6027, + SpvOpRayQueryGetIntersectionObjectRayOriginKHR = 6028, + SpvOpRayQueryGetWorldRayDirectionKHR = 6029, + SpvOpRayQueryGetWorldRayOriginKHR = 6030, + SpvOpRayQueryGetIntersectionObjectToWorldKHR = 6031, + SpvOpRayQueryGetIntersectionWorldToObjectKHR = 6032, + SpvOpMax = 0x7fffffff, +} SpvOp; + +#ifdef SPV_ENABLE_UTILITY_CODE +inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultType) { + *hasResult = *hasResultType = false; + switch (opcode) { + default: /* unknown opcode */ break; + case SpvOpNop: *hasResult = false; *hasResultType = false; break; + case SpvOpUndef: *hasResult = true; *hasResultType = true; break; + case SpvOpSourceContinued: *hasResult = false; *hasResultType = false; break; + case SpvOpSource: *hasResult = false; *hasResultType = false; break; + case SpvOpSourceExtension: *hasResult = false; *hasResultType = false; break; + case SpvOpName: *hasResult = false; *hasResultType = false; break; + case SpvOpMemberName: *hasResult = false; *hasResultType = false; break; + case SpvOpString: *hasResult = true; *hasResultType = false; break; + case SpvOpLine: *hasResult = false; *hasResultType = false; break; + case SpvOpExtension: *hasResult = false; *hasResultType = false; break; + case SpvOpExtInstImport: *hasResult = true; *hasResultType = false; break; + case SpvOpExtInst: *hasResult = true; *hasResultType = true; break; + case SpvOpMemoryModel: *hasResult = false; *hasResultType = false; break; + case SpvOpEntryPoint: *hasResult = false; *hasResultType = false; break; + case SpvOpExecutionMode: *hasResult = false; *hasResultType = false; break; + case SpvOpCapability: *hasResult = false; *hasResultType = false; break; + case SpvOpTypeVoid: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeBool: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeInt: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeFloat: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeVector: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeMatrix: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeImage: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeSampler: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeSampledImage: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeArray: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeStruct: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeOpaque: *hasResult = true; *hasResultType = false; break; + case SpvOpTypePointer: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeFunction: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeEvent: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeReserveId: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeQueue: *hasResult = true; *hasResultType = false; break; + case SpvOpTypePipe: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; + case SpvOpConstantTrue: *hasResult = true; *hasResultType = true; break; + case SpvOpConstantFalse: *hasResult = true; *hasResultType = true; break; + case SpvOpConstant: *hasResult = true; *hasResultType = true; break; + case SpvOpConstantComposite: *hasResult = true; *hasResultType = true; break; + case SpvOpConstantSampler: *hasResult = true; *hasResultType = true; break; + case SpvOpConstantNull: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstant: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstantOp: *hasResult = true; *hasResultType = true; break; + case SpvOpFunction: *hasResult = true; *hasResultType = true; break; + case SpvOpFunctionParameter: *hasResult = true; *hasResultType = true; break; + case SpvOpFunctionEnd: *hasResult = false; *hasResultType = false; break; + case SpvOpFunctionCall: *hasResult = true; *hasResultType = true; break; + case SpvOpVariable: *hasResult = true; *hasResultType = true; break; + case SpvOpImageTexelPointer: *hasResult = true; *hasResultType = true; break; + case SpvOpLoad: *hasResult = true; *hasResultType = true; break; + case SpvOpStore: *hasResult = false; *hasResultType = false; break; + case SpvOpCopyMemory: *hasResult = false; *hasResultType = false; break; + case SpvOpCopyMemorySized: *hasResult = false; *hasResultType = false; break; + case SpvOpAccessChain: *hasResult = true; *hasResultType = true; break; + case SpvOpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; + case SpvOpPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case SpvOpArrayLength: *hasResult = true; *hasResultType = true; break; + case SpvOpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; + case SpvOpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case SpvOpDecorate: *hasResult = false; *hasResultType = false; break; + case SpvOpMemberDecorate: *hasResult = false; *hasResultType = false; break; + case SpvOpDecorationGroup: *hasResult = true; *hasResultType = false; break; + case SpvOpGroupDecorate: *hasResult = false; *hasResultType = false; break; + case SpvOpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; + case SpvOpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; + case SpvOpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; + case SpvOpVectorShuffle: *hasResult = true; *hasResultType = true; break; + case SpvOpCompositeConstruct: *hasResult = true; *hasResultType = true; break; + case SpvOpCompositeExtract: *hasResult = true; *hasResultType = true; break; + case SpvOpCompositeInsert: *hasResult = true; *hasResultType = true; break; + case SpvOpCopyObject: *hasResult = true; *hasResultType = true; break; + case SpvOpTranspose: *hasResult = true; *hasResultType = true; break; + case SpvOpSampledImage: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageFetch: *hasResult = true; *hasResultType = true; break; + case SpvOpImageGather: *hasResult = true; *hasResultType = true; break; + case SpvOpImageDrefGather: *hasResult = true; *hasResultType = true; break; + case SpvOpImageRead: *hasResult = true; *hasResultType = true; break; + case SpvOpImageWrite: *hasResult = false; *hasResultType = false; break; + case SpvOpImage: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQueryFormat: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQueryOrder: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQuerySize: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQueryLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQueryLevels: *hasResult = true; *hasResultType = true; break; + case SpvOpImageQuerySamples: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertFToU: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertFToS: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertSToF: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertUToF: *hasResult = true; *hasResultType = true; break; + case SpvOpUConvert: *hasResult = true; *hasResultType = true; break; + case SpvOpSConvert: *hasResult = true; *hasResultType = true; break; + case SpvOpFConvert: *hasResult = true; *hasResultType = true; break; + case SpvOpQuantizeToF16: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertPtrToU: *hasResult = true; *hasResultType = true; break; + case SpvOpSatConvertSToU: *hasResult = true; *hasResultType = true; break; + case SpvOpSatConvertUToS: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertUToPtr: *hasResult = true; *hasResultType = true; break; + case SpvOpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; + case SpvOpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; + case SpvOpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; + case SpvOpBitcast: *hasResult = true; *hasResultType = true; break; + case SpvOpSNegate: *hasResult = true; *hasResultType = true; break; + case SpvOpFNegate: *hasResult = true; *hasResultType = true; break; + case SpvOpIAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpFAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpISub: *hasResult = true; *hasResultType = true; break; + case SpvOpFSub: *hasResult = true; *hasResultType = true; break; + case SpvOpIMul: *hasResult = true; *hasResultType = true; break; + case SpvOpFMul: *hasResult = true; *hasResultType = true; break; + case SpvOpUDiv: *hasResult = true; *hasResultType = true; break; + case SpvOpSDiv: *hasResult = true; *hasResultType = true; break; + case SpvOpFDiv: *hasResult = true; *hasResultType = true; break; + case SpvOpUMod: *hasResult = true; *hasResultType = true; break; + case SpvOpSRem: *hasResult = true; *hasResultType = true; break; + case SpvOpSMod: *hasResult = true; *hasResultType = true; break; + case SpvOpFRem: *hasResult = true; *hasResultType = true; break; + case SpvOpFMod: *hasResult = true; *hasResultType = true; break; + case SpvOpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; + case SpvOpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; + case SpvOpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; + case SpvOpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; + case SpvOpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; + case SpvOpOuterProduct: *hasResult = true; *hasResultType = true; break; + case SpvOpDot: *hasResult = true; *hasResultType = true; break; + case SpvOpIAddCarry: *hasResult = true; *hasResultType = true; break; + case SpvOpISubBorrow: *hasResult = true; *hasResultType = true; break; + case SpvOpUMulExtended: *hasResult = true; *hasResultType = true; break; + case SpvOpSMulExtended: *hasResult = true; *hasResultType = true; break; + case SpvOpAny: *hasResult = true; *hasResultType = true; break; + case SpvOpAll: *hasResult = true; *hasResultType = true; break; + case SpvOpIsNan: *hasResult = true; *hasResultType = true; break; + case SpvOpIsInf: *hasResult = true; *hasResultType = true; break; + case SpvOpIsFinite: *hasResult = true; *hasResultType = true; break; + case SpvOpIsNormal: *hasResult = true; *hasResultType = true; break; + case SpvOpSignBitSet: *hasResult = true; *hasResultType = true; break; + case SpvOpLessOrGreater: *hasResult = true; *hasResultType = true; break; + case SpvOpOrdered: *hasResult = true; *hasResultType = true; break; + case SpvOpUnordered: *hasResult = true; *hasResultType = true; break; + case SpvOpLogicalEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpLogicalOr: *hasResult = true; *hasResultType = true; break; + case SpvOpLogicalAnd: *hasResult = true; *hasResultType = true; break; + case SpvOpLogicalNot: *hasResult = true; *hasResultType = true; break; + case SpvOpSelect: *hasResult = true; *hasResultType = true; break; + case SpvOpIEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpINotEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpUGreaterThan: *hasResult = true; *hasResultType = true; break; + case SpvOpSGreaterThan: *hasResult = true; *hasResultType = true; break; + case SpvOpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpULessThan: *hasResult = true; *hasResultType = true; break; + case SpvOpSLessThan: *hasResult = true; *hasResultType = true; break; + case SpvOpULessThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpSLessThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFOrdEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFUnordEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFOrdLessThan: *hasResult = true; *hasResultType = true; break; + case SpvOpFUnordLessThan: *hasResult = true; *hasResultType = true; break; + case SpvOpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; + case SpvOpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; + case SpvOpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpShiftRightLogical: *hasResult = true; *hasResultType = true; break; + case SpvOpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; + case SpvOpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; + case SpvOpBitwiseOr: *hasResult = true; *hasResultType = true; break; + case SpvOpBitwiseXor: *hasResult = true; *hasResultType = true; break; + case SpvOpBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case SpvOpNot: *hasResult = true; *hasResultType = true; break; + case SpvOpBitFieldInsert: *hasResult = true; *hasResultType = true; break; + case SpvOpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; + case SpvOpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; + case SpvOpBitReverse: *hasResult = true; *hasResultType = true; break; + case SpvOpBitCount: *hasResult = true; *hasResultType = true; break; + case SpvOpDPdx: *hasResult = true; *hasResultType = true; break; + case SpvOpDPdy: *hasResult = true; *hasResultType = true; break; + case SpvOpFwidth: *hasResult = true; *hasResultType = true; break; + case SpvOpDPdxFine: *hasResult = true; *hasResultType = true; break; + case SpvOpDPdyFine: *hasResult = true; *hasResultType = true; break; + case SpvOpFwidthFine: *hasResult = true; *hasResultType = true; break; + case SpvOpDPdxCoarse: *hasResult = true; *hasResultType = true; break; + case SpvOpDPdyCoarse: *hasResult = true; *hasResultType = true; break; + case SpvOpFwidthCoarse: *hasResult = true; *hasResultType = true; break; + case SpvOpEmitVertex: *hasResult = false; *hasResultType = false; break; + case SpvOpEndPrimitive: *hasResult = false; *hasResultType = false; break; + case SpvOpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; + case SpvOpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; + case SpvOpControlBarrier: *hasResult = false; *hasResultType = false; break; + case SpvOpMemoryBarrier: *hasResult = false; *hasResultType = false; break; + case SpvOpAtomicLoad: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicStore: *hasResult = false; *hasResultType = false; break; + case SpvOpAtomicExchange: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicIAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicISub: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicSMin: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicUMin: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicSMax: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicUMax: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicAnd: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicOr: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicXor: *hasResult = true; *hasResultType = true; break; + case SpvOpPhi: *hasResult = true; *hasResultType = true; break; + case SpvOpLoopMerge: *hasResult = false; *hasResultType = false; break; + case SpvOpSelectionMerge: *hasResult = false; *hasResultType = false; break; + case SpvOpLabel: *hasResult = true; *hasResultType = false; break; + case SpvOpBranch: *hasResult = false; *hasResultType = false; break; + case SpvOpBranchConditional: *hasResult = false; *hasResultType = false; break; + case SpvOpSwitch: *hasResult = false; *hasResultType = false; break; + case SpvOpKill: *hasResult = false; *hasResultType = false; break; + case SpvOpReturn: *hasResult = false; *hasResultType = false; break; + case SpvOpReturnValue: *hasResult = false; *hasResultType = false; break; + case SpvOpUnreachable: *hasResult = false; *hasResultType = false; break; + case SpvOpLifetimeStart: *hasResult = false; *hasResultType = false; break; + case SpvOpLifetimeStop: *hasResult = false; *hasResultType = false; break; + case SpvOpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; + case SpvOpGroupAll: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupAny: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupBroadcast: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupIAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupFAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupFMin: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupUMin: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupSMin: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupFMax: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupUMax: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupSMax: *hasResult = true; *hasResultType = true; break; + case SpvOpReadPipe: *hasResult = true; *hasResultType = true; break; + case SpvOpWritePipe: *hasResult = true; *hasResultType = true; break; + case SpvOpReservedReadPipe: *hasResult = true; *hasResultType = true; break; + case SpvOpReservedWritePipe: *hasResult = true; *hasResultType = true; break; + case SpvOpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case SpvOpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case SpvOpCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case SpvOpCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case SpvOpIsValidReserveId: *hasResult = true; *hasResultType = true; break; + case SpvOpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; + case SpvOpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case SpvOpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case SpvOpEnqueueMarker: *hasResult = true; *hasResultType = true; break; + case SpvOpEnqueueKernel: *hasResult = true; *hasResultType = true; break; + case SpvOpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; + case SpvOpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; + case SpvOpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; + case SpvOpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; + case SpvOpRetainEvent: *hasResult = false; *hasResultType = false; break; + case SpvOpReleaseEvent: *hasResult = false; *hasResultType = false; break; + case SpvOpCreateUserEvent: *hasResult = true; *hasResultType = true; break; + case SpvOpIsValidEvent: *hasResult = true; *hasResultType = true; break; + case SpvOpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; + case SpvOpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; + case SpvOpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; + case SpvOpBuildNDRange: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseFetch: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseGather: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; + case SpvOpNoLine: *hasResult = false; *hasResultType = false; break; + case SpvOpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; + case SpvOpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; + case SpvOpImageSparseRead: *hasResult = true; *hasResultType = true; break; + case SpvOpSizeOf: *hasResult = true; *hasResultType = true; break; + case SpvOpTypePipeStorage: *hasResult = true; *hasResultType = false; break; + case SpvOpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; + case SpvOpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; + case SpvOpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; + case SpvOpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; + case SpvOpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; + case SpvOpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; + case SpvOpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; + case SpvOpModuleProcessed: *hasResult = false; *hasResultType = false; break; + case SpvOpExecutionModeId: *hasResult = false; *hasResultType = false; break; + case SpvOpDecorateId: *hasResult = false; *hasResultType = false; break; + case SpvOpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; + case SpvOpCopyLogical: *hasResult = true; *hasResultType = true; break; + case SpvOpPtrEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpPtrNotEqual: *hasResult = true; *hasResultType = true; break; + case SpvOpPtrDiff: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; + case SpvOpReadClockKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; + case SpvOpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case SpvOpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; + case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break; + case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; + case SpvOpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; + case SpvOpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; + case SpvOpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; + case SpvOpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case SpvOpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case SpvOpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; + case SpvOpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpIAverageINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUAverageINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpISubSatINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpDecorateString: *hasResult = false; *hasResultType = false; break; + case SpvOpMemberDecorateString: *hasResult = false; *hasResultType = false; break; + case SpvOpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; + case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; + } +} +#endif /* SPV_ENABLE_UTILITY_CODE */ + +#endif + diff --git a/ios/include/spirv_cross/spirv.hpp b/ios/include/spirv_cross/spirv.hpp new file mode 100644 index 00000000..9f98683d --- /dev/null +++ b/ios/include/spirv_cross/spirv.hpp @@ -0,0 +1,2114 @@ +// Copyright (c) 2014-2020 The Khronos Group Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and/or associated documentation files (the "Materials"), +// to deal in the Materials without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Materials, and to permit persons to whom the +// Materials are 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 Materials. +// +// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS +// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND +// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +// +// THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS +// IN THE MATERIALS. + +// This header is automatically generated by the same tool that creates +// the Binary Section of the SPIR-V specification. + +// Enumeration tokens for SPIR-V, in various styles: +// C, C++, C++11, JSON, Lua, Python, C#, D +// +// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL +// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL +// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL +// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL +// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] +// - C# will use enum classes in the Specification class located in the "Spv" namespace, +// e.g.: Spv.Specification.SourceLanguage.GLSL +// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL +// +// Some tokens act like mask values, which can be OR'd together, +// while others are mutually exclusive. The mask-like ones have +// "Mask" in their name, and a parallel enum that has the shift +// amount (1 << x) for each corresponding enumerant. + +#ifndef spirv_HPP +#define spirv_HPP + +namespace spv { + +typedef unsigned int Id; + +#define SPV_VERSION 0x10500 +#define SPV_REVISION 1 + +static const unsigned int MagicNumber = 0x07230203; +static const unsigned int Version = 0x00010500; +static const unsigned int Revision = 1; +static const unsigned int OpCodeMask = 0xffff; +static const unsigned int WordCountShift = 16; + +enum SourceLanguage { + SourceLanguageUnknown = 0, + SourceLanguageESSL = 1, + SourceLanguageGLSL = 2, + SourceLanguageOpenCL_C = 3, + SourceLanguageOpenCL_CPP = 4, + SourceLanguageHLSL = 5, + SourceLanguageMax = 0x7fffffff, +}; + +enum ExecutionModel { + ExecutionModelVertex = 0, + ExecutionModelTessellationControl = 1, + ExecutionModelTessellationEvaluation = 2, + ExecutionModelGeometry = 3, + ExecutionModelFragment = 4, + ExecutionModelGLCompute = 5, + ExecutionModelKernel = 6, + ExecutionModelTaskNV = 5267, + ExecutionModelMeshNV = 5268, + ExecutionModelRayGenerationKHR = 5313, + ExecutionModelRayGenerationNV = 5313, + ExecutionModelIntersectionKHR = 5314, + ExecutionModelIntersectionNV = 5314, + ExecutionModelAnyHitKHR = 5315, + ExecutionModelAnyHitNV = 5315, + ExecutionModelClosestHitKHR = 5316, + ExecutionModelClosestHitNV = 5316, + ExecutionModelMissKHR = 5317, + ExecutionModelMissNV = 5317, + ExecutionModelCallableKHR = 5318, + ExecutionModelCallableNV = 5318, + ExecutionModelMax = 0x7fffffff, +}; + +enum AddressingModel { + AddressingModelLogical = 0, + AddressingModelPhysical32 = 1, + AddressingModelPhysical64 = 2, + AddressingModelPhysicalStorageBuffer64 = 5348, + AddressingModelPhysicalStorageBuffer64EXT = 5348, + AddressingModelMax = 0x7fffffff, +}; + +enum MemoryModel { + MemoryModelSimple = 0, + MemoryModelGLSL450 = 1, + MemoryModelOpenCL = 2, + MemoryModelVulkan = 3, + MemoryModelVulkanKHR = 3, + MemoryModelMax = 0x7fffffff, +}; + +enum ExecutionMode { + ExecutionModeInvocations = 0, + ExecutionModeSpacingEqual = 1, + ExecutionModeSpacingFractionalEven = 2, + ExecutionModeSpacingFractionalOdd = 3, + ExecutionModeVertexOrderCw = 4, + ExecutionModeVertexOrderCcw = 5, + ExecutionModePixelCenterInteger = 6, + ExecutionModeOriginUpperLeft = 7, + ExecutionModeOriginLowerLeft = 8, + ExecutionModeEarlyFragmentTests = 9, + ExecutionModePointMode = 10, + ExecutionModeXfb = 11, + ExecutionModeDepthReplacing = 12, + ExecutionModeDepthGreater = 14, + ExecutionModeDepthLess = 15, + ExecutionModeDepthUnchanged = 16, + ExecutionModeLocalSize = 17, + ExecutionModeLocalSizeHint = 18, + ExecutionModeInputPoints = 19, + ExecutionModeInputLines = 20, + ExecutionModeInputLinesAdjacency = 21, + ExecutionModeTriangles = 22, + ExecutionModeInputTrianglesAdjacency = 23, + ExecutionModeQuads = 24, + ExecutionModeIsolines = 25, + ExecutionModeOutputVertices = 26, + ExecutionModeOutputPoints = 27, + ExecutionModeOutputLineStrip = 28, + ExecutionModeOutputTriangleStrip = 29, + ExecutionModeVecTypeHint = 30, + ExecutionModeContractionOff = 31, + ExecutionModeInitializer = 33, + ExecutionModeFinalizer = 34, + ExecutionModeSubgroupSize = 35, + ExecutionModeSubgroupsPerWorkgroup = 36, + ExecutionModeSubgroupsPerWorkgroupId = 37, + ExecutionModeLocalSizeId = 38, + ExecutionModeLocalSizeHintId = 39, + ExecutionModePostDepthCoverage = 4446, + ExecutionModeDenormPreserve = 4459, + ExecutionModeDenormFlushToZero = 4460, + ExecutionModeSignedZeroInfNanPreserve = 4461, + ExecutionModeRoundingModeRTE = 4462, + ExecutionModeRoundingModeRTZ = 4463, + ExecutionModeStencilRefReplacingEXT = 5027, + ExecutionModeOutputLinesNV = 5269, + ExecutionModeOutputPrimitivesNV = 5270, + ExecutionModeDerivativeGroupQuadsNV = 5289, + ExecutionModeDerivativeGroupLinearNV = 5290, + ExecutionModeOutputTrianglesNV = 5298, + ExecutionModePixelInterlockOrderedEXT = 5366, + ExecutionModePixelInterlockUnorderedEXT = 5367, + ExecutionModeSampleInterlockOrderedEXT = 5368, + ExecutionModeSampleInterlockUnorderedEXT = 5369, + ExecutionModeShadingRateInterlockOrderedEXT = 5370, + ExecutionModeShadingRateInterlockUnorderedEXT = 5371, + ExecutionModeMax = 0x7fffffff, +}; + +enum StorageClass { + StorageClassUniformConstant = 0, + StorageClassInput = 1, + StorageClassUniform = 2, + StorageClassOutput = 3, + StorageClassWorkgroup = 4, + StorageClassCrossWorkgroup = 5, + StorageClassPrivate = 6, + StorageClassFunction = 7, + StorageClassGeneric = 8, + StorageClassPushConstant = 9, + StorageClassAtomicCounter = 10, + StorageClassImage = 11, + StorageClassStorageBuffer = 12, + StorageClassCallableDataKHR = 5328, + StorageClassCallableDataNV = 5328, + StorageClassIncomingCallableDataKHR = 5329, + StorageClassIncomingCallableDataNV = 5329, + StorageClassRayPayloadKHR = 5338, + StorageClassRayPayloadNV = 5338, + StorageClassHitAttributeKHR = 5339, + StorageClassHitAttributeNV = 5339, + StorageClassIncomingRayPayloadKHR = 5342, + StorageClassIncomingRayPayloadNV = 5342, + StorageClassShaderRecordBufferKHR = 5343, + StorageClassShaderRecordBufferNV = 5343, + StorageClassPhysicalStorageBuffer = 5349, + StorageClassPhysicalStorageBufferEXT = 5349, + StorageClassMax = 0x7fffffff, +}; + +enum Dim { + Dim1D = 0, + Dim2D = 1, + Dim3D = 2, + DimCube = 3, + DimRect = 4, + DimBuffer = 5, + DimSubpassData = 6, + DimMax = 0x7fffffff, +}; + +enum SamplerAddressingMode { + SamplerAddressingModeNone = 0, + SamplerAddressingModeClampToEdge = 1, + SamplerAddressingModeClamp = 2, + SamplerAddressingModeRepeat = 3, + SamplerAddressingModeRepeatMirrored = 4, + SamplerAddressingModeMax = 0x7fffffff, +}; + +enum SamplerFilterMode { + SamplerFilterModeNearest = 0, + SamplerFilterModeLinear = 1, + SamplerFilterModeMax = 0x7fffffff, +}; + +enum ImageFormat { + ImageFormatUnknown = 0, + ImageFormatRgba32f = 1, + ImageFormatRgba16f = 2, + ImageFormatR32f = 3, + ImageFormatRgba8 = 4, + ImageFormatRgba8Snorm = 5, + ImageFormatRg32f = 6, + ImageFormatRg16f = 7, + ImageFormatR11fG11fB10f = 8, + ImageFormatR16f = 9, + ImageFormatRgba16 = 10, + ImageFormatRgb10A2 = 11, + ImageFormatRg16 = 12, + ImageFormatRg8 = 13, + ImageFormatR16 = 14, + ImageFormatR8 = 15, + ImageFormatRgba16Snorm = 16, + ImageFormatRg16Snorm = 17, + ImageFormatRg8Snorm = 18, + ImageFormatR16Snorm = 19, + ImageFormatR8Snorm = 20, + ImageFormatRgba32i = 21, + ImageFormatRgba16i = 22, + ImageFormatRgba8i = 23, + ImageFormatR32i = 24, + ImageFormatRg32i = 25, + ImageFormatRg16i = 26, + ImageFormatRg8i = 27, + ImageFormatR16i = 28, + ImageFormatR8i = 29, + ImageFormatRgba32ui = 30, + ImageFormatRgba16ui = 31, + ImageFormatRgba8ui = 32, + ImageFormatR32ui = 33, + ImageFormatRgb10a2ui = 34, + ImageFormatRg32ui = 35, + ImageFormatRg16ui = 36, + ImageFormatRg8ui = 37, + ImageFormatR16ui = 38, + ImageFormatR8ui = 39, + ImageFormatMax = 0x7fffffff, +}; + +enum ImageChannelOrder { + ImageChannelOrderR = 0, + ImageChannelOrderA = 1, + ImageChannelOrderRG = 2, + ImageChannelOrderRA = 3, + ImageChannelOrderRGB = 4, + ImageChannelOrderRGBA = 5, + ImageChannelOrderBGRA = 6, + ImageChannelOrderARGB = 7, + ImageChannelOrderIntensity = 8, + ImageChannelOrderLuminance = 9, + ImageChannelOrderRx = 10, + ImageChannelOrderRGx = 11, + ImageChannelOrderRGBx = 12, + ImageChannelOrderDepth = 13, + ImageChannelOrderDepthStencil = 14, + ImageChannelOrdersRGB = 15, + ImageChannelOrdersRGBx = 16, + ImageChannelOrdersRGBA = 17, + ImageChannelOrdersBGRA = 18, + ImageChannelOrderABGR = 19, + ImageChannelOrderMax = 0x7fffffff, +}; + +enum ImageChannelDataType { + ImageChannelDataTypeSnormInt8 = 0, + ImageChannelDataTypeSnormInt16 = 1, + ImageChannelDataTypeUnormInt8 = 2, + ImageChannelDataTypeUnormInt16 = 3, + ImageChannelDataTypeUnormShort565 = 4, + ImageChannelDataTypeUnormShort555 = 5, + ImageChannelDataTypeUnormInt101010 = 6, + ImageChannelDataTypeSignedInt8 = 7, + ImageChannelDataTypeSignedInt16 = 8, + ImageChannelDataTypeSignedInt32 = 9, + ImageChannelDataTypeUnsignedInt8 = 10, + ImageChannelDataTypeUnsignedInt16 = 11, + ImageChannelDataTypeUnsignedInt32 = 12, + ImageChannelDataTypeHalfFloat = 13, + ImageChannelDataTypeFloat = 14, + ImageChannelDataTypeUnormInt24 = 15, + ImageChannelDataTypeUnormInt101010_2 = 16, + ImageChannelDataTypeMax = 0x7fffffff, +}; + +enum ImageOperandsShift { + ImageOperandsBiasShift = 0, + ImageOperandsLodShift = 1, + ImageOperandsGradShift = 2, + ImageOperandsConstOffsetShift = 3, + ImageOperandsOffsetShift = 4, + ImageOperandsConstOffsetsShift = 5, + ImageOperandsSampleShift = 6, + ImageOperandsMinLodShift = 7, + ImageOperandsMakeTexelAvailableShift = 8, + ImageOperandsMakeTexelAvailableKHRShift = 8, + ImageOperandsMakeTexelVisibleShift = 9, + ImageOperandsMakeTexelVisibleKHRShift = 9, + ImageOperandsNonPrivateTexelShift = 10, + ImageOperandsNonPrivateTexelKHRShift = 10, + ImageOperandsVolatileTexelShift = 11, + ImageOperandsVolatileTexelKHRShift = 11, + ImageOperandsSignExtendShift = 12, + ImageOperandsZeroExtendShift = 13, + ImageOperandsMax = 0x7fffffff, +}; + +enum ImageOperandsMask { + ImageOperandsMaskNone = 0, + ImageOperandsBiasMask = 0x00000001, + ImageOperandsLodMask = 0x00000002, + ImageOperandsGradMask = 0x00000004, + ImageOperandsConstOffsetMask = 0x00000008, + ImageOperandsOffsetMask = 0x00000010, + ImageOperandsConstOffsetsMask = 0x00000020, + ImageOperandsSampleMask = 0x00000040, + ImageOperandsMinLodMask = 0x00000080, + ImageOperandsMakeTexelAvailableMask = 0x00000100, + ImageOperandsMakeTexelAvailableKHRMask = 0x00000100, + ImageOperandsMakeTexelVisibleMask = 0x00000200, + ImageOperandsMakeTexelVisibleKHRMask = 0x00000200, + ImageOperandsNonPrivateTexelMask = 0x00000400, + ImageOperandsNonPrivateTexelKHRMask = 0x00000400, + ImageOperandsVolatileTexelMask = 0x00000800, + ImageOperandsVolatileTexelKHRMask = 0x00000800, + ImageOperandsSignExtendMask = 0x00001000, + ImageOperandsZeroExtendMask = 0x00002000, +}; + +enum FPFastMathModeShift { + FPFastMathModeNotNaNShift = 0, + FPFastMathModeNotInfShift = 1, + FPFastMathModeNSZShift = 2, + FPFastMathModeAllowRecipShift = 3, + FPFastMathModeFastShift = 4, + FPFastMathModeMax = 0x7fffffff, +}; + +enum FPFastMathModeMask { + FPFastMathModeMaskNone = 0, + FPFastMathModeNotNaNMask = 0x00000001, + FPFastMathModeNotInfMask = 0x00000002, + FPFastMathModeNSZMask = 0x00000004, + FPFastMathModeAllowRecipMask = 0x00000008, + FPFastMathModeFastMask = 0x00000010, +}; + +enum FPRoundingMode { + FPRoundingModeRTE = 0, + FPRoundingModeRTZ = 1, + FPRoundingModeRTP = 2, + FPRoundingModeRTN = 3, + FPRoundingModeMax = 0x7fffffff, +}; + +enum LinkageType { + LinkageTypeExport = 0, + LinkageTypeImport = 1, + LinkageTypeMax = 0x7fffffff, +}; + +enum AccessQualifier { + AccessQualifierReadOnly = 0, + AccessQualifierWriteOnly = 1, + AccessQualifierReadWrite = 2, + AccessQualifierMax = 0x7fffffff, +}; + +enum FunctionParameterAttribute { + FunctionParameterAttributeZext = 0, + FunctionParameterAttributeSext = 1, + FunctionParameterAttributeByVal = 2, + FunctionParameterAttributeSret = 3, + FunctionParameterAttributeNoAlias = 4, + FunctionParameterAttributeNoCapture = 5, + FunctionParameterAttributeNoWrite = 6, + FunctionParameterAttributeNoReadWrite = 7, + FunctionParameterAttributeMax = 0x7fffffff, +}; + +enum Decoration { + DecorationRelaxedPrecision = 0, + DecorationSpecId = 1, + DecorationBlock = 2, + DecorationBufferBlock = 3, + DecorationRowMajor = 4, + DecorationColMajor = 5, + DecorationArrayStride = 6, + DecorationMatrixStride = 7, + DecorationGLSLShared = 8, + DecorationGLSLPacked = 9, + DecorationCPacked = 10, + DecorationBuiltIn = 11, + DecorationNoPerspective = 13, + DecorationFlat = 14, + DecorationPatch = 15, + DecorationCentroid = 16, + DecorationSample = 17, + DecorationInvariant = 18, + DecorationRestrict = 19, + DecorationAliased = 20, + DecorationVolatile = 21, + DecorationConstant = 22, + DecorationCoherent = 23, + DecorationNonWritable = 24, + DecorationNonReadable = 25, + DecorationUniform = 26, + DecorationUniformId = 27, + DecorationSaturatedConversion = 28, + DecorationStream = 29, + DecorationLocation = 30, + DecorationComponent = 31, + DecorationIndex = 32, + DecorationBinding = 33, + DecorationDescriptorSet = 34, + DecorationOffset = 35, + DecorationXfbBuffer = 36, + DecorationXfbStride = 37, + DecorationFuncParamAttr = 38, + DecorationFPRoundingMode = 39, + DecorationFPFastMathMode = 40, + DecorationLinkageAttributes = 41, + DecorationNoContraction = 42, + DecorationInputAttachmentIndex = 43, + DecorationAlignment = 44, + DecorationMaxByteOffset = 45, + DecorationAlignmentId = 46, + DecorationMaxByteOffsetId = 47, + DecorationNoSignedWrap = 4469, + DecorationNoUnsignedWrap = 4470, + DecorationExplicitInterpAMD = 4999, + DecorationOverrideCoverageNV = 5248, + DecorationPassthroughNV = 5250, + DecorationViewportRelativeNV = 5252, + DecorationSecondaryViewportRelativeNV = 5256, + DecorationPerPrimitiveNV = 5271, + DecorationPerViewNV = 5272, + DecorationPerTaskNV = 5273, + DecorationPerVertexNV = 5285, + DecorationNonUniform = 5300, + DecorationNonUniformEXT = 5300, + DecorationRestrictPointer = 5355, + DecorationRestrictPointerEXT = 5355, + DecorationAliasedPointer = 5356, + DecorationAliasedPointerEXT = 5356, + DecorationCounterBuffer = 5634, + DecorationHlslCounterBufferGOOGLE = 5634, + DecorationHlslSemanticGOOGLE = 5635, + DecorationUserSemantic = 5635, + DecorationUserTypeGOOGLE = 5636, + DecorationMax = 0x7fffffff, +}; + +enum BuiltIn { + BuiltInPosition = 0, + BuiltInPointSize = 1, + BuiltInClipDistance = 3, + BuiltInCullDistance = 4, + BuiltInVertexId = 5, + BuiltInInstanceId = 6, + BuiltInPrimitiveId = 7, + BuiltInInvocationId = 8, + BuiltInLayer = 9, + BuiltInViewportIndex = 10, + BuiltInTessLevelOuter = 11, + BuiltInTessLevelInner = 12, + BuiltInTessCoord = 13, + BuiltInPatchVertices = 14, + BuiltInFragCoord = 15, + BuiltInPointCoord = 16, + BuiltInFrontFacing = 17, + BuiltInSampleId = 18, + BuiltInSamplePosition = 19, + BuiltInSampleMask = 20, + BuiltInFragDepth = 22, + BuiltInHelperInvocation = 23, + BuiltInNumWorkgroups = 24, + BuiltInWorkgroupSize = 25, + BuiltInWorkgroupId = 26, + BuiltInLocalInvocationId = 27, + BuiltInGlobalInvocationId = 28, + BuiltInLocalInvocationIndex = 29, + BuiltInWorkDim = 30, + BuiltInGlobalSize = 31, + BuiltInEnqueuedWorkgroupSize = 32, + BuiltInGlobalOffset = 33, + BuiltInGlobalLinearId = 34, + BuiltInSubgroupSize = 36, + BuiltInSubgroupMaxSize = 37, + BuiltInNumSubgroups = 38, + BuiltInNumEnqueuedSubgroups = 39, + BuiltInSubgroupId = 40, + BuiltInSubgroupLocalInvocationId = 41, + BuiltInVertexIndex = 42, + BuiltInInstanceIndex = 43, + BuiltInSubgroupEqMask = 4416, + BuiltInSubgroupEqMaskKHR = 4416, + BuiltInSubgroupGeMask = 4417, + BuiltInSubgroupGeMaskKHR = 4417, + BuiltInSubgroupGtMask = 4418, + BuiltInSubgroupGtMaskKHR = 4418, + BuiltInSubgroupLeMask = 4419, + BuiltInSubgroupLeMaskKHR = 4419, + BuiltInSubgroupLtMask = 4420, + BuiltInSubgroupLtMaskKHR = 4420, + BuiltInBaseVertex = 4424, + BuiltInBaseInstance = 4425, + BuiltInDrawIndex = 4426, + BuiltInDeviceIndex = 4438, + BuiltInViewIndex = 4440, + BuiltInBaryCoordNoPerspAMD = 4992, + BuiltInBaryCoordNoPerspCentroidAMD = 4993, + BuiltInBaryCoordNoPerspSampleAMD = 4994, + BuiltInBaryCoordSmoothAMD = 4995, + BuiltInBaryCoordSmoothCentroidAMD = 4996, + BuiltInBaryCoordSmoothSampleAMD = 4997, + BuiltInBaryCoordPullModelAMD = 4998, + BuiltInFragStencilRefEXT = 5014, + BuiltInViewportMaskNV = 5253, + BuiltInSecondaryPositionNV = 5257, + BuiltInSecondaryViewportMaskNV = 5258, + BuiltInPositionPerViewNV = 5261, + BuiltInViewportMaskPerViewNV = 5262, + BuiltInFullyCoveredEXT = 5264, + BuiltInTaskCountNV = 5274, + BuiltInPrimitiveCountNV = 5275, + BuiltInPrimitiveIndicesNV = 5276, + BuiltInClipDistancePerViewNV = 5277, + BuiltInCullDistancePerViewNV = 5278, + BuiltInLayerPerViewNV = 5279, + BuiltInMeshViewCountNV = 5280, + BuiltInMeshViewIndicesNV = 5281, + BuiltInBaryCoordNV = 5286, + BuiltInBaryCoordNoPerspNV = 5287, + BuiltInFragSizeEXT = 5292, + BuiltInFragmentSizeNV = 5292, + BuiltInFragInvocationCountEXT = 5293, + BuiltInInvocationsPerPixelNV = 5293, + BuiltInLaunchIdKHR = 5319, + BuiltInLaunchIdNV = 5319, + BuiltInLaunchSizeKHR = 5320, + BuiltInLaunchSizeNV = 5320, + BuiltInWorldRayOriginKHR = 5321, + BuiltInWorldRayOriginNV = 5321, + BuiltInWorldRayDirectionKHR = 5322, + BuiltInWorldRayDirectionNV = 5322, + BuiltInObjectRayOriginKHR = 5323, + BuiltInObjectRayOriginNV = 5323, + BuiltInObjectRayDirectionKHR = 5324, + BuiltInObjectRayDirectionNV = 5324, + BuiltInRayTminKHR = 5325, + BuiltInRayTminNV = 5325, + BuiltInRayTmaxKHR = 5326, + BuiltInRayTmaxNV = 5326, + BuiltInInstanceCustomIndexKHR = 5327, + BuiltInInstanceCustomIndexNV = 5327, + BuiltInObjectToWorldKHR = 5330, + BuiltInObjectToWorldNV = 5330, + BuiltInWorldToObjectKHR = 5331, + BuiltInWorldToObjectNV = 5331, + BuiltInHitTKHR = 5332, + BuiltInHitTNV = 5332, + BuiltInHitKindKHR = 5333, + BuiltInHitKindNV = 5333, + BuiltInIncomingRayFlagsKHR = 5351, + BuiltInIncomingRayFlagsNV = 5351, + BuiltInRayGeometryIndexKHR = 5352, + BuiltInWarpsPerSMNV = 5374, + BuiltInSMCountNV = 5375, + BuiltInWarpIDNV = 5376, + BuiltInSMIDNV = 5377, + BuiltInMax = 0x7fffffff, +}; + +enum SelectionControlShift { + SelectionControlFlattenShift = 0, + SelectionControlDontFlattenShift = 1, + SelectionControlMax = 0x7fffffff, +}; + +enum SelectionControlMask { + SelectionControlMaskNone = 0, + SelectionControlFlattenMask = 0x00000001, + SelectionControlDontFlattenMask = 0x00000002, +}; + +enum LoopControlShift { + LoopControlUnrollShift = 0, + LoopControlDontUnrollShift = 1, + LoopControlDependencyInfiniteShift = 2, + LoopControlDependencyLengthShift = 3, + LoopControlMinIterationsShift = 4, + LoopControlMaxIterationsShift = 5, + LoopControlIterationMultipleShift = 6, + LoopControlPeelCountShift = 7, + LoopControlPartialCountShift = 8, + LoopControlMax = 0x7fffffff, +}; + +enum LoopControlMask { + LoopControlMaskNone = 0, + LoopControlUnrollMask = 0x00000001, + LoopControlDontUnrollMask = 0x00000002, + LoopControlDependencyInfiniteMask = 0x00000004, + LoopControlDependencyLengthMask = 0x00000008, + LoopControlMinIterationsMask = 0x00000010, + LoopControlMaxIterationsMask = 0x00000020, + LoopControlIterationMultipleMask = 0x00000040, + LoopControlPeelCountMask = 0x00000080, + LoopControlPartialCountMask = 0x00000100, +}; + +enum FunctionControlShift { + FunctionControlInlineShift = 0, + FunctionControlDontInlineShift = 1, + FunctionControlPureShift = 2, + FunctionControlConstShift = 3, + FunctionControlMax = 0x7fffffff, +}; + +enum FunctionControlMask { + FunctionControlMaskNone = 0, + FunctionControlInlineMask = 0x00000001, + FunctionControlDontInlineMask = 0x00000002, + FunctionControlPureMask = 0x00000004, + FunctionControlConstMask = 0x00000008, +}; + +enum MemorySemanticsShift { + MemorySemanticsAcquireShift = 1, + MemorySemanticsReleaseShift = 2, + MemorySemanticsAcquireReleaseShift = 3, + MemorySemanticsSequentiallyConsistentShift = 4, + MemorySemanticsUniformMemoryShift = 6, + MemorySemanticsSubgroupMemoryShift = 7, + MemorySemanticsWorkgroupMemoryShift = 8, + MemorySemanticsCrossWorkgroupMemoryShift = 9, + MemorySemanticsAtomicCounterMemoryShift = 10, + MemorySemanticsImageMemoryShift = 11, + MemorySemanticsOutputMemoryShift = 12, + MemorySemanticsOutputMemoryKHRShift = 12, + MemorySemanticsMakeAvailableShift = 13, + MemorySemanticsMakeAvailableKHRShift = 13, + MemorySemanticsMakeVisibleShift = 14, + MemorySemanticsMakeVisibleKHRShift = 14, + MemorySemanticsVolatileShift = 15, + MemorySemanticsMax = 0x7fffffff, +}; + +enum MemorySemanticsMask { + MemorySemanticsMaskNone = 0, + MemorySemanticsAcquireMask = 0x00000002, + MemorySemanticsReleaseMask = 0x00000004, + MemorySemanticsAcquireReleaseMask = 0x00000008, + MemorySemanticsSequentiallyConsistentMask = 0x00000010, + MemorySemanticsUniformMemoryMask = 0x00000040, + MemorySemanticsSubgroupMemoryMask = 0x00000080, + MemorySemanticsWorkgroupMemoryMask = 0x00000100, + MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, + MemorySemanticsAtomicCounterMemoryMask = 0x00000400, + MemorySemanticsImageMemoryMask = 0x00000800, + MemorySemanticsOutputMemoryMask = 0x00001000, + MemorySemanticsOutputMemoryKHRMask = 0x00001000, + MemorySemanticsMakeAvailableMask = 0x00002000, + MemorySemanticsMakeAvailableKHRMask = 0x00002000, + MemorySemanticsMakeVisibleMask = 0x00004000, + MemorySemanticsMakeVisibleKHRMask = 0x00004000, + MemorySemanticsVolatileMask = 0x00008000, +}; + +enum MemoryAccessShift { + MemoryAccessVolatileShift = 0, + MemoryAccessAlignedShift = 1, + MemoryAccessNontemporalShift = 2, + MemoryAccessMakePointerAvailableShift = 3, + MemoryAccessMakePointerAvailableKHRShift = 3, + MemoryAccessMakePointerVisibleShift = 4, + MemoryAccessMakePointerVisibleKHRShift = 4, + MemoryAccessNonPrivatePointerShift = 5, + MemoryAccessNonPrivatePointerKHRShift = 5, + MemoryAccessMax = 0x7fffffff, +}; + +enum MemoryAccessMask { + MemoryAccessMaskNone = 0, + MemoryAccessVolatileMask = 0x00000001, + MemoryAccessAlignedMask = 0x00000002, + MemoryAccessNontemporalMask = 0x00000004, + MemoryAccessMakePointerAvailableMask = 0x00000008, + MemoryAccessMakePointerAvailableKHRMask = 0x00000008, + MemoryAccessMakePointerVisibleMask = 0x00000010, + MemoryAccessMakePointerVisibleKHRMask = 0x00000010, + MemoryAccessNonPrivatePointerMask = 0x00000020, + MemoryAccessNonPrivatePointerKHRMask = 0x00000020, +}; + +enum Scope { + ScopeCrossDevice = 0, + ScopeDevice = 1, + ScopeWorkgroup = 2, + ScopeSubgroup = 3, + ScopeInvocation = 4, + ScopeQueueFamily = 5, + ScopeQueueFamilyKHR = 5, + ScopeShaderCallKHR = 6, + ScopeMax = 0x7fffffff, +}; + +enum GroupOperation { + GroupOperationReduce = 0, + GroupOperationInclusiveScan = 1, + GroupOperationExclusiveScan = 2, + GroupOperationClusteredReduce = 3, + GroupOperationPartitionedReduceNV = 6, + GroupOperationPartitionedInclusiveScanNV = 7, + GroupOperationPartitionedExclusiveScanNV = 8, + GroupOperationMax = 0x7fffffff, +}; + +enum KernelEnqueueFlags { + KernelEnqueueFlagsNoWait = 0, + KernelEnqueueFlagsWaitKernel = 1, + KernelEnqueueFlagsWaitWorkGroup = 2, + KernelEnqueueFlagsMax = 0x7fffffff, +}; + +enum KernelProfilingInfoShift { + KernelProfilingInfoCmdExecTimeShift = 0, + KernelProfilingInfoMax = 0x7fffffff, +}; + +enum KernelProfilingInfoMask { + KernelProfilingInfoMaskNone = 0, + KernelProfilingInfoCmdExecTimeMask = 0x00000001, +}; + +enum Capability { + CapabilityMatrix = 0, + CapabilityShader = 1, + CapabilityGeometry = 2, + CapabilityTessellation = 3, + CapabilityAddresses = 4, + CapabilityLinkage = 5, + CapabilityKernel = 6, + CapabilityVector16 = 7, + CapabilityFloat16Buffer = 8, + CapabilityFloat16 = 9, + CapabilityFloat64 = 10, + CapabilityInt64 = 11, + CapabilityInt64Atomics = 12, + CapabilityImageBasic = 13, + CapabilityImageReadWrite = 14, + CapabilityImageMipmap = 15, + CapabilityPipes = 17, + CapabilityGroups = 18, + CapabilityDeviceEnqueue = 19, + CapabilityLiteralSampler = 20, + CapabilityAtomicStorage = 21, + CapabilityInt16 = 22, + CapabilityTessellationPointSize = 23, + CapabilityGeometryPointSize = 24, + CapabilityImageGatherExtended = 25, + CapabilityStorageImageMultisample = 27, + CapabilityUniformBufferArrayDynamicIndexing = 28, + CapabilitySampledImageArrayDynamicIndexing = 29, + CapabilityStorageBufferArrayDynamicIndexing = 30, + CapabilityStorageImageArrayDynamicIndexing = 31, + CapabilityClipDistance = 32, + CapabilityCullDistance = 33, + CapabilityImageCubeArray = 34, + CapabilitySampleRateShading = 35, + CapabilityImageRect = 36, + CapabilitySampledRect = 37, + CapabilityGenericPointer = 38, + CapabilityInt8 = 39, + CapabilityInputAttachment = 40, + CapabilitySparseResidency = 41, + CapabilityMinLod = 42, + CapabilitySampled1D = 43, + CapabilityImage1D = 44, + CapabilitySampledCubeArray = 45, + CapabilitySampledBuffer = 46, + CapabilityImageBuffer = 47, + CapabilityImageMSArray = 48, + CapabilityStorageImageExtendedFormats = 49, + CapabilityImageQuery = 50, + CapabilityDerivativeControl = 51, + CapabilityInterpolationFunction = 52, + CapabilityTransformFeedback = 53, + CapabilityGeometryStreams = 54, + CapabilityStorageImageReadWithoutFormat = 55, + CapabilityStorageImageWriteWithoutFormat = 56, + CapabilityMultiViewport = 57, + CapabilitySubgroupDispatch = 58, + CapabilityNamedBarrier = 59, + CapabilityPipeStorage = 60, + CapabilityGroupNonUniform = 61, + CapabilityGroupNonUniformVote = 62, + CapabilityGroupNonUniformArithmetic = 63, + CapabilityGroupNonUniformBallot = 64, + CapabilityGroupNonUniformShuffle = 65, + CapabilityGroupNonUniformShuffleRelative = 66, + CapabilityGroupNonUniformClustered = 67, + CapabilityGroupNonUniformQuad = 68, + CapabilityShaderLayer = 69, + CapabilityShaderViewportIndex = 70, + CapabilitySubgroupBallotKHR = 4423, + CapabilityDrawParameters = 4427, + CapabilitySubgroupVoteKHR = 4431, + CapabilityStorageBuffer16BitAccess = 4433, + CapabilityStorageUniformBufferBlock16 = 4433, + CapabilityStorageUniform16 = 4434, + CapabilityUniformAndStorageBuffer16BitAccess = 4434, + CapabilityStoragePushConstant16 = 4435, + CapabilityStorageInputOutput16 = 4436, + CapabilityDeviceGroup = 4437, + CapabilityMultiView = 4439, + CapabilityVariablePointersStorageBuffer = 4441, + CapabilityVariablePointers = 4442, + CapabilityAtomicStorageOps = 4445, + CapabilitySampleMaskPostDepthCoverage = 4447, + CapabilityStorageBuffer8BitAccess = 4448, + CapabilityUniformAndStorageBuffer8BitAccess = 4449, + CapabilityStoragePushConstant8 = 4450, + CapabilityDenormPreserve = 4464, + CapabilityDenormFlushToZero = 4465, + CapabilitySignedZeroInfNanPreserve = 4466, + CapabilityRoundingModeRTE = 4467, + CapabilityRoundingModeRTZ = 4468, + CapabilityRayQueryProvisionalKHR = 4471, + CapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478, + CapabilityFloat16ImageAMD = 5008, + CapabilityImageGatherBiasLodAMD = 5009, + CapabilityFragmentMaskAMD = 5010, + CapabilityStencilExportEXT = 5013, + CapabilityImageReadWriteLodAMD = 5015, + CapabilityShaderClockKHR = 5055, + CapabilitySampleMaskOverrideCoverageNV = 5249, + CapabilityGeometryShaderPassthroughNV = 5251, + CapabilityShaderViewportIndexLayerEXT = 5254, + CapabilityShaderViewportIndexLayerNV = 5254, + CapabilityShaderViewportMaskNV = 5255, + CapabilityShaderStereoViewNV = 5259, + CapabilityPerViewAttributesNV = 5260, + CapabilityFragmentFullyCoveredEXT = 5265, + CapabilityMeshShadingNV = 5266, + CapabilityImageFootprintNV = 5282, + CapabilityFragmentBarycentricNV = 5284, + CapabilityComputeDerivativeGroupQuadsNV = 5288, + CapabilityFragmentDensityEXT = 5291, + CapabilityShadingRateNV = 5291, + CapabilityGroupNonUniformPartitionedNV = 5297, + CapabilityShaderNonUniform = 5301, + CapabilityShaderNonUniformEXT = 5301, + CapabilityRuntimeDescriptorArray = 5302, + CapabilityRuntimeDescriptorArrayEXT = 5302, + CapabilityInputAttachmentArrayDynamicIndexing = 5303, + CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, + CapabilityUniformTexelBufferArrayDynamicIndexing = 5304, + CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, + CapabilityStorageTexelBufferArrayDynamicIndexing = 5305, + CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, + CapabilityUniformBufferArrayNonUniformIndexing = 5306, + CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, + CapabilitySampledImageArrayNonUniformIndexing = 5307, + CapabilitySampledImageArrayNonUniformIndexingEXT = 5307, + CapabilityStorageBufferArrayNonUniformIndexing = 5308, + CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, + CapabilityStorageImageArrayNonUniformIndexing = 5309, + CapabilityStorageImageArrayNonUniformIndexingEXT = 5309, + CapabilityInputAttachmentArrayNonUniformIndexing = 5310, + CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, + CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311, + CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, + CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312, + CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, + CapabilityRayTracingNV = 5340, + CapabilityVulkanMemoryModel = 5345, + CapabilityVulkanMemoryModelKHR = 5345, + CapabilityVulkanMemoryModelDeviceScope = 5346, + CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, + CapabilityPhysicalStorageBufferAddresses = 5347, + CapabilityPhysicalStorageBufferAddressesEXT = 5347, + CapabilityComputeDerivativeGroupLinearNV = 5350, + CapabilityRayTracingProvisionalKHR = 5353, + CapabilityCooperativeMatrixNV = 5357, + CapabilityFragmentShaderSampleInterlockEXT = 5363, + CapabilityFragmentShaderShadingRateInterlockEXT = 5372, + CapabilityShaderSMBuiltinsNV = 5373, + CapabilityFragmentShaderPixelInterlockEXT = 5378, + CapabilityDemoteToHelperInvocationEXT = 5379, + CapabilitySubgroupShuffleINTEL = 5568, + CapabilitySubgroupBufferBlockIOINTEL = 5569, + CapabilitySubgroupImageBlockIOINTEL = 5570, + CapabilitySubgroupImageMediaBlockIOINTEL = 5579, + CapabilityIntegerFunctions2INTEL = 5584, + CapabilitySubgroupAvcMotionEstimationINTEL = 5696, + CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, + CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, + CapabilityMax = 0x7fffffff, +}; + +enum RayFlagsShift { + RayFlagsOpaqueKHRShift = 0, + RayFlagsNoOpaqueKHRShift = 1, + RayFlagsTerminateOnFirstHitKHRShift = 2, + RayFlagsSkipClosestHitShaderKHRShift = 3, + RayFlagsCullBackFacingTrianglesKHRShift = 4, + RayFlagsCullFrontFacingTrianglesKHRShift = 5, + RayFlagsCullOpaqueKHRShift = 6, + RayFlagsCullNoOpaqueKHRShift = 7, + RayFlagsSkipTrianglesKHRShift = 8, + RayFlagsSkipAABBsKHRShift = 9, + RayFlagsMax = 0x7fffffff, +}; + +enum RayFlagsMask { + RayFlagsMaskNone = 0, + RayFlagsOpaqueKHRMask = 0x00000001, + RayFlagsNoOpaqueKHRMask = 0x00000002, + RayFlagsTerminateOnFirstHitKHRMask = 0x00000004, + RayFlagsSkipClosestHitShaderKHRMask = 0x00000008, + RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010, + RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020, + RayFlagsCullOpaqueKHRMask = 0x00000040, + RayFlagsCullNoOpaqueKHRMask = 0x00000080, + RayFlagsSkipTrianglesKHRMask = 0x00000100, + RayFlagsSkipAABBsKHRMask = 0x00000200, +}; + +enum RayQueryIntersection { + RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0, + RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1, + RayQueryIntersectionMax = 0x7fffffff, +}; + +enum RayQueryCommittedIntersectionType { + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0, + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1, + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2, + RayQueryCommittedIntersectionTypeMax = 0x7fffffff, +}; + +enum RayQueryCandidateIntersectionType { + RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0, + RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1, + RayQueryCandidateIntersectionTypeMax = 0x7fffffff, +}; + +enum Op { + OpNop = 0, + OpUndef = 1, + OpSourceContinued = 2, + OpSource = 3, + OpSourceExtension = 4, + OpName = 5, + OpMemberName = 6, + OpString = 7, + OpLine = 8, + OpExtension = 10, + OpExtInstImport = 11, + OpExtInst = 12, + OpMemoryModel = 14, + OpEntryPoint = 15, + OpExecutionMode = 16, + OpCapability = 17, + OpTypeVoid = 19, + OpTypeBool = 20, + OpTypeInt = 21, + OpTypeFloat = 22, + OpTypeVector = 23, + OpTypeMatrix = 24, + OpTypeImage = 25, + OpTypeSampler = 26, + OpTypeSampledImage = 27, + OpTypeArray = 28, + OpTypeRuntimeArray = 29, + OpTypeStruct = 30, + OpTypeOpaque = 31, + OpTypePointer = 32, + OpTypeFunction = 33, + OpTypeEvent = 34, + OpTypeDeviceEvent = 35, + OpTypeReserveId = 36, + OpTypeQueue = 37, + OpTypePipe = 38, + OpTypeForwardPointer = 39, + OpConstantTrue = 41, + OpConstantFalse = 42, + OpConstant = 43, + OpConstantComposite = 44, + OpConstantSampler = 45, + OpConstantNull = 46, + OpSpecConstantTrue = 48, + OpSpecConstantFalse = 49, + OpSpecConstant = 50, + OpSpecConstantComposite = 51, + OpSpecConstantOp = 52, + OpFunction = 54, + OpFunctionParameter = 55, + OpFunctionEnd = 56, + OpFunctionCall = 57, + OpVariable = 59, + OpImageTexelPointer = 60, + OpLoad = 61, + OpStore = 62, + OpCopyMemory = 63, + OpCopyMemorySized = 64, + OpAccessChain = 65, + OpInBoundsAccessChain = 66, + OpPtrAccessChain = 67, + OpArrayLength = 68, + OpGenericPtrMemSemantics = 69, + OpInBoundsPtrAccessChain = 70, + OpDecorate = 71, + OpMemberDecorate = 72, + OpDecorationGroup = 73, + OpGroupDecorate = 74, + OpGroupMemberDecorate = 75, + OpVectorExtractDynamic = 77, + OpVectorInsertDynamic = 78, + OpVectorShuffle = 79, + OpCompositeConstruct = 80, + OpCompositeExtract = 81, + OpCompositeInsert = 82, + OpCopyObject = 83, + OpTranspose = 84, + OpSampledImage = 86, + OpImageSampleImplicitLod = 87, + OpImageSampleExplicitLod = 88, + OpImageSampleDrefImplicitLod = 89, + OpImageSampleDrefExplicitLod = 90, + OpImageSampleProjImplicitLod = 91, + OpImageSampleProjExplicitLod = 92, + OpImageSampleProjDrefImplicitLod = 93, + OpImageSampleProjDrefExplicitLod = 94, + OpImageFetch = 95, + OpImageGather = 96, + OpImageDrefGather = 97, + OpImageRead = 98, + OpImageWrite = 99, + OpImage = 100, + OpImageQueryFormat = 101, + OpImageQueryOrder = 102, + OpImageQuerySizeLod = 103, + OpImageQuerySize = 104, + OpImageQueryLod = 105, + OpImageQueryLevels = 106, + OpImageQuerySamples = 107, + OpConvertFToU = 109, + OpConvertFToS = 110, + OpConvertSToF = 111, + OpConvertUToF = 112, + OpUConvert = 113, + OpSConvert = 114, + OpFConvert = 115, + OpQuantizeToF16 = 116, + OpConvertPtrToU = 117, + OpSatConvertSToU = 118, + OpSatConvertUToS = 119, + OpConvertUToPtr = 120, + OpPtrCastToGeneric = 121, + OpGenericCastToPtr = 122, + OpGenericCastToPtrExplicit = 123, + OpBitcast = 124, + OpSNegate = 126, + OpFNegate = 127, + OpIAdd = 128, + OpFAdd = 129, + OpISub = 130, + OpFSub = 131, + OpIMul = 132, + OpFMul = 133, + OpUDiv = 134, + OpSDiv = 135, + OpFDiv = 136, + OpUMod = 137, + OpSRem = 138, + OpSMod = 139, + OpFRem = 140, + OpFMod = 141, + OpVectorTimesScalar = 142, + OpMatrixTimesScalar = 143, + OpVectorTimesMatrix = 144, + OpMatrixTimesVector = 145, + OpMatrixTimesMatrix = 146, + OpOuterProduct = 147, + OpDot = 148, + OpIAddCarry = 149, + OpISubBorrow = 150, + OpUMulExtended = 151, + OpSMulExtended = 152, + OpAny = 154, + OpAll = 155, + OpIsNan = 156, + OpIsInf = 157, + OpIsFinite = 158, + OpIsNormal = 159, + OpSignBitSet = 160, + OpLessOrGreater = 161, + OpOrdered = 162, + OpUnordered = 163, + OpLogicalEqual = 164, + OpLogicalNotEqual = 165, + OpLogicalOr = 166, + OpLogicalAnd = 167, + OpLogicalNot = 168, + OpSelect = 169, + OpIEqual = 170, + OpINotEqual = 171, + OpUGreaterThan = 172, + OpSGreaterThan = 173, + OpUGreaterThanEqual = 174, + OpSGreaterThanEqual = 175, + OpULessThan = 176, + OpSLessThan = 177, + OpULessThanEqual = 178, + OpSLessThanEqual = 179, + OpFOrdEqual = 180, + OpFUnordEqual = 181, + OpFOrdNotEqual = 182, + OpFUnordNotEqual = 183, + OpFOrdLessThan = 184, + OpFUnordLessThan = 185, + OpFOrdGreaterThan = 186, + OpFUnordGreaterThan = 187, + OpFOrdLessThanEqual = 188, + OpFUnordLessThanEqual = 189, + OpFOrdGreaterThanEqual = 190, + OpFUnordGreaterThanEqual = 191, + OpShiftRightLogical = 194, + OpShiftRightArithmetic = 195, + OpShiftLeftLogical = 196, + OpBitwiseOr = 197, + OpBitwiseXor = 198, + OpBitwiseAnd = 199, + OpNot = 200, + OpBitFieldInsert = 201, + OpBitFieldSExtract = 202, + OpBitFieldUExtract = 203, + OpBitReverse = 204, + OpBitCount = 205, + OpDPdx = 207, + OpDPdy = 208, + OpFwidth = 209, + OpDPdxFine = 210, + OpDPdyFine = 211, + OpFwidthFine = 212, + OpDPdxCoarse = 213, + OpDPdyCoarse = 214, + OpFwidthCoarse = 215, + OpEmitVertex = 218, + OpEndPrimitive = 219, + OpEmitStreamVertex = 220, + OpEndStreamPrimitive = 221, + OpControlBarrier = 224, + OpMemoryBarrier = 225, + OpAtomicLoad = 227, + OpAtomicStore = 228, + OpAtomicExchange = 229, + OpAtomicCompareExchange = 230, + OpAtomicCompareExchangeWeak = 231, + OpAtomicIIncrement = 232, + OpAtomicIDecrement = 233, + OpAtomicIAdd = 234, + OpAtomicISub = 235, + OpAtomicSMin = 236, + OpAtomicUMin = 237, + OpAtomicSMax = 238, + OpAtomicUMax = 239, + OpAtomicAnd = 240, + OpAtomicOr = 241, + OpAtomicXor = 242, + OpPhi = 245, + OpLoopMerge = 246, + OpSelectionMerge = 247, + OpLabel = 248, + OpBranch = 249, + OpBranchConditional = 250, + OpSwitch = 251, + OpKill = 252, + OpReturn = 253, + OpReturnValue = 254, + OpUnreachable = 255, + OpLifetimeStart = 256, + OpLifetimeStop = 257, + OpGroupAsyncCopy = 259, + OpGroupWaitEvents = 260, + OpGroupAll = 261, + OpGroupAny = 262, + OpGroupBroadcast = 263, + OpGroupIAdd = 264, + OpGroupFAdd = 265, + OpGroupFMin = 266, + OpGroupUMin = 267, + OpGroupSMin = 268, + OpGroupFMax = 269, + OpGroupUMax = 270, + OpGroupSMax = 271, + OpReadPipe = 274, + OpWritePipe = 275, + OpReservedReadPipe = 276, + OpReservedWritePipe = 277, + OpReserveReadPipePackets = 278, + OpReserveWritePipePackets = 279, + OpCommitReadPipe = 280, + OpCommitWritePipe = 281, + OpIsValidReserveId = 282, + OpGetNumPipePackets = 283, + OpGetMaxPipePackets = 284, + OpGroupReserveReadPipePackets = 285, + OpGroupReserveWritePipePackets = 286, + OpGroupCommitReadPipe = 287, + OpGroupCommitWritePipe = 288, + OpEnqueueMarker = 291, + OpEnqueueKernel = 292, + OpGetKernelNDrangeSubGroupCount = 293, + OpGetKernelNDrangeMaxSubGroupSize = 294, + OpGetKernelWorkGroupSize = 295, + OpGetKernelPreferredWorkGroupSizeMultiple = 296, + OpRetainEvent = 297, + OpReleaseEvent = 298, + OpCreateUserEvent = 299, + OpIsValidEvent = 300, + OpSetUserEventStatus = 301, + OpCaptureEventProfilingInfo = 302, + OpGetDefaultQueue = 303, + OpBuildNDRange = 304, + OpImageSparseSampleImplicitLod = 305, + OpImageSparseSampleExplicitLod = 306, + OpImageSparseSampleDrefImplicitLod = 307, + OpImageSparseSampleDrefExplicitLod = 308, + OpImageSparseSampleProjImplicitLod = 309, + OpImageSparseSampleProjExplicitLod = 310, + OpImageSparseSampleProjDrefImplicitLod = 311, + OpImageSparseSampleProjDrefExplicitLod = 312, + OpImageSparseFetch = 313, + OpImageSparseGather = 314, + OpImageSparseDrefGather = 315, + OpImageSparseTexelsResident = 316, + OpNoLine = 317, + OpAtomicFlagTestAndSet = 318, + OpAtomicFlagClear = 319, + OpImageSparseRead = 320, + OpSizeOf = 321, + OpTypePipeStorage = 322, + OpConstantPipeStorage = 323, + OpCreatePipeFromPipeStorage = 324, + OpGetKernelLocalSizeForSubgroupCount = 325, + OpGetKernelMaxNumSubgroups = 326, + OpTypeNamedBarrier = 327, + OpNamedBarrierInitialize = 328, + OpMemoryNamedBarrier = 329, + OpModuleProcessed = 330, + OpExecutionModeId = 331, + OpDecorateId = 332, + OpGroupNonUniformElect = 333, + OpGroupNonUniformAll = 334, + OpGroupNonUniformAny = 335, + OpGroupNonUniformAllEqual = 336, + OpGroupNonUniformBroadcast = 337, + OpGroupNonUniformBroadcastFirst = 338, + OpGroupNonUniformBallot = 339, + OpGroupNonUniformInverseBallot = 340, + OpGroupNonUniformBallotBitExtract = 341, + OpGroupNonUniformBallotBitCount = 342, + OpGroupNonUniformBallotFindLSB = 343, + OpGroupNonUniformBallotFindMSB = 344, + OpGroupNonUniformShuffle = 345, + OpGroupNonUniformShuffleXor = 346, + OpGroupNonUniformShuffleUp = 347, + OpGroupNonUniformShuffleDown = 348, + OpGroupNonUniformIAdd = 349, + OpGroupNonUniformFAdd = 350, + OpGroupNonUniformIMul = 351, + OpGroupNonUniformFMul = 352, + OpGroupNonUniformSMin = 353, + OpGroupNonUniformUMin = 354, + OpGroupNonUniformFMin = 355, + OpGroupNonUniformSMax = 356, + OpGroupNonUniformUMax = 357, + OpGroupNonUniformFMax = 358, + OpGroupNonUniformBitwiseAnd = 359, + OpGroupNonUniformBitwiseOr = 360, + OpGroupNonUniformBitwiseXor = 361, + OpGroupNonUniformLogicalAnd = 362, + OpGroupNonUniformLogicalOr = 363, + OpGroupNonUniformLogicalXor = 364, + OpGroupNonUniformQuadBroadcast = 365, + OpGroupNonUniformQuadSwap = 366, + OpCopyLogical = 400, + OpPtrEqual = 401, + OpPtrNotEqual = 402, + OpPtrDiff = 403, + OpSubgroupBallotKHR = 4421, + OpSubgroupFirstInvocationKHR = 4422, + OpSubgroupAllKHR = 4428, + OpSubgroupAnyKHR = 4429, + OpSubgroupAllEqualKHR = 4430, + OpSubgroupReadInvocationKHR = 4432, + OpTypeRayQueryProvisionalKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, + OpRayQueryGenerateIntersectionKHR = 4475, + OpRayQueryConfirmIntersectionKHR = 4476, + OpRayQueryProceedKHR = 4477, + OpRayQueryGetIntersectionTypeKHR = 4479, + OpGroupIAddNonUniformAMD = 5000, + OpGroupFAddNonUniformAMD = 5001, + OpGroupFMinNonUniformAMD = 5002, + OpGroupUMinNonUniformAMD = 5003, + OpGroupSMinNonUniformAMD = 5004, + OpGroupFMaxNonUniformAMD = 5005, + OpGroupUMaxNonUniformAMD = 5006, + OpGroupSMaxNonUniformAMD = 5007, + OpFragmentMaskFetchAMD = 5011, + OpFragmentFetchAMD = 5012, + OpReadClockKHR = 5056, + OpImageSampleFootprintNV = 5283, + OpGroupNonUniformPartitionNV = 5296, + OpWritePackedPrimitiveIndices4x8NV = 5299, + OpReportIntersectionKHR = 5334, + OpReportIntersectionNV = 5334, + OpIgnoreIntersectionKHR = 5335, + OpIgnoreIntersectionNV = 5335, + OpTerminateRayKHR = 5336, + OpTerminateRayNV = 5336, + OpTraceNV = 5337, + OpTraceRayKHR = 5337, + OpTypeAccelerationStructureKHR = 5341, + OpTypeAccelerationStructureNV = 5341, + OpExecuteCallableKHR = 5344, + OpExecuteCallableNV = 5344, + OpTypeCooperativeMatrixNV = 5358, + OpCooperativeMatrixLoadNV = 5359, + OpCooperativeMatrixStoreNV = 5360, + OpCooperativeMatrixMulAddNV = 5361, + OpCooperativeMatrixLengthNV = 5362, + OpBeginInvocationInterlockEXT = 5364, + OpEndInvocationInterlockEXT = 5365, + OpDemoteToHelperInvocationEXT = 5380, + OpIsHelperInvocationEXT = 5381, + OpSubgroupShuffleINTEL = 5571, + OpSubgroupShuffleDownINTEL = 5572, + OpSubgroupShuffleUpINTEL = 5573, + OpSubgroupShuffleXorINTEL = 5574, + OpSubgroupBlockReadINTEL = 5575, + OpSubgroupBlockWriteINTEL = 5576, + OpSubgroupImageBlockReadINTEL = 5577, + OpSubgroupImageBlockWriteINTEL = 5578, + OpSubgroupImageMediaBlockReadINTEL = 5580, + OpSubgroupImageMediaBlockWriteINTEL = 5581, + OpUCountLeadingZerosINTEL = 5585, + OpUCountTrailingZerosINTEL = 5586, + OpAbsISubINTEL = 5587, + OpAbsUSubINTEL = 5588, + OpIAddSatINTEL = 5589, + OpUAddSatINTEL = 5590, + OpIAverageINTEL = 5591, + OpUAverageINTEL = 5592, + OpIAverageRoundedINTEL = 5593, + OpUAverageRoundedINTEL = 5594, + OpISubSatINTEL = 5595, + OpUSubSatINTEL = 5596, + OpIMul32x16INTEL = 5597, + OpUMul32x16INTEL = 5598, + OpDecorateString = 5632, + OpDecorateStringGOOGLE = 5632, + OpMemberDecorateString = 5633, + OpMemberDecorateStringGOOGLE = 5633, + OpVmeImageINTEL = 5699, + OpTypeVmeImageINTEL = 5700, + OpTypeAvcImePayloadINTEL = 5701, + OpTypeAvcRefPayloadINTEL = 5702, + OpTypeAvcSicPayloadINTEL = 5703, + OpTypeAvcMcePayloadINTEL = 5704, + OpTypeAvcMceResultINTEL = 5705, + OpTypeAvcImeResultINTEL = 5706, + OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, + OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, + OpTypeAvcImeSingleReferenceStreaminINTEL = 5709, + OpTypeAvcImeDualReferenceStreaminINTEL = 5710, + OpTypeAvcRefResultINTEL = 5711, + OpTypeAvcSicResultINTEL = 5712, + OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, + OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, + OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, + OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, + OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, + OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, + OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, + OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, + OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, + OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, + OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, + OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, + OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, + OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, + OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, + OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, + OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, + OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, + OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, + OpSubgroupAvcMceConvertToImePayloadINTEL = 5732, + OpSubgroupAvcMceConvertToImeResultINTEL = 5733, + OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, + OpSubgroupAvcMceConvertToRefResultINTEL = 5735, + OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, + OpSubgroupAvcMceConvertToSicResultINTEL = 5737, + OpSubgroupAvcMceGetMotionVectorsINTEL = 5738, + OpSubgroupAvcMceGetInterDistortionsINTEL = 5739, + OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, + OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, + OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, + OpSubgroupAvcMceGetInterDirectionsINTEL = 5743, + OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, + OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, + OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, + OpSubgroupAvcImeInitializeINTEL = 5747, + OpSubgroupAvcImeSetSingleReferenceINTEL = 5748, + OpSubgroupAvcImeSetDualReferenceINTEL = 5749, + OpSubgroupAvcImeRefWindowSizeINTEL = 5750, + OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, + OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, + OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, + OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, + OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, + OpSubgroupAvcImeSetWeightedSadINTEL = 5756, + OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, + OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, + OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, + OpSubgroupAvcImeConvertToMceResultINTEL = 5765, + OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, + OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, + OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, + OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, + OpSubgroupAvcImeGetBorderReachedINTEL = 5776, + OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, + OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, + OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, + OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, + OpSubgroupAvcFmeInitializeINTEL = 5781, + OpSubgroupAvcBmeInitializeINTEL = 5782, + OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, + OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, + OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, + OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, + OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, + OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, + OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, + OpSubgroupAvcRefConvertToMceResultINTEL = 5790, + OpSubgroupAvcSicInitializeINTEL = 5791, + OpSubgroupAvcSicConfigureSkcINTEL = 5792, + OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, + OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, + OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, + OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, + OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, + OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, + OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, + OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, + OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, + OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, + OpSubgroupAvcSicEvaluateIpeINTEL = 5803, + OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, + OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, + OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, + OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, + OpSubgroupAvcSicConvertToMceResultINTEL = 5808, + OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, + OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, + OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, + OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, + OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, + OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, + OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, + OpSubgroupAvcSicGetInterRawSadsINTEL = 5816, + OpRayQueryGetRayTMinKHR = 6016, + OpRayQueryGetRayFlagsKHR = 6017, + OpRayQueryGetIntersectionTKHR = 6018, + OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019, + OpRayQueryGetIntersectionInstanceIdKHR = 6020, + OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021, + OpRayQueryGetIntersectionGeometryIndexKHR = 6022, + OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023, + OpRayQueryGetIntersectionBarycentricsKHR = 6024, + OpRayQueryGetIntersectionFrontFaceKHR = 6025, + OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026, + OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027, + OpRayQueryGetIntersectionObjectRayOriginKHR = 6028, + OpRayQueryGetWorldRayDirectionKHR = 6029, + OpRayQueryGetWorldRayOriginKHR = 6030, + OpRayQueryGetIntersectionObjectToWorldKHR = 6031, + OpRayQueryGetIntersectionWorldToObjectKHR = 6032, + OpMax = 0x7fffffff, +}; + +#ifdef SPV_ENABLE_UTILITY_CODE +inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + *hasResult = *hasResultType = false; + switch (opcode) { + default: /* unknown opcode */ break; + case OpNop: *hasResult = false; *hasResultType = false; break; + case OpUndef: *hasResult = true; *hasResultType = true; break; + case OpSourceContinued: *hasResult = false; *hasResultType = false; break; + case OpSource: *hasResult = false; *hasResultType = false; break; + case OpSourceExtension: *hasResult = false; *hasResultType = false; break; + case OpName: *hasResult = false; *hasResultType = false; break; + case OpMemberName: *hasResult = false; *hasResultType = false; break; + case OpString: *hasResult = true; *hasResultType = false; break; + case OpLine: *hasResult = false; *hasResultType = false; break; + case OpExtension: *hasResult = false; *hasResultType = false; break; + case OpExtInstImport: *hasResult = true; *hasResultType = false; break; + case OpExtInst: *hasResult = true; *hasResultType = true; break; + case OpMemoryModel: *hasResult = false; *hasResultType = false; break; + case OpEntryPoint: *hasResult = false; *hasResultType = false; break; + case OpExecutionMode: *hasResult = false; *hasResultType = false; break; + case OpCapability: *hasResult = false; *hasResultType = false; break; + case OpTypeVoid: *hasResult = true; *hasResultType = false; break; + case OpTypeBool: *hasResult = true; *hasResultType = false; break; + case OpTypeInt: *hasResult = true; *hasResultType = false; break; + case OpTypeFloat: *hasResult = true; *hasResultType = false; break; + case OpTypeVector: *hasResult = true; *hasResultType = false; break; + case OpTypeMatrix: *hasResult = true; *hasResultType = false; break; + case OpTypeImage: *hasResult = true; *hasResultType = false; break; + case OpTypeSampler: *hasResult = true; *hasResultType = false; break; + case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break; + case OpTypeArray: *hasResult = true; *hasResultType = false; break; + case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; + case OpTypeStruct: *hasResult = true; *hasResultType = false; break; + case OpTypeOpaque: *hasResult = true; *hasResultType = false; break; + case OpTypePointer: *hasResult = true; *hasResultType = false; break; + case OpTypeFunction: *hasResult = true; *hasResultType = false; break; + case OpTypeEvent: *hasResult = true; *hasResultType = false; break; + case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; + case OpTypeReserveId: *hasResult = true; *hasResultType = false; break; + case OpTypeQueue: *hasResult = true; *hasResultType = false; break; + case OpTypePipe: *hasResult = true; *hasResultType = false; break; + case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; + case OpConstantTrue: *hasResult = true; *hasResultType = true; break; + case OpConstantFalse: *hasResult = true; *hasResultType = true; break; + case OpConstant: *hasResult = true; *hasResultType = true; break; + case OpConstantComposite: *hasResult = true; *hasResultType = true; break; + case OpConstantSampler: *hasResult = true; *hasResultType = true; break; + case OpConstantNull: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; + case OpSpecConstant: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break; + case OpFunction: *hasResult = true; *hasResultType = true; break; + case OpFunctionParameter: *hasResult = true; *hasResultType = true; break; + case OpFunctionEnd: *hasResult = false; *hasResultType = false; break; + case OpFunctionCall: *hasResult = true; *hasResultType = true; break; + case OpVariable: *hasResult = true; *hasResultType = true; break; + case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break; + case OpLoad: *hasResult = true; *hasResultType = true; break; + case OpStore: *hasResult = false; *hasResultType = false; break; + case OpCopyMemory: *hasResult = false; *hasResultType = false; break; + case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break; + case OpAccessChain: *hasResult = true; *hasResultType = true; break; + case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; + case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case OpArrayLength: *hasResult = true; *hasResultType = true; break; + case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; + case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case OpDecorate: *hasResult = false; *hasResultType = false; break; + case OpMemberDecorate: *hasResult = false; *hasResultType = false; break; + case OpDecorationGroup: *hasResult = true; *hasResultType = false; break; + case OpGroupDecorate: *hasResult = false; *hasResultType = false; break; + case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; + case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; + case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; + case OpVectorShuffle: *hasResult = true; *hasResultType = true; break; + case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break; + case OpCompositeExtract: *hasResult = true; *hasResultType = true; break; + case OpCompositeInsert: *hasResult = true; *hasResultType = true; break; + case OpCopyObject: *hasResult = true; *hasResultType = true; break; + case OpTranspose: *hasResult = true; *hasResultType = true; break; + case OpSampledImage: *hasResult = true; *hasResultType = true; break; + case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageFetch: *hasResult = true; *hasResultType = true; break; + case OpImageGather: *hasResult = true; *hasResultType = true; break; + case OpImageDrefGather: *hasResult = true; *hasResultType = true; break; + case OpImageRead: *hasResult = true; *hasResultType = true; break; + case OpImageWrite: *hasResult = false; *hasResultType = false; break; + case OpImage: *hasResult = true; *hasResultType = true; break; + case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break; + case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySize: *hasResult = true; *hasResultType = true; break; + case OpImageQueryLod: *hasResult = true; *hasResultType = true; break; + case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break; + case OpConvertFToU: *hasResult = true; *hasResultType = true; break; + case OpConvertFToS: *hasResult = true; *hasResultType = true; break; + case OpConvertSToF: *hasResult = true; *hasResultType = true; break; + case OpConvertUToF: *hasResult = true; *hasResultType = true; break; + case OpUConvert: *hasResult = true; *hasResultType = true; break; + case OpSConvert: *hasResult = true; *hasResultType = true; break; + case OpFConvert: *hasResult = true; *hasResultType = true; break; + case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break; + case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break; + case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break; + case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break; + case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break; + case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; + case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; + case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; + case OpBitcast: *hasResult = true; *hasResultType = true; break; + case OpSNegate: *hasResult = true; *hasResultType = true; break; + case OpFNegate: *hasResult = true; *hasResultType = true; break; + case OpIAdd: *hasResult = true; *hasResultType = true; break; + case OpFAdd: *hasResult = true; *hasResultType = true; break; + case OpISub: *hasResult = true; *hasResultType = true; break; + case OpFSub: *hasResult = true; *hasResultType = true; break; + case OpIMul: *hasResult = true; *hasResultType = true; break; + case OpFMul: *hasResult = true; *hasResultType = true; break; + case OpUDiv: *hasResult = true; *hasResultType = true; break; + case OpSDiv: *hasResult = true; *hasResultType = true; break; + case OpFDiv: *hasResult = true; *hasResultType = true; break; + case OpUMod: *hasResult = true; *hasResultType = true; break; + case OpSRem: *hasResult = true; *hasResultType = true; break; + case OpSMod: *hasResult = true; *hasResultType = true; break; + case OpFRem: *hasResult = true; *hasResultType = true; break; + case OpFMod: *hasResult = true; *hasResultType = true; break; + case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; + case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; + case OpOuterProduct: *hasResult = true; *hasResultType = true; break; + case OpDot: *hasResult = true; *hasResultType = true; break; + case OpIAddCarry: *hasResult = true; *hasResultType = true; break; + case OpISubBorrow: *hasResult = true; *hasResultType = true; break; + case OpUMulExtended: *hasResult = true; *hasResultType = true; break; + case OpSMulExtended: *hasResult = true; *hasResultType = true; break; + case OpAny: *hasResult = true; *hasResultType = true; break; + case OpAll: *hasResult = true; *hasResultType = true; break; + case OpIsNan: *hasResult = true; *hasResultType = true; break; + case OpIsInf: *hasResult = true; *hasResultType = true; break; + case OpIsFinite: *hasResult = true; *hasResultType = true; break; + case OpIsNormal: *hasResult = true; *hasResultType = true; break; + case OpSignBitSet: *hasResult = true; *hasResultType = true; break; + case OpLessOrGreater: *hasResult = true; *hasResultType = true; break; + case OpOrdered: *hasResult = true; *hasResultType = true; break; + case OpUnordered: *hasResult = true; *hasResultType = true; break; + case OpLogicalEqual: *hasResult = true; *hasResultType = true; break; + case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; + case OpLogicalOr: *hasResult = true; *hasResultType = true; break; + case OpLogicalAnd: *hasResult = true; *hasResultType = true; break; + case OpLogicalNot: *hasResult = true; *hasResultType = true; break; + case OpSelect: *hasResult = true; *hasResultType = true; break; + case OpIEqual: *hasResult = true; *hasResultType = true; break; + case OpINotEqual: *hasResult = true; *hasResultType = true; break; + case OpUGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpSGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpULessThan: *hasResult = true; *hasResultType = true; break; + case OpSLessThan: *hasResult = true; *hasResultType = true; break; + case OpULessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break; + case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break; + case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break; + case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; + case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; + case OpBitwiseOr: *hasResult = true; *hasResultType = true; break; + case OpBitwiseXor: *hasResult = true; *hasResultType = true; break; + case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case OpNot: *hasResult = true; *hasResultType = true; break; + case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break; + case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; + case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; + case OpBitReverse: *hasResult = true; *hasResultType = true; break; + case OpBitCount: *hasResult = true; *hasResultType = true; break; + case OpDPdx: *hasResult = true; *hasResultType = true; break; + case OpDPdy: *hasResult = true; *hasResultType = true; break; + case OpFwidth: *hasResult = true; *hasResultType = true; break; + case OpDPdxFine: *hasResult = true; *hasResultType = true; break; + case OpDPdyFine: *hasResult = true; *hasResultType = true; break; + case OpFwidthFine: *hasResult = true; *hasResultType = true; break; + case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break; + case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break; + case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break; + case OpEmitVertex: *hasResult = false; *hasResultType = false; break; + case OpEndPrimitive: *hasResult = false; *hasResultType = false; break; + case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; + case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; + case OpControlBarrier: *hasResult = false; *hasResultType = false; break; + case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break; + case OpAtomicLoad: *hasResult = true; *hasResultType = true; break; + case OpAtomicStore: *hasResult = false; *hasResultType = false; break; + case OpAtomicExchange: *hasResult = true; *hasResultType = true; break; + case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; + case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; + case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; + case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; + case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break; + case OpAtomicISub: *hasResult = true; *hasResultType = true; break; + case OpAtomicSMin: *hasResult = true; *hasResultType = true; break; + case OpAtomicUMin: *hasResult = true; *hasResultType = true; break; + case OpAtomicSMax: *hasResult = true; *hasResultType = true; break; + case OpAtomicUMax: *hasResult = true; *hasResultType = true; break; + case OpAtomicAnd: *hasResult = true; *hasResultType = true; break; + case OpAtomicOr: *hasResult = true; *hasResultType = true; break; + case OpAtomicXor: *hasResult = true; *hasResultType = true; break; + case OpPhi: *hasResult = true; *hasResultType = true; break; + case OpLoopMerge: *hasResult = false; *hasResultType = false; break; + case OpSelectionMerge: *hasResult = false; *hasResultType = false; break; + case OpLabel: *hasResult = true; *hasResultType = false; break; + case OpBranch: *hasResult = false; *hasResultType = false; break; + case OpBranchConditional: *hasResult = false; *hasResultType = false; break; + case OpSwitch: *hasResult = false; *hasResultType = false; break; + case OpKill: *hasResult = false; *hasResultType = false; break; + case OpReturn: *hasResult = false; *hasResultType = false; break; + case OpReturnValue: *hasResult = false; *hasResultType = false; break; + case OpUnreachable: *hasResult = false; *hasResultType = false; break; + case OpLifetimeStart: *hasResult = false; *hasResultType = false; break; + case OpLifetimeStop: *hasResult = false; *hasResultType = false; break; + case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; + case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; + case OpGroupAll: *hasResult = true; *hasResultType = true; break; + case OpGroupAny: *hasResult = true; *hasResultType = true; break; + case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupIAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupFAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupFMin: *hasResult = true; *hasResultType = true; break; + case OpGroupUMin: *hasResult = true; *hasResultType = true; break; + case OpGroupSMin: *hasResult = true; *hasResultType = true; break; + case OpGroupFMax: *hasResult = true; *hasResultType = true; break; + case OpGroupUMax: *hasResult = true; *hasResultType = true; break; + case OpGroupSMax: *hasResult = true; *hasResultType = true; break; + case OpReadPipe: *hasResult = true; *hasResultType = true; break; + case OpWritePipe: *hasResult = true; *hasResultType = true; break; + case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break; + case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break; + case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break; + case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break; + case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break; + case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; + case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; + case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; + case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; + case OpRetainEvent: *hasResult = false; *hasResultType = false; break; + case OpReleaseEvent: *hasResult = false; *hasResultType = false; break; + case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break; + case OpIsValidEvent: *hasResult = true; *hasResultType = true; break; + case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; + case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; + case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; + case OpBuildNDRange: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break; + case OpImageSparseGather: *hasResult = true; *hasResultType = true; break; + case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; + case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; + case OpNoLine: *hasResult = false; *hasResultType = false; break; + case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; + case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; + case OpImageSparseRead: *hasResult = true; *hasResultType = true; break; + case OpSizeOf: *hasResult = true; *hasResultType = true; break; + case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break; + case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; + case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; + case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; + case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; + case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; + case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; + case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; + case OpModuleProcessed: *hasResult = false; *hasResultType = false; break; + case OpExecutionModeId: *hasResult = false; *hasResultType = false; break; + case OpDecorateId: *hasResult = false; *hasResultType = false; break; + case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; + case OpCopyLogical: *hasResult = true; *hasResultType = true; break; + case OpPtrEqual: *hasResult = true; *hasResultType = true; break; + case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break; + case OpPtrDiff: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; + case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; + case OpReadClockKHR: *hasResult = true; *hasResultType = true; break; + case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; + case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; + case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case OpTraceNV: *hasResult = false; *hasResultType = false; break; + case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; + case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break; + case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; + case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; + case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; + case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; + case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; + case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case OpDecorateString: *hasResult = false; *hasResultType = false; break; + case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break; + case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; + case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; + } +} +#endif /* SPV_ENABLE_UTILITY_CODE */ + +// Overload operator| for mask bit combining + +inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); } +inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); } +inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); } +inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); } +inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); } +inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); } +inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); } +inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); } +inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); } + +} // end namespace spv + +#endif // #ifndef spirv_HPP + diff --git a/ios/include/spirv_cross/spirv_cfg.hpp b/ios/include/spirv_cross/spirv_cfg.hpp new file mode 100644 index 00000000..9f3e62a1 --- /dev/null +++ b/ios/include/spirv_cross/spirv_cfg.hpp @@ -0,0 +1,156 @@ +/* + * Copyright 2016-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_CFG_HPP +#define SPIRV_CROSS_CFG_HPP + +#include "spirv_common.hpp" +#include + +namespace SPIRV_CROSS_NAMESPACE +{ +class Compiler; +class CFG +{ +public: + CFG(Compiler &compiler, const SPIRFunction &function); + + Compiler &get_compiler() + { + return compiler; + } + + const Compiler &get_compiler() const + { + return compiler; + } + + const SPIRFunction &get_function() const + { + return func; + } + + uint32_t get_immediate_dominator(uint32_t block) const + { + auto itr = immediate_dominators.find(block); + if (itr != std::end(immediate_dominators)) + return itr->second; + else + return 0; + } + + uint32_t get_visit_order(uint32_t block) const + { + auto itr = visit_order.find(block); + assert(itr != std::end(visit_order)); + int v = itr->second.get(); + assert(v > 0); + return uint32_t(v); + } + + uint32_t find_common_dominator(uint32_t a, uint32_t b) const; + + const SmallVector &get_preceding_edges(uint32_t block) const + { + auto itr = preceding_edges.find(block); + if (itr != std::end(preceding_edges)) + return itr->second; + else + return empty_vector; + } + + const SmallVector &get_succeeding_edges(uint32_t block) const + { + auto itr = succeeding_edges.find(block); + if (itr != std::end(succeeding_edges)) + return itr->second; + else + return empty_vector; + } + + template + void walk_from(std::unordered_set &seen_blocks, uint32_t block, const Op &op) const + { + if (seen_blocks.count(block)) + return; + seen_blocks.insert(block); + + if (op(block)) + { + for (auto b : get_succeeding_edges(block)) + walk_from(seen_blocks, b, op); + } + } + + uint32_t find_loop_dominator(uint32_t block) const; + + bool node_terminates_control_flow_in_sub_graph(BlockID from, BlockID to) const; + +private: + struct VisitOrder + { + int &get() + { + return v; + } + + const int &get() const + { + return v; + } + + int v = -1; + }; + + Compiler &compiler; + const SPIRFunction &func; + std::unordered_map> preceding_edges; + std::unordered_map> succeeding_edges; + std::unordered_map immediate_dominators; + std::unordered_map visit_order; + SmallVector post_order; + SmallVector empty_vector; + + void add_branch(uint32_t from, uint32_t to); + void build_post_order_visit_order(); + void build_immediate_dominators(); + bool post_order_visit(uint32_t block); + uint32_t visit_count = 0; + + bool is_back_edge(uint32_t to) const; + bool has_visited_forward_edge(uint32_t to) const; +}; + +class DominatorBuilder +{ +public: + DominatorBuilder(const CFG &cfg); + + void add_block(uint32_t block); + uint32_t get_dominator() const + { + return dominator; + } + + void lift_continue_block_dominator(); + +private: + const CFG &cfg; + uint32_t dominator = 0; +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_common.hpp b/ios/include/spirv_cross/spirv_common.hpp new file mode 100644 index 00000000..252d0329 --- /dev/null +++ b/ios/include/spirv_cross/spirv_common.hpp @@ -0,0 +1,1781 @@ +/* + * Copyright 2015-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_COMMON_HPP +#define SPIRV_CROSS_COMMON_HPP + +#include "spirv.hpp" +#include "spirv_cross_containers.hpp" +#include "spirv_cross_error_handling.hpp" +#include + +// A bit crude, but allows projects which embed SPIRV-Cross statically to +// effectively hide all the symbols from other projects. +// There is a case where we have: +// - Project A links against SPIRV-Cross statically. +// - Project A links against Project B statically. +// - Project B links against SPIRV-Cross statically (might be a different version). +// This leads to a conflict with extremely bizarre results. +// By overriding the namespace in one of the project builds, we can work around this. +// If SPIRV-Cross is embedded in dynamic libraries, +// prefer using -fvisibility=hidden on GCC/Clang instead. +#ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE +#define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE +#else +#define SPIRV_CROSS_NAMESPACE spirv_cross +#endif + +namespace SPIRV_CROSS_NAMESPACE +{ +namespace inner +{ +template +void join_helper(StringStream<> &stream, T &&t) +{ + stream << std::forward(t); +} + +template +void join_helper(StringStream<> &stream, T &&t, Ts &&... ts) +{ + stream << std::forward(t); + join_helper(stream, std::forward(ts)...); +} +} // namespace inner + +class Bitset +{ +public: + Bitset() = default; + explicit inline Bitset(uint64_t lower_) + : lower(lower_) + { + } + + inline bool get(uint32_t bit) const + { + if (bit < 64) + return (lower & (1ull << bit)) != 0; + else + return higher.count(bit) != 0; + } + + inline void set(uint32_t bit) + { + if (bit < 64) + lower |= 1ull << bit; + else + higher.insert(bit); + } + + inline void clear(uint32_t bit) + { + if (bit < 64) + lower &= ~(1ull << bit); + else + higher.erase(bit); + } + + inline uint64_t get_lower() const + { + return lower; + } + + inline void reset() + { + lower = 0; + higher.clear(); + } + + inline void merge_and(const Bitset &other) + { + lower &= other.lower; + std::unordered_set tmp_set; + for (auto &v : higher) + if (other.higher.count(v) != 0) + tmp_set.insert(v); + higher = std::move(tmp_set); + } + + inline void merge_or(const Bitset &other) + { + lower |= other.lower; + for (auto &v : other.higher) + higher.insert(v); + } + + inline bool operator==(const Bitset &other) const + { + if (lower != other.lower) + return false; + + if (higher.size() != other.higher.size()) + return false; + + for (auto &v : higher) + if (other.higher.count(v) == 0) + return false; + + return true; + } + + inline bool operator!=(const Bitset &other) const + { + return !(*this == other); + } + + template + void for_each_bit(const Op &op) const + { + // TODO: Add ctz-based iteration. + for (uint32_t i = 0; i < 64; i++) + { + if (lower & (1ull << i)) + op(i); + } + + if (higher.empty()) + return; + + // Need to enforce an order here for reproducible results, + // but hitting this path should happen extremely rarely, so having this slow path is fine. + SmallVector bits; + bits.reserve(higher.size()); + for (auto &v : higher) + bits.push_back(v); + std::sort(std::begin(bits), std::end(bits)); + + for (auto &v : bits) + op(v); + } + + inline bool empty() const + { + return lower == 0 && higher.empty(); + } + +private: + // The most common bits to set are all lower than 64, + // so optimize for this case. Bits spilling outside 64 go into a slower data structure. + // In almost all cases, higher data structure will not be used. + uint64_t lower = 0; + std::unordered_set higher; +}; + +// Helper template to avoid lots of nasty string temporary munging. +template +std::string join(Ts &&... ts) +{ + StringStream<> stream; + inner::join_helper(stream, std::forward(ts)...); + return stream.str(); +} + +inline std::string merge(const SmallVector &list, const char *between = ", ") +{ + StringStream<> stream; + for (auto &elem : list) + { + stream << elem; + if (&elem != &list.back()) + stream << between; + } + return stream.str(); +} + +// Make sure we don't accidentally call this with float or doubles with SFINAE. +// Have to use the radix-aware overload. +template ::value, int>::type = 0> +inline std::string convert_to_string(const T &t) +{ + return std::to_string(t); +} + +// Allow implementations to set a convenient standard precision +#ifndef SPIRV_CROSS_FLT_FMT +#define SPIRV_CROSS_FLT_FMT "%.32g" +#endif + +// Disable sprintf and strcat warnings. +// We cannot rely on snprintf and family existing because, ..., MSVC. +#if defined(__clang__) || defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable : 4996) +#endif + +static inline void fixup_radix_point(char *str, char radix_point) +{ + // Setting locales is a very risky business in multi-threaded program, + // so just fixup locales instead. We only need to care about the radix point. + if (radix_point != '.') + { + while (*str != '\0') + { + if (*str == radix_point) + *str = '.'; + str++; + } + } +} + +inline std::string convert_to_string(float t, char locale_radix_point) +{ + // std::to_string for floating point values is broken. + // Fallback to something more sane. + char buf[64]; + sprintf(buf, SPIRV_CROSS_FLT_FMT, t); + fixup_radix_point(buf, locale_radix_point); + + // Ensure that the literal is float. + if (!strchr(buf, '.') && !strchr(buf, 'e')) + strcat(buf, ".0"); + return buf; +} + +inline std::string convert_to_string(double t, char locale_radix_point) +{ + // std::to_string for floating point values is broken. + // Fallback to something more sane. + char buf[64]; + sprintf(buf, SPIRV_CROSS_FLT_FMT, t); + fixup_radix_point(buf, locale_radix_point); + + // Ensure that the literal is float. + if (!strchr(buf, '.') && !strchr(buf, 'e')) + strcat(buf, ".0"); + return buf; +} + +#if defined(__clang__) || defined(__GNUC__) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif + +struct Instruction +{ + uint16_t op = 0; + uint16_t count = 0; + uint32_t offset = 0; + uint32_t length = 0; +}; + +enum Types +{ + TypeNone, + TypeType, + TypeVariable, + TypeConstant, + TypeFunction, + TypeFunctionPrototype, + TypeBlock, + TypeExtension, + TypeExpression, + TypeConstantOp, + TypeCombinedImageSampler, + TypeAccessChain, + TypeUndef, + TypeString, + TypeCount +}; + +template +class TypedID; + +template <> +class TypedID +{ +public: + TypedID() = default; + TypedID(uint32_t id_) + : id(id_) + { + } + + template + TypedID(const TypedID &other) + { + *this = other; + } + + template + TypedID &operator=(const TypedID &other) + { + id = uint32_t(other); + return *this; + } + + // Implicit conversion to u32 is desired here. + // As long as we block implicit conversion between TypedID and TypedID we're good. + operator uint32_t() const + { + return id; + } + + template + operator TypedID() const + { + return TypedID(*this); + } + + bool operator==(const TypedID &other) const + { + return id == other.id; + } + + bool operator!=(const TypedID &other) const + { + return id != other.id; + } + + template + bool operator==(const TypedID &other) const + { + return id == uint32_t(other); + } + + template + bool operator!=(const TypedID &other) const + { + return id != uint32_t(other); + } + +private: + uint32_t id = 0; +}; + +template +class TypedID +{ +public: + TypedID() = default; + TypedID(uint32_t id_) + : id(id_) + { + } + + explicit TypedID(const TypedID &other) + : id(uint32_t(other)) + { + } + + operator uint32_t() const + { + return id; + } + + bool operator==(const TypedID &other) const + { + return id == other.id; + } + + bool operator!=(const TypedID &other) const + { + return id != other.id; + } + + bool operator==(const TypedID &other) const + { + return id == uint32_t(other); + } + + bool operator!=(const TypedID &other) const + { + return id != uint32_t(other); + } + +private: + uint32_t id = 0; +}; + +using VariableID = TypedID; +using TypeID = TypedID; +using ConstantID = TypedID; +using FunctionID = TypedID; +using BlockID = TypedID; +using ID = TypedID; + +// Helper for Variant interface. +struct IVariant +{ + virtual ~IVariant() = default; + virtual IVariant *clone(ObjectPoolBase *pool) = 0; + ID self = 0; +}; + +#define SPIRV_CROSS_DECLARE_CLONE(T) \ + IVariant *clone(ObjectPoolBase *pool) override \ + { \ + return static_cast *>(pool)->allocate(*this); \ + } + +struct SPIRUndef : IVariant +{ + enum + { + type = TypeUndef + }; + + explicit SPIRUndef(TypeID basetype_) + : basetype(basetype_) + { + } + TypeID basetype; + + SPIRV_CROSS_DECLARE_CLONE(SPIRUndef) +}; + +struct SPIRString : IVariant +{ + enum + { + type = TypeString + }; + + explicit SPIRString(std::string str_) + : str(std::move(str_)) + { + } + + std::string str; + + SPIRV_CROSS_DECLARE_CLONE(SPIRString) +}; + +// This type is only used by backends which need to access the combined image and sampler IDs separately after +// the OpSampledImage opcode. +struct SPIRCombinedImageSampler : IVariant +{ + enum + { + type = TypeCombinedImageSampler + }; + SPIRCombinedImageSampler(TypeID type_, VariableID image_, VariableID sampler_) + : combined_type(type_) + , image(image_) + , sampler(sampler_) + { + } + TypeID combined_type; + VariableID image; + VariableID sampler; + + SPIRV_CROSS_DECLARE_CLONE(SPIRCombinedImageSampler) +}; + +struct SPIRConstantOp : IVariant +{ + enum + { + type = TypeConstantOp + }; + + SPIRConstantOp(TypeID result_type, spv::Op op, const uint32_t *args, uint32_t length) + : opcode(op) + , basetype(result_type) + { + arguments.reserve(length); + for (uint32_t i = 0; i < length; i++) + arguments.push_back(args[i]); + } + + spv::Op opcode; + SmallVector arguments; + TypeID basetype; + + SPIRV_CROSS_DECLARE_CLONE(SPIRConstantOp) +}; + +struct SPIRType : IVariant +{ + enum + { + type = TypeType + }; + + enum BaseType + { + Unknown, + Void, + Boolean, + SByte, + UByte, + Short, + UShort, + Int, + UInt, + Int64, + UInt64, + AtomicCounter, + Half, + Float, + Double, + Struct, + Image, + SampledImage, + Sampler, + AccelerationStructure, + RayQuery, + + // Keep internal types at the end. + ControlPointArray, + Char + }; + + // Scalar/vector/matrix support. + BaseType basetype = Unknown; + uint32_t width = 0; + uint32_t vecsize = 1; + uint32_t columns = 1; + + // Arrays, support array of arrays by having a vector of array sizes. + SmallVector array; + + // Array elements can be either specialization constants or specialization ops. + // This array determines how to interpret the array size. + // If an element is true, the element is a literal, + // otherwise, it's an expression, which must be resolved on demand. + // The actual size is not really known until runtime. + SmallVector array_size_literal; + + // Pointers + // Keep track of how many pointer layers we have. + uint32_t pointer_depth = 0; + bool pointer = false; + + spv::StorageClass storage = spv::StorageClassGeneric; + + SmallVector member_types; + + struct ImageType + { + TypeID type; + spv::Dim dim; + bool depth; + bool arrayed; + bool ms; + uint32_t sampled; + spv::ImageFormat format; + spv::AccessQualifier access; + } image; + + // Structs can be declared multiple times if they are used as part of interface blocks. + // We want to detect this so that we only emit the struct definition once. + // Since we cannot rely on OpName to be equal, we need to figure out aliases. + TypeID type_alias = 0; + + // Denotes the type which this type is based on. + // Allows the backend to traverse how a complex type is built up during access chains. + TypeID parent_type = 0; + + // Used in backends to avoid emitting members with conflicting names. + std::unordered_set member_name_cache; + + SPIRV_CROSS_DECLARE_CLONE(SPIRType) +}; + +struct SPIRExtension : IVariant +{ + enum + { + type = TypeExtension + }; + + enum Extension + { + Unsupported, + GLSL, + SPV_debug_info, + SPV_AMD_shader_ballot, + SPV_AMD_shader_explicit_vertex_parameter, + SPV_AMD_shader_trinary_minmax, + SPV_AMD_gcn_shader + }; + + explicit SPIRExtension(Extension ext_) + : ext(ext_) + { + } + + Extension ext; + SPIRV_CROSS_DECLARE_CLONE(SPIRExtension) +}; + +// SPIREntryPoint is not a variant since its IDs are used to decorate OpFunction, +// so in order to avoid conflicts, we can't stick them in the ids array. +struct SPIREntryPoint +{ + SPIREntryPoint(FunctionID self_, spv::ExecutionModel execution_model, const std::string &entry_name) + : self(self_) + , name(entry_name) + , orig_name(entry_name) + , model(execution_model) + { + } + SPIREntryPoint() = default; + + FunctionID self = 0; + std::string name; + std::string orig_name; + SmallVector interface_variables; + + Bitset flags; + struct + { + uint32_t x = 0, y = 0, z = 0; + uint32_t constant = 0; // Workgroup size can be expressed as a constant/spec-constant instead. + } workgroup_size; + uint32_t invocations = 0; + uint32_t output_vertices = 0; + spv::ExecutionModel model = spv::ExecutionModelMax; + bool geometry_passthrough = false; +}; + +struct SPIRExpression : IVariant +{ + enum + { + type = TypeExpression + }; + + // Only created by the backend target to avoid creating tons of temporaries. + SPIRExpression(std::string expr, TypeID expression_type_, bool immutable_) + : expression(move(expr)) + , expression_type(expression_type_) + , immutable(immutable_) + { + } + + // If non-zero, prepend expression with to_expression(base_expression). + // Used in amortizing multiple calls to to_expression() + // where in certain cases that would quickly force a temporary when not needed. + ID base_expression = 0; + + std::string expression; + TypeID expression_type = 0; + + // If this expression is a forwarded load, + // allow us to reference the original variable. + ID loaded_from = 0; + + // If this expression will never change, we can avoid lots of temporaries + // in high level source. + // An expression being immutable can be speculative, + // it is assumed that this is true almost always. + bool immutable = false; + + // Before use, this expression must be transposed. + // This is needed for targets which don't support row_major layouts. + bool need_transpose = false; + + // Whether or not this is an access chain expression. + bool access_chain = false; + + // A list of expressions which this expression depends on. + SmallVector expression_dependencies; + + // By reading this expression, we implicitly read these expressions as well. + // Used by access chain Store and Load since we read multiple expressions in this case. + SmallVector implied_read_expressions; + + SPIRV_CROSS_DECLARE_CLONE(SPIRExpression) +}; + +struct SPIRFunctionPrototype : IVariant +{ + enum + { + type = TypeFunctionPrototype + }; + + explicit SPIRFunctionPrototype(TypeID return_type_) + : return_type(return_type_) + { + } + + TypeID return_type; + SmallVector parameter_types; + + SPIRV_CROSS_DECLARE_CLONE(SPIRFunctionPrototype) +}; + +struct SPIRBlock : IVariant +{ + enum + { + type = TypeBlock + }; + + enum Terminator + { + Unknown, + Direct, // Emit next block directly without a particular condition. + + Select, // Block ends with an if/else block. + MultiSelect, // Block ends with switch statement. + + Return, // Block ends with return. + Unreachable, // Noop + Kill // Discard + }; + + enum Merge + { + MergeNone, + MergeLoop, + MergeSelection + }; + + enum Hints + { + HintNone, + HintUnroll, + HintDontUnroll, + HintFlatten, + HintDontFlatten + }; + + enum Method + { + MergeToSelectForLoop, + MergeToDirectForLoop, + MergeToSelectContinueForLoop + }; + + enum ContinueBlockType + { + ContinueNone, + + // Continue block is branchless and has at least one instruction. + ForLoop, + + // Noop continue block. + WhileLoop, + + // Continue block is conditional. + DoWhileLoop, + + // Highly unlikely that anything will use this, + // since it is really awkward/impossible to express in GLSL. + ComplexLoop + }; + + enum + { + NoDominator = 0xffffffffu + }; + + Terminator terminator = Unknown; + Merge merge = MergeNone; + Hints hint = HintNone; + BlockID next_block = 0; + BlockID merge_block = 0; + BlockID continue_block = 0; + + ID return_value = 0; // If 0, return nothing (void). + ID condition = 0; + BlockID true_block = 0; + BlockID false_block = 0; + BlockID default_block = 0; + + SmallVector ops; + + struct Phi + { + ID local_variable; // flush local variable ... + BlockID parent; // If we're in from_block and want to branch into this block ... + VariableID function_variable; // to this function-global "phi" variable first. + }; + + // Before entering this block flush out local variables to magical "phi" variables. + SmallVector phi_variables; + + // Declare these temporaries before beginning the block. + // Used for handling complex continue blocks which have side effects. + SmallVector> declare_temporary; + + // Declare these temporaries, but only conditionally if this block turns out to be + // a complex loop header. + SmallVector> potential_declare_temporary; + + struct Case + { + uint32_t value; + BlockID block; + }; + SmallVector cases; + + // If we have tried to optimize code for this block but failed, + // keep track of this. + bool disable_block_optimization = false; + + // If the continue block is complex, fallback to "dumb" for loops. + bool complex_continue = false; + + // Do we need a ladder variable to defer breaking out of a loop construct after a switch block? + bool need_ladder_break = false; + + // If marked, we have explicitly handled Phi from this block, so skip any flushes related to that on a branch. + // Used to handle an edge case with switch and case-label fallthrough where fall-through writes to Phi. + BlockID ignore_phi_from_block = 0; + + // The dominating block which this block might be within. + // Used in continue; blocks to determine if we really need to write continue. + BlockID loop_dominator = 0; + + // All access to these variables are dominated by this block, + // so before branching anywhere we need to make sure that we declare these variables. + SmallVector dominated_variables; + + // These are variables which should be declared in a for loop header, if we + // fail to use a classic for-loop, + // we remove these variables, and fall back to regular variables outside the loop. + SmallVector loop_variables; + + // Some expressions are control-flow dependent, i.e. any instruction which relies on derivatives or + // sub-group-like operations. + // Make sure that we only use these expressions in the original block. + SmallVector invalidate_expressions; + + SPIRV_CROSS_DECLARE_CLONE(SPIRBlock) +}; + +struct SPIRFunction : IVariant +{ + enum + { + type = TypeFunction + }; + + SPIRFunction(TypeID return_type_, TypeID function_type_) + : return_type(return_type_) + , function_type(function_type_) + { + } + + struct Parameter + { + TypeID type; + ID id; + uint32_t read_count; + uint32_t write_count; + + // Set to true if this parameter aliases a global variable, + // used mostly in Metal where global variables + // have to be passed down to functions as regular arguments. + // However, for this kind of variable, we should not care about + // read and write counts as access to the function arguments + // is not local to the function in question. + bool alias_global_variable; + }; + + // When calling a function, and we're remapping separate image samplers, + // resolve these arguments into combined image samplers and pass them + // as additional arguments in this order. + // It gets more complicated as functions can pull in their own globals + // and combine them with parameters, + // so we need to distinguish if something is local parameter index + // or a global ID. + struct CombinedImageSamplerParameter + { + VariableID id; + VariableID image_id; + VariableID sampler_id; + bool global_image; + bool global_sampler; + bool depth; + }; + + TypeID return_type; + TypeID function_type; + SmallVector arguments; + + // Can be used by backends to add magic arguments. + // Currently used by combined image/sampler implementation. + + SmallVector shadow_arguments; + SmallVector local_variables; + BlockID entry_block = 0; + SmallVector blocks; + SmallVector combined_parameters; + + struct EntryLine + { + uint32_t file_id = 0; + uint32_t line_literal = 0; + }; + EntryLine entry_line; + + void add_local_variable(VariableID id) + { + local_variables.push_back(id); + } + + void add_parameter(TypeID parameter_type, ID id, bool alias_global_variable = false) + { + // Arguments are read-only until proven otherwise. + arguments.push_back({ parameter_type, id, 0u, 0u, alias_global_variable }); + } + + // Hooks to be run when the function returns. + // Mostly used for lowering internal data structures onto flattened structures. + // Need to defer this, because they might rely on things which change during compilation. + // Intentionally not a small vector, this one is rare, and std::function can be large. + Vector> fixup_hooks_out; + + // Hooks to be run when the function begins. + // Mostly used for populating internal data structures from flattened structures. + // Need to defer this, because they might rely on things which change during compilation. + // Intentionally not a small vector, this one is rare, and std::function can be large. + Vector> fixup_hooks_in; + + // On function entry, make sure to copy a constant array into thread addr space to work around + // the case where we are passing a constant array by value to a function on backends which do not + // consider arrays value types. + SmallVector constant_arrays_needed_on_stack; + + bool active = false; + bool flush_undeclared = true; + bool do_combined_parameters = true; + + SPIRV_CROSS_DECLARE_CLONE(SPIRFunction) +}; + +struct SPIRAccessChain : IVariant +{ + enum + { + type = TypeAccessChain + }; + + SPIRAccessChain(TypeID basetype_, spv::StorageClass storage_, std::string base_, std::string dynamic_index_, + int32_t static_index_) + : basetype(basetype_) + , storage(storage_) + , base(std::move(base_)) + , dynamic_index(std::move(dynamic_index_)) + , static_index(static_index_) + { + } + + // The access chain represents an offset into a buffer. + // Some backends need more complicated handling of access chains to be able to use buffers, like HLSL + // which has no usable buffer type ala GLSL SSBOs. + // StructuredBuffer is too limited, so our only option is to deal with ByteAddressBuffer which works with raw addresses. + + TypeID basetype; + spv::StorageClass storage; + std::string base; + std::string dynamic_index; + int32_t static_index; + + VariableID loaded_from = 0; + uint32_t matrix_stride = 0; + uint32_t array_stride = 0; + bool row_major_matrix = false; + bool immutable = false; + + // By reading this expression, we implicitly read these expressions as well. + // Used by access chain Store and Load since we read multiple expressions in this case. + SmallVector implied_read_expressions; + + SPIRV_CROSS_DECLARE_CLONE(SPIRAccessChain) +}; + +struct SPIRVariable : IVariant +{ + enum + { + type = TypeVariable + }; + + SPIRVariable() = default; + SPIRVariable(TypeID basetype_, spv::StorageClass storage_, ID initializer_ = 0, VariableID basevariable_ = 0) + : basetype(basetype_) + , storage(storage_) + , initializer(initializer_) + , basevariable(basevariable_) + { + } + + TypeID basetype = 0; + spv::StorageClass storage = spv::StorageClassGeneric; + uint32_t decoration = 0; + ID initializer = 0; + VariableID basevariable = 0; + + SmallVector dereference_chain; + bool compat_builtin = false; + + // If a variable is shadowed, we only statically assign to it + // and never actually emit a statement for it. + // When we read the variable as an expression, just forward + // shadowed_id as the expression. + bool statically_assigned = false; + ID static_expression = 0; + + // Temporaries which can remain forwarded as long as this variable is not modified. + SmallVector dependees; + bool forwardable = true; + + bool deferred_declaration = false; + bool phi_variable = false; + + // Used to deal with Phi variable flushes. See flush_phi(). + bool allocate_temporary_copy = false; + + bool remapped_variable = false; + uint32_t remapped_components = 0; + + // The block which dominates all access to this variable. + BlockID dominator = 0; + // If true, this variable is a loop variable, when accessing the variable + // outside a loop, + // we should statically forward it. + bool loop_variable = false; + // Set to true while we're inside the for loop. + bool loop_variable_enable = false; + + SPIRFunction::Parameter *parameter = nullptr; + + SPIRV_CROSS_DECLARE_CLONE(SPIRVariable) +}; + +struct SPIRConstant : IVariant +{ + enum + { + type = TypeConstant + }; + + union Constant { + uint32_t u32; + int32_t i32; + float f32; + + uint64_t u64; + int64_t i64; + double f64; + }; + + struct ConstantVector + { + Constant r[4]; + // If != 0, this element is a specialization constant, and we should keep track of it as such. + ID id[4]; + uint32_t vecsize = 1; + + ConstantVector() + { + memset(r, 0, sizeof(r)); + } + }; + + struct ConstantMatrix + { + ConstantVector c[4]; + // If != 0, this column is a specialization constant, and we should keep track of it as such. + ID id[4]; + uint32_t columns = 1; + }; + + static inline float f16_to_f32(uint16_t u16_value) + { + // Based on the GLM implementation. + int s = (u16_value >> 15) & 0x1; + int e = (u16_value >> 10) & 0x1f; + int m = (u16_value >> 0) & 0x3ff; + + union { + float f32; + uint32_t u32; + } u; + + if (e == 0) + { + if (m == 0) + { + u.u32 = uint32_t(s) << 31; + return u.f32; + } + else + { + while ((m & 0x400) == 0) + { + m <<= 1; + e--; + } + + e++; + m &= ~0x400; + } + } + else if (e == 31) + { + if (m == 0) + { + u.u32 = (uint32_t(s) << 31) | 0x7f800000u; + return u.f32; + } + else + { + u.u32 = (uint32_t(s) << 31) | 0x7f800000u | (m << 13); + return u.f32; + } + } + + e += 127 - 15; + m <<= 13; + u.u32 = (uint32_t(s) << 31) | (e << 23) | m; + return u.f32; + } + + inline uint32_t specialization_constant_id(uint32_t col, uint32_t row) const + { + return m.c[col].id[row]; + } + + inline uint32_t specialization_constant_id(uint32_t col) const + { + return m.id[col]; + } + + inline uint32_t scalar(uint32_t col = 0, uint32_t row = 0) const + { + return m.c[col].r[row].u32; + } + + inline int16_t scalar_i16(uint32_t col = 0, uint32_t row = 0) const + { + return int16_t(m.c[col].r[row].u32 & 0xffffu); + } + + inline uint16_t scalar_u16(uint32_t col = 0, uint32_t row = 0) const + { + return uint16_t(m.c[col].r[row].u32 & 0xffffu); + } + + inline int8_t scalar_i8(uint32_t col = 0, uint32_t row = 0) const + { + return int8_t(m.c[col].r[row].u32 & 0xffu); + } + + inline uint8_t scalar_u8(uint32_t col = 0, uint32_t row = 0) const + { + return uint8_t(m.c[col].r[row].u32 & 0xffu); + } + + inline float scalar_f16(uint32_t col = 0, uint32_t row = 0) const + { + return f16_to_f32(scalar_u16(col, row)); + } + + inline float scalar_f32(uint32_t col = 0, uint32_t row = 0) const + { + return m.c[col].r[row].f32; + } + + inline int32_t scalar_i32(uint32_t col = 0, uint32_t row = 0) const + { + return m.c[col].r[row].i32; + } + + inline double scalar_f64(uint32_t col = 0, uint32_t row = 0) const + { + return m.c[col].r[row].f64; + } + + inline int64_t scalar_i64(uint32_t col = 0, uint32_t row = 0) const + { + return m.c[col].r[row].i64; + } + + inline uint64_t scalar_u64(uint32_t col = 0, uint32_t row = 0) const + { + return m.c[col].r[row].u64; + } + + inline const ConstantVector &vector() const + { + return m.c[0]; + } + + inline uint32_t vector_size() const + { + return m.c[0].vecsize; + } + + inline uint32_t columns() const + { + return m.columns; + } + + inline void make_null(const SPIRType &constant_type_) + { + m = {}; + m.columns = constant_type_.columns; + for (auto &c : m.c) + c.vecsize = constant_type_.vecsize; + } + + inline bool constant_is_null() const + { + if (specialization) + return false; + if (!subconstants.empty()) + return false; + + for (uint32_t col = 0; col < columns(); col++) + for (uint32_t row = 0; row < vector_size(); row++) + if (scalar_u64(col, row) != 0) + return false; + + return true; + } + + explicit SPIRConstant(uint32_t constant_type_) + : constant_type(constant_type_) + { + } + + SPIRConstant() = default; + + SPIRConstant(TypeID constant_type_, const uint32_t *elements, uint32_t num_elements, bool specialized) + : constant_type(constant_type_) + , specialization(specialized) + { + subconstants.reserve(num_elements); + for (uint32_t i = 0; i < num_elements; i++) + subconstants.push_back(elements[i]); + specialization = specialized; + } + + // Construct scalar (32-bit). + SPIRConstant(TypeID constant_type_, uint32_t v0, bool specialized) + : constant_type(constant_type_) + , specialization(specialized) + { + m.c[0].r[0].u32 = v0; + m.c[0].vecsize = 1; + m.columns = 1; + } + + // Construct scalar (64-bit). + SPIRConstant(TypeID constant_type_, uint64_t v0, bool specialized) + : constant_type(constant_type_) + , specialization(specialized) + { + m.c[0].r[0].u64 = v0; + m.c[0].vecsize = 1; + m.columns = 1; + } + + // Construct vectors and matrices. + SPIRConstant(TypeID constant_type_, const SPIRConstant *const *vector_elements, uint32_t num_elements, + bool specialized) + : constant_type(constant_type_) + , specialization(specialized) + { + bool matrix = vector_elements[0]->m.c[0].vecsize > 1; + + if (matrix) + { + m.columns = num_elements; + + for (uint32_t i = 0; i < num_elements; i++) + { + m.c[i] = vector_elements[i]->m.c[0]; + if (vector_elements[i]->specialization) + m.id[i] = vector_elements[i]->self; + } + } + else + { + m.c[0].vecsize = num_elements; + m.columns = 1; + + for (uint32_t i = 0; i < num_elements; i++) + { + m.c[0].r[i] = vector_elements[i]->m.c[0].r[0]; + if (vector_elements[i]->specialization) + m.c[0].id[i] = vector_elements[i]->self; + } + } + } + + TypeID constant_type = 0; + ConstantMatrix m; + + // If this constant is a specialization constant (i.e. created with OpSpecConstant*). + bool specialization = false; + // If this constant is used as an array length which creates specialization restrictions on some backends. + bool is_used_as_array_length = false; + + // If true, this is a LUT, and should always be declared in the outer scope. + bool is_used_as_lut = false; + + // For composites which are constant arrays, etc. + SmallVector subconstants; + + // Non-Vulkan GLSL, HLSL and sometimes MSL emits defines for each specialization constant, + // and uses them to initialize the constant. This allows the user + // to still be able to specialize the value by supplying corresponding + // preprocessor directives before compiling the shader. + std::string specialization_constant_macro_name; + + SPIRV_CROSS_DECLARE_CLONE(SPIRConstant) +}; + +// Variants have a very specific allocation scheme. +struct ObjectPoolGroup +{ + std::unique_ptr pools[TypeCount]; +}; + +class Variant +{ +public: + explicit Variant(ObjectPoolGroup *group_) + : group(group_) + { + } + + ~Variant() + { + if (holder) + group->pools[type]->free_opaque(holder); + } + + // Marking custom move constructor as noexcept is important. + Variant(Variant &&other) SPIRV_CROSS_NOEXCEPT + { + *this = std::move(other); + } + + // We cannot copy from other variant without our own pool group. + // Have to explicitly copy. + Variant(const Variant &variant) = delete; + + // Marking custom move constructor as noexcept is important. + Variant &operator=(Variant &&other) SPIRV_CROSS_NOEXCEPT + { + if (this != &other) + { + if (holder) + group->pools[type]->free_opaque(holder); + holder = other.holder; + group = other.group; + type = other.type; + allow_type_rewrite = other.allow_type_rewrite; + + other.holder = nullptr; + other.type = TypeNone; + } + return *this; + } + + // This copy/clone should only be called in the Compiler constructor. + // If this is called inside ::compile(), we invalidate any references we took higher in the stack. + // This should never happen. + Variant &operator=(const Variant &other) + { +//#define SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE +#ifdef SPIRV_CROSS_COPY_CONSTRUCTOR_SANITIZE + abort(); +#endif + if (this != &other) + { + if (holder) + group->pools[type]->free_opaque(holder); + + if (other.holder) + holder = other.holder->clone(group->pools[other.type].get()); + else + holder = nullptr; + + type = other.type; + allow_type_rewrite = other.allow_type_rewrite; + } + return *this; + } + + void set(IVariant *val, Types new_type) + { + if (holder) + group->pools[type]->free_opaque(holder); + holder = nullptr; + + if (!allow_type_rewrite && type != TypeNone && type != new_type) + { + if (val) + group->pools[new_type]->free_opaque(val); + SPIRV_CROSS_THROW("Overwriting a variant with new type."); + } + + holder = val; + type = new_type; + allow_type_rewrite = false; + } + + template + T *allocate_and_set(Types new_type, Ts &&... ts) + { + T *val = static_cast &>(*group->pools[new_type]).allocate(std::forward(ts)...); + set(val, new_type); + return val; + } + + template + T &get() + { + if (!holder) + SPIRV_CROSS_THROW("nullptr"); + if (static_cast(T::type) != type) + SPIRV_CROSS_THROW("Bad cast"); + return *static_cast(holder); + } + + template + const T &get() const + { + if (!holder) + SPIRV_CROSS_THROW("nullptr"); + if (static_cast(T::type) != type) + SPIRV_CROSS_THROW("Bad cast"); + return *static_cast(holder); + } + + Types get_type() const + { + return type; + } + + ID get_id() const + { + return holder ? holder->self : ID(0); + } + + bool empty() const + { + return !holder; + } + + void reset() + { + if (holder) + group->pools[type]->free_opaque(holder); + holder = nullptr; + type = TypeNone; + } + + void set_allow_type_rewrite() + { + allow_type_rewrite = true; + } + +private: + ObjectPoolGroup *group = nullptr; + IVariant *holder = nullptr; + Types type = TypeNone; + bool allow_type_rewrite = false; +}; + +template +T &variant_get(Variant &var) +{ + return var.get(); +} + +template +const T &variant_get(const Variant &var) +{ + return var.get(); +} + +template +T &variant_set(Variant &var, P &&... args) +{ + auto *ptr = var.allocate_and_set(static_cast(T::type), std::forward

(args)...); + return *ptr; +} + +struct AccessChainMeta +{ + uint32_t storage_physical_type = 0; + bool need_transpose = false; + bool storage_is_packed = false; + bool storage_is_invariant = false; +}; + +enum ExtendedDecorations +{ + // Marks if a buffer block is re-packed, i.e. member declaration might be subject to PhysicalTypeID remapping and padding. + SPIRVCrossDecorationBufferBlockRepacked = 0, + + // A type in a buffer block might be declared with a different physical type than the logical type. + // If this is not set, PhysicalTypeID == the SPIR-V type as declared. + SPIRVCrossDecorationPhysicalTypeID, + + // Marks if the physical type is to be declared with tight packing rules, i.e. packed_floatN on MSL and friends. + // If this is set, PhysicalTypeID might also be set. It can be set to same as logical type if all we're doing + // is converting float3 to packed_float3 for example. + // If this is marked on a struct, it means the struct itself must use only Packed types for all its members. + SPIRVCrossDecorationPhysicalTypePacked, + + // The padding in bytes before declaring this struct member. + // If used on a struct type, marks the target size of a struct. + SPIRVCrossDecorationPaddingTarget, + + SPIRVCrossDecorationInterfaceMemberIndex, + SPIRVCrossDecorationInterfaceOrigID, + SPIRVCrossDecorationResourceIndexPrimary, + // Used for decorations like resource indices for samplers when part of combined image samplers. + // A variable might need to hold two resource indices in this case. + SPIRVCrossDecorationResourceIndexSecondary, + // Used for resource indices for multiplanar images when part of combined image samplers. + SPIRVCrossDecorationResourceIndexTertiary, + SPIRVCrossDecorationResourceIndexQuaternary, + + // Marks a buffer block for using explicit offsets (GLSL/HLSL). + SPIRVCrossDecorationExplicitOffset, + + // Apply to a variable in the Input storage class; marks it as holding the base group passed to vkCmdDispatchBase(). + // In MSL, this is used to adjust the WorkgroupId and GlobalInvocationId variables. + SPIRVCrossDecorationBuiltInDispatchBase, + + // Apply to a variable that is a function parameter; marks it as being a "dynamic" + // combined image-sampler. In MSL, this is used when a function parameter might hold + // either a regular combined image-sampler or one that has an attached sampler + // Y'CbCr conversion. + SPIRVCrossDecorationDynamicImageSampler, + + SPIRVCrossDecorationCount +}; + +struct Meta +{ + struct Decoration + { + std::string alias; + std::string qualified_alias; + std::string hlsl_semantic; + Bitset decoration_flags; + spv::BuiltIn builtin_type = spv::BuiltInMax; + uint32_t location = 0; + uint32_t component = 0; + uint32_t set = 0; + uint32_t binding = 0; + uint32_t offset = 0; + uint32_t xfb_buffer = 0; + uint32_t xfb_stride = 0; + uint32_t array_stride = 0; + uint32_t matrix_stride = 0; + uint32_t input_attachment = 0; + uint32_t spec_id = 0; + uint32_t index = 0; + spv::FPRoundingMode fp_rounding_mode = spv::FPRoundingModeMax; + bool builtin = false; + + struct Extended + { + Extended() + { + // MSVC 2013 workaround to init like this. + for (auto &v : values) + v = 0; + } + + Bitset flags; + uint32_t values[SPIRVCrossDecorationCount]; + } extended; + }; + + Decoration decoration; + + // Intentionally not a SmallVector. Decoration is large and somewhat rare. + Vector members; + + std::unordered_map decoration_word_offset; + + // For SPV_GOOGLE_hlsl_functionality1. + bool hlsl_is_magic_counter_buffer = false; + // ID for the sibling counter buffer. + uint32_t hlsl_magic_counter_buffer = 0; +}; + +// A user callback that remaps the type of any variable. +// var_name is the declared name of the variable. +// name_of_type is the textual name of the type which will be used in the code unless written to by the callback. +using VariableTypeRemapCallback = + std::function; + +class Hasher +{ +public: + inline void u32(uint32_t value) + { + h = (h * 0x100000001b3ull) ^ value; + } + + inline uint64_t get() const + { + return h; + } + +private: + uint64_t h = 0xcbf29ce484222325ull; +}; + +static inline bool type_is_floating_point(const SPIRType &type) +{ + return type.basetype == SPIRType::Half || type.basetype == SPIRType::Float || type.basetype == SPIRType::Double; +} + +static inline bool type_is_integral(const SPIRType &type) +{ + return type.basetype == SPIRType::SByte || type.basetype == SPIRType::UByte || type.basetype == SPIRType::Short || + type.basetype == SPIRType::UShort || type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt || + type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64; +} + +static inline SPIRType::BaseType to_signed_basetype(uint32_t width) +{ + switch (width) + { + case 8: + return SPIRType::SByte; + case 16: + return SPIRType::Short; + case 32: + return SPIRType::Int; + case 64: + return SPIRType::Int64; + default: + SPIRV_CROSS_THROW("Invalid bit width."); + } +} + +static inline SPIRType::BaseType to_unsigned_basetype(uint32_t width) +{ + switch (width) + { + case 8: + return SPIRType::UByte; + case 16: + return SPIRType::UShort; + case 32: + return SPIRType::UInt; + case 64: + return SPIRType::UInt64; + default: + SPIRV_CROSS_THROW("Invalid bit width."); + } +} + +// Returns true if an arithmetic operation does not change behavior depending on signedness. +static inline bool opcode_is_sign_invariant(spv::Op opcode) +{ + switch (opcode) + { + case spv::OpIEqual: + case spv::OpINotEqual: + case spv::OpISub: + case spv::OpIAdd: + case spv::OpIMul: + case spv::OpShiftLeftLogical: + case spv::OpBitwiseOr: + case spv::OpBitwiseXor: + case spv::OpBitwiseAnd: + return true; + + default: + return false; + } +} + +struct SetBindingPair +{ + uint32_t desc_set; + uint32_t binding; + + inline bool operator==(const SetBindingPair &other) const + { + return desc_set == other.desc_set && binding == other.binding; + } + + inline bool operator<(const SetBindingPair &other) const + { + return desc_set < other.desc_set || (desc_set == other.desc_set && binding < other.binding); + } +}; + +struct StageSetBinding +{ + spv::ExecutionModel model; + uint32_t desc_set; + uint32_t binding; + + inline bool operator==(const StageSetBinding &other) const + { + return model == other.model && desc_set == other.desc_set && binding == other.binding; + } +}; + +struct InternalHasher +{ + inline size_t operator()(const SetBindingPair &value) const + { + // Quality of hash doesn't really matter here. + auto hash_set = std::hash()(value.desc_set); + auto hash_binding = std::hash()(value.binding); + return (hash_set * 0x10001b31) ^ hash_binding; + } + + inline size_t operator()(const StageSetBinding &value) const + { + // Quality of hash doesn't really matter here. + auto hash_model = std::hash()(value.model); + auto hash_set = std::hash()(value.desc_set); + auto tmp_hash = (hash_model * 0x10001b31) ^ hash_set; + return (tmp_hash * 0x10001b31) ^ value.binding; + } +}; + +// Special constant used in a {MSL,HLSL}ResourceBinding desc_set +// element to indicate the bindings for the push constants. +static const uint32_t ResourceBindingPushConstantDescriptorSet = ~(0u); + +// Special constant used in a {MSL,HLSL}ResourceBinding binding +// element to indicate the bindings for the push constants. +static const uint32_t ResourceBindingPushConstantBinding = 0; +} // namespace SPIRV_CROSS_NAMESPACE + +namespace std +{ +template +struct hash> +{ + size_t operator()(const SPIRV_CROSS_NAMESPACE::TypedID &value) const + { + return std::hash()(value); + } +}; +} // namespace std + +#endif diff --git a/ios/include/spirv_cross/spirv_cpp.hpp b/ios/include/spirv_cross/spirv_cpp.hpp new file mode 100644 index 00000000..e78d0369 --- /dev/null +++ b/ios/include/spirv_cross/spirv_cpp.hpp @@ -0,0 +1,86 @@ +/* + * Copyright 2015-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_CPP_HPP +#define SPIRV_CROSS_CPP_HPP + +#include "spirv_glsl.hpp" +#include + +namespace SPIRV_CROSS_NAMESPACE +{ +class CompilerCPP : public CompilerGLSL +{ +public: + explicit CompilerCPP(std::vector spirv_) + : CompilerGLSL(std::move(spirv_)) + { + } + + CompilerCPP(const uint32_t *ir_, size_t word_count) + : CompilerGLSL(ir_, word_count) + { + } + + explicit CompilerCPP(const ParsedIR &ir_) + : CompilerGLSL(ir_) + { + } + + explicit CompilerCPP(ParsedIR &&ir_) + : CompilerGLSL(std::move(ir_)) + { + } + + std::string compile() override; + + // Sets a custom symbol name that can override + // spirv_cross_get_interface. + // + // Useful when several shader interfaces are linked + // statically into the same binary. + void set_interface_name(std::string name) + { + interface_name = std::move(name); + } + +private: + void emit_header() override; + void emit_c_linkage(); + void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; + + void emit_resources(); + void emit_buffer_block(const SPIRVariable &type) override; + void emit_push_constant_block(const SPIRVariable &var) override; + void emit_interface_block(const SPIRVariable &type); + void emit_block_chain(SPIRBlock &block); + void emit_uniform(const SPIRVariable &var) override; + void emit_shared(const SPIRVariable &var); + void emit_block_struct(SPIRType &type); + std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id) override; + + std::string argument_decl(const SPIRFunction::Parameter &arg); + + SmallVector resource_registrations; + std::string impl_type; + std::string resource_type; + uint32_t shared_counter = 0; + + std::string interface_name; +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_cross.hpp b/ios/include/spirv_cross/spirv_cross.hpp new file mode 100644 index 00000000..373f9976 --- /dev/null +++ b/ios/include/spirv_cross/spirv_cross.hpp @@ -0,0 +1,1055 @@ +/* + * Copyright 2015-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_HPP +#define SPIRV_CROSS_HPP + +#include "spirv.hpp" +#include "spirv_cfg.hpp" +#include "spirv_cross_parsed_ir.hpp" + +namespace SPIRV_CROSS_NAMESPACE +{ +struct Resource +{ + // Resources are identified with their SPIR-V ID. + // This is the ID of the OpVariable. + ID id; + + // The type ID of the variable which includes arrays and all type modifications. + // This type ID is not suitable for parsing OpMemberDecoration of a struct and other decorations in general + // since these modifications typically happen on the base_type_id. + TypeID type_id; + + // The base type of the declared resource. + // This type is the base type which ignores pointers and arrays of the type_id. + // This is mostly useful to parse decorations of the underlying type. + // base_type_id can also be obtained with get_type(get_type(type_id).self). + TypeID base_type_id; + + // The declared name (OpName) of the resource. + // For Buffer blocks, the name actually reflects the externally + // visible Block name. + // + // This name can be retrieved again by using either + // get_name(id) or get_name(base_type_id) depending if it's a buffer block or not. + // + // This name can be an empty string in which case get_fallback_name(id) can be + // used which obtains a suitable fallback identifier for an ID. + std::string name; +}; + +struct ShaderResources +{ + SmallVector uniform_buffers; + SmallVector storage_buffers; + SmallVector stage_inputs; + SmallVector stage_outputs; + SmallVector subpass_inputs; + SmallVector storage_images; + SmallVector sampled_images; + SmallVector atomic_counters; + SmallVector acceleration_structures; + + // There can only be one push constant block, + // but keep the vector in case this restriction is lifted in the future. + SmallVector push_constant_buffers; + + // For Vulkan GLSL and HLSL source, + // these correspond to separate texture2D and samplers respectively. + SmallVector separate_images; + SmallVector separate_samplers; +}; + +struct CombinedImageSampler +{ + // The ID of the sampler2D variable. + VariableID combined_id; + // The ID of the texture2D variable. + VariableID image_id; + // The ID of the sampler variable. + VariableID sampler_id; +}; + +struct SpecializationConstant +{ + // The ID of the specialization constant. + ConstantID id; + // The constant ID of the constant, used in Vulkan during pipeline creation. + uint32_t constant_id; +}; + +struct BufferRange +{ + unsigned index; + size_t offset; + size_t range; +}; + +enum BufferPackingStandard +{ + BufferPackingStd140, + BufferPackingStd430, + BufferPackingStd140EnhancedLayout, + BufferPackingStd430EnhancedLayout, + BufferPackingHLSLCbuffer, + BufferPackingHLSLCbufferPackOffset, + BufferPackingScalar, + BufferPackingScalarEnhancedLayout +}; + +struct EntryPoint +{ + std::string name; + spv::ExecutionModel execution_model; +}; + +class Compiler +{ +public: + friend class CFG; + friend class DominatorBuilder; + + // The constructor takes a buffer of SPIR-V words and parses it. + // It will create its own parser, parse the SPIR-V and move the parsed IR + // as if you had called the constructors taking ParsedIR directly. + explicit Compiler(std::vector ir); + Compiler(const uint32_t *ir, size_t word_count); + + // This is more modular. We can also consume a ParsedIR structure directly, either as a move, or copy. + // With copy, we can reuse the same parsed IR for multiple Compiler instances. + explicit Compiler(const ParsedIR &ir); + explicit Compiler(ParsedIR &&ir); + + virtual ~Compiler() = default; + + // After parsing, API users can modify the SPIR-V via reflection and call this + // to disassemble the SPIR-V into the desired langauage. + // Sub-classes actually implement this. + virtual std::string compile(); + + // Gets the identifier (OpName) of an ID. If not defined, an empty string will be returned. + const std::string &get_name(ID id) const; + + // Applies a decoration to an ID. Effectively injects OpDecorate. + void set_decoration(ID id, spv::Decoration decoration, uint32_t argument = 0); + void set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument); + + // Overrides the identifier OpName of an ID. + // Identifiers beginning with underscores or identifiers which contain double underscores + // are reserved by the implementation. + void set_name(ID id, const std::string &name); + + // Gets a bitmask for the decorations which are applied to ID. + // I.e. (1ull << spv::DecorationFoo) | (1ull << spv::DecorationBar) + const Bitset &get_decoration_bitset(ID id) const; + + // Returns whether the decoration has been applied to the ID. + bool has_decoration(ID id, spv::Decoration decoration) const; + + // Gets the value for decorations which take arguments. + // If the decoration is a boolean (i.e. spv::DecorationNonWritable), + // 1 will be returned. + // If decoration doesn't exist or decoration is not recognized, + // 0 will be returned. + uint32_t get_decoration(ID id, spv::Decoration decoration) const; + const std::string &get_decoration_string(ID id, spv::Decoration decoration) const; + + // Removes the decoration for an ID. + void unset_decoration(ID id, spv::Decoration decoration); + + // Gets the SPIR-V type associated with ID. + // Mostly used with Resource::type_id and Resource::base_type_id to parse the underlying type of a resource. + const SPIRType &get_type(TypeID id) const; + + // Gets the SPIR-V type of a variable. + const SPIRType &get_type_from_variable(VariableID id) const; + + // Gets the underlying storage class for an OpVariable. + spv::StorageClass get_storage_class(VariableID id) const; + + // If get_name() is an empty string, get the fallback name which will be used + // instead in the disassembled source. + virtual const std::string get_fallback_name(ID id) const; + + // If get_name() of a Block struct is an empty string, get the fallback name. + // This needs to be per-variable as multiple variables can use the same block type. + virtual const std::string get_block_fallback_name(VariableID id) const; + + // Given an OpTypeStruct in ID, obtain the identifier for member number "index". + // This may be an empty string. + const std::string &get_member_name(TypeID id, uint32_t index) const; + + // Given an OpTypeStruct in ID, obtain the OpMemberDecoration for member number "index". + uint32_t get_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; + const std::string &get_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration) const; + + // Sets the member identifier for OpTypeStruct ID, member number "index". + void set_member_name(TypeID id, uint32_t index, const std::string &name); + + // Returns the qualified member identifier for OpTypeStruct ID, member number "index", + // or an empty string if no qualified alias exists + const std::string &get_member_qualified_name(TypeID type_id, uint32_t index) const; + + // Gets the decoration mask for a member of a struct, similar to get_decoration_mask. + const Bitset &get_member_decoration_bitset(TypeID id, uint32_t index) const; + + // Returns whether the decoration has been applied to a member of a struct. + bool has_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; + + // Similar to set_decoration, but for struct members. + void set_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration, uint32_t argument = 0); + void set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration, + const std::string &argument); + + // Unsets a member decoration, similar to unset_decoration. + void unset_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration); + + // Gets the fallback name for a member, similar to get_fallback_name. + virtual const std::string get_fallback_member_name(uint32_t index) const + { + return join("_", index); + } + + // Returns a vector of which members of a struct are potentially in use by a + // SPIR-V shader. The granularity of this analysis is per-member of a struct. + // This can be used for Buffer (UBO), BufferBlock/StorageBuffer (SSBO) and PushConstant blocks. + // ID is the Resource::id obtained from get_shader_resources(). + SmallVector get_active_buffer_ranges(VariableID id) const; + + // Returns the effective size of a buffer block. + size_t get_declared_struct_size(const SPIRType &struct_type) const; + + // Returns the effective size of a buffer block, with a given array size + // for a runtime array. + // SSBOs are typically declared as runtime arrays. get_declared_struct_size() will return 0 for the size. + // This is not very helpful for applications which might need to know the array stride of its last member. + // This can be done through the API, but it is not very intuitive how to accomplish this, so here we provide a helper function + // to query the size of the buffer, assuming that the last member has a certain size. + // If the buffer does not contain a runtime array, array_size is ignored, and the function will behave as + // get_declared_struct_size(). + // To get the array stride of the last member, something like: + // get_declared_struct_size_runtime_array(type, 1) - get_declared_struct_size_runtime_array(type, 0) will work. + size_t get_declared_struct_size_runtime_array(const SPIRType &struct_type, size_t array_size) const; + + // Returns the effective size of a buffer block struct member. + size_t get_declared_struct_member_size(const SPIRType &struct_type, uint32_t index) const; + + // Returns a set of all global variables which are statically accessed + // by the control flow graph from the current entry point. + // Only variables which change the interface for a shader are returned, that is, + // variables with storage class of Input, Output, Uniform, UniformConstant, PushConstant and AtomicCounter + // storage classes are returned. + // + // To use the returned set as the filter for which variables are used during compilation, + // this set can be moved to set_enabled_interface_variables(). + std::unordered_set get_active_interface_variables() const; + + // Sets the interface variables which are used during compilation. + // By default, all variables are used. + // Once set, compile() will only consider the set in active_variables. + void set_enabled_interface_variables(std::unordered_set active_variables); + + // Query shader resources, use ids with reflection interface to modify or query binding points, etc. + ShaderResources get_shader_resources() const; + + // Query shader resources, but only return the variables which are part of active_variables. + // E.g.: get_shader_resources(get_active_variables()) to only return the variables which are statically + // accessed. + ShaderResources get_shader_resources(const std::unordered_set &active_variables) const; + + // Remapped variables are considered built-in variables and a backend will + // not emit a declaration for this variable. + // This is mostly useful for making use of builtins which are dependent on extensions. + void set_remapped_variable_state(VariableID id, bool remap_enable); + bool get_remapped_variable_state(VariableID id) const; + + // For subpassInput variables which are remapped to plain variables, + // the number of components in the remapped + // variable must be specified as the backing type of subpass inputs are opaque. + void set_subpass_input_remapped_components(VariableID id, uint32_t components); + uint32_t get_subpass_input_remapped_components(VariableID id) const; + + // All operations work on the current entry point. + // Entry points can be swapped out with set_entry_point(). + // Entry points should be set right after the constructor completes as some reflection functions traverse the graph from the entry point. + // Resource reflection also depends on the entry point. + // By default, the current entry point is set to the first OpEntryPoint which appears in the SPIR-V module. + + // Some shader languages restrict the names that can be given to entry points, and the + // corresponding backend will automatically rename an entry point name, during the call + // to compile() if it is illegal. For example, the common entry point name main() is + // illegal in MSL, and is renamed to an alternate name by the MSL backend. + // Given the original entry point name contained in the SPIR-V, this function returns + // the name, as updated by the backend during the call to compile(). If the name is not + // illegal, and has not been renamed, or if this function is called before compile(), + // this function will simply return the same name. + + // New variants of entry point query and reflection. + // Names for entry points in the SPIR-V module may alias if they belong to different execution models. + // To disambiguate, we must pass along with the entry point names the execution model. + SmallVector get_entry_points_and_stages() const; + void set_entry_point(const std::string &entry, spv::ExecutionModel execution_model); + + // Renames an entry point from old_name to new_name. + // If old_name is currently selected as the current entry point, it will continue to be the current entry point, + // albeit with a new name. + // get_entry_points() is essentially invalidated at this point. + void rename_entry_point(const std::string &old_name, const std::string &new_name, + spv::ExecutionModel execution_model); + const SPIREntryPoint &get_entry_point(const std::string &name, spv::ExecutionModel execution_model) const; + SPIREntryPoint &get_entry_point(const std::string &name, spv::ExecutionModel execution_model); + const std::string &get_cleansed_entry_point_name(const std::string &name, + spv::ExecutionModel execution_model) const; + + // Traverses all reachable opcodes and sets active_builtins to a bitmask of all builtin variables which are accessed in the shader. + void update_active_builtins(); + bool has_active_builtin(spv::BuiltIn builtin, spv::StorageClass storage); + + // Query and modify OpExecutionMode. + const Bitset &get_execution_mode_bitset() const; + + void unset_execution_mode(spv::ExecutionMode mode); + void set_execution_mode(spv::ExecutionMode mode, uint32_t arg0 = 0, uint32_t arg1 = 0, uint32_t arg2 = 0); + + // Gets argument for an execution mode (LocalSize, Invocations, OutputVertices). + // For LocalSize, the index argument is used to select the dimension (X = 0, Y = 1, Z = 2). + // For execution modes which do not have arguments, 0 is returned. + uint32_t get_execution_mode_argument(spv::ExecutionMode mode, uint32_t index = 0) const; + spv::ExecutionModel get_execution_model() const; + + bool is_tessellation_shader() const; + + // In SPIR-V, the compute work group size can be represented by a constant vector, in which case + // the LocalSize execution mode is ignored. + // + // This constant vector can be a constant vector, specialization constant vector, or partly specialized constant vector. + // To modify and query work group dimensions which are specialization constants, SPIRConstant values must be modified + // directly via get_constant() rather than using LocalSize directly. This function will return which constants should be modified. + // + // To modify dimensions which are *not* specialization constants, set_execution_mode should be used directly. + // Arguments to set_execution_mode which are specialization constants are effectively ignored during compilation. + // NOTE: This is somewhat different from how SPIR-V works. In SPIR-V, the constant vector will completely replace LocalSize, + // while in this interface, LocalSize is only ignored for specialization constants. + // + // The specialization constant will be written to x, y and z arguments. + // If the component is not a specialization constant, a zeroed out struct will be written. + // The return value is the constant ID of the builtin WorkGroupSize, but this is not expected to be useful + // for most use cases. + uint32_t get_work_group_size_specialization_constants(SpecializationConstant &x, SpecializationConstant &y, + SpecializationConstant &z) const; + + // Analyzes all OpImageFetch (texelFetch) opcodes and checks if there are instances where + // said instruction is used without a combined image sampler. + // GLSL targets do not support the use of texelFetch without a sampler. + // To workaround this, we must inject a dummy sampler which can be used to form a sampler2D at the call-site of + // texelFetch as necessary. + // + // This must be called before build_combined_image_samplers(). + // build_combined_image_samplers() may refer to the ID returned by this method if the returned ID is non-zero. + // The return value will be the ID of a sampler object if a dummy sampler is necessary, or 0 if no sampler object + // is required. + // + // If the returned ID is non-zero, it can be decorated with set/bindings as desired before calling compile(). + // Calling this function also invalidates get_active_interface_variables(), so this should be called + // before that function. + VariableID build_dummy_sampler_for_combined_images(); + + // Analyzes all separate image and samplers used from the currently selected entry point, + // and re-routes them all to a combined image sampler instead. + // This is required to "support" separate image samplers in targets which do not natively support + // this feature, like GLSL/ESSL. + // + // This must be called before compile() if such remapping is desired. + // This call will add new sampled images to the SPIR-V, + // so it will appear in reflection if get_shader_resources() is called after build_combined_image_samplers. + // + // If any image/sampler remapping was found, no separate image/samplers will appear in the decompiled output, + // but will still appear in reflection. + // + // The resulting samplers will be void of any decorations like name, descriptor sets and binding points, + // so this can be added before compile() if desired. + // + // Combined image samplers originating from this set are always considered active variables. + // Arrays of separate samplers are not supported, but arrays of separate images are supported. + // Array of images + sampler -> Array of combined image samplers. + void build_combined_image_samplers(); + + // Gets a remapping for the combined image samplers. + const SmallVector &get_combined_image_samplers() const + { + return combined_image_samplers; + } + + // Set a new variable type remap callback. + // The type remapping is designed to allow global interface variable to assume more special types. + // A typical example here is to remap sampler2D into samplerExternalOES, which currently isn't supported + // directly by SPIR-V. + // + // In compile() while emitting code, + // for every variable that is declared, including function parameters, the callback will be called + // and the API user has a chance to change the textual representation of the type used to declare the variable. + // The API user can detect special patterns in names to guide the remapping. + void set_variable_type_remap_callback(VariableTypeRemapCallback cb) + { + variable_remap_callback = std::move(cb); + } + + // API for querying which specialization constants exist. + // To modify a specialization constant before compile(), use get_constant(constant.id), + // then update constants directly in the SPIRConstant data structure. + // For composite types, the subconstants can be iterated over and modified. + // constant_type is the SPIRType for the specialization constant, + // which can be queried to determine which fields in the unions should be poked at. + SmallVector get_specialization_constants() const; + SPIRConstant &get_constant(ConstantID id); + const SPIRConstant &get_constant(ConstantID id) const; + + uint32_t get_current_id_bound() const + { + return uint32_t(ir.ids.size()); + } + + // API for querying buffer objects. + // The type passed in here should be the base type of a resource, i.e. + // get_type(resource.base_type_id) + // as decorations are set in the basic Block type. + // The type passed in here must have these decorations set, or an exception is raised. + // Only UBOs and SSBOs or sub-structs which are part of these buffer types will have these decorations set. + uint32_t type_struct_member_offset(const SPIRType &type, uint32_t index) const; + uint32_t type_struct_member_array_stride(const SPIRType &type, uint32_t index) const; + uint32_t type_struct_member_matrix_stride(const SPIRType &type, uint32_t index) const; + + // Gets the offset in SPIR-V words (uint32_t) for a decoration which was originally declared in the SPIR-V binary. + // The offset will point to one or more uint32_t literals which can be modified in-place before using the SPIR-V binary. + // Note that adding or removing decorations using the reflection API will not change the behavior of this function. + // If the decoration was declared, sets the word_offset to an offset into the provided SPIR-V binary buffer and returns true, + // otherwise, returns false. + // If the decoration does not have any value attached to it (e.g. DecorationRelaxedPrecision), this function will also return false. + bool get_binary_offset_for_decoration(VariableID id, spv::Decoration decoration, uint32_t &word_offset) const; + + // HLSL counter buffer reflection interface. + // Append/Consume/Increment/Decrement in HLSL is implemented as two "neighbor" buffer objects where + // one buffer implements the storage, and a single buffer containing just a lone "int" implements the counter. + // To SPIR-V these will be exposed as two separate buffers, but glslang HLSL frontend emits a special indentifier + // which lets us link the two buffers together. + + // Queries if a variable ID is a counter buffer which "belongs" to a regular buffer object. + + // If SPV_GOOGLE_hlsl_functionality1 is used, this can be used even with a stripped SPIR-V module. + // Otherwise, this query is purely based on OpName identifiers as found in the SPIR-V module, and will + // only return true if OpSource was reported HLSL. + // To rely on this functionality, ensure that the SPIR-V module is not stripped. + + bool buffer_is_hlsl_counter_buffer(VariableID id) const; + + // Queries if a buffer object has a neighbor "counter" buffer. + // If so, the ID of that counter buffer will be returned in counter_id. + // If SPV_GOOGLE_hlsl_functionality1 is used, this can be used even with a stripped SPIR-V module. + // Otherwise, this query is purely based on OpName identifiers as found in the SPIR-V module, and will + // only return true if OpSource was reported HLSL. + // To rely on this functionality, ensure that the SPIR-V module is not stripped. + bool buffer_get_hlsl_counter_buffer(VariableID id, uint32_t &counter_id) const; + + // Gets the list of all SPIR-V Capabilities which were declared in the SPIR-V module. + const SmallVector &get_declared_capabilities() const; + + // Gets the list of all SPIR-V extensions which were declared in the SPIR-V module. + const SmallVector &get_declared_extensions() const; + + // When declaring buffer blocks in GLSL, the name declared in the GLSL source + // might not be the same as the name declared in the SPIR-V module due to naming conflicts. + // In this case, SPIRV-Cross needs to find a fallback-name, and it might only + // be possible to know this name after compiling to GLSL. + // This is particularly important for HLSL input and UAVs which tends to reuse the same block type + // for multiple distinct blocks. For these cases it is not possible to modify the name of the type itself + // because it might be unique. Instead, you can use this interface to check after compilation which + // name was actually used if your input SPIR-V tends to have this problem. + // For other names like remapped names for variables, etc, it's generally enough to query the name of the variables + // after compiling, block names are an exception to this rule. + // ID is the name of a variable as returned by Resource::id, and must be a variable with a Block-like type. + // + // This also applies to HLSL cbuffers. + std::string get_remapped_declared_block_name(VariableID id) const; + + // For buffer block variables, get the decorations for that variable. + // Sometimes, decorations for buffer blocks are found in member decorations instead + // of direct decorations on the variable itself. + // The most common use here is to check if a buffer is readonly or writeonly. + Bitset get_buffer_block_flags(VariableID id) const; + +protected: + const uint32_t *stream(const Instruction &instr) const + { + // If we're not going to use any arguments, just return nullptr. + // We want to avoid case where we return an out of range pointer + // that trips debug assertions on some platforms. + if (!instr.length) + return nullptr; + + if (instr.offset + instr.length > ir.spirv.size()) + SPIRV_CROSS_THROW("Compiler::stream() out of range."); + return &ir.spirv[instr.offset]; + } + + ParsedIR ir; + // Marks variables which have global scope and variables which can alias with other variables + // (SSBO, image load store, etc) + SmallVector global_variables; + SmallVector aliased_variables; + + SPIRFunction *current_function = nullptr; + SPIRBlock *current_block = nullptr; + std::unordered_set active_interface_variables; + bool check_active_interface_variables = false; + + // If our IDs are out of range here as part of opcodes, throw instead of + // undefined behavior. + template + T &set(uint32_t id, P &&... args) + { + ir.add_typed_id(static_cast(T::type), id); + auto &var = variant_set(ir.ids[id], std::forward

(args)...); + var.self = id; + return var; + } + + template + T &get(uint32_t id) + { + return variant_get(ir.ids[id]); + } + + template + T *maybe_get(uint32_t id) + { + if (id >= ir.ids.size()) + return nullptr; + else if (ir.ids[id].get_type() == static_cast(T::type)) + return &get(id); + else + return nullptr; + } + + template + const T &get(uint32_t id) const + { + return variant_get(ir.ids[id]); + } + + template + const T *maybe_get(uint32_t id) const + { + if (id >= ir.ids.size()) + return nullptr; + else if (ir.ids[id].get_type() == static_cast(T::type)) + return &get(id); + else + return nullptr; + } + + // Gets the id of SPIR-V type underlying the given type_id, which might be a pointer. + uint32_t get_pointee_type_id(uint32_t type_id) const; + + // Gets the SPIR-V type underlying the given type, which might be a pointer. + const SPIRType &get_pointee_type(const SPIRType &type) const; + + // Gets the SPIR-V type underlying the given type_id, which might be a pointer. + const SPIRType &get_pointee_type(uint32_t type_id) const; + + // Gets the ID of the SPIR-V type underlying a variable. + uint32_t get_variable_data_type_id(const SPIRVariable &var) const; + + // Gets the SPIR-V type underlying a variable. + SPIRType &get_variable_data_type(const SPIRVariable &var); + + // Gets the SPIR-V type underlying a variable. + const SPIRType &get_variable_data_type(const SPIRVariable &var) const; + + // Gets the SPIR-V element type underlying an array variable. + SPIRType &get_variable_element_type(const SPIRVariable &var); + + // Gets the SPIR-V element type underlying an array variable. + const SPIRType &get_variable_element_type(const SPIRVariable &var) const; + + // Sets the qualified member identifier for OpTypeStruct ID, member number "index". + void set_member_qualified_name(uint32_t type_id, uint32_t index, const std::string &name); + void set_qualified_name(uint32_t id, const std::string &name); + + // Returns if the given type refers to a sampled image. + bool is_sampled_image_type(const SPIRType &type); + + const SPIREntryPoint &get_entry_point() const; + SPIREntryPoint &get_entry_point(); + static bool is_tessellation_shader(spv::ExecutionModel model); + + virtual std::string to_name(uint32_t id, bool allow_alias = true) const; + bool is_builtin_variable(const SPIRVariable &var) const; + bool is_builtin_type(const SPIRType &type) const; + bool is_hidden_variable(const SPIRVariable &var, bool include_builtins = false) const; + bool is_immutable(uint32_t id) const; + bool is_member_builtin(const SPIRType &type, uint32_t index, spv::BuiltIn *builtin) const; + bool is_scalar(const SPIRType &type) const; + bool is_vector(const SPIRType &type) const; + bool is_matrix(const SPIRType &type) const; + bool is_array(const SPIRType &type) const; + uint32_t expression_type_id(uint32_t id) const; + const SPIRType &expression_type(uint32_t id) const; + bool expression_is_lvalue(uint32_t id) const; + bool variable_storage_is_aliased(const SPIRVariable &var); + SPIRVariable *maybe_get_backing_variable(uint32_t chain); + spv::StorageClass get_backing_variable_storage(uint32_t ptr); + + void register_read(uint32_t expr, uint32_t chain, bool forwarded); + void register_write(uint32_t chain); + + inline bool is_continue(uint32_t next) const + { + return (ir.block_meta[next] & ParsedIR::BLOCK_META_CONTINUE_BIT) != 0; + } + + inline bool is_single_block_loop(uint32_t next) const + { + auto &block = get(next); + return block.merge == SPIRBlock::MergeLoop && block.continue_block == ID(next); + } + + inline bool is_break(uint32_t next) const + { + return (ir.block_meta[next] & + (ParsedIR::BLOCK_META_LOOP_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT)) != 0; + } + + inline bool is_loop_break(uint32_t next) const + { + return (ir.block_meta[next] & ParsedIR::BLOCK_META_LOOP_MERGE_BIT) != 0; + } + + inline bool is_conditional(uint32_t next) const + { + return (ir.block_meta[next] & + (ParsedIR::BLOCK_META_SELECTION_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT)) != 0; + } + + // Dependency tracking for temporaries read from variables. + void flush_dependees(SPIRVariable &var); + void flush_all_active_variables(); + void flush_control_dependent_expressions(uint32_t block); + void flush_all_atomic_capable_variables(); + void flush_all_aliased_variables(); + void register_global_read_dependencies(const SPIRBlock &func, uint32_t id); + void register_global_read_dependencies(const SPIRFunction &func, uint32_t id); + std::unordered_set invalid_expressions; + + void update_name_cache(std::unordered_set &cache, std::string &name); + + // A variant which takes two sets of names. The secondary is only used to verify there are no collisions, + // but the set is not updated when we have found a new name. + // Used primarily when adding block interface names. + void update_name_cache(std::unordered_set &cache_primary, + const std::unordered_set &cache_secondary, std::string &name); + + bool function_is_pure(const SPIRFunction &func); + bool block_is_pure(const SPIRBlock &block); + + bool execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const; + bool execution_is_direct_branch(const SPIRBlock &from, const SPIRBlock &to) const; + bool execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const; + SPIRBlock::ContinueBlockType continue_block_type(const SPIRBlock &continue_block) const; + + void force_recompile(); + void clear_force_recompile(); + bool is_forcing_recompilation() const; + bool is_force_recompile = false; + + bool block_is_loop_candidate(const SPIRBlock &block, SPIRBlock::Method method) const; + + bool types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const; + void inherit_expression_dependencies(uint32_t dst, uint32_t source); + void add_implied_read_expression(SPIRExpression &e, uint32_t source); + void add_implied_read_expression(SPIRAccessChain &e, uint32_t source); + + // For proper multiple entry point support, allow querying if an Input or Output + // variable is part of that entry points interface. + bool interface_variable_exists_in_entry_point(uint32_t id) const; + + SmallVector combined_image_samplers; + + void remap_variable_type_name(const SPIRType &type, const std::string &var_name, std::string &type_name) const + { + if (variable_remap_callback) + variable_remap_callback(type, var_name, type_name); + } + + void set_ir(const ParsedIR &parsed); + void set_ir(ParsedIR &&parsed); + void parse_fixup(); + + // Used internally to implement various traversals for queries. + struct OpcodeHandler + { + virtual ~OpcodeHandler() = default; + + // Return true if traversal should continue. + // If false, traversal will end immediately. + virtual bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) = 0; + + virtual bool follow_function_call(const SPIRFunction &) + { + return true; + } + + virtual void set_current_block(const SPIRBlock &) + { + } + + // Called after returning from a function or when entering a block, + // can be called multiple times per block, + // while set_current_block is only called on block entry. + virtual void rearm_current_block(const SPIRBlock &) + { + } + + virtual bool begin_function_scope(const uint32_t *, uint32_t) + { + return true; + } + + virtual bool end_function_scope(const uint32_t *, uint32_t) + { + return true; + } + }; + + struct BufferAccessHandler : OpcodeHandler + { + BufferAccessHandler(const Compiler &compiler_, SmallVector &ranges_, uint32_t id_) + : compiler(compiler_) + , ranges(ranges_) + , id(id_) + { + } + + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + + const Compiler &compiler; + SmallVector &ranges; + uint32_t id; + + std::unordered_set seen; + }; + + struct InterfaceVariableAccessHandler : OpcodeHandler + { + InterfaceVariableAccessHandler(const Compiler &compiler_, std::unordered_set &variables_) + : compiler(compiler_) + , variables(variables_) + { + } + + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + + const Compiler &compiler; + std::unordered_set &variables; + }; + + struct CombinedImageSamplerHandler : OpcodeHandler + { + CombinedImageSamplerHandler(Compiler &compiler_) + : compiler(compiler_) + { + } + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + bool begin_function_scope(const uint32_t *args, uint32_t length) override; + bool end_function_scope(const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + + // Each function in the call stack needs its own remapping for parameters so we can deduce which global variable each texture/sampler the parameter is statically bound to. + std::stack> parameter_remapping; + std::stack functions; + + uint32_t remap_parameter(uint32_t id); + void push_remap_parameters(const SPIRFunction &func, const uint32_t *args, uint32_t length); + void pop_remap_parameters(); + void register_combined_image_sampler(SPIRFunction &caller, VariableID combined_id, VariableID texture_id, + VariableID sampler_id, bool depth); + }; + + struct DummySamplerForCombinedImageHandler : OpcodeHandler + { + DummySamplerForCombinedImageHandler(Compiler &compiler_) + : compiler(compiler_) + { + } + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + bool need_dummy_sampler = false; + }; + + struct ActiveBuiltinHandler : OpcodeHandler + { + ActiveBuiltinHandler(Compiler &compiler_) + : compiler(compiler_) + { + } + + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + Compiler &compiler; + + void handle_builtin(const SPIRType &type, spv::BuiltIn builtin, const Bitset &decoration_flags); + }; + + bool traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const; + bool traverse_all_reachable_opcodes(const SPIRFunction &block, OpcodeHandler &handler) const; + // This must be an ordered data structure so we always pick the same type aliases. + SmallVector global_struct_cache; + + ShaderResources get_shader_resources(const std::unordered_set *active_variables) const; + + VariableTypeRemapCallback variable_remap_callback; + + bool get_common_basic_type(const SPIRType &type, SPIRType::BaseType &base_type); + + std::unordered_set forced_temporaries; + std::unordered_set forwarded_temporaries; + std::unordered_set suppressed_usage_tracking; + std::unordered_set hoisted_temporaries; + std::unordered_set forced_invariant_temporaries; + + Bitset active_input_builtins; + Bitset active_output_builtins; + uint32_t clip_distance_count = 0; + uint32_t cull_distance_count = 0; + bool position_invariant = false; + + void analyze_parameter_preservation( + SPIRFunction &entry, const CFG &cfg, + const std::unordered_map> &variable_to_blocks, + const std::unordered_map> &complete_write_blocks); + + // If a variable ID or parameter ID is found in this set, a sampler is actually a shadow/comparison sampler. + // SPIR-V does not support this distinction, so we must keep track of this information outside the type system. + // There might be unrelated IDs found in this set which do not correspond to actual variables. + // This set should only be queried for the existence of samplers which are already known to be variables or parameter IDs. + // Similar is implemented for images, as well as if subpass inputs are needed. + std::unordered_set comparison_ids; + bool need_subpass_input = false; + + // In certain backends, we will need to use a dummy sampler to be able to emit code. + // GLSL does not support texelFetch on texture2D objects, but SPIR-V does, + // so we need to workaround by having the application inject a dummy sampler. + uint32_t dummy_sampler_id = 0; + + void analyze_image_and_sampler_usage(); + + struct CombinedImageSamplerDrefHandler : OpcodeHandler + { + CombinedImageSamplerDrefHandler(Compiler &compiler_) + : compiler(compiler_) + { + } + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + std::unordered_set dref_combined_samplers; + }; + + struct CombinedImageSamplerUsageHandler : OpcodeHandler + { + CombinedImageSamplerUsageHandler(Compiler &compiler_, + const std::unordered_set &dref_combined_samplers_) + : compiler(compiler_) + , dref_combined_samplers(dref_combined_samplers_) + { + } + + bool begin_function_scope(const uint32_t *args, uint32_t length) override; + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + Compiler &compiler; + const std::unordered_set &dref_combined_samplers; + + std::unordered_map> dependency_hierarchy; + std::unordered_set comparison_ids; + + void add_hierarchy_to_comparison_ids(uint32_t ids); + bool need_subpass_input = false; + void add_dependency(uint32_t dst, uint32_t src); + }; + + void build_function_control_flow_graphs_and_analyze(); + std::unordered_map> function_cfgs; + const CFG &get_cfg_for_current_function() const; + const CFG &get_cfg_for_function(uint32_t id) const; + + struct CFGBuilder : OpcodeHandler + { + explicit CFGBuilder(Compiler &compiler_); + + bool follow_function_call(const SPIRFunction &func) override; + bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; + Compiler &compiler; + std::unordered_map> function_cfgs; + }; + + struct AnalyzeVariableScopeAccessHandler : OpcodeHandler + { + AnalyzeVariableScopeAccessHandler(Compiler &compiler_, SPIRFunction &entry_); + + bool follow_function_call(const SPIRFunction &) override; + void set_current_block(const SPIRBlock &block) override; + + void notify_variable_access(uint32_t id, uint32_t block); + bool id_is_phi_variable(uint32_t id) const; + bool id_is_potential_temporary(uint32_t id) const; + bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + SPIRFunction &entry; + std::unordered_map> accessed_variables_to_block; + std::unordered_map> accessed_temporaries_to_block; + std::unordered_map result_id_to_type; + std::unordered_map> complete_write_variables_to_block; + std::unordered_map> partial_write_variables_to_block; + std::unordered_set access_chain_expressions; + // Access chains used in multiple blocks mean hoisting all the variables used to construct the access chain as not all backends can use pointers. + std::unordered_map> access_chain_children; + const SPIRBlock *current_block = nullptr; + }; + + struct StaticExpressionAccessHandler : OpcodeHandler + { + StaticExpressionAccessHandler(Compiler &compiler_, uint32_t variable_id_); + bool follow_function_call(const SPIRFunction &) override; + bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + uint32_t variable_id; + uint32_t static_expression = 0; + uint32_t write_count = 0; + }; + + struct PhysicalStorageBufferPointerHandler : OpcodeHandler + { + explicit PhysicalStorageBufferPointerHandler(Compiler &compiler_); + bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; + Compiler &compiler; + std::unordered_set types; + }; + void analyze_non_block_pointer_types(); + SmallVector physical_storage_non_block_pointer_types; + + void analyze_variable_scope(SPIRFunction &function, AnalyzeVariableScopeAccessHandler &handler); + void find_function_local_luts(SPIRFunction &function, const AnalyzeVariableScopeAccessHandler &handler, + bool single_function); + bool may_read_undefined_variable_in_block(const SPIRBlock &block, uint32_t var); + + // Finds all resources that are written to from inside the critical section, if present. + // The critical section is delimited by OpBeginInvocationInterlockEXT and + // OpEndInvocationInterlockEXT instructions. In MSL and HLSL, any resources written + // while inside the critical section must be placed in a raster order group. + struct InterlockedResourceAccessHandler : OpcodeHandler + { + InterlockedResourceAccessHandler(Compiler &compiler_, uint32_t entry_point_id) + : compiler(compiler_) + { + call_stack.push_back(entry_point_id); + } + + bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; + bool begin_function_scope(const uint32_t *args, uint32_t length) override; + bool end_function_scope(const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + bool in_crit_sec = false; + + uint32_t interlock_function_id = 0; + bool split_function_case = false; + bool control_flow_interlock = false; + bool use_critical_section = false; + bool call_stack_is_interlocked = false; + SmallVector call_stack; + + void access_potential_resource(uint32_t id); + }; + + struct InterlockedResourceAccessPrepassHandler : OpcodeHandler + { + InterlockedResourceAccessPrepassHandler(Compiler &compiler_, uint32_t entry_point_id) + : compiler(compiler_) + { + call_stack.push_back(entry_point_id); + } + + void rearm_current_block(const SPIRBlock &block) override; + bool handle(spv::Op op, const uint32_t *args, uint32_t length) override; + bool begin_function_scope(const uint32_t *args, uint32_t length) override; + bool end_function_scope(const uint32_t *args, uint32_t length) override; + + Compiler &compiler; + uint32_t interlock_function_id = 0; + uint32_t current_block_id = 0; + bool split_function_case = false; + bool control_flow_interlock = false; + SmallVector call_stack; + }; + + void analyze_interlocked_resource_usage(); + // The set of all resources written while inside the critical section, if present. + std::unordered_set interlocked_resources; + bool interlocked_is_complex = false; + + void make_constant_null(uint32_t id, uint32_t type); + + std::unordered_map declared_block_names; + + bool instruction_to_result_type(uint32_t &result_type, uint32_t &result_id, spv::Op op, const uint32_t *args, + uint32_t length); + + Bitset combined_decoration_for_member(const SPIRType &type, uint32_t index) const; + static bool is_desktop_only_format(spv::ImageFormat format); + + bool image_is_comparison(const SPIRType &type, uint32_t id) const; + + void set_extended_decoration(uint32_t id, ExtendedDecorations decoration, uint32_t value = 0); + uint32_t get_extended_decoration(uint32_t id, ExtendedDecorations decoration) const; + bool has_extended_decoration(uint32_t id, ExtendedDecorations decoration) const; + void unset_extended_decoration(uint32_t id, ExtendedDecorations decoration); + + void set_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration, + uint32_t value = 0); + uint32_t get_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const; + bool has_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const; + void unset_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration); + + bool type_is_array_of_pointers(const SPIRType &type) const; + bool type_is_block_like(const SPIRType &type) const; + bool type_is_opaque_value(const SPIRType &type) const; + + bool reflection_ssbo_instance_name_is_significant() const; + std::string get_remapped_declared_block_name(uint32_t id, bool fallback_prefer_instance_name) const; + + bool flush_phi_required(BlockID from, BlockID to) const; + +private: + // Used only to implement the old deprecated get_entry_point() interface. + const SPIREntryPoint &get_first_entry_point(const std::string &name) const; + SPIREntryPoint &get_first_entry_point(const std::string &name); +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_cross_c.h b/ios/include/spirv_cross/spirv_cross_c.h new file mode 100644 index 00000000..0c218396 --- /dev/null +++ b/ios/include/spirv_cross/spirv_cross_c.h @@ -0,0 +1,912 @@ +/* + * Copyright 2019-2020 Hans-Kristian Arntzen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_C_API_H +#define SPIRV_CROSS_C_API_H + +#include +#include "spirv.h" + +/* + * C89-compatible wrapper for SPIRV-Cross' API. + * Documentation here is sparse unless the behavior does not map 1:1 with C++ API. + * It is recommended to look at the canonical C++ API for more detailed information. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Bumped if ABI or API breaks backwards compatibility. */ +#define SPVC_C_API_VERSION_MAJOR 0 +/* Bumped if APIs or enumerations are added in a backwards compatible way. */ +#define SPVC_C_API_VERSION_MINOR 33 +/* Bumped if internal implementation details change. */ +#define SPVC_C_API_VERSION_PATCH 0 + +#if !defined(SPVC_PUBLIC_API) +#if defined(SPVC_EXPORT_SYMBOLS) +/* Exports symbols. Standard C calling convention is used. */ +#if defined(__GNUC__) +#define SPVC_PUBLIC_API __attribute__((visibility("default"))) +#elif defined(_MSC_VER) +#define SPVC_PUBLIC_API __declspec(dllexport) +#else +#define SPVC_PUBLIC_API +#endif +#else +#define SPVC_PUBLIC_API +#endif +#endif + +/* + * Gets the SPVC_C_API_VERSION_* used to build this library. + * Can be used to check for ABI mismatch if so-versioning did not catch it. + */ +SPVC_PUBLIC_API void spvc_get_version(unsigned *major, unsigned *minor, unsigned *patch); + +/* Gets a human readable version string to identify which commit a particular binary was created from. */ +SPVC_PUBLIC_API const char *spvc_get_commit_revision_and_timestamp(void); + +/* These types are opaque to the user. */ +typedef struct spvc_context_s *spvc_context; +typedef struct spvc_parsed_ir_s *spvc_parsed_ir; +typedef struct spvc_compiler_s *spvc_compiler; +typedef struct spvc_compiler_options_s *spvc_compiler_options; +typedef struct spvc_resources_s *spvc_resources; +struct spvc_type_s; +typedef const struct spvc_type_s *spvc_type; +typedef struct spvc_constant_s *spvc_constant; +struct spvc_set_s; +typedef const struct spvc_set_s *spvc_set; + +/* + * Shallow typedefs. All SPIR-V IDs are plain 32-bit numbers, but this helps communicate which data is used. + * Maps to a SPIRType. + */ +typedef SpvId spvc_type_id; +/* Maps to a SPIRVariable. */ +typedef SpvId spvc_variable_id; +/* Maps to a SPIRConstant. */ +typedef SpvId spvc_constant_id; + +/* See C++ API. */ +typedef struct spvc_reflected_resource +{ + spvc_variable_id id; + spvc_type_id base_type_id; + spvc_type_id type_id; + const char *name; +} spvc_reflected_resource; + +/* See C++ API. */ +typedef struct spvc_entry_point +{ + SpvExecutionModel execution_model; + const char *name; +} spvc_entry_point; + +/* See C++ API. */ +typedef struct spvc_combined_image_sampler +{ + spvc_variable_id combined_id; + spvc_variable_id image_id; + spvc_variable_id sampler_id; +} spvc_combined_image_sampler; + +/* See C++ API. */ +typedef struct spvc_specialization_constant +{ + spvc_constant_id id; + unsigned constant_id; +} spvc_specialization_constant; + +/* See C++ API. */ +typedef struct spvc_buffer_range +{ + unsigned index; + size_t offset; + size_t range; +} spvc_buffer_range; + +/* See C++ API. */ +typedef struct spvc_hlsl_root_constants +{ + unsigned start; + unsigned end; + unsigned binding; + unsigned space; +} spvc_hlsl_root_constants; + +/* See C++ API. */ +typedef struct spvc_hlsl_vertex_attribute_remap +{ + unsigned location; + const char *semantic; +} spvc_hlsl_vertex_attribute_remap; + +/* + * Be compatible with non-C99 compilers, which do not have stdbool. + * Only recent MSVC compilers supports this for example, and ideally SPIRV-Cross should be linkable + * from a wide range of compilers in its C wrapper. + */ +typedef unsigned char spvc_bool; +#define SPVC_TRUE ((spvc_bool)1) +#define SPVC_FALSE ((spvc_bool)0) + +typedef enum spvc_result +{ + /* Success. */ + SPVC_SUCCESS = 0, + + /* The SPIR-V is invalid. Should have been caught by validation ideally. */ + SPVC_ERROR_INVALID_SPIRV = -1, + + /* The SPIR-V might be valid or invalid, but SPIRV-Cross currently cannot correctly translate this to your target language. */ + SPVC_ERROR_UNSUPPORTED_SPIRV = -2, + + /* If for some reason we hit this, new or malloc failed. */ + SPVC_ERROR_OUT_OF_MEMORY = -3, + + /* Invalid API argument. */ + SPVC_ERROR_INVALID_ARGUMENT = -4, + + SPVC_ERROR_INT_MAX = 0x7fffffff +} spvc_result; + +typedef enum spvc_capture_mode +{ + /* The Parsed IR payload will be copied, and the handle can be reused to create other compiler instances. */ + SPVC_CAPTURE_MODE_COPY = 0, + + /* + * The payload will now be owned by the compiler. + * parsed_ir should now be considered a dead blob and must not be used further. + * This is optimal for performance and should be the go-to option. + */ + SPVC_CAPTURE_MODE_TAKE_OWNERSHIP = 1, + + SPVC_CAPTURE_MODE_INT_MAX = 0x7fffffff +} spvc_capture_mode; + +typedef enum spvc_backend +{ + /* This backend can only perform reflection, no compiler options are supported. Maps to spirv_cross::Compiler. */ + SPVC_BACKEND_NONE = 0, + SPVC_BACKEND_GLSL = 1, /* spirv_cross::CompilerGLSL */ + SPVC_BACKEND_HLSL = 2, /* CompilerHLSL */ + SPVC_BACKEND_MSL = 3, /* CompilerMSL */ + SPVC_BACKEND_CPP = 4, /* CompilerCPP */ + SPVC_BACKEND_JSON = 5, /* CompilerReflection w/ JSON backend */ + SPVC_BACKEND_INT_MAX = 0x7fffffff +} spvc_backend; + +/* Maps to C++ API. */ +typedef enum spvc_resource_type +{ + SPVC_RESOURCE_TYPE_UNKNOWN = 0, + SPVC_RESOURCE_TYPE_UNIFORM_BUFFER = 1, + SPVC_RESOURCE_TYPE_STORAGE_BUFFER = 2, + SPVC_RESOURCE_TYPE_STAGE_INPUT = 3, + SPVC_RESOURCE_TYPE_STAGE_OUTPUT = 4, + SPVC_RESOURCE_TYPE_SUBPASS_INPUT = 5, + SPVC_RESOURCE_TYPE_STORAGE_IMAGE = 6, + SPVC_RESOURCE_TYPE_SAMPLED_IMAGE = 7, + SPVC_RESOURCE_TYPE_ATOMIC_COUNTER = 8, + SPVC_RESOURCE_TYPE_PUSH_CONSTANT = 9, + SPVC_RESOURCE_TYPE_SEPARATE_IMAGE = 10, + SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS = 11, + SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE = 12, + SPVC_RESOURCE_TYPE_RAY_QUERY = 13, + SPVC_RESOURCE_TYPE_INT_MAX = 0x7fffffff +} spvc_resource_type; + +/* Maps to spirv_cross::SPIRType::BaseType. */ +typedef enum spvc_basetype +{ + SPVC_BASETYPE_UNKNOWN = 0, + SPVC_BASETYPE_VOID = 1, + SPVC_BASETYPE_BOOLEAN = 2, + SPVC_BASETYPE_INT8 = 3, + SPVC_BASETYPE_UINT8 = 4, + SPVC_BASETYPE_INT16 = 5, + SPVC_BASETYPE_UINT16 = 6, + SPVC_BASETYPE_INT32 = 7, + SPVC_BASETYPE_UINT32 = 8, + SPVC_BASETYPE_INT64 = 9, + SPVC_BASETYPE_UINT64 = 10, + SPVC_BASETYPE_ATOMIC_COUNTER = 11, + SPVC_BASETYPE_FP16 = 12, + SPVC_BASETYPE_FP32 = 13, + SPVC_BASETYPE_FP64 = 14, + SPVC_BASETYPE_STRUCT = 15, + SPVC_BASETYPE_IMAGE = 16, + SPVC_BASETYPE_SAMPLED_IMAGE = 17, + SPVC_BASETYPE_SAMPLER = 18, + SPVC_BASETYPE_ACCELERATION_STRUCTURE = 19, + + SPVC_BASETYPE_INT_MAX = 0x7fffffff +} spvc_basetype; + +#define SPVC_COMPILER_OPTION_COMMON_BIT 0x1000000 +#define SPVC_COMPILER_OPTION_GLSL_BIT 0x2000000 +#define SPVC_COMPILER_OPTION_HLSL_BIT 0x4000000 +#define SPVC_COMPILER_OPTION_MSL_BIT 0x8000000 +#define SPVC_COMPILER_OPTION_LANG_BITS 0x0f000000 +#define SPVC_COMPILER_OPTION_ENUM_BITS 0xffffff + +#define SPVC_MAKE_MSL_VERSION(major, minor, patch) ((major) * 10000 + (minor) * 100 + (patch)) + +/* Maps to C++ API. */ +typedef enum spvc_msl_platform +{ + SPVC_MSL_PLATFORM_IOS = 0, + SPVC_MSL_PLATFORM_MACOS = 1, + SPVC_MSL_PLATFORM_MAX_INT = 0x7fffffff +} spvc_msl_platform; + +/* Maps to C++ API. */ +typedef enum spvc_msl_vertex_format +{ + SPVC_MSL_VERTEX_FORMAT_OTHER = 0, + SPVC_MSL_VERTEX_FORMAT_UINT8 = 1, + SPVC_MSL_VERTEX_FORMAT_UINT16 = 2 +} spvc_msl_vertex_format; + +/* Maps to C++ API. */ +typedef struct spvc_msl_vertex_attribute +{ + unsigned location; + unsigned msl_buffer; + unsigned msl_offset; + unsigned msl_stride; + spvc_bool per_instance; + spvc_msl_vertex_format format; + SpvBuiltIn builtin; +} spvc_msl_vertex_attribute; + +/* + * Initializes the vertex attribute struct. + */ +SPVC_PUBLIC_API void spvc_msl_vertex_attribute_init(spvc_msl_vertex_attribute *attr); + +/* Maps to C++ API. */ +typedef struct spvc_msl_resource_binding +{ + SpvExecutionModel stage; + unsigned desc_set; + unsigned binding; + unsigned msl_buffer; + unsigned msl_texture; + unsigned msl_sampler; +} spvc_msl_resource_binding; + +/* + * Initializes the resource binding struct. + * The defaults are non-zero. + */ +SPVC_PUBLIC_API void spvc_msl_resource_binding_init(spvc_msl_resource_binding *binding); + +#define SPVC_MSL_PUSH_CONSTANT_DESC_SET (~(0u)) +#define SPVC_MSL_PUSH_CONSTANT_BINDING (0) +#define SPVC_MSL_SWIZZLE_BUFFER_BINDING (~(1u)) +#define SPVC_MSL_BUFFER_SIZE_BUFFER_BINDING (~(2u)) +#define SPVC_MSL_ARGUMENT_BUFFER_BINDING (~(3u)) + +/* Obsolete. Sticks around for backwards compatibility. */ +#define SPVC_MSL_AUX_BUFFER_STRUCT_VERSION 1 + +/* Runtime check for incompatibility. Obsolete. */ +SPVC_PUBLIC_API unsigned spvc_msl_get_aux_buffer_struct_version(void); + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_coord +{ + SPVC_MSL_SAMPLER_COORD_NORMALIZED = 0, + SPVC_MSL_SAMPLER_COORD_PIXEL = 1, + SPVC_MSL_SAMPLER_INT_MAX = 0x7fffffff +} spvc_msl_sampler_coord; + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_filter +{ + SPVC_MSL_SAMPLER_FILTER_NEAREST = 0, + SPVC_MSL_SAMPLER_FILTER_LINEAR = 1, + SPVC_MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff +} spvc_msl_sampler_filter; + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_mip_filter +{ + SPVC_MSL_SAMPLER_MIP_FILTER_NONE = 0, + SPVC_MSL_SAMPLER_MIP_FILTER_NEAREST = 1, + SPVC_MSL_SAMPLER_MIP_FILTER_LINEAR = 2, + SPVC_MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff +} spvc_msl_sampler_mip_filter; + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_address +{ + SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0, + SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1, + SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2, + SPVC_MSL_SAMPLER_ADDRESS_REPEAT = 3, + SPVC_MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4, + SPVC_MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff +} spvc_msl_sampler_address; + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_compare_func +{ + SPVC_MSL_SAMPLER_COMPARE_FUNC_NEVER = 0, + SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS = 1, + SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2, + SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER = 3, + SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4, + SPVC_MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5, + SPVC_MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6, + SPVC_MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7, + SPVC_MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff +} spvc_msl_sampler_compare_func; + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_border_color +{ + SPVC_MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0, + SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1, + SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2, + SPVC_MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff +} spvc_msl_sampler_border_color; + +/* Maps to C++ API. */ +typedef enum spvc_msl_format_resolution +{ + SPVC_MSL_FORMAT_RESOLUTION_444 = 0, + SPVC_MSL_FORMAT_RESOLUTION_422, + SPVC_MSL_FORMAT_RESOLUTION_420, + SPVC_MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff +} spvc_msl_format_resolution; + +/* Maps to C++ API. */ +typedef enum spvc_msl_chroma_location +{ + SPVC_MSL_CHROMA_LOCATION_COSITED_EVEN = 0, + SPVC_MSL_CHROMA_LOCATION_MIDPOINT, + SPVC_MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff +} spvc_msl_chroma_location; + +/* Maps to C++ API. */ +typedef enum spvc_msl_component_swizzle +{ + SPVC_MSL_COMPONENT_SWIZZLE_IDENTITY = 0, + SPVC_MSL_COMPONENT_SWIZZLE_ZERO, + SPVC_MSL_COMPONENT_SWIZZLE_ONE, + SPVC_MSL_COMPONENT_SWIZZLE_R, + SPVC_MSL_COMPONENT_SWIZZLE_G, + SPVC_MSL_COMPONENT_SWIZZLE_B, + SPVC_MSL_COMPONENT_SWIZZLE_A, + SPVC_MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff +} spvc_msl_component_swizzle; + +/* Maps to C++ API. */ +typedef enum spvc_msl_sampler_ycbcr_model_conversion +{ + SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709, + SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601, + SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020, + SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff +} spvc_msl_sampler_ycbcr_model_conversion; + +/* Maps to C+ API. */ +typedef enum spvc_msl_sampler_ycbcr_range +{ + SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW, + SPVC_MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff +} spvc_msl_sampler_ycbcr_range; + +/* Maps to C++ API. */ +typedef struct spvc_msl_constexpr_sampler +{ + spvc_msl_sampler_coord coord; + spvc_msl_sampler_filter min_filter; + spvc_msl_sampler_filter mag_filter; + spvc_msl_sampler_mip_filter mip_filter; + spvc_msl_sampler_address s_address; + spvc_msl_sampler_address t_address; + spvc_msl_sampler_address r_address; + spvc_msl_sampler_compare_func compare_func; + spvc_msl_sampler_border_color border_color; + float lod_clamp_min; + float lod_clamp_max; + int max_anisotropy; + + spvc_bool compare_enable; + spvc_bool lod_clamp_enable; + spvc_bool anisotropy_enable; +} spvc_msl_constexpr_sampler; + +/* + * Initializes the constexpr sampler struct. + * The defaults are non-zero. + */ +SPVC_PUBLIC_API void spvc_msl_constexpr_sampler_init(spvc_msl_constexpr_sampler *sampler); + +/* Maps to the sampler Y'CbCr conversion-related portions of MSLConstexprSampler. See C++ API for defaults and details. */ +typedef struct spvc_msl_sampler_ycbcr_conversion +{ + unsigned planes; + spvc_msl_format_resolution resolution; + spvc_msl_sampler_filter chroma_filter; + spvc_msl_chroma_location x_chroma_offset; + spvc_msl_chroma_location y_chroma_offset; + spvc_msl_component_swizzle swizzle[4]; + spvc_msl_sampler_ycbcr_model_conversion ycbcr_model; + spvc_msl_sampler_ycbcr_range ycbcr_range; + unsigned bpc; +} spvc_msl_sampler_ycbcr_conversion; + +/* + * Initializes the constexpr sampler struct. + * The defaults are non-zero. + */ +SPVC_PUBLIC_API void spvc_msl_sampler_ycbcr_conversion_init(spvc_msl_sampler_ycbcr_conversion *conv); + +/* Maps to C++ API. */ +typedef enum spvc_hlsl_binding_flag_bits +{ + SPVC_HLSL_BINDING_AUTO_NONE_BIT = 0, + SPVC_HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0, + SPVC_HLSL_BINDING_AUTO_CBV_BIT = 1 << 1, + SPVC_HLSL_BINDING_AUTO_SRV_BIT = 1 << 2, + SPVC_HLSL_BINDING_AUTO_UAV_BIT = 1 << 3, + SPVC_HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4, + SPVC_HLSL_BINDING_AUTO_ALL = 0x7fffffff +} spvc_hlsl_binding_flag_bits; +typedef unsigned spvc_hlsl_binding_flags; + +#define SPVC_HLSL_PUSH_CONSTANT_DESC_SET (~(0u)) +#define SPVC_HLSL_PUSH_CONSTANT_BINDING (0) + +/* Maps to C++ API. */ +typedef struct spvc_hlsl_resource_binding_mapping +{ + unsigned register_space; + unsigned register_binding; +} spvc_hlsl_resource_binding_mapping; + +typedef struct spvc_hlsl_resource_binding +{ + SpvExecutionModel stage; + unsigned desc_set; + unsigned binding; + + spvc_hlsl_resource_binding_mapping cbv, uav, srv, sampler; +} spvc_hlsl_resource_binding; + +/* + * Initializes the resource binding struct. + * The defaults are non-zero. + */ +SPVC_PUBLIC_API void spvc_hlsl_resource_binding_init(spvc_hlsl_resource_binding *binding); + +/* Maps to the various spirv_cross::Compiler*::Option structures. See C++ API for defaults and details. */ +typedef enum spvc_compiler_option +{ + SPVC_COMPILER_OPTION_UNKNOWN = 0, + + SPVC_COMPILER_OPTION_FORCE_TEMPORARY = 1 | SPVC_COMPILER_OPTION_COMMON_BIT, + SPVC_COMPILER_OPTION_FLATTEN_MULTIDIMENSIONAL_ARRAYS = 2 | SPVC_COMPILER_OPTION_COMMON_BIT, + SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION = 3 | SPVC_COMPILER_OPTION_COMMON_BIT, + SPVC_COMPILER_OPTION_FLIP_VERTEX_Y = 4 | SPVC_COMPILER_OPTION_COMMON_BIT, + + SPVC_COMPILER_OPTION_GLSL_SUPPORT_NONZERO_BASE_INSTANCE = 5 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_SEPARATE_SHADER_OBJECTS = 6 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION = 7 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_VERSION = 8 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_ES = 9 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS = 10 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP = 11 | SPVC_COMPILER_OPTION_GLSL_BIT, + SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_INT_PRECISION_HIGHP = 12 | SPVC_COMPILER_OPTION_GLSL_BIT, + + SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL = 13 | SPVC_COMPILER_OPTION_HLSL_BIT, + SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT = 14 | SPVC_COMPILER_OPTION_HLSL_BIT, + SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT = 15 | SPVC_COMPILER_OPTION_HLSL_BIT, + SPVC_COMPILER_OPTION_HLSL_SUPPORT_NONZERO_BASE_VERTEX_BASE_INSTANCE = 16 | SPVC_COMPILER_OPTION_HLSL_BIT, + + SPVC_COMPILER_OPTION_MSL_VERSION = 17 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_TEXEL_BUFFER_TEXTURE_WIDTH = 18 | SPVC_COMPILER_OPTION_MSL_BIT, + + /* Obsolete, use SWIZZLE_BUFFER_INDEX instead. */ + SPVC_COMPILER_OPTION_MSL_AUX_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_SWIZZLE_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT, + + SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX = 20 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX = 21 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX = 22 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX = 23 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_WORKGROUP_INDEX = 24 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_BUILTIN = 25 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION = 26 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER = 27 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_SWIZZLE_TEXTURE_SAMPLES = 28 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_PAD_FRAGMENT_OUTPUT_COMPONENTS = 29 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_TESS_DOMAIN_ORIGIN_LOWER_LEFT = 30 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_PLATFORM = 31 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS = 32 | SPVC_COMPILER_OPTION_MSL_BIT, + + SPVC_COMPILER_OPTION_GLSL_EMIT_PUSH_CONSTANT_AS_UNIFORM_BUFFER = 33 | SPVC_COMPILER_OPTION_GLSL_BIT, + + SPVC_COMPILER_OPTION_MSL_TEXTURE_BUFFER_NATIVE = 34 | SPVC_COMPILER_OPTION_MSL_BIT, + + SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS = 35 | SPVC_COMPILER_OPTION_GLSL_BIT, + + SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX = 36 | SPVC_COMPILER_OPTION_MSL_BIT, + + SPVC_COMPILER_OPTION_EMIT_LINE_DIRECTIVES = 37 | SPVC_COMPILER_OPTION_COMMON_BIT, + + SPVC_COMPILER_OPTION_MSL_MULTIVIEW = 38 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX = 39 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_DEVICE_INDEX = 40 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_VIEW_INDEX_FROM_DEVICE_INDEX = 41 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_DISPATCH_BASE = 42 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_DYNAMIC_OFFSETS_BUFFER_INDEX = 43 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_TEXTURE_1D_AS_2D = 44 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ENABLE_BASE_INDEX_ZERO = 45 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_IOS_FRAMEBUFFER_FETCH_SUBPASS = 46 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_INVARIANT_FP_MATH = 47 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_EMULATE_CUBEMAP_ARRAY = 48 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ENABLE_DECORATION_BINDING = 49 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_FORCE_ACTIVE_ARGUMENT_BUFFER_RESOURCES = 50 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS = 51 | SPVC_COMPILER_OPTION_MSL_BIT, + + SPVC_COMPILER_OPTION_ENABLE_STORAGE_IMAGE_QUALIFIER_DEDUCTION = 52 | SPVC_COMPILER_OPTION_COMMON_BIT, + + SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV = 53 | SPVC_COMPILER_OPTION_HLSL_BIT, + + SPVC_COMPILER_OPTION_FORCE_ZERO_INITIALIZED_VARIABLES = 54 | SPVC_COMPILER_OPTION_COMMON_BIT, + + SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV = 55 | SPVC_COMPILER_OPTION_HLSL_BIT, + + SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK = 56 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN = 57 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN = 58 | SPVC_COMPILER_OPTION_MSL_BIT, + SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING = 59 | SPVC_COMPILER_OPTION_MSL_BIT, + + SPVC_COMPILER_OPTION_INT_MAX = 0x7fffffff +} spvc_compiler_option; + +/* + * Context is the highest-level API construct. + * The context owns all memory allocations made by its child object hierarchy, including various non-opaque structs and strings. + * This means that the API user only has to care about one "destroy" call ever when using the C API. + * All pointers handed out by the APIs are only valid as long as the context + * is alive and spvc_context_release_allocations has not been called. + */ +SPVC_PUBLIC_API spvc_result spvc_context_create(spvc_context *context); + +/* Frees all memory allocations and objects associated with the context and its child objects. */ +SPVC_PUBLIC_API void spvc_context_destroy(spvc_context context); + +/* Frees all memory allocations and objects associated with the context and its child objects, but keeps the context alive. */ +SPVC_PUBLIC_API void spvc_context_release_allocations(spvc_context context); + +/* Get the string for the last error which was logged. */ +SPVC_PUBLIC_API const char *spvc_context_get_last_error_string(spvc_context context); + +/* Get notified in a callback when an error triggers. Useful for debugging. */ +typedef void (*spvc_error_callback)(void *userdata, const char *error); +SPVC_PUBLIC_API void spvc_context_set_error_callback(spvc_context context, spvc_error_callback cb, void *userdata); + +/* SPIR-V parsing interface. Maps to Parser which then creates a ParsedIR, and that IR is extracted into the handle. */ +SPVC_PUBLIC_API spvc_result spvc_context_parse_spirv(spvc_context context, const SpvId *spirv, size_t word_count, + spvc_parsed_ir *parsed_ir); + +/* + * Create a compiler backend. Capture mode controls if we construct by copy or move semantics. + * It is always recommended to use SPVC_CAPTURE_MODE_TAKE_OWNERSHIP if you only intend to cross-compile the IR once. + */ +SPVC_PUBLIC_API spvc_result spvc_context_create_compiler(spvc_context context, spvc_backend backend, + spvc_parsed_ir parsed_ir, spvc_capture_mode mode, + spvc_compiler *compiler); + +/* Maps directly to C++ API. */ +SPVC_PUBLIC_API unsigned spvc_compiler_get_current_id_bound(spvc_compiler compiler); + +/* Create compiler options, which will initialize defaults. */ +SPVC_PUBLIC_API spvc_result spvc_compiler_create_compiler_options(spvc_compiler compiler, + spvc_compiler_options *options); +/* Override options. Will return error if e.g. MSL options are used for the HLSL backend, etc. */ +SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_bool(spvc_compiler_options options, + spvc_compiler_option option, spvc_bool value); +SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options, + spvc_compiler_option option, unsigned value); +/* Set compiler options. */ +SPVC_PUBLIC_API spvc_result spvc_compiler_install_compiler_options(spvc_compiler compiler, + spvc_compiler_options options); + +/* Compile IR into a string. *source is owned by the context, and caller must not free it themselves. */ +SPVC_PUBLIC_API spvc_result spvc_compiler_compile(spvc_compiler compiler, const char **source); + +/* Maps to C++ API. */ +SPVC_PUBLIC_API spvc_result spvc_compiler_add_header_line(spvc_compiler compiler, const char *line); +SPVC_PUBLIC_API spvc_result spvc_compiler_require_extension(spvc_compiler compiler, const char *ext); +SPVC_PUBLIC_API spvc_result spvc_compiler_flatten_buffer_block(spvc_compiler compiler, spvc_variable_id id); + +SPVC_PUBLIC_API spvc_bool spvc_compiler_variable_is_depth_or_compare(spvc_compiler compiler, spvc_variable_id id); + +/* + * HLSL specifics. + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_root_constants_layout(spvc_compiler compiler, + const spvc_hlsl_root_constants *constant_info, + size_t count); +SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_vertex_attribute_remap(spvc_compiler compiler, + const spvc_hlsl_vertex_attribute_remap *remap, + size_t remaps); +SPVC_PUBLIC_API spvc_variable_id spvc_compiler_hlsl_remap_num_workgroups_builtin(spvc_compiler compiler); + +SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_resource_binding_flags(spvc_compiler compiler, + spvc_hlsl_binding_flags flags); + +SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_resource_binding(spvc_compiler compiler, + const spvc_hlsl_resource_binding *binding); +SPVC_PUBLIC_API spvc_bool spvc_compiler_hlsl_is_resource_used(spvc_compiler compiler, + SpvExecutionModel model, + unsigned set, + unsigned binding); + +/* + * MSL specifics. + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_rasterization_disabled(spvc_compiler compiler); + +/* Obsolete. Renamed to needs_swizzle_buffer. */ +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_aux_buffer(spvc_compiler compiler); +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_swizzle_buffer(spvc_compiler compiler); +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_buffer_size_buffer(spvc_compiler compiler); + +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_output_buffer(spvc_compiler compiler); +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_patch_output_buffer(spvc_compiler compiler); +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_input_threadgroup_mem(spvc_compiler compiler); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_vertex_attribute(spvc_compiler compiler, + const spvc_msl_vertex_attribute *attrs); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_resource_binding(spvc_compiler compiler, + const spvc_msl_resource_binding *binding); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_discrete_descriptor_set(spvc_compiler compiler, unsigned desc_set); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_argument_buffer_device_address_space(spvc_compiler compiler, unsigned desc_set, spvc_bool device_address); +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_vertex_attribute_used(spvc_compiler compiler, unsigned location); +SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_resource_used(spvc_compiler compiler, + SpvExecutionModel model, + unsigned set, + unsigned binding); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_ycbcr(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv); +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_fragment_output_components(spvc_compiler compiler, unsigned location, unsigned components); + +SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding(spvc_compiler compiler, spvc_variable_id id); +SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding_secondary(spvc_compiler compiler, spvc_variable_id id); + +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_dynamic_buffer(spvc_compiler compiler, unsigned desc_set, unsigned binding, unsigned index); + +SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_inline_uniform_block(spvc_compiler compiler, unsigned desc_set, unsigned binding); + +/* + * Reflect resources. + * Maps almost 1:1 to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_interface_variables(spvc_compiler compiler, spvc_set *set); +SPVC_PUBLIC_API spvc_result spvc_compiler_set_enabled_interface_variables(spvc_compiler compiler, spvc_set set); +SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources(spvc_compiler compiler, spvc_resources *resources); +SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources_for_active_variables(spvc_compiler compiler, + spvc_resources *resources, + spvc_set active); +SPVC_PUBLIC_API spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, spvc_resource_type type, + const spvc_reflected_resource **resource_list, + size_t *resource_size); + +/* + * Decorations. + * Maps to C++ API. + */ +SPVC_PUBLIC_API void spvc_compiler_set_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration, + unsigned argument); +SPVC_PUBLIC_API void spvc_compiler_set_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration, + const char *argument); +SPVC_PUBLIC_API void spvc_compiler_set_name(spvc_compiler compiler, SpvId id, const char *argument); +SPVC_PUBLIC_API void spvc_compiler_set_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, + SpvDecoration decoration, unsigned argument); +SPVC_PUBLIC_API void spvc_compiler_set_member_decoration_string(spvc_compiler compiler, spvc_type_id id, + unsigned member_index, SpvDecoration decoration, + const char *argument); +SPVC_PUBLIC_API void spvc_compiler_set_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index, + const char *argument); +SPVC_PUBLIC_API void spvc_compiler_unset_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); +SPVC_PUBLIC_API void spvc_compiler_unset_member_decoration(spvc_compiler compiler, spvc_type_id id, + unsigned member_index, SpvDecoration decoration); + +SPVC_PUBLIC_API spvc_bool spvc_compiler_has_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); +SPVC_PUBLIC_API spvc_bool spvc_compiler_has_member_decoration(spvc_compiler compiler, spvc_type_id id, + unsigned member_index, SpvDecoration decoration); +SPVC_PUBLIC_API const char *spvc_compiler_get_name(spvc_compiler compiler, SpvId id); +SPVC_PUBLIC_API unsigned spvc_compiler_get_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); +SPVC_PUBLIC_API const char *spvc_compiler_get_decoration_string(spvc_compiler compiler, SpvId id, + SpvDecoration decoration); +SPVC_PUBLIC_API unsigned spvc_compiler_get_member_decoration(spvc_compiler compiler, spvc_type_id id, + unsigned member_index, SpvDecoration decoration); +SPVC_PUBLIC_API const char *spvc_compiler_get_member_decoration_string(spvc_compiler compiler, spvc_type_id id, + unsigned member_index, SpvDecoration decoration); +SPVC_PUBLIC_API const char *spvc_compiler_get_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index); + +/* + * Entry points. + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_get_entry_points(spvc_compiler compiler, + const spvc_entry_point **entry_points, + size_t *num_entry_points); +SPVC_PUBLIC_API spvc_result spvc_compiler_set_entry_point(spvc_compiler compiler, const char *name, + SpvExecutionModel model); +SPVC_PUBLIC_API spvc_result spvc_compiler_rename_entry_point(spvc_compiler compiler, const char *old_name, + const char *new_name, SpvExecutionModel model); +SPVC_PUBLIC_API const char *spvc_compiler_get_cleansed_entry_point_name(spvc_compiler compiler, const char *name, + SpvExecutionModel model); +SPVC_PUBLIC_API void spvc_compiler_set_execution_mode(spvc_compiler compiler, SpvExecutionMode mode); +SPVC_PUBLIC_API void spvc_compiler_unset_execution_mode(spvc_compiler compiler, SpvExecutionMode mode); +SPVC_PUBLIC_API void spvc_compiler_set_execution_mode_with_arguments(spvc_compiler compiler, SpvExecutionMode mode, + unsigned arg0, unsigned arg1, unsigned arg2); +SPVC_PUBLIC_API spvc_result spvc_compiler_get_execution_modes(spvc_compiler compiler, const SpvExecutionMode **modes, + size_t *num_modes); +SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument(spvc_compiler compiler, SpvExecutionMode mode); +SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument_by_index(spvc_compiler compiler, + SpvExecutionMode mode, unsigned index); +SPVC_PUBLIC_API SpvExecutionModel spvc_compiler_get_execution_model(spvc_compiler compiler); + +/* + * Type query interface. + * Maps to C++ API, except it's read-only. + */ +SPVC_PUBLIC_API spvc_type spvc_compiler_get_type_handle(spvc_compiler compiler, spvc_type_id id); + +/* Pulls out SPIRType::self. This effectively gives the type ID without array or pointer qualifiers. + * This is necessary when reflecting decoration/name information on members of a struct, + * which are placed in the base type, not the qualified type. + * This is similar to spvc_reflected_resource::base_type_id. */ +SPVC_PUBLIC_API spvc_type_id spvc_type_get_base_type_id(spvc_type type); + +SPVC_PUBLIC_API spvc_basetype spvc_type_get_basetype(spvc_type type); +SPVC_PUBLIC_API unsigned spvc_type_get_bit_width(spvc_type type); +SPVC_PUBLIC_API unsigned spvc_type_get_vector_size(spvc_type type); +SPVC_PUBLIC_API unsigned spvc_type_get_columns(spvc_type type); +SPVC_PUBLIC_API unsigned spvc_type_get_num_array_dimensions(spvc_type type); +SPVC_PUBLIC_API spvc_bool spvc_type_array_dimension_is_literal(spvc_type type, unsigned dimension); +SPVC_PUBLIC_API SpvId spvc_type_get_array_dimension(spvc_type type, unsigned dimension); +SPVC_PUBLIC_API unsigned spvc_type_get_num_member_types(spvc_type type); +SPVC_PUBLIC_API spvc_type_id spvc_type_get_member_type(spvc_type type, unsigned index); +SPVC_PUBLIC_API SpvStorageClass spvc_type_get_storage_class(spvc_type type); + +/* Image type query. */ +SPVC_PUBLIC_API spvc_type_id spvc_type_get_image_sampled_type(spvc_type type); +SPVC_PUBLIC_API SpvDim spvc_type_get_image_dimension(spvc_type type); +SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_depth(spvc_type type); +SPVC_PUBLIC_API spvc_bool spvc_type_get_image_arrayed(spvc_type type); +SPVC_PUBLIC_API spvc_bool spvc_type_get_image_multisampled(spvc_type type); +SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_storage(spvc_type type); +SPVC_PUBLIC_API SpvImageFormat spvc_type_get_image_storage_format(spvc_type type); +SPVC_PUBLIC_API SpvAccessQualifier spvc_type_get_image_access_qualifier(spvc_type type); + +/* + * Buffer layout query. + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size(spvc_compiler compiler, spvc_type struct_type, size_t *size); +SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size_runtime_array(spvc_compiler compiler, + spvc_type struct_type, size_t array_size, size_t *size); +SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_member_size(spvc_compiler compiler, spvc_type type, unsigned index, size_t *size); + +SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_offset(spvc_compiler compiler, + spvc_type type, unsigned index, unsigned *offset); +SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_array_stride(spvc_compiler compiler, + spvc_type type, unsigned index, unsigned *stride); +SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_matrix_stride(spvc_compiler compiler, + spvc_type type, unsigned index, unsigned *stride); + +/* + * Workaround helper functions. + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_build_dummy_sampler_for_combined_images(spvc_compiler compiler, spvc_variable_id *id); +SPVC_PUBLIC_API spvc_result spvc_compiler_build_combined_image_samplers(spvc_compiler compiler); +SPVC_PUBLIC_API spvc_result spvc_compiler_get_combined_image_samplers(spvc_compiler compiler, + const spvc_combined_image_sampler **samplers, + size_t *num_samplers); + +/* + * Constants + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_get_specialization_constants(spvc_compiler compiler, + const spvc_specialization_constant **constants, + size_t *num_constants); +SPVC_PUBLIC_API spvc_constant spvc_compiler_get_constant_handle(spvc_compiler compiler, + spvc_constant_id id); + +SPVC_PUBLIC_API spvc_constant_id spvc_compiler_get_work_group_size_specialization_constants(spvc_compiler compiler, + spvc_specialization_constant *x, + spvc_specialization_constant *y, + spvc_specialization_constant *z); + +/* + * Buffer ranges + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_buffer_ranges(spvc_compiler compiler, + spvc_variable_id id, + const spvc_buffer_range **ranges, + size_t *num_ranges); + +/* + * No stdint.h until C99, sigh :( + * For smaller types, the result is sign or zero-extended as appropriate. + * Maps to C++ API. + * TODO: The SPIRConstant query interface and modification interface is not quite complete. + */ +SPVC_PUBLIC_API float spvc_constant_get_scalar_fp16(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API float spvc_constant_get_scalar_fp32(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API double spvc_constant_get_scalar_fp64(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u32(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API int spvc_constant_get_scalar_i32(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u16(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API int spvc_constant_get_scalar_i16(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u8(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API int spvc_constant_get_scalar_i8(spvc_constant constant, unsigned column, unsigned row); +SPVC_PUBLIC_API void spvc_constant_get_subconstants(spvc_constant constant, const spvc_constant_id **constituents, size_t *count); +SPVC_PUBLIC_API spvc_type_id spvc_constant_get_type(spvc_constant constant); + +/* + * Misc reflection + * Maps to C++ API. + */ +SPVC_PUBLIC_API spvc_bool spvc_compiler_get_binary_offset_for_decoration(spvc_compiler compiler, + spvc_variable_id id, + SpvDecoration decoration, + unsigned *word_offset); + +SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_is_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id); +SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_get_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id, + spvc_variable_id *counter_id); + +SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_capabilities(spvc_compiler compiler, + const SpvCapability **capabilities, + size_t *num_capabilities); +SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_extensions(spvc_compiler compiler, const char ***extensions, + size_t *num_extensions); + +SPVC_PUBLIC_API const char *spvc_compiler_get_remapped_declared_block_name(spvc_compiler compiler, spvc_variable_id id); +SPVC_PUBLIC_API spvc_result spvc_compiler_get_buffer_block_decorations(spvc_compiler compiler, spvc_variable_id id, + const SpvDecoration **decorations, + size_t *num_decorations); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/ios/include/spirv_cross/spirv_cross_containers.hpp b/ios/include/spirv_cross/spirv_cross_containers.hpp new file mode 100644 index 00000000..f5760a0e --- /dev/null +++ b/ios/include/spirv_cross/spirv_cross_containers.hpp @@ -0,0 +1,734 @@ +/* + * Copyright 2019-2020 Hans-Kristian Arntzen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_CONTAINERS_HPP +#define SPIRV_CROSS_CONTAINERS_HPP + +#include "spirv_cross_error_handling.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE +#define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE +#else +#define SPIRV_CROSS_NAMESPACE spirv_cross +#endif + +namespace SPIRV_CROSS_NAMESPACE +{ +#ifndef SPIRV_CROSS_FORCE_STL_TYPES +// std::aligned_storage does not support size == 0, so roll our own. +template +class AlignedBuffer +{ +public: + T *data() + { +#if defined(_MSC_VER) && _MSC_VER < 1900 + // MSVC 2013 workarounds, sigh ... + // Only use this workaround on MSVC 2013 due to some confusion around default initialized unions. + // Spec seems to suggest the memory will be zero-initialized, which is *not* what we want. + return reinterpret_cast(u.aligned_char); +#else + return reinterpret_cast(aligned_char); +#endif + } + +private: +#if defined(_MSC_VER) && _MSC_VER < 1900 + // MSVC 2013 workarounds, sigh ... + union { + char aligned_char[sizeof(T) * N]; + double dummy_aligner; + } u; +#else + alignas(T) char aligned_char[sizeof(T) * N]; +#endif +}; + +template +class AlignedBuffer +{ +public: + T *data() + { + return nullptr; + } +}; + +// An immutable version of SmallVector which erases type information about storage. +template +class VectorView +{ +public: + T &operator[](size_t i) SPIRV_CROSS_NOEXCEPT + { + return ptr[i]; + } + + const T &operator[](size_t i) const SPIRV_CROSS_NOEXCEPT + { + return ptr[i]; + } + + bool empty() const SPIRV_CROSS_NOEXCEPT + { + return buffer_size == 0; + } + + size_t size() const SPIRV_CROSS_NOEXCEPT + { + return buffer_size; + } + + T *data() SPIRV_CROSS_NOEXCEPT + { + return ptr; + } + + const T *data() const SPIRV_CROSS_NOEXCEPT + { + return ptr; + } + + T *begin() SPIRV_CROSS_NOEXCEPT + { + return ptr; + } + + T *end() SPIRV_CROSS_NOEXCEPT + { + return ptr + buffer_size; + } + + const T *begin() const SPIRV_CROSS_NOEXCEPT + { + return ptr; + } + + const T *end() const SPIRV_CROSS_NOEXCEPT + { + return ptr + buffer_size; + } + + T &front() SPIRV_CROSS_NOEXCEPT + { + return ptr[0]; + } + + const T &front() const SPIRV_CROSS_NOEXCEPT + { + return ptr[0]; + } + + T &back() SPIRV_CROSS_NOEXCEPT + { + return ptr[buffer_size - 1]; + } + + const T &back() const SPIRV_CROSS_NOEXCEPT + { + return ptr[buffer_size - 1]; + } + + // Makes it easier to consume SmallVector. +#if defined(_MSC_VER) && _MSC_VER < 1900 + explicit operator std::vector() const + { + // Another MSVC 2013 workaround. It does not understand lvalue/rvalue qualified operations. + return std::vector(ptr, ptr + buffer_size); + } +#else + // Makes it easier to consume SmallVector. + explicit operator std::vector() const & + { + return std::vector(ptr, ptr + buffer_size); + } + + // If we are converting as an r-value, we can pilfer our elements. + explicit operator std::vector() && + { + return std::vector(std::make_move_iterator(ptr), std::make_move_iterator(ptr + buffer_size)); + } +#endif + + // Avoid sliced copies. Base class should only be read as a reference. + VectorView(const VectorView &) = delete; + void operator=(const VectorView &) = delete; + +protected: + VectorView() = default; + T *ptr = nullptr; + size_t buffer_size = 0; +}; + +// Simple vector which supports up to N elements inline, without malloc/free. +// We use a lot of throwaway vectors all over the place which triggers allocations. +// This class only implements the subset of std::vector we need in SPIRV-Cross. +// It is *NOT* a drop-in replacement in general projects. +template +class SmallVector : public VectorView +{ +public: + SmallVector() SPIRV_CROSS_NOEXCEPT + { + this->ptr = stack_storage.data(); + buffer_capacity = N; + } + + SmallVector(const T *arg_list_begin, const T *arg_list_end) SPIRV_CROSS_NOEXCEPT : SmallVector() + { + auto count = size_t(arg_list_end - arg_list_begin); + reserve(count); + for (size_t i = 0; i < count; i++, arg_list_begin++) + new (&this->ptr[i]) T(*arg_list_begin); + this->buffer_size = count; + } + + SmallVector(SmallVector &&other) SPIRV_CROSS_NOEXCEPT : SmallVector() + { + *this = std::move(other); + } + + SmallVector &operator=(SmallVector &&other) SPIRV_CROSS_NOEXCEPT + { + clear(); + if (other.ptr != other.stack_storage.data()) + { + // Pilfer allocated pointer. + if (this->ptr != stack_storage.data()) + free(this->ptr); + this->ptr = other.ptr; + this->buffer_size = other.buffer_size; + buffer_capacity = other.buffer_capacity; + other.ptr = nullptr; + other.buffer_size = 0; + other.buffer_capacity = 0; + } + else + { + // Need to move the stack contents individually. + reserve(other.buffer_size); + for (size_t i = 0; i < other.buffer_size; i++) + { + new (&this->ptr[i]) T(std::move(other.ptr[i])); + other.ptr[i].~T(); + } + this->buffer_size = other.buffer_size; + other.buffer_size = 0; + } + return *this; + } + + SmallVector(const SmallVector &other) SPIRV_CROSS_NOEXCEPT : SmallVector() + { + *this = other; + } + + SmallVector &operator=(const SmallVector &other) SPIRV_CROSS_NOEXCEPT + { + if (this == &other) + return *this; + + clear(); + reserve(other.buffer_size); + for (size_t i = 0; i < other.buffer_size; i++) + new (&this->ptr[i]) T(other.ptr[i]); + this->buffer_size = other.buffer_size; + return *this; + } + + explicit SmallVector(size_t count) SPIRV_CROSS_NOEXCEPT : SmallVector() + { + resize(count); + } + + ~SmallVector() + { + clear(); + if (this->ptr != stack_storage.data()) + free(this->ptr); + } + + void clear() SPIRV_CROSS_NOEXCEPT + { + for (size_t i = 0; i < this->buffer_size; i++) + this->ptr[i].~T(); + this->buffer_size = 0; + } + + void push_back(const T &t) SPIRV_CROSS_NOEXCEPT + { + reserve(this->buffer_size + 1); + new (&this->ptr[this->buffer_size]) T(t); + this->buffer_size++; + } + + void push_back(T &&t) SPIRV_CROSS_NOEXCEPT + { + reserve(this->buffer_size + 1); + new (&this->ptr[this->buffer_size]) T(std::move(t)); + this->buffer_size++; + } + + void pop_back() SPIRV_CROSS_NOEXCEPT + { + // Work around false positive warning on GCC 8.3. + // Calling pop_back on empty vector is undefined. + if (!this->empty()) + resize(this->buffer_size - 1); + } + + template + void emplace_back(Ts &&... ts) SPIRV_CROSS_NOEXCEPT + { + reserve(this->buffer_size + 1); + new (&this->ptr[this->buffer_size]) T(std::forward(ts)...); + this->buffer_size++; + } + + void reserve(size_t count) SPIRV_CROSS_NOEXCEPT + { + if ((count > std::numeric_limits::max() / sizeof(T)) || + (count > std::numeric_limits::max() / 2)) + { + // Only way this should ever happen is with garbage input, terminate. + std::terminate(); + } + + if (count > buffer_capacity) + { + size_t target_capacity = buffer_capacity; + if (target_capacity == 0) + target_capacity = 1; + if (target_capacity < N) + target_capacity = N; + + // Need to ensure there is a POT value of target capacity which is larger than count, + // otherwise this will overflow. + while (target_capacity < count) + target_capacity <<= 1u; + + T *new_buffer = + target_capacity > N ? static_cast(malloc(target_capacity * sizeof(T))) : stack_storage.data(); + + // If we actually fail this malloc, we are hosed anyways, there is no reason to attempt recovery. + if (!new_buffer) + std::terminate(); + + // In case for some reason two allocations both come from same stack. + if (new_buffer != this->ptr) + { + // We don't deal with types which can throw in move constructor. + for (size_t i = 0; i < this->buffer_size; i++) + { + new (&new_buffer[i]) T(std::move(this->ptr[i])); + this->ptr[i].~T(); + } + } + + if (this->ptr != stack_storage.data()) + free(this->ptr); + this->ptr = new_buffer; + buffer_capacity = target_capacity; + } + } + + void insert(T *itr, const T *insert_begin, const T *insert_end) SPIRV_CROSS_NOEXCEPT + { + auto count = size_t(insert_end - insert_begin); + if (itr == this->end()) + { + reserve(this->buffer_size + count); + for (size_t i = 0; i < count; i++, insert_begin++) + new (&this->ptr[this->buffer_size + i]) T(*insert_begin); + this->buffer_size += count; + } + else + { + if (this->buffer_size + count > buffer_capacity) + { + auto target_capacity = this->buffer_size + count; + if (target_capacity == 0) + target_capacity = 1; + if (target_capacity < N) + target_capacity = N; + + while (target_capacity < count) + target_capacity <<= 1u; + + // Need to allocate new buffer. Move everything to a new buffer. + T *new_buffer = + target_capacity > N ? static_cast(malloc(target_capacity * sizeof(T))) : stack_storage.data(); + + // If we actually fail this malloc, we are hosed anyways, there is no reason to attempt recovery. + if (!new_buffer) + std::terminate(); + + // First, move elements from source buffer to new buffer. + // We don't deal with types which can throw in move constructor. + auto *target_itr = new_buffer; + auto *original_source_itr = this->begin(); + + if (new_buffer != this->ptr) + { + while (original_source_itr != itr) + { + new (target_itr) T(std::move(*original_source_itr)); + original_source_itr->~T(); + ++original_source_itr; + ++target_itr; + } + } + + // Copy-construct new elements. + for (auto *source_itr = insert_begin; source_itr != insert_end; ++source_itr, ++target_itr) + new (target_itr) T(*source_itr); + + // Move over the other half. + if (new_buffer != this->ptr || insert_begin != insert_end) + { + while (original_source_itr != this->end()) + { + new (target_itr) T(std::move(*original_source_itr)); + original_source_itr->~T(); + ++original_source_itr; + ++target_itr; + } + } + + if (this->ptr != stack_storage.data()) + free(this->ptr); + this->ptr = new_buffer; + buffer_capacity = target_capacity; + } + else + { + // Move in place, need to be a bit careful about which elements are constructed and which are not. + // Move the end and construct the new elements. + auto *target_itr = this->end() + count; + auto *source_itr = this->end(); + while (target_itr != this->end() && source_itr != itr) + { + --target_itr; + --source_itr; + new (target_itr) T(std::move(*source_itr)); + } + + // For already constructed elements we can move-assign. + std::move_backward(itr, source_itr, target_itr); + + // For the inserts which go to already constructed elements, we can do a plain copy. + while (itr != this->end() && insert_begin != insert_end) + *itr++ = *insert_begin++; + + // For inserts into newly allocated memory, we must copy-construct instead. + while (insert_begin != insert_end) + { + new (itr) T(*insert_begin); + ++itr; + ++insert_begin; + } + } + + this->buffer_size += count; + } + } + + void insert(T *itr, const T &value) SPIRV_CROSS_NOEXCEPT + { + insert(itr, &value, &value + 1); + } + + T *erase(T *itr) SPIRV_CROSS_NOEXCEPT + { + std::move(itr + 1, this->end(), itr); + this->ptr[--this->buffer_size].~T(); + return itr; + } + + void erase(T *start_erase, T *end_erase) SPIRV_CROSS_NOEXCEPT + { + if (end_erase == this->end()) + { + resize(size_t(start_erase - this->begin())); + } + else + { + auto new_size = this->buffer_size - (end_erase - start_erase); + std::move(end_erase, this->end(), start_erase); + resize(new_size); + } + } + + void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT + { + if (new_size < this->buffer_size) + { + for (size_t i = new_size; i < this->buffer_size; i++) + this->ptr[i].~T(); + } + else if (new_size > this->buffer_size) + { + reserve(new_size); + for (size_t i = this->buffer_size; i < new_size; i++) + new (&this->ptr[i]) T(); + } + + this->buffer_size = new_size; + } + +private: + size_t buffer_capacity = 0; + AlignedBuffer stack_storage; +}; + +// A vector without stack storage. +// Could also be a typedef-ed to std::vector, +// but might as well use the one we have. +template +using Vector = SmallVector; + +#else // SPIRV_CROSS_FORCE_STL_TYPES + +template +using SmallVector = std::vector; +template +using Vector = std::vector; +template +using VectorView = std::vector; + +#endif // SPIRV_CROSS_FORCE_STL_TYPES + +// An object pool which we use for allocating IVariant-derived objects. +// We know we are going to allocate a bunch of objects of each type, +// so amortize the mallocs. +class ObjectPoolBase +{ +public: + virtual ~ObjectPoolBase() = default; + virtual void free_opaque(void *ptr) = 0; +}; + +template +class ObjectPool : public ObjectPoolBase +{ +public: + explicit ObjectPool(unsigned start_object_count_ = 16) + : start_object_count(start_object_count_) + { + } + + template + T *allocate(P &&... p) + { + if (vacants.empty()) + { + unsigned num_objects = start_object_count << memory.size(); + T *ptr = static_cast(malloc(num_objects * sizeof(T))); + if (!ptr) + return nullptr; + + for (unsigned i = 0; i < num_objects; i++) + vacants.push_back(&ptr[i]); + + memory.emplace_back(ptr); + } + + T *ptr = vacants.back(); + vacants.pop_back(); + new (ptr) T(std::forward

(p)...); + return ptr; + } + + void free(T *ptr) + { + ptr->~T(); + vacants.push_back(ptr); + } + + void free_opaque(void *ptr) override + { + free(static_cast(ptr)); + } + + void clear() + { + vacants.clear(); + memory.clear(); + } + +protected: + Vector vacants; + + struct MallocDeleter + { + void operator()(T *ptr) + { + ::free(ptr); + } + }; + + SmallVector> memory; + unsigned start_object_count; +}; + +template +class StringStream +{ +public: + StringStream() + { + reset(); + } + + ~StringStream() + { + reset(); + } + + // Disable copies and moves. Makes it easier to implement, and we don't need it. + StringStream(const StringStream &) = delete; + void operator=(const StringStream &) = delete; + + template ::value, int>::type = 0> + StringStream &operator<<(const T &t) + { + auto s = std::to_string(t); + append(s.data(), s.size()); + return *this; + } + + // Only overload this to make float/double conversions ambiguous. + StringStream &operator<<(uint32_t v) + { + auto s = std::to_string(v); + append(s.data(), s.size()); + return *this; + } + + StringStream &operator<<(char c) + { + append(&c, 1); + return *this; + } + + StringStream &operator<<(const std::string &s) + { + append(s.data(), s.size()); + return *this; + } + + StringStream &operator<<(const char *s) + { + append(s, strlen(s)); + return *this; + } + + template + StringStream &operator<<(const char (&s)[N]) + { + append(s, strlen(s)); + return *this; + } + + std::string str() const + { + std::string ret; + size_t target_size = 0; + for (auto &saved : saved_buffers) + target_size += saved.offset; + target_size += current_buffer.offset; + ret.reserve(target_size); + + for (auto &saved : saved_buffers) + ret.insert(ret.end(), saved.buffer, saved.buffer + saved.offset); + ret.insert(ret.end(), current_buffer.buffer, current_buffer.buffer + current_buffer.offset); + return ret; + } + + void reset() + { + for (auto &saved : saved_buffers) + if (saved.buffer != stack_buffer) + free(saved.buffer); + if (current_buffer.buffer != stack_buffer) + free(current_buffer.buffer); + + saved_buffers.clear(); + current_buffer.buffer = stack_buffer; + current_buffer.offset = 0; + current_buffer.size = sizeof(stack_buffer); + } + +private: + struct Buffer + { + char *buffer = nullptr; + size_t offset = 0; + size_t size = 0; + }; + Buffer current_buffer; + char stack_buffer[StackSize]; + SmallVector saved_buffers; + + void append(const char *s, size_t len) + { + size_t avail = current_buffer.size - current_buffer.offset; + if (avail < len) + { + if (avail > 0) + { + memcpy(current_buffer.buffer + current_buffer.offset, s, avail); + s += avail; + len -= avail; + current_buffer.offset += avail; + } + + saved_buffers.push_back(current_buffer); + size_t target_size = len > BlockSize ? len : BlockSize; + current_buffer.buffer = static_cast(malloc(target_size)); + if (!current_buffer.buffer) + SPIRV_CROSS_THROW("Out of memory."); + + memcpy(current_buffer.buffer, s, len); + current_buffer.offset = len; + current_buffer.size = target_size; + } + else + { + memcpy(current_buffer.buffer + current_buffer.offset, s, len); + current_buffer.offset += len; + } + } +}; + +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_cross_error_handling.hpp b/ios/include/spirv_cross/spirv_cross_error_handling.hpp new file mode 100644 index 00000000..fa90610b --- /dev/null +++ b/ios/include/spirv_cross/spirv_cross_error_handling.hpp @@ -0,0 +1,87 @@ +/* + * Copyright 2015-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_ERROR_HANDLING +#define SPIRV_CROSS_ERROR_HANDLING + +#include +#include +#include +#ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS +#include +#endif + +#ifdef SPIRV_CROSS_NAMESPACE_OVERRIDE +#define SPIRV_CROSS_NAMESPACE SPIRV_CROSS_NAMESPACE_OVERRIDE +#else +#define SPIRV_CROSS_NAMESPACE spirv_cross +#endif + +namespace SPIRV_CROSS_NAMESPACE +{ +#ifdef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS +#if !defined(_MSC_VER) || defined(__clang__) +[[noreturn]] +#elif defined(_MSC_VER) +__declspec(noreturn) +#endif +inline void +report_and_abort(const std::string &msg) +{ +#ifdef NDEBUG + (void)msg; +#else + fprintf(stderr, "There was a compiler error: %s\n", msg.c_str()); +#endif + fflush(stderr); + abort(); +} + +#define SPIRV_CROSS_THROW(x) report_and_abort(x) +#else +class CompilerError : public std::runtime_error +{ +public: + explicit CompilerError(const std::string &str) + : std::runtime_error(str) + { + } +}; + +#define SPIRV_CROSS_THROW(x) throw CompilerError(x) +#endif + +// MSVC 2013 does not have noexcept. We need this for Variant to get move constructor to work correctly +// instead of copy constructor. +// MSVC 2013 ignores that move constructors cannot throw in std::vector, so just don't define it. +#if defined(_MSC_VER) && _MSC_VER < 1900 +#define SPIRV_CROSS_NOEXCEPT +#else +#define SPIRV_CROSS_NOEXCEPT noexcept +#endif + +#if __cplusplus >= 201402l +#define SPIRV_CROSS_DEPRECATED(reason) [[deprecated(reason)]] +#elif defined(__GNUC__) +#define SPIRV_CROSS_DEPRECATED(reason) __attribute__((deprecated)) +#elif defined(_MSC_VER) +#define SPIRV_CROSS_DEPRECATED(reason) __declspec(deprecated(reason)) +#else +#define SPIRV_CROSS_DEPRECATED(reason) +#endif +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_cross_parsed_ir.hpp b/ios/include/spirv_cross/spirv_cross_parsed_ir.hpp new file mode 100644 index 00000000..4880c841 --- /dev/null +++ b/ios/include/spirv_cross/spirv_cross_parsed_ir.hpp @@ -0,0 +1,231 @@ +/* + * Copyright 2018-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_PARSED_IR_HPP +#define SPIRV_CROSS_PARSED_IR_HPP + +#include "spirv_common.hpp" +#include +#include + +namespace SPIRV_CROSS_NAMESPACE +{ + +// This data structure holds all information needed to perform cross-compilation and reflection. +// It is the output of the Parser, but any implementation could create this structure. +// It is intentionally very "open" and struct-like with some helper functions to deal with decorations. +// Parser is the reference implementation of how this data structure should be filled in. + +class ParsedIR +{ +private: + // This must be destroyed after the "ids" vector. + std::unique_ptr pool_group; + +public: + ParsedIR(); + + // Due to custom allocations from object pools, we cannot use a default copy constructor. + ParsedIR(const ParsedIR &other); + ParsedIR &operator=(const ParsedIR &other); + + // Moves are unproblematic, but we need to implement it anyways, since MSVC 2013 does not understand + // how to default-implement these. + ParsedIR(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT; + ParsedIR &operator=(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT; + + // Resizes ids, meta and block_meta. + void set_id_bounds(uint32_t bounds); + + // The raw SPIR-V, instructions and opcodes refer to this by offset + count. + std::vector spirv; + + // Holds various data structures which inherit from IVariant. + SmallVector ids; + + // Various meta data for IDs, decorations, names, etc. + std::unordered_map meta; + + // Holds all IDs which have a certain type. + // This is needed so we can iterate through a specific kind of resource quickly, + // and in-order of module declaration. + SmallVector ids_for_type[TypeCount]; + + // Special purpose lists which contain a union of types. + // This is needed so we can declare specialization constants and structs in an interleaved fashion, + // among other things. + // Constants can be of struct type, and struct array sizes can use specialization constants. + SmallVector ids_for_constant_or_type; + SmallVector ids_for_constant_or_variable; + + // Declared capabilities and extensions in the SPIR-V module. + // Not really used except for reflection at the moment. + SmallVector declared_capabilities; + SmallVector declared_extensions; + + // Meta data about blocks. The cross-compiler needs to query if a block is either of these types. + // It is a bitset as there can be more than one tag per block. + enum BlockMetaFlagBits + { + BLOCK_META_LOOP_HEADER_BIT = 1 << 0, + BLOCK_META_CONTINUE_BIT = 1 << 1, + BLOCK_META_LOOP_MERGE_BIT = 1 << 2, + BLOCK_META_SELECTION_MERGE_BIT = 1 << 3, + BLOCK_META_MULTISELECT_MERGE_BIT = 1 << 4 + }; + using BlockMetaFlags = uint8_t; + SmallVector block_meta; + std::unordered_map continue_block_to_loop_header; + + // Normally, we'd stick SPIREntryPoint in ids array, but it conflicts with SPIRFunction. + // Entry points can therefore be seen as some sort of meta structure. + std::unordered_map entry_points; + FunctionID default_entry_point = 0; + + struct Source + { + uint32_t version = 0; + bool es = false; + bool known = false; + bool hlsl = false; + + Source() = default; + }; + + Source source; + + spv::AddressingModel addressing_model = spv::AddressingModelMax; + spv::MemoryModel memory_model = spv::MemoryModelMax; + + // Decoration handling methods. + // Can be useful for simple "raw" reflection. + // However, most members are here because the Parser needs most of these, + // and might as well just have the whole suite of decoration/name handling in one place. + void set_name(ID id, const std::string &name); + const std::string &get_name(ID id) const; + void set_decoration(ID id, spv::Decoration decoration, uint32_t argument = 0); + void set_decoration_string(ID id, spv::Decoration decoration, const std::string &argument); + bool has_decoration(ID id, spv::Decoration decoration) const; + uint32_t get_decoration(ID id, spv::Decoration decoration) const; + const std::string &get_decoration_string(ID id, spv::Decoration decoration) const; + const Bitset &get_decoration_bitset(ID id) const; + void unset_decoration(ID id, spv::Decoration decoration); + + // Decoration handling methods (for members of a struct). + void set_member_name(TypeID id, uint32_t index, const std::string &name); + const std::string &get_member_name(TypeID id, uint32_t index) const; + void set_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration, uint32_t argument = 0); + void set_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration, + const std::string &argument); + uint32_t get_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; + const std::string &get_member_decoration_string(TypeID id, uint32_t index, spv::Decoration decoration) const; + bool has_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration) const; + const Bitset &get_member_decoration_bitset(TypeID id, uint32_t index) const; + void unset_member_decoration(TypeID id, uint32_t index, spv::Decoration decoration); + + void mark_used_as_array_length(ID id); + uint32_t increase_bound_by(uint32_t count); + Bitset get_buffer_block_flags(const SPIRVariable &var) const; + + void add_typed_id(Types type, ID id); + void remove_typed_id(Types type, ID id); + + class LoopLock + { + public: + explicit LoopLock(uint32_t *counter); + LoopLock(const LoopLock &) = delete; + void operator=(const LoopLock &) = delete; + LoopLock(LoopLock &&other) SPIRV_CROSS_NOEXCEPT; + LoopLock &operator=(LoopLock &&other) SPIRV_CROSS_NOEXCEPT; + ~LoopLock(); + + private: + uint32_t *lock; + }; + + // This must be held while iterating over a type ID array. + // It is undefined if someone calls set<>() while we're iterating over a data structure, so we must + // make sure that this case is avoided. + + // If we have a hard lock, it is an error to call set<>(), and an exception is thrown. + // If we have a soft lock, we silently ignore any additions to the typed arrays. + // This should only be used for physical ID remapping where we need to create an ID, but we will never + // care about iterating over them. + LoopLock create_loop_hard_lock() const; + LoopLock create_loop_soft_lock() const; + + template + void for_each_typed_id(const Op &op) + { + auto loop_lock = create_loop_hard_lock(); + for (auto &id : ids_for_type[T::type]) + { + if (ids[id].get_type() == static_cast(T::type)) + op(id, get(id)); + } + } + + template + void for_each_typed_id(const Op &op) const + { + auto loop_lock = create_loop_hard_lock(); + for (auto &id : ids_for_type[T::type]) + { + if (ids[id].get_type() == static_cast(T::type)) + op(id, get(id)); + } + } + + template + void reset_all_of_type() + { + reset_all_of_type(static_cast(T::type)); + } + + void reset_all_of_type(Types type); + + Meta *find_meta(ID id); + const Meta *find_meta(ID id) const; + + const std::string &get_empty_string() const + { + return empty_string; + } + + void make_constant_null(uint32_t id, uint32_t type, bool add_to_typed_id_set); + +private: + template + T &get(uint32_t id) + { + return variant_get(ids[id]); + } + + template + const T &get(uint32_t id) const + { + return variant_get(ids[id]); + } + + mutable uint32_t loop_iteration_depth_hard = 0; + mutable uint32_t loop_iteration_depth_soft = 0; + std::string empty_string; + Bitset cleared_bitset; +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_cross_util.hpp b/ios/include/spirv_cross/spirv_cross_util.hpp new file mode 100644 index 00000000..708b7cb5 --- /dev/null +++ b/ios/include/spirv_cross/spirv_cross_util.hpp @@ -0,0 +1,30 @@ +/* + * Copyright 2015-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_UTIL_HPP +#define SPIRV_CROSS_UTIL_HPP + +#include "spirv_cross.hpp" + +namespace spirv_cross_util +{ +void rename_interface_variable(SPIRV_CROSS_NAMESPACE::Compiler &compiler, + const SPIRV_CROSS_NAMESPACE::SmallVector &resources, + uint32_t location, const std::string &name); +void inherit_combined_sampler_bindings(SPIRV_CROSS_NAMESPACE::Compiler &compiler); +} // namespace spirv_cross_util + +#endif diff --git a/ios/include/spirv_cross/spirv_glsl.hpp b/ios/include/spirv_cross/spirv_glsl.hpp new file mode 100644 index 00000000..1eafc2ce --- /dev/null +++ b/ios/include/spirv_cross/spirv_glsl.hpp @@ -0,0 +1,760 @@ +/* + * Copyright 2015-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_GLSL_HPP +#define SPIRV_CROSS_GLSL_HPP + +#include "GLSL.std.450.h" +#include "spirv_cross.hpp" +#include +#include +#include + +namespace SPIRV_CROSS_NAMESPACE +{ +enum PlsFormat +{ + PlsNone = 0, + + PlsR11FG11FB10F, + PlsR32F, + PlsRG16F, + PlsRGB10A2, + PlsRGBA8, + PlsRG16, + + PlsRGBA8I, + PlsRG16I, + + PlsRGB10A2UI, + PlsRGBA8UI, + PlsRG16UI, + PlsR32UI +}; + +struct PlsRemap +{ + uint32_t id; + PlsFormat format; +}; + +enum AccessChainFlagBits +{ + ACCESS_CHAIN_INDEX_IS_LITERAL_BIT = 1 << 0, + ACCESS_CHAIN_CHAIN_ONLY_BIT = 1 << 1, + ACCESS_CHAIN_PTR_CHAIN_BIT = 1 << 2, + ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT = 1 << 3, + ACCESS_CHAIN_LITERAL_MSB_FORCE_ID = 1 << 4 +}; +typedef uint32_t AccessChainFlags; + +class CompilerGLSL : public Compiler +{ +public: + struct Options + { + // The shading language version. Corresponds to #version $VALUE. + uint32_t version = 450; + + // Emit the OpenGL ES shading language instead of desktop OpenGL. + bool es = false; + + // Debug option to always emit temporary variables for all expressions. + bool force_temporary = false; + + // If true, Vulkan GLSL features are used instead of GL-compatible features. + // Mostly useful for debugging SPIR-V files. + bool vulkan_semantics = false; + + // If true, gl_PerVertex is explicitly redeclared in vertex, geometry and tessellation shaders. + // The members of gl_PerVertex is determined by which built-ins are declared by the shader. + // This option is ignored in ES versions, as redeclaration in ES is not required, and it depends on a different extension + // (EXT_shader_io_blocks) which makes things a bit more fuzzy. + bool separate_shader_objects = false; + + // Flattens multidimensional arrays, e.g. float foo[a][b][c] into single-dimensional arrays, + // e.g. float foo[a * b * c]. + // This function does not change the actual SPIRType of any object. + // Only the generated code, including declarations of interface variables are changed to be single array dimension. + bool flatten_multidimensional_arrays = false; + + // For older desktop GLSL targets than version 420, the + // GL_ARB_shading_language_420pack extensions is used to be able to support + // layout(binding) on UBOs and samplers. + // If disabled on older targets, binding decorations will be stripped. + bool enable_420pack_extension = true; + + // In non-Vulkan GLSL, emit push constant blocks as UBOs rather than plain uniforms. + bool emit_push_constant_as_uniform_buffer = false; + + // Always emit uniform blocks as plain uniforms, regardless of the GLSL version, even when UBOs are supported. + // Does not apply to shader storage or push constant blocks. + bool emit_uniform_buffer_as_plain_uniforms = false; + + // Emit OpLine directives if present in the module. + // May not correspond exactly to original source, but should be a good approximation. + bool emit_line_directives = false; + + // In cases where readonly/writeonly decoration are not used at all, + // we try to deduce which qualifier(s) we should actually used, since actually emitting + // read-write decoration is very rare, and older glslang/HLSL compilers tend to just emit readwrite as a matter of fact. + // The default (true) is to enable automatic deduction for these cases, but if you trust the decorations set + // by the SPIR-V, it's recommended to set this to false. + bool enable_storage_image_qualifier_deduction = true; + + // On some targets (WebGPU), uninitialized variables are banned. + // If this is enabled, all variables (temporaries, Private, Function) + // which would otherwise be uninitialized will now be initialized to 0 instead. + bool force_zero_initialized_variables = false; + + enum Precision + { + DontCare, + Lowp, + Mediump, + Highp + }; + + struct + { + // GLSL: In vertex shaders, rewrite [0, w] depth (Vulkan/D3D style) to [-w, w] depth (GL style). + // MSL: In vertex shaders, rewrite [-w, w] depth (GL style) to [0, w] depth. + // HLSL: In vertex shaders, rewrite [-w, w] depth (GL style) to [0, w] depth. + bool fixup_clipspace = false; + + // Inverts gl_Position.y or equivalent. + bool flip_vert_y = false; + + // GLSL only, for HLSL version of this option, see CompilerHLSL. + // If true, the backend will assume that InstanceIndex will need to apply + // a base instance offset. Set to false if you know you will never use base instance + // functionality as it might remove some internal uniforms. + bool support_nonzero_base_instance = true; + } vertex; + + struct + { + // Add precision mediump float in ES targets when emitting GLES source. + // Add precision highp int in ES targets when emitting GLES source. + Precision default_float_precision = Mediump; + Precision default_int_precision = Highp; + } fragment; + }; + + void remap_pixel_local_storage(std::vector inputs, std::vector outputs) + { + pls_inputs = std::move(inputs); + pls_outputs = std::move(outputs); + remap_pls_variables(); + } + + // Redirect a subpassInput reading from input_attachment_index to instead load its value from + // the color attachment at location = color_location. Requires ESSL. + void remap_ext_framebuffer_fetch(uint32_t input_attachment_index, uint32_t color_location); + + explicit CompilerGLSL(std::vector spirv_) + : Compiler(std::move(spirv_)) + { + init(); + } + + CompilerGLSL(const uint32_t *ir_, size_t word_count) + : Compiler(ir_, word_count) + { + init(); + } + + explicit CompilerGLSL(const ParsedIR &ir_) + : Compiler(ir_) + { + init(); + } + + explicit CompilerGLSL(ParsedIR &&ir_) + : Compiler(std::move(ir_)) + { + init(); + } + + const Options &get_common_options() const + { + return options; + } + + void set_common_options(const Options &opts) + { + options = opts; + } + + std::string compile() override; + + // Returns the current string held in the conversion buffer. Useful for + // capturing what has been converted so far when compile() throws an error. + std::string get_partial_source(); + + // Adds a line to be added right after #version in GLSL backend. + // This is useful for enabling custom extensions which are outside the scope of SPIRV-Cross. + // This can be combined with variable remapping. + // A new-line will be added. + // + // While add_header_line() is a more generic way of adding arbitrary text to the header + // of a GLSL file, require_extension() should be used when adding extensions since it will + // avoid creating collisions with SPIRV-Cross generated extensions. + // + // Code added via add_header_line() is typically backend-specific. + void add_header_line(const std::string &str); + + // Adds an extension which is required to run this shader, e.g. + // require_extension("GL_KHR_my_extension"); + void require_extension(const std::string &ext); + + // Legacy GLSL compatibility method. + // Takes a uniform or push constant variable and flattens it into a (i|u)vec4 array[N]; array instead. + // For this to work, all types in the block must be the same basic type, e.g. mixing vec2 and vec4 is fine, but + // mixing int and float is not. + // The name of the uniform array will be the same as the interface block name. + void flatten_buffer_block(VariableID id); + + // After compilation, query if a variable ID was used as a depth resource. + // This is meaningful for MSL since descriptor types depend on this knowledge. + // Cases which return true: + // - Images which are declared with depth = 1 image type. + // - Samplers which are statically used at least once with Dref opcodes. + // - Images which are statically used at least once with Dref opcodes. + bool variable_is_depth_or_compare(VariableID id) const; + +protected: + void reset(); + void emit_function(SPIRFunction &func, const Bitset &return_flags); + + bool has_extension(const std::string &ext) const; + void require_extension_internal(const std::string &ext); + + // Virtualize methods which need to be overridden by subclass targets like C++ and such. + virtual void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags); + + SPIRBlock *current_emitting_block = nullptr; + SPIRBlock *current_emitting_switch = nullptr; + bool current_emitting_switch_fallthrough = false; + + virtual void emit_instruction(const Instruction &instr); + void emit_block_instructions(SPIRBlock &block); + virtual void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, + uint32_t count); + virtual void emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t result_id, uint32_t op, + const uint32_t *args, uint32_t count); + virtual void emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t result_id, uint32_t op, + const uint32_t *args, uint32_t count); + virtual void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op, + const uint32_t *args, uint32_t count); + virtual void emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, + uint32_t count); + virtual void emit_header(); + void emit_line_directive(uint32_t file_id, uint32_t line_literal); + void build_workgroup_size(SmallVector &arguments, const SpecializationConstant &x, + const SpecializationConstant &y, const SpecializationConstant &z); + + virtual void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id); + virtual void emit_texture_op(const Instruction &i); + virtual std::string to_texture_op(const Instruction &i, bool *forward, + SmallVector &inherited_expressions); + virtual void emit_subgroup_op(const Instruction &i); + virtual std::string type_to_glsl(const SPIRType &type, uint32_t id = 0); + virtual std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage); + virtual void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, + const std::string &qualifier = "", uint32_t base_offset = 0); + virtual void emit_struct_padding_target(const SPIRType &type); + virtual std::string image_type_glsl(const SPIRType &type, uint32_t id = 0); + std::string constant_expression(const SPIRConstant &c); + std::string constant_op_expression(const SPIRConstantOp &cop); + virtual std::string constant_expression_vector(const SPIRConstant &c, uint32_t vector); + virtual void emit_fixup(); + virtual std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0); + virtual std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id); + virtual std::string to_function_name(VariableID img, const SPIRType &imgtype, bool is_fetch, bool is_gather, + bool is_proj, bool has_array_offsets, bool has_offset, bool has_grad, + bool has_dref, uint32_t lod, uint32_t minlod); + virtual std::string to_function_args(VariableID img, const SPIRType &imgtype, bool is_fetch, bool is_gather, + bool is_proj, uint32_t coord, uint32_t coord_components, uint32_t dref, + uint32_t grad_x, uint32_t grad_y, uint32_t lod, uint32_t coffset, + uint32_t offset, uint32_t bias, uint32_t comp, uint32_t sample, + uint32_t minlod, bool *p_forward); + virtual void emit_buffer_block(const SPIRVariable &type); + virtual void emit_push_constant_block(const SPIRVariable &var); + virtual void emit_uniform(const SPIRVariable &var); + virtual std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id, + bool packed_type, bool row_major); + + virtual bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const; + + void emit_copy_logical_type(uint32_t lhs_id, uint32_t lhs_type_id, uint32_t rhs_id, uint32_t rhs_type_id, + SmallVector chain); + + StringStream<> buffer; + + template + inline void statement_inner(T &&t) + { + buffer << std::forward(t); + statement_count++; + } + + template + inline void statement_inner(T &&t, Ts &&... ts) + { + buffer << std::forward(t); + statement_count++; + statement_inner(std::forward(ts)...); + } + + template + inline void statement(Ts &&... ts) + { + if (is_forcing_recompilation()) + { + // Do not bother emitting code while force_recompile is active. + // We will compile again. + statement_count++; + return; + } + + if (redirect_statement) + { + redirect_statement->push_back(join(std::forward(ts)...)); + statement_count++; + } + else + { + for (uint32_t i = 0; i < indent; i++) + buffer << " "; + statement_inner(std::forward(ts)...); + buffer << '\n'; + } + } + + template + inline void statement_no_indent(Ts &&... ts) + { + auto old_indent = indent; + indent = 0; + statement(std::forward(ts)...); + indent = old_indent; + } + + // Used for implementing continue blocks where + // we want to obtain a list of statements we can merge + // on a single line separated by comma. + SmallVector *redirect_statement = nullptr; + const SPIRBlock *current_continue_block = nullptr; + + void begin_scope(); + void end_scope(); + void end_scope(const std::string &trailer); + void end_scope_decl(); + void end_scope_decl(const std::string &decl); + + Options options; + + virtual std::string type_to_array_glsl( + const SPIRType &type); // Allow Metal to use the array template to make arrays a value type + std::string to_array_size(const SPIRType &type, uint32_t index); + uint32_t to_array_size_literal(const SPIRType &type, uint32_t index) const; + uint32_t to_array_size_literal(const SPIRType &type) const; + virtual std::string variable_decl(const SPIRVariable &variable); // Threadgroup arrays can't have a wrapper type + std::string variable_decl_function_local(SPIRVariable &variable); + + void add_local_variable_name(uint32_t id); + void add_resource_name(uint32_t id); + void add_member_name(SPIRType &type, uint32_t name); + void add_function_overload(const SPIRFunction &func); + + virtual bool is_non_native_row_major_matrix(uint32_t id); + virtual bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index); + bool member_is_remapped_physical_type(const SPIRType &type, uint32_t index) const; + bool member_is_packed_physical_type(const SPIRType &type, uint32_t index) const; + virtual std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type, + uint32_t physical_type_id, bool is_packed); + + std::unordered_set local_variable_names; + std::unordered_set resource_names; + std::unordered_set block_input_names; + std::unordered_set block_output_names; + std::unordered_set block_ubo_names; + std::unordered_set block_ssbo_names; + std::unordered_set block_names; // A union of all block_*_names. + std::unordered_map> function_overloads; + std::unordered_map preserved_aliases; + void preserve_alias_on_reset(uint32_t id); + void reset_name_caches(); + + bool processing_entry_point = false; + + // Can be overriden by subclass backends for trivial things which + // shouldn't need polymorphism. + struct BackendVariations + { + std::string discard_literal = "discard"; + std::string demote_literal = "demote"; + std::string null_pointer_literal = ""; + bool float_literal_suffix = false; + bool double_literal_suffix = true; + bool uint32_t_literal_suffix = true; + bool long_long_literal_suffix = false; + const char *basic_int_type = "int"; + const char *basic_uint_type = "uint"; + const char *basic_int8_type = "int8_t"; + const char *basic_uint8_type = "uint8_t"; + const char *basic_int16_type = "int16_t"; + const char *basic_uint16_type = "uint16_t"; + const char *int16_t_literal_suffix = "s"; + const char *uint16_t_literal_suffix = "us"; + const char *nonuniform_qualifier = "nonuniformEXT"; + const char *boolean_mix_function = "mix"; + bool swizzle_is_function = false; + bool shared_is_implied = false; + bool unsized_array_supported = true; + bool explicit_struct_type = false; + bool use_initializer_list = false; + bool use_typed_initializer_list = false; + bool can_declare_struct_inline = true; + bool can_declare_arrays_inline = true; + bool native_row_major_matrix = true; + bool use_constructor_splatting = true; + bool allow_precision_qualifiers = false; + bool can_swizzle_scalar = false; + bool force_gl_in_out_block = false; + bool can_return_array = true; + bool allow_truncated_access_chain = false; + bool supports_extensions = false; + bool supports_empty_struct = false; + bool array_is_value_type = true; + bool comparison_image_samples_scalar = false; + bool native_pointers = false; + bool support_small_type_sampling_result = false; + bool support_case_fallthrough = true; + bool use_array_constructor = false; + } backend; + + void emit_struct(SPIRType &type); + void emit_resources(); + void emit_buffer_block_native(const SPIRVariable &var); + void emit_buffer_reference_block(SPIRType &type, bool forward_declaration); + void emit_buffer_block_legacy(const SPIRVariable &var); + void emit_buffer_block_flattened(const SPIRVariable &type); + void emit_declared_builtin_block(spv::StorageClass storage, spv::ExecutionModel model); + bool should_force_emit_builtin_block(spv::StorageClass storage); + void emit_push_constant_block_vulkan(const SPIRVariable &var); + void emit_push_constant_block_glsl(const SPIRVariable &var); + void emit_interface_block(const SPIRVariable &type); + void emit_flattened_io_block(const SPIRVariable &var, const char *qual); + void emit_block_chain(SPIRBlock &block); + void emit_hoisted_temporaries(SmallVector> &temporaries); + std::string constant_value_macro_name(uint32_t id); + void emit_constant(const SPIRConstant &constant); + void emit_specialization_constant_op(const SPIRConstantOp &constant); + std::string emit_continue_block(uint32_t continue_block, bool follow_true_block, bool follow_false_block); + bool attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method); + + void branch(BlockID from, BlockID to); + void branch_to_continue(BlockID from, BlockID to); + void branch(BlockID from, uint32_t cond, BlockID true_block, BlockID false_block); + void flush_phi(BlockID from, BlockID to); + void flush_variable_declaration(uint32_t id); + void flush_undeclared_variables(SPIRBlock &block); + void emit_variable_temporary_copies(const SPIRVariable &var); + + bool should_dereference(uint32_t id); + bool should_forward(uint32_t id) const; + bool should_suppress_usage_tracking(uint32_t id) const; + void emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp); + void emit_nminmax_op(uint32_t result_type, uint32_t id, uint32_t op0, uint32_t op1, GLSLstd450 op); + bool to_trivial_mix_op(const SPIRType &type, std::string &op, uint32_t left, uint32_t right, uint32_t lerp); + void emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, + uint32_t op3, const char *op); + void emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, + const char *op); + void emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); + + void emit_unary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op, + SPIRType::BaseType input_type, SPIRType::BaseType expected_result_type); + void emit_binary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, + SPIRType::BaseType input_type, bool skip_cast_if_equal_type); + void emit_binary_func_op_cast_clustered(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, + const char *op, SPIRType::BaseType input_type); + void emit_trinary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, + const char *op, SPIRType::BaseType input_type); + void emit_trinary_func_op_bitextract(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, + uint32_t op2, const char *op, SPIRType::BaseType expected_result_type, + SPIRType::BaseType input_type0, SPIRType::BaseType input_type1, + SPIRType::BaseType input_type2); + void emit_bitfield_insert_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, + uint32_t op3, const char *op, SPIRType::BaseType offset_count_type); + + void emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op); + void emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op); + void emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); + void emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, + bool negate, SPIRType::BaseType expected_type); + void emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, + SPIRType::BaseType input_type, bool skip_cast_if_equal_type); + + SPIRType binary_op_bitcast_helper(std::string &cast_op0, std::string &cast_op1, SPIRType::BaseType &input_type, + uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type); + + virtual bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0); + + std::string to_ternary_expression(const SPIRType &result_type, uint32_t select, uint32_t true_value, + uint32_t false_value); + + void emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op); + bool expression_is_forwarded(uint32_t id) const; + bool expression_suppresses_usage_tracking(uint32_t id) const; + SPIRExpression &emit_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs, + bool suppress_usage_tracking = false); + + void access_chain_internal_append_index(std::string &expr, uint32_t base, const SPIRType *type, + AccessChainFlags flags, bool &access_chain_is_arrayed, uint32_t index); + + std::string access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count, AccessChainFlags flags, + AccessChainMeta *meta); + + std::string access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, + AccessChainMeta *meta = nullptr, bool ptr_chain = false); + + std::string flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count, + const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, + uint32_t array_stride, bool need_transpose); + std::string flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count, + const SPIRType &target_type, uint32_t offset); + std::string flattened_access_chain_matrix(uint32_t base, const uint32_t *indices, uint32_t count, + const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, + bool need_transpose); + std::string flattened_access_chain_vector(uint32_t base, const uint32_t *indices, uint32_t count, + const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, + bool need_transpose); + std::pair flattened_access_chain_offset(const SPIRType &basetype, const uint32_t *indices, + uint32_t count, uint32_t offset, + uint32_t word_stride, bool *need_transpose = nullptr, + uint32_t *matrix_stride = nullptr, + uint32_t *array_stride = nullptr, + bool ptr_chain = false); + + const char *index_to_swizzle(uint32_t index); + std::string remap_swizzle(const SPIRType &result_type, uint32_t input_components, const std::string &expr); + std::string declare_temporary(uint32_t type, uint32_t id); + void emit_uninitialized_temporary(uint32_t type, uint32_t id); + SPIRExpression &emit_uninitialized_temporary_expression(uint32_t type, uint32_t id); + void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector &arglist); + std::string to_expression(uint32_t id, bool register_expression_read = true); + std::string to_composite_constructor_expression(uint32_t id); + std::string to_rerolled_array_expression(const std::string &expr, const SPIRType &type); + std::string to_enclosed_expression(uint32_t id, bool register_expression_read = true); + std::string to_unpacked_expression(uint32_t id, bool register_expression_read = true); + std::string to_unpacked_row_major_matrix_expression(uint32_t id); + std::string to_enclosed_unpacked_expression(uint32_t id, bool register_expression_read = true); + std::string to_dereferenced_expression(uint32_t id, bool register_expression_read = true); + std::string to_pointer_expression(uint32_t id, bool register_expression_read = true); + std::string to_enclosed_pointer_expression(uint32_t id, bool register_expression_read = true); + std::string to_extract_component_expression(uint32_t id, uint32_t index); + std::string enclose_expression(const std::string &expr); + std::string dereference_expression(const SPIRType &expression_type, const std::string &expr); + std::string address_of_expression(const std::string &expr); + void strip_enclosed_expression(std::string &expr); + std::string to_member_name(const SPIRType &type, uint32_t index); + virtual std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain); + std::string type_to_glsl_constructor(const SPIRType &type); + std::string argument_decl(const SPIRFunction::Parameter &arg); + virtual std::string to_qualifiers_glsl(uint32_t id); + const char *to_precision_qualifiers_glsl(uint32_t id); + virtual const char *to_storage_qualifiers_glsl(const SPIRVariable &var); + const char *flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags); + const char *format_to_glsl(spv::ImageFormat format); + virtual std::string layout_for_member(const SPIRType &type, uint32_t index); + virtual std::string to_interpolation_qualifiers(const Bitset &flags); + std::string layout_for_variable(const SPIRVariable &variable); + std::string to_combined_image_sampler(VariableID image_id, VariableID samp_id); + virtual bool skip_argument(uint32_t id) const; + virtual void emit_array_copy(const std::string &lhs, uint32_t rhs_id, spv::StorageClass lhs_storage, + spv::StorageClass rhs_storage); + virtual void emit_block_hints(const SPIRBlock &block); + virtual std::string to_initializer_expression(const SPIRVariable &var); + virtual std::string to_zero_initialized_expression(uint32_t type_id); + bool type_can_zero_initialize(const SPIRType &type) const; + + bool buffer_is_packing_standard(const SPIRType &type, BufferPackingStandard packing, + uint32_t *failed_index = nullptr, uint32_t start_offset = 0, + uint32_t end_offset = ~(0u)); + std::string buffer_to_packing_standard(const SPIRType &type, bool support_std430_without_scalar_layout); + + uint32_t type_to_packed_base_size(const SPIRType &type, BufferPackingStandard packing); + uint32_t type_to_packed_alignment(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing); + uint32_t type_to_packed_array_stride(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing); + uint32_t type_to_packed_size(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing); + + std::string bitcast_glsl(const SPIRType &result_type, uint32_t arg); + virtual std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type); + + std::string bitcast_expression(SPIRType::BaseType target_type, uint32_t arg); + std::string bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type, const std::string &expr); + + std::string build_composite_combiner(uint32_t result_type, const uint32_t *elems, uint32_t length); + bool remove_duplicate_swizzle(std::string &op); + bool remove_unity_swizzle(uint32_t base, std::string &op); + + // Can modify flags to remote readonly/writeonly if image type + // and force recompile. + bool check_atomic_image(uint32_t id); + + virtual void replace_illegal_names(); + void replace_illegal_names(const std::unordered_set &keywords); + virtual void emit_entry_point_declarations(); + + void replace_fragment_output(SPIRVariable &var); + void replace_fragment_outputs(); + bool check_explicit_lod_allowed(uint32_t lod); + std::string legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t lod, uint32_t id); + + uint32_t indent = 0; + + std::unordered_set emitted_functions; + + // Ensure that we declare phi-variable copies even if the original declaration isn't deferred + std::unordered_set flushed_phi_variables; + + std::unordered_set flattened_buffer_blocks; + std::unordered_set flattened_structs; + + std::string load_flattened_struct(SPIRVariable &var); + std::string to_flattened_struct_member(const SPIRVariable &var, uint32_t index); + void store_flattened_struct(SPIRVariable &var, uint32_t value); + + // Usage tracking. If a temporary is used more than once, use the temporary instead to + // avoid AST explosion when SPIRV is generated with pure SSA and doesn't write stuff to variables. + std::unordered_map expression_usage_counts; + void track_expression_read(uint32_t id); + + SmallVector forced_extensions; + SmallVector header_lines; + + // Used when expressions emit extra opcodes with their own unique IDs, + // and we need to reuse the IDs across recompilation loops. + // Currently used by NMin/Max/Clamp implementations. + std::unordered_map extra_sub_expressions; + + uint32_t statement_count = 0; + + inline bool is_legacy() const + { + return (options.es && options.version < 300) || (!options.es && options.version < 130); + } + + inline bool is_legacy_es() const + { + return options.es && options.version < 300; + } + + inline bool is_legacy_desktop() const + { + return !options.es && options.version < 130; + } + + bool args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure); + void register_call_out_argument(uint32_t id); + void register_impure_function_call(); + void register_control_dependent_expression(uint32_t expr); + + // GL_EXT_shader_pixel_local_storage support. + std::vector pls_inputs; + std::vector pls_outputs; + std::string pls_decl(const PlsRemap &variable); + const char *to_pls_qualifiers_glsl(const SPIRVariable &variable); + void emit_pls(); + void remap_pls_variables(); + + // GL_EXT_shader_framebuffer_fetch support. + std::vector> subpass_to_framebuffer_fetch_attachment; + std::unordered_set inout_color_attachments; + bool subpass_input_is_framebuffer_fetch(uint32_t id) const; + void emit_inout_fragment_outputs_copy_to_subpass_inputs(); + const SPIRVariable *find_subpass_input_by_attachment_index(uint32_t index) const; + const SPIRVariable *find_color_output_by_location(uint32_t location) const; + + // A variant which takes two sets of name. The secondary is only used to verify there are no collisions, + // but the set is not updated when we have found a new name. + // Used primarily when adding block interface names. + void add_variable(std::unordered_set &variables_primary, + const std::unordered_set &variables_secondary, std::string &name); + + void check_function_call_constraints(const uint32_t *args, uint32_t length); + void handle_invalid_expression(uint32_t id); + void find_static_extensions(); + + std::string emit_for_loop_initializers(const SPIRBlock &block); + void emit_while_loop_initializers(const SPIRBlock &block); + bool for_loop_initializers_are_same_type(const SPIRBlock &block); + bool optimize_read_modify_write(const SPIRType &type, const std::string &lhs, const std::string &rhs); + void fixup_image_load_store_access(); + + bool type_is_empty(const SPIRType &type); + + virtual void declare_undefined_values(); + + static std::string sanitize_underscores(const std::string &str); + + bool can_use_io_location(spv::StorageClass storage, bool block); + const Instruction *get_next_instruction_in_block(const Instruction &instr); + static uint32_t mask_relevant_memory_semantics(uint32_t semantics); + + std::string convert_half_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); + std::string convert_float_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); + std::string convert_double_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); + + std::string convert_separate_image_to_expression(uint32_t id); + + // Builtins in GLSL are always specific signedness, but the SPIR-V can declare them + // as either unsigned or signed. + // Sometimes we will need to automatically perform bitcasts on load and store to make this work. + virtual void bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type); + virtual void bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type); + void unroll_array_from_complex_load(uint32_t target_id, uint32_t source_id, std::string &expr); + void convert_non_uniform_expression(const SPIRType &type, std::string &expr); + + void handle_store_to_invariant_variable(uint32_t store_id, uint32_t value_id); + void disallow_forwarding_in_expression_chain(const SPIRExpression &expr); + + bool expression_is_constant_null(uint32_t id) const; + virtual void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression); + + uint32_t get_integer_width_for_instruction(const Instruction &instr) const; + uint32_t get_integer_width_for_glsl_instruction(GLSLstd450 op, const uint32_t *arguments, uint32_t length) const; + + bool variable_is_lut(const SPIRVariable &var) const; + + char current_locale_radix_character = '.'; + + void fixup_type_alias(); + void reorder_type_alias(); + + void propagate_nonuniform_qualifier(uint32_t id); + + static const char *vector_swizzle(int vecsize, int index); + +private: + void init(); +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_hlsl.hpp b/ios/include/spirv_cross/spirv_hlsl.hpp new file mode 100644 index 00000000..e98c6443 --- /dev/null +++ b/ios/include/spirv_cross/spirv_hlsl.hpp @@ -0,0 +1,329 @@ +/* + * Copyright 2016-2020 Robert Konrad + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_HLSL_HPP +#define SPIRV_HLSL_HPP + +#include "spirv_glsl.hpp" +#include + +namespace SPIRV_CROSS_NAMESPACE +{ +// Interface which remaps vertex inputs to a fixed semantic name to make linking easier. +struct HLSLVertexAttributeRemap +{ + uint32_t location; + std::string semantic; +}; +// Specifying a root constant (d3d12) or push constant range (vulkan). +// +// `start` and `end` denotes the range of the root constant in bytes. +// Both values need to be multiple of 4. +struct RootConstants +{ + uint32_t start; + uint32_t end; + + uint32_t binding; + uint32_t space; +}; + +// For finer control, decorations may be removed from specific resources instead with unset_decoration(). +enum HLSLBindingFlagBits +{ + HLSL_BINDING_AUTO_NONE_BIT = 0, + + // Push constant (root constant) resources will be declared as CBVs (b-space) without a register() declaration. + // A register will be automatically assigned by the D3D compiler, but must therefore be reflected in D3D-land. + // Push constants do not normally have a DecorationBinding set, but if they do, this can be used to ignore it. + HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0, + + // cbuffer resources will be declared as CBVs (b-space) without a register() declaration. + // A register will be automatically assigned, but must be reflected in D3D-land. + HLSL_BINDING_AUTO_CBV_BIT = 1 << 1, + + // All SRVs (t-space) will be declared without a register() declaration. + HLSL_BINDING_AUTO_SRV_BIT = 1 << 2, + + // All UAVs (u-space) will be declared without a register() declaration. + HLSL_BINDING_AUTO_UAV_BIT = 1 << 3, + + // All samplers (s-space) will be declared without a register() declaration. + HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4, + + // No resources will be declared with register(). + HLSL_BINDING_AUTO_ALL = 0x7fffffff +}; +using HLSLBindingFlags = uint32_t; + +// By matching stage, desc_set and binding for a SPIR-V resource, +// register bindings are set based on whether the HLSL resource is a +// CBV, UAV, SRV or Sampler. A single binding in SPIR-V might contain multiple +// resource types, e.g. COMBINED_IMAGE_SAMPLER, and SRV/Sampler bindings will be used respectively. +// On SM 5.0 and lower, register_space is ignored. +// +// To remap a push constant block which does not have any desc_set/binding associated with it, +// use ResourceBindingPushConstant{DescriptorSet,Binding} as values for desc_set/binding. +// For deeper control of push constants, set_root_constant_layouts() can be used instead. +struct HLSLResourceBinding +{ + spv::ExecutionModel stage = spv::ExecutionModelMax; + uint32_t desc_set = 0; + uint32_t binding = 0; + + struct Binding + { + uint32_t register_space = 0; + uint32_t register_binding = 0; + } cbv, uav, srv, sampler; +}; + +class CompilerHLSL : public CompilerGLSL +{ +public: + struct Options + { + uint32_t shader_model = 30; // TODO: map ps_4_0_level_9_0,... somehow + + // Allows the PointSize builtin, and ignores it, as PointSize is not supported in HLSL. + bool point_size_compat = false; + + // Allows the PointCoord builtin, returns float2(0.5, 0.5), as PointCoord is not supported in HLSL. + bool point_coord_compat = false; + + // If true, the backend will assume that VertexIndex and InstanceIndex will need to apply + // a base offset, and you will need to fill in a cbuffer with offsets. + // Set to false if you know you will never use base instance or base vertex + // functionality as it might remove an internal cbuffer. + bool support_nonzero_base_vertex_base_instance = false; + + // Forces a storage buffer to always be declared as UAV, even if the readonly decoration is used. + // By default, a readonly storage buffer will be declared as ByteAddressBuffer (SRV) instead. + bool force_storage_buffer_as_uav = false; + + // Forces any storage image type marked as NonWritable to be considered an SRV instead. + // For this to work with function call parameters, NonWritable must be considered to be part of the type system + // so that NonWritable image arguments are also translated to Texture rather than RWTexture. + bool nonwritable_uav_texture_as_srv = false; + }; + + explicit CompilerHLSL(std::vector spirv_) + : CompilerGLSL(std::move(spirv_)) + { + } + + CompilerHLSL(const uint32_t *ir_, size_t size) + : CompilerGLSL(ir_, size) + { + } + + explicit CompilerHLSL(const ParsedIR &ir_) + : CompilerGLSL(ir_) + { + } + + explicit CompilerHLSL(ParsedIR &&ir_) + : CompilerGLSL(std::move(ir_)) + { + } + + const Options &get_hlsl_options() const + { + return hlsl_options; + } + + void set_hlsl_options(const Options &opts) + { + hlsl_options = opts; + } + + // Optionally specify a custom root constant layout. + // + // Push constants ranges will be split up according to the + // layout specified. + void set_root_constant_layouts(std::vector layout); + + // Compiles and remaps vertex attributes at specific locations to a fixed semantic. + // The default is TEXCOORD# where # denotes location. + // Matrices are unrolled to vectors with notation ${SEMANTIC}_#, where # denotes row. + // $SEMANTIC is either TEXCOORD# or a semantic name specified here. + void add_vertex_attribute_remap(const HLSLVertexAttributeRemap &vertex_attributes); + std::string compile() override; + + // This is a special HLSL workaround for the NumWorkGroups builtin. + // This does not exist in HLSL, so the calling application must create a dummy cbuffer in + // which the application will store this builtin. + // The cbuffer layout will be: + // cbuffer SPIRV_Cross_NumWorkgroups : register(b#, space#) { uint3 SPIRV_Cross_NumWorkgroups_count; }; + // This must be called before compile(). + // The function returns 0 if NumWorkGroups builtin is not statically used in the shader from the current entry point. + // If non-zero, this returns the variable ID of a cbuffer which corresponds to + // the cbuffer declared above. By default, no binding or descriptor set decoration is set, + // so the calling application should declare explicit bindings on this ID before calling compile(). + VariableID remap_num_workgroups_builtin(); + + // Controls how resource bindings are declared in the output HLSL. + void set_resource_binding_flags(HLSLBindingFlags flags); + + // resource is a resource binding to indicate the HLSL CBV, SRV, UAV or sampler binding + // to use for a particular SPIR-V description set + // and binding. If resource bindings are provided, + // is_hlsl_resource_binding_used() will return true after calling ::compile() if + // the set/binding combination was used by the HLSL code. + void add_hlsl_resource_binding(const HLSLResourceBinding &resource); + bool is_hlsl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const; + +private: + std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override; + std::string image_type_hlsl(const SPIRType &type, uint32_t id); + std::string image_type_hlsl_modern(const SPIRType &type, uint32_t id); + std::string image_type_hlsl_legacy(const SPIRType &type, uint32_t id); + void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; + void emit_hlsl_entry_point(); + void emit_header() override; + void emit_resources(); + void declare_undefined_values() override; + void emit_interface_block_globally(const SPIRVariable &type); + void emit_interface_block_in_struct(const SPIRVariable &type, std::unordered_set &active_locations); + void emit_builtin_inputs_in_struct(); + void emit_builtin_outputs_in_struct(); + void emit_texture_op(const Instruction &i) override; + void emit_instruction(const Instruction &instruction) override; + void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, + uint32_t count) override; + void emit_buffer_block(const SPIRVariable &type) override; + void emit_push_constant_block(const SPIRVariable &var) override; + void emit_uniform(const SPIRVariable &var) override; + void emit_modern_uniform(const SPIRVariable &var); + void emit_legacy_uniform(const SPIRVariable &var); + void emit_specialization_constants_and_structs(); + void emit_composite_constants(); + void emit_fixup() override; + std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override; + std::string layout_for_member(const SPIRType &type, uint32_t index) override; + std::string to_interpolation_qualifiers(const Bitset &flags) override; + std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override; + bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0) override; + std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override; + std::string to_sampler_expression(uint32_t id); + std::string to_resource_binding(const SPIRVariable &var); + std::string to_resource_binding_sampler(const SPIRVariable &var); + std::string to_resource_register(HLSLBindingFlagBits flag, char space, uint32_t binding, uint32_t set); + void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override; + void emit_access_chain(const Instruction &instruction); + void emit_load(const Instruction &instruction); + void read_access_chain(std::string *expr, const std::string &lhs, const SPIRAccessChain &chain); + void read_access_chain_struct(const std::string &lhs, const SPIRAccessChain &chain); + void read_access_chain_array(const std::string &lhs, const SPIRAccessChain &chain); + void write_access_chain(const SPIRAccessChain &chain, uint32_t value, const SmallVector &composite_chain); + void write_access_chain_struct(const SPIRAccessChain &chain, uint32_t value, + const SmallVector &composite_chain); + void write_access_chain_array(const SPIRAccessChain &chain, uint32_t value, + const SmallVector &composite_chain); + std::string write_access_chain_value(uint32_t value, const SmallVector &composite_chain, bool enclose); + void emit_store(const Instruction &instruction); + void emit_atomic(const uint32_t *ops, uint32_t length, spv::Op op); + void emit_subgroup_op(const Instruction &i) override; + void emit_block_hints(const SPIRBlock &block) override; + + void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier, + uint32_t base_offset = 0) override; + + const char *to_storage_qualifiers_glsl(const SPIRVariable &var) override; + void replace_illegal_names() override; + + Options hlsl_options; + + // TODO: Refactor this to be more similar to MSL, maybe have some common system in place? + bool requires_op_fmod = false; + bool requires_fp16_packing = false; + bool requires_uint2_packing = false; + bool requires_explicit_fp16_packing = false; + bool requires_unorm8_packing = false; + bool requires_snorm8_packing = false; + bool requires_unorm16_packing = false; + bool requires_snorm16_packing = false; + bool requires_bitfield_insert = false; + bool requires_bitfield_extract = false; + bool requires_inverse_2x2 = false; + bool requires_inverse_3x3 = false; + bool requires_inverse_4x4 = false; + bool requires_scalar_reflect = false; + bool requires_scalar_refract = false; + bool requires_scalar_faceforward = false; + uint64_t required_textureSizeVariants = 0; + void require_texture_query_variant(const SPIRType &type); + + enum TextureQueryVariantDim + { + Query1D = 0, + Query1DArray, + Query2D, + Query2DArray, + Query3D, + QueryBuffer, + QueryCube, + QueryCubeArray, + Query2DMS, + Query2DMSArray, + QueryDimCount + }; + + enum TextureQueryVariantType + { + QueryTypeFloat = 0, + QueryTypeInt = 16, + QueryTypeUInt = 32, + QueryTypeCount = 3 + }; + + enum BitcastType + { + TypeNormal, + TypePackUint2x32, + TypeUnpackUint64 + }; + + BitcastType get_bitcast_type(uint32_t result_type, uint32_t op0); + + void emit_builtin_variables(); + bool require_output = false; + bool require_input = false; + SmallVector remap_vertex_attributes; + + uint32_t type_to_consumed_locations(const SPIRType &type) const; + + void emit_io_block(const SPIRVariable &var); + std::string to_semantic(uint32_t location, spv::ExecutionModel em, spv::StorageClass sc); + + uint32_t num_workgroups_builtin = 0; + HLSLBindingFlags resource_binding_flags = 0; + + // Custom root constant layout, which should be emitted + // when translating push constant ranges. + std::vector root_constants_layout; + + void validate_shader_model(); + + std::string get_unique_identifier(); + uint32_t unique_identifier_count = 0; + + std::unordered_map, InternalHasher> resource_bindings; + void remap_hlsl_resource_binding(HLSLBindingFlagBits type, uint32_t &desc_set, uint32_t &binding); +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_msl.hpp b/ios/include/spirv_cross/spirv_msl.hpp new file mode 100644 index 00000000..e56d27b9 --- /dev/null +++ b/ios/include/spirv_cross/spirv_msl.hpp @@ -0,0 +1,962 @@ +/* + * Copyright 2016-2020 The Brenwill Workshop Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_MSL_HPP +#define SPIRV_CROSS_MSL_HPP + +#include "spirv_glsl.hpp" +#include +#include +#include +#include +#include + +namespace SPIRV_CROSS_NAMESPACE +{ + +// Indicates the format of the vertex attribute. Currently limited to specifying +// if the attribute is an 8-bit unsigned integer, 16-bit unsigned integer, or +// some other format. +enum MSLVertexFormat +{ + MSL_VERTEX_FORMAT_OTHER = 0, + MSL_VERTEX_FORMAT_UINT8 = 1, + MSL_VERTEX_FORMAT_UINT16 = 2, + MSL_VERTEX_FORMAT_INT_MAX = 0x7fffffff +}; + +// Defines MSL characteristics of a vertex attribute at a particular location. +// After compilation, it is possible to query whether or not this location was used. +struct MSLVertexAttr +{ + uint32_t location = 0; + uint32_t msl_buffer = 0; + uint32_t msl_offset = 0; + uint32_t msl_stride = 0; + bool per_instance = false; + MSLVertexFormat format = MSL_VERTEX_FORMAT_OTHER; + spv::BuiltIn builtin = spv::BuiltInMax; +}; + +// Matches the binding index of a MSL resource for a binding within a descriptor set. +// Taken together, the stage, desc_set and binding combine to form a reference to a resource +// descriptor used in a particular shading stage. +// If using MSL 2.0 argument buffers, the descriptor set is not marked as a discrete descriptor set, +// and (for iOS only) the resource is not a storage image (sampled != 2), the binding reference we +// remap to will become an [[id(N)]] attribute within the "descriptor set" argument buffer structure. +// For resources which are bound in the "classic" MSL 1.0 way or discrete descriptors, the remap will become a +// [[buffer(N)]], [[texture(N)]] or [[sampler(N)]] depending on the resource types used. +struct MSLResourceBinding +{ + spv::ExecutionModel stage = spv::ExecutionModelMax; + uint32_t desc_set = 0; + uint32_t binding = 0; + uint32_t msl_buffer = 0; + uint32_t msl_texture = 0; + uint32_t msl_sampler = 0; +}; + +enum MSLSamplerCoord +{ + MSL_SAMPLER_COORD_NORMALIZED = 0, + MSL_SAMPLER_COORD_PIXEL = 1, + MSL_SAMPLER_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerFilter +{ + MSL_SAMPLER_FILTER_NEAREST = 0, + MSL_SAMPLER_FILTER_LINEAR = 1, + MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerMipFilter +{ + MSL_SAMPLER_MIP_FILTER_NONE = 0, + MSL_SAMPLER_MIP_FILTER_NEAREST = 1, + MSL_SAMPLER_MIP_FILTER_LINEAR = 2, + MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerAddress +{ + MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0, + MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1, + MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2, + MSL_SAMPLER_ADDRESS_REPEAT = 3, + MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4, + MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerCompareFunc +{ + MSL_SAMPLER_COMPARE_FUNC_NEVER = 0, + MSL_SAMPLER_COMPARE_FUNC_LESS = 1, + MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2, + MSL_SAMPLER_COMPARE_FUNC_GREATER = 3, + MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4, + MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5, + MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6, + MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7, + MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerBorderColor +{ + MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0, + MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1, + MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2, + MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff +}; + +enum MSLFormatResolution +{ + MSL_FORMAT_RESOLUTION_444 = 0, + MSL_FORMAT_RESOLUTION_422, + MSL_FORMAT_RESOLUTION_420, + MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff +}; + +enum MSLChromaLocation +{ + MSL_CHROMA_LOCATION_COSITED_EVEN = 0, + MSL_CHROMA_LOCATION_MIDPOINT, + MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff +}; + +enum MSLComponentSwizzle +{ + MSL_COMPONENT_SWIZZLE_IDENTITY = 0, + MSL_COMPONENT_SWIZZLE_ZERO, + MSL_COMPONENT_SWIZZLE_ONE, + MSL_COMPONENT_SWIZZLE_R, + MSL_COMPONENT_SWIZZLE_G, + MSL_COMPONENT_SWIZZLE_B, + MSL_COMPONENT_SWIZZLE_A, + MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerYCbCrModelConversion +{ + MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709, + MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601, + MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020, + MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff +}; + +enum MSLSamplerYCbCrRange +{ + MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW, + MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff +}; + +struct MSLConstexprSampler +{ + MSLSamplerCoord coord = MSL_SAMPLER_COORD_NORMALIZED; + MSLSamplerFilter min_filter = MSL_SAMPLER_FILTER_NEAREST; + MSLSamplerFilter mag_filter = MSL_SAMPLER_FILTER_NEAREST; + MSLSamplerMipFilter mip_filter = MSL_SAMPLER_MIP_FILTER_NONE; + MSLSamplerAddress s_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; + MSLSamplerAddress t_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; + MSLSamplerAddress r_address = MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE; + MSLSamplerCompareFunc compare_func = MSL_SAMPLER_COMPARE_FUNC_NEVER; + MSLSamplerBorderColor border_color = MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK; + float lod_clamp_min = 0.0f; + float lod_clamp_max = 1000.0f; + int max_anisotropy = 1; + + // Sampler Y'CbCr conversion parameters + uint32_t planes = 0; + MSLFormatResolution resolution = MSL_FORMAT_RESOLUTION_444; + MSLSamplerFilter chroma_filter = MSL_SAMPLER_FILTER_NEAREST; + MSLChromaLocation x_chroma_offset = MSL_CHROMA_LOCATION_COSITED_EVEN; + MSLChromaLocation y_chroma_offset = MSL_CHROMA_LOCATION_COSITED_EVEN; + MSLComponentSwizzle swizzle[4]; // IDENTITY, IDENTITY, IDENTITY, IDENTITY + MSLSamplerYCbCrModelConversion ycbcr_model = MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; + MSLSamplerYCbCrRange ycbcr_range = MSL_SAMPLER_YCBCR_RANGE_ITU_FULL; + uint32_t bpc = 8; + + bool compare_enable = false; + bool lod_clamp_enable = false; + bool anisotropy_enable = false; + bool ycbcr_conversion_enable = false; + + MSLConstexprSampler() + { + for (uint32_t i = 0; i < 4; i++) + swizzle[i] = MSL_COMPONENT_SWIZZLE_IDENTITY; + } + bool swizzle_is_identity() const + { + return (swizzle[0] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[1] == MSL_COMPONENT_SWIZZLE_IDENTITY && + swizzle[2] == MSL_COMPONENT_SWIZZLE_IDENTITY && swizzle[3] == MSL_COMPONENT_SWIZZLE_IDENTITY); + } + bool swizzle_has_one_or_zero() const + { + return (swizzle[0] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[0] == MSL_COMPONENT_SWIZZLE_ONE || + swizzle[1] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[1] == MSL_COMPONENT_SWIZZLE_ONE || + swizzle[2] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[2] == MSL_COMPONENT_SWIZZLE_ONE || + swizzle[3] == MSL_COMPONENT_SWIZZLE_ZERO || swizzle[3] == MSL_COMPONENT_SWIZZLE_ONE); + } +}; + +// Special constant used in a MSLResourceBinding desc_set +// element to indicate the bindings for the push constants. +// Kinda deprecated. Just use ResourceBindingPushConstant{DescriptorSet,Binding} directly. +static const uint32_t kPushConstDescSet = ResourceBindingPushConstantDescriptorSet; + +// Special constant used in a MSLResourceBinding binding +// element to indicate the bindings for the push constants. +// Kinda deprecated. Just use ResourceBindingPushConstant{DescriptorSet,Binding} directly. +static const uint32_t kPushConstBinding = ResourceBindingPushConstantBinding; + +// Special constant used in a MSLResourceBinding binding +// element to indicate the buffer binding for swizzle buffers. +static const uint32_t kSwizzleBufferBinding = ~(1u); + +// Special constant used in a MSLResourceBinding binding +// element to indicate the buffer binding for buffer size buffers to support OpArrayLength. +static const uint32_t kBufferSizeBufferBinding = ~(2u); + +// Special constant used in a MSLResourceBinding binding +// element to indicate the buffer binding used for the argument buffer itself. +// This buffer binding should be kept as small as possible as all automatic bindings for buffers +// will start at max(kArgumentBufferBinding) + 1. +static const uint32_t kArgumentBufferBinding = ~(3u); + +static const uint32_t kMaxArgumentBuffers = 8; + +// Decompiles SPIR-V to Metal Shading Language +class CompilerMSL : public CompilerGLSL +{ +public: + // Options for compiling to Metal Shading Language + struct Options + { + typedef enum + { + iOS = 0, + macOS = 1 + } Platform; + + Platform platform = macOS; + uint32_t msl_version = make_msl_version(1, 2); + uint32_t texel_buffer_texture_width = 4096; // Width of 2D Metal textures used as 1D texel buffers + uint32_t swizzle_buffer_index = 30; + uint32_t indirect_params_buffer_index = 29; + uint32_t shader_output_buffer_index = 28; + uint32_t shader_patch_output_buffer_index = 27; + uint32_t shader_tess_factor_buffer_index = 26; + uint32_t buffer_size_buffer_index = 25; + uint32_t view_mask_buffer_index = 24; + uint32_t dynamic_offsets_buffer_index = 23; + uint32_t shader_input_wg_index = 0; + uint32_t device_index = 0; + uint32_t enable_frag_output_mask = 0xffffffff; + bool enable_point_size_builtin = true; + bool enable_frag_depth_builtin = true; + bool enable_frag_stencil_ref_builtin = true; + bool disable_rasterization = false; + bool capture_output_to_buffer = false; + bool swizzle_texture_samples = false; + bool tess_domain_origin_lower_left = false; + bool multiview = false; + bool view_index_from_device_index = false; + bool dispatch_base = false; + bool texture_1D_as_2D = false; + + // Enable use of MSL 2.0 indirect argument buffers. + // MSL 2.0 must also be enabled. + bool argument_buffers = false; + + // Ensures vertex and instance indices start at zero. This reflects the behavior of HLSL with SV_VertexID and SV_InstanceID. + bool enable_base_index_zero = false; + + // Fragment output in MSL must have at least as many components as the render pass. + // Add support to explicit pad out components. + bool pad_fragment_output_components = false; + + // Specifies whether the iOS target version supports the [[base_vertex]] and [[base_instance]] attributes. + bool ios_support_base_vertex_instance = false; + + // Use Metal's native frame-buffer fetch API for subpass inputs. + bool ios_use_framebuffer_fetch_subpasses = false; + + // Enables use of "fma" intrinsic for invariant float math + bool invariant_float_math = false; + + // Emulate texturecube_array with texture2d_array for iOS where this type is not available + bool emulate_cube_array = false; + + // Allow user to enable decoration binding + bool enable_decoration_binding = false; + + // Requires MSL 2.1, use the native support for texel buffers. + bool texture_buffer_native = false; + + // Forces all resources which are part of an argument buffer to be considered active. + // This ensures ABI compatibility between shaders where some resources might be unused, + // and would otherwise declare a different IAB. + bool force_active_argument_buffer_resources = false; + + // Forces the use of plain arrays, which works around certain driver bugs on certain versions + // of Intel Macbooks. See https://github.com/KhronosGroup/SPIRV-Cross/issues/1210. + // May reduce performance in scenarios where arrays are copied around as value-types. + bool force_native_arrays = false; + + // If a shader writes clip distance, also emit user varyings which + // can be read in subsequent stages. + bool enable_clip_distance_user_varying = true; + + bool is_ios() const + { + return platform == iOS; + } + + bool is_macos() const + { + return platform == macOS; + } + + void set_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) + { + msl_version = make_msl_version(major, minor, patch); + } + + bool supports_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) const + { + return msl_version >= make_msl_version(major, minor, patch); + } + + static uint32_t make_msl_version(uint32_t major, uint32_t minor = 0, uint32_t patch = 0) + { + return (major * 10000) + (minor * 100) + patch; + } + }; + + const Options &get_msl_options() const + { + return msl_options; + } + + void set_msl_options(const Options &opts) + { + msl_options = opts; + } + + // Provide feedback to calling API to allow runtime to disable pipeline + // rasterization if vertex shader requires rasterization to be disabled. + bool get_is_rasterization_disabled() const + { + return is_rasterization_disabled && (get_entry_point().model == spv::ExecutionModelVertex || + get_entry_point().model == spv::ExecutionModelTessellationControl || + get_entry_point().model == spv::ExecutionModelTessellationEvaluation); + } + + // Provide feedback to calling API to allow it to pass an auxiliary + // swizzle buffer if the shader needs it. + bool needs_swizzle_buffer() const + { + return used_swizzle_buffer; + } + + // Provide feedback to calling API to allow it to pass a buffer + // containing STORAGE_BUFFER buffer sizes to support OpArrayLength. + bool needs_buffer_size_buffer() const + { + return !buffers_requiring_array_length.empty(); + } + + // Provide feedback to calling API to allow it to pass a buffer + // containing the view mask for the current multiview subpass. + bool needs_view_mask_buffer() const + { + return msl_options.multiview && !msl_options.view_index_from_device_index; + } + + // Provide feedback to calling API to allow it to pass a buffer + // containing the dispatch base workgroup ID. + bool needs_dispatch_base_buffer() const + { + return msl_options.dispatch_base && !msl_options.supports_msl_version(1, 2); + } + + // Provide feedback to calling API to allow it to pass an output + // buffer if the shader needs it. + bool needs_output_buffer() const + { + return capture_output_to_buffer && stage_out_var_id != ID(0); + } + + // Provide feedback to calling API to allow it to pass a patch output + // buffer if the shader needs it. + bool needs_patch_output_buffer() const + { + return capture_output_to_buffer && patch_stage_out_var_id != ID(0); + } + + // Provide feedback to calling API to allow it to pass an input threadgroup + // buffer if the shader needs it. + bool needs_input_threadgroup_mem() const + { + return capture_output_to_buffer && stage_in_var_id != ID(0); + } + + explicit CompilerMSL(std::vector spirv); + CompilerMSL(const uint32_t *ir, size_t word_count); + explicit CompilerMSL(const ParsedIR &ir); + explicit CompilerMSL(ParsedIR &&ir); + + // attr is a vertex attribute binding used to match + // vertex content locations to MSL attributes. If vertex attributes are provided, + // is_msl_vertex_attribute_used() will return true after calling ::compile() if + // the location was used by the MSL code. + void add_msl_vertex_attribute(const MSLVertexAttr &attr); + + // resource is a resource binding to indicate the MSL buffer, + // texture or sampler index to use for a particular SPIR-V description set + // and binding. If resource bindings are provided, + // is_msl_resource_binding_used() will return true after calling ::compile() if + // the set/binding combination was used by the MSL code. + void add_msl_resource_binding(const MSLResourceBinding &resource); + + // desc_set and binding are the SPIR-V descriptor set and binding of a buffer resource + // in this shader. index is the index within the dynamic offset buffer to use. This + // function marks that resource as using a dynamic offset (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC + // or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC). This function only has any effect if argument buffers + // are enabled. If so, the buffer will have its address adjusted at the beginning of the shader with + // an offset taken from the dynamic offset buffer. + void add_dynamic_buffer(uint32_t desc_set, uint32_t binding, uint32_t index); + + // desc_set and binding are the SPIR-V descriptor set and binding of a buffer resource + // in this shader. This function marks that resource as an inline uniform block + // (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT). This function only has any effect if argument buffers + // are enabled. If so, the buffer block will be directly embedded into the argument + // buffer, instead of being referenced indirectly via pointer. + void add_inline_uniform_block(uint32_t desc_set, uint32_t binding); + + // When using MSL argument buffers, we can force "classic" MSL 1.0 binding schemes for certain descriptor sets. + // This corresponds to VK_KHR_push_descriptor in Vulkan. + void add_discrete_descriptor_set(uint32_t desc_set); + + // If an argument buffer is large enough, it may need to be in the device storage space rather than + // constant. Opt-in to this behavior here on a per set basis. + void set_argument_buffer_device_address_space(uint32_t desc_set, bool device_storage); + + // Query after compilation is done. This allows you to check if a location or set/binding combination was used by the shader. + bool is_msl_vertex_attribute_used(uint32_t location); + + // NOTE: Only resources which are remapped using add_msl_resource_binding will be reported here. + // Constexpr samplers are always assumed to be emitted. + // No specific MSLResourceBinding remapping is required for constexpr samplers as long as they are remapped + // by remap_constexpr_sampler(_by_binding). + bool is_msl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const; + + // This must only be called after a successful call to CompilerMSL::compile(). + // For a variable resource ID obtained through reflection API, report the automatically assigned resource index. + // If the descriptor set was part of an argument buffer, report the [[id(N)]], + // or [[buffer/texture/sampler]] binding for other resources. + // If the resource was a combined image sampler, report the image binding here, + // use the _secondary version of this call to query the sampler half of the resource. + // If no binding exists, uint32_t(-1) is returned. + uint32_t get_automatic_msl_resource_binding(uint32_t id) const; + + // Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers, in which case the + // sampler's binding is returned instead. For any other resource type, -1 is returned. + uint32_t get_automatic_msl_resource_binding_secondary(uint32_t id) const; + + // Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers for multiplanar images, + // in which case the second plane's binding is returned instead. For any other resource type, -1 is returned. + uint32_t get_automatic_msl_resource_binding_tertiary(uint32_t id) const; + + // Same as get_automatic_msl_resource_binding, but should only be used for combined image samplers for triplanar images, + // in which case the third plane's binding is returned instead. For any other resource type, -1 is returned. + uint32_t get_automatic_msl_resource_binding_quaternary(uint32_t id) const; + + // Compiles the SPIR-V code into Metal Shading Language. + std::string compile() override; + + // Remap a sampler with ID to a constexpr sampler. + // Older iOS targets must use constexpr samplers in certain cases (PCF), + // so a static sampler must be used. + // The sampler will not consume a binding, but be declared in the entry point as a constexpr sampler. + // This can be used on both combined image/samplers (sampler2D) or standalone samplers. + // The remapped sampler must not be an array of samplers. + // Prefer remap_constexpr_sampler_by_binding unless you're also doing reflection anyways. + void remap_constexpr_sampler(VariableID id, const MSLConstexprSampler &sampler); + + // Same as remap_constexpr_sampler, except you provide set/binding, rather than variable ID. + // Remaps based on ID take priority over set/binding remaps. + void remap_constexpr_sampler_by_binding(uint32_t desc_set, uint32_t binding, const MSLConstexprSampler &sampler); + + // If using CompilerMSL::Options::pad_fragment_output_components, override the number of components we expect + // to use for a particular location. The default is 4 if number of components is not overridden. + void set_fragment_output_components(uint32_t location, uint32_t components); + +protected: + // An enum of SPIR-V functions that are implemented in additional + // source code that is added to the shader if necessary. + enum SPVFuncImpl + { + SPVFuncImplNone, + SPVFuncImplMod, + SPVFuncImplRadians, + SPVFuncImplDegrees, + SPVFuncImplFindILsb, + SPVFuncImplFindSMsb, + SPVFuncImplFindUMsb, + SPVFuncImplSSign, + SPVFuncImplArrayCopyMultidimBase, + // Unfortunately, we cannot use recursive templates in the MSL compiler properly, + // so stamp out variants up to some arbitrary maximum. + SPVFuncImplArrayCopy = SPVFuncImplArrayCopyMultidimBase + 1, + SPVFuncImplArrayOfArrayCopy2Dim = SPVFuncImplArrayCopyMultidimBase + 2, + SPVFuncImplArrayOfArrayCopy3Dim = SPVFuncImplArrayCopyMultidimBase + 3, + SPVFuncImplArrayOfArrayCopy4Dim = SPVFuncImplArrayCopyMultidimBase + 4, + SPVFuncImplArrayOfArrayCopy5Dim = SPVFuncImplArrayCopyMultidimBase + 5, + SPVFuncImplArrayOfArrayCopy6Dim = SPVFuncImplArrayCopyMultidimBase + 6, + SPVFuncImplTexelBufferCoords, + SPVFuncImplImage2DAtomicCoords, // Emulate texture2D atomic operations + SPVFuncImplFMul, + SPVFuncImplFAdd, + SPVFuncImplCubemapTo2DArrayFace, + SPVFuncImplUnsafeArray, // Allow Metal to use the array template to make arrays a value type + SPVFuncImplInverse4x4, + SPVFuncImplInverse3x3, + SPVFuncImplInverse2x2, + // It is very important that this come before *Swizzle and ChromaReconstruct*, to ensure it's + // emitted before them. + SPVFuncImplForwardArgs, + // Likewise, this must come before *Swizzle. + SPVFuncImplGetSwizzle, + SPVFuncImplTextureSwizzle, + SPVFuncImplGatherSwizzle, + SPVFuncImplGatherCompareSwizzle, + SPVFuncImplSubgroupBallot, + SPVFuncImplSubgroupBallotBitExtract, + SPVFuncImplSubgroupBallotFindLSB, + SPVFuncImplSubgroupBallotFindMSB, + SPVFuncImplSubgroupBallotBitCount, + SPVFuncImplSubgroupAllEqual, + SPVFuncImplReflectScalar, + SPVFuncImplRefractScalar, + SPVFuncImplFaceForwardScalar, + SPVFuncImplChromaReconstructNearest2Plane, + SPVFuncImplChromaReconstructNearest3Plane, + SPVFuncImplChromaReconstructLinear422CositedEven2Plane, + SPVFuncImplChromaReconstructLinear422CositedEven3Plane, + SPVFuncImplChromaReconstructLinear422Midpoint2Plane, + SPVFuncImplChromaReconstructLinear422Midpoint3Plane, + SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane, + SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane, + SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane, + SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane, + SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane, + SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane, + SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane, + SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane, + SPVFuncImplExpandITUFullRange, + SPVFuncImplExpandITUNarrowRange, + SPVFuncImplConvertYCbCrBT709, + SPVFuncImplConvertYCbCrBT601, + SPVFuncImplConvertYCbCrBT2020, + SPVFuncImplDynamicImageSampler, + + SPVFuncImplArrayCopyMultidimMax = 6 + }; + + // If the underlying resource has been used for comparison then duplicate loads of that resource must be too + // Use Metal's native frame-buffer fetch API for subpass inputs. + void emit_texture_op(const Instruction &i) override; + void emit_binary_unord_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); + void emit_instruction(const Instruction &instr) override; + void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, + uint32_t count) override; + void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op, + const uint32_t *args, uint32_t count) override; + void emit_header() override; + void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; + void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override; + void emit_subgroup_op(const Instruction &i) override; + std::string to_texture_op(const Instruction &i, bool *forward, + SmallVector &inherited_expressions) override; + void emit_fixup() override; + std::string to_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, + const std::string &qualifier = ""); + void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, + const std::string &qualifier = "", uint32_t base_offset = 0) override; + void emit_struct_padding_target(const SPIRType &type) override; + std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override; + + // Allow Metal to use the array template to make arrays a value type + std::string type_to_array_glsl(const SPIRType &type) override; + + // Threadgroup arrays can't have a wrapper type + std::string variable_decl(const SPIRVariable &variable) override; + + // GCC workaround of lambdas calling protected functions (for older GCC versions) + std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0) override; + + std::string image_type_glsl(const SPIRType &type, uint32_t id = 0) override; + std::string sampler_type(const SPIRType &type); + std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override; + std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override; + std::string to_name(uint32_t id, bool allow_alias = true) const override; + std::string to_function_name(VariableID img, const SPIRType &imgtype, bool is_fetch, bool is_gather, bool is_proj, + bool has_array_offsets, bool has_offset, bool has_grad, bool has_dref, uint32_t lod, + uint32_t minlod) override; + std::string to_function_args(VariableID img, const SPIRType &imgtype, bool is_fetch, bool is_gather, bool is_proj, + uint32_t coord, uint32_t coord_components, uint32_t dref, uint32_t grad_x, + uint32_t grad_y, uint32_t lod, uint32_t coffset, uint32_t offset, uint32_t bias, + uint32_t comp, uint32_t sample, uint32_t minlod, bool *p_forward) override; + std::string to_initializer_expression(const SPIRVariable &var) override; + std::string to_zero_initialized_expression(uint32_t type_id) override; + + std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id, + bool is_packed, bool row_major) override; + + // Returns true for BuiltInSampleMask because gl_SampleMask[] is an array in SPIR-V, but [[sample_mask]] is a scalar in Metal. + bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override; + + std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override; + bool emit_complex_bitcast(uint32_t result_id, uint32_t id, uint32_t op0) override; + bool skip_argument(uint32_t id) const override; + std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain) override; + std::string to_qualifiers_glsl(uint32_t id) override; + void replace_illegal_names() override; + void declare_undefined_values() override; + void declare_constant_arrays(); + + // Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries + void declare_complex_constant_arrays(); + + bool is_patch_block(const SPIRType &type); + bool is_non_native_row_major_matrix(uint32_t id) override; + bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index) override; + std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type, uint32_t physical_type_id, + bool is_packed) override; + + void preprocess_op_codes(); + void localize_global_variables(); + void extract_global_variables_from_functions(); + void mark_packable_structs(); + void mark_as_packable(SPIRType &type); + + std::unordered_map> function_global_vars; + void extract_global_variables_from_function(uint32_t func_id, std::set &added_arg_ids, + std::unordered_set &global_var_ids, + std::unordered_set &processed_func_ids); + uint32_t add_interface_block(spv::StorageClass storage, bool patch = false); + uint32_t add_interface_block_pointer(uint32_t ib_var_id, spv::StorageClass storage); + + struct InterfaceBlockMeta + { + struct LocationMeta + { + uint32_t num_components = 0; + uint32_t ib_index = ~0u; + }; + std::unordered_map location_meta; + bool strip_array = false; + }; + + void add_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, SPIRType &ib_type, + SPIRVariable &var, InterfaceBlockMeta &meta); + void add_composite_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, + SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta); + void add_plain_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, + SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta); + void add_plain_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, + SPIRType &ib_type, SPIRVariable &var, uint32_t index, + InterfaceBlockMeta &meta); + void add_composite_member_variable_to_interface_block(spv::StorageClass storage, const std::string &ib_var_ref, + SPIRType &ib_type, SPIRVariable &var, uint32_t index, + InterfaceBlockMeta &meta); + uint32_t get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array); + void add_tess_level_input_to_interface_block(const std::string &ib_var_ref, SPIRType &ib_type, SPIRVariable &var); + + void fix_up_interface_member_indices(spv::StorageClass storage, uint32_t ib_type_id); + + void mark_location_as_used_by_shader(uint32_t location, spv::StorageClass storage); + uint32_t ensure_correct_builtin_type(uint32_t type_id, spv::BuiltIn builtin); + uint32_t ensure_correct_attribute_type(uint32_t type_id, uint32_t location, uint32_t num_components = 0); + + void emit_custom_templates(); + void emit_custom_functions(); + void emit_resources(); + void emit_specialization_constants_and_structs(); + void emit_interface_block(uint32_t ib_var_id); + bool maybe_emit_array_assignment(uint32_t id_lhs, uint32_t id_rhs); + + void fix_up_shader_inputs_outputs(); + + std::string func_type_decl(SPIRType &type); + std::string entry_point_args_classic(bool append_comma); + std::string entry_point_args_argument_buffer(bool append_comma); + std::string entry_point_arg_stage_in(); + void entry_point_args_builtin(std::string &args); + void entry_point_args_discrete_descriptors(std::string &args); + std::string to_qualified_member_name(const SPIRType &type, uint32_t index); + std::string ensure_valid_name(std::string name, std::string pfx); + std::string to_sampler_expression(uint32_t id); + std::string to_swizzle_expression(uint32_t id); + std::string to_buffer_size_expression(uint32_t id); + std::string builtin_qualifier(spv::BuiltIn builtin); + std::string builtin_type_decl(spv::BuiltIn builtin, uint32_t id = 0); + std::string built_in_func_arg(spv::BuiltIn builtin, bool prefix_comma); + std::string member_attribute_qualifier(const SPIRType &type, uint32_t index); + std::string argument_decl(const SPIRFunction::Parameter &arg); + std::string round_fp_tex_coords(std::string tex_coords, bool coord_is_fp); + uint32_t get_metal_resource_index(SPIRVariable &var, SPIRType::BaseType basetype, uint32_t plane = 0); + uint32_t get_ordered_member_location(uint32_t type_id, uint32_t index, uint32_t *comp = nullptr); + + // MSL packing rules. These compute the effective packing rules as observed by the MSL compiler in the MSL output. + // These values can change depending on various extended decorations which control packing rules. + // We need to make these rules match up with SPIR-V declared rules. + uint32_t get_declared_type_size_msl(const SPIRType &type, bool packed, bool row_major) const; + uint32_t get_declared_type_array_stride_msl(const SPIRType &type, bool packed, bool row_major) const; + uint32_t get_declared_type_matrix_stride_msl(const SPIRType &type, bool packed, bool row_major) const; + uint32_t get_declared_type_alignment_msl(const SPIRType &type, bool packed, bool row_major) const; + + uint32_t get_declared_struct_member_size_msl(const SPIRType &struct_type, uint32_t index) const; + uint32_t get_declared_struct_member_array_stride_msl(const SPIRType &struct_type, uint32_t index) const; + uint32_t get_declared_struct_member_matrix_stride_msl(const SPIRType &struct_type, uint32_t index) const; + uint32_t get_declared_struct_member_alignment_msl(const SPIRType &struct_type, uint32_t index) const; + + const SPIRType &get_physical_member_type(const SPIRType &struct_type, uint32_t index) const; + + uint32_t get_declared_struct_size_msl(const SPIRType &struct_type, bool ignore_alignment = false, + bool ignore_padding = false) const; + + std::string to_component_argument(uint32_t id); + void align_struct(SPIRType &ib_type, std::unordered_set &aligned_structs); + void mark_scalar_layout_structs(const SPIRType &ib_type); + void mark_struct_members_packed(const SPIRType &type); + void ensure_member_packing_rules_msl(SPIRType &ib_type, uint32_t index); + bool validate_member_packing_rules_msl(const SPIRType &type, uint32_t index) const; + std::string get_argument_address_space(const SPIRVariable &argument); + std::string get_type_address_space(const SPIRType &type, uint32_t id, bool argument = false); + const char *to_restrict(uint32_t id, bool space = true); + SPIRType &get_stage_in_struct_type(); + SPIRType &get_stage_out_struct_type(); + SPIRType &get_patch_stage_in_struct_type(); + SPIRType &get_patch_stage_out_struct_type(); + std::string get_tess_factor_struct_name(); + void emit_atomic_func_op(uint32_t result_type, uint32_t result_id, const char *op, uint32_t mem_order_1, + uint32_t mem_order_2, bool has_mem_order_2, uint32_t op0, uint32_t op1 = 0, + bool op1_is_pointer = false, bool op1_is_literal = false, uint32_t op2 = 0); + const char *get_memory_order(uint32_t spv_mem_sem); + void add_pragma_line(const std::string &line); + void add_typedef_line(const std::string &line); + void emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem); + void emit_array_copy(const std::string &lhs, uint32_t rhs_id, spv::StorageClass lhs_storage, + spv::StorageClass rhs_storage) override; + void build_implicit_builtins(); + uint32_t build_constant_uint_array_pointer(); + void emit_entry_point_declarations() override; + uint32_t builtin_frag_coord_id = 0; + uint32_t builtin_sample_id_id = 0; + uint32_t builtin_vertex_idx_id = 0; + uint32_t builtin_base_vertex_id = 0; + uint32_t builtin_instance_idx_id = 0; + uint32_t builtin_base_instance_id = 0; + uint32_t builtin_view_idx_id = 0; + uint32_t builtin_layer_id = 0; + uint32_t builtin_invocation_id_id = 0; + uint32_t builtin_primitive_id_id = 0; + uint32_t builtin_subgroup_invocation_id_id = 0; + uint32_t builtin_subgroup_size_id = 0; + uint32_t builtin_dispatch_base_id = 0; + uint32_t swizzle_buffer_id = 0; + uint32_t buffer_size_buffer_id = 0; + uint32_t view_mask_buffer_id = 0; + uint32_t dynamic_offsets_buffer_id = 0; + + void bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) override; + void bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type) override; + void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression) override; + + void analyze_sampled_image_usage(); + + bool emit_tessellation_access_chain(const uint32_t *ops, uint32_t length); + bool emit_tessellation_io_load(uint32_t result_type, uint32_t id, uint32_t ptr); + bool is_out_of_bounds_tessellation_level(uint32_t id_lhs); + + void ensure_builtin(spv::StorageClass storage, spv::BuiltIn builtin); + + void mark_implicit_builtin(spv::StorageClass storage, spv::BuiltIn builtin, uint32_t id); + + std::string convert_to_f32(const std::string &expr, uint32_t components); + + Options msl_options; + std::set spv_function_implementations; + std::unordered_map vtx_attrs_by_location; + std::unordered_map vtx_attrs_by_builtin; + std::unordered_set vtx_attrs_in_use; + std::unordered_map fragment_output_components; + std::set pragma_lines; + std::set typedef_lines; + SmallVector vars_needing_early_declaration; + + std::unordered_map, InternalHasher> resource_bindings; + + uint32_t next_metal_resource_index_buffer = 0; + uint32_t next_metal_resource_index_texture = 0; + uint32_t next_metal_resource_index_sampler = 0; + // Intentionally uninitialized, works around MSVC 2013 bug. + uint32_t next_metal_resource_ids[kMaxArgumentBuffers]; + + VariableID stage_in_var_id = 0; + VariableID stage_out_var_id = 0; + VariableID patch_stage_in_var_id = 0; + VariableID patch_stage_out_var_id = 0; + VariableID stage_in_ptr_var_id = 0; + VariableID stage_out_ptr_var_id = 0; + + // Handle HLSL-style 0-based vertex/instance index. + enum class TriState + { + Neutral, + No, + Yes + }; + TriState needs_base_vertex_arg = TriState::Neutral; + TriState needs_base_instance_arg = TriState::Neutral; + + bool has_sampled_images = false; + bool builtin_declaration = false; // Handle HLSL-style 0-based vertex/instance index. + + bool is_using_builtin_array = false; // Force the use of C style array declaration. + bool using_builtin_array() const; + + bool is_rasterization_disabled = false; + bool capture_output_to_buffer = false; + bool needs_swizzle_buffer_def = false; + bool used_swizzle_buffer = false; + bool added_builtin_tess_level = false; + bool needs_subgroup_invocation_id = false; + std::string qual_pos_var_name; + std::string stage_in_var_name = "in"; + std::string stage_out_var_name = "out"; + std::string patch_stage_in_var_name = "patchIn"; + std::string patch_stage_out_var_name = "patchOut"; + std::string sampler_name_suffix = "Smplr"; + std::string swizzle_name_suffix = "Swzl"; + std::string buffer_size_name_suffix = "BufferSize"; + std::string plane_name_suffix = "Plane"; + std::string input_wg_var_name = "gl_in"; + std::string output_buffer_var_name = "spvOut"; + std::string patch_output_buffer_var_name = "spvPatchOut"; + std::string tess_factor_buffer_var_name = "spvTessLevel"; + spv::Op previous_instruction_opcode = spv::OpNop; + + // Must be ordered since declaration is in a specific order. + std::map constexpr_samplers_by_id; + std::unordered_map constexpr_samplers_by_binding; + const MSLConstexprSampler *find_constexpr_sampler(uint32_t id) const; + + std::unordered_set buffers_requiring_array_length; + SmallVector buffer_arrays; + std::unordered_set atomic_image_vars; // Emulate texture2D atomic operations + + // Must be ordered since array is in a specific order. + std::map> buffers_requiring_dynamic_offset; + + SmallVector disabled_frag_outputs; + + std::unordered_set inline_uniform_blocks; + + uint32_t argument_buffer_ids[kMaxArgumentBuffers]; + uint32_t argument_buffer_discrete_mask = 0; + uint32_t argument_buffer_device_storage_mask = 0; + + void analyze_argument_buffers(); + bool descriptor_set_is_argument_buffer(uint32_t desc_set) const; + + uint32_t get_target_components_for_fragment_location(uint32_t location) const; + uint32_t build_extended_vector_type(uint32_t type_id, uint32_t components); + + bool suppress_missing_prototypes = false; + + void add_spv_func_and_recompile(SPVFuncImpl spv_func); + + void activate_argument_buffer_resources(); + + bool type_is_msl_framebuffer_fetch(const SPIRType &type) const; + + // OpcodeHandler that handles several MSL preprocessing operations. + struct OpCodePreprocessor : OpcodeHandler + { + OpCodePreprocessor(CompilerMSL &compiler_) + : compiler(compiler_) + { + } + + bool handle(spv::Op opcode, const uint32_t *args, uint32_t length) override; + CompilerMSL::SPVFuncImpl get_spv_func_impl(spv::Op opcode, const uint32_t *args); + void check_resource_write(uint32_t var_id); + + CompilerMSL &compiler; + std::unordered_map result_types; + std::unordered_map image_pointers; // Emulate texture2D atomic operations + bool suppress_missing_prototypes = false; + bool uses_atomics = false; + bool uses_resource_write = false; + bool needs_subgroup_invocation_id = false; + }; + + // OpcodeHandler that scans for uses of sampled images + struct SampledImageScanner : OpcodeHandler + { + SampledImageScanner(CompilerMSL &compiler_) + : compiler(compiler_) + { + } + + bool handle(spv::Op opcode, const uint32_t *args, uint32_t) override; + + CompilerMSL &compiler; + }; + + // Sorts the members of a SPIRType and associated Meta info based on a settable sorting + // aspect, which defines which aspect of the struct members will be used to sort them. + // Regardless of the sorting aspect, built-in members always appear at the end of the struct. + struct MemberSorter + { + enum SortAspect + { + Location, + LocationReverse, + Offset, + OffsetThenLocationReverse, + Alphabetical + }; + + void sort(); + bool operator()(uint32_t mbr_idx1, uint32_t mbr_idx2); + MemberSorter(SPIRType &t, Meta &m, SortAspect sa); + + SPIRType &type; + Meta &meta; + SortAspect sort_aspect; + }; +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_parser.hpp b/ios/include/spirv_cross/spirv_parser.hpp new file mode 100644 index 00000000..dafa3e86 --- /dev/null +++ b/ios/include/spirv_cross/spirv_parser.hpp @@ -0,0 +1,93 @@ +/* + * Copyright 2018-2020 Arm Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_PARSER_HPP +#define SPIRV_CROSS_PARSER_HPP + +#include "spirv_cross_parsed_ir.hpp" +#include + +namespace SPIRV_CROSS_NAMESPACE +{ +class Parser +{ +public: + Parser(const uint32_t *spirv_data, size_t word_count); + Parser(std::vector spirv); + + void parse(); + + ParsedIR &get_parsed_ir() + { + return ir; + } + +private: + ParsedIR ir; + SPIRFunction *current_function = nullptr; + SPIRBlock *current_block = nullptr; + + void parse(const Instruction &instr); + const uint32_t *stream(const Instruction &instr) const; + + template + T &set(uint32_t id, P &&... args) + { + ir.add_typed_id(static_cast(T::type), id); + auto &var = variant_set(ir.ids[id], std::forward

xBRj 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

l#cn<;CZ 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 SPiQ9223{APR;{)+pZ^8?W&8F3 literal 0 HcmV?d00001 diff --git a/ios/libs/glslang/libglslang-default-resource-limits.a b/ios/libs/glslang/libglslang-default-resource-limits.a new file mode 100644 index 0000000000000000000000000000000000000000..7ba44889ea016b70f93022fe0e3de02379915170 GIT binary patch literal 44792 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 literal 0 HcmV?d00001 diff --git a/ios/libs/glslang/libglslang.a b/ios/libs/glslang/libglslang.a new file mode 100644 index 0000000000000000000000000000000000000000..b701c919f377ab0874b04e3efa29552ee9ce3991 GIT binary patch literal 2405368 zcmeEP34B~t)lUnkAc8CcB1_p(1T&Kz1xed!32oDmOv}zN$-E?wPG*LgN!p--3T}vq z$SR;9BI1JjfeOeXA_yoT2#C0#D9R!zC@RYGopaCszU97UW|FkP_oct|_n&+3x#!(| zIrrRicY05@JT$uhM!O{5m295p{!6qsw{&!LB$`|1&1-8;P=Ev{nw#5OTj$M7bab_~ zstCtyl*#NfaM-eisYOlhzrLkSO}~3%Q`5QE&uuz*Bf&E^5L^ZKO1M7;_j+(&1~+r# z_&=K~n1Fi-`0n+@|17xw0$c_Eg&Ruv@EpO90KWvh8{f-=?jqp*!2ela;{6cm`4eyh z<+};^pO5mnr&0dd zy$bFhy-D2L!@Vus_k!*?xW57S$J^a0YbqMx#3SI!bw@chz;CnT`b0%=vyCwWMxR(RB1$H3( zp}mFf7~mH0uOPpF+gHK|@txCva}a(P!q0>I*U0x-D2EjIz5}=^@E`9KzP|*X4BQrY z+FlaAKJfT=h`R;&)whd#C*Wm!in|*)2YAsQ;(smD{Rz0ghjg|foy(B^GQuAN{X)36 z0^R`nty+Zd8Q}8+#230X_hH5d5BldrP##E8%|{&;~99ZUX!<+Uq626M-$@a{%1^ za32T!X8|$(ekd)tV1?j6;eQ$Y?*cvt++jbV+Ya=9JyP7a11|%91UL*_ z4BQjAA@GSKB>qo<-vsvIJMRO27kD4=S>W6Dm-vf-Rp6I^cLLw=UZHCP9tS)f_)Xw% zfm2LYDe%9*&TgSU6u1U>8Ssz5_2&!SuD}7{>A-IRe+GORxcdT$w+wg+ z@T#s$3pQR1fBuB8Tb$29x0(a8~6b5dEj=7B>Z6DXMk4$e*wG^>G%Th zMBp*NZs5+q^?+|#Ec|inAL&X0K;P1e%3iq4? zC46V#O8BSXz5;kJa94!?2kt$4B>q2F3a*5EgvN93XJc@G4DQ=NcLDHZgkK809rzS* z^Miy>2kQ(^b3Jwz|R5i06qiU3FF!#;27{i;7h>d!NT`Q z;HkjtfKLIxiu&56U+7DyucP2z4EKp}-wFC>fM10Ft-u{X{{-A`d5`ejWI*sajHgMs z_eJ|MMRZ_vOI%0Dtv<@jniH%5c90xbw#) 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

Y4_3$`$i|- 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 z

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ƭ(=ILX8yS?{F3XqFg+0oH+$>rH>O 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
  • 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

    Ilkn>jp<_4_B=cNUL7$2t9E4xh#LGjjN3 zwpSX~rg?t~Mzn1gg%KE!Gy|p~Q z)Ny*h=J+nQ&(mzrgKWP&NS5lOg2S)n_Pvkg3Qn&(L*&1d?R}8t|KRXemcP))^NAw< zb(+1f7nbLn{j5(5=l?S6e~|N|_YX;*{XD+k#d6|yk>2#Li|}5TkQ-T^uvN%^yYB*A)wy-aDuKXMID+NxZ(z+{W=|ARKkpxmUD4_bWCQ7o^qXpgycG6C^?U!!80UQDiO|ni zo{IU_SH90rUg#%xj2jrA-hcHy-+=n{m8n{NWeleSP02`~C;#sHZ05nN5hd8XvWzlLp22CLEWUiO+ACV(|TzGJ8Q$ zsc)iwkrE2d7HW>xlek@c0q-m+nPLk{&m)$(pp?EAly{bt5(`R~YM;~dw|r9O5`1`w zJ`iM%h9Oe$NkM$%E5lx5FVsGCGjx2-z~>b)5eYBBcaHLgjxEd!Eyd?h{BzZ-){*-VK#osJFoI^cPwZ8lTdL!O~$;ZruP$57uH zr11qrLaSY+eU;L$!I{lBqp9W7n3sVs0xiVPBIn|(KqY$9SXmZhvzg2$n=Qv)icba6 zw>FD5;LE6mg~dhb)*Mr6syW(bqYs{LwK*L{8_M!+j*^l=2_TO6Dki1lxPbF@gA8s( z)T}WU(n#mf_0?muWoWbzUvtwVcx!ve7=B5Zk;HBK7bJD7Tu7XOipL>2(P7XD@Ks#@ z6bHv%SStIke{64Gp=8e%kxOgNFUZSt@L<4+`IRLaQ5@W*{U$(>2#tTac6^!CUm2hN zLq=OfpBPIoTJG}8$0r&MGYd=gvHdLR1&pXG?lnTdSl$Xh&uDC^xPsDjd?0s&qa>xc z5G~AKIgS=zP`ZRZ)`dQC)_8IHe9Be{oE)ZwA;J?gxfv(HWSD-CU*IIP8DTNLMC-(~ z;f?6Dm2NG-_aPT(3y1}_JLIZ{3qljgpwqB&8WfS{NqoGsAeZK+3&!|Jrg(iU z^^SdKDXsR2%X36DQ;S?&URW+ZzvZLSPYe%zhACD*W4X(Y zPa_9T7yavO!KMT~k!8i`TtlaW#)Qv`(&y;{=OYtBE#d>;Lr0{+1z+*hzVS@8?w{U( zF-u>O_(zi6e&`tbviRIFXbpaQsiP#2Ix;7%)>9n07_1z5+_QYn&3(-V`X)JBzsr9&lm&WIPZ6vHPuZN=+tB{0SiwSz0bboz*;f3bY@ zpsui(u1;~WQdZ&^6xC<$kc03td@0vIO^%33)q6!l*Mb~PHz8=%=z;sdhY z*nXYHj0?-N#MaaHX(W_>MoDp5aT%JXu7fvKpNL3#P`m)?MI$|2l42Elmc%d`4-scT zzozM(mV4;|lF}Q_&~dyik~-e)MFp5+ya^3fJjLv1{{X{-H;&gnT$SjzVimZ&1QVsn zKc)Cgt=&L};v%hfQU*nVviNGZQ`DVyX)-vD@3rfoP+3!hf^en2gMmsT>ns?;`#@9i|Zf2Me+CcDT)?k&nYe`Q=GO1rDY}Jwpl*2 z(52XN?sk+ED|F?D>pQxOR{EzGzzcbHSQyIhWKr7>HC{m)$##vK(upPb#Z_CZ!WLs}9aFS1Mh27@D zlFPQGprj0!mzqJnolLJ#Q*2&&q08r9$%>@R^rH2}D+`J?X=ixL6XW&A;@pATARD!C zQAJ5*#eCt;-rmy&HQdGK)D^d`jJ6dN3`k!#zJiKW5#&|&>|y$-Wujqg(5<3DN$JtG zr5i4hhd9GqfI;ORsCR(=jtN6+ZZynpD=aSO`&Xr@E6{Rv!*dx2nQvg~`h->P%Cna_ z24Axbj4gXz63uX8lph#H&)#H04DSGrIHg4{T=SK!*Lr6mzS@r7>U3@?T##Fs=fupT zi*%O{SNM4g3XAi~@qy?8ZEr)ly(G`CT6KGyNTKE42p5w`pj!xEDjlCY2wy54?~NtQtu|A1rj!FEE4q6;?mpw%B%RJM<1Vw^S?;jW z(q8y{*~Lj}#xhLldP~RDPWdF+Y=w3g=Y@OWF5F;9UzuoIxyXj#Sf``3l*H6j?FKnc ziMORA3}?sUIw4PlQ9^M-d0PRV@z8B|iiHfZg5rQ8Tuo`7TT)Y;KMHI}L> z72)`&_3@!gCP(M9m5djYY{ac4s3+0}OE#^nD^@1>=3`D^L+9X@HdM3O*CVn`B$BRG z1vfAoRfYESB0U3@k(#3o(E(M(gh_ZGK&^oH38lOK#` z9abyXE;enO9NTR6k_}qpzh%X(sDoISy`UuhR_YrIso_y$yTzt;%?oY&IimTexRz&P zPZ?c+c+Eaw)=J7Pc5Tz9B(ano5LM2z`bu{|u-?xD2Fhu4h+w^%7n=g+tgp3vgELpj zQVd#*rw-6fX0NTfvbqIyW}32Lx81)DZa#kd*+VJ;^i(eMA3Q( z*(GIqJ^ZxPtq|bU^E=N>i$8j}PfxzJl^BLK=|S1~mdf|4Su2lEpsa5H5WS{_1-y$k zv9OT$#^nq|Cib0?{M6vZ;s9HiV{i682h%GbQzbpT5f#Swr1h{=EaUwj)aY&e!qXaP zCfRxh*17c89*}FTO26Hw4S!}_S)v{a=|*mzIQM_!#G8=kz&usFjpp;f)2mi>=PFu; zx4U}p1uVlLo~Z4-u@=+q3{3WCTP4KXFatpcUL{aueU)Gia62J^M$NM+pJ1cuNK@Xw z702h`8El^K4RNf?wFmlxZ`$Bi#-O`4FqHr84Jx321M+rwbBTklP5Hu&My27-jJqf8 zx{%KUE=5K|T;yGftn`t{6pg!PxLvP3xyZO=#!Jj|I9!V{MT$9!uGC^Pm)c$0V#lXZ z4{X!aWVOoVW~((z8n5V{;R16~lI}D~r*xSUWw>-ompMU(OQ&?1<7K#XN|!lKhD)b( znPX+RbV^rDj5pjYohIq@ahYXQ=`=~Fbj6rtROvMNIAwUW*J+YYub(+7QQFt*l%D29 zuct{mrOTWk!=+QY%<(c@I;G1TC&Q&vy3DaMTsoyICdM0XmQIs&`nb$8s&ty9Q@UbI zGOBc%e4O6!m}sxlES)Cll)*^}($rq3^fV`WJx$UnUFHNCE}hb4j+f!mDP86`87`gD zWsa5M(kWdrG2U>qbeg2o$7PmLrPCyx(iLNpQKi%569*WybPC4=`zR3aOspTGk(&C2RM^-N>@ybH{2|pCh7EXnPpVz zG)bp)#h7GN=`{H`z2Py@UZ+_)P11?rvO-s!UJ7%P*J+YY=`!OTbiKgRDP86S87`gD zWsaBO(kWf$I2kUT(q)d7;nFExF)`k7vviuI)5m3&QKi!)ozfL!l2N78)$3%Ob zX6ZCZCxT({Slx=|B(KvXozi7al;P4TUFHNCE}hb4j+f!mDP86`87`gDWsa5M(kWdr zG2U>qbeg2o$A#ac&{qS}X_8LqiZRKk(rNN>dc$L)y-u@qnxqrKFnEkN>m;w!B%RV_ zPL$!&DP3m#%A4K;q*J=g@iJUGrOO;A!=+QYVq(4FX6ZCZr*y@{$f(k3l1?9&Sw@vk zlXOZ~j7dh7PLq$*8y*wwb(*EqB%KI`?ajKu%t>CSNjjy=oG8PkQ@YFvGF&>P%N#Gm zrBk}haWY&wHJATIwf}_@?PK!a{kR}5)|+08beg5pB%RU~6XQM0ES)Cl^mWOoX0OvE zozfL!@`jtG)8ymyhQ~yEoo4AYNhg9)Z6;Z5UZ*L^>y$2YqSwxwaXoo4AY z`8xHJV(@#n`uHiGCLgC(ZPDIHNnWQ(I;G2;D8r>wy37eOTso!8952JAQ@YG?GF&<} z*F{#FH@z5qs$MsRbeg17x?*BvROvKHr;p1lqe`bqI;AVdB%?~F$;aspkBRm=&C+Rt zb2R?0GF@kmj+B3c-NFa)<6~nZBNO7H@hhEZI!0$8Ci-Z69*#}?XHB#-h zH#*=IK}eXDiVQhA2mFTH!unV!CHM5JM}4NNb` zFTMNDk>1rv2Cx6(&xne-?OR$(^XK^empR(^2dBK1EJ4YVvD-LV?Y{R5RkL}9FPgYNE>|Gw-cxL;Q#xsjY?(Gd$ z4!qc((D-8TWDgRrt=}2$Neil6(NG$mm<6_fP`#odIGjGgRRdl2Duy=IJ*rZz5B_fQ zi&upwR^}M?9$Fl9^ic3r5A>@k4N~?#3Hj-rhNJtRHXMCB_=*FRuCcOmMU+xsVzelS z{qsveKF=Y)DkJjs%Zu`HDVZ4h}n@r~Rl>x#CKstLtwFsa&DCQ6|z`)A>5+ zyz{%s-f}$KmTW*-3`(V{G*u=?IF+QcrFZvFAJ>mxzakTu2=c#y4Oe78t9sL zZe7os{xrYzKlDkz2kGxPclv>BQ8jM(Y~jADZD4&}gbn<4^wvGWg3XkVd5<#a^$h1+x=`b8_+Sc9{AMOD#{OVBr3{LAp- z;_$?a(c3-E&%VRZ2A+q$&r_f987nk9ABCO&IN9^!%5&@LUuP{yFYU+Q3OFv%_;a?h zH(*?#@#d_3A!cB`DR24o1vmOa#f8_~m$kv!^sNtmGo)}_RFPTAN=l*ca z{VnG)_xq{)So&yPzEU*x>(pXN|Ho{xS3+thUf?WjEKGuEExnm16oq^Gu~ zj__+!FZrb3hOyjr?)DTY{b3!;1N4RZ;M##>4v&pd^S(ptg>4a47ofLK`tHeo_P&5I z*S{^~V=YD3VB5i}5B99ccmAlP;iJie*MBi*Ujq$wUF44N)Ab_i&R^$CF%}GKTkx58 zhIJhGZ3AQc?8~Y0ldl)}l=)qdVqpel7 zIeCDMFVS`3CAuCO*0vU)?%ctH`yAC<6xJB+g_xfrmBSG=7f^?n%GN%*57joR7F@)7 z%}3wixXuVTURQoQHke zfBfafw&55n{OgUbYcKYCHeg>E&b6A4P2E=vUT0tE+QGl<^gL$`o?)Q;75>-aXS>gQ zDX*~t+VoP*J;QL{#jCGRT@5vUcklUs-~KN|-~6%XKOSCCy34+G-s5bbblpQ;b1tY} z(S7jXdEeU$nD+R={fyQN^xV^Up4Tk?{p?cQCm4>gFktzE1DC(y!3V{C(=V}Jy43f4 z2d&fhVx3;Y>-7B>u*UQ0%R^lQ7$;gz8z(5IwQGR-i%Z)*L|d!E_3`<(HE$jIuJeXr zJ?7trX|CvoUV-*2ocCPeW7na|e!=$zeAE0A_ag(^aTw;EKz1Cq`F0rUIbgYmGu=yB zKf~}$KVbQXq22?gJDlqcpZ+sc!#0N_21KS&Z3DJZ2v}_qgic zzx>y+`kt35c&Fo`?OLgyH zSlh0zzQfRm{p;*ftmB5GzWntZst^26YX8*s*Psu4)%Jb%Xb#sNp8t>9exUJsIIc7N z`xM>ZOZzAGj*P>;#EX0`?Vn~i&jJ4Z^~K=-InTHcquhVSo@iRLx<}#KkoQ5KYt8Rp zR_gCxs+>OShoSDTOu5j#3_kP4u+Bs0p=*2LgXet@WVmeUpAKEqr9szWyQaHh@V$cz zy+`To&ptM!c0>Db23_C3gtcNDuN9lly;eMH+Wz}YX)Ssb>34Ga%@>#cpmy~?JYBD? z{r9bs-XFpqJ#3HGi?xT}GvNQ>>3Z$q`z{6P{3L8q&$ei|I9m+5hezpN;Pp?SHhrnm z9genqX8RhvkCTP>a#rL0oK<*F=k~_F;>(PIo&;8Ic*$kIUF%V+5D10$;7KdH8T`tubbb!sTwE37KSL9Ra4=9 zHe~Z_K{6h`dlxq79E!IlX!Gu&(wm696q$y9UT+~x%j?e}o8O0<@_Ybk;S-Eun*aQu z&3gi+&HDW?K-ziTgYo2(DBqdwi&6KB8d1kuT~phQh*dT>AWYOR-naU5 zwujmQ!sx4sT0G-)%i%eAw_(nV_Ng}+f;L(ZpW+z5VR<+rPMk0DQ})i+uY+YF6S!3%$ST8l$*uY?}xmscpKMcnCl zS8cKuKVnltqIiD~7!Z&sII=4xV;E&!6%pS+{|3i}Lx$^Ng~bPJo^77^UpB1&5zJ5Ugarbobq! zh9Jvn98|kHNDA-QJVQ zuG57*Ey}YwNb^&a5$~pac;A2bXL?}YPoGed5_*ImmA1Hq+ z$2(*j=y7KIGPJLyXlGWmw_DNfZozn*-iUUn^*yRP(xZQ;a`eo01Ky!j_P&cYcVd)s z`Uyq(@WiMmrvCjZ5$DYIg&4<0pM57d2xIo({PjNAzc}RRXB);M&&!baIOs4QZG1xG zncxugS$g*p_QL;$ozpyeo3BSZ{x~@JfH7RO@84oPZP0%`=|NTC)&9i=aXF{P@gZOKkD`Q6w2s%1@#$WNJ2dx!h6qJpA6g&gSCE0 z{YUh>D+lyDz5P;Odiy;45XKR2o2h@raMZx(_1}XwiT+JGe?t8WZIZ(EGQ1s1btBs3 z+bF}QieKh;O`|j;N4raIkbnV9(_D&DE&)fWAGXejS&sdEe`p4)4{k#`O-VO`j{i!LU;do zE73=__^*h5zX|e3XxF{e zt^>?HQ9SpEzJ)p&uQclI+FgpZ!YDDu`i~nY5GKZqFz=Yruyfs@KKByp{LJ<==zcT$ z+!FM)AnzQ1t~t#{bJ7*M{=wROMr~pe=8QWqH{E-8xu@Mbexl##<0sZa_fJ$Z4~&5d;R zJ|OzZWS@Kohxx`mj`JT!{Rf^Cr+LTF`;fOjhUWChIdSrT_aAx~{f*iL>MM-O;to1Ptbu+(ceBoTctU~Xu_HXZ4*Drk?`h7ac!~-?KU6( z^|nIu46Vh<*6(0!)7QkGtX_zD>PQ349TeXfaPF4pQ9hK%4>1RR8hqtkeA>I_5Y}>A zV6S_>W%20q3-K);Lq8pY#^?B|ojCmNR_I_+rlFE6m z9(sOL#QZjf(xW<|-*XW2!gUQUlfXC#!#fbg-7& zjyAnh*?SYl-`CKNK0=(Pyx zEredLXz534x(@UU)V@B#T8{eA$FM!+3ma?Kd~d;@?2YjxR{DwG)o2UkH#0yy_*E^! zb*Oz|Qs`AmtifQ|JHsIQzwZB@BK&DxvKl(;{ssO0aiLQzr$>ic4v$eShffAyJNFjD zm@%-!VVl9YDec*+sm50_qe?=6?1Y_R7H?Y@XuYg)q3&rg{=I9?z>_q4(B>ZcC&Qv zPZ=DqEr5QJ0sJZh=;yw2aC(*ier*BHjr_ml=Rej{U)1VzjvNE^b>o2g{wmx%M_i13 zLVWBOkA6rt_w_Rc@S6v}@A`}hul}t+?(;8jZSCVX2Y#Qx??U^vKHuR!RZTAXr&tq& z9XNq?fqxsRS0c1F;;Zk70Q&mc#XpV80BQ7MP2_Kfe+BS+KY-ug1NgZE`27`rL(R7z zYjcg5bLBWC=GjP$@xJpgt?S%=^YEg{+T5$%19?hY1L3|E=HV?t%AqS^pN5gRzk=(7 z{1HlKKFrh&Yh998$M$6|;rO}9cTix0`O<^=oi}AC6V|>7Q z+JgM)dc}yjI${#;F}SY`Hwki$DDl%@n6K+(LPq{aet`L<96hEA?-Pz)(1b5NLh)?J=JpBcP;e#BIPiCMCgKb@b6RlT2fzc z2Us#tqZ@g{TYqYf`r3HBs-VB<2vJ%&8Qa`!AetDGa z*E11^^7+I^zn`OjPl0~!F<9TCO#g?yvjK>!I`jU$GbAA&DmIv4jLm4Gk{FdCgn;JM zNdiiAj5NWBnm9~g5=e#*VTeRigO#>uuo6pK%u+)Ym87U>u@Xf^o9)sq?=HLL?XtUU zMP+w!L*J!aYDr6)_y64Ixp!vxOkBI4P3!%g=bY!9^PKN<&%Mm0wB9{^CS$-pf5q@p z{b*>upNC#>oQIU-p2^C=LMyeHMB`c5>4^ItH|k>@>f=4*o`KRa>)D(`O#96Bk8Lc3>@`aYpCv&%l24YhH8Y z-Y?kKrdw0yhpj2~JLp*j-@`S2Ie719mwP`u=FLWG!{=zLD=zd4Sajq}5~+9~5)=pxstk6_~t$`@_+S>!vmd|~-r;X3sp^7H;r%8$<1q+ILH zwOn=^*3JmbyE8C%VBLHW=j)hz>HJ|BZAa%16yZ^SH69?gT^@Zl}9KqKDRUb z%)pY#)|8u3rkhZ3yILGqp8gYn!YO)_goBf4bK;=3=a4OJ*!7{x0@T6FoOuHs+m;MjE3b>*Kg}G2WF- z>9x~ZO7CH)nfLk6VO^c*-I;fdH7Nz<-+*zBbKedBd2KOvKk;nD*m~!FW$xiFN8kEG z*L6AS$E@o=#6BdnuQfihWaJOJ=G*`4jO9OQIj7iD{b$V~k4!g*OtPo@L-+6hu({-s z;5$B{eV*=tH;h?FXx|;WhR`^t`E&r!&Bwlv!+YxByFtdD`adu)yys)wGfekR5}mh1 z#?pGA-FG$S?6cKR!~G=1olc+ZI9uJ>(53e}*29hg>``Z9{Th2Obp_U;kL;1h=)Q^a zcW91o`j5_v#-0lkr_;IQ z0M3pt!F{6^S&sUk`_l3IYLqLQ^RQt*WIx(*Z+miM#K@XHDz1Ujx0$ zo3uk0;e6SA_TGqho9Mk$x+mW-4s8{nn zCCZ2LqxX~saIa#%r-W}TM0caiN7kd9I7|D#Nc+gWd|vSh+GO~BEg3INzjhwkh%-KV z7t4I_gYJR)w%GVNHI+r~K}>tz-<^;&@IKmqKHEEh^b%072OiRn9+*S=!E?Oz@_v%> zjw06Q(tEY!J0xE^TU;RTfKgxRK;4u+qaDq%X{YF23hFnZ=ZXjLe0-wz;PX-LQ&ex1 z7WH4^Z+E?k`yn0srSN^DdB118v$3rm?~=KmjKrB_2hOBF!5R7-eZfyWdh|&;d;B|F z^ub%~kw3ZGR{rE3J@O|9^f@OV!P)+Dynps%ePqpVU? z+MzwDpM%bWhnFDFq=ye4&O+ZdpHrMd9sK~$0Q&GAC$*jVe8OR0aFF_&*w7kwrDHe*5rm?#>-qgE9W`&t1t>pZ~Ie`(GyB`=fa8#n&FT z{r*hL$6wYCt-x~*8cQyOnPad1^qJKIc;<1$Hs3gRepJ$VOwzd%x@T+)PJS5wt;3ja zTOJKbXC1<5k57Fn3-f$A>Ii39uy^6f_2}1RKlS^u&)leQ(mXs`sH3iI=!@ge?uU(Y zO6?fEQ+@Fhu93TDYc2HNTG{28lg8B715#i3Mo;ts`=XOJoJEeH{UZ^tF+yuOg>_&p z`hM*DuHO$KD-xYtHgN&`7eB>&L~%C|1rxq7kPN>mz;bC z<%@-W>APUD?#9mH8W&0`lw;_L-$QZ97q?5_iM=b{hmNRQs5IECkRl=dB` z&$Q5cc+{`SJ~Pi!JQMo}wvt_0m+chJarl7VQSN{=kdSYwI1(2W1oVv zA!@%HHSOfU!Xt}fvoHow-zyMrIo{`u^}3QPaR#{p`L6J4$seHZVgJdGp*tJ$Zj6~M zoV%O4c-MP%EXq6=WjTOnbM>g#gLbXO|M&7 zezFhm+tD*WdX{(f49(EVn~m{|^wNZ8x+n22_ME$}9>KSBPOUgycjHkHLp4{eY+#Ab!r84cO&18l2$D0p3g0jwr zZIt#L*meujA)D~tjFCT)>^^|!mt@;U*cOZYWm2BuRa(f? zOpBfc{C1a)aW?+lu20POi=-dY-2XS|Tl8$;o%3xYOGa%+=~))_6FTSr5bGw5N%Ne) z?B`nYDfE|2S-&DTXonUV>(?S94$a4Dm}|?Pu^r9&9Ib=qyv)y>ZrqcUg#E$s-0QXD zA1vkll=`?Zu+@PJN6Xj_Pge3E%Yq^gIVZr zSWh>iPtC!aN^|h_uRM0R1JA{-gH1G#4AXoym*=V*WUiVobJYRNNlBQimSC=0AahkN z;*kHsSN>$exhm`QnKd*Y(%)Iw@eB|zLA8X(37?zVF@I;x97!ZQDq(xa@6NnNwo#th zcrH%we3*82V9pDjQ$y_xom0PsJYPpUREn)J#=OeUf6O^C3;DWWYouZ8B_}@`J(KYX z;!zxmOJ(GE^mjJF^_=YOL;acdR>EGKs~Gb?*-QQ5VqH5m6MlH0b&A#{(~sitx)j_~ z(=*4hbKLapOwZDSYt-@oqH9#;zhjLm#Tu1`aiY%-U#Dn|qP2?FC}XWU5AMZSr@n;s z3Ue6digQ}8evP$rvh|AIp9x#9u-}WM_3HeyU$6eymabF(Q`&O0@C}UBiPtmQH=6Iw z(%77hc{dhw?xVPm`5pEm2kaM}d<6F|^mj7kNAKIL&@VCWYu~k{ z<=88^U=NjnY^D3D{nq`|;*fiz@$2bm;g5{_BeI*)diOVHGX4}}+`O;)CERA6{_)<4 z|1NmCzek|H{=fNta-x1h&#tLn%y+!#J$f2H%Q24WOye_gAsoQU4RH14_NT!icx z_}!U|M{#cQ3HGNg#yI3>+~#=&oiF9WcI+9~1aJ;P@44>9`04)rnb+_#+rj|OBxuY` zbgylWC7j_I{~U~R+*=v{9E@_DD;WPAjB@%WDgAR8SFIfHj2ZtNjPgZHD}3P?`O-16 zL*zJS`O-1+Vv!vZe)*X2%f`r8jgjfQs`SrHe;JFGynKv|`#xor;jWeD5xw2OlE#6&HB@lZSYGB_;kM|V zp*P1<5-2P-DxT7pU~ix>KQ9{}Yc4H7rwD5SG;mI__kIsmVZLvI&|SrarA3~-g#jzk zU`M3SKL?5njXoBVommxZ71xE8>E1lw{Y8bvC^B^lv!KCd_2d-<5)&ry-&qv&mU8Xz z`u&AQe>HMP8A^O+FN`;nC<*iSWc$%;tuXH5B>`VScAlS_1D2VAMTI2+9$hHsULVGq zRRxm2RTlIVRAg9*Xl&;D3Ib*upjf_Qw6E2_C5`M*KeL&4lB)={ zQs?;4wFiYLq#O;7YuaYBDoRRsaIf0oEy>HCEYR$76GikE=LK@nT_=wn>>3lrFUds(^ZYbL zu&3BZ6U1Jl-X_w^_LrjT6#I;_Po!{Psn-h2_vII&rb@C4i!fFB^1THx-xwA&m4}a1 zYYc=06=0$=KDUmDo?ZSzln`SjFOcW;qiK0mhp2~42{dzHf?+dBWs;svK{BE}JN=m8 zc~-*YX_*Nl%sz^;`SW(>@ziW&%*%lvGpjiWJv&PavT2I75-7>``n|=T9n|Y(f~5{X z@vRY)SFl&+K@7iwlDvR1O^}N8)M6h-2YS2FFcbM3gMXp`Pw8G?wiTL#Cc(-ODD>p| z{6!dW!JJK_a(p{VcX^76(IPudKWQsxA`LnjL}S8|#suAb`|UToQ$5*5MToG^@ALTc z3VfcNJX$KHgNaIB0eV%=n6P!XrIWWJ^e(wTQ^bw5EDf zZ&!BM5{SG)rsG_%e<$?@FVBkzG)F!!%$^;2-V$s4hsQ;wITOuXq}D?ErLk0nMimvS zBjkHac)AQvHfWM(r!SCgY<@Ow%1CvabwqRRE;Ogr`-~Rfv{iO2SiDR2cxXy5&O=Ry zPVUgz8IJJ5MaFS{vRGSF077Wk`-*wB=3_8g(-&c|=6(l~{g;YjkdPaL9E2G;7Q!2^FY>|h(7|%Tj zFnh(sG1qNM*?jxP6l33vIR}$1EqK@?uX1`ROPbzy_|dK&A7(yd+vv^NYitxLm^SaS zK<~xso7O36@`OBHjU$3EA+m=T(UzW#ODNe9yI5T>A;j#n0HYjYQj?@ z`vD^;d{a$csQi5NhrQSxVAp7D)OQpbRZOAM&UuAAkz2F-B)e*g5*9Sx1he6JhBs|C zeaCOPsZu5=Xqb0+E=EvzLCI_Kf>P*21ttHm(y)@*q+vnhO)!fTEGVZp*}X+*b<4Dt z&wZUja(sL9vV9(7J7rdyHP@IPQix)o7sDYR6P~%{q!eg08+$lYn>=>T7AM}sNJEZEs7^KunZ=aZU1Nv}FZS}&`sUOP z8@Ft{eUm3`wW$4Qz2iH>@Gwe!{0Yq2=RM4Hi5?Yb#79n&;<-*Be*{qAHyu*RBK;&EULLN zi^CKO!8v*YrQm`wK5*itW4xX;l(kxp*9coPSbZ9$sf;!&jF*^+5}IhS8LwyBJ;7W) zxpHug8m}|Kx)H8K{cOsH3sab^4h*Hq8jb?brr}7>tN?SHGv3%~8;+6*Q<}=?sTz(G zI;V!4?!*Aa(LyHB;NE$P+lMi6&T7)7Qz5fx*4c1)U79CZbi*vs zzOEi0ILUGGc*XF8?GmRLR_m zOp~NJ46QTr@d-|FS{|+xa=&mE^Lfa09uhI+%*{Fr9-qs!^-d{Hay~phwTVuO$7@NY zhaII(sug;uI)Tzu$Ila}k3WbWuVnSI;K8tYBt2ePI)imMJ-x=5VN3NpHW5Cs9-q_{ zN7oZ62M@8sLnnG@VLX+YUX7m5Os^HZbDv&!qPcD&1Lf(>^a+Zh^&DsV7}gV==~e03 zPKZ{jN6y)#ONSogPN5clC^L~_$Z_jr!N&YDS>PmRIU(vWJmhh~M6D1K9R8?b(p0Ri z!`O!o<6{ILKTHs2ZR0(`Q~&X5=0rQ@k;Hh#@P*l#I9@}VFJ#KJ9#c%JY)upNU}3yg zNT$I;@S}@xp{ji z#gIoD(|cB{tp!n2Jx zc5{7J@#MVmQ@|RD8C5znLG0Qc=kVu4mD%w(~t2rU_A#34+_p+A&&^h7;t;&Q;G2CVL{X-Lk*wi zF@JbUlRfYc*P7zFV`%1E?{MF`Zj(d1B1a3eXiNIW&08HBufm!+=V>ybX`yEr4%yp> zd;0cz{rtRBGZzpI)9N+5di z-}cjEQH>@(EkKXhk=(Dj-zDCjv8{+J)pcKGNyQ zUV81%LFVoA1sr+w(j&dug@;~v_YwzMctD=B(vk1ohg==Sc&B79+rP8ah={j{eBKhD z<_Kz2>CCLP8>WwXMTtWSdP8UiW)f)hf3RlBOfm= zk+o)l1BFyqTqjcC>$PG$>Bbu>A=P120(qlleL2@_>4haFd8n~q$|We8@dAq#UE@5o z9K01t&40hQxIo+C%k}QfL#>B3`t{mU%R~*`C8SZWf_Rl9+gm^p5ZC9pO3b^88t*F3 zL!H+{(TN(lY#X21?w)<5_;H#Nh4&v)~@Fcg*b)xqkits^%XeG z0fBm^L3hnov`N4brczo$t#Gq@i`(dwTTA_Wyak$J!>7`lILqJ|qHdmDT8y_*0uFw+ z7sj%2X7_`U1wKp%cxRO61Z&pS@Q~FUp3?QSJJ)UAv~knTDE#&4app_d@^14V@y8nY zV+~AR1EW|<+`4v6D~P{|z6S4=Yj=V<;4R>2v8LSvHiG!u=4-NqHTSXX7B&}gI+-BF zPZ7omV?au;t&sC+5^e);gMW2_rrik614(Z%pVMy?p73+H3#4!dNcQyN5ABH^yP4I( z7-4@N`=@|Z&Uql^)0wMjUj$DGo4^#v)gakl1a1b`f>eHo$k97Feyxwg_k)ywk}xxe z^km5CiWKTIr_GF5G5=ilTvovij*aiMS zB+xHMQXTNT-IWs>Qzoq_{21XGOcf{LDtw1{32%|` z29V-aihqUp=YR(gFN>+%5}qdENg&0G7XK*mAKAwBG|W^(;GZI$L8fX2--X=5RE=Oe zb>O!&K?uKSOpiRUAm|vXZ$y8YDYL?qUC7=Jqb|pAfH;sahqxMZz0Equkd$H{sZFq znJQDlGbDT&Nd3;iREt5X&lslaxr^(wo2fcLs?QTl)e2I5wlGx{_z~nvrrHLQT`rL9 zUCZ1a1O6O((M+XD_-Lk~w|x+#cpWVJPl$gLNcJ`|RRc)&)-#nKr1sBcs%;?Io5@se zknBxks(IjtkRzFD@J_aKfVsU3Bs*HfzghgNzz-0wlBog`UL@gJAjL}&f0y_#2Kx{% zhN&VXT$Avjtx|4~>gxn^dnHKqRl!u{AkAw+Rfs|hgNckm!lx_lZdn8Et z^<}VsFLQe>*o$;(n5r72{K`SfuS{e=NcrV5RSrn`xk1X$1yX)%ncJg4%5QiJ`wua< zcY;)(9Zc0G;jI$h2vWQ%@vjvBZ6MW4CR4d3JWaxrK#I3m{A0v_a5I;0fT?;xva^S| zy#u6pP2%4u{`*0ymolcxk?<@DPX{Spg80XYe=PWU_|F6X9`PfYYVeDimJE4-sk%Y3 zql>w{4y5r_%TzTWjjw8^%8>AM33p3)nuN~-X}xYs*EIZ|;x$bmt*wPy-Q z?UexD4XyE$OnX2n{wy%?^I>5g}_z9+J2g%+xrmB$eatYrLzK!rQ zrt*VtLC$5WZD1SZOs0whsXkURRV+yPEn_MNNck;hs=iHJo*wWa_;)i^8%Xui0vi1a zqf{7;LTteNctHd>BmU8 z22#GGZiCyqL9(k6{J(HEFjYPHw~*_YY92`S5Xn>#AnD_OL^XP=ru9G`VX8K84$`dv zNw1u#_Je-|xs0iDZ_%`M(8~nL-XxIvN#8~;PZvo2q#dMw(hB|z@mrXx5R;5Q+=m?{peg1nNc7K7E0W0-36W=(qn@(5G)f{#P)VX8Ke;IQ;puFX_#4Y6BmE+{#on zAhk;s_%i(Qn~+3RF8*cUOYjdcm0$dGz!%}4#Z;N%pAI&`-_2Ah;=dN8eP$9<#fg6` zcrW~yG1X%6j|R8HKZ>a$#a{!<;6IvbPz{4*{~$smI;TRGs2~0>qGa zw=-3%_&0+Xn(ij1Y7qZA5JS&h%T(3kUkPFexht4zzxW403=ww`Q{{?(7KmFY_co@= z5PvuLE%>J~l}r4SK+I?d>d1ZtcQSf+CiEhnn9W$szI6` zGC`W}(mxRV(-xkXx9lLgaFhV?au8o^aH~>5VW| z4@l{CGgTKz>2)$yoyfH!yFn_?(2Z<&A4qn0f|O4ONcNs!sy6X&1^*BHTbQZ|oDKbY z39kcBAiS2T(#78mQhI4j`{(h#~22wk%1gV{>6|Z-Gkk*}C=5{yON%k?-T9EFOY-;1%UvM#%TA_h0I6SAfmDCnKx&UTkoxILrfNy#`^09ZY6PjDH852z zNd2sasr=yEkaL+T3w#UmHl|7k+aSA{Dh4F|Xr`J6l71vpjjm?>5vJ+{DZGQJ+9bSH z!ka*2-w0AWRx-DjgPTykGSH}3rYaKu9FY25CU_j_XE0ToguB2u;lGxtR*L^JkkWH7 z)nf6F0x7)+kkZqbYB+)I7zA74KfqKy;@<_n4*yQ3>Ja~S@CWd3W2z?cZvbC|e?3$A z#XkpZfqxcLrHg+W_$S$Tz0x8}~km4-^Dc*1#@5_gnst+W+ZjkgkLDH)O zUqE`bOjQYz-hPnu0wC$7fX`FDOqBpGfE>qEu^`1;3{t#kkmB`U$NT?2rs@GNLcDIK z>I5lXJ4o?bL5f!iHbAd}sRAJB<$|P_1(M!c@LA|3G1W2&kCyPkYc=f|gby%PFG%q_ zL5g1oeiz}jOjQXQ~ zl3qRdH1z72s#?O!B|J^!B#|S*??69-sfJf_x&t7k+Xqs*tzaGWT9~Rq!fPbl5B>?l zbD1h#!d(&`1s+EDJf<4Gn)4X~DW3t*$On9i@?ok5kjhyLl3q1PdRbsC^tLfox`ewV zJPQ0a<;PT`D3(KkyLc$5f-S96ktAcpF%a z@K&a31Sy?5kkY9ENiPR{0(x0Yg%6+_;VBXx4SpTrQB0+Ql+N%~k{@W~2R=^uF;ydI zB1X4N?U?uc4rW(0|!v{bLZw0@G@D`?O1fwB0FjXB$=~jc3ZY4AQ>_I_FAgNVSdjEamhye!FjMt|q}KzIUKeQO3qDNwGF1&|@4f=0ezIpxb# zYe6Gl(8w1w^1YnTZHAeuA2jj>jeJ4UYXToadW}p~E8&$Ao(X;l;TcSo0#Z6jAf*!r zQaX{~e&|Io)$nDkHvp1eA4qyF;DgX>W~zFS(yIYUuL>l+T<`(t3fzbA zc}z9x;BxbC8FbY7nG&eIUi_0V!T1SPH!crm6u+uM#9Z`jJA?bAtisr7=|! zNO~(l(pv_S-tgx&tps{QOw|XHUN=a3ognGefyL0PWvVI(-!I{A@IK0qsggh=KhVez zq;!TZ)wCk$4Kh_PNP1l$>2-jlR|^(GuZF2AK+-D%Nv{YbJr`I2y|qlW5+pqbNP00K z=?yH_w0!9GGgUW8dL1C?wS%Nr4f>&1#Z>!2(klW@`;m?{90UM@&_Ss>}H1#_X7#8k^9JX*s07iroq zg!eI37f9)x04bd|kkY9FcS5g{smego^Mj<90~+~(KFW`&VkJCA!UrzqbF+S?>INyD z4v^Am2PvIuFdOMqG1Y#M^ol^z%LPd<3ETla`mh10mVu-f1Cm}8NP2zPq9vET*9sc>f?1R=Qx!>gmW0QF9)z!Cs>L9s69rN_kszhhgU$H8(CcQZ6Cmlef~40B zl3qEu9eVqj$`6uW7D#%TAnC<|+n~3MsiHyBiv&rJHvgp8h0XUp(CcKXHjwn1LDFjk zNv{mN8+rkz$^l6)6C}NKkn|RVcR??Pspf$fLXKoA+U!%j;fpxlAV~4rz)a}1GF2l; zdUYVBUjvd}4tOW@vY09zB)t@n^wxr;HxJxO`7+fA7H!fS1WB(SB)t~!4(K&ARXs?0 zH6ZC#fuy$$%z$1dQ>BAZkljp`0#dvrkmALG6puCwTc9_JNgGsyAnEmiq}KzIUL&{} zdJRlf1Cm}PNP6WU>7|2TqxlRD+yDAnC<|q~`!hZwQTl8}tU5suv`^E|By(K+>xP z-IOm=Rf6Y3u3)PDAjK;JDPAr}@sdb}UIJ4s14%E2WH1UOy*@P7Ezs*_s!k&O+d81J_f2Ocezh`GH1$=W#mS;5z7aF;z22;q?+;Mnrgksd7L{Cle&S zbn*us;Em8*%v4bz{_md0R1qM>8=1%PhCqtf4t@c8ZA{e!l3qPX>DPj!mkTQB?KWiW=`uI4dI|x#`{UD{=0!4T9RMjA*UjdTdevs04gV#bYjj57A z(pw3V-ZGH%hG%M6B#%Q?iK$kCD6%`2sT?51iv}sbc_78>ouO$fpx47xoghqhcQ92uNby=giq`~Ey#3&E z=#?>*U&6OZ_)0LA@@J~WAhLAFFjW*t=|+H*?nnfu+XY?)y-ucT1t}cg7c=rL1FuAQ zfT?mMJVU~lfma~h!BkP8kq=1ejM_P!Zg3g&x|pg3r0@m_4}eP%Uc^*6AWU^AFFRmjY6~M1hw>Zyr-cNcgag!%u*hA-tWbnn6mZ0i<;5KuV_!#4VjWz*Jcho-W}I z5Vv0L#Y`0iqKNK!OceoAx+6NLI|Nd??I3QU+-*$N48lZr6H_&S6t5N}d#XW-=Lc~M zI?DNFCuLFpB(#K-hLZzQ3uRf!qg< zf<54AunYVh*a7|)YzI$)tsu&Belz$Ruo3(OtOx%MtOb7wR)fC=@l7mk7%T^W1(tzB zU=g?l`R59=gqgy0@H~X4f%8BYcoCQcE(GJi^TAkfG3Wr%2It3s*ML#rN-z?<3e>f!Bc@U_96kUIMm)POuqV12%$7!Fn(etOYLwtHBGv zN^k*K4&r-U=a+$(fkog7Fc(}6W`V1~OfUgV2V=oB@N&=vUJE9HSA%ijG7vi26`%uL z1jc~SIX?Z44syH5)IWDXZU&zRk%ke! z9`r)41^0l}Aca?glzzGRmw^S4i$F>@7o_kk@OxmU$m!rQ$Y~=(cW8pT~x4k7t&x!c*z7+gtB#ySM#byM18$;P#>Ih`+rK*Y<5Ew#~8)-ZONM z-ClQ3{XGr$K>zN_yY2RtyISvRy9@f6gPB8_usE|C*Ooh5?}Wu$`?kVoYc;MdceLIC zpNzf?#LTG7K+G+zTiUk3Z*$*f_-(Glwe^c_UxaPx{pqu8)#)|3w%*=$JA5|vZ<=MR z+*Gv*7T(r&Tl;N@=k9Z(4%`*Ew%po!t8Qz!wdGbDu8p_OvUT6mbIUB-=*Dtf8#Xp> zoMr1w>q?tt8@_quX87FPh->FfT{poebtKhpZ%l1UZB9kJl%5n=lTwLm^M;lUc6cBKv1D)_Ws-F7wdThYG) z`K_qJwRw5V@>#Z?*xp#()*0IqYs0lG7HM8pj%&kJjaMPfE4!|Q&lTmkHeAtog>I|4 zqTvb~uC-UpvYlAgu?%HjI#YAR+R2E9I}KL))%rY8pZ#8l$iw6J+0`tX9m1w#u^+67g( zwq4YI5n@CSM58Z8*F@{K^62Vl8?F`bX`bIQA9eA$-p`@!KUaZk!3orApQG|ka%wR0Nh*l?|zW4CwC?wZ{_8|9B2 zi9~LZ4UwpmS>3aGW+A_s!!vbT-^`(zHeCB>qOZ)X#3&34p~ZO}GkLw(q4Y^VOH8iJ#Dyl?CHdHWX~wBmHsL}x|Y8d z*G_*IuD$*~TnGGv~GzXru`GMO}0)>?%a#6xS7_n8h`? z)|S+jz+F;P5@A14(oxb04wsCSjDqcf6M>EZatZX|+8yY@^~Bzey{O{7)wtH|tKEkV zUp7>Re9IckBJ5rJy7%?Kulj+S2Tz5k7gjDtq?MLbdIu2l{9B9S0_COt7AJ*$0M%8yetoIN*AJ)5wBM6?iTz*G2Z$qI(?<VC_M@j@WciZzi@M)K3t*59&R{frI)WarB^G zUIkWH={3ZLD!q}|TBWxUJFE0AVqcZsPaLk&M~Ib=>s60~wbgoEH8}EwKKcaM^Mu|@ zY<)s+Bi25l*AYj)u8)45!oRNf5?jBnw-IZBYFq1?TFq^tf|*)>%qo)y@}ZMjNbhW*zt_sNvwTV zuX`4(epat}7AAE)t9L)E_mJ1Xv-;q(y4_ycpjS2M)eQ)3ZqQpA^j32AHR$~f`alB| zM;i1|@@jleZ+cE|eh$vs=k>bh_4?;2ndkID^6Gg`?|n}1BWL9cdesYh^$Q5?d0y{* z9$p>K>z&W*UE~~kK_7lWA9(>;cf6o?zMyx#0N>UZ^tKoDc5?O})%%X>{YMeK=BQpv z9B9-B8xhpjsJA!jC&=0TJ-z39dhhoTTJ=4>n%H+t?>~m1mScMBF};nPCtlP$Uer5Z zL}nE)>Xk3*RWCxZr%CT^LTFQy-rS_OkhAt(&_Wxe`k_%^?+x4f*kl5^l?eeh*{=w(u9)~lNJ>SmI~|Dty~s)!Sdy zPrQmamEYH^z7Mv1UvDLz_`cpj?Eb#qL#%Jn8(P5H7QLAy^C0LT(3P2 zHXPR*i7m(VR^sq+eS|o8Tpv1)sMT-iHE-y(Z@}5{hTi#x-t`7T``*y|$*bZ`z4A@H z>PGt$(-Rkmh{cQ_{m>`nQ9^Lu7jIgXAa)-*_d<4v}xgAq|Dc ziG15KmR%y>y_Ds2k#}9ra+b(}%UCWF`D+fA%SAqn!x2iqTI4I2vs^DSz4t=l%_7^x z-gc3HC-!xTd|K@56M2rvLn1E}d+DJ%{aYsXMv1&e>~)BIi-Yrz6Zy2*;}ZF#*pn`D zztmrr$bB;qA7>gxBL6)OXU>OT)^kSo+7?O=;g3l8I!X`nH$}dl(u4ep$ZM&*kbfxh z7pQ!Y|3Tzim$H0XWO^@y!Y|m%`R$?dL0&HMLsUMf?g&lCI3rvm}}TO{^fCGs_5-#U?94vy~=`B!4k zgCc(*_4N&r|4!^XCUURX_m0RvH|tB}lVZ=mi9BMq=RU(cZHCAzM2->rZWH-xv9Cbn zpNoB87P(XGJ0kL*ihZw%{AXfcm&iXB`#u)=XJX%Z53oHSi9OedJS6tqB(hy(ugD9; zzK2BqvDkN5uWe>7F?}~lvMg9x1?_QDrUhLT~^8XWi zzAdsY@{dGr5&J$C`5Cb#61h(7n{|Nme_8BXF7kU~-;E-dihcKpoGtd1i%jn?Qhgm3`ChT_gveQ9-!DYY z7yB+K=lmZK`(j1@n%H-}$cG)A{x*?cT*C5~M7~?*zdDiA#NL-gP856pOyujt-ae6? zVz2(NX8coS&~6nTr-*DUgdrhOux5qmxq`4?i( zuSNbRv1k4xY~O&`bG6977JF_I*(S12g&%${+Za< zBl2IG_KEygV&BXPw(qB6-*S=rmU8|nBL70{*(LIC#hx;e&lCAEksV^+t0MnY?0aA2 zcg4Q*zQXyxA@*er{&tF7A?0~U-P?~2?Y_Wn@h*O##Ue<$*8v3FrT=btI|C5!w;v2Ux$Tg1M5 zMZQDq^NGAe?8_IqQ0yxfdB52An8;5!*q(2Sti+yQi2RJ$`;^GH%Y4%<^3`H*^mjGm zU*!yLza**eWg@4Eyv@$xts?6p*PHrMUZ>&*9A? z-)LjGOXNPC=Z+5T3sCr0EerM?ry9(uo>*2_CZUcHp%heTd~Im^$Be8*)h z|GCIBrT(0fKmEM}rMFt-4N`vd{)+zIfWkkN@${tF^RdYEo<4>Do5Aq`M*4$WnJMyIv;T>FGvzlUct4s!`OU;L%;&g$1GB84Y;Pf&@ zzeD79N$*y%FG|Y)Pk5qC_77!p{(20{gSWH1RO)whJt0U(|c>A?-2WsOMS&j{n&z^ri6DCu)Nx^w_S7ZWceMDNBu1C{~V{+QpECOi&>7_!}251EO*?;a`8nh zr{%HyMX_&W7t67iaClXY#GlV{SvJe3FNKWxDehU8??itKsSfQp><^VOJ%!2CO+&*w z$H)(jN$+n^KcV^%!(_)8`3&Z|Q2k$xvFC#^@6BKaYw3 zn=!J6AKcB)F50JgJa=!}5?JN&IFs?A?h^X`#IDpb^3L(6?=^zg?DCh;SHt4tZ}tT; za`8=#ob1V6-{O5e_;-=SVFzeN10GA}F*cnWvo z(+2oSXGvhP%$*7N{q3Z6#rR2Ve78C;dph;iPZ@jgp@ca_&pxu z3lV{9(Y}+FE#66G+mcP+jNghM7%wc|kn79dle+oVOb|!wdX~&`B6B9nuG~?q; zdvBtz)qlpRht2k@tO+&1*RtAQ}DjxKx#hbiqAM@Z&49Gm`sxpCmcGTg)T%%Vv#SE^iWp% z#C&${9?wp1o}YZO%eLtI)XGdq8wCt9my%SG~yHTG7_}XbfV5d>T z^l1Xryx+e!|Jv;Q9DLK;r+K!}*B3T<^Q{nH{tjPGjxXoh{KA}4{9=EYrMpVK#W_=( z6>pkF2~S{{b9L<sM}sQiR`z4?&>brcQBw|J7r4B|0qg^sk)Eg3D0QYBW6nE6|AR%L7~*jczG zuVBx5e4rySIEp_5Gp!k6>YhFA5S}{vDj693DTxVs;3{0@$;P;}dZIBSO;Q-YrvzVr$0}5}qYCg86z0GHcM=a~r*W+U8E4sOQ6zd;Wj>=B9a!db|hUrt|uF*4S)} zb(!ppu};UnzKv974l_pu?%icBaHGFil@V;S@Z(r^s<*QFS^75yK*NKaYAYtE&HX`TP?P{Y9`Wuo2Szk3@nWrcp4E_>_Q zcG;=-7n5~aw=;Qy;gd@9SjN_n)BN!D*9f09G=9>#2~!h|w~4mf;qyA33u3m+_vPea zl8aB^$u78TnJ0^MqIp&+x>qHpdhi+9b+@H>b`_O+BE`Un1Y2L zPbL`;v+-bgf>krz{IN%TPTUWs#_|lhoQala(B)ihc?Mn11j{q%a;~yGgDz*h^d z3~^eX@o|>Z8FZSFlY)h{oXM8UnPfSGF6SD{Gw5%JK}l zobi??xwx>Fm(v+^TCVsw%jpa{;b%l%6D+LdOtxIkB+D6eIoDX8L6e6I4g9e2T4&G+zd(Lbq9g$tk0a5UEoac> zOtL(KF6SD{Gw5%JK}lobi??xwy!dm(v+^TCVsw%jpa{ z;fErxmLx#4$d)tNaygSMXVB$bV|fN$&P2;I=yI;MJcBN0g5?=>IagVpL6dFGlP#As$#Mo=&NY^2(B(|DJcBOhYRfa|a^kBI zl4sE6TxEF%UCwyRlU!WnpqJBfIzyb6XMCLHbOxR9L+MvZYM@zq%b9GsoJp25=yI;H zJcBN0qU9NMIagbrL6#_|lhoQala(B)ih zc?Mn11j{q%a;~yG$;H)RdBw+DPG`_bF0K(PG~Q`BouN*%5b<%r@DQg_BXN=%Xm$+C znQXb7NtQF{a;~vFgDz*H}4s@?oiH3UC9B%+m z8g`TheAgCIa>l>E{OvD(kJrJC*FoumS39*V8!is~hktlASL+FVS=8_iUcQ2Njp<)G z#lb&Q#w(;6{YUB1KOAxR%H;3aSq#vH1nT}C$&>DuFQxpU7v++6;-dB|r$EMdHcD*l&EWhVdKZ!iO;ipUV z=so8}Xc_f05gw`oxAwPz5yS5yj_0yzEj16hzA>ThzHr^hbfl-dPR*X}I*#8J{H5dK zv={AN%#RZFte1e3Yqu z!Zs`&*M_g54JXvy7p^}$u-W( z!(q_Nd*LhJIQ$wud)8-PcZDxQlNK?uru1Gdd05w0V~9pCggsg3yH0%oebO62dxXXtu&sNw^cn4FnN2&j zWY6lP8k?4od#@{bHp;vETG!EA^|=RgZIK5l?*PiZ1^FMaMW1w`|7Y3SlPS%t1zM5= zefx-Q{z>ndGZ{^1&MYjQsh#RReP%WJH$v{S&o}Zv{op%CPuuaiA&hC%e@oanm9ea0 zET4YxU85a_Z+{zo3G=}Q#6eoix4DvIVcQDC$5^~?Bidp4h1y@;sI*@;&d@UOrxn$= z=-Q!!n6}(`c}aU_&pViWGBa3EnKfBdP|eQ9V%jFCmBA6$oi^qyh2nVusgy*&=pT&LWagAbx?du4zXbm1MeB7R zbu#F>z;!CiroD!(Rdg&JhT*WI%?pK|P1 zC>@7B@my%^Yi4No&A}RwHXr+s+4y7;=H4ZjYWI1;zyFaf*-YzQ=wJ^Q{r7(!^t%jx z*rT0=eG8BEV4gnxU@Gb>1@*Q8^|v1NxbEm^;g5_t?VRd$`G50zeNP)-uRjX<{ioGy zaFvARiX`4jZn1L(7T=~~8b4wP?RqtzFW?W^dc)pw)M;!h{5>%d&}rO1ui7ndmQ zzN6T;OxJ(0|EJGw9}4Zm526oKzK+`vKP0_I^tne*pNU%WU~bv+*>es$u>NMDkN2sm z`}oPVXK#lc_TbMo5B&rBET!Fk!_;a2l%x@azB*Rbcd+0vkZ1l$Om(w0_#ZO<(5ABPNnQgNdWo*10 z{cHyMnZ9t(dzi1L>t`R@7hCboxsvSt?^I9t$i-QdGgwb6|CiQN`DN!;PappNe`$ZZ z_}uEL_J3(T)kmFMJ#G45T2C&VOH4lx2j`~<)Ke_>!5#mkC7Wyh!|i7>@be4!X;b+B zi}h36XQB{R;&lqT-4a9@CXrIz2|-oaS2 z-{P~%7_8$1bT0v!&V7t?PdfjwM;hla+SgosE{44!h1LK5ObhJ|&3&QwD#Zo^1g=-#?aTO!v5Wa??Zk|>%&)60{Ywf4*a%3cCMCFSP;M~FnEf9 zKl(LUT2Nf*_iKLq!4fNoM~;vF%+^%k;&orV*sq27@h>)L`FREM%0FI~Dbe!1 zWuYSfF#tk5`KA6q9^TN?ihMplUfwG$2xvv#;y|9)l&ohP4*bbkt^;rWmFD{j0ws=u z!hoaLmtDB4AnyTR&Pqqgp1h(W_26%NkfJXKCI#)&@=HqsjvYQnQDI45AP;}@YpKBo*y;B<^7v2wtVki5$t$rX zFnCM)#?9AkbvUn0a0F0%U*H-aegM}@eivRU!h2GVK(4pIQCRFSUcRQ1(&0Y-4MZE~ z_-^{9CGHEbOl?&o0 zR@^yERgT|iA(_6(2r3tdeBEoADib%hB-0Hp*%Jfe48V;u2cn9@Z~BnDlBtI98#j@V z2bn5TWcn=~_^S^5<__6^f~orP&^>6W!?|6Co=%h@!gFn2HJm zefKCT0W`j~N8!VeK{W)TD&6$$Jy12G5=g&+sp>(}uVWhD!b4TLYaoNF6^*t6pL=Qq zmw|QQaGy&tit+6^P&JD`&WyQVGSzlppF9|Gmu17eMEcQaL!_}7EfU+S2uM*J&5oHM&C zm?{ON_IEK=FA`gcbeq9z@P9ve9Z0{iNA;Qj#)0_YL*$7_{6hQe%Gvl_!t8onyJz>{ zS~;g`4nBl1rybX!Im5U%%x#>DAKS-QTi`Qy7+3y|OYgkCdH4jvc{S%j=fXyOC#LSg zdR%KRti^S7emTApiEHh`x`jwHrU~Dy zsgG%(@7G*hiSOEs#+2jQcX2_AaJ>M90)0 z+WVOP-J+fUNxQ#`&OtzYUHco_{gqnzd$sciwR8AUmHMi*^Xs+qE!z2jcAlfH8~>Yj zE^FsgwR6hdM*oVm^Fi%AQ#%*5^3Q7LlpBry{eyPS@g_c__xm^PeIBNB&^TWQ|2mjJ ze@=ToQjR~qu05CT>&`oHPC3gygfO6gw3i{B{~W@A{@JzjYr*{VuLy0?{Xc=p>ED~$ z{jWn#(Lb!KD))oh`BPeX+T)S_30ix9RZnRjd8ND`&(Xg>;ZL7Kjrfz!e}_N%cQ=mO zPv!hK_+Nic-PWIjr(@3lPu#gT?wp?0Kkvec{yZi}7Y}Ve*Gagd-@Hz%Dd)i_<@hLL z+AHa$z|e_sSKT(<(oGR+01lUK?o1OuDY&Hsc^`G zlc%C&B}~x2|H}6%Y?~s*zf^-v6Lq)Othncn>+m@Gl_({PmZ9a;JS@6gFtIV}lc(Ob zcfEP=ov-NO!*Rwx9{AEBwBah6M<9vbWEEmVE8o(_VU4dXQfNX}n^?%L-*eT@6s;Y_dOp)eqT?D1*yL#n)SU8EsFeJ4Nru!f znw;=c-~@O^yATJz6O^TX;hkzc{}7GWso#f38;pBr`K~)){p%p5FUW=^kA>6JZHtS<5$LF7j?1V0*fABjni{D=l}M}xN` zG0l-cW-V4R67Cy`@zribB4H!puj-9xWN9>XG!h!B6^RB*Mt|{GNv()3dJwuH)wsba zPJBI}1P<0(wUmvEkj5nvIhZJJkPKf|gg^Ylnkhq!$&mk=%2dT!r0LH_?VQvv|D%VK zjT;P3RvV-G=-0CqBD;%}YKn1#yq@lVrq&SyC!1pRsCqf_KgA(ZN=klV(V}b1Ys&c< z>=*65G&4fEp@$_#N8|44;t*eYUwwL#thVu|5A?OE?;dSksgKlJ|VE)5SG>Easi z^opzs6K+BaYo%<*KZ)!l2IWbsnf;(nnR70pLgxJ;D>u`E#bAM&_{bLE$kq>*bw@4bCfYe-4g~IL^n>gy$-$oX`@u9M4Y})e^`> z`3X3m$U^Wp=LFtiKFc^yHDBXKI^PW|v8Iiwh7zX{n3&fRSja-u*P|0{9UsncwLFP> zKEd&u6GtJYbX@08Ol(C}hNW4uuwKNC4)$AEP5)A~V{-X=fP)7(z=s+F-72wQguy$d z=?$%uM%5h08s{g7;~)&N=X1;0H$PrpczMR;)(csU{~h?YB{q2%);g&!>=`{xE$0e} z7*mdIG2)3hwtjJR%l=!HdrBPBm05`IXtFl=@t%QEh#Az{8TV%Ga;noiDq80!7(<47 zd6__5pBLgi$~LAq@cR&f8?Xm=ivzKS{CCMWRs?}{2l=3RoM2I!r<%w7l%o!p7MtY| z$J$=)c&M7<<}fabKi_fU+I@w)EJu1Kj;e7WzOf`!xv%UM%MnZ8L)8V7*KMjQ2HpHn zdWMZRw-Am+6GrU_f!2eFi)k`lus8Qa`9{PGwzPk;df$FvOJ$B>ECLS}E|kWbv!&TA zr{o74s{406cdxXn;~DA1clTLPXTcqoXS`$bn@vYn?Nj0*7pWKqFwRo(sFp?WkJlo` z)34PzEhD%2BN{i+<@;o*E7YTn^CxkbIWjJY(8b(~N7YDZ%l&QX8KV1Ri&*Fr&<~FR z3gS1XJ1@qj>bc?!W(|t4TytniN}QZ11^gVJ8}Q$GRUVi&Wo(2|9jxW6?Mx=c9a0) z{)vp-5)t{4i#4hO=6OAEJIbZy?j2)cEmSrL+DBY2V(ipdUc$EL!55di5kFJdl7580 zU&-W6o0=YU2dQ3_SH~&5G8C@IKW0uKDop8#>%J#A3*nhEKlc3K3mY z{d*?4m^UniOt1)SbUiSnm>sxvHoSo~C-|s0EW?pvc)U5#5zRt~-k)&l*_$c9b_dG~ zkj%5N$!&-uazZ{6jg@60z7;Vk9U_zcTWl@+7rH`yh#Ncrexb1~G_wXj*8ga&i;tzt zhO&@@RF=v>Z|4=Rvo<(TZ)6T2DNL`U1kJX}mr@UN>mG#LF-K z6j&hUg6QNE&`Cfnn9rXf`nnhQ{OAMekwS(wHYHA+J?Vd-TpABe$1<21su6I{5ob+crhz_M5}Y?Zv1gBDXcY`CGgj zr%8?vVNQ65t*pTn%BqpdSPrNCprY$8>f~~v|6ey(mlZpfwqk58sI#oiu@rV;jWip) zhS*cC8-9f`i_k4-sthrVg6jUX&D@d;1}ye)8Ts z%Of)XlW>g9R4hdGI>nJzg~ByQfuZ{{kJ3Mqqg=;Q9Q|Cx%kRRN1W><(`bo!7{Vx*@ z;u;*4ifr`bx?V;#B_W@qI6k1rkvd=i_oxydU$r7CN0Pz7O|~C&h3_t9&0n#>E<+!~ zI(bmFHB;{S4rm?m!hwxZInmUaDeuPhwh885lC_frmPgOE!xn6V-N)(AuX`ro&6IcI znLrtE5nLgxaYTM&f1fQqo7??7UoA{_1*LEtxmD4LlP|NcR|^#p_#{?UFQnH z=2v1F`E#^pe#$fXtRXy6^z}ct`GQSoo7y?04C+0A`)*pBe>nMisZOdpux!o>Yi3>! zzE_wsuqjF?e&O?@(o>?|oo=xcs_cI6M8N_rji>_ihz^;boc5aAl_R zz3|Vf-xFK!eeEl3>Y+-}_p6ZW`9tMt!KI7Yl<@7MZ}4W(H=lLCZezzkKs)Q_3YO0P zXM|9AZ~6-Vi^7TiO30;R=7jwaDmJrG`*%slOF$d_KSCS187sn*vYh^1mg82)hJmMX zZ7Qy9#&KyV_rFJH80?@L7&$Cg|r(#`B3}=wY2f4|;ka zUC}=bJ@o77VJ_(Dt#gF&VvN0acSbMCln&T4{XZ6BY#PVInex-OvpkYhWRG!~%WWRV zLz(iAalf^3L9lg}b%zqCgZLeiAw@W+>-uZTZ=WkvjCZ0ke_9ZgV=*!c^2U%0v2wwg z44=+5_-v$nR!4FhdPuV5=2))vRR7nKB;=xjcZ{A(MXnLv4?)+RiS99E#_+a8Q!@A( zx_QJjOuG4MV9f3EczO(IwrxLb+majea^P#6(w~HFTe2cIhsyQC#sVdEaw*|>*c;~s{MyA?L>AZ*-b*tmOPG^ZZMrU_^^O*d>@ z2Yh}3$Xaek1j;kzRf|uxGqzj|zq2x@83SKzekcFNHoVN_JMeUQs1NG^e)uT3ugH&U zij6T|wLuiW1ix0IUONDv#D3sK&-GE9G3L6wAKuxS@~!B{XK8<*&-0#C^a1fwME`!* zQ~hCW61u_Azay4iq<H}gq$$Txf|O@0F`j-IeMTs~`eMbI`4e%uY>ONSs&?Jm?aT5uNnne!0j=^@C| zb&#hP2lLH^JhgP2f_0FmmT5SLEVV$EqW<*~zW)wa!Y5HCgjzAbQe@MLsBDsoT+R}k z%UANPu{n^tr4Ad`^3cDMrOd}3a&?*P-Lox4@U=~Z?6nD9MH!yi_{Q5;vPxR$$Q(OW zDX*N{ah|6;AC2?Ty7Rn+4#BRRBS%cgfwe^Dd1Y47+J|R3MDz&A`zbu?z2m&qR>fT!CrmPJ;~?ZN*f2Z;Yk4uow{z3nh#{=ewd zGCknufUaD?lqo-)pj;rXoL9({SEAgD@QqSG%;?82(2t0Z61D*Oi}&P3B0rRx34Cam z^KqY#gWe`1d9SXEMPm-QO;&;Nt(@tpJ_tMOUHVpwbc1HEH72;n{lF4zWeK)&fNbEc zRUKuTAGiZ_I2S%(tm7y?Uno*5J6siJr6JO2*P#Pf|bCzfxj{>LuY zqCdm+J-!Zi9N#$pY?p6F9c{a@mIEFp`sVLj^|oEE!o4lKNA=b+$k4`7kgGUWjOsPf z(KM=8q~q=^$hq#>12bHqicF!)mBzZfjaj`+DVwD}W6DyW*`298Q*IHvt`$rum#LM@ z)XHV{cI>wIPQbGjlRdMkopMWBSEXR?YO9cXy?q&|N0nuKtq382uT#JKU_+7p)FOPW+9#=WI{g~`q|p}N8JAt?!SrqZ_N_W zFEjep+W0oE{~6c+XO;>5Xm9*)+)L{c(GO*<3-r075c0R3^}bXg_D1Citsf&N4Ep24 zdYCFJ)N6dL+*^;eCz0)V5o=`#KilvSVzapXQOg%}QY?`O+wfg&e#ftyK(A{r^;FY4 z^LtcZK*=FS^T>io`!2-8yj;&h+tJR8OH94dzNm7n6){xN1y51F|4)GyKx-#cqNq4SgX^^=zhv;WE!cAwm?ST z2pOG~q>Ro?Sw;^)50pbrf2{LixKfbOE=5M)5hJ5}eruO+_*PU$l04vkiG-Ma5%rp7 zbqr>X=k0R%wkShzAYg6FuJ(tDuHh;!sex&+t1*~KO?LU$z>MqlL^71qpy{3{4RX1P&qg==0yY#cQvo_%>-1EU z-JMjOfm7?mxAP-@HohO+PD?1ay|-FMmLH@|7%$=B>s$8&xR zo`EHH`C$W3=g9HAAqG$P*X{D;&l#TQ)?c5b6}->In9mLb!A>Ip=^!QKkt9<^CdIR?U>ZYj7d)g{C^mecKDdM?}^Wky^R@~ zAB)x=$TvoQD)Nn`t3I;Ebj3%uA3l=_cC3S$;UlX^SD!JZtIzCCQ=e%}Q=Tc7#I8#i zd}I}ATDdf}T%%d5+uS?hORA5oSW4@f$jn_715G{~(g_wxS|}a4;|Z+eDe(~A#znyn z^gVD4>stq+zFBFOUA_tL)waa0#B=kt)91z`wz3iBKaH04e%UTpqAb;=zaDVf<=MDS zZ3~o78%H;-Xa0b7kRFsM&-E?L=|^2%pfMhA@{eiJ-|?|0L&i`3V^xPfuKM#DQ=P0o z-49z}9ee}7`>KJ}Q1Rz{e!;QweMPs{pj(sDeQ2^Wwf887?k+7~DTk z-)f{HSLz^F-mCd+(v+iF4eaU=Hd} zVGc^Nv1kWy za`KqEA0QTsVrys}cnj8H^?rVR++NkYHu$7B+ZoxM_${gvVq32Z3qKtn2 zR0%$K6?W^_5gRuav2n)`Lw5`@bYa9D(Ry$sHttF_HqNuluH-~e?BPPy9?nP19>w!2 z@oGMrpQ-U`w6_Sw{)LwzhUpsot*r1_iapg1#Bl^xntT-d7nn%(vaZ0}75Ij+!Y2v& z*1+2)UtmtT8lOks49*u$3_MeT7!j;L?y3mB+@i+*9ola4h4)#V;Vo9@Jj4~w6ADTP zo-wKMA-hb<+GGE7Cg0caZUsu*-`MqmIf53OoZGnvF$44-NAa#o-~Tz65EldD_`OYj2X<@(6P>NgZO`~R z9C0xq(rY&P_ozdOufRN3;VTp9AJ}|~KG58D9L6Vv@h{op>L?SW!8XZWQ;N7t#M|$k zdZKb;9daH_I&62rO!nJ|H)z2@=Y#OY5-CiS|sMv`0{lV$TQSx!GeJ4Zg!iMis zz12aA+iOLPyg~!xRT?PTW}nu!o3&7k=1F`ryrnOpu3U+jN>EaU45AQyO?Ko>-x$r*JvCcujq2Y7f^1-??q{q*LQ9CJH){}n$}hBQR7aOxPOcbwZ&;%`oA{$+ZeyUnK+%(;N%~p;&A|Y)M|Lt zYIxKFkHs1uwHh9^z+;IHk0rokG4P=Hnf5;HNeDbtS*^ykP&`Z(@~(54z}J9y86FeD z*Jb$iM6oq}6DxhneXPqIxH=a1s^@Jo1Ma;3;o?!azrGUrn)Iq#Q&yP-Yd~ZrNl1|s_{aSy#I9fh_o_4N$Q9qBgo@~qp;a&wlfgX3qVw?Ox zGPvXWwPe=~xD3ympTu~kz(>5^Q@-aNW<1YVzxX=vkN@T*@J)eV41DpOjg}*7F8Jg> zlkwvl^c%^+m8{MsKWYc)cRBFoabw&^LGw_G<0b#WDZ2Cw^Qt)tKil^35@%$;t*J`l z`4PzFov__cYgdk--V^7jUPIp7j?V>8Tnu^7=UMUdCd1ZIza`MynC`e7C_UqB@+^E~ zd9E=$-_}-Xtt;nB1GiMx2=eQ~JpnQAwCfGd&e#zs<^}~X61Gkj)gU3^S zQWx`auKbMW(>zc%Y`2tjsdbH~`VND}Qo^hhn2j|sOARw^j_~R*-|!kX+o?7i*PV*( zF+MMQCE`O2+am?r!{w=751aQ21Gm)pRm1HdzJD})eCqyZ=gjW}tUE!YYlqn%%8-qx z%Eo#Pw~q~*FE!pSLfj$N-VMG!$9xT(A2)D5_kMfGfoTTL=NxCUMN3)hy@NLzHfTzI z91XXYWcDXB)=ST5y|lj7Q$6`Jh|N2nd}h`*>{)^MUt?aG;=B^F@Fxatso9>;)$4(q z5sR1H{(*e$PVoZ?S}dM0eo6>B*s$Nvt^Lk1|F=1YY)sYOv4U2o>%LJo)~=vi)*>$c zR(y~7+t~Q{L_ALGGT|Exx*G}IDZX+cFZ(yZ&ybOyjf_+v=02Uk4I3*a{MNRS4e_n* zSqsj;TK6sG6wJCeKIIGv6Y=R?hNXLT)>+DXlj!iYa*+33E5?SBO0#c|Izh z$BO4pOC_gTPZsv2E@ln87^?}4!Z%XLlgI0!apZXcx1&A!Eh)JnwH$%t)Et47XD?`D zAyIUx`PsC*_a>ZgS&|Xi>yYXTAU`F|RVW9c>sm`qF7gk`c=sxNJGeL<^=6Ep%UCEt z`&O@cWmawD!?WC!4+`IuEAK#i!rYEBr6{uu$1mfEHmI+B59~VBb5zVP<=9}4fW14@ zS@!BNO@p6)4|rT-sqv%!{WdkX8I_~=UOBLGAH%yV`5LvckaYPuoygBgI0*v>5azO#b0 zj5+*+C)7MZW0d_3sGc5E`SS%^SO*iSKFYN|4*Ni=IRIDJ&zKqf9&)K_{f_i`fl5FA zMYspr8;f`P>0iT2F49(k?Kld0SoVGxIVz*?KyB&Yp*D+!j;6CvLpWTZV5IH$c`wdi zh~u5$t;6xoSY^M?Q+Y?do+u}vG%6AAsO728oOjyVZQucQAJWtD(J|~3vd2VxMD?iq zN4x+Y+R~`jLD%|FhVKV@41Cw8D}Mm@IB#%1VvU_9uSeYL=(q^h@Z|G`1k{OXl-6j_!R4Ie%e)MCzb-fqfEE@>z%U--4^} zK>4nTP6!{!-yzE39Z-(wm)E2AF&BA4*@g=2dr0^F*w;ruTf0#Yl|4wg#nC>|L+f#A zC(%7y!&(BBuo-Zj@^UNZdnDzY*L48*58|4V$5gB1{x`z~FKIl)%aIRG)w!yUp?$Y0 zzxHCZ(~i0iXu3yfKPc^V^Y-_o$F^Uop7VMS;Qm2eQ`=YT{wmr}#M`&fb@ZzpHX@bh z_AKRN=Qge5BS|hOV|g$1NxkjuR)r^3K2vp;56^Dz%jo5Kty}-wQbT=p2rT4)T`0l+ zb7Zhk8)8vNw^AgTxgw)iu_3W{b)khd>^W+w zp}tBM)?2ukHAo*=YAhJP5`nc$T;UErj`eNd5)t<9Z9$S#0pu^Hy~Vk`9hD!nr&n%d zU+Z@@dxy)cSerq$h1yXkzfWV29PYjzfytCR-woTXiUp_N4&EdhkvgJu%G*|-%~$BK zo$~E#`-)Lr+i^}u0eh9xk!&zJ5>8&=L^te)nekiM*DAMDGGl*p;1nsNN-GRO3sUN%#^qyN9F^|AlP~RwL^Pi|(+#Xp9{UKNS7T8G-F?|0pumFKwe@OlZE9Ftt-5XT=mp9CQuIg$}W~odFd;< z82T!t;Wu*Cvtqh-Ev|`OrhF===BhV6mewV#F?aEH9Is09i)e?-cg|1L&gY4?hRbhW z0&M$rKADtroM*=FW8U<#B-aBoZu3k>{ZSi9-S<_5yd_?a=CCK5Lfu1t?WKwD@%cDEs`9%#=wX2{gUk@2{p0!G)eL{;Nyjz z%3u#m7R-6Hc>>u6!|owVdj?^DE@e&t`()s(Lyw*|zAA;B z+-K_>$McFmh`%sj<8vgbR+7K}r?9_*A!}k|kO_Bp z9PZv(lDrVO^R*Z57d)5y0{lLiZ{%)Fp2v)RG}L*oALCmGUGl>8B>2d{cSQSW5WaI@ zcb(QIdiX5R?`d?z=V`AUD|Exa(?iEm4s4IoaC$QIYv3F64Q(p;K0VE#-=TazlxH~J zfA2?3Wh(goLo)cLFc%wAznw?&!2@! zg*p3>bo>RB!?Y)2r6DIG-&*!pVy(59Im-}>S8QgZhO*UCq2Ur>ybp0&r=8Cka$>}C zf-rtF8H^1%F*2V7@SOmBKT98;u}7r3N8}vHX9M@{*KO?h2lE8m`niIovmbH2sm`xc zk=b)$KmYkNrgv8|dU)eQ z&nFsHa(Myk8$qL|_0t(x$N1@zjme|fp&rOnj`hDKvxaS8ea2YVgRbuc)`rd+IyNYv ziwzx5YCJ+(x3aeoi@*%3yyAu8?6Pf$oyY*$aA`Z#QsDmELGC5p`cXd-f}c z>oe#sH8~f-uh^b_pMhU$IZTVxy|5Mf8)weG)W9z#{7P#*)qm7|V`k`z;$VJ z>qeq0mVU{=EhXH_J=O0S^M};r+G0<2n}Jzsn2|1pTw8B3_%jv$ED>x|G7MTviPq+s zTdRGDw=m`ksm&FvhA-)Os{T&$CCvkF7lTI)-|}a$j|{MGgAOsUKKED?U0-kL>y&g4 z_bsbFtI^qG5!Ykrq15$|f?si7c8{?hpBnwSuy-c-_Nfv>M)DZq0KWUc{vggm-FF`j z7MqibzR^up_t$$o)rAIqrbeHzmuMc?3qOsa!_U1AC#+jb4Xn?#EFis4SpOo!(D$kM zH>|~;>fdAk1H(p2%|;?xn{4>HQ`0@5wW$WJrG{B6a%EsI7lS{O=TGY{Pxa3X%u=H> zV0HsAGi<_hY!kXLKZNcOuP}Hz6+5L=!|i44XKT>txuwy1VBHBCt-8{n(Nt)ZrYtvn|B+lm=V~30>zMwD2Ct8p z*T+lQ|Bf|l!?sD?wjo}(mV2syV66FnX1q?A&+}mY-=NtM>8CQokM^0;YKaBk|2Yi# zI&%GF&%V^aZ$!MV+Vb}7KU{9m-$>~1EhDDn4CpQ|dxk-GBf`&IX!v!{b=+7z{A{K0 zvpr_`iBh6bj+>%e@>%xZ8TgF|zs;8zIyn`c97A^@F}oG>7{h0gyw4&AKjhT7#lUYw ze5=U4kS&`T^XPLvkB*^P!JfUvkeMT=*?fEULIb~%<2TNpEgJZxgr5?-2OE0_)@O`3 zm2(`Yg4n(Fk+^}vDPK3%#70D`ihdu@vLyq*k>e+fpYqZK!#+=Ce#2$u!xtE`@|^pA zAS*i|E3*t5O_|57rf2W%E;e{ORo=Fmy!YM<+!F0M*2p~7jIk%(^NhT{;mz=AoG!1g z&epNEda5r1t|PTC`FQxn+|K=Cey1@Op44PQQ8Zq4Ubm;(S7eOE;LW0MK8xIg)%Mr8*if89z2#FmOHYU}v7kh1gbieiLNnlJ?r#pZSz#0yf_J6_gM0K2REU)#E@~*xau8@m)X1A`d>~f99@$rf-mtE*8H{YCzP|3RwKH<>p%>DCSA(~I-Gq%BNa`~!$E6P>W zj~vv&@OLTh3uSM#{?fcdIiIYak90k~)9MPfn!0D#3ZB{Z78VL06G9~`a&!72yZSG$ z^jU-3tD)nq{g;bA>TCFEA>{wxjJy4tg%bleSNaAkD}C?nv9-KbeqHdL?DUrohdnum zZ-ty#mgx*vW;zdte^z~1Y`u5uSJ>3SO3~LGay`GdJS{kHF`E*;UGxpW-kt}0+lsxc z(aw5~!%%*tUAv@H^g(wDdFZ;a=T-n?OnVsm|5pfcoTcB0@_TtKFAcc=g0YsVu#rAi z?Cvqj+;RfWD@S{(&CK&UjZe=xobUfFVSV&R7|YxYg_lyr*)OWt^-46Wpblvo< zC_iD~9g|~`X!~s8T^WbB^fOVO4!qkcq~5onpL4<2G#V1xi{m=`#DY$GPI>kM_1O@fb)&omyi3ztVtC!;W?Sivxt>Anga^`)=nL)^z zNeh`GXC_sq1-C-ZOj^WZ=Jcf#(XX{8rxpF3hyKn(f6KzQj?%ETV+`z^>3f-PV1mmz zSFn^)AN%WFz7q7w|A?!rFROcY{{+0_3>KQO_TgE@Yag0bw07;Rek;mkj?IC;pj5(h z4th?xmX`yWraK=UdoI``=Yh*yA;&d%=f+oN6;1TaR^&VO{Uv!HD8;=p77BbBM__go z;}D?w3C~se3oU|eD)p5?f6zG5`1l1j<93XT`?hXp6$?(k9r}aDQ^GZ=BWiz{fx|

    ev|-O&%-F#z3h2)d&gx?^(!-7ybz!u7{IA+vM<`lBBD zV?FdoiKajLp+DwAe^{VD(AN6ld^Kwl=nfBb$H&9iwI6GCtw*OfjzVupTY!5STOe&= zzE8jBis+G^Rib=bF8FMMxtH`ljRV&)fggzSS8z|^9gXjZceaD?!j(cOT!z1E1mzk3 z9Q-b{I>UP`&b~bsjLkUcp2&7>Geb4w?p8!_24%? zE}bJBm$n4s(wc%!Z`F-W2xHR^+#PM|_&C~_FM|I)qWn<~%ku&6&_*HTy#O++#MQA# zune}|E!KedUq1?*>mGLnOTi;$f^~2)V>JV!rSmJ0nFY8%9!GkP_VLTjAJbg>h%2b@ z={S{dB=DLAe1^Qa4VP^5Y*K7LvfFh0#{DG9c!IZ&rL*kN#&YmP10>Hrxn+1X7Dlk=-$?} zX%UkK_kS9$xq_~vtB-M^J+L;(D-q9hhLNw+HDPn<=@~M?{@((bl9kW zmO($T_NTkLiqcq@oA&BngL+LYT;7E&{6rCC+Tuar2VS(~jcu0lE^OxQl%kDEc;`FO-e$oz zSR}9-;%86V>aNGuu->Aym%9#$nVqYJ%)!NY9~0`N`z0a^)l=VWEc6D(kJA!##@=_v ztQ(y0EwP5i^iI61!tds&t}Hwb-N=~2=S9$~M2p*ZvzC%Au8uN68r)@KHAH`~hxbm$ zJHMKaKH{C{Z!+&B9O%6l*X7%2$Cm^s-6O+32SvsXAMN&Xy$RE1ZeGLuWJ3L$jFY;aQT~6_NFloB1R= z##2&tHyh1PSR5{&wYwr{o96NrZV(k&Vt1jQ(Sozk&zxMAtb;7EIGArPWW1%@6s&`c zw@kyiPQFX9Dg3~z6>}DEdU;1bY)c39PZ9Kw!iU)^A99|rS|G~7Y?ikj^0*y*OZ>>? z=;!5KYw2Adxo60C4PdN0NS0k19nYq@qWn+v-mv$^K)=6XVlBt;?ta(}^!_HnlXC#} zIbjgh|IvGEr+KR1)$V&67X$;%(YccMdQsj&buY1>dEL7+dP$bX)L$ve&8R;x6*3n0 zUclV9hvWf%)0~3rp#zY8v?d~e&-=7~`gMJ5Di`GkwK^D{^P(LA$3GOQw2%lBT0i8N z1gO1y7t}M`aJym~so2mw@SxTQKQJ$Lda5rqss657%n1ok_a;U6WV<&-b&oV#l)sAp zkY9|-?Vl7=c7eXE_Zm^2PxzwGwdhByz|^_Ereh$ZcF^@0y+b<2hyIY=4}9FXug6q! z!v05{if$CN<1aKF`3vUz_SSF#?_2ykRHHn@Hy_Vw*@8RsY!<(Kh1@%jtx zwqAYv5#E3exu5fMUq-J9b^d}d)Z_utJ@;*Rm_~1zYPA<6S54{eo&0?YMdW@y0>PXU!feS&;ud$AvZxfxf5KBXu zZ?jO(cX6J^T6(^V^9N&}QQ8~Le1QU#F{AAFb z46>KxR-ZQZbX|Ym4f<%uwJjLG{WDbz^q4y?6y-VS8?~v}lYb9+HX8l96YqmIEk9M; z+%?Wz!+EbA`c8ms3d3HBAFJCjR*HZAy$WFIayD6+O!F0z8Hw!FsD8lw19Vu0I^*R* zE#86no#d=STbMtJ;LS@&9%(Y5_9oYf{qP;KhuX4gZ(=9r07sHXMK`)m6r0&7x?Xf6 zJK<2}QnmwfDKb8}qMQy46wG7d-(TE4wwJJeSM$#hk4f)idAC1TdDBGs8N3tO4dEXPF?y)S zEXq&fo!SV2 z*X&HKFOY#0r$x5sTF55SH}7h+NV1K;tM{l$woxDOE+l7o>q1gNu~o!!jt+*d`V;S2JZRseoDLA8V>0e`1C@4*!%u6&+Ncj7CN{` zRCEW~>^#2B51v(?)9jLus7_v&c1`~dGckXU_b(~^fRBk}0`;rV#kQF)H`kCqs_-^; zq++*Na||{^2tFw19&zVIST85p&TaKJ$Vr9wh$nP*GS?MkCllTCF_qpm$v?rEa64RY z$LMLa=YUCm6y@5ofI|X4=;<@b4^cfPyCSoP;+LlVCiy{>+p@mAgX$r=qxaOe<@TH8 z29)7)<&N>H{8spScGN%0>5ty$`zXWtPfwe>HQGES4m6uJ*dUXXIOyk1)5=*(QXK zVxQn0pQSoAUZrcdW4&xC;!sHTYyllBI+%C@b-=l?;h1LM5RED_lj=Y@&L4DbE$a9t z>hPfsvXi^%d7_;a#5ZMc5KnVlqxP%n$4*o>+IO0ljf?2CL}gVQH?=bVg8oJAV_Nsf z?VOkwwF!!TZ`#Sn4Ra8T*|^RZ3RH}!{{ecx7#dRNkMyqe{=9w@@T<_xFAwBK+hBW5 zJDXAG=LNGpcxUCkV`xhqA5L3DKT4Sp(MRk(l3{J81uv1ULgk7?_&pkL2?lZ@r+(y_ zeXvq$AsQy0DB5k>Np#HM#|rGpP_C0+Q_d^ZbB^r++&_qGsvJ;hN(QbG`K22tMNVLh z6#o)rabPXlei^={Dy$jX#E9M2^nXqAl1z;E60!HicGlZo5#=*Q=Tkow9x8~~{dyhO z^gEMWjptv2{&~TarrNL~+p&GOxtGgO&RZcx2de&mlB*)t4!E7i*9D+ctJhx2b*j2X zM>z8Pgd6?w^*)mG`!(6W9k}OS!a{#UdE)J_{j<1Z-|xg7%hO$?rXM}qPyarA>Fwj?QmJA&>Q-_oyKN~sh7(ldKa|)k}03% z96%jh&e8SgImt1VP9pm2A5HRK?6LmQw%tsjyDg9C=er1yXfI7Bd%xf8FyMlaDIGSkAgyZgX*z!d4>Ahwg2M~8sktuY!;1Bm!q{B|3 zvgztGyVKNX8q<_#$}M8owSo!d(zJ4ES~+uXN29rS0-mjy?3qpNlv~oeDg|>F(IeU2 z?WP66XF&th-!#}{`aV}ZXOg|>Gncm<--y1z`*93Srib7^Q*FJTi(%VC_btZw5}zir z5%_c5R-iSl0M;8Reon%ABdsI$Z>{Pm!+Im}V+Z(gE_}T%ZLLvCajo%eu4nQ1l>SQ0 zJFrh;nZQCc*Q2$p67XpMkHkpa1g&Ky8{WjsJ~%X+vPdknb$pVkt2+|b{`nxd*NU>5;nJx_Qa zH^~QVsvR~QUPa*X68jeiFU97A42j3f@vupL8hCNN7B5SV%_sZ3pp$H9aSG`+Rfh0b zEG{QV$B7P4^|dJX7p+V}{O5otbuy#h3LRon;}gzbnepuynbEWY_CGLBh|d>Nrml{~ z=N^;%ftBTP8$Lj&Yq8!K^Stgpw{7`-{v5aQK2PJNk55WuJA8Zwc0)gGu8v#8Y4GXC z(7NLrCV2*EosZqHHk_Z>l}ooSM%;@U{R8KAiseK$bg3)E_JvGe_#0g``wuH?N6_P-Rx&yF>Fj^&%f+3 zBWBIa%bABc?ickNF~qb*FtZf9IuN_NS2|I-uP~oA7&xiC?}rWc7I5Nz@nqK7)17K?qrWRf2S_Ma6$kR1AV#07ko?UDa8MmNBhLEl>p z#eW0%&ccT8EanL|>%isso-Xb?i$Q#6aR}d8ybs^_VZ`!>5zGG`V)@_G#qz(0SpN4A z%l{huZ-**H->(pVdkC@oOSNw-;&Wmk#<{Z}{>h>2?EMLRp#Btmpd|O^g6~SqN$}Z? z$@AIyu2+)vF%!OZz!!lerg2XGBkY0S-|)_$up1&4X*L&o0O5O2GW45*Ejgr)`+~|~%9rsU$zXh+AtOd2Bjy6%TJ8Ig zQ|31M`H-RGMkFITAR`KspfOocPy_3c(YYS$M?BTv zGq65qI+N&noA#~cu=B--4Y|SPMk={ixxBVKGmlrNx< zf399OyFHXou9UtD;d7j-96|11hVO($#E;-xI(#?MGG@ifXRkK!OUdry`1!HsW6<3Q>291o z8#!DJ{D#?Yfq(bN{Qxw#DrMY{V$W_d@JoqrOJTQH8knVonRPMtelp}-N|+I!(!5;J zuR>n-bIHU87<0ulo-0N$x8!BdGcZ5r^B0n*>mzhtIOQ;61q^#Ad3%WCce5d1Q51h$9 zrTta)IUS_;PEPY+zbzg=5)hHk7BM5m$jeOm;5O>+QEbU-ku@ZWEpdxK+obM+iM_m5 z+#d{F&X5b2_9%+hRg~tb=KD{rLA}Ujs^qlyVy|Bw$3n3yJ;+nP7WdKq2K==YqnwgA z3H@0l<_+@p9mw@@OuV2oaG7U0y#w`~@BbJ!*ZiFOB95|M17yD+qb>C4u@Bn*+vJXHKxr z3>#oQ_l1mS**9TtIRn2GY|kRhQ3XCn9W&+RNo^k-%GZ+M8v$j%3FI@ZrM%?Wk6@_0 z{Eq(#%Zok^7i>Z9^4tH&riBlfSF9e(8oEDVHLEXS4V1r2`F#;<*oA8j?1QusaT%0P zKayKfmxEl*Z-^Xxr^yw+MVBkS_06!74_&|Km;24I>_oq4KNH$_!3;j5oc6IfFAF-i z=ZZITUgQGfdD5%qU_DNkC%x(qVR>wVa*nui z(tm~JER>7nI@94XR8DqpTu$~tZ&*I@QMlkG>`TXU$3}AQ-^PBV^xnXk_8odX2Ww-L z2fiJ7z@z}sEwX>bswLecINX=7_HRR(}#U2CuH}&xH~tJKb`N1)83a8xkmN+i4Gcb z)tuuMxoV$Gxk^3#x!7Z79P(qYV_ika7gtMV`_wi%@b3M{pU&wgLSK8r@_O`*>K0D3 zcP8IA)8k_`UhpY&V#tvJo-U5v<1)}4mhVHIJP&4cp9yX63$&Feuc>~Y8lHQU=OoqN zJ702So=FZ;Nw_^W|KLvW|7kGic}DfvlFZ?Gpieg@2JVzI{#!A)H+6*NfBG<7z-4_@ zj;Qn~o(Rj~qsifEVviVj?#pua>+;J=!q;Q) z^!_L;Zv~!Qc93nN*kEKo;9GNJj}GKUhfKHtKGk{IN z+&%jJ3OEj$zt5ICL%jI9gjMLXSt3ucp%Fez7=tRzr`_5Hq$rw z_~uRd){D=Lyx$DVl^=u)63U7%1-&*X4 zhJEvt`Mb8Sx4VM1NIzg54(L1y`*auH!km80{b~P1Q{28|O_iAcQ=Jvq7Z`r40P@!l zwI4c{MF+57DcLHDKjPE!(Eeo=zP_?@<(&7m#}$_U9`&B~JBAeU%APG>HLXkZ$K~%G zK>prA&tCy@z%Adk-Uj?_uQc-HQCZgV5Q{(Aj&Tv*&3#djL9n z9_xPH%8q}4^^f(A(|kL+D?wa+cM5U!-S~#jjWLZ`W0Ax17~oEOsxRYf*F)sVR{V|J z?|OmDHBz!8>rQr#CrzUlU|Zk@=c(O!nM7qSJsM*g_Sp2*0{71O`V z!t%4IgYSLH_m)?94)4a_qv_JHyb0wTmG~a}@DH9)_t3>Y?C8@m?A7SMMhNwo%AXHZ z3L$LVt?dOgHnQ(xxZXJvYhoek70f+|uYo`HBYy8=g^&9xos!w?jKAmp3$9D2Uf*A+ z$_U<9M^RY5n{dHcDY#5l-`O*r?V!FY*MJMPPkT=Ws9(F({fp=t?Om&mvFf9xcN7X$ zzwtuwT`u^J_RWlc4za+UJ&=jvW$=FjkHE?bpLD4edmoOS5?E>Sv4ia9z(i`7bp_t8 z@by1e;j<#wwTG6&UvVt+xPPXd+ES4Ce^;*Wm4?>{^v}-uc5yM=r8u(TpyStg!&Zh$EviC z_X>hGzCI?rb2WIF=%_ZA?fi8RKIBm>REqUS$d|p-PgHKi{thjZPORFuwTA6PfA39LpsQL(X5unf+a+_Y)N1lnH|K5x{w1-@JNZQaf)7My-N=#wy2u%PYvmY<||KwlG$FVD5l$C>zx=&aSG$xC2N*Z8 z;`{Kn?G_`~^)du|A_s{N{|L<0{e0E^eQEvB0iMGe6yzuNtL3stvsntNMLu zuUBr@(tYnQ@97}hmD_71`)M!R5caa=7(0%glrP8oj$y~2C>rGo?fPKVK6=(-&uy0M zW16>uZwEw6=lq9RaMDy)$7aDcSY%~2k3F_1c;%YHU`a9ST`kxL*B};QKHi~#g_U~t z53E${$s5xw~YlwWxdHZfvIi00s*%j>~j(1AS`C-D>Qze#jLW24_U-qC+jei6@c*&fkznoc7< zl!%5oeIFD>g|>nl%R|fmauV`7x+X{RQNJH_Z59iy{x);2HZiACPSb;bYkE!+3L^TA z=6H&2N4SChIo-S8IVslxH=-Fn7T!jiI>)K7X?r)5?S=Ks-Bxv;vW3=PEnWUOSbv2b z)>mnU?J^ejqiXx;?J@VCPs$5Wza`)GL|G;~vgYlRHD3ya3osv2bWl6SlQ7gj)AQCz z`C2?P754Rqi2Lb($K@-tu*n`Xt0`M&Z3uvtB*f-Oh|MWLY>pRkMPA0_si2jw;TbxY z(%G=_PCtQ62|tnE;GX)^Xgt$59#G<$cr245OVKwqo=JT-eVh@s({q{_CO2Y<#-Oin zm{`lHF-#g>31XNwn=Tk^O=mUZ@GRx`;dSt}ETwI{Gh&WNP}$>J(JrRMm^y@`7I|_Uf1#A&DVB({I$xC;G&9-Prg^) zas2Lo^>&Mk-pBXPf%9>9Ivx& zFkG`5Wh{7(XqA`I=VBtfE&}#H2fZys+339sIpZnP$!k+`_cQkY$RQY>wG+f`<=Rd>HrFVFO&juR^@(Z34xvmE34FUok*b$X{n{dd5Yh922L{kD9| zv7G#yj;1~ysdfDB4!(0V_`K%MWOT2c3aDp^bF|i zWjs^6t!dNa#1r_vYulrn4hz8<$OXEil)0RXgh@+xL1&l1{)G+PQfg)`a|O1;mhYN* z1ODhbY=Nb<(BIR5!xGp-)bFBnCO5%Wv99WN&K>W1qFxNnApKpR#&+aU90%H`dBKy= z>r|ePg@W;M)=`M@qw6$ZYgNWV#e>EI^RpVlmd3&anezh1;uz+WZ(uC4(FZGR`hnx& zoul!a^wd~oTnaEQD&Hz|K(YM!7cefZ%DB+IJj@R?8C5@h=6$%HcwE%6!x;Fg7@Gz< z^EpPloNoNq{9sN;p6)!4IUSPASD3~oyGWKxC~w!D+m+|ly5K{@v+D0W{I1p2Q;T{o z!gChZP;X*2jv}RwhDYi5CF=D~`rYbslAKoh(u!xEbvY$bJAW4E-sm})DNnix?PzuV z`-yOkRD^S_zO8hA3C>Yx(}}Pw;aCV731n=(K+@{2qU+R#R=09aZFtev6}tDl0`+`J zcm5@uPt%=G!?|DgzJ5G^PxFNwN-`Rx9G~=A~=VWE1(DHYS{3a43aSR{l%VY2Yh)n_Jt3bI|{F0 zp~9JvgKn44qRjs-R>{qLk{vohf}FtopN(cGEDo2?+FcQ}5l$P_`M=$TIz|i5Lg2&a z{_9Y;#ld`Y;U~0on}T)l6Iy`hT+IC~%G}?wUb3@L73Sh|Av-dgj zAm_XLH5oW!UYnxI+Tr-^~*ciYbv%h`Klm` zn3>IJx)(HQX4CldCD`M##KIQ9W^3>QpL~q{aCM;V8Tw~oCpHX1hUG(k5BFR*W78S* z?unHZz@Z$vVvnLHcwPGUV0e#4ygS*!`to>(ybo{wzrYYU!jDIK&;gn#(P*M*+Zu%? zYOf;MSB`deD{Zh#5bp|I`pNfx3;iUZZ4>T6m##E-oDhYmK22ABWHc@$$6tP&1qrv! zCxs4=m4%*yOx;|{e4C$V&boG22iZ8gK}XZb$C8e*gI;i_vrq~8c^}4dx{$y3PbVuk zS~8$_;Cq7ZfbS_k;(HQ-8}~gqVY@laY=;xWCEmFL?_Lg@>lH8InCLoTQ~+E5 zFR)X%?GTT*WOjuXr?VY(ct0!lNF46JdTj*rNuZxmX}_NBV>4K3678vrB~tz zSzJ09N66q(8Ar&9QYVfxah#1Kl| z#yHP|?Q&SON9s8Q-S!d2X{*4dQ9Cx=zq77>CY5_F9F|v0Y;rN49~7F6TtTvq{A>8~uJ) zG<6=t-y;_R&pS0d?@{r5_6p#M--PEuF-^r2&nkHST*LD>DxSz4*7B}sj?}~P+yXqQ zoeJ2AmF|X_RBjLOoMf_X?ZddhhRo*gvNsg2SqD6+Jl&s&cOYAu-k;-5xDeh~=*FgA z0KX`9r**J?&H7Dsz{iDhci~wZWEs9+8SKNgs?h3viy&j9md$U0?m|T<^Bt7Q#Bl&v zPa=9_@NGQB8eDkiW*eJ!1@2vizhY)@E)lYt^<@a-mj!9*z{zmUq%@av^}ho*{N9Rp zy7A4sg1<(6M1N~A26puMub{~_BHQsEj=iAYt1o6bW#1PXu0&g9_X-VdIA&etno0Bw z9ai&W8_~dM1^2S`tbyjlW&Z%&$rtcEa0gFZ?Y?3r;rCZDE2hpzLC;4)&+ntHBWR1- zd5pIMEJmT7FxsIu-$xs29it*;U&DJ)n+$DGo8W1s&0V;@2C|Ue=ht<2&b&%%|JNAP zD}d2qvAFYBg1z}BV0Kuvbv}ZH}66}=^1M4_b7i1_fX%CGSu-Qev>})u3e`aRno{e9zT^*3}btv`@02|tF~zWy5SDbH)ydN4*- z<(n((-V)e-Wew8c6~Ih-4C^A07nWBxZz{W#9U*;7_z*8(zMV%$s%Me~J}Zms13ThV znuX>~C4z15d_iad?cIC`^R{9f?-GRGc8lwVd+_J_dFxHWKeXMnR4}zXTFj0VgExxk znu~p({k#q2(0Vgtmt8zB+tNHgt^B3hRqR5{6H=``?JA)ph-`vJv4h_qhvBy*N zDEM5eBW$pq5V4J-HjA5V!Mmb1-;ib2B~hj!S_bq28!XyR!hS7|_KWbf0Yt9pC|d9TMn}El}y7ewX0AEen{!4|Hz9IF|{+(vsh-yTFni=V~j9$%LkegD?jg;Wp8ml4$=xttcPC15SKeyBPUjx~6I z=*2_yQmV`kkEqW_>0AOo>gjI3D8M{rdGtqfB>p@8m}uUn%F*1VWY?(t5j&?*=5>U# z)~{CB6iw(?-dC^|Wy&AKdCjsPx}NZ)R|IK}^S|Nn)7|hxybRwmts|+p$JUwXT0$%| z-f4wQQTrCfK#?grc~Ogg5nj0qTpg>?whR5LMV|)HpQ4k9p)%zvYh-HM(R$*~6JbOc zlrc8g4UC#dmMQJR2S)PFggIo~HBTHyWV3O60_YDD*s%Dh?>a)vR;cvzSz?xO><|;k z^}%N~b_x6Ov%i6Ukj%P~HMEnw46m(ThwqF@7P>(@r=#O;jgALFH-5%u3`NKB7{}9f zLToht0$s=ICdL23b|%}mezk8y^4RJ6mdLOEG1f&t#N6l@d`sjTk@#G-9J;~`pEP`E zG#`;X%vtyYv7<1LDL(4j2@Ek4QNQ0ukV)Rh%|UlHY)CEs$6d{QSVs*}3{Y*Oxy${0 z)c5Cp9=@w7n76?1LcYJ+>Fh+^y)IvU#hl>MAG&<2b0j79=g#%0V~PoDv8EW`U){Z` z@2{>RL-GC9{V>+|=Z1gHJwe2}WkII^{lH-J-aml4c4q~fCb*n+=x52d#^xZ7u$20_ zuHNOVL!Ug4xVjp%x@WJO0H4J5EVQKYN3#|;J~FGe@!?tPtaxUXw9t_`cB=A>a&E_Y zp6+}!&PVIc^A$HyTm<@g*=U~%&IN*%=Sj)8GLP!aU}2EH?dIDmvIDcO{kyx zDXq$1Xc25v>(I|8dItJiSu4Raip}m!U+CV=eB^&gnmQ&X$#BQwsyoskRP(}TkOaZ%-?8D=or=!^3&PQ zFxGa~eY@M~z}m;U^x%v?m^{@X)GwjFGBJO!4RgD7=s($GGqydsNiun!C=oqR^oQU7 zpcD0P{eo>h@vJ8&J+}DFx4Zf~HYa%=0i&58^ zDBel+TmHlZ`owxi6Z~4^p|8Eyt7{_sIldkeU8kb;kTH?x_3!d(C_MdVzl85JEunD4xtaLF-}V{PD?RP&6Arq6{5|VYnnIJ>c$Cc(w#3T<1|iLE9Ab%B5_PJ#liJy zYkxFm4`PjK1;)=IUeHW^rS|=%*m6C1&pOar9q6!fW5BBz11e6WAzVN2d#tl zJYF9Bf8bHexOpG6Vg9}d>s>UDZ{7`iNSsuqO?iDzxwD>*f5F=4 z&lLY%PBZF#6m2~=+x5ivQU5!rzsTbH#APY}a({Spb*nJ<6N(!UAg7Cwe}&$=53-zO zA!LnDLc9HF7q+vK`=seAmoFeXN(;x|^FeK9>~j^EBlG9jl`Q9@O4bstsmtqAwDLU57MZ4?Wxfy-Y)#m*~|u;XapMJ$WR)QN2*MTa84UvcLK1 zyauG1(p1bdF5e41>>a@hwqVU;FXCs!-=@NLBCpK4nPg7mu!#I$n??`zc)j77bh-t3 zZw}AMi-yM&hW*;Gnyyv)ME-Y1{_hP4;~rCfv%(g?I!#UU5Dv=Pew2@qDA$3y>#B6u za7n`KUz-*`y&)`F7Cqn6`kYyBni1Ahzg}hRJhp}iP_a{$y{oXu*S0qN4z z^HdFQ{62ML8&zO_Ky2r>j@URTquWkeV@(q0w%A8-he8va|eO91bSB#TH|6|0n zZDdVg`7(4uX|Y||I-k}Pon5w{^}FQxS0~5Go7dl-?DmNf-y~W;b)M9oe4@^gHNgFM zi68pP=0p8#gt!nYGE& zcHE}ecEy{T+IcoLw#OKov45DupLFIpJ!WgmT6HdC(|-tKM;qIj+VAn6BM+nfHp@y< zvM4Q0N89^_^Nh(Y_UPwB%>KHX+&o9V_H#4ZU!k8LfAn*^$JEa>{m}XJ;r-CV&uyM6 z3nbI?eLsIUQ(PJk$NRZ`VsdNxZls@^Iqk9Ejq-Cdr@`}Wj-T5zrZhBuGuF?|?62w2 zOg}fX&SDQ;>*r>Ur|0V%{M^iGZ~W>uKer^4UYfpK<>%Jb8$aW=5l7VN1}Xw9=0hNoeI%4mw6TXJub{NCZdFh`pe`pW$k1)poV?r=z#u|wo>tg#c55>8Swb=K5 z`J&?~yH-8h>i{;13+SA1&$25X?ZrFwnu;@iG{3+)MjV|#?W)QK$?)zYg7;MOlwl99 zz&K5wq4mvEq+QHYxNi&}j(UsdQ-(DjYZl>&`6}|z20E=7Xe!V4i1RZv-@!d?DvwuU z9pDP2(@0m@(dI{JZ=ce0FV+u8hMXh$$Dj5H-+;askUsD8t@q&FuYP@wk!CuB6NB$j zgk|WN){#gLO^iK)^BQep5SJg55EmbPqaDw6VJ`J@Pw2Swvpo;c`Jho7kP z`>|y+PpQWt58e(v$}^-sJxV+2u?cGqMtBP_|F?VZ$V{Pe?!}#PPCNnU#*KMmlFGw3 z&2u&t-`Eq)kI;Upkzghk~Rd38RBma!BjP^FCO6NWyw0l_fFO!t>2y ze-rB{r;^vCA)l~zO1yM-kI+|!QoW8A6Sj{%BYtY zpj?~lrqKq*lFs2r)v+U#rujl5Z%e^5960Netcf!s-nA0UIgIs%E>~ht^O$Mf24iAl zF0u8_=7P}UCO2BkGS)vX$2p6io7*1<>AjBD*yheI{&wr+=7Pl-lP|u%Ic^Z#PPGq0 z>wIF57JJ^b?ndWWnoy1c*V9o(+Rz@;_JH|joSL6wb9m`8^k=k2I2UWrRHkT+nw}{$ z$}OGePr`giocqUl{&|p9k2TCQJy$``RMcZ#v>5B6v`-^-Pv`e#Ih~8O_rSRNt#v-j zU;kmO1^Ez)^-U|z6LatSCdIKiBxG&#Tx~7N`(xXAV?5TlTiGJfK6gP|i8VxH9byq< z(Y?z&Loc$2FHYc{-!kez7wE+>@4cGc_zB9yXcLY4AHyAG-)nAdGSjmQ1`o-gaz*RE z294Ti!%Xf}_Hjq5A8nENe^U*-L6nD~z(1q3%zuj^u z-lp5~MSq2J7Td8l`mgjcE+Ag_m}D+EZW^;A9h21fVgI?wYxjn4!QG+_xQB%u^`Oj9 zo-}u)v!!XsyHwPnl(o&z%ClB`aR)&2Tt;Wc);4`4>-iV$6Yv}rn_hrAj=c}DXY)xo zE9g9)ebb0?wl{>`n2xwK6|rHYj|CTDynuCkV~w^ED-Py*5 zHGPD2UfhG)8S`$Q%$TWG7COYp=>FSI-R3P){OQtr% zoc{>ZFJI>&PIOO`Hw=WI1RB=f{AkaB7FZ_Cx^Lu5u@~HcdEElvSQoO$ALTjepYnn9 zPx-LQ6hEU(8fByD__cmA%;Cfyzajoh_$6Hsf9FG7j5&}l@mwQ&xA=%W$0P4XC-dp| ze@?MC%Wzi#!*~YgsBne`XZ9Su=*(Wv{)w|`f6_4bywW1}CxyK~rViY;Et-1iXox9W6rp=t4PKWKDRC z_PVA{O?WIE&vRVF!yQwnV*hmBmf=^;+d6#Syk~|l!ZYtvu}|!B@cW9b4f>)nu!pgY zqr2c7X$JZtw6l)AtMa}${&WrQTyR{3GDCOUL-&s@1aHqoexrskGJrJhx8uxw1L&eJ zQqSevXg`b@dk+nM&v%IDrA*INVUV|Oi)e>sn@R1khP|;LDXr=mx3|#_AHjHbrh2}k z3FGAs;#n$s9#YN^NKP#Fsoq9=jIk!#b#kLUEcpyv=V|dnXJG$%!Q`Z2u@>i$1(St7 zH`2UjEzZWqc9+j#(3pE9){w)|7TIx5Z2{V>k%?^j-Ow+sEt8%-D3{cBjzl{w=r|8X z^hVIFicb9%wbNTcUjVwND;ws)-ka?k_f1sSsINHv-lH6=pXxl0F(%?_txld%qVfyb zbUq;99;DUhq0MTA@)(W1{XCS-T*SkQ`i|%7s19(oW+eJOQ@+r%Znt3Xj(9uswg+%- zr-0iN*2-rQeCKl@qs=PtnV;{VdULGmaf~TA#uggd#}KrWct+z2^mED7$NBb7(;0s` z26tvqo74_v#*Tf{&aD?7$iSY-t(cqGFy}G)ZF}>aT^T3?`#+!i(8!j!Z-eGRxMQL- zk2!EP%=Y7Rb{)Z(p(mcdApKJMDE>Cc?1(TPqkYJbjt4HddfAGx*!y0Mypemu|JY>SEB3icRw;wIW> zZTIz@UB)xN7$dB;v3858y`}SEq|en>$YoM4gWO^vx2=$Sre|zVJyzoDJWP8T{lGUB zIP*_uNWO=jseCv{ziSfK_Qu|GQOm^#UV&~G)0~2bzntE3!D0vW=7?mEOx40)9tU1J zbNdB!T-0*mfn=KBL&tPpw*7#GD}Kb80?HHCGG;O6`0Jk5+8sy)kB)Rl@YXLcgnt@m z_eB`@wz7lAhI8 z;+(;*X_{kkSH!6o)*a{^eOJgjfIapE$SQ`c#gIjN-HRcM+_5H7a1Y8(`mvOooh@xI z)7d;K3(w%pUW3SU-~K0+lWqvBJ@QPPVfbp!F5;!O)|^HvE0kZ((5r@j1UYvj4AS8j z;G4@^i}W3YtOowk@aq!U>j`|-aGaBP-MCkR%8IRJ`^6Mj;wO2us-lFr^+65>d zryet6ev5d?zDm_~^fxw3!qEjZhe!R-AjEw!oh?kB$rknLUF zS*Zr(?O@Ixi$hrEIxz@(r1qWSX|yXeE)KlMVHfhrkhK-h3rvL`<^4V>>TaDmyY981 zoFTtuIb3kyQ|L?9b$P$fZCF1+-Fbt?6_j`4T!YFxdo=Fqh;F~wh+{95jcEhr{UKEE zj68B8k5C5v@~EsATT6BH)OjGw5w&mhJ+;o*x?8SKIMNn#(O5Ol>!s#-GcY#G$Fps8 zHphW@f2746Xu^5p&LQm%ur8}E!L!EG>CU$wAG&45BbRuN3`QHh_QM36-C?cQwUhnn zIGp<-f6okDzCyz@3~Mnj?1j9i@m~VmjIzEO=TLFpvOT@4Wi{Hy!{BTBaLce5oKtDU z`Hb%o2fBv{^PETMEYA0iq_vaK4^sQi)!8f?Yx^?d^o^xM;^UO(_Rg%e9cKmh!yleo zdyt{7IzXegVeo(jD=t#cQB#}n%skBd5r3Lr8F3;yvn5=<1$ltH!+G?RpEuu+bdu~u zlnY~SM*ise7AO4BT2pg~_WF?`3;LB%^edP*U4io<7=QmD+Pi>p8FbUsna<0h9$>D# z7iV_-=HMvXG&WC1-ZUbOiQ zB(oc@Qsa4ZeGBZzDLvGe6F>3M`0ANx-*f9-k%z|fv#7g|bVZz3qwi{-%Q1)1);8ii zPdd(xtv2qBYYkap4SM#!$wzapf9HAJj}bpQ7igS8YR0qgLMJVy?!;UOdC`RVm7M2M zn?ZSJJJ1E^-;BApCd$<)l#4W!k5r65FgL@wA*8*{KhXAml!Wmm`o~9*#~)qBzWD@Y z@kfOH!zwlm=hGg++P9bQ8T4xgAL+^9dkcE%VoI0!{Mz12`C2+J)kJzidgK_?_dNe$ z%o{1KpNRCz_Jqnc)+oGs`t9;qt5fOeW3-{iuQ*vZ)Rs}%FwQR+Wu^IQI*Vn&I4%@= zv_hX@&@0YiU17&KPP>uD7j*6rcPYvGCCa&~UsT@)$nx7UHsR>8khZ-%JrdU9Z0F0g z?zXD^f&+AJ5$VR-Ov2Gyy3(8!{YIFa^HD$I!TlWz58y5*JVz|*gIYhMGVP%{D#C*f zQ7&lwA4oITp#_*TY`=`H{Rnm8y?JcdJMGxfJ({&AjsI3_C|B^$B2ey8=Be!4CvF+` zBHBs1chqJ_8=}g62jo-xQ1GD~J%crv7?ibZ)wQCRIKfx9$c-~_7G2!d8+=4`smOXUaiXYK`#iKplullbqPSbzwKdJwc^FX8jqBGyr_bgO$7AZMn(bqMjU-)F; ztt*l+Hd$zrlL$AXEEnTEKm+oT=EWar?GK>sETH&P+kUG42kST}^Bg+Upt}(0FmQd2 z$~>Oo#`n@25{`7l-1#ud|K(`=1N-|~=u=2v^gQs$keCA+%F9n79oMD9UnAxyKVy75 z=W5I+uujwleS8_#iB@TB`Y`w-{vo(0X$I1^0QG?A?H^nz(nb4fMmuSwFC1ZX4(V`! z$|2Pol22jbnUwZJjx`6!@Nbu#KR3r=zbF1M%32}(zKL-p-4&G#nLndE5$%@d=0}Ph z2}ikI)=%nZXuSLb#tR=sX-A$up{-qg4(8YBFFe>^YCwOn0Q}oAmfC_fn{yzG;$wu- z_IUFn2NAd1&?Zw|>WV(|81iH}>NVA;c}T~m581G>nD5bgqcP_<=KIt>(0qT>JqWiI zwY7AojjtYkG&O$cVcY|>0C!zAcEy|vYrjt*E`=c&vr^lEdb_a`Iue^tCx%6UId(D#du*qcUC#I>7U9$wHWhEaTZa%JXq!8QWa;rVC>rMpd%Wsq>$a-zTGWKC0ng&|?mh3p^OChUt5~%q zI=a4koVEIi^R5o-Qk`Dyh~9CYgFCo0`t16*&f9lh!??%B6w|O{4BquW9;5buCaMyd(`Z*4Y5BL+w;<^?Qh$wYq~jxIno_3*4%Mv z*V+NK6I;ghTzBcWm!?f9Z~0fpQAbwzjXiIueYfY`;rqkiuC+!KRTfolX_*}{sIE(| z;l1WZER0w&;f9D?BGT(tO;{E2^@OBeqkFCF^-0UmTHX_}s@InhU-W8fd7$Oc$i&F6 zTAt1GG$%isf7$EX3Exl1(?(9bDDuaaPQGyBWp#Epl~f^NH(%Nw-frGHG)Er~6-A5;Nf5$aDEj%WeEzKD$lzfL901wA|7rB&yHA z+xVT@QSDvJom%?9)dM$_9M!^0Czl=>_^xFnf0*ZmjO4k4o+|Ae^)P?1O^mx=R9?ul zypy&LzkeUJwawdYI%!|F(c)^{>q0^-A(qs(m&A>XdMNI?C^q=kw(m#nYdf&r2kzdJ z=e4_H@{5x@OsSjl+LWE`dbjW6xu*R>Pxjz_o{!tF9c&p=G-PDi@R<9C+)(!OkVP@? z#GKcmuEVwtAC>i;dgauN_}k<6$G?KRkgplq>a3!(&YE`bS-XdJ9ac5$$XT0*IW8D` z!I}%cy&&PjJ1+d;!qkparfr&bbH}vdpLT3hKD~TEr(1{5?et!!r^{o{u0Q*=vs+Z` z8$LqsdCn63b3JLq4I@4nG5?%iBi}fuPv^3Ve^i82&K$XINA;XH=IFsY_D#rw&WItjqmf7N)(O z)?-xtsGXyn>6Pi>T|Hf&N{`C8EaQoc@QW_JXzfMT(PKvcZS>*Mk9M`5o0EBGX2H1! zG841bWQAo<%zilAo>P?bkDRDnPwt}JeYpu2uRC|;#dlpiBkxMQvGIdEYqvMM&Cb6y ze@*^-*l~_2=vOeRU|a#(f>ZoWEC}T_1#=3n749nw?kf08!8*{AwMPox0QLm^%YttU z25KRNp@ppr89TplP+@6dC}*s)a53z+7v5EPf8mzG9fgMrwJ|b?P#!;Kpf+Mm?wFD> zSC3gT=FTyH6D|*rd11`kV|t@C7(O;_Z1z|-asOA}97cN|W$VzXWfwLsH$Q9QqysJD zPXs?f4g8)On9qFDnwx#*_!GNMy!D$)TR01AZpqGJ(J^fhPA6|zOIjKs4HUFbHL^#; zd@=j9ITiQ<>{Y<%7|9tOGlfls{dv&Sf$=A1bh%z&{D}pSAAe#gY=Z?Qla1&Ye`5QI z`4%IT>)Ffjv7^%t{LTbVBAd}=Mi-J{aGV*tsgUkvh0Jp9eXvQNPoB6R=IEHktZ!>V zqJ9c3UMKi(WF_oeb`~4ORZnlj*%i3ch^OAGoPi$iU5Im2whp{yif8uGjg+0NV zI&VeHHnS($T;W=b->~NG>_uUdaqMnAIj&93_p=?HBJm}+9i2!Ye^Y+O2%OQSQQ<3! zPH|n#u4i+U{na*xT++?I{z&du*?RbYK1|vOrDo^`ZtJ(c*u}RX6n9i06&7KSGl79U)OyTcl!{Ouku#2MBvb7OoVIFUiu%Uwy?hT0L zE~MZMg!U*((Yx$@!FN&Ady0QXmp#h#7Mo%x+3&EA*kf!jvxUc>_*l3}t;e5mLE03% z^huidP^IDdu+Ib^V_NX@Kdb?cw1+SY3&oOg7_%`uj^>852t3FV#aiI%#g?oUYmLh- z+Ol?NCt_F!l3H7d&x!Ghkg?U&RTI6Z0oK@iR9ZX1Y zjZ+P)Wp%8c&0sUxEH;~6&aOcFawYo{+Or0B6`RMdX7kyf*){B1wty{Ui%_$du2FMhkim`wLsc{>uKw{>~cNS}fw- zi`si1T8IbO25eD0BwEu)(6(+ueSVBRjy9EA)2A4@~KNy^eNZ7u(I=WN)#z**olA_8!`UJ?sPaA?o~I_A&c}eTqlvKV$!7pR*>m zpM8Pl|AXvH_7(e@9b(_GZ`pV3F#DeUz<$Ifgh$y=>}Ph29cL$4Gh>`{jfZdx59L-K z#_>Kb%+|tr1drrVyakWuEqN=pP` zpT~RfSl*NO;=Oqv-j|=x`|NA%w2pE zFX5%!%_s9I+{4TGR6dQD^9o+ct2nN3<2AgN*YSEjgU{r%_-uYTzk<)`F#Foeht4Cuex5y7xBe>3BQhC&u`#M`HlQ0eluUjZ{fG{+xT*RJ72-?;4Ar^ z{4TzVujY62dpK@-V=4IR_>M%XM)IA?l!g?H!beBy((wDAuV-zwQ9M}B{#fLY1jM7hauK@H4)T|2BqYBis5u#RCh)@e61046n0A3ytBuu0KqI|07yP@>{ggFep9@tU>>3 zKGEF#pPWwwYf!KT1#8f6nUM!;P_PF5-_;;rKNIYOf~&&++pEG<7k>FDE?9$t`zpbG z6}hkSYif|M{xmlS`=DSS6zqe3NgrgcJ!JkpYEYm|!){)SJ9%d^xE2@O+y8Ia+o#g{ zTWU~qv$3~tlzSfjdmsjDP+{n&VQ6M z&c0IpOH9EU6kN>?u4emIvwun5k-Whg6s$qP8uVLg(7#vb{<}wU|M}-(licxA@Jv<@3+}_2O^* z@80{A{9R6EJGtL@UflB%$oslqxYG6Hb*g=*;F7#Ip4KHWq~C7u;l1f2P*$8aSR10z ztuJ)ni*bt#-2juQC27gHc_kHhuLSz~|I@xsE8{)1ak#DO65L{S3-06Tr+Eaf=CRtX z{4?B-)k15d)$#xQO>ni^Odh-m?vFL%{WETaYNd6=eM^sC)^U0?B4thPW9I#?ws3&yWRS0_iFQiuW0MFYxx+s zjMLg{Zvtbqd-!g?Li-DUg5-qIQ{9q!nu}ZIV`^m1?uKYqbU1LTwRlZJMI3 z(*A_ohTJe+soja&x&N-+h5MXtK@48T_c3T{3hrm};7%B)BLYHhx@SX-j4 z)c&kpgLvGfIkoQE9IY2LI0!A)4%{3i+pKhLw3e-9YHw>fTCSFd`>e)ltF^ne@mc{= zb&0m8`NQTq#CjI|eA;}B-=Zzk{)Uj(X%A_ewWqXK_*88RZi;$Zds%Bbz5_Q+Ax7GD z+UK}g>w0ai_95<_`bfJ$yHUGeTdLipJ)zx!*ssL>U<0))v_|b=ZMXIw{JgJi)TU`G zprzaSGg`S;p)KZ5;spnc-7kKP%dL;&J}xpJ=R38RwEl2AChR^mINufiTKV}l+$6rj zHw3tPlq_=pv&ro5kFh|1$N6z^)7SVr#wlJ#+zhIL*LXP%KfaL3k3p6EWb>C~=JD|! z6S45|E)xEN_jLyE>-;_L>om&luf^`(GJmoJ-%X%_ZvHoe2D%z{^Id-i&A_1u_qW|4 z8mvLV8uWYBAev(tCG+&yh`Tx&`zOAi^CmCl;8pPPY zUW+qo#Oc=J4EI0`)}Y|~+y49C-xgSEf2lpV9~2zL1xInewAPsUuQshJnCWCT_JacH z^8@yS0^JR}xeqdE1_pOjUBP#V{#U$1)F_d^4EuWbgU;mdbTx>v;F*NrTX_E{Z{a;t z4LH5q++Ym~zQ;QF9&7O)>(kegGr9aVSc8H!C|HAjLk&7p?ee+(caP%!^Uu$aW`fVp z{IQ;&p*;PiYuPQeM@>D@>DRJJw)xMzmTl1c<1Ocg`AitN8+0b#)c=EL%P2m;%fY%aj9nnAYOrqnuh$L6TAF%|Gwp!}w(Y@wBb(*0;7ud{zuYuJ<@cA3sWSX( zMzC%SWx;;qarOlJBdxV z`_%>c{Ih@E=%AhToBECOwEq0ufH4|l{^80HPhO`w6_?~q^^3QEjDK(2&CmQXxc~n~%8NVM8*C?goxR51I_WK*yBM9F{D|#kAG1$RI;E1!FXnkXpBHd? zZ^cwTjhFKZUdgL)Bh74n4ZoIO&adEC@;SI!XfEy*x{A-^SM&L}ap^pXteZ#(GU$a9jf=BWw9>Y8Ev$&l*csOs%+wu0?%EP#gx8kjN8!n%JZo#8@ zOa3D}!j7_zyc0j0|HOV~$C$jm=QumTn%N*8#|Lx9IoJ3|p1>3NIlMD>@-Doq*e~hM z&*QxU&T$RoLwG!%)HmOBk;IdE3Qy%}+_(=kn~&z1JPXhN)6@T#@Jo3O?orCYjY#8h zGtyYTfG@<|NZ0Y}ai7wS{3gB(w|?Eqm-E~Cr?>@dI_~|d;}baD{I-Y}@e*E&8{cl= zH}l(gF?Vq{pUfBYNw|+_lejnF3H~I1ia*V_@@M$7{5k$Se}TWqUlR8hy~EtK1L`Fs3*{sI4xf5boLpWx>=?K z@fP+lGurBn>=E`4wuwE;9%I+C1#BT(#1^w9>}EC!^_FIb6|5Z6X0a>T3U)iYjoks; zGIlFl$>y<_*m8CVB|8PTT`~5fYE@j|xD4NE_|~yXHUl^l-y-%WRtmg@U5(#o*^7*` zRM9$o&zG{BK)ar8#V^A-HTt_qt75gRo=s=7SvBl)*%bV`$q9dUe0#HAtPktSLYb9? zF&ooZG>c*_SWD($;VgnhvJlpab!Tl@2X>b5bq;=a;MaYD&l?}Oi$zc z9P7&lus9ZvTf9fIM3&4_*(jF5MiVP5!MC;63Aa-TD;um(+UU10%Vw7Xt#Bbd*|l>t z8*catgWaKpYhASnt)~{LMQH=H7NFID_i}u>b`^dZE5moPc;=n4cC5Xibz&WXud>eA zfsTdgWqg|v>*M?g{|Pve-NZWJ2{jK?<_H*HD({k4|b z#Vn5%uzb^dmkY5TM1Ngyr&(w1T-?qzP@4n01-=@9Q<(+7F{~|fvR7b2rm&y+5Bz-A zkM(DR*g!Uz4Z+&%g^cFfv^tx>l2{5$W9jT7uy1GC@R5m|`p7f=CBf8B%V87P6-8JsS`-E@z=x4djW1b9F9J>w-%y>3hHPrOKYp#FBEv5`0a+@ES7`c_FA0Q4yfaM zmev7xy7kp!VIF~7&${CtGRB5zeKe+Vw1$3v79OI3$~F8VJaQu={e^^t;4A+X!ng5Z zR)0|;@MqCN=pSW@ev2Z5+o|!-B zN*X}BLb@k)Ysd({T%)2G3Koa$h#i_fBOG=H8$ulKy@E4QQfdr|e6 zFQW&PpI7*+-p_03MdfEF`bp|f{Xe_VckV_HOCRcG-$qYr{=AER_qTtj=YAjk^B(ly z^7EnS$M>Sg{y6vvYT$R!z$X|Jeu6RRrx?S1ic#D@F@B>FTocA~G@_%=0d=<(jc)xv z#!Xj;aM#s$xXtP?deOuDM|_Upa}=MS@c9{cHqsr6$I&CAPt=;xc~Cb*?G5#T7R`!p z7``@q?D#nF3HN>?FcygvpB5O8M5E7diJLQ9Y4Imc{aMpB{>0km_03l`|E2k(=8u~{ zYyP}>U-Lhk<4>%^_jY`5Y`(f#W74-p;RcLM9unpUymE_Rf4}(+_^`vo*jAY2CyYxR zdZMn`!8SGbh0BWO3!0yXd$r(lH%}J$Jp1azDwxiPghjwXA`J44(VI6UX?oL3xeZqw zQ+xL$pP|uMe~W6>wn4+sqpgwSdTJSHWKZqEC(!!M+7UikJIV)WKVjz4R{JY-f2o*R z$eW=r!|Z})6q7K=pm|8Cm|IN2{9zf|#M{I?v!+XR~uKx^!ZE8GHw4@Ex4; z9h{@Yio;kj*QRo9lxYuU;BsC&8*2|&W2J#sA!sJP2(xK98^1x#$8T0M^4r9mdkEFNs8fmzaBsLOk>Qb4tsu}EzX+F|lJLyRw6=>JE8^8?U+gkQR$*d^qq2^vXx zp3}|rbnm?J{srF+@`3lk(`e3^+0zKkI6d$l;;SQV z3uWs>u^WllB>~G+%OO{NaM!e0*O(9AG+x^Z9ln6oh&|$-M0rah^%2xRP}@Sifdy@T zwDtkQrW8Moz9$Xq8!n+O8b59oX&s66mk}an9`NX(r|?|Jb%|ap39teYpP`i?dcr6NynXrkSgXpznpHoXvFndjs|0+WL`sryb0g*1C~nnc?u|mII=-o( znV;S>)`Zf~Hd8(%VfE){q{E_7tf|-h0`YJmo{jMBLQFRxejg}aIUY8~z;XmE$H2b( zA)mlVHvvAWw>!c^aVvM2wiO{!Txk6J1;R|hHvzQ$B9;lTe+$!2(Xy0nz;S(BS4QUs0R>(OaT|;_=^bYA4GAJZI&2o_?$1>J(nWeAaj$>LJ9ojndoX{?z-9lqS`-Bb%9UMA5G$AxKbad#&q2od)hPp$ih0YB9 zbLisGrJ>71SBEx+ZU}uebW7;=(4C=ghkh9PN$BUH2SdLJ{UP*cbe0yY%^G2iwzji& zvBp|^TjQ+5tjX4NYp%7xdYRQ_ono!9)>;2#ooBtqy2yHi^=9jG>z&qntbezzw?1h7 zhxG~T7VGoY9o9FjZ(H|RKeqnUdcb`vM%(gjm)c5f(`>c2 zD{NQW7Ta#L-DbPf_7~e)+XJ>oY){y>+Fr1|V%ueV*Y=U^Gur{%H?|*b$88~YyS;_I zt-YhYi@k@vuYHhxn0=%@)jryOv3;z4qP@gE#XikmWv{beZl7zPZ(nG?-hQ)vx&1Et zU+j(c`|JH^%j<$}o9GxBA96cTV z9C40ejuDPzN4g`+k>?oanCO_~nBpjROn1z1T;XVN{MoU{af4%-<95egjx~<8j{6-O z9gjPnc5HLJ=y=Vs+wrdBL&rYHe#cji?;J-RCmbQ+w(zL%HsNQ5JHxw&_YNNr9v?nD zJTW{id~|qj_?YlZ!;8b+;nTva!|TH@4{r$nbNHh08^Ui1UlG14d`YQdu1$;YS@3C#YqJ!xVRomsyd$LIT|f3^}DYMLw;!(yIDNn=j+>x-*X zIY6wUiujtyl-$0EQXpv-6zKCTxO|j8th&ZsQdUc97llzoqr_DSy*Vejovuo!t7b|) zQJrIj7tL_j)VXIBp&+=M{(%1W5whC)e^b(-BEsk)}DqKuLRVI;WBJrkxnSM4+aywsoyP<-=}il$W8s{jV8 zEQJ~?QEBkY2t<&SQT3H&$dwAiBbDy@I=Ax7Ce=@#jMTa65Wh*FGpKtuwJz1Jx)Kko zby00&p0c_`gTtFp)Rm&T8dnK%n;BBa6;NP+A~Orjxvtr03Q8ftXCZE%Eu+%UF{6^4 zseN#vRY`Hxx!`QJ209D>W(Fyt)IFoD#9dP5ao13_n_lm(cTaXzl$Fo+(q>lGOq+sM zr`k(FE96h8tg1u~%|H`QnSuPHfXwWw(NguCIs+!kvab{cwwu02+-QGipirYhk?kl- zJDSb`LyGF8Y0yB!G$anDq2~5p2~fn70#XgP>KqK_(=_J+U5UZ1I+&AW`*$(yG+m2I zlT)S8)HNuINGv7MU=ajLsX;hZf(^G*CeU#7?-~Pi?H_%^iwr9;t%mDq6lXY}MpK6K zX*6Uwt4_4Sg-SV#nG~fcK1G=cLQ#s~s;jCfD?wLQPpy?`QESbDWWBC2lhE9uxkg?0 zb=hSVt|=(%^^>a6p`hVI!(n#zcbHsKRaK4PQA5jo#(JO8=*4CGUWs-U&Bhc@wbR!n zd3zLA;Vvz!uQ;_Ex|&lvpnY^tE~`WnipIXSuBN`Ej+NF^i%-L@3U|dM=z;>ifL-Cd z5*^@d3{?a_Ijdz4lTIH7M^cQjg>pQ~Pt(#M4a&+f(*VLd*Or_rooJurxJBm_WRb5S1ZhvF2oF-WpcUORaswc_Ctx8=JH_p?Q=E!W3Y|?SSE(#jA~8=j#hNTketaFbgQov zC5%MpWak&Kq@0{gmXTe+3h5^;Gba(WF{#M|#qS{T8^eJGuE&2BswDo^t{SIRE8^=;aRiIx`L}f@*p-3FWB*qa6UWtM( z`Bf^?1cI(o0hIg#1zqwhEu{$rU1}9VI(e zQiTtr2hB_=257vvQt7hrJV zHPhH1ZPCSrsd?kcoR*xElM9uCC&Onf^chvlLG6KGE9NBxv}0bnUxVc5b%3`W9pK+G zDrCsEA&e)>Q@q~>KOX6B^k8)-2}15?Hi6!~QI0fxp5VNj0GD5at-tFYnd zv!IptSz8Z zBz~E~lgJe5QxeTmGO`j!r9zV#hM~|f2!vXt3k=eQDCCFwM#CUoh(az(;f6n1Lj7Eb zOXPy&5k@IPQpw#Yy~3kWcFh)HHZo5NGHgZ~r219R%Hn4;l4N3}7?@doc3%ul>>|^R zq*Ap}@~JvWWn|@>#Sy=>`#7Z?`7C_MVy!$=ITl7)q!m@D)Nm0hGc1M%47;f)3%|b9 z7#zN0tb`-xhMO<4rXh_=%}Eqvq~i-hu~6yq84Wg2y+nVJMjCva(p|9|#mnDnFe_K( zXcQuUtHG;Wy@Dvu%oc-B%#Zhln^BOQ4z++IB{eOvFtdOaW@msoi=kW1LxPN2m5C{SepXISK|0G!98Y1( z37jw1G$-@gAj?2x=NX~%%P>pkG zCkU=oM^eX;0zu2m$b$2jRB0WPkvdkI3KH{2lSx#KRMyQ^LR)0CaZ*OR6h&AH#1b6s zi(zL5OQAuoYF+6v@5M0QwYn zC3cyy$)xsGB{!{fiET08URLd?S+IKP`BzLnpQcpSR|cd}5@?SO>(Di<0xO$kaupVP zTjpfCN=wClmzgH^K+S|2x7@ySm7A$0w4^dq7I?R41L);dQ?OE8 zUKAk4AY)_IEX5%EQ?dL?Nvf*!k8QVv0ZeYnimgFYWK2}A!c5MPhb3Clutq@wiG?tzaFYv@I4L)JtU z-e_M!#z0toI+7dbKD%)C>DlX0RE1XPbdINWI8~6?L`RjzuB=Kpa=;W@S=hXpQG+r! z2;VrS98CG9@>A@@_~mB+E9#IasV9-Kn~mBecW2CI$!-qGyODutsErR+TSmLrs2v7D zZr_*)v>T2+vQiVNTf$(ZW{6J=v{6*)o>^2|f(mLP3wtSeaGFzh5hQs*VES`<^) zBzHLz$BqJGdkWe~q6hSc!UhbWpMeZ#6L3lct-vXwO$D0V1Clir8-phHI&3i2$}WQH zRvqm*xofBaHkA)w>t@;_L<9!;jy|X&C>tN&frvbJX+52Ba3X>@;x%cuv!)(P3Hy%7Or41{MOBp;7r8~=f7awlMe?YIvUoYj1wPT{!$oY-79sAg5|8L;jIg}jNLeY^ zs_Sb#MFt5`5NAN3Wt;?YSC+U>rW6_RppD=<56(GE@gRMoO&x<%D%Djrb$Ozj#&H}) z&&PR-%2JFB0vU3Q#K}VxdEl#|Ga-n*an=WWpUJd6>JpU!>VxKL=rD^@odUwHDUJbw z4Py*y0L3{V=c&&3IO!mbILt#qz+ygRBOK)^8>c#Eg9CkZ@WrW4z98q+p%G`mArc&a zI{6fd^WL{o2!(!*v5v*RZ1JV%sI0Ll}s8% z+fS{dC}(|rSqf>!xgQi)3`Z;6ed#<3PK${%ZdH?+la4lk!uq1o5&Ohmr#? z8VrPFC$6H}N;>mImZ4s=iR>l%XkLlX4*o9R%Q;O=zjlx%k zp#l}%po-WF2jMJTr6UpObc1pHK^~C6A)#rNRWmD3c~HVQ$x()D0wzNRWkXs0P*w(0 zJ=uoDv3h*fQ4JU-f;wT7~ zaT3KSAs@#jaEL)1OF=JP$Li@v#jKwU6O^GivP3R~0H|Ktg#iRQz#byR(Y&jirWj~q^9?sta*SIpu6NhWrrD{lO*3>z10t5Pg9Ot1mEV^%v(0Ot`AR#)u|1 zqm*Tc`AUf!Mnx0)@REfs34;jf%E)LqvXmOvOnA(#s+DJWa;s1*MEsM>%c_+RGNxc& zkxly zJWH!V*OiQeE;UG8$uwyaL~obqa}6LF(Pe2>Q_?VZ5OIf2O(ihbI3!Bt(={8b3`Pf= zA#|Hd{THbKCmw5A0hS#y-80oBS)E6;OJX8GbgDY94^ycsR6RH!p5S-QI%{j@L9 zP-D$(5mt6pF7@{(5t5DZK_I7;>*LRthlssw(tfgcNe}d$i^7&wRf?f6sa&c%MI0@a zW=cPmR%&_3>`Ov29mFHDSF47uP9h5J6V=F8(h8b2uTMj1W?BHR!2)fO3pmXTJ}N~b zji%PgRWmU5qfr=MCHPeM91y2U?OQV-tR?B1@zpAPbN&(9# zcNG?_YGw;Nr3_7Md1;<&b`H+8m(ht|gOE~&)9KWngO(#sikrE-lvA=5R0vUCrh*FB zEQm=jtD_SEfYD`@6yXedgaBn8lGDmvQ)<0I6;z36z%H<$N{WKrTU`9ivMhpBfD95D z470a(o04gL0BzRO_z5np;^(EuO#WUdmh;&?XpX+SM9DT~(1s zv{RV98m+Uz0=3c6<S6NwYC|v>xLCF@wZVj$!)fceb$)M&no!K;g#_y?gDM-1^{r zqnPnvO8QGU>A{*`&i`9{DZj=QML`T|AgF<$27($0Y9OeApay~(2x=gxfuIJ08VG72 zsDYpcf*J^FAgF<$27($0Y9OeApay~(2x{OzqJhH$H1@59^&Q?{W1j&Ta5ivDKaKqa zTn*d}bSgZE7h)WRy;0%zzS7>Ha35ZkL2{M?F9*&7lAHn{$!X{yE%HIDRja>z~eI!n_0Ea`LOrn1HY>izA`yq+? zKA;E(I1BQ&0WX027K!>sMQ;QS1AUD|eTkws0EdD;N22ag^a;Rt(8o#C(}6=^Pm!p{ z0r8%z%>EK}Com57P7?Jtz(KG_OVn+^fv{U7>U%oL`0fM_0DXrJB0g}FK%6_aP z$}RYgNYoDkDZP7v{XpL%QQr+bANHLR_07P0Eo=?p+l*yCs_cZY>&t;8X9@6J_*)=R zZvgg%eU3!k1MCBPsYJa1NdD4+y+KcrsK)_&!QNk@9t-RVdpC)C8(=K#(GqnVum|iG ziTbg#G<0T@iTX|;#e0WDeH*YV>{}%2>w)(m{e+bMMr9|Y z^v@?mI!b|5j#7Zs4s-*O{ttDK<#jKR_;v%kK>kjN`Zl1G!jq_P0L}zo0`MToQD{@R zH%97hH?T9wk*IH1^f?Ms6vin$)?Q;V;6EZ!KMec~={Y1(-vOlj*aAEUe48ceD;0eS zkm}uh;6UIkMK1@E9FIhOoT3i}7J)BT**i)1%ovG!8%4JP&qjC_i8@}RB+`8duTm1_ z6DZnI;OCIHQPCTL6z&>{dIPW%W5y%Ui9 zMJV@Uckiy#lr1*^kQa%?*)Kh@OHx&3N$&;u@EBc<+ zN{+(SKniE6vNr%pz6VJ1a}_-T*dF27B#HbNYqy=_hrB~@V8W=K3~yi0b7G!CsFq(`UGGr(8o#CGZj4n*b?;N z67~Ly-VGQHx>KUwM$v7+7NA=s>PK42_#OmCf!-uh-=pX|fsvr^kf?7_^o_s>&^Jib z*C_gOU^wW@BX?VwMPsOKtr3eX06f zpxje{6iy#t6EIrQEx^O@$0X_pBW1ky0>1-&k3@Z^qHhC!3;Gs``bHpyvqrfu15!A1 zfE12L(I)`EfxmGQ^%Nlai&O61faEU%NdAsRsB#EA1b+u5>N^#E3y}C5fyBQ|(H8)} z2LF7CdNq*3DOT>eK=L;fNdCGhdJOO@_-i9kKNc?i9RyN&*aIYg+koV6gQBkiehGi8 zCF*k&y&OpVrNDo}y;!1N06YkLu0(w(kmUCPQhAG&sCOcF&?A)lF^8154@l)?H<0{o z2OfaGZ4&j3K#?EHeHoDAF$YNg$`!pB_yzn;kf>)W`fwoe#{ntc{Uz$%fcs&0O4MyY z3jdg0#`}mwy$MM4cYq{kJFto3CsBVC_&MwwCF&c16wZ2y`f4EgUj`(7ES0D?04ZJ7 z%Dos!^3#EoA43(r4{#s+#Y)uM0Lh<4xgWMke|v!BZwHXV+XDO){x(b0S1bBbAcZpv zNc^RWJ`VT^_zNWJLlr$1Nc_=2;%AC}I84Jkc+u`i)b{`>UORvk{$?QgTLUD2OBH=S za4-BdNYu-LhEYiLYDCQ49;#(FX>2*M&7byF1W%qE6{R#9fOwPYHOPsh7NaNmRz%MW_TPktl z&YwA}1bqi^8gM(X47d&G0d4_S05=26fg6ESfE$2QfpdP~VxBik;>0>2&F{;BA0WLR ziFz?`59|{p>IJ~}Vb7JQCjj4reYiwD7Pu1QeL@=VcT;vk8t)(bo{M?-5s4F{4|Db| z_#!0g(cf{rI~I0{`sQ!x?T_eJB+aykG{6fl^52SdO0!fY&DC!H4 z+@+{4o+IMgT*QA2x})1&9$!CX=Wi`<%0z;qNez^6`*FeK(N&?Ubl*2a?=v z5+^>Y+&3!s4M38+UZTE4*%v6g2T0)*1K$GQ1c`cqbkEF{s9S(kUYNv*NB+s#_wct* z;TGUw*f#f#1P>0g%e!e2MxTAf;!PM7<73@vWAqmjX#%vBZfJfFvhV z(bE+@0oWS;hD+4@0Owg)W{ko%K)l2>Gg_h^0d&A_lc-yOZ^F(b>W4p*>DddU@U{ax z!hM@W{ZZf#psxpZ0=-e9z7j~`E(el6mMClhlAKvUibtJ9-2)_jluFbKfW(&zr1)h@ z)Kh@FVNZ~##{nsvZVEdAZE%l~s2|!V-49CC_W`#+?q)@QRM9s89|wJcqK{MbTwns| zji1W;uo_79V5!0eMW3bYrNB&tUo26d0Ne%pIEi{UAjQ`yQI7%M1$hTQk@O~sdLxkP z-voux3b%bM>2nm80!d!6L_GnB^`pN1flmOPz^%YzdpR2l+y^ANdw`UVcYuk&9Y7tp z1xWr@11TLVCF;w8Z@|7xqCOu;^T!5>dL5ABQ7uvT0Lg!;M7M)0U@wrU z4+oO}p%V2zK=L0eQSS!40d}WEy%Ui9$4Jx}ko+IRE8~FrULg73BT;_`_$utXCF(nY zc+Yj_4vG2(Ao*V}QIAvh{>ttI?f`!$iMmbMEy{lIL+QUsqP_!o9`xt|?f}}9yG6Ml z`9Q|+utfb3@MXw9C{eElQn_2bN9NaZAm!IGAmwigkm8#lQ6CO`6ZCi9m+kjPAm#IN zAn`4es4oFt1A4Whmn(W7Wsg;MCvX|~j=U%RAC{=^RQ4Upz5&<>zGaHORM8gzKLouL z_!81pEKyIF?wKhP_2Ixh;EMsi2);HF^<(eKaF0mT4*}l?-wq)0ZI`GwO83k)67|w| zINn8$@FeQ}ft3C}67^VMUkVR+J1_!>H>zjaB=(Bpt6s3nc0dz>%=ek*LoC5`QU>_;Z2J!97!=9`}X}rxTF;#YoiK0LdQ%lD~tmbG8lc zO%nB;JEgxzf#h$aM12F0{H+9%zXd=Y?(-$;)vrlK+;F9M1A)E59B zhWjkwQzTcp4^{5{fscWH=y}QaD3JVbl&G%=^?aMFbImEB`AVgv0G$qG1Xvb5E?o(YE;S~Y7jLlm=Xj*5X3%N zvIK)HVPg$~=X3J=dcC%tXPqNUS8h?RSDvRl7e8PC6c{Nxxy!_2MdWkLeoF z&lfRWJq|G6OnicVRi^7$WA9T^rfbD^rpHYe!wt#Jri-BeJTl*Ov+!|pwdtzRzdtX- z5uAkneNF)V`>N6Om~I69`>G83_f>qcL97y9`-WD@;y+R(qRN|-K&{(V)m>7wZ0 zXEvBFg8qHxeACt8qvW}!n}dG2HR#`m%`)9ge2iRWx*6!}sxV#l*_^;^rjMAe^l8hJ zO*ieyoWLxmmz%EZ3Co?PoByEYdeap>V0pahTJEi;(Rk*@e<1uP1kmt<%H?#(XVfw>B^dO0*5pI6w`IzniGhSyG$2D-@n;(Rk!2> zl1vYqZW8+G#ir}M*{1iHZr)9n>r6NC#+<;Z%wJ@>_C=PHrki;~PT&-#SD9`&niIH+ zJY>42>v95Dk{eA|cCF?LFKV zHeCeY;=G)z_FA=!nDw{uRx*_!YBV)SOD{}&mu>82`>d;T0Yr4`aasn%v zKG}2u^vfNZZ|xb=&AZ&@t25oyzgaFbU5WA}20PGe*USZE56wBMAHT8_&mgV2QT7%Bl8WIt{=zV2jTs+r%cz5 z_mPvPYem2OxanH(VU{=V&(>aNy1CfqxAQ`4pJBSext0e^*Kt8kpw+L>bnUppug`Qb z^!uv;{r;*$-+!*@YS7m+%XHOv7ya7KxAuhTTG4;5YC!)vYd-qd>v`zkPu8Me&K%R# z;1b%y_#jTj$FT&T!}jy+b)*HaAV<(Irw;vcYn5l9UthV}%hWyveLa)V@ArTltj!7R z&GrqLt{?Xz_n9t*zRq^jwc%^b--7;qMZKoa)ATC5m-)k{E5|1KO~&Q4mzZu6o=W?8 zIdX1J;6`#BeZLmdHR5Bm*WxQU18>Etcn|%`OjqosJ%n-E^G(-xj=ewV!n@YUGyJ4drUWoeto@o9_>A*i{cUF2Gh;JGszXEE5jJ` z6{Fv;6HPZBU!Z+xjc-=*Oe^YOh!O99&Aj8q-Zfzn*f_mEoO! z{c4}6_VM^J?ZanT{~^;2;=gF`QG2)AJMk0R6KZc&dkp`=`kPJHgm;n~O;?G(Fkd

    N(eDt5^>rFQg?;zKiZX){aDl%ONU-Zj6gU>VAi+*~K>ALW3 z+S}0Yw`Pp7ye88%pzj|sT^;&*s?;7<`xNC;2Tgb(xn~1lPi%gf9t^H}b1p4Jg(bq8-{qkx}HwXRlYD_l^o5(DP}uIXmtU9?X{Kc1K38<=m?!vWKco?`p46aD;Y)1|P1{;itcfG_)ea!w$M_2~Ck zHTrr>(a%5GbiLJypT8DwV!zBWT{Zgap#pEDeVXZt(XVHs>Bi%A z^y@uI>oZ*%{q>r_M!&yJ7e{~nMsX4C4W^riez|p~n}dG-F#7o`O*aGm{8P}+UuwEy z9IMN8l_%P9t3ZF;rr{baLEmqZ>1Lf^{br)?SBZZ54AZ4&T6+@x`H)a9Q%)XlKac4+ z&d%GE>DuuI>Pwn#3i{=inr@_u_jxR@5B+-6=$D^TZbRQcVY*hlkLgWnZ&Z8u7_MW# ze@r(6qvQ(HO~O*%!}(qtkRL^!?jSmqg#c{s`+|jn~qDrs*ot_n%?9flAB$rt8Bv z^G`l3CvXk(m6)#cP_7$t+H|!uasms;Fqi=6AT~&p( zPeb2cZo2G&);@^7eZX{aXYEbs+Z#z9wdpZ_IXbi)T&zai5__qTrY z(D$n|UB|vT{Da`U4>n!Xo|YR;H)o3F8q=jGTkbI3q^&I%o33t4%X3ZFu$kqE=`s^6 z51OubJ-a{9W4f}S8%#HaA6jk0 z^itDxza0qp`vG01oBNjKTGNf^hb4Y`$aL-euw!d-(sYgJ$E|v`&r|y}e#qhbm78uN z`hNb0AHIE*A9|qc?6#aXT?>wlqiSzZd-%1$*nNje(`8->jNNw_G+hHX+x>lri0LMC zGu_`8C^21{o6uL0J4`pL({i=xMxPIi-6zPJu4PSN?7l$Ebmi&5*nNSirt5n)z<2m^ zU(Zh&~Ccwr!3DjoxeHh?<E)&yc_I+_8`FnPmqtH-hw0{X6S1D@^`@)DvGK`t`Hu$zmoeSn zJVe*_SRimIIbpieN3H*4)Ac_R;LCJ*A7{EW`umIt^gril!Ff!NnQjjH@p%@Gy`G_8 zf4S)H%gxQXEBn~HVxD>L0>^!-Xq z*T>C;XXw{~zCC5ScD$SR7Mz0qCWPNl{jJuo&vZTL->-C_e}9&be!utgq1W4m{_}dZ zas~SJOf%gi^zY{;qCXzv(XS^TAHvLXisyfWrW?SE$o-~Eq5mA8z_I-!=i%P;t25nP z+>2amx=Q>rd4}nV(APEIbe;DE#_l(?qHm9zE{6W|R0QwGdi3?pGhHp-PWw!}koGFm zh0%Y$pC%_`BY8Z&ilcGspEX?u{c?J7F3agLT{rsWbjVh`h8(r&;Re&yD9=(Z#|v1_ zRMSmH|9K;GcVO&uemDBh`3Zas8}L?~hvze2o$0F4f6lMO^Jt%8x?)^TdkAZ3&o^CW zSs-vOdC+v7==-Jc9NODW*R1v^o=tm$>E@_?D$b$3%ydO+&&RW9_ct%lb>0;iyT6b& zT`T&}D=l~i{bHu8NB{c(HR#W`D)i@HrE)&{^LMbt+S~9Katr$YjcRXDo{9cEp2f`u z|Gu~aufQVo=YRH2yPo>7g`B`u*o^-CornJXt(Fz&&);dLD@T9+PBmQ-`uekXSUnl^ z^$#ewps##jy$Z#nvUC&_&D_4*I{ z=tlXl?(5B(t_S^f)NQ&h^zT=jZnNdoVGaG~nr=$7jgQ56I_(opSA26|?0woq)3x4c zIc~a0)bf1OO}*OQ7nPZ==_<>OrYpVD@?_Jc=UeVDU4|E_S*(B1bakAxKF>8>J}0Zs z{-i}0<0SOC*>qFRv|MVsqS+c}Ocy`J-Y2z~u2Ol1^6<$veaLi4+=k`1nXVeQCeJio z8NTI@i`t9To~gEegC?I}tzVnk6KbzJiSdQy%{5)oiS~YGyy=oN?fprc>G)>gvG*r4 zO*a|+aV|04z;S^9iwgIft_}V4gz0LJ4Fp(pc#i3&qMu%7y5VC2ffJZMWV*(q1A)WH zQPWkR??26SlQ7Blr;f7rcGJa>lETfVYr=!cji#H+Abt?J)^u~wzm8X-e;u8M$1}a$ zbW_l;x72i#v5S61=wC1A9ck0+OjpBAP=CG5kdx6bw+Pu4;qj*PH%t9;M-LyGJsKQ028#y!(;E;reP1l2d{!V1q^SN?N*NT3-!%ledyna2&OR?Rn~s0FWo&&lrYo5i2(atJlT6olfSu31 zrfXMDDwq7xwyPNZc8y10f5>zr<(7v{H-KaByVTyP_7?Ql#d!3uPs97!d_$&-?Q7>_ zJ#y&6^Gr7j{raj+H*Fuw<))j2{ty+LZX$9B!bPSV;w1I+XH3_P?DBAz={nJ0hiTKb za1#6eG1JY*LzrG~x_RjP*O@N7r}eKiU0Io3C&kDv4o@^)5&G+SbPwCk3|26G&~*LC zp$+$$t`~j(H2Ukb4LQW&gz1`)LmF;0T@?NL8cY{KKmT0x^H(E>G(6LEmFTx~hUv<7 zw|3Y!j>o#3#XIo!0 z`sGG&D*fl1ZgeLb|1x+t)4S1+uW9r@4~*kVjH0i5uAGUSQsFAog^^PxTxq&;e4hR# z=znh4w4;rO1Cy=3e$(~gy-e>^ds^)+$SD_&nJ%K~^EG`YE@!?O$f*~uFkOk-i;zPf z9&ftg9c;ZrrW-&GdAQ$n&G-j$lj-Ww@5gzjn~NW@zDnfKhi8~>icJrfnr`Cuwx6=w znf=Hq5biTwFLDUOJ*MkMe_T3n7ur*%YeT>Ogy~w*k2{TOkE(qRa;U>KrmNKS8Jb># z9P02S(*@A)x8agNfI|}=GF>&47E>1c0stz zbQ95UN0I4C%WhzK#B?d-P=wn}SA!ga@GR4nqu>6?YA;cHW}MA8Xu2l! z^EH~T7X5rP)n29cDd_h@sp(2EMZfI&);?mo0p)(>4jiFhQnsT1eX=;_v)&fdH6n`) zM@?6cn~>+3ZZ7)yYLWki=a_C57Llt>{?5+osYJhDi_p(Eyk21J_vr?aQ!YGUa^E>H z_Ir0drt3hzohkHnx5+sA<+Px$J7&5l`nnrTHxGTkI%L)1xu%FHGAyKh zis?$xuXj9h=))n?WkZ3n-zyw3T_=9a&s);w>~_qff70ad>jGnc&k{pU-Egz%nvhE- z+-SP_=+{>#=b*2@3jKD4O*aGm@+(X?4RgumrkjF(zEbqtJ=t`Va0_y=>Bgh4J7muG zf2`s6LpEs38!_D=ZqAV3g+H*|G=7h*Ha#3ST|N5kn`gQ@O`ogjGmuq;D@=Z_VEd)S zriUk)Zan(+^>8qJJ>913zzFrG%-QX@fSfdE$MJoZ-(tEt^!sy;tVX|ID$wu0X{IYx zyFd7T`e;EQuo=^{rW-(pm~g-8dXOO|+-C));Ylk^Ih5meNH(e6_@oY0) z0{wQjqQ6e&BSTiW-gGs{kQJU~x|!&Yca`ZXl&2||p(d#1N^ta+T@I(eICm=zs4vgbbPCeAA7xP`{q6IeQp=|3Nu`bPe~Lt{46G^q4MzetTMR zJneDQHKJcm1pWD4i+(>&ks9 zSBGQclj-IlLru8GbTiR!ZqbQkXx>^*XW6zxmquS#2Xe}UQ>IIx?_Z04|IRU84f^ezWjcOsz^^LIkI}uZ zBVhF;k*08)>Eh_?X)$NV&@aEqbi8*Q`}@99b9NJh<;MAe2~pe#BUps>xFOcz1gymk zum;CtHI767K4pEZ#PzTOIkzU1V-U-*5KFNDOE4FUaT>o$UWA;36GF-X%p+$RRC90` z*)bC`_*-6J!T|n?efSIZAm{FcF8mqO_!Fk^M@%B;^n?WdfN}gU#_)S=!V!$(e=vgI zVLg6}b;z|ap%%Zv8vGio@!wd5Ls*GlVFiAP<@g1bVFpX_b1cEnuoyqZBIFvI5W-I| zfFEO)LH}Pkj02d#kI=sl{1E%_pV)(3lM}k||1gdJK>z;m159EcCh&cX<9isxchSF3 z}d^KA{%h#2S19tMPTL!fvd@*RTR##d3TF%diVe@ntN*m#`RL z#3Jm(5Wau`d>*sBSgpZfOk)P0!vTC2`|ug;!4B-gr!kGIF@;ZI5>uGKCoztzFosWH z6SiX%AIAtjhV}R;)?pHB@e!=Sl~|1rV->bxB|d}|_#l?!16YO$EXDh=1n2(|9MQ@D5C3m`gZ;OUQAIVGM7_ zCcF)!*o+Zeg!Q->>+n{r#apljo3I*hz$&~REAeKmz?-lfZ^SZe#8T{{juKpn#Tcc% z2;U%w@H%n;uf;5H4z9sr|0aRy87yHO7{G0@54XV{+#0)Z5~gu0OyQQ8#4Rv^#TduU zF@~F=|D03D@}sy9M(_cw$K$aMU&LB;Sc9EdjodGqP=)(qC6;3azJTSp50;@{UMX(M z`bv=3;0eXJ2^L`k+Zn=ze*1BO-+tZTRhYpmaR5JKd3|^_xd*SnE}V~P{5z)5 z_eLT_-8D~ zxmbo5U@4xDC3qedV=WfpIT*sTF@SS0%bUA1aTw3Q4A$TPj%`0)NbbRNu?x?_G@gzr zJPngL8xwdc#&H(L@Dyx9fBd58&#wsj^Q#{H`BjJh{HjHNe$}8qzpBxnUsdSOuS)di zR|Wd>s~r9LRfhijD#d-U1pWC?jK^aU`tvJ<{`?A{KfkiPS@q}FF#7s3=+CbK^ygO} z`sMl0<9>Nv=+Cb-?useg4db{w#&8de;2f;Sld%qu$67oFYp@2Z@f57WBd`*yu>w!T zay$;p@KP+rORxmb!D5_;MaX;82_ZZI19%c#2hd?3PQxBN0K0I1OyeIhh2@yU z{V;+1VjTCu7*53|+#92~7e;VTtj98}!#%JTcgGt116Jb{tis)}5_iQ4+y%?A6w7dD zEXAF$1b4(@oQy@d1BP&W4B&Q{~#hAp+ zF@c+595=-nPQ)hM1f#eyMsOpn$0Dr54Y3v{U=417)i@rja2!_R`dESMVL67d41-vT zg;;_GSd95tgn1akT;%@(Iq2`}1#lRDY~7yg84{1N?qz$_;5 z2Tb69F^=D33`ejD|ASHd4kP$2*5feN;Wt=|Ut?{$tMDtV#4oV|zrb?LU>San zrT7_^;HOxOgII*0U` zV*=m9IKGQ9?8PR02c!5lM({1H#~!T1H?bDqz#4oVtFara@HMQ&SFr+L!E)@vGJF|J z@g*$57qJ*Su?Szl5I&CqT!UFYyr*#(pF@9t_E{XjXRr@Dum_*UE?kXid;Gd*{yTQz<(S65VG8RpiI-sl zFU2@sf-#(jP54)g;$JX=7h^rvVI5wCwfJYO!3(h(=VBFJfR%VYR^WM9js$>#+*!@EEMcqp=2$!fFg-6&{I|cm!79;aHB9ScZpTDgFsd z@K7wq8CZnVF@%R;01rlg-@5{b@gU6LfjHoAo?#zO!yY^U{r&L$F^zx36qaKW_rnD4 zi*eisV>lI?aBqy_UKqhWu^!8?4)?%X+#PH14_J*;unKp>O57DIa2G7cQY^!ru@ra0 z65J7saWWR+4j97iF@W1)wvg9<9L8-igWKQ$ZjF673H^Qft*{HX#58V!{=R%M`up*l zV*)qBIBtqDoQO@h2}W^ajNnFCk40FA8)7X^z#7~Dt8qM5;W(_s^|1oi!*UE^83wTw z3$X+Xuo&~P2=g$6xfsA4^!NJ%IE=q>zb}Ko;sE}FeaOAj2|f5T`uqMrVH$tL6lO7r zKcK&_|6h#b_ZUO&xlU-p|6mlq!w7zh^*D@m_zl+L*I0x9#%dhGD*Os7@k^}0FR&al zScactDSn0}_$e0SAQs^#7{ZS+fd9fQH+2Va7(c=ceuxA3Pwc~f?7{!TF8l|k@dHdD z_mU?h@qJ9-dl<)eF^1e@p3sEvU=-iR2)>2&*n@TWCf4E`Sc9))HFjeazJ`_fDpuet zSdLv-hA(3&zJw+CA{JvO7U2sR!sju7YcR`A>@*JJbC|(raR8seKJ36Ad>XrOHKy?? zOd z%aMEZ6Uy*@EXDh<1Xo}&wqg<9iy>T&0lWvZ+^mn|Fy4(BT!sU97xrNb_TWY7F2NYiL$)#SSESa!UyyYME=K0{U&%0m z{|{V*wfJYO!3(h(=VBFJfR%VYR^WM9j?6Qm49~?hKt>#iOwXkHTsUV-+5Wm3RbJ;Ne(~?2`#)co>%ApRfd{@lsNZhmwnM28M7t zLf{aeb6axaIr({|Q_6z5Z8^!DVD4aUCO4SdpF6;FZ*CvYsl1Ln{yVRa=V*RoetzC) zUL?OEKbYH*pXRx_AXdPXf<~Sr1r0n8)*wp_4)EL)?B%&3 z6b60Bd%76Ed8{oNP ze0qE+H?={>2BF;K2JIUJb6Ylu`)5AF2XoUCI(Z)A_CPRqgqsCawPEXq{P%`gp1X^B zis)0+$#bfxgXh+w1kbUe7QP=iTGYsYH*VCl5qoH(*hZn;^hTZhcXFe4o<}yy@*Lf` zabs%RILUL*CcT?5?|an>O-1GBG=mJu@-G zbKk^%o_jXy-HbJE-n2RGn`d~AZ`ryfTe{@{&+S{KwqmZWvOM=~)4vVv+YfBdR_xfb zBUP2Qmj-j2c5B{^x%O<`lc{?S@Z3GMXDUavyrG;v73~!)xgx`J>fnxpsrKL&o`((| z=DFpN_#xDJ$RN*s)BC4W&-7lNQ`0+m?)+2NpIH83&4;n%!v=V6tZb@e?^Sm496P+_ zaQcUP!@=CHa5vARM@NpK=dlCFvVUeKXEN{1W}aJ4il0Q!lY395&RMOqSkCE9r?baS zkMi7mTHk4`{q%nRJ8^m&&&@Tl8frd0!+&SzjLr$>4$m3kx$E5Sb6NYjojk|RZ#kdk zpWn>$$lNU7!JNFT{W6wzSs%|W_3?U^^Y_@_S??9SSFpw_o33P;S7vx_y()1POS>+o z`#P?jrbRi;i!izLYRqYF#NkCbBR+RF=5+boa$`>XMr>Q0lU$6gi*pj* z#^#)+X3WHLhGLkC<#c$Pm*&Kl`sqt^n!M4wavJZ#p}TX2@5aI9Ihp0yzanQ~1@=l1m^=I+MpouFtij{KCH{mD=NCAaSvKRuF{iZI&87Us1q#OyVBqt{?xG_OC3 z9gFhPi!gpuUh7R5xh1dR793ohmsyNmx94@=jtzI@Meo4$9eJJJ(WQBj7EHC|b$CaX z{^l6y#f=7ytV{3Jd_uG2!|ie8+jO0$-Isv##4E% zDQtW?ujy&bK9e{43}!yh8~Pl3zs&3V(zlP~jgDaKr@WS*u;G`y=r7oIQ-1O$UZr{# z=l3qg!MpM^cVXn={Dy~ds6BtU9b>EWTUKMoEBWbHaG)=Lun!wQ$#41uQ~%EI_%{xZ zSX<N#3R`7NI}#)m@LR7u_IZK_O?D%ka!9+s|$u! zGL5b2f`m7=rl4gF zHmxaW_D0tfG_NXz~tp6%2M^wyR*& z+x|*H>J?1CTG06_HoR64eGNxnD~NPs&uay}K6k!e(DgdDzFv^QaI#oT~L@pGU6_Miyf8!eGoBUl?rlrWOV}ygkuiZxn~G4~|^# z^Yy`AZ|a6%#|=2JC^)zXTN;D$M&I5P>}bNS#lh~y*tR&B^mg7J?7AI0ZV#rtt+xjg z-t-;8&O5NFCD`181IvPg%dq{PVCo)hxF;C(##)0d{(X4n-r&%^IC@_&azA$87wowY zQ}+iue2(59Z1g7Eg6(ZSCxeYi97qNSyoey(3QtvrpsD)4^eH z!?VHYv)J-%Fz)StE;#TU_C6Qv^L9TM?D59Z!Im^8(!n-wJRNNH_NIe<-obP*lw!Ma(uLZljP2IufZj5#Z8@-Y4U_*B>KQH-uu>JL5>UEkLUJpjS+3w(|?=svS z9PwQSx`Tt=!HoaUuI^xWcd*A#?dT4seN*I(V8a{1=o>Wkybj{$?=cZF@7A^!B_N?Da-_f{i^G=?OM?hu;j2`1xWz!ImCO_XIn=ogW0d zK4ALDC&BC|ta|X1VCIwH&?hvtd>V{@im6Y79p1*zf=!=!Gr^_|U9(>WN52Y2hG=RX z3MRZAL&3DSXDHa~?H>vbcr!!6p&{0m9SV+mI~Ih}3-}Dzv>?>HfKPOTjiF2)qU zMeo3&J3_JsBT_lLQUTEL!nM@ye-t) z=BKxXA`fHh!=Z$?VPz<~5@RbvE#Az^(2%#|kx=>(%svtt^$tH08u9i#8tQ!%(~pNb zANTq3P_H-fM5yfv-~L3X)7$+-sK-0-L}<`E^h9Xbn|&fQ>TOsRimt+@RiS2Y>#9(~ zn_LxY_jaxdb$JI@g)-jJRiVg}7=1F-=uJHt>hShF8S3@+KN%YEW}gg=db^(r^*n_Q zt3%P%*t9y->}^>cihGl*L+#$q)uAqL-|A4mcXV|q@-((S9ZGo9Plr0a!%v4sypfJj zLkHJoTSqAAO|A*GufdjALh)Cy>y=RVE8LIid^6PbW~lp3W@&jV6n_hw-U>Cp#iaN< zq1JaoiFf$Vu6IM-?}mEbWyYcRLc{NciqGa|6Zh19e|*Z%*Z95UK}!#EBw-kfAnd4iodeyooCtf<(fY1 z>tTQQeQP^?Gj0_6`VZ9pdwG`SDa!R{Sl(8-M(g{5UyAXMjpo?&e=EOwvgJ*)w*D8m z0qK{&k8*X`@}HDjzl_K9*~&L*e_Z$}aP`>UM%MU2uKF9Kzs`vS$EPtf@ z^eL7rwf-J${|(A#DGw+gFx~nep?XHNzE6~|KhmaWmESnTa*66WO4q{)BUb<0I-a{K zFVOjVzVc=|z7geOZSNh*59@lkTlu&$zCWRy z)&BcI`OlN-U%-i_>+32_U;4dm&l@`b+LXh)SpSgvZ>{s^Nlm}>L|gx>%7Zg3`(HNl zkG*ufu2TN{X*T`8KiKq|!!3WO<2hIB-$Tc1Yt^^A@iT$DIichI znR4@Cw!Zyzd`~^c@}4@rlXX0%YkR(|wdvO@7pk6Jv^~G*`Z-Q{*9zd_Z>{b1 z-{0ZS_uZA(*Zyiye&!&Xey8$Xs(-Go-zrVNN_kgZpSLPMcc#sMukt6l{-*wD`+K?S z%W8lBto47d+^+gg)c!hL$FExXb6xMJC||AlXDPR8e5h0YkB(17`OljFM&&MT&ppbg zDu1E8kGAit-}~!$U8LhTetWi;^Et^cIr_)WI=%%uo?Ghr4(t3M(e-t*^4Yq6uTy?r z=i^Kr@6Gi3^se&Zn*NRQ38&ls-do4JRpXIUzDxV_Jmt%@zaCc3*ZI|}e24bmka9-* z?(5vgy{pSm)a_I$lR9AE)#46yG5f3ETRa^?A2|3k_f>Gk3* z)?eBjpZ=vJ;t8%T5xBul&|LE5K4k}Mnz3c1xcxz{?H^VRQ`p0(KUwdl$HQHY@ zl%Jet{fE{65xssLr|Io_KX;4r?RtHgsOxLCUeC@^&e#6AM0rVt?cZWuA3Zw%mnbhe z*QTd*{-0YzW>ZH$wC(-mY@5Eh-hT!4ezN5gn?6zb@U#g1j>kS)|7qHv8|r$# zQ27vDuM3s`tMjEq`*-%4w*HHi7ifR)s_|=B=j*=82kCsBp*%^;ODnI|`PZ#{#v!)+ zua&>n_HLp5y->^FLHT~Y-#AnGFu%X@`JE;0?{D<_J6ZW=ou7LvKcv@-0p*LeKepBJ z$T`oJ7uNo}QOipzf2HmDO5@3u%Byrew`u#Y(f;~b=U=<>3)BU))>!|z`hTzSY9~!UTHCv~^4A*wDwG#$dyi7yPTPBqa@TZQ z|2*ZtYkLepk>u2RlwLk9B`7%MTPbX^sY~%MQ z`^Wz=hkq>4_Kf3?82n>1ZO>-P?T15?b$eVw7a zmA2>4%2#Q7u2i0=`mR@gK-cRn%7>}GnDW=UKI6*w==yw6`R}T4wQ`Z_dsF#z)%UUT zN?rdW${VY`koM>Ox_&1rPg8x{DE~v_WvTK4)wh@ORMqE{@74Kzrt)_>|1VcQSoJJa zUZL^fHsuTb>mA3pPsjJ4IzBt{$1DD^zv_*t|C<_b?)-gz)w@D@qUv3({IbUH4&|L# zmtS92>)TiLoyQ-|_{WzzzDH^OPwIR>Sosqj-H0ZUxnAevNy^XY{5xHFx~|V- zmBVM*`FgnWQe8hsD%WX$oTa?GreC6bgz7t2IZyppD1W5$3n@oxnd7HUNQct z%RfHS=Z$*)ILbd}DzDJ%$11%(#Ff+j{S#dq_@goZ*ii4Ue!t)Mh=0B2eE9wS+XtuH z@i;>Bm+Jl3Eae4yeY!|_JH6gtt^AE%FCJ2!Uu(;ILwTI8mwPqdouca{q5OdATdBN( zu9v5jm+SNRbISYadgxSs_fT73m-76BEx)e3hpvZrl&kgr;{)Y?>;1q-%F}9W{!f(` zX@7jBJgEKgt#X6*#}CR|sNP?cpVaZn8_gX%9>=NP^^||Cu=Pz){z&_86XkiTuUPp7 z9j~pGH&%VyD_@}cc2*vz`gT{2>wMWq`9Re-P5A>I&*{pIs_zKpb5!54%0HiF^;at& zq54i&zC-U%&QbnO<3XMBt$KfQx$@4c?^@*-HQwB=JXiH4l($uVPb&YY@u6G!Ce`=8 z@;^16e5^c0^?jp!jq3YNc}LZ^{x5d?R_prTRJmI9ZLj>>blV?$DL;0Q<^7c#RbQp@ zcB=0<0j=c&GbDj%o%K386)@$4JrBURsz$^&}+&HL5%=as5&edQfh-$doU18x6JQhrS1 z^^VGislGob->&g@U*%8rdUv4m;i~U2zn2lv9UTJ?AK2p!)u- ze5mTXRQVqo|E^TtMfF{)T(A0WQtsFIcf0b%s&AQcq3XL&xmE86Rw^H<`c^6bs`2kx z<-W76{+E<5RDEwKcW8WmPkEf``%w8J)%TflzUuq8@*NtVN0j$deLpLIsPQ@XH#`2f zsJ``-FHn6&%AGYIaqRsKNZ^E~ChX?&iqJVEs~DEsd*_Mg8Sl@C+B z&B|YE{A*F})%e`1e4grSQ%-4oZdVSfz7FLY)z_))zl7PZzgzh>jnBQxd#k>FB9#=ql~7plHl%5Q7@J4bmt)mNu{x$3)Ic}vyTp!|r&=bMy|QhhPy zk?FSomMh<{@wrWTf$CeOyqW4tE1#|UUR7?__}r_!f$IBE`C*OE8RbJ%-*?Ib8vjO> zuTy=6{E@nU?63NYlqagbEtMb8_`H*HR^#7Z%7>}GgOnfA_th3Y#|`CW~FXDI(w z_03h@QuSS-{JO^HX65@eKHsN2P4%Ue7pcDImH(mf?=9s6Ro`dI?`Zt{R=HO7H^`ELdRrMXB zyioO3Dfesqo2@)w^R8Oo=q zzM0AoXna0LIal>vqP+a~&mYSBslI0AcQyX4P@b>)o>bmL^}V9Jp6Yu?d6~xN50(F| z@$U=eX{s-)9M||9;!9WjV;|L5to*9R=be;mRo_0!8>+q;%FkWE1#+QCM&3S zS6*3T*VER@zi2$(K{>4Yc2OSEc)W-50@b&#@@A@UnsU3w4(wu6(}gjViyO@p-ZGS*mxLa#rJCLiu)$&yOqbsd}GR?yIo<^Sbi0 z8lOK$EoYMHbo$>{$ zZ#U&bRbQF%KhCoH_fg(O^&OyGulg#K-_rPZsPe_C??~lB)pxvdtH$Tkl#f(>=PUoJ z@$WL_K8=4@C|{`hu2b&N_}rvCPW9cXJV*6Cpq#JzRx973@wrQRKh^iP@`uxHe|(^P zi|YGW`2yAVg>pdk{h)k|>dWIxvHWA1#^)mCA2j}Lt-M6zbE&fb_k;ZVt-X|A)%bjX z^2Ms}K;_A*?-1o*HU3p9FV^^cjPl1C|7I%hsrpV)zD@PjDDSHJ&QpF)J}*`-Reej9pV9byukvxK??L5Zjen0S zFVXnCO8E%Y_l)vn)z_)~l*Z?GltZfTU&<$`zG3C3H9q?hiaTtyWHHe7-=rTJ`=-`QIA< z7AY^%_`F1UC)InO^6M40f0D|NYkXdr%0r1AM(<#SZu zpz_Ze|9(}zL*w(tdejg?~lr_YkWRR`ApR}OZica&-0Z1Kg#RJ+eYP+ zRo}hJKWhA2t$dT}>rtMf`aV~FXSyx#E9GldUylEx7aldLZ&T&(HU5<-&rp3+l^1J# zu23G*_*bResQP9qZ>Rd^C_kt1`7-5mRNo@yEmYq_%Ky>$_q1|U_4O#fukr6Q<(*XD zZ^}2QzKMK^q^h3czPUa9fs0=S#=kD*dezshyshdRRDN6I-w(=d8lNZdrJw$Bu<9#O zZc=?ylt0q=?3AagzT=hqG(OK(zEJi3S$Ul5yGr>njnB6#pRM|CS3XGf-KiX_vFqtk z<U&A~J&nh&Dqo=bzEt-A_@BSte^g$k@puAXhUy=Os=n=&v(v2q4CU?g z`Y~I1)f}6Cu5y9utyi9@dY33atnqoN@=>byQRR;{K6fZbG(PtzZ>4&_Q+~d}*8hWY zLgVwOvQvFI`u(;>jn5O6|4-xJcFI##-&EyZjnC7S&r^Lfm4mA9Jmuvxtez{BPf&eV zEAOHDZc*;l@%x8*T0ls*YV3JpQ+>bjk5no3H|Z>uk!sme!nW8qVubeFU9qb zsXD*LE8kdS^KY!&uj93y@@}ecC*{|4ymnKrQGI(Uf3N*P8B=U1olX{xVFc~q~jZz(U)`SlOw zBUInV%9B;!7s^kaW%Um$hg9Fs$|tG59R2=LQm_9(iWJ_`ApTbOnE)klT_}|_5FhK?Yh4Ely_4-pDJIjdWMx>(e?d{@*h-R z5nrzDAJ6Oh-d6b})wjFy_qtx3a*M9-u<|jg?^NYoR9~&~)it)iu26nU*K?zCiRxRb zoYwXHpz;Z-?fKa%iLUQ$l=oA;rOMs9zV}u>U-ecf7pUH&l-nw7{WFzs)%AU<^3JO7eC113 z-`|v9)b$-z-bVE;QGQm}_kGI8tG*|czt#2KsoXfj>Ul@`Al3Jw@)oKuqr6h%Y* zr`h})@@4M+5mtT0$}2Sf?5KRG>f1~C9~yrSRIXQjGnBVgea9)keUPoMM!8L&KQ2-} zSoK}0+@$($Q2t2o@0*p&Ro|V;eR_ZYfbxZ^Z>91$)t6F!Y`WF+g7Vp_?{(#aRNs5b zy&CTZly^{l-zfh@^<|ac(|8x;OY{BX0@XKBdF&sB$>+~Mm6vHe-dFih)pv|?R^#0{ z%5Q7DyHxpH)pwKfDvigj$_1+LN#*lY-x}p#HU7P>yjbJ$2g-Y@zG3A)jei9twtb6K z-&V?JtG->8f71AOpz`6W??mO8UN35uM>YOkseFs-yG3~?)fZRp)cCwg`2y9qMtK|6 z_l9y-~$zT1>9Qhh6wpVj#MsPguzuT%L+jn6&GVb%99xKu2nul^V~=Q~qA#@ovg9{PGIJeS@X9jZ$SONp3rXAf8IpPalVw?KXSFa%+{9Q0pGvpzqY;w>?WTZmHnUb z_}r(w`~b^yw7oAdo1Y$2uG+zJ)PM0W557BgZ2H8kE&oK-+x4U63si5P@}7UR{%u1x zJ^TmDbKB3~spUPU{oAhn9bq0nyN4cgxE%6ymeSiR#_ z->BxFw}s8m%k9|ow3dIG<{#Glk1J1AZqWMpVo>Jf_t#WkkLKT3%bTp}8STF&ZSS1T zZGCm4HvbL9mZ$t``9GT8u6+6yHoaHNe^dRZ{bv0)*YvEGm(cvJzu5FYs(+9AzpDBs zs=m`ye}(E>uH!RF`|At!A6EbII{&kpzMuAIt>*s&tM%tczw&)reu?V;+wc9iwEe%= z`qqDZzU7~`v0PDRd7l!?qx_=^{;^8io0($ynMpQ%#&(vU-^y~Fe=Na2e%spe9RBeD z|5&mexgZ^A+K&z8v23#CI^|3J_`&q_J~sUhKi=@4zyH0^Q_OFBc5L>*7W=H7cb~d; z&ThMQ{%G&D^I;pTo%dU3`l*~y|GU10>r8K0XMO#9t=&Ioo%!Ehr~d)$um4^C)J@jT z8*jXJuHp6RfBP@ne(n6-I{hEpa_#9O?BD;Lf0weg^U8IW@BeYS|Ls3}o#l_;b?xcr zt+TwH_gs7WU)R~b-F91h`b7-5|GT~=oIn4Y)9W1XCw5+Fw;b&mHL z`>ox7!8+&jXX`9~(K^Tf{&nhEyw33+$NS0u-QMeVSUZO&tevZOT03vQ&h|gG&h-Ch z?_J>ItjhfHcW!A?C<-m*PE%Yk1 z?_-s`-{*VI`c}qN@*X9mHvFvEN^-rQ|fPnV$WYI_IX@skFyke zpQYq)pOT;Tm_KFv>`~gEq1gL(Z}Y~#NRhWGau(yUtpAIOd<({JIsEfjFUs;9thZ#D zmYK5rv)Nv`Q;|Qc$Zs6$jsJB;-k``~MSel4uN{i~6|Dc{{N1m#uX~mH|F}|~Rf_!g znEz#cy_ipA`KOBgURB!bh|->JRO}1$dh~5k^qr;1UsvR)Qs1vA_4PGH{(_SK^OW~b zSK8~tO8n(Y{NE}1Cl#4&CEM#EMc+M&{0^mjMrtTK)IU6Gq*9k=3M)6zbNK~{!9t~w zE)K?edq;<}W~9GVtfuqDN=Lbz9_`XbO5~>s4YxWfRu?PzE3%m>G?~$SmZhuZ{3d;t5!_QPkMvjd!DeJITeaR_RoYn5M@mA+NZ)X};)E-vOF#$NaAmrj z9?Dj;Whb6$<3o7n65)+vZ;jM^BAiZE1MIFc^p z2l92598#QIK9k87mt}|gTs=xst%#EKL{M@|4YxmCNY^V&EMMs^RX} z#@CM+gY8yj2eRdCQ4H03dzfTmw`J6cVqHTg+en2P>J+gkvBmjpAtT2* ztUqSTN&ZPnB7GyKBU;RVz36p6=k$*Q^|oD?_F3bR;sIuXum@1qM9g) z-kza!pRIbu$ZE1XTbU58_ z;kMDyOm@JL5K^g@Dn=o7cBNXjmU=lnQ<#r4m~MwHY6ws0NkGqFsag_3QYf-Syo)KC z=;Fp9dMvkEq8XMa_wN4XJt@=d&!x+$YB`;+R=WGUx|Tc5z>E%Kp^$=&t(5`=cE!`f z!`Wh{Yvl#~LUA!|>F1YvJU!*u*)b`w41Co$I79VEBjYg^5PvgY1D^O+h~-D3*$&L#2_5HAh#v zR-xoh^e#({Wg#hPuXd+Xj0|Ve)okr_fY?+4eItWLs!|-r;;A}dqy`*-HTzHrUj>#L z*jUb2@kI5R=IAKwUc|!PW?+kQAz#d*{tJZ-LudC7WrS!~b`{ok!)Q5zbxG#zp;Bg~ zU}?nrVnRhS<*cB%HY2_0^OY?6RTZOf#H?7WE78wrxGj~JQaz)?Eu`w`T6F=nj@I6u z(nz^Ki!iG5m8RKC3zhN^4KH5vdlN9*a_M5GkX<}d>=#PW5Og|`NV3<7)OG0k!;y{U z^zg`Vk61@wMPJEc1}pYwyH--Z<90SX1_#U8LD=^os;xq0GkHWcBSYzR*+YF(wraT5 zD)iD)X}F_`RZ$<70%&by%2@Bxe5Kk=nTz(ifgR<+3cA%{lsjf6(UUD;(4*n;e<+=> zosO{YpPPs~S(r*Ii3(GDiy(F)wL_Ju8LP;cno+9Op3=xOIFc@BsB4Z?`!Sq~0m|Ew zqgGeB2zx&mxMGIOXj}O*R+lvS)^-dt*42|+ig|kk;mgvMb?7NmYmC|&SC&fy`GQVo z{-8Pznk!Svm7~oX<(Agj$~m#zAyug@bC`yZa+lcm)kKai&u*l_zt>)c*F;dXMbqS* zpyg@Z5r=w9*zU@-Ov{Lo8>5n#_QlHfAgP2Cm{7~87c<_8<$I-)A1n@G-B>S4yRTAW zG~juwQ7J%N6ktW)TJ*%XLSM4tS-8IyD$SBu*}oO4&}PMwyT5LA9ggkVuxr3-pjf>q zT^O-7ijmt}-3O}zOz>jcY!z^&n6nN~gE?3z^`#5-EOf98#D=ov!K~|Num^k3yh)1< z5N;fdAU)Ak-&9R2oDgcQrnNLZioJpRy0v;y6`BW881+uai?aRjMhFK`?RZ8RmL_E- zr_Q=bI0wX{I&Q79ysIkfEqUPg%(3xwCL`7!XaZuH-!)pBk;B%p=`GMveG7C{-U1zK z-vS-^w?IeVTc9IjbphUuzXdv}v%dvPg@fkATKUs>B|Pfg@V57~rfOX5U8@T#DWEIW z)z#OV6204P{dyhseC%&Rm09cZdlOp1Q@W7egu+@6)0I|VYda(6-@4sAei%D~o`qJItd|iJ2SQjH{%>W& zZVT2?NjLA(<(2L79&CBk?M+XZs>PmhMU#Q)X)7%1qPe=$qST&|heWCyVHk7GQ6616H`t{_dGY_L7IS9YT6=Yh zrjGN;oMsOx+BsHTD~7F}Ww|lDOIdVL$%4a$H{-w)|(o zg)%&)dkEVFuO%b)p4f3%4dPU`p2G_LPii&)cTGQGOgLE_y`@pdBgH&Ce5rNW(Nr2< zGn$l^i1{KqoX(fKFQECXg9b;M^OmH<*m$_}Ri8CwEgD{dF5xvfwmrEteDJ&vv+9vL zjTN`|A|A(U4lue%TWoZ+klnO0amgh;y_c-SeyPrEBqEb{pWH1g>&L1&Mm>ag=ro{C zvRIFj>vws{Dyg;a)OBxbny$5o$ag*MW;i1@o!L$tDCqplmQ&t3=A_zd6L(q2^9%=R z{l$LUVXOkIwF-NWD&8Dh%XC__4v)GXCdU9~-Pe>39uB*XEqjQ})blP_hCFo5mdk9# zfXJNfpRA|ba)#8`y)+W;N}abf)pc<%P5IR_4toX)xZROvcdVxiERC4rg$vGKMR$-& z<6Me%-F_&9qwG_I#mv&8lAc45h{wMDxdCCut^eHoFMNh9iZlo2+Jb z5~-QJD@Xcpc|o`|-&Atph!_{#l-Mq{1$>hU4AKt>ic01g|t)uc+SRCwq{z+;#Mtnm+g1L+TjL=^h$vzL=*ot2#}!p5CRA zxI0p1Fz{5dVJ@X|*#g$eSoCeM&n=bAcrGz%U6dZn;Y`F$1jiDz&FRNID@CcdIVIu5 zv<@IOB@$-zE)4}$do(HX;Vu{LNyv42a8p;Cz9;``%||zs@)^+#>(x57#X1hO=wZyM zhm|Y3E>=5mkqXZ+HC4&Nt(bgp70>NLcKHrVi5auDxHKr%wa;N`3`dorWlGiJpu&45 za9F8DBGyF&97z^4=|ZW_7TY*vZc+Wy<(%Hyme~BrnMgy?tkm*!9xA* z0Bf{7C}E|Bb&?gs zZPem0F7XljR|x=pC2JJ3_LWooy&{FA*8C6&0<6UCBt%F5Fz3rEkx zB|qzyt9|p#xdcl2iuWpEUAS7KUOjboLx-;mdnu_|Bzv74D3eCbh;K%*ep`uC>7leZ zMYC%yjHM@Y-sV-il1|dST(~x{ms+ctYrL;}=Pfg`!MfAujD3gue#{;i+yYz8*fZ9= zC6kM$Gm5-=wl#;Hdu#kzO`hjJ!yPxJg%eg9tFpMqS`=s8nyz`68J}`|)17@!nZq`; zLFH&!lf~LC1eiLjhQsm4A4+!R17lihS+_ToO`XPuJrUuumRqB030d{j_q}Rc_EfqO z$fj5_YnIgBwIE#qI6U3B1wOT#?=aPcY4z${Bh&hu!znlq4^L|wl;XPoP`Zx7!_!8! z4nJ(MKd03C;i)kXT2z`WV$#*dm2fF)dV^Z^E2S%yW}=v_RI?fDaIxM@Hl>ERr9n8z z4po8NlIxmF(@74`g5g%W4enf~01JhI$o(+>@Tl;dVGf`BYhgFEo>J7qz{mu1&ZEOWW$& z=4Z7LH?D|L$6&F;*q(ZFXEn!#rWl+Oy?S5s6gBmx6IOTUZRIR3Qf|P7M!HK`udh#$ zlf&7e3lq5h1uWL(?gsZlHr$Gj(%^2n<@a~|HC?OFTI$rm;W%WKFv>8(FwD?oD4{k^jA4RdoMDV% zlwpKnn4!s#Q8K}aF-$OwGmJ5eGK??`Gc*}8O2#=ch6#pohB1awh7pEgh9*Ns$rvZb zFu^d+Fvc*-Fv2j*&}7Ic8Rf(nCK$#U#u!E!Mi_<}nhY5wBb*q+1j9JP7{e&T2*WT# zlOdyIm=j}|U>Ii@V;E%^VHjp;GGvs**NoX+u8m=WVVq%%VU%HnVVI#QK{thDs|(v0 zCK$#U#u!E!Mi_<}nlfbUCYDULxrJnyU>Ii@V;E%^VHjp;GL#V~*5<+l!#Kkj!zjZD z!!SdWA){o%O`(lpf?=FtjA4{vgkhMW$&gVp&WSNhFpM*dF^n>dFbp#^88S-7I5CC^ zhH-{5hEawQhGB*#Lq^FcC&nFv>8(FwD?o$S4`%#26+R#u>&KMj1vJh8da+ z870G<7{dg^IKvpjD8mTDFhi3eqom1+F-$OwGmJ5eGK??`Gc+aGDq%OZWUC9?7$z9T z8O9h!8Acd}8JaR=>?W2>CU{_RVS?E>!x+OT!wADLLzAI|+T0Y{7$z9T8O9h!8Acd} z8JY|kB@>(&!vw=P!x+OT!wADLLz5w+WSkRYm|z%Z7-JY^7-1M@XfkA!jB#QN6Aa@F zV+^AVBMid~O@@q;QBI6uf?=FtjA4{vgkhMW$&gVp!ih0VFpM*dF^n>dFbp#^88S+S zIWdL_hH-{5hEawQhGB-L1X~$1N}8N7!vw=P!x+OT!wADLLsNpS5_VHdwz{y5VS-_t zVT@svVT56rp(#Vc)uG|IGpr<&E^K3%U>Ii@V;E%^VHjp;GL%poC&nFv>8( zFwD?o$S9fM#26+R#u>&KMj1vJh8da+871SK7{dg^IKvpjD8mTDFhi3eqhyQ|W0+tV zXBcA`Wf)-?W@s{Gl#Fs>3=<6F3}XzV3?mG~3{8fNk`YdfVS-_tVT@svVT56rp~;X@ zGR%oFOfZZyj4_Ndj4%u{G$q)|m{HQ?gc&9n#u>&KMj1vJh8da?Y?ZK^TC&xJZ446( z;|yaAqYNVq!wgLsGDcz;YGORpxUenh!UV%O!x+OT!wADLLzAI|+T0Y{7$z9T8O9h! z8Acd}8JY|kB@>(&!vw=P!x+OT!wADLLz5w+WSkRYm|z%Z7-JY^7-1M@XfkA!jB#QN z6Aa@FV+^AVBMid~O@@q;QBI6uf?=FtjA4{vgkhMW$&gVp!ih0VFpM*dF^n>dFbp#^ z88S+SIWdL_hH-{5hEawQhGB-L1X~$1N}8N7!vw=P!x+OT!wADLLsNpS5_VHdwz{y5 zVS-_tVT@svVT56rp(#VgNDMIi@V;E%^VHjp;GL%r8n?f7I1j9JP z7{e&T2*WT#lOdyIf)ityU>Ii@V;E%^VHjp;GGvsDb7Bk=4C4%A45JJq48sgfhK!Oi zPK;rKVVq%%VU%HnVVI%GkWn(~CYE3rXBcA`Wf)-?W@s{Gl#IA3v@uLDj5CZej53Tc z3^OztGD?OyF@_0-afUI5QHBwQVTPszTNyJ-nw&7h1j9JP7{e&T2*WT#Q-ZA$c2i5X zy0DF5f?=FtjA4{vgkhMWDMQ9c4C70L#}^m2C0&?c7-tw`7-bk?7#2{yEa)Di+9!Lu z@2NZ+UT`;c2{M^%bHm#hCK$#U#u!E!Mi_<}nhY5w@fG}zub*LpVVq%%VU%HnVVI%G zkWn(ui7`wtj5CZej53Tc3^OztGD^lcF@_0-afUI5QHBwQVTL9{M#(5A#xTJ!&M?L> z$}qw(%+O@WC>i0z7$z9T8O9h!8Acd}8JY|kCBvK;!vw=P!x+OT!wADLLsNpSj2R_O zPMBeWVVq%%VU%HnVVI#Q!Bz>osU=%o*v2ryFwQW>Fv>8(FwD@DA>#<$Mp%k3F)WA0 zfQ7%#akmTGk}gazj5CZej53Tc3=8;X2P`*rlQl}H%?)p3m|z%Z7-JY^7-1M@XfkA! zOmJch6Aa@FV+^AVBMid~O@@q;aZZe3f?=FtjA4{vgkhMW$&gVp#)&aZFpM*dF^n>d zFbp#^88S*nIWdL_hH-{5hEawQhGB*#Lq^F6C&nFv>8(FwD?o$S4`+#26+R z#u>&KMj1vJh8da?Y-P+SX>!606Aa@FV+^AVBMid~O$oM2*i9|j>cTdL35IcoF@{lw z5r$!grVJT}-2uxK0~Y=|1C|Thk}gazj5CZej53Tc3=8;X2P`*rlQl}H%?)p3m|z%Z z7-JY^7-1M@XfkA!OmJch6Aa@FV+^AVBMid~O@@q;aZZe3f?=FtjA4{vgkhMW$&gVp z#)&aZFpM*dF^n>dFbp#^88S*nIWdL_hH-{5hEawQhGB*#Lq^F6C&nFv>8( zFwD?o$S4`+#26+R#u>&KMj1vJh8f}q8=Rhrp6p^qNz*0U7$z9T8O9h!8Acd}8JZGo zm9U#yvekuc3=<6F3}XzV3?mG~3{4qISPWCGjxmx+7q&4>FpM*dF^n>dFbp#^8A_;) z6JwZQ7-tw`7-bk?7-ncPWRy&BVhj@u;|yaAqYNVq!wgM^jFNFqjA4RdoMDV%lwpKn zn4!s#Q8LDfF-$OwGmJ5eGK??`Gc*}8N=7*`h6#pohB1awh7pEgh9*Ns$p|OLFu^d+ zFvc*-Fv2j*&}7Ic8RoECGknH7%)bt|HuJw)Y%zEfKFj82_~~%PjN-4E zo)=%6j^AfEyJY>)BL4o%>(9U8{Ja$XCKP^}(=g~~8k-3i27VgS*o5ETs`sz&$5x2_ zQ__Yb<0rZd=Rb;p@4~`&zFToExfkF1!m@)}?Kq^5lKs%X8O8*DkID!do1HlHOj+L% z=TfPZSD&NjwQ7R)q7RPyVNxytcfHI(j?!jk~^Y;YaXWs`T%XA6fZZn(!I3 zd=@AF#g8oE*Kg<>^sRrX)Y7FFE#nw#?0R)x-Hdve>L2oF|5AVzOVyWF^j&ihefWt# z!?HCB6r5q;CmV(QyK{ZU&G>y%vJZZS)p-B=e8$5t{`f%W4j9ojpu7{;uezkQTJQ{>Mn@?DDj8Abk-B7Z`W zZ&u_R6?sgNKcvW;75V*&yh)L(iae~y1x3y&az>HYDDwLh`C>)xRb=!xPkk;`dUM5ZY!zb((t1YpTVty;uAv_z%*qp|r}S{aVBQO2hq3 z!~I0V{i}xizJ|kZ-h0L{p1vK0nq1yg2q2XT9aKG1Z&uO^dXt+HZ?msl#(;Dsx z4fg{L_s<&cF%9=k4fiz-_Z1EIMGd!I!+lP}-KpVj*KoILxSKWH77h1d4R?)(d%uR; zsNu>QZb-xBG+e)iyIjLvqTzZq+zJi1M8kDyxONTqHySRk;Y&lZFdwxXEB`-+x`hy{h3})NuPW+;279UJdti4fk&v?nw>zLk+iE!+l%B z!G}<@KG>z<9@KDO(r`O8+`Ss^E)Dl-4fjb6w^hU4sNp`M;jYziS82FS8m^+@iW)Aj z;W8R71&;g;ygsk>8PIx74Zl#MYpI4iPs4R;xCI)nO~XYr+}Rp#o`(A?4L3)_ov7iC z)o^dua7Spk1`X%aaDNKa_JcoaxR*8D^BNBO*P4FypBnC$8t$hW?#CMLUo_m~8tyw9 z?hy_5j~ec)8t#4#_XQ32_ZsdV4fk0M_bCncaSiuT4R^hU`;dmaTEktT;YKvvu!dWw z;RZBZTEo3h!@XC-t9YG~9I>ZnK8FQp0V~aO*W(LBkDdxIPVc znTESq!}VymwQ9JtG~5{)ZmxzqS;HNt;f~R8Gc;VIh6`x8 zH*gLmpUKdAYeK`lqTzn8;hxiQztM1eG~9n^xTiJT6B_OZ8t$Jp++!NM0{;U3m-yENQ`8tzLP4hMKO zdA?V}-KF6^t>HeY;czfmlg5o2?jsuRS`BxVhEva;XD+*x;CI}>+z&i_>Vt}(w6eFb-Utb05&arSGSX^+vlZ3ySKqeraY_Hg}k zTRNY2d{T7gQ;}rnEZqs$$*1BSS;vWxM!6q(LQ`>-&Ww|5TBGqR3AuGM$mg`o5>g z-%;d875STrOlKsrzK0a~enrMTOi%pnicDuDvc9_&`Ll|An_ zBF|Ukd5V0xBF|OiQxy3GMLt%Mk5=Rvirl2gAw~8n@&Wiw<@PzD$hdFo34ckE>5N2v z|5-);jUr=i_r(8&BGVa(tnVj^{DdO^P?5i<$aF>`>w8p@zp2Q(6!{@VrZW;*-+hX_ zU6JoqPmFs>maXyk3!q6gjWRSw&7O z@@0yAi6XC7yfnId;9a+e}^DDnbDPAYOtkxfOOugLQh`E*5|tH`G)@(GH3tRf$+ z$TJkVNs&W}>{DbqBaz$7gd)GH$S*1K^NLJoB(lEWDDqxK{)Hm{RFUb7MAr9&BL7g4 zzo*FGQDizJk@bC3k#{NbLyCOABGVa(tZ%y_->b-XEAnR*na)ULeYYy|Rz4k@xvkq^LsDz^_hBa!7-75ODa zeqNEERb)CNk@f9WVBZxor%NMwD#P~@K~@=p}` z2}Pze5?SB(6!|-f{HP*-Q<3S6MAr9^BHypb_bKvrMW!N4?{8>f5O_6U^WI7{} z_1&b%*DLaMihPYCU!};Siaeso>lJxOk@Je2RphiHU#7^HDDrAWzEF{uDRQ?WcPVm* zA}>(nq$0-@*;M5Diabw|Pgmr*ihPP9pPOS|gVfwqLvS0nK zkkPBtu^D=C-*GFQ$&BIidSm#!-u2Sw^^7{7*Q2;O!-$PZpUc~Z&*U~CPZ%G!M)A2l zd>noj&VFvj{U7(Uc>Fm%>)c|m_?(_T|8gIo{MGxMp6f?<))|qUXW<i=52E86#|_>A{8eEvn;W^jFd{;ePEMB7I^eAeJ-vgLs*JMbCG$55rltbJ#FZRpu| z_=f&e@^62AFtB}pDu~Zkh7jI>^rme;@NM7L$w0#se+UG3{O3u=u2<3aUPJo0gS?{= z?Y~ic=DdAkTj2QpE%s;LozIO@9&nd>{aL3Ny|awXPwq$C#C_&7Pr`dwqHkcVxEcP6 zttY*;krZ=_k!e>e@OwBje zj~!w3{sTVK|E_gw+txK5x#flz-v87Ze6D{w^t3;^=G2bB;2lPD`qaJX!+Qe9?>K+% znp5vRjz6pWS=ga{?%Goaz)_f$7kqv<(1`OqqZfB2aLvV-Wi;nbZTxZmRA(GGtz+!= z=K{uoJr!f?HD_9%^__D(KEsM}rSbjkAAc5nldoyZnfIsKQn&inWAD~G@6lA-xewti z5IWDj&scvqeI9s*@x*h8yCk1)OFe3=#~P=1ALK^g5nHD3O|`Af&ueRXDb?1rcTU@! zm*%wXMHrQX>^pu^`>r`5W4&Wj=d;7uC-q+H8@PkwIqi|+pU}8@RVrY-lz!mTw>vso z(B{tn@2kJ^I?9`zX1wIX=WOM=adiLTxb|H=u)}WmbH5k|&@W#XpHDu{la5t)C+?uS zrF2P_^FeY4bm997k{F{W9Gla5I@*+nLtZG}s2q>Z(-F_Z(YZUgU2?qfX~u-8pVK$5 z!go~M+==gaptJo$iAQ;9$*4@9>l<_HO|9Fh%O%=u%=*owJH`+XIpqjnC{&$D9#7%zOrgV*{4Th}1nevE}Q-dba!HBZx;WNdBw z#5m&7y#VLl!Det%jn%nh5I)yzFqkV=-*JuH`#pCr-c1 zH?OI=b356*88(mlj0s!!R!g_{Gw*BqjIGl#*3R=y|91ejMLTurF?o-Htm;4`F_JGKBKZHvV+WniJb69)0<$r^ud7 zM;^PS@yOX*o(nYX=)KO^zwUvK?RWZ)*!Ku@+;mfF|NLv_?4O6SUhO+_AAJr#zr(jZ zH=D}s%^T@bzgu9c^~yt@^@>%8W6!kHdIMWm=lcQb)a`FYJebQHZ|u1`{ChCZ;`<5I z_}74U+MpUHuU)A9IBjEWcKbvQ?M02h8NAwN$lhu^(nbBj)rYp!64dCUHm0nD#!zp& zk+!NsO=C0SsqfaVHN5qw>JVxDY4V|$F-A;&o4$J|h_N7qwE@-#AEfWzQPu$;JY_%n z?SwPd?)f{cN&ME_I5}x-pM0A!L2cw!>f19hHY1$mIqk;%j|GihTGz~ZpYhT?Xm_u^ z!`S-D)kd=FGajPvix}%Pw$6V3{kK?aKx+*u^gLy3-|g>sU>v&lLLY@cW8WS6*4k*> zUg&Y|`)vE*Wi{j6UZh3g2d-RstPB7M^ zExUV%x%S?{u`{)Qr|nUjYVoXLt#)tM+0nE<)U_|UPIYa~T2p%K`EdHEZcj1xnA*qe zJ;8VNyi?viSkI9y54L8O%Pi)F5nku(+BEhT7anYXQKJ*z&*a?M(&_ZB$-VZQ{Gk7d z*9SwG4;#>4rlH+5qE9qoeeT~%Yh-7vkK_AP)Uu~9qVdMEgA+zJ$#tT?hKvWVIH!GL z^cmmQRN#bto6#qZ!}#_`zp)kHdvo*g0b?uOLwgjKcutqnG2WgFmwZ#PXHV?gsK0O{daYxgPj{RqXOZiUR*M4BKm)6+h(0?NMB?01_ z_N6iA(;6b@U!vU$=KS^@Jrmz?6XEuL1AW()^xY~>d7V6_FY46W;?mAt<8$S)+A32H zJk`sbxyJhOIh+pls{@{Kwl;olhBtm*6FsFR^O@7xwdncv+gEc^L(GWeLDK!68L~< z&(-0(9&2&AuUUF>k98*-Phy*6fhEoVR(v%rRnAHF$<1Q>-0>!KrBCJhpnbb+BN{W( zr%||-cM2!l3H}V`o&1S$>g-P1bDDc$+g#Yf*AR|dxOpb;tsVQM@s5LELmH0#o%WH2 z9y#3Qq0`}=JZwG$8;JIBB-eqX!)Yf}pN-Smt~7ouKNP(m=-k!PpwatscXIdJj6{x} zZ*R1oN59>A9&^0)oY`zWXSG<*V_U7~?6ySiHN1Bm-lymBc%Pmp;C*_Yi1+Dv65glh z$#|chr{H}&TYPQ!IE=FfKE(D_#P}N0lmomN7jR!0^Mz;KLi__pQIRyJr zyuIfpW@5c1w@Kg$e8-+>lZ|gTCdlt{u<*%+{wMxa3ZT6P(QZR%zYS=|@atZQ^=iPs zmG)bIz?yK*RmOIViDGYdwcoe>>JJ#(U&9`1_eVSSKR&&ESJMegUcMV^%@oG{G@e@? z>)iib;H)!K3))|P6u!nA&urgy!wE+pliGWp@N+(ou<6F;W4^Uu_~pIuY227Jj(L9a z`c-%OW~?K>(v4@d@46GZ$k%xT_WPJ{VmBPqkz7kp?Ca0G&4|+bTcGzwq;=DR_FIb3 z|10QkZfbwMy{Y4zXD9Dmb(gREb$n+~FZa2bJD$OKK=afX-fcv>&mvv=e#W~oo{gPN z{=t?r=bSS9@*1oM<@Y-6?`x#@jQPefuP($mfd5F>_??d=pFN^|f_!qZ`)|d(Z|%*j zGavF9Su(}j9oU}`X*bO}X3o*=>v3nbH-Yi;`uzKDnKxt21J7N#=7Dp4)AyxcpX|LJ zWxfIaiknd8kHQWggI(4k&o?d@zNOpObmlzY4E%T0ne$FDj=@*$u77s&TdOvs%v7c| zzV0jbzz%!fWAr|Pwz3ELbIWa~jqfw?l(A1PWAezJH(SP>u|MvnC)xB7v<2CwPF-yN zdVBKCrZxT%+n%WZIjH|VN*eb_^=+(v+nX-a__as}ZS7gKk8{zkRok6r+ivrv?W1qD zEFQZdEvqf&UiO|v&fMX5(t7yK+f7buH+-venwHd-$+jJZH}2i=RL#7MdDt^AW1e0u z*1h`nFVdND-pgtoohGOA(&$rIV>~hEXzv;$Hfo)#;>_6o{!e`xWALre`m?Uh5dN0b z5Bj1m9k)#*{4Gfb{eIlDPMW#Hu^0J5#d-{9MY}P6HJ;M`ai@+B*$iAFg%AhcL##8E<|Jl-nNlDN5T(v%OxLh-XZcpL$DdYW1xh zb7JqSX^UtDluYTInyBgQVt?f;5rUpR9|r>%?1GCpyfC!NQn zu$GDclJ)@@|D>?o{@;7TobgxK=Z}B%gxw>}Gvlw#sh{3!@AQOSYqtf`nS1rGy@lef+g^IFCro~C{Kbu)Fxh4;FMh-m zCg(Hv`;U3T!uq7J-0!~R4U=rPZQs?NFu4rl z&!y^ywLCXiH!SyT$rC2m!?y9sxZKvA@kq4K|C+XQA=c3cU4PJ8X?^>Ib9P`%H=-xu zT=iu9=e#=`YnZ3uvwt1?2gldt_}#|Nz&(~w`vks^`@u8kw{KsIGutHx7Cm+6x6jTKG5UZ0cD&$tQN2-8M)^BXp22-#}d5J|%ho?bxTBfUTAD z9rCnKv1GAN@$niSztb_R@j{&4{Ap68NBfy)P=}4+=?;$HuCt%JXXMB4aO(dv(~PZG zqMS~-@)MH}Vej@NmFFKOCh=Pq#w_bx-J5^o==NPt!ro(K&->V(_{|j0oa2=FIOsec z|4kq*$IfFoDW?^%8}vg5c9>i|0+WAGO>&28V_i1Zqfo>;pD8uzvT_hheS zgJXAe+I9F7dCz9Q-}1)fLw^7-w^673f5aKi_))kQ(qxp?eU=l4!kym|*e3b!Xl$lC zi;msu?O(^JE{3=+?(+CLrFH3atTPrIIrBBtg|6+z?*HVJdt`Z?p)2bc>0kEtnQx_T z8V62;4MZ99T*gPxx9a9$e&fuyV(ypqUu%zzGUwEvla}+F2;+CQC!0<&X6`$y1NTFW z^=bGXI`5}DK-O>EjD_1r=gd8^jPLF8?7JO(<9^sN*??rm75v00D81*SS7rYDOmD4ZJLA#dwrZWb%kj?Rq-N*J*onHFilYd)Vw%a^q zbNY)@7Fmbz-P*rv)A&BiM$_NbE^O3s|K{8KBpaQGe9^c-?>l3`A93zJ=eX^1%*`E8`V#G{{`>E0;Lew#6VB&|D!#$7(#kEVMM z3lXmq@jHoW;NM|~0jxww{5p9j`b97=qME5i3 zKF75fi$*Rtk|XwAj%^sDj}vz}`0RQdcQ{7wF}APq8xwS|#IpS?+~u&^>D6mvZE9Z0 z2kP{N*9ZR*`S+n5ew2rQAByfD(QliGyDIN{1pTS~mPS9;z37Lp;hcNAZ}#_7zFGTD zgJ0=q{#jd=1RB48mVfgt>wJyhzZ!ew4>n>>Mj!kh#`!&rb`xqS}OY`bR5?Q4#r`$pDT+yw0LRm?3kpVKNZuay2Czc=1)lrw+%Bgwq6KaoSd_z^GHU`&kr8@Is6nIxOaciQ%+ zI?$%SBYtzmvA6C%kmFCLab_|Q*iL6M7+-en_H9cv!iU*7!#ca)2A{3t$GAcHJuYWl zoQpg;c+UrM9~b?YzDvsC%Co&*d-fd*x9>UPkp*k~n-}EKS8<1E!Z|0?-FMnE zryb$ArxoyRAODp#u0D4h-3K++_hL*Pn~rg_!?^z$+_|1}iSZH!3#@C5t>+^z<0&Ia z_841&^%>f-;}hS8e%(#sM__z-r?Gu}-xgX|j?QT`lH^LUqRLGkCj=o4qOD3>_jG=92fzkL_?W`t{h=ZX5KnCI-@qnq^wcoQ(B1g?HeN5bXiB zO*0;(H96f;oG#YF)4xB@c;v}**EjCN_c8W1-n8iB@T4I^raJPtsPpue$|t zD_6}t$r>+}J7SvqlFq#_tIn)7(Kg(fY{742jR&NAlW0Fa+kg1#JFv#ae^fU<*o5kS z{A%<6gd%oXQR)_Rb5v9?AS#oG%#&Uo#%b9?Qmy9@a!+JbIeAYGFI{}Z~;htRrW zHtwk6JBc6cz*_nd%v;VFviovt40*gk8bfejnZ}TNjpE^F$AACm}N9> zhCOHw^4>j19;oflveLkLKjxU-n8&tZzJ0|1$b#L|u}8ukfIUZSUO;DVV~cCYqIs~P zGZvi>A0O&slyrO#eZaCO?OpU^&}p{)oiT{gq4a1B!hJM%48mT2){jx`t9#jnt1r1Moy`xe9~r&sn(KaZ{Y_hMz3sDi-@E*43+rIE+PM_$ADTfHW^nL*BT!&ZbTFLr15FvF5_N&nC(l(gT^l7VdLAz zZsUi>lg7UpKR5Oozcuz5FB-2JuN#v_(AVTU$~V(@yzdm>X})**-sLlWao^wg+I?NV zCB7BDUf(6Y%YFU6oNvfi_HFdN-*=7g!@e!Pn|-(XZui~k`~Hde82HM=li|y72kyK4PU_D=%3*~#($juWdB_M8UC~Ut^Sz*9RIog zMgDI8a(|EiV*h3SKL4P<;9u|G;J?zp*?*n?2LH$WpYY%2zr+7`{%!vI{15nd`oH0S z^ey<`zxaRb|Ed3%{{Qrk`=9r}?Ej zSPnh!&wcj4Y7uE8qRH4)X?3qyrHMz;)cr_`Wgls3JvQKi~hHv z;mU^1Hntf4dtJi~4Ik5leWKwu4a@KSzliQQgcAQ9;%sZUui=3y;_htt28T9$x8eH@ z|H`tbk4$C7pEUfe?pwdA8=}|v>xO3=UTFA3!~TW?hxw*n-=lv2v}x0hoObjy{4Obe zSNm9u#Ag~Wg#PlsgInNi*eR^oDsG%(yvOLo?6t&Lu7uUsxXKgrB9ElLb*XW=(Ps=8 zYcV61Ma&Jx6~+gqd`H!Bc=ENzhm9Mc|D(n&n00SA?lA7rruKQv#a~3o15)T$jjs#o zVdF95yT;?jk1#(!4d!Q3oL?HxV77kFc)@ttcn$OQ8;0N4;G2#a`xxJB--*6cF=wCQ zJJWZzFN|6H9N&920pGQly>IY+)OU;T zlbFBn@ZID4yl)3)@CSTf^?lv@`X2ZF$oC{>@t^sA>3hcaTg>Ax_+IwC=6fA8 zx!>R5pYA`(e`t0(#y{JCq8;~C|7n={&-9<|5BuYo``_d5^e?ut7nUJkS>yz#Lx;lmimLq07Wi)9am@Bl2A&T5EbvRr_rDE17kDA?GG_eO18)TU z!3NCvM+J`w&JLc4S^tI5X~8q__u&6KGk7*u2l3!J!S@6^gNuVpg3E)ef)`;uaCxvV zI1pTm6+t<;LFl?7_yMd2J`8+A@T0+7uok#Ict`M_;O8;>e=+z#@T+ z!5?APe>(WH;4g#EVBWX#@m%nQ;LE|+F#o?1^oJTk(?dsvjzJ!0hfWNgidDcFp)*5g zi#&(17C0yLo=~SsZka9*^@RpPYePk>7dC{h2z?-QEmjOSggzR& zCG<(G8SV((6Z(8;2UZOaguWX3dgx)S8@?NQJoF<;{&Vc1{l9+CP-#Q9xsvTK6*JBKxqKnhTrD*ZthHQVeRBo>Hrwd9EYO*+FDLs^^nf!))=AimY z2Qx|<_Vk#wCQp=g+3qzFvYYw~Bb7Yr=b%vw*#TH9m#4o|>MZ96bB7i)lP|-*&G}*` zy9rIrBc9VNi_HU+ziN4;zdBOR8cwxr%wKUuA!|6Mw?#B3!)Y)^e`#pARLmBu^Ec)z zSyAWILJX@8jG?Pf3R3ToSa(oW8;vhW>SeBVDTA^*G`PKYTwld!` zl5H!Svtm1(^^z5DzSEVALTNCM=1*mH;3f%^b<%y6QemW;U6daf$daGvr8>X6*k8^Lq4q6tQPvg9Sve3AhxM0+N1IE1 zYtc4QSw&=$+Gw>cRi%NeuT-LXw&;;MJZLjsC%!fSFKCt5kcb$M*07Wh4LwjOrS%yR zAvJ0;rI9`ibZRN7$V4I$7{M*PL)%8E;qyf^Uab?KjG%d;mLui5i1BC*YZ;-2c8#D9 zsbMW6xU^MhyZD}LdqVW_rCf4s)n49^I!So!;C(|%#8$1TEN_S>5pR%N5HGDygyPiG zMPWK+#7o+^EVUJ-gt^+7S1L=&bFDTt&{Zb|DEg2P6;ESNZ-}ePOM8pyXtI;jy+c7B zdrJB!tlm5NglbJ7sS|-ZeToU3ENN_@1bH&9gt-YRyp(Y{gs?o+s9{=l6seBBT1&_p zy{3>u6k8wxjTxBrSb%9MQ#MIy$mNr0oeqlb7Fmj0tGKqHc64tUZBi*7C8H^yM0+wP z@owfMPRg9a(o-(B%xhIs1dX2BQaYNv#dKJuoItvxm2D2y&if+ zuShDbtEaZO-k@4dN`WakYk2@5XVnwn$*L#BO~AuSS!JG(J_QQFx=vm?S$U!W4P9Gm zPNlY*EmcanT@{+jR>M4{R|DPbsR5D=JVB}%Y69yg=P^gkd-W0&5%t;B8HEhu>h``y zLG@lyDpzQ*ZChI)JD^rOw5Y|PxLTVz0ebbdwsPW230Q@pfZ7r(VQyZTSBmTj@MOvp zqF1ENlv-@oLm_pN@D$wphLi}!ibt*W%Ww%omNu-`*2R|DURaQq)0up_STQo$!E!cR zF)I0D7CUJ1sHTg9w2?}e`iT`)cSS_(tHn>ndg}d1X0|F!&RVj%sNr-@g#u4(izr;`^_GXZPI#B&fvyvd z#w}{XtCd))7l-Z1jSLLH6RgM=WBgaB)x#>Y2u?#%&s!s^RL*v`xH9A{a26UWD_ z;-s*G6O$8mEg|l6A=rDSeleGU9S_j$E6|IdVxkM@&jNVp7VHOUgNN zNhwDzC+BD(+6cypY(~zJOUgN7QpypNQjT0w&XG$>IdVBUM;DHyGj4BjtC-lHjp^a@ zOXd6(rD7F6XQ%d^AQ}?MVO|rkD4!k_UTWu!m1)GJfnoVYZe*7erqBn#9CZTnbyT6n z>feBA^Z_f%dLAay2e=IlHF%I1b@T7)KyN#kj(R0>b<{1I8>3zs-3WCH>$c&#g>_@p zEiA{VS6Gfwudr^6x`lOP)GMqT!76NjAwP^&Fy_BJPHwQ+Hd~EyKgLY=FbAhym27Wz z6K393*$U1vv2Ga37p1ui=SiDnF`dcCqBrvLQgL-LkK?@|zj4mvL%0j0H4~*7Fsd7Uv6v=B^dP%SQ@@xkgWR z{Ro{*PB)h3i|cUgxm4h@<6iZeI*Zg+w!0| zMuqP!5&G3r}#IwMNngzU+i#i;Li z^G0#xRD|rw8!_IzS&aIYoKByTHz9lSW-;nJ-n>y9ITay$@%859{cuMMUwQqV$YsFJiBnx;-Y{l}H+2Ly6mD98aAi93V^BZng z^}!>B8-13`W`0HZScI3^9c(^m8v-bGx-WU$+%>cDOKkWmrEJk3N!lQl&QGV02UYXv8ddb#)<+t5dIT9 z$=hp`a8;???7T?MEOukD1FI7*uRQ$a%d$hI@~BqwdaXPWJK>K|U+yNylviI*4tK{g z#(CuA@w_kmN4#n_D%RaLX5gH!p=i+sZ5zv2yK_vkXoO6PKlx0=pzC0^d#(fC4yzE$ zV09b8_74+_QpCdUCp6)*@KQH>0(%%>mgn!h7|iP zE6hVt!Zn00o=9FQsFi~nb0{>rth0F*w^%)roqZ2SDX4@RFI%wc&5dUhYCK9&7}kyG zFxr@wfxU4BS3kBD;uNx*dXi|j9wnA}J(TsHCV;EM6Q5{)$7>+h;&tfyxpynCrT|n6 zR__vX+hWW^!)2_e;i1yeq9Ap`psG#?6$(LO`0*y=S^>e>i7&*oBwYTTrE(e5

    ;1 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

    -aVH zx+)dh%lK9Hk}3t;^O$DOsgkihjbCA3Q6*t}9A9UTsj_T)7{AOOQpIok60Wc>sxoK$ zEWXA*qspZ16Zj?eaaBfbAHgrO534d@dq1Yw`&8++y$ip<-l!uv+OBV;=9K$wg>T9_JAsjwlCl_ z?DMM3*glO|?47+dhO(u@9=!XL~PxioHjbPTM>1N%nSCT5NB&^K$|A zhAK7O__~Qtuvb(m+P;R5vlmoZwLOcEvGd;mJB9xyYvXp37-mnX616>opJZQFC1`s9 zA7%HevS9l>eu8~Ym1*0jFvLEoiqG~je1v^el_A>)@#E|Rs`T34gCAq>R;9!Cb_}w& zsnUGEKCT9Slzm;5s_hkgn7ypZn(YOAh&``L*7ghr*wd;cZBO8X>~U2hwlCuY>|s>` zw)^oT>`SW5+dhYW_E}Y?Y@fvY*(X#Pvwajl%s!&ZpzQmNffNp%=&f;C{GpbD5K7n_#kE=3j`v~5_KCH@s?fp2<-ls~p?Ok{~ zd#5UGwzuMK>@BLSZ?ET5$6MKJs+4Un;T(HWmAvgayoG&Lm9*_Ecr$xSmALIOyoo)k zO4#-g&awwpS+ac*Z)9IkW!Cl?yn%gMl?mI&@p^WjDkHWJ;|%+dD*d+i;dSi2s&v`j ziPy4ssM2bC3tq$CY}-)kxbgar)9h7MO12mAYW6i%a<;GHRqR<+R%}n5WP1>=WDlsaX!`9oBAFJW(2rN#ErPuZz zJe$2+l@8n6ag4o9mF9N({50?^_H|XNwpZ{>_OdE#wioaW_Pi=t+cP-Io>nDkdjd~q zkE;@~eHl+<533Te-H)fTFR3zb`y7t2&#E$x(_Ty5In3^}?xf2QdVK47eOvoHz*9J` zqDs;B0-nsCS0#h)&rJy0wJ{htV^tr0`IBQk57ULXWBv#y)yT6+a$KUs7cr52DYhGK~k)r&JloUb;_}5j=oC ztjYlHPw!Wy2lu0QtI~lz^mbKRa9?_J(}q&Vedsk+%D6YZq)Gw1>3LPMxEDR6N(%R+ zCsm2z9`vXxVeF!ZRPp2P^d(j1aX0#$D$}?teM*&a?4SD6&h&m&dT=Lt zw<;ajL2p;31$U%3`Nf7($1U`lDrMY(UQ(ri{1()gS0#)5*2b)p@=MM)rHT*vl=bm5Qm62U--SxMt8c`mnr0-`}msXlo8#1T()sJpQA0@^x%1nW3~RlFF>co7!yLM$M!En9MU0cP=h zOyhZ&LSA#WB=B5};W-$=voVZg7{s&Ck7wc{o`Lf?inDk+PUC4fiKpT?j^G%cf+Kh` z4x!)x@*20L4^P4#JQ2I_1nj^eY{TQR1&>4b_3>D&;~=`PkH?_7i$`D@562Ypn!3e(JvT;w&D3)3`rQ;(j=e zJvfH@;t1}8L%25%Ag|$D`fxAo!9B4H_rMP9!ZzF;TW~jQ@QY_xtYaruaThG(&gj05 z?u72^C|?`43wp~K{)5l^5&S>*`Hz3c0c>I){tbKZf3XYyiXGU%Hv9{=;QwHQ7l}V( z9oMmn|BYq*6BhB0Sit|n9M&<5f50^U9#dGu1eP&|zrzUr7Q^_T7{n_2@!xO}e~t6_ z9?s%#a2o#uC$WO#`0qG|@8Ssl3Wx9=9KhRne){lM?7=zgLU;Zh_%m$7pJEICEApJQ ztRau7#q?Dt;Qv_&gTzIV|8an8PS$@o7w>`}n2sUOwLvcn`+#Zj9gp zhVd>8;+^QnJ8%*C+}|>fx8p26gwq(nNqi8;@c|sekKhRUaR@(*1Nb5A!zJv&4`LVI zhaLCbgZLQw@hM!y2u@=ZC-GSv$IsvxK93{#X&l0*aR8seK8#@xK8IcS0(Rhw zxOvm?$mUIxQ=2!fe^*w+)lg zZDV9|+Z37EHcRHWEs&*c%VcfaI@#RTza7VK7bc_I#mMA#DKfKNmdtNgAWPeo$=Y^x zvbmjqGskZZlhMsFGPyZLW;SQZ{N@5#+FT}Uo9kqAv%ihw+rnhDEk-8WQe>trOXk}O zWT~x8*4pZ1Z2S23n>Vd)pCc>VSIOA>;_utMDg3@=(*ORz`?=Qp3uNW}Rrk;Bh4#&x zs_iwh+3w$gBX?LP<2xkC^bQ#^ze9m6?@%GvcW98oEg?Q$(Je7DwPl4|-I61VTS{bY zOP%!Z7}#<1rsW+YWMao8nb|Q*7Is`CD?3)n#*R%g)DiCBJUim#N=KT^b>zuXN13d5 ztdoJAf;(;A6xk_CCU;7a*_~F&wVjG&b*CEH+{wQ)=fCqZ8Q(cUrgzSe`JD@7dFKkb zzH@^N?h@LC^WP;#rgm8&S9i&g#a&8dZI?Rf?+kQu{+$sr(U~MOomsNbxkgqxt7N0I zNrrX}@5=e_8YfqFO_RA@^JHn)GFjhsoeb<2+>P_!ElMVLOOe^#R>`&9iez=S8rj^< zzdPr@`!X5dJwc{-&ye}u3uJls3c0>}gA8_sx;X!?7@6u?Ay>O{WU;G6*1GDXe~-W( zoc|sXGO-#mx;QpcgIsg4*WNQBva&`Y4S=_%wh7JfHz^(1?Cu{rHS>gvI z_~-Ni88UxBfh-?TA=eLRkip(iFSphkBU8OA> zW)94fg#*{f%7Im~abS}S9TYx@XXBtaxpGjN%pH^`O9z$7`a$bt;NalFJR1i`$>hN) zGJEhUxpr`otR7q=n+N;*csBZ$$#`FaO!sBTd|!bq_f^RCz6KdQBy9kN2M z9+D%Ahm^?LA$8J!Xy8!J|Ii4TI5bIS4$YEBa26r$l4Kg(tl*&NY4Mr2$?uCNoJ1Bl7%DJ z$jXsbvTQR!6ca(%#ww{HL@~TB^!fHGIVVCSkC|0IJt6cn#>)WCrihc$@;PD zWZ<~qah(5gQ8Ia4ip(CjO0FGOB&)~O$mVhW<2nE1m&y3?2{L_rhRh#dAj`*B$o1nJ zWN;`n#Q6`!$kfmZxjK|1i$f){HdH75Cj?I5{7;CGi4&4!=7cO+IAM*foKPhjCp5{> ziQyAD{}bcn%86+*cVeC_omeL8C$5u$lY%F4{wGDrU{7C;5jt z|KVjaKAa%a!x=I^Tp-KC6>@#JK?WrxoIig;B|O51{pjpbQT8vDc zwnDC+mLrR&mB`v@b<%%&;B?Oa^az+q|IJq*K zCUc{CvNT#I>!a&r;EdoIoc|e7GI>Ud%$~7IuANaND`!;6$eGbIxtBAuWa-Q@896I@ z7H4}_hzyJc$GDfVI9V85BeP?xWNK`Mtc+F3^|1ySI6HVY=WuqOES_B=t7q59#@S6W zcuwdXZuy)jnK&m&rq9WcxpVSl@thJ_J*P%C&S{dtb3^BH{JBvwac+`KpPM0b=jO@c zxh1lCZjEf5+a!a&kdNbiQ8M96l4)Ot%=z+U(N`j?z8cx^HOb(4q4PNYyeOGCFG;4) z%aFPA@?`P65?MX3MmElClEL#s=X3n|Q8ICUl1!hUA#>;F$>RAXvU+}vY@FXDgBOG@ z;P?xoWa5G(nZ6)H<}S#S#S2Pg^@1ANxS&Y}$3x>BKOQ9$<4H0-o*{GNd9pZOBCF#y zvN7HygBOM_W#S2Sh^}-t2xUfkEFA816@fStO#6?LmeNl$Y zU6dz_7nR8BMK!Wf%CK;RvO>q1~ zluS${$@D~q%uVFU;zWt8PSnW8M3W3&61s%rFNu@sm+9F_|ROlNmBMnJ0^rC9*nMBO8-VGI)9Da*n?|N+vE( zlIhDcWbX1jS-iYNRxhuSjmw*4@QTnC9DhZWOk9y9(^q83+!cAUctwemtsxH3tmugs9SEAwRW$`V<Qs$vOf|{i*3edt-x?(oTa#pZYlh5i&6CBgC9=A;MmDxK$>3F?t2q9uD4Dn_Nv5yL zkh!b!WbvvJS-q-8Hm+)t!K*`8bNtm&GI4d1OkbTLb64ld;?*UxdUcI#T-_vt)1hgO zpN^7==_Hw+&XBq3JXxGBk=5xM*_dvU!D~X-aQrnoW z>6#{Iw`9oNEqStdONp%BQX?C;G|Avx zXpZCOqGVz&Nv7vAWNt1`7UxQ2b*@G>=9*;i*3hjSe`}OX+?piQw`R!Pt$DI|Yl*Dh zS|b~`Hp$>^q1!nAwkVmnElH+t%aFO-@?`P05?Q^iMmBD1lEK?Uw{!gMQ8ICRl1$&8 zA#=Cq$>QxLvU+=sY~0=?gY%(zj-QW`iTNa%p3jiE`8-*iFOk*x8rhg{lEFJdcX0e2 zQ8IByl1$%`A#-=+$>JR)vU*32Y~0Z#gLj7RwnZ7ea=I+ds#XC!6_0AgE zxU)$H?+V?;@pnbZ#9c`;eOHFe-IXVcca_NMT{W_CSCb4bgcdk{Axb6|l4N=zL*^Fp zWO1QHRu^hyW1&d~?+)F~@pnhb#NA0UeRqb;-JK_kcbCZO-8Hgtcasd>6S{}v?}?I$ zdy-`Oo(!40Cr=jdDUsECYGmV{CK8zmF>Cdu@@88UZoo^0IPB&+w<$l|>v zGP)RBJzf1p5??knHN@3rnrlkxi!Wb;1%2l?IF2P0(u zg9S4F!2}swiZAiItfeAZUs@;QA4+_P{loDOw{8=>Y;H91G4|ok{^#QNu z%sl92AH?W`Ud&m1&?`A>4|;W{Ki~xdxE$~z&P2dVIx_(;>nsGkHD@K@Rh^-SyzoQV z2zX7`S03`xuE!qo;?C5=-pa$SKkUVw;fK9tXX7ES=`OE7**)F zjI;2hxAr8iJn5yK%_lwor*QpAui<*|DKGRCCZ6(=&eBs}*_nOHTXoi-^46Wp5IxEcy+fIBHr4@aZh`zZZAIVm7Mjby>(~s887q<#-8!w z&h#^0##wyED{b^=z09-py^i+b@W2BTic*?87# zx_u?;rCs+w=LMd_demEYy%hDz&Ro>XJCo0ODR+7LIWOZZKIfI3x#zsRv+p$-iosj z^VXc@m{)PuW8S(m_!%$s8BDz3C11eE3trTje!lR$lU|&gjct>}3qS?1i1HFMB!X%FABbS$o;5J4-KnW#{rMUgQ-F zyy69&nOD55Gx>^_a#mjPs?N1nyrMId@WKgfzT)|vD+w>{j3>N=vy|}4&V0fvI0LVG z!B=rT;Wb=OzUrl1kG|@~oNKRoMd#|PUhY*MfBjW&-5LI@xBOZ5NYaZYv5@rEoGYLA z(x1op7rew5FqrZ}DXgcwb!X{|UipjI_>$NB5>~(D)tu!oc@^jCm%N-a`I?t{4cA`t ziq6VwUey_1@s?MxvEntIr7wHsFJs_!FZenxzwSkxYp;7nXYMOr{wtVHdzm!GzUsxl zilMK0;jiKP*Sv-^{B>{n>$viDFYSzHyhH}G8E@5D&Uh8)>NmXHH?a5(ue9Mez0x=7 zwQqWL=kgm~<-}Kg0Dj)a?Z-CS9NB-<7K~tE8p?b&ct`Tq%-y%FYXNH zyig9S-}7qUbAI2eeIG+_dEvJ(^_I8d%)aHVI@jOw8qT$U@rwWAF3)=_c`W9=k~96b zmw6lWZ+iu2^aoz-2U!1sx9&{-&`bRg<3IEg&cKhn;E!-m)`V^kU9L(Mvj4ieB28D|&h7TG1;yt3|Ko4F22;{TyRI z_u|gv&%Knh^mDK5T>rV(aQc7Y1%83iUwAQR{g>YQFELT_k|kUzd1+_1Sa{D{dygNvwoLP;N&b84|Nno7^K*FD-TOM+ z|3-K-+7{lM5P4Ahxx9JM^{;+J`%69Ax7y_w@B>kI`A-9S`4ha^)AgubemQTxbp0jk z*Yf5_*S}%?F5cYe`l|I)d2^!cIqMf4sC~_PkKO;jS^q0<=5xpY&iWc}#&f-4{pptrl-c0HG zjn)_J{Fbd>VCVN4>&MyoecAfQcr&cK{`alBKd;^O-&nuN?(dJ*kGK2#yY=td^LMH} z{-4?NcfR!x^JYkQd-qwtmG>dI-e(`*%iQM&{cP**?-6kQ7V9742j8wgZr%O4imv~= z^+Wg5zU2XZz8iLbCs_YAZ=Q6=UuFF}_W9ka$- z+1(z`TgTh&Kcx3R)~kJc>$};ePOM^)K?KOLzIH)?4l4Gj9EI zdpsYr`~L}V?sdoCVwcwr*8b>M^?W?uthr@d-lOtE?SJGA1Mc{{zo)&zn|WQo&947V z-eBPRy!E@?$72)kg>!G50nfc87B z-?NAI$E{yz&&TuD9~sumGylBYp6|D;Ut#xOw0?`-f5rM4_IUng{ZhOCT^`oQpR=|J^0V#?fH4e`a8VY+8w`Q{ZG7E+V!`r z=k4S5j`d&dua`Hhe~vdByW=}Ps^{zeyc5^^tlwhicdGR>?ffpW{xol9cgNrS&*Sa< z{MHxj{GPJ@ke%NbtzUewUjKX6-JhrEZtvIDkGAt`Sbx8r-^LqXIORX_=3{sKK|wwL zx83I>eZ+c?o!^z#|75@Z@3j6m`}O~bb@%6ByX(JX{TBym&szVTy&n9``d7R4^1AiM zd2_Y9e*4Gtd_G|3*K2*k&hKRF58La*71l@W_3BRRm)Q9}V*Lg?--Pu+`+D{*>u1>c z{?hs`cD{eM{*JwVwSQdC?|b&^{XpxVx7V)`>z?`{kH`JTmhOM=+Sk9`t$$-zy}f?xar^pr zy7j-<>+6;OJbp-zzuo%lz1qKTJz%frW$Rn*{u+eH$dq1erJ6@yT5HdsrR>F_qVt86Yc(vv!1c92a|UFw-49zz03M5ecC^6{d7D2JiGpc z9exnIT|C_`5c>ZRuf4$b%;cYltz`}_@B|E_&~_=4TvvVDDc%lf*#{;t{azqHri-&=ou2YY@V*Yn%n z&Tnt)zqHreW35*P^!N*`|M@WOH(P(xUT;5Q{X9FrnBCuAc77S_Yxa8lj2-`ief@ad z`fK+5J@!34zZ32C^JAaU{y}?uKepqq-C57)7uLld-@Ddtx7Y9YtRHJ%U;beIWP7~- zWBmeqy#KJiw>{qXJ)!r1ggxHftT%h~{(G#yW#`*(J!P-=Cs==KCq4cw>%X@*$M(ZSvi;_gly}(cb@_{KvHSjpX-q zGv#k0Z=k*Jc)w|%AJg9Fl0O?X@e9f8Pd0oQ`S)qR&m~_*`#p(#I^~;7eg@^MA|FWk zmXgc)C(>V^CBK~Vz2d~Dd~cHvrF?%RU+LJ}2TXZZ2TXdS$X})X98dlz?Pn?ZsVv`4 zrkBI=HIc8PeVxJhH_^V{LN4bWiu~UvKPB7nCFH%j8orWzD*eS;@*lGQ`W`g$|DE>b zH1bnezF#uFe4k75`wjV6mhVII!7SfS@(|@eK%PeVJ23q}(mrRCzuMEJKal)5wr@w? zzlZmCA%C0Y&mmvQ^7kjdm*qc}{3DkCWb#)dCckr;-zLA|7n1*p_Pvz6miGNB@|S5p zr;;zC{k)cZGRrrQd@Rd%8~G5{|2^b4u>K!*;zx`;PmqtNe9w_jp?q(U`zhbMKJOA!zEde*Px4-rFOU2X`%8%Ye9AZ0iBI{i zB+sLKbI5&^uZldA@;yr4kMgZ1-@*R;2KlRfO!@yv{zLZXzmwli`Pwfv<$0g|xi9$- zX|GNu|FL6_$zPdCVx-|xt;q`~1qelLdC|@4=X_T*sT)uZB>7PwrNcqah_tW0oO8%SPCjLX@FVfyTM}8me&70(Z zIn~79=ERQ}et^85_NM<2jl7#_Z%!j$Mtd`nT)tZ&^4>;%>j1-lM1C>ld!76=%J&I* zAIg{Un8{DRqb=#3KzY-{1_#_iR0n($;b9L=}jds%r*Qrayi#esa6 za{r*^M&20Z9Yfxc@?J$Q-^Y>omE?cTH~dlZHT?{Km3#^9XCwIn+RrW=zdu3y_$~4^ zw2x!Re?$2O&|mzX@`cEsqI_qO%en9(-^UMH_TLWHS0nkPd=q}HlRoS3Glusge~9Vr zV}1UZ{3_PxOXRoFeqY4&7Sn!DCVz?bbt&WDInd-^Mqa}9y^dVY^A-84$bWm9;n_@Y zNzCv<^5@u|d#Qgz$zSFDLDt{9@g&&iZU5U*6e-e@0$Jd$#HhySc1`-Awo@mM@3;^C05>uuOJ`5 z_)n}h^|7D!{snR`n>U zqCY<;Pow;AkoTlKzaig7dHz8DGs^QZ`3m~S&&lOnM@fG_`LF38J3MXVUlB3kIpno| z!}G~srhhz(3SlRTaBJxG2L<$KDBPx)RUmvhdg zJTI;_@_*6Y@L!W}qK_fr%9AG8;_y$mKf;lHVJToA7Q! z3?IYrKGe@ke`LasVSBA0e}?V*7UQ2r{pi8)TK3=XG5s#|HyPxAqW$SZzLxR~C6{x< zMZOsM4c#ao`S)1ApEAEcuzr({e5~KhCyo4T+5Y{=-*DQW{C>9ospL-%GWnfNK8Njp z1-X15K;)Z2zHzwW7d!H^{;wu~g!b(Qa``@{-2Wi?q9KO=nEYba&riv-SRe0`?`C^8 zl8%*cv zeOUg%Lq3W6w~RbU{aZ~g-!+%^evSMb>faXfe$>Ce zke@in#NSVTpugc6KQ{Wjh4!Kk`OkWo@IvwjIvai}`I8)Po#Vt0oA6Td*L;T0B(FKa z@CD?LA7}Vt@@oeg{v`Qnly5EhF_iCh^7fSPeewp{vmNB;(w==qo=thPo-*YfKzRp{ zpG*xXqVN4V-dRWc`HZQLhuD7ikdI`4`H=Cu9dFYAoO~er%R%xlsE=8^e*^WgFZr|7#{%-Z z*k7XLOQ?TmIq{wTLjID|U&z<6e7VmW`S;Skd_Z2t{<4(ugOu+H@}89MS@Hwazn_u+ zu9GS62J%ttFTW$tpuCObJt*%1^1+lhYn7327xl3(c^d2c6!PCtA5SHJjQV&E`R&xl zE66J-?;P@9P#+gK@u`mwkl#antR;Vp`uHOGG|IP;{1)otAIZ<6e7nhqP`>n^nDRAK zAN!L3mHHTP!s(w&$YYc@PTq&|+)Vxn`^P=xUdmra-ZaFt&yUF8aQrv4f!0(b0>K*<@q6bU&`|{@;`Mo>Fp#x zh5DTKoT<;fQ4@X)`9J7?i^#h=@{sQ+F!5)TAD} zdIiP7XOiDa`|<d<)3$r9FAliBEg7g?yFI+%F#~kiVN~zlW0F zO?xtq{4(0VtH}!}-@WALQ6Dl_oAl&6WYYfK$BOhLmXmi1 znDF`J9m9qX`KigTH_HF|cn$dr zv^PH@pGW)n9QoDhi0{E!i?H+Zcc;jQYrPj3{vBx_7r#l$1D?%7B zzZp(GmgTQudEd%F{PuWW_$`y)BKn7y82@74|7-GcroW9mLVwjr-j)99OY%=?50d1Y z=^rv*GWiXm|H>i%G-~7@ME)i1!O7&MqVJHm+uP>;S7?uJVEBWyM|YB6!u)Ef|1H@xUgbN`xS4G)ulG1%}j#&2SOoQh`oXQ4U|6;GxE%&d?VPO?j%2-`nr_-81|>tp8$yXN{`7R>=8T-==@=a`?+sPj(H1SuE z*HZuM$PdxpJjVLiM0@jN@*nj!_pc_eX8XKC{vEc@>*RH`znh%+5p)0V$kSPW4^W?W zQ~oOQF&@N6dtAc)aX;<#hrIvE6HR)bkdMeU@hcgB4(;g|48NV_J4imB<;(b)(T5XQ zzFy=#SiV!pKksbv8%`c)`ObFYvwT;Q_oKWwke^6-Zzn%MfA}bQ7UlaT`HYy!FOT(c zocIsX&v%Txzwd9tf6MsKOZnliwvsJ8t`@^@Kh`1Ne>H1aiUuN?A5woiZZK_g6hy~%g6 zKJv+b&-&~^emeChle|ZNbAKoDG`8;$^53xj3dpB1{VU10u|9p|&*q!-BIHw8zLDg& zuzesIoil;=9~bhht}F+oG z#?*i5Nk;xL9RE#c|E}WrXAJxI-Q?dLVdCFQUPAqJ-gkRB&xDt~XwtvGui>-FXHwou z@{6cnHRK8UqvcL~>eo}`H`1Q}guG1j2jyA5$>jIZ5R>1JsE^N4o~OwdQJ&|?ucAD4 zLl;_vv(<#sUUTqb7bXc_YVb{m7GS?>zD?9N!Eg|Cr;OQ^=n`#-w*Dd37Jd z&mjK}o%1MA6m)8D>DUO&Lx|1S9> z91nazUP<{rB)^>UZ72W9spkGhCqCu-f_xF>+e^NL`}Kd@|+RK|Y7_{f)es@*N-_Px;!_oAT%9ne;Qslk8uE$bZZJe=>O&$}`#t zXMaC~{Lk#~CFFl&f0|6bf&G03`S01^E6JZa#>lgnypr;)B)^>UtR){wdsI*U0Q>vf zPJGJOKznPu5a`}F!^v4g$ zpJ0FgixZ#n{f+!q%GX4GFXc;r)zsG&l&>5449Yivd>G{$LY_nUP9Q(X{{AiU_u1da zk`JYPmpJj+->)WbPx-DV??w6UApe;5=zj9O15Np#Ab*Ya=qKcl(jL7;zL4_0MSdma z+e$uz_NdW`Px37 z=TN>Y$>qD&(m&>se~GHZM-?Q`=$C0N|z9RAsMJE2aN2}ko*_)A7$iE(tlh>-bDMnz===)aXqeJzH=@5H;{ZjtH03KIKbP_qlgB8}Wb$#8=W6oalxHUS zW$f?wZ!q~6u)i-Qj~!>^SwY^B{e3n0@7SMyPX03c(;MWEvp@ZTd@uENhZCRu=?n5- zvOhJE|Bn5s!<$CFC)l5kA-|mY4o=AQM^?5#dQ0lJ(&KdfxNiT}Fc5{!|`;Pd=8pGv#Np8M8 z3*Wc$)LYM7YwpK4nQVUZnTEfC_+34C{(YR`@;xnyZ_PD)c6-B{<`{llrs4Sv4`mo$ zK>n21@V_(uxpw-<|8#TzFL{4A#=jo2OMYJRT;9Kj_y3vl^k(?DG!y?f3~xvN9QiM7 zd9nY2`{eI9a>FpMu;s-!b;g)0jdp%GuW78|-ywf=l;N{&d9j~?ej$HDYUvCGW6}@`eoN1G0Tpcbc znRjhjz&B;)^lPu1TXybs(?0mQk!Yzh*VbjtpP`yD}xN+wL2e(kif*|Dq3=1wrhZ?o9`C?ZICrNJ-~uFi0cec4IyY=6k9g|f1evK!}) z9v?&1eP`x`sWU3hKg;iDJ)S%BsMwvs)rcW-r>Z-DsqR)61@%TR!^y7PW-CUF~r7b(3aa)iS}Ba=V)P@MxmJWmip|G`B1=)7E%*^-i|q zr@EcrS2AJdb+f0Gojr4kUpkTLbLUQ)UUuGW*tXFozSHoBcOt+4`l)lK&K)^*#-!PH zgG5R$k_)5Hm&OsPMH~jVl=ZOQ_HU)tS_^!(To<+}mZM!J^y{Sh*HS9ENPFpFCTFzd z)iOpai(|()N(wQ%SZB|id97%Fi^_I-ogMf!h5Dw+w65ilEzX3pY4AVNkz32;w6Vtc z8o~Vkeu}MSEV5;6X>de413qeJ%b>3l@ZU_XwREQcOqe%)^2}*1I}NXWojm_?0!NU* zcHxILpwojVnBad>m~WI;+j5PZJ!!_2@*~Q{U>N1rW00@6S^r$htp*XT`m1BJzEN7O zOKfz%`0A@?mt76>eORHL-lQ?Uu08(E6a%3%F&?{a>a@9IXIwOC_EZ_)aa1PeJyOyt zZ1hpu;a^XyMa{Q#fJOFD+8#RCV*{5PYh^)O-sd<@8By2+{=GU>6-E_C6owUs6b2Or6#8Azr&v)8&jGTh7<-B1{C^T(5F~YEUXzTj4F&M3@Z#N3@QvL^t+%>v7%T=GgcT?7*QBj7*ZHi z7*ObUL7!qpv7lzGFsd-3Fsv}7FsLw~(C>F)7xXDs6bq;j3Zn`m3d0IR3WEv*3jKZ; zc0r$FMKQk$p)jg2qA;v5q%f#3pwN%b?r5_c`dpV&5n{d+EK(R%7*QBj7*ZHi7*Oc< zyRaK7PGua66*=-2DU2$NC=4qMDGVwM*zlVg$&?^|O%WwYU3R0?#Uh-lO6w6-7*QBj z7*ZHi7*ObUL7!qpv1lr{B85?f5rtueA%#JO0fl}S^eI*pi)h9QqY5Jm!wN$Rg9-x* z{R$Pu!kU@FsKSWCu)>hSpu&JczYF>lD~g3QV}((L5rtueA%#JO0fl}S^eI*p3u?v+ zqY5Jm!wN$Rg9-x*VHi^hyP;1nD~bhDaf=j26-E?>6^0ZB6$TW-Fs2fAL!Vw&6!WLz z7AcG>j3^8%3@HpM3@C(QOeO4wKG)?`gqSY{ixfr`Mihn>h7<-B1{A_DrV?%e^>Qja z7K=KDrAT2^VMJkAVMt+6VZesp)G($5@oS1OjH$~mRFt|{q%f*5qA;v5q%f#3pwRDv zKE;Y+QO#IkRAEG6SYb$EP+>r!-vxb&6~!W&vBIdrh{CYKkiwwCfI`0u`V=dQg*9V^ zQH2qOVTB=uL4^T@ei!s9Rul_q#tNefBMQR`Lkfcm0}A~v=u@mH7SxOtMioXBh82bs z1{DSr!bqkPc0-?DRul`Q;ua~4DvT%$D-017uxO2sWw7*!Zi7*-fk7*rTg z=yyS%Vnwm2W~?x(FrqN5Fr+Z3Frd)yf|g;9kOg<*vug+YY@g?<xa9GT+ zqYbfG3Kl7hDvT%$D-0x7dSfntjFrqN5Fr+Z3Frd)y zf zFsv}7FsLw~5Ee6)nj8A`vZ7cZ6}L!XRAEG6SYb$EP+>qJEM_WUH}vUcMKOOWZjr*M z!id7K!jQtC!hk|p%v8c|=yP38MTq%Qut;H4VMJkAVMt+6VL%})W-8$pP%k4K7Bl2% zLoAkpMGB(|BMQR`Lkfcm0}A~v=u_-MMVhg~sKSWCu)>hSpu&JczYF>lD~d%mV}((L z5rtueA%#JO0fl}S^eI*pi)h9QqY5Jm!wN$Rg9-x*{VwQJtSA=Nj1@)|Mihn>h7<-B z1{C^T(5F~Y4Bv}!td7E{!id7K!jQtC!hk}*3;Gl*iUl=eg;9kOg<*vug+YY@g)n!i zgx%1mmleeVsklW7qY5Jm!wN$Rg9-x*VeV21yP;1nD~kD3af=j26-E?>6^0ZB6$TW- z+@%tBL!aw%DniVcf<+3W3L^@`3PTEm3IhsZ?otW2fO;9>Fn2*m4P&tsEK(R%7*QBj z7*ZHi7_i~LIY3OwhSpu&JczYF>lD~jRe2*+3{j4F&M3@Z#N3@QvL z^t+%>v7%T=GgcT?7*QBj7*ZHi7*L3AnM&9VeR^3@ESQR0q%f*5qA;v5q%f#3pb!=_ zm9QK7^s=H@AQiVrVN_v6VOU{EVNhW}AuMJpVK?;YWkoT6DsGX&sKSWCu)>hSpu&Jc zSj<$yZs>DePDP0MQm{y2RAEG6SYb$EP+>qJEM_X<7EmuE92PU+^o3X~1&b6$6-E?> z6^0ZB6$TXgUC^i4h48U3r#~u;DvT%$D-0GJo6h;+B6owUs6b2Or6#8Azr&v)etQjkeDvT%$D-0qJ%v~yBH}vUcMKOOWZjr*M!id7K!jQtC!hk}UyHvt%=yP38 zMTq%Qut;H4VMJkAVMt+6VL&0wT`J)gP%k4K=FV?T8+HEJNGX1uCmU0+D3*dzg%O2e zg&~DOg#m?r7xXE1p`ui7MGB(|BMQR`Lkfcm0}A~v=u@mH7S)UuMioXBh82bs1{DSr z`V}gQMKm*oQH2qOVTB=uL4^T@ei!s9Rul_s#tNefBMQR`Lkfcm0}A~v=u@mH7SfCr zMioXBh82bs1{DSr!tA9Ic0-?DRul`S;ua~4DvT%$D-0BV? zEm9a&7*QBj7*ZHi7*Gf+lSyd#Qxo(C5DF z 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 R+H@2-`qqT;oPp%?zX1C_VEq69 literal 0 HcmV?d00001 diff --git a/ios/libs/spirv-cross/libspirv-cross-core.a b/ios/libs/spirv-cross/libspirv-cross-core.a new file mode 100644 index 0000000000000000000000000000000000000000..9bb9d7f3a6558d5a3b59960bd32eb5afb07ea76c GIT binary patch literal 570464 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%0A}Av!SZScd_3l&#&WsD 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

    dBjx&L<&5&9BF{72^jP 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Ä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 literal 0 HcmV?d00001 diff --git a/ios/libs/spirv-cross/libspirv-cross-glsl.a b/ios/libs/spirv-cross/libspirv-cross-glsl.a new file mode 100644 index 0000000000000000000000000000000000000000..dd45116d0e814b44601a17dc1f0798b631c3830f GIT binary patch literal 1196552 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 z z>^O1>rIQmjgPh^su6I1{;2H8#y#`MS-Ah^mp|0;sP6A)^dh~$K(>0ZCdDiT0yGP!43pt0-`zrlFQy_HUKQ*;!=V4nB zTjg5r>`2)H*Nma3sHbDQ==1aG*!3E}c-{`*MZ_@mz~7?dd#wGwRm7Ssw?eMVga_^X z*_4}pRUrC2wud6(Pn!3YoGE^f{a5ET@ba3q2RA0=*^)d=oY}zl(}>fa)%`>Amp6E< z=KL$S=Zg&31-$9-x~%JAVnT;xFPDLxgE>~nxum@R6?#<#ed^4q38jMXou=t0`LRo; z=`z+uIuEwAFW)(%-bwxei4U4Q*e#W-0wLM?PzIMv?d>Pk3Yg_(1Yir@L zYvHwP;JHu2d!Hch@S?8RBDXrLRIq7h8FH$c*ptF*(*AOu3%_a2I0+r9iA_Donfg)o z0h|G>T11(0cgbAEJCrlH>{Yy%*(5N^ejl4X6#{4H>wc3kd!wx zajswLz07xqtw+s&3I!v5O@foQlo~5i!#6qj@6dxVrd7ECNqQsRCPG_CMC{&;8Sf{kF$&8_m z} zDw%d~LZd!#(sa&O>y)%zV4c_e-B~U9wUhL^dtTbk{N!@&&{*pCxbtj2$Xk*ld;raN zfrt2A3M^SKao9QV7oMC<;cGdYSvIWKx5LaolPjW;^{0UKXE(C8?MDksy~x*`Z~A5w zK;w3vYk8LSC&#rje~2|e$!*4GiOXICSgS6DuA7kC`;pr_T@#w1*V0R=_rP5j+}wbi zZ>4;*OUwCMzLinFj`Ff*G`KRGWbMnLtmwxwe!}V3s`gH;>)+p6 zp~mq2+sH?+6*f+0tr!ER_qA4hK-^@lP%?O@va46z#ePQOG8!2f;l0S_aAradOOCIz z%3*l35P8O3WL-}4YTUYhEw;#m zY|MbCyzrI}9`nO%naIZR=;EH>Zz`n8F891et`&I$p@s0LnqTA;5#1+( zOo$+V#MY){Ht>6uzgb?l@iz-Q%6MmJIh9X&uLn7m%lWX#DPsCZJT4`t+SV3KjTBg+ zwoL1$m7L4SKFRydz_!S*tS2>AT?X-2j3~^OPPTIn*g<-MlyZ_nB)N52|&W@#h?@{#H*`rqD6`TI|5zBZoW1 zE@F9`mILD`&$9la(>-c<$;0}cMm_vUr{=QGh2P1jh#+Tb;hPyQD>R#L0&f}Tvp=Bz zPQSHE=AC8j%$K!8{(oofbE}`MOwJyiyyMg(&w5{@HT~JwZQFpRbs$>m!uQFOKfDneRF>uI zSSkL*wtr58?Vs~m`qzMe&H(#xku(3S*?Q1ycKT&4z~J)8%aI2xn@tCW;S*@r~;u*VN*8o2mW0%Hn=xqy4(-P)fvBQUnvg{eeFDSaw zkG~Q!U1Xp&eeu@=$eDp1+SariI*}VasPG`ahnd&pkiuSs3<8f5mEXfV9Gma1R5V}= zynJiRD6DAom+;3K*97E(ywApGY(m~#Gwz1J!Z*v=s-2sK_Iej-KdcYhCyDDE$9vZp zc;6HtClGj7oSk+S`9+<%%mpVyJJl!p+B1Af!ryBTV`kgWgbqTZ584j{Kl0iYbGLz z9cxxV#_axOervYqE)m9UhU=SuAG=xW5@Ao8I$w|MwL;%#|8)?ZMr87>tc_vT583BR zedXs@bM+AOg?w|OM`+p8=gC*!qZQDw92u}kY;4|cp(h&}+XkrDO=AO;vd{Ca!XtJ= zt)t*e*!`f`-jKnuE5Pk-z32JAtQV0<ZCT_rQ<%Y=m=D z&#~|gT6f5e@5OSveGjM{gZqXwTMq?y^X`Y{9rFuEhWdHatl8{|>t(#emNK7T8IJ}}UUMHlduHr~ z_ABhVRxD$#^L?xRei!RRs`rr_(7`Nk^D<;}iN~t%`II$R=qc?x%kMF`y%ie)$Gnf+ zJQ7aiM&Qs7!C7D#yjPIdve7f$-!lQ5wo`_@moYobd>8@CmPZSrnT*SFSwBUd$-I-X z@O}QY*c}er>sNd%K4Q6M;5)}P6`mhd-Wd3|o3Z(b@t?=I*>nq);7=+%DDl3`yEgCe zDEY!!*KC7VpP8Q@FL!<+|OVzcE=L@zSi*h(V}PiP-eJ`u7o!xyagri#QiS|1yg zBRLX9H(HD@x#7Qse?VNMEz!Z=z}HLgigLyxXFCQr3t2B`rH7EK1=zJ@&onSe>HU>g zPw?CD3kLs86(lDj6URMJY-(_fm!0o z^Y+LS#G9X?t`uY>WsGr|1{usrq_fNukrtGe+_mYZQB%E68l8lUbPG|?+XIf z!$0I4TK0Cxms7X1KjeHl_*#RzGTUbzSOV^X*Q@N4O2~PxeBRM%<38`L=$gjoeHQzg z0(ac!{S0fc(hvLf{wA`sM&+R%D*vR47qI-{ZQAFZ_JmH6orkqNLwA&C7c#L3-}$ip zUG_r}*8etq-dpf_7rc772PAoZ#AkP);Vi!F@Y0CyPG5H5B>S=#((lfNRxtN>-}sK4 z&j>zpjuO7bOAg(dznA@#KHEv$vpmr>XWj=LLq%U~EIYX;flVYDTLFCf6UkzKYI%nO z@Rs1v=^1^0LSzVcgx)pRP|CFu`@O&oJJupu8_arS*=L(=U)ogfeTK8lldgjWn?Bq+ zSqyFeRB$OAb*^f!(Z=_FOu8ib-rxJJdhgGnPrwQlOt$^+;afA$G(FKjYu-Hvlf))8 zJpV8JuWb3O^>WU7fOFOZ&~GY#=Dj&*O`N?xq3;zh((@=Azx__ii|%IX^l-O(*oJLz z6yEhtvku@uF-`2Ksx0psv#bL@aXd$+S_k$zo*Q}ovEw;1#X7LZ@!ZJsPRDa(vUPw1 zRBg9opH(=?Iv{>6ro9Ny+Z@l0Jm2Sdj!d);bU2>zK|b(p$8%(Yb)ePpj4k89I-bp0 zvyvO*tpi_ol&R(UtB&WMOzXgE$8#;uUvfP6_^ks?JY!$ccq6;i9R^!=DcuZxS=MJm z^9Z_f*d7zXq0?&}_^kQPa|zF%c06}xSO+-lh|{Hn=j$EM*kTVXc08Bx{7J`iC-DSo z9M2^@qwK}ub#gzW(teixZkRg*V#5-A<#`#;Igaw^cq$jC`p&+67yI^6=QmgAJv;IW zHbSldCuO;$eY6@AWuLY0UMN|f;_d}>a^9_&DLR#-Y|6VAW5`mc?bdl`R{F=i*)lmB ziQBuBja6bqB;GY*V_j+6SOef;Y^=-p-`H5ut+8h(?s_Ia7bbmA<%}AjS2M;Y1KQiQt&FLLJ33oGH!A0^OZMUaPGWGMlbPpa<~f=9 z&EtpUP6RSRY_~?2w3x@{y^$5>+lSRN$BMfqcY4g-A&KeAzBcaDBlcmZUzO;+Etkk$ zXnpQ3cIM>o%g*N<2*08S-QJD}=M=S^iJ0iAuobyI%TxfFNSEXjG# z`s(7m$lBGiprFyjbksKHjo1qQAwAK~?J3&Xg^hiHGYY}!sq^s-FSO>2umzfXbCYem zqyrb{y*XcHAnIPfaKF37z27&_ilz~t!+mefeh>J0CUeKZ>)P+)4u-mS5$4`S@dvwi zaRX<1hHeYrr9Y(;iRClpPrE<(;Bm(veqbC-zxq=2i!-+P8UI53_2DmNC;qTJ5?Oah z+xYQ06h4+1E#5=nV-m-v5gT*Krv0nA+ZZb0UQavxG~q1-@bU?!)3H zwllBe{8aAcy&Fs)XSAYoV%MqiaaOC&XdS$k+~3`{zk!pcBWSRN_(7NcNYS7z{af{7 z-&6hfCHkLgUWGZMO9lJg@PD^CE%=wDVYjr$OKhlr5;WSRY19af;GH$=@+Ds2$k@!t zTIDaAQoiJzUA|c3K0$1qMa0(e5L+j0zcmh7GXa~w-0ezp^BmyU+ON*OBo5F?-$5m7 zHn~5rteFjM#r8PO{*BxC83VEX$8E_xdwKpee*G8OWyK#`>dJU=Z!tbz2RN6Pc`kF! z*mk8%r+c^}ZrkO#glA`aoxqoKXalo^XTRgQlQ@m>I6%}_v8rqyaoSb=lW&MhtiBTb z?ytiibhFDpXvtX|Yg_~Vpp9~_?K`r)bhm#;=J*?;&1+T;ci>}5tjXvSet$jleisHSH3mlA9@FVqr6iwX?D8&Lo0x_8Cd%s_7l$!zgO-nPN8lSb!n?v?zBkV z4$eWFs4MLkVmGRDjc;$Dy!_85hoUjk281HxY=HO!rW_!DPwlXF=Yv};69@lEGE@JaEv z%j$L`10@!*{BQ1|dKa(-`#cUnH94 zFg#Y&oFg-Tw%)^eGJL!B=lu5Vv4Z{7{S7pIX^*Ct%oBA#M&eOr>NQHmo8mlU)IEX% z&N>{i)k=UBfu3hx2t?0t))GF>_u~m)!Ps8Tbbl=RX5LVMzDirM`*_zO?{X9GzQ(&d z+|DX99&y=zCSi@qAGR}H7Y-oB0Iq?c7}$$!h%G|2?cu znR9mB1@Uo+#XMcH84i5--{2E&Z5?s0E%kBkn@PsuUld-Y3V_7sWTn@RXar z>bMIUclb-m%uM^&+?R?JDBp&P|4s~}IeZJx&~&{uJt3bB|GWzSJjz+#)i#XCx+f}; zw{yk!RL0;ge6aqKZ+GEyYGk|cLdp2yirY<{oycT~ndac(Lheh%?_*t}&gBk38-=go z@loe_HjlF>dQ{qW;)sLB0g6=f-Z|jyGVdHP1MCF_o}#aF z4TRn!*1)8>Xy#NQ{sqqUBKBk&_tqwGr)45{TPAVGWioeNrf_dW&tcTWHhR?hH=Hog4<+I0q%Rh5` zAk&KGfBu%^;*0x+>>IZP4mO%K#gimEH?`I`vTyW#yS08L@$%PstX0#eY}_t!^TQbu z-(LH}ct00V{ycu-(}^EkE%7UB;S=qnsC~H)!3z?zd>QcMz2JL@GNP-h_NO4f(bI%p zdOhPV0ndu&Cv1Np{Ium+;Cu}@{WiYl-m)s&uu$PL$Q&`a$a%N;My*V`_w0hMdsttn zr(>+M{D&+pD@w=1zt|Ai#v=cM1VzLH=kw2G`C z#=A`yLq|h5v&M^@lfAl+-%@^wnX#&LO564UWT1J+oiP0l+qijmf*5J4+!cv;gUF2r z#*~<8+fBJhxt68UhVX zd6Ft8!uK8^P6%W8zH%a;djn=G!?D$denqbyQ9S&7V(vea*pGEWIl>OY0LV zCj$KuyhQitM|Q@#!RLK24%_s3WG#y@2>s3~_?2Tm}skyZ|5Pgj?fp_Blk#CX5 z^}HS0TVwm-{jK)H1BT#XS;UL*0&~9bD}Kjs6Fc0}<81Jk@r)2}USf5!Kdeye8^6ip zn(U*z%k$acT`6>_U7pVjKkmsJ4%mJp@2ssyF5ZNEyb(Eh1M>1y+yT743;C(`bYXi8 zRQqqU-{I_6a2GrxZ}DueuO?1~w9CDh1Ak$!SAth3{yBB#S;iLsoIf|u@}1{}=9%w3 zj{FYNPDzH&|KP+$#vMIV@0*~FGrxn>X&dM83F6tyv*21}>WKVdzkQ*3rd{YfH?Bv> zcb?6?M@3Kkatcj(`A+Oqky~o-#g;w-1ve>+r{ZTI8B5!_E zebe(+-;aIJnmo7jV(Pj6>)&@?Y|roY0sJ=g+_sntPJT^}!2v%_8|fEh$977wPivGl zm_1Ale*Usw6WwPab5VG*ed-O-cJ{!H$N;kkZW&__+%Zw_fisEsDtpzVDfYl&+K_KU z?{N<-`)9KUHv8vHe67aX10(NYpO$*TyXj4xA42xT2Dc^biN&_u#=7N~Ju&{~P1vie zB_1aF(lXg2pU?da>=QzVUg&LnpoFH?6Wpu%*qf*Nmg?PDHuJObP@An2?c%P0@W@x; zr(D*3tvA{F3u}3&Cy&_n62m3o<2#z4bX;@cryiT1dfpR1jkZTg|IL0y=4U)kobkg& zzmj!a_D@cGx9p$1y*2EeT*G2_D)_G1H)+`}e5Tib_`T-ih!5u`FVpB4Xl6{zKJ16^ z#d@c%X|F}bexc-OHu~0+=u8E!%7>s&n;jRX2z`FN(Gz8jOH~)y#{GY-bFmj!@XjBu zkabV|VbwZ#eWI?c=_A@ERLM^Q|l`|{2DqZ)BV*a@z4GO`r9PEE=%37F=oj; zru2GS$A}595RYH@MedUe@5r7(Xr$(4ihWWedmu0SEVVD9O(}QCxmU8^g^|;I)BBVa z3455*CD2C<--^tBzc@B~70L1SOk6#sJE5O-qT~7Li`JzMRYpW#bM&iooUQw&C-}wimgqh+OKis&)-p36$lM_ZmdA| z#bs_IbBsA$vCeH(uKR*jDKbjrx7bJ4rK6AQ@9~^R>o@}rw;oy$VGWV<;AN86MCoRd zD@exzmARWLzO1tyxz|!{xA7YPpFQ_!8u5>G9KB)N_9ks`Ry60Xf4Dw62mM?3$;8&l z!6u;PdS|*Fzr&7k&t5~t?P>B{${!A467QhpoqMwKXp;tMa;ytimR%WL0%sR{iPFzlS-K%4TKso)@7%XAlyz z4H{dV*Lb-iFSd7NJAa+6=f!id&vtn`UY+5Mp7XW*_1$);RLUWz(k+ghN;%Di6OwZ(^cujgMrgN^ zewD1DEjwRPt}DmRSM;^v*{{bAJk7k4ccxtGd_@%_@)dQdd_~!IzM^b9Uy-H}b8cD> z+ctH)j$aBJlzN6gW*?kMu&P2|N}4*jylme&X3@_GicBp;bF9odrC{UY|r-$2vf{y}ujYr*## z@ctzDe}aB2;%o(dlk+;sV}boW>eM;qe3SErt>2H!@$=$x{JC^3$4|Jm&e>?MxlLCX zeR9W`Yox?j4%;!q66>yxA?92s#aGFkvn9&uvodG7JXKEXxQTM3b>27NQxnr6QEv2l z9|2wt^8Dk{)rdEZu4X;^>J2V<$<11C5#yT}u#-6Z<=Z3Si-N@LPOztRP zsBuiS|MMRDe5jLsgsffcJ#O+IIzN5x-oC}WecLf_cQJ2&%(?E}>YiPs^okSFCAxH zU=Mh=yvL|wQ|Ie7Iv6oelnzF&PkXC z&T_T39H@)Sf$g>&7(E|H&TWA=dTx)sPfZ0+`$YD4=y>q8vd>(>K2wcVUVNXqpZS(5 z2c3!2x|lQYjdpJ8#{WmhF%58@RQAro;|&ATPPL&YIAfW1vo=a@>Ou61I^+h91CQRp z8C^4VvlxRr8G}^uOatU|l=6w#qM5c&YwCEWxnf7*JkGS&&3Y@oyDLYvGcty$h3+Bk z406UkR<7zE&KeA^1&i?ufqzPhdh&f&-cvtd?OIJ9K!4iz0$<-HG5hT^Kp*y@QtpqK zwNhYoxw+rrwkpJ*^Dz2>4>)aGh)YIXrwDPU{0H&LB?h$QN%Xq>WwXKG`+RMsX&W75 zb|)}=&`o?FD)Q0QzPHKw7>B? zDG`&PZf$sLl?`iT}F}ALsyd6JO``=$z_|lo(@--O_>YZJ0`5G7Bp4`C)8LpV}>J za{0=}d3CM|<|8;ZEhEmq#6E6nS~*Yh zGL|vsa)vyUbFRJrJrL^P&O-yVliW4c5(D|cox}+D`%A}J73&y_UgqLh`24Zn3!bIK zw-i3_g|1!nL-=Mr|I1mXjH8KJ+I;(s(IMmu<5YHs@{P|N#O}Csko_cMH58$a&v$ft z+3w68E5C4Kv~*3=a2Gz3v)~ysK7Pixj`<;e>&fqg_XDnt+mq?vj_fe-e5_%m$b_em zQ^wc+Qrp*FaFK5VoIzbW&gpBPImB5fzV=7)wa>)Y-miS^#iyj4x{A->KdI|uPf|`@ z>5uGln(?(?C;Z9($b@6)@XBY+^aH!?ser3(6wdGFH`#|j-kYq`q8~j{?0z_3(04)1K)7;haTwi;DdqaEyPyZ`5^DNac+oQ7Mir*hwt5* z(qZ@xbQ?G3aw(+U9j~l*@*$y8!7J*YO_|9t|iu2T7f_ZR%4?b=ilYAh( z_^?P`utU@ESMg|n71?`8d9i7j_*0QR;tMA}90_W%A) z;fHAUV-mk^Ci&xKOeKEZ58=xWfUz4*7@s}#s zXP-jbe&`_diT5*x?-*yL;)7OuI>r?@&Pwg_rth`GoYQgcDmWM#5czs;I7`118+o`w z|1WU7C;7HWKYvrc+5RkV(3h;=#U4FFA0j`{eu-hH@3n(Z#bEcvcPvVYjS`S%$g8JW)} zW?}q}!6NiyS=YozCMj0kS??Gqe^hOUmHJ-fllaQCxyQ<-sLRTFA7<>Oe}zf$;vQc& zuj_H-g=NQ!+r|F|w-NUr9)5Cx%SR4*^2f*Tk^QuFLBXXuR@`prEj*%V`aWJ1{~iT*r|p}`doRA*A}{1zob@n1uSA}xdvW%hk}_@Lm&1ILwbQ^6 zxMnU2UF13L3(0e%e0R({@uf8LPVs(R=2+eK^QahU@P}$oeMjcMA74uDUOoHzEiUXg z*ay~nus2!QoAjBO=!#;C?!#VCG`S|U8$Ucb_hYWs3s3BFTXT1@?j4r3jpvAGTAA;D z@$K*qp$9DWkz>YxA$MEIZ&voXLzRQbsM_-b-zh;i5T0@RM}mjInAS6ObY3x8KO|qR zv@Peh$@L^RqqO6t9WS~;$vd$Fz*4$mFE$O6>o&Qb=*y{Wy2dVV^0l4K9zPd*{Oj1` zE0(jjwq=Nk7xM<|j(HdM$l3FT1@Su$ml}Iki{8hs&@_}j3N6*1nRmt)f6Q}GQ;%QM z&xoCu`pk@4_Wa~mKlRPy%aGS{C#;wCOyZQ>Pn;5w#peAo^e1W8d`rY7NZccn{)EYe zApM9Hc=6?~9dW1ZqljVhs*Q6tIJY=(2H)TT8)x(0;B3Bq5S*Q|D-|!8`!nQwD$Bvf zpTi#fDQw7PSJmJn&Hhz=qzERfqHFpnp!sm79*CIFk@Z}P6-Z!{%hyHTP zXOxZKukMj%Hy>gjEo(>Q_c5hkRJ-z&jo-)jY8T(hi7DUNM?UHUPBkzJ8Lw(={d@3x zE%QCMeevJrXdAyBA6?eDY;64KFkOuk!3W*Xauxqz`OLsSeib-Rq_pebJ<6`%W83wQ zD7$`+vg@CC4|e^pV!P;3cKsY>*B2V03n+T6ggzzE$Jq7fxpLbL&DyZ*%Y4q`ohg^v zu0L;tU0=oodf0aT9NVt{9A_UnJD7vqd4Fzu-v7z5?fQ2QzZbi{Q(g=={FB;Wi(F5& z?!}&z{9!(9-+pZ1nb^X|BU2|JQzv3~^&nIAJuHz2GM4gpwmZ71{EPG0ODH<+7rip! zbFO5?6;||a*W`*$+qZK!{@`LyS=rP$uaUj*O5!gRJdZy$a#_|v=eJT~dC0d`#;4$& zv{l}V#73d_QA#J`&W5))FdXSmANC&FP#<~4TC=9^hUm&q-4OM{Z&&{p?~Y+~?g92b zrP=I1TWc!cZgmA`oNrB)_Y!Nh;M49^8<9Ozh!-LMck+L{56GQkyl-Pa>r;2Kd>uY@ zkIC18olV_SGB)#6_f|T|6DfOBiI*h#t$J7k&EB{V+knWmz*LJn4`RD)sh2#yiMvi( zM~eFecQFrHiv%~>d&J+1zwjd2mn81Qv>IRHm3-U7{>1(+GF$4#eMg}M_VHjpWu(5~ z6NxF`zY4h@3&= zc3;UDlOMS8N^%60T{G%lnylZJm8sSxFMIk3XG&+lMRH7c{#8xXB{BhAx^AzD%5zb+ zw_~sx|108huXFo{EbNG-yepeP{OD@dGRk-Ul`Hy1iD80`S@lEk7au_OI_jBz;PW>( zTx>r}f8^P|4{~>uJO<)RFZh>POMlH=m-}8%*mrKR5zNk8!9LZKKV-p=ai0tJ73}3# zE#^*O^=GY9y~sTuerFc;V;?@(>pX?cHM}cjY-NudhQIvHE9Z6aC;MJmF4g0$=taPlz5PO4c3X^nB{Zl8&lcu!iEaBXbJAdCf(C^) z4SeTWQ>)K+ttxWRVHY$kg9e#NbcoP)31jPGY{QJX+$r@=V9elK;RW^19&ec|*c^v; z(O2ty{EVe+b|9+lmi*71OR0x$F)hlOh4B*;{Kc+n=p1HWEOZu`V(1-i{nmn%F;8gI z&^r09U$5H{zrZdhI;qUL$O+rW7@b=9MedNcvEGS{@O@L?KlN|GM(Fl;h|H*PwQm>x zGyB^xWp|r-4LzK)AWS*V&9ts7d@j1X&F7-iJK?0lqX!;pLq4avKiaBwXr;4CnyP+}i+{VOpFZauu};`>ex}Wnf}?LUv{b6_$jn;DyB^1!k+x*dEOJEtFOj{k zvt9Py@t6hjJr+}R=wv?3HZZ}D^)rs2&;y_P3b6^4nKIx~%U#k-cotc!@S~o>#j%c! ziHp={?<(hHs;_tdGFV&3!Y%xQwdh^f-4OM$UgUh*x1*N3fTj3hm$4p}Um56XK<;hB5Bn<*uiw6n{fF!U zz3ivD@Hdn)d(q9M%u33j7e30qO7b?IaDg}&U(DjE%|2(o1JTsg?`q}*-Qt2&NW%qBDvF}+Ti>y`F!E*{-*!& zd>6+)o7T1g=ehWE(A&r+wGTk|lrub;o6d4$+7E1dgR^Yy7=G0MALEp2kDRcV$R1~G z-^DrTudiV%nVZ5^^7^ENZtz}hC1dt!g>6gW_uXwGIb+yFaz?~;6?;j-zL1EcBY2Ot zi6mm`e3Ukk+_+6d<1BWMH%8b*5;&W09|UKo>^b|~`;U9qA-?a3`*fEq*{@9} ze-{5c?FIv4Qy|Y*BX>Q``HHM%G5d~Z{Cs7^+{OlKYzroa6MJiK9&xqWto>@w6}J7l zn7@V>bsfrazS216`HI#<{tIhZ0eQAMoqG=l4yJvvV_LnA7^Gohklt3jY?E@lpraH^gp2Y4`b-_dFF^;y39%EoDJ;rX^*vdqYIlCzOxpe&_z~o_mc$&8E>`k+?{1TD`PLQ6=JR0=ksjq{ki)Ji;%4g*;Cc9r_%Oe zp`X&{?K7Cy?eh#-yALtvKi1gL9yjto*_Ygw|Fx-OLyp+T_G|ewVjnBEPI#lw{w8}_ ziRG(oFU1L2CUh`+RU^|l7v1`I64QYCFWP0LoQg3jvh9T04_3(8YLAj}3BPjVOD=ve zst#p)evgdfyj49@r%j&i^Vn1Hxf+Lcw%nBR(uR~{FK5;jkxNdPA~)mbvw}}j8?`*g zzYCt^Ju_`OVZOUh|2Ta5)9~r{;M4EMr(chY^d(^X^4}%?z=}@O(dqM8OLDPogtG zH=Uf{lwuPuuzeZDhUh)ux~bsPu2r4bhgsK^PiuR!Z>4QhS2|fNqf2aqah*);f+F{o z&&#(*>ttia)qFBxAB^|sJ?La5Y3O9OFQdZ03jBZLTGexV68>u%?>4@nIyP-$KP&!R zZDI>uge??*EYWAg#;I(fS6ET|d)(hbVz7k^u!ZJg3tfcV;`u>n7x_7DWBYBxo~`c` zw$y)xGY#{<+==FlbefT0##d)$ig$mR;vKe?QFU)k@$Q%I(dBMTQEo|!ch~R^I!5s+ zKDGGk=;ioerELzBj&lVFaMe0NU>l&1OUKeip`_lr~Dae0b1@tYpi zuM1PWV?0Kc%TMu+Jd&fzO-}JHGsU~~6z@3y8wKxecqDlo-$?Q9wD3|AUE=j@TbR($ z1$~XYoiPocMf;uMRaq<5den~&&smy45r0&8^|)s&F|xU6apXheCNX2x z9uS>I_JH5#jKqxh?I&YP#pWEIZ|g&%_sAa5)|Z@R-LFV2hpcWxN1@kh*0K%oQ_Uv= z2L+~wyIf{ITnN8$o^njeNxlbD&&b7M+D(2ZcI4!D-$_xILxfS~CZ%{Mw)A9p=#!(~ z$r*noe`a2qxtc#Y5E9vM^oQTdK3LX)#jaIt#fdfOh^(RZ8f3;!?kOxOwr*;g(2>

    lIo8~(pKm(&W`-4dgL#Pq;A|zE$62Sk=F7a}tZE%` zq_K+#UTN8ZQkna`%sJ78`?C@{+*7hXW#IS2Ir4>5YQMglyA#k|?axe1D$WeH{#I=jm3xHsRbIA zQ+D=3{}RUJDe(nx`Iz(XV6z`AIa@xRqwHO-m7lx*?e!d7z`_ajzKaq8|oZG8?_Le_hVRsoJKoD4%j|=^_{7RwGy4{a*S_?vvE#Kn_gWG+ z%IteY?~-S+A$47q80+^tcFFPQ1+JniI-ZO}XX|H2p8PsL#~3#Imj5ZRy)V|-E5P8g$(@P%yAkix17WfA9Ea%br@w zOZ^dJYW6AXTMg}_RyyKwx`JnbEOq3`1OawiFIQnPJdv2M}U5;?aA7clIA8J>KHV)dC4Rm>VNxibiU(H1dlrK2p8+~&}$w4f8tLBznOm`c!(YFPl0bF)}lH`LDz5N z?%HhVBhNS^>hl-g@m}t@TwyASliBMj`nP)TTm!~lSF^icV_m)LPh?$f;ZCDjR~xg~ zJJOd2`1@PaSLoG<-_&<_X0s8eGciRgHuK!UU%TTybW#3PW<1*9Ei-<~o=?4E%Ae0) zoOjTvy`N`a%C{l|OZKwxt=Xrl7>+y}K9y%L&jQP|RWiZRmhcC8Y8v@|JAdd3x?GY@ zF18hETj@uRGXwQ(kFT^<>mQECj}-mW>mRPT$%ZN4g&&qNrb5eq&-{R`Y^m%8O2p^R zK@a@g=CZ$>rg%lZi_aZ%t4+$;bP~GMVt){OgBlacMK~9cIJ0s3Q%2F&*4;;*152#$ z49?BGoS*sdP4II^!aX8aO|ox-w6ojzivyAhJZhd7E40|3&)$H;56?gZ=%h_<25s zFI&WIN$$kiJ(GwjfZyAIiZkIW>*4I&;2|_SM9xlW3t!GM=X>IO%Td&3}bsrWB8!n?kY zq8-{uKEvbwLVO+zZ^^T)L;o;yT-;_SxWs)TfFaN3j$3k{q#q;73rvy6Houzkrhjh` zALQNoXX=cio88un#$O|;tR4Cm%#pgC z$gHdAyF9D9JXhJzLYq$HWvTN!&vVT8b$sWHQtY_~p6sthmKt~w=IMy~JYVGe&U`I0 z^??@=x;f5HJ9+k*@8HveJQqCMlFvqMTFWytC0UlVm=mirbdm{gUl-vkZ8(4j)Zp8xH289KJ_WhYD6%x! zPcxEhMN`JOI9Y@5vo%}d(8DjBGm__#Ke^+({3?9Ie%xBW-u8t*TP!KY48LNlyX}C^ zA>E1ntC6vjT(uIXIf88Tl5;ka9v}~nHCu3zcoNISE;tQ)WFcqaa|4z5I?tA8FFw!O zcS@gyn|U4f=)F!(VW7)*GB7-F#x)$_EFlm7=z?#McgV}w$U1&OB98Q%;5MSYTGp2t z+!=A>1BVS$-K9frdX{shkb(|HrK}ssF*)t{5_|<$Sw9o_X!==p&L$H#+vIE#KQxhpVVf6)Mm>xd z_v(&uk1EI-vlTf^j8Y(yT z*6)t6w@wD0sw?AR_e1C|>x%T{-RespMBWi=Fevy7Ztk~YOIb6qg=*c-`E4fgcl0`? zeGR0J#GXvhOpoC`)NiCuavnWaJaUOeK5(XHc;#tp_^UImuDgk29)m|EmUl938~HQl zJ~E(j(mnN^lXk6clw97+bT0499PLZL613O+I*<=@C<2GU8b;)05^Ysft zXZlmi+NAP?@3M2HLvwHXe_P#1uJq1HEh-1L+|B$ba5w=R88fw403XpYDj84n?B!W> zAM+exe<O-ETnq>RW6#$A<>cOn~?Ap@kpBlbM_Vh=aC(HE2bvCqYy zH|HDg4_j4EF{9elZPREw#$90I7k=-T30=qNIYzG(d0gPJDhnE{N|W2gn`uQY;_DbaXqViXxAh=D zdQhFjS;3z|?l&5}NbdY=eLXK8&&c|HMum&GV+J27v+SMNqcZPY=(o3{6Nvw<$o5?- z7Lx4M^c*aFJ7)XpO1wAy&da(Z`H{S=8KM&wu#c2?wY;L;8TcsAx4|Ew3? z(#zgj{)i2!;=Xy&HNEeg@S>N^HTtFSU#I8RQN9qa|K(a5%OsbSXME6kKWMmNA@+b8 z?tA}S#jw%sFz?_;iM=QA;Ja?I4@KUN%^q501>MA|?CY@h-vQ6Rywj>Ixo%T^**@FV^e+PuOC`XF6U6}5v#JV^_~Skqs|)*u1fsxLcR$t^#dK& zn!eV17mP!f{|zw` z(vzOJ4~UFOj2K8ma6BeQ~7x-zDFpdZ0YjA@XFvLfv@29+i;6A;&27#;!8Il+xVr<(*yf|dHSi%zcRPLiQ8M*_aOW}%N1Su^5*)L%%_2y-67v{U!pwknF{7+6FEqUhj(fu!<9=elqjGb?H zW*n}xOS$@vOMkL@=qH6q`i%o{^ayi zwD%P44LsPInh=L~De&%rz8CtS z3*#{ONcx)U2|}+44)ZNm1tnUTzyh`XdF_;P=G9Tgr@Y8oqvrf#cY?Kv z%`?jn8`>H*KtMs_RrdDm;7S(#`cpHt$K0`M1-DOv&wRPT0QteTBxs@I_tB7pO8At`?5Qr(HZKrQm0qf zIm-LJ%;TZVaiPyq{|k(J19Bm@1G+2`x=aiH3$o!e;C%FD`VO6kipPbvPTX97BXAq0 z3w@@=>2p70xRkQxz-@*y94Xzo~u+bGe}u z_{+0Z|2q7e>&sb_m%uMF9-pSXp|7IV&wvfD#Et@ch0rTIcq?TLKgl|0{;!ewN1527 zoJxODP8@$3|GnV8gn5A+Q{&(FH$umpIG$!KRhuukqi^-=arF1*C_D{LBg(zxj@|~& zGTyPbz;CV4HaFNj2u;U7G>V^um%@}0Uh?nGjpJAT^yd1Zefv_DkMrKQg|2z2@y+x^ z-^%hRJp9Y^#>O|-6UVo28}MwIlzBKWcpZAj9q1iOJ{5bS;c`!O9r}mAX!_Xju5iHH znSiHY%=biJS>%cO*G~^#i_C98Pw@BJu(oWj-^+S5v@LxkA6@H-E);qSFWu&e_U#pV z<_8xg^Tf@b=w5U(##6)Hogb&A@Y@n(AojYgo6wbpS|_aOkTt3S`oMRwJAwN%q2-LA z@U$6MHSW!x=+Vua>i2G9ERey1hkyAD1$!~P17KD6nf)s@I1CBxyB*dB2H74X-e zmw^8)@SnAYh5x&4{V+_K>Q5tAdlN9bCv2&2-;X>7o*8ecBW)S@zUAjD+3l-2KiJJY zX=09xt|0QY>>1=R&x0#6w7#%gm%Z!qE%l$?^3ZAna}M)Y_3?4We3@SJM8@~M1m3O- zf=3uH*1edr`!F{u>Sw<^x#{JiRdJ~8kXtL66QlW^Fd(mMgEmjSM@I=P3h%*nH#D${%&*q z0CIVt*cZbiH=I4PM9kINz&vz1$7Zp(rtaHh(CXf1s8_zB%ESJyf7XVo{wp?cHI9LXMbu+(``BCT_ri{S$?Jf?o z_p0)$1)DPq9ZFc*`5=zji~FJS)0n`9g!+p!@O*Re32pi8@`-exr;_xi8dz zGv(#^Y4~Z8FXU?p9~;<9ox>LfMF;m4U8Lrpv?qE|x9}BUi0-{r102#o&Ik4arAJgAsXQ1QPfZ@6%&PU}oZ$j&O#S24e(M#dy-QchGX3H;$_pgaHU-pR7 zufgM4Yg*CoihV}E8yD?w1@>WJ1IsRVto@q$)py@-hc{OZ52L>y!F+$+&0+I`Aco zab5a-^=0U5gE#v_0>6KU(6uxuI_C&^K5JYw6InDge_V75zgp)kjpM!+9Oi?62k=Dy zE2q9$H#V_myj%@F$gut&3(d=d=G$iG-et&!*v;dj`+;#8FyvR&SwbDwP2ch|)dy2Y zeY<5`RPf)o`CIklC;fQ!%a7RjKO%H53&Ou6>9=BB^rdD^Ltjz3!dvLA=7vq1p?-fz z(dTb;x&Ft6&gF4B8#xwh9TycmRoS&Rj=kjy$CtA*N4EQIji;jRQQ-X>a!&TA#hIa3 zc8rUj#~kZF&imb$2Fs99N0=jKy{JR~Z@&~hc7CQ_FN!WxZTMW51w}p!pTx_uP9NDs z*_(CQ{u97lepygpj4Frx8En?&Vn^Ype##!cEGTof4*a@*37po<&<6N^Ci7SCgD;Pd zwc*P`LxW$9Q|rxO>*bY4*&E4RiS+~b72vMFTmuEN`ae|9_`O)g%__>a9_(Bukl)bWgM35&6>A}{*QiDuD{31sh35)!&j;` z@GIcn0Zv1$d224S=fAJ$su3^-Z?o$zqHY0o*IyNsJ+Yyq;-mTL(WddpNOXF^&)2JA z`0cgBl$A9>cvh_kH8MB;O!Gv|p9R|=+EQQV&^OxQ3IBbJ^&Z+kpR&7kSp&=PvueK~ zJvwQZwoj=!=g_NScY=3?&}vrj%iwb*xQk8|=ABw&md{fC6?;bemmXSe=uKZj%WQnx z?S9kfIN!RaJ`*+g^Rrc}psOUA)pYh?|V=o_1kNRA5 z6L43dFRilo4@ZGnCF49-^|{;buTyR)YA<_C8rzDYC48 z4{#3y*VboZOEQ$*r~OmtUrJU^v~7h~$NAE<8<&wcWJJrv?%R5`f*D%@{eB|!yE<65 z2^z6xChKuB&%%_EIrj43K&RfTQ`6~-noj+X0k39$@CZDw^upvd@Xn0rOKT~675#Ve z{ORx}$cX-S8*r44y3~#Tm8p+#_f!mWAny-7SM&jn|!!I0sGbD8T z^F*7@a>s%9g6`|fFM*qBclVzM%fSs>i=I;_XtRobz9Dq0P7P}aSZ55~suga7ze7g! z7pyV-qWJKQj3|3FC7b#^_dvJm;1OgiI?bB0JCL!LvyOTuhtdv(kG+`bjVgWFwV~eU z@^#4E>Xvf@)}pdIfIX{ljqC@Ny){jji4}XJ{gdvg5`C?kb@|9<^oZoSLOfA5Pcn2J z(ZAKarH+OUD-c5oxx`DK%bdl?rUzhG%J-C*#*}$7@!@C)Hm)uh&`_#I9Ti8=k zX4~Y@W0dEtLG4w2StIdQ@VKie@UQ2$?rC7(LA|{;>>L|*Gq7jfqxLUfrred3|2n^e zPuk_CkA^$=!sJl94O`)P-iCTVV-afwR`oqqH-qQOOE=Z8WNjWeGgz0ufD zysWdm#|9tq;$zi&Y~5ktmD}(pSo=>tqwSeu=ln8b_|yISSD$PKPxflSQ+n%Q>y%LJ z7vAW<9R=Ua;x+xv_f+|>(l8X>v@3X*J@d@z?uWqpSK!_2s`SsE`+` ze~I!(?eg<&_*dKY&UmA@0QY+6)4mV7phpk(PYF$~+E72)HMyg|^`5HWr@mD`<%S=v zp7Lkb!5n-^2j7|!D!9O^oLnQYe!5_CK$lhJ{>D)*YpO1{$cA;F4eLHfnR2_#HM&f! z+!yWNc289O>j2*!EQW8G5*)XoR@wv{%N6IR5K)&WjW-cwbFzU_xjL3r+z=i)U5e(1DZ!{L9fGqhCY+20@j)V|fH zW@Lqe`#053@mp&O@+te5x@>F@@P4KHID!5Jkp~YW4^GX>(zO5LNSJ19PA##&H`#C= z1I`N?&Z!kyA)%ETyT2Y;KMR~neV0xdSWA7%_`Yn*o8#1fNz2BcKFz#(h5MztXoxmoH{+i)<_c&Qr{xjqE=MUdRf)HFOEj*m{_U181^AzHiv@ zW4`E%9=~35*4ghe{Lz`z@6Whb$xW%}L;o7coEGZOytnG9O`GdWnPUUR(?Y%ty3T}_ z@Uh>`01mRycdveD))>L(*VH+A8U36;EmTYyC0E;Yx&GXHtFA}B$$l#~%O90}{I6f8 z{GJkhuGldep2+;mfb(m{`KOHY$>wQ#P1&N$#+LY_{lyyp<&-U=?8#QUOmH;3lRKt` zHc&3UKfd3FvjR9*+^g2Qli;-V-x$wFfFu2Ua3maA4<}!?sebD-;B(Y2vt5_zpMP)F zWcn!UPi(DUt%s8@qmSc(*KgxR9%)(goph5v-U?ompRxP-mR)w2jo&u#yH@v8`nZO& zC$q9OE%uCtcd|S?Bz+80PL08jY&d&?bMw7bV%sWvW)pgC*&6Vu^mUDdAv{=m+2&(i zm+d<}u-@Jj4KN)LL>AARLXcm%yLcGMpY z|H>bA!dfh_egUlAQ!0IbZ^LRH1J-e1y`W(k9Zv0qPWYo;E8FV_`u)-0zvPel4r(|r zpYg}{oj0QAU1|1XL%^t_pO5Ksq7#kO-TcZfRoAWUE`w*XL)Y{FU&H^(2Gn|QRX8(q zL_bzaKRlVt%dAS@;W6M&%2aTF{q&~#pI(QKP@JRebtC#RBQxszCtW{QkQx1bapwQe z-rL7lRbBc2=iVFO-h}X&@Teq#T9f!xMhK)P!wsPtaI7`Z+G;xinco<|)&aGZG93az zNB}LVTC4O|f_^)bU}@`DXu0Fe0Me;J`!Hy0XTHvSy#YJDNqj;;a#6hB_vf6m?>)JB z0MvG#_~X3pJ^Sp3wfA0o?X}ikd#(69_Rh{bE_HMY&p6)L^;@vSO~g9~bRpJ-^EOUOdLxkALp$tKvJ1EmZ-rY}#jK#jk<) zs6b9Cxbz1r+UvSw?IC#T$D>Yq*hv)%eT?sw~bAyqGSU|VK$?{YTv9=Z&g-2dtv+Yuhmm8@?_@AZr*3^DQ~Agi|9{<=}*>J zdz?ato$){N+&$&sQ%~9S{;c?GTN!`JroZ*zz`w7peiXUWFMgXbmb@g~w{NJCXEy-_PE>47<^8w+r&Z#W6Uc`IjWt=nBkBx+0ck;jTTvq(&?5oNB=V%IM$&u*7SE^jcPU!yDv5_NhIQ4|S z&-;_qbKJ@Q`jM=7lD?mG(nQaUZnpFOD^?o4dgzq%J@HN!I>CF&FJq6B?!k| z@yX2p4~@?LbgEAEP5G~)T;_Yi!PJ=AWfP2v+Y9T(Ulid(&7q3(UHiKQ#XDHxG5zO>U}AgQxbIsTmsoQ|ey` zJkk28j_txYx851+%egzUh0Fg<58e{){xtPIzDGWwRAUtgWQWctkQ#3F09 z>dN;Liws*$+%xFT6K8qk-F7u;1@*)_vNmy7ynGn<8z%&@1!7-qzU_M}q7%nQaz5hJ zf8_f0?E5QD-0$YOvUfcZ+I$#$qxj=)o|5|NT#Zu~_1v+(d=G8qT))107qG++jF0RE zp4`&<>IuHwO*L7_tAV=m&tfN@d;9w8PiK+mrSXxPiO4Qx$}?e8B9M)4aJ`);er$YX z{MXl4e~x^1o>@*FQ_pzPPBo1A)Z!nm?y3g6YvCwkT) zSOiDMRqppHxBQiqf5<7{F@HkDz!19DSyzT{5+C-r!0^a@f4$<=vI!2a_DLttk;m4T zPlJ{vuFba3Cr{P$9ho3rYneqZ30|H1ll2+GRDVz>O0?)Mwr??0yg zo%dDm%KrX}Y3vuW6WFzLbM*t4?p$&FIr3geTQ@m*6RYUYQ|oQLjae)98o47o{xN8t zO}oC}S1B%(drRogH7j=;G4QLKlu_JnOGI+&vv0%&vP=cKnU| zvuz%%12`LXcJ)wpJhYIr-)-6P#8&?Qxm(8z>&vmjT^S``9XJ@RoEUlKams4EmN

    l}EKU99Khk4<#O`mR)+ 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
    bp5s(v$t5C%Ai8^hDCfUi%x6+O}Z zYsmfT+1{8S$_vDh~m!rZs++~#<6hc2H)dYqrY*!rWg;_RPrTU zTLp)pVd6dd1D`U>EKeUslW%~(k|@vj2EPyjpHrplq2C0)(?&+(CE&pGF8z#g#gC?{ z-qOz~&-&-;`uq-l#H|nh3GjWu_)dE$XC63joCk%I8S~2aP@lZ4geP53DEJ}cF562> z%=S89s{|kC4Hj~WSC-=LZJgZ#J;r?OkF2rYbS#W|+^;aM1ox$dI6FF?1=}I*F=GKT zUIgJ}*@VAz%3|DE(N1YM`dRFa?SMNg-T|BT_wvqa6k=w`SbS)wRR7PuQhq;TS`5M6 zT@mhy1Gp~^;@-FzzUw9MUH5hFhkow>eB=%yj>S>j$sR%+i+4+vVrJL( zr`C5Zee$a05ybu3{ixNIsIWT`cM12{<6t)?^MLP!FVQZ@P_N=1@ioOGMT>MCz6oNS z(F+g<4)<=M$;E4WJD#iEeKCB`gSeNqk#js%&_$mo)(If)S+ofM-?pF||Br~?HVJb% z5Ae^$IObqH5sYg#?!FP@((f0(?un_suHEH`sS2N)=(C^cUb>^QGlny&6lWB0Xw?mV z-lt3eyyG`4!#mFVgG10Z%C7YVnk(Rw7;2I+j;CC#^Gke3`h=n$%bW1%dop2rAlj9D zlvyUHk7?HSCW=1X_T;nK9^+LI4!4YaPA?^ueCs z+#TU^ylfCx261JexRTfR*0J?T&k;i3$xNG{@lNj06ZQFa_P`?ArOADlbFZNc%ct!f zQBUrjL4WQ@GK4rKI>)eUFZAyDb2GNe(L2U~rk8=Xj|GiSkF&B5XViY2Q3r8GG3N|z zZ5Hgt<8u*g7%_b8$ie=z1P5J+-n0!+s$fK z$IA;N_9$&$qsj&_tmO2G7}sj}(#1;PPlvf!Gu#^Sol(|^e#p*0flY|;n}yG$j432# zM)E92FqXaw&ZT_k$Y=Dk%~C#@qx>kG%Xj(M4)bbEg#8h7tT1nhl*{$|Lx7X93U`99 z(BI@-x_;n$;M?1DncZ?8{hma7p>qacB==ZlCdu5izEpFaF)? z>;H4~n%iIlIDg3(`Zpo&+#H|v1m*eVh>1G|F`w(~F?(l?xc=}KjCDC;(&4#z^H6L4 zgQ&CrQQMp@cfZ2@l@!}oH2htCtg!`OdQ4DH~Zh$GF|d5j$v4E}C)X#MClf8w|q z6Aoje%suAIzRL1XSzXbyB>!jG72jQWZunn5hjt$ERebl{z_}j?Pnz_BUBKPNXg>s) zd%%wdvHzFDKE4*P#1FT=M0>yu7;_WG%owN7oMpXT`H>Z?LpJ#Gv6DX#v?{*~8^OJk zKSDf_c=kEK$$0{dd)8qroTJ_F;o^KbeH~3bQH(yy>@h3!oIQ9j^~A3+4!+anVu+8; zSU<(X>ibs!u2S0qtkwN7zzn^>rU2*!V)|~cLtky^i}SJwzj|JP1EoD!n=-78ZZpxJ zdSWm7K`c1g&#=HswyWnVdX|;MOu}w2Gfp4ziaHO0Lu$O#KV-ulQzlt(i`ChVKh|6D zEdIwI|BsyyI&!|1Z1t7ywGank!A!)PxfA|xcUs-;9}Opch*QXNZOi_xwtZPo?XqRt zYCA?gU%P1JirQP2Ew5d;ELOW<*}b)~o6*kA%oF18jO{@E9jJesS^rn4|LfY=xdoj* z_)o;f*LO$9+uc#|+;-W*We=d8Z`6KnSwUy?A+!ZNfse$C(C5Aw{afrUd(2A0acBr= zD89dpaw%V6FZuk|hpc2f-f_Q+G2#EXQ9q8gV*MD}v5j_OMmsx!%Tctmz*h);1z@|y z?rz`U!cV*Ewq*kwL+nYw|0HNM)+gH<5=P`s$eK5Tu?KY?1eSw6-}Jj7tNj-HIU#7Y zj4dd}2|Sl^(Iq}$Ee&~Wb1m~&x$>CRm4dA@_b}zL7-OZT$z$n$G&;8f<*B=s>?LCw zTdNNFNaLk0Q_Egsaqh5exnIg&Y5bWen8=PJPG7yU>xGTk4brL;o~|E zu^b=s&O|BmL#AYT6MiWVF@~0eO`p@xW1n%)cfNcjMLX-IeO@w;75fn8vYNl`|oc|-2cNn$#bQy11|g3zGy;RGV1zKb3RBr-+kJdYb~-!ORv|spA{+-+hdi_N{9qfe^@=1_S&4;f% zvrYVGowgjfKZuKxcYi;h=(6#{by|Tvup25H0*(XqtWYFb$#ML(W2JjCaJ|Z38dAFVow{z_SAp-!8 zIPPNgy}UR}jQy+6m_Z%`vK;Q{&KUgnGoHT>`Zz!I$pz3S7vk=42<|?Sa~ifNrk;Z_ zvZIKR9lue;5!vt%@{5@~X8^vLlq(yw5tA4Rd_A% zb5+y5$Y*jDzAL_D8~E(vC13htWw3bVSiGBnze#ra%W>pQAx}ONd&Y?qfxWSSaa(bQ z==$Vq$j?L(7e0U-cI98yXNlY+cLATRYhhvhb zjT0RQsP)R z#F|xt7d{_8!217?@xPGyfQwq@3-tEAsLSylBBbbZs3qJFf6x9@omC@gHDxvCNRatN zHLWHc3`}?F^Y>s+sqs2;wMW)m5_S506gpxp=RJrzkN$1FBRj_UjJ=`1(~rV@7T=BX zUpD$o46x5Hc=~L{a~Jxo!<+`-GXP%7weNucw9e&c!d>Bk>lV-R&7M9Gv?XmEpY%NQ zyPmrcV9@Jw+ga&yx-JueuY@k+mE|+wH0JBW=tqw=3jd9?u^M>`%{CIiYu#@EJ|w!| zJw+bau&!Bg6?Q9aBV;VJ&9J`;-DpiW*L0L;E*Psu^oM#Z&lqYJeq*0OJp*?NJ@sr| z59=6N;KG@2e)eN*CjOaYjovb_Hg=lx1D_{7Kl%E7*{Bo0bzpV=$*2>#ZD4hN<{6*a zMijnh1A+B1wqeZs_dU;#iszZm9)8&KOg{;;zWna)aq->Q^AE7R@x0Pg|6b2?hv&If zJiGAlj5PcIg6G-${X$RuMV@Dz<7w^5@9uc04>SAY`DQ+sdfNMt=UMU{lHR@sJF-eo zeOcb^&n*8c%Cn9I`Ly0sug25QMV{|GLo?xY`;lx}tMVh8c`s79 z_W(a;8N3zG^EBR!GCt3A$oLjyeaiXMA_dsQ^%4v_uxgDXC$zFW`E!}zJ5DqZ4_(p zTX#P6edmeHNkcAp4E{71kKO}$SM%tnf(NvXO~ZpM>%uV!+1!*B$gc;1YXRUb@o~Ya z%?0JzGXakO3%%2s0LRbH5I9z!A#i;041wd5X9yg~%XmiM>Bs@V@lKy*ZzGoX@%Aj` z>ol6q^OU**=m-S;f}Y@1=;&_-0K>aMM}K&Rz;WLh0>^D<2po|!1dj915I70|2ld@w z0sq0@FRR}#soyWE-_NVxyVdWV>i2Kd@BdN1x2xaV)NfS%{+0Uutoo(?QR~^G$jx@6 z@eCiSs_Tts_&8NvXFMkmoAVmuIg00b#&ZJxYqO2#D4xmV>HZQ!`m5@U=O~^pHJ;%k zRaI>~NAY}#@eH5us*8>1D4wSp&k5XLTwpv$@m!&vKWMy5UHrU{q!eVS-~hYuI! zDGhf7zG6zEmN^@1tJy5!y9FZZrL$OkIBr zy8U36?^@#aREik23wU z80S7P4E8sObq_!M`Ly4JZ#Qy?`XGz?aTig5{K>qFkiHS2x9V}XYE6&u7k*2CHR->K z_hvG0B`}17wg?{n%#y7AQBKI+TqUit2|1ZMd)FVYzb!ck~=Ae8!+QBblkuJym z5aX0}AvXIp>R!pNMmwI8AV$&N;stu$P}#*b;|*9qA6&tk+n3;s9t1?#mG8 zeZ6r9wGMYsQQScpYwfi+HScJ+CwNCwiTjzwcUt|}d&$u6N zTx*HOKL^gaR?V~TAe`R0XI|kt%%!kr!ra!AE_>!Qj{9wMP9HPtaGXXRJwE0ZHpkb) zI-^xTAIV;abl^%DEc$z@rRrXwQih?to<2t*UR}J?sMG$ zr?YM&jCE7vi(%co<8#*SLsrd8Yzu8nW?N{JW6aK7|63YGduh3hG4~7T`-Jk$o!eWo`LYE4M)5z-xm3#6g&eKP3|>X>Ir6Rx z{<6t^KZYM_A^ch&gJ0`ohF@z3+HA!)z@FjPdMmyyLSJ6L)@$&7o~q;ZYrO>D5JST2 z*BbA*DKm!x_KfMTdGwA?8Gf2_j`m?b?>?N`bT{T8s&aKKFmiQpUMR0|{J;|j=X{t; zzL)2%I}Zmi55IHb;tVh!NRBx>fH}*^2cqUIBOi#GGf^kUoW*y@I9sHV#Ek^@m%cX> z_dg0}qS#v)ml&TYhZrxg(Q%#`^F`x~SwEkwOCEI${InAnENiT@0?qefZR&o2d=B?m z^XZe3@Y_>>pTeeT1^rbF8zS>OhCeI z7ZmQQ{-$0PYH{oVI|jZMvX!N-yN))1t%D`Lyd1%ev=Ixqf|j zSo3=@m(lIk^y9+8dvoghaZj1cMm`%HG0l@*7;B8ojo%p^>GC$u0UwDMq*=QE1>oDg z^RNc`1A#y5b~yHLk8m7lThFf#_#?}>Jj#`Lr*UQZ9THb!7;~Bq-~@0bFak8fFT*;Xf#D9gF>y#KL&Z|oJ$E8B`Ld1uG@HICDeXW~P@(HJ`m zbl$*&OVzkoj_X7F?H=g!^ggB>yb|y}13!g!#9Y>AQ{XA7EAB&V%Ho!`>cm1XPdXhx?e>rqf;=q zKT4llj8DLjxbOZK6Dzy^6uR)&e~MrEKYyY=Apo4@UTXy%XFeW5YyR?`ne%{w6Stx- zbG^T)$6=JYnee;^dtvu#;IL=SdOZ9S^FMjZc-QsMdi^%LdjT@AQ!lFU!Qq2*=&7pp zx-1;Px}0V{@s}6_*8n!v)5Y2GQAI~DDr$)!rn=rkInT=zg@@;cXCFA{A#}IM`5c+{VXF&B4 zQ0K1GZo>fDZBzUb_?Y<6AEnW~C2Bl?|M-q}82~(cs#$K6(xsH2yo44?; zys)Tc+ua!B0Ojv!hOb<9Udy{z!AHpZHP0Q65t2As$wNe*PqN`u8_zrI2mZ{F;0W`4@*)t>02>2XS}Jd+T-WwdHZE2DTQZQFZpm zA*XqHJyUP}Fv{ljF-HH|$5``)8F)#$zRo=dh5h(x)_L>*=S}%RtVbW#V~1Lg8>|}I zE?K9!UxAN`#>YZRzhUsU&RpW|X4X5@|M6s8!Oz0RocmwMG_W2|vDfq541(t`;AXx6s1qI2LEpiTmMPoeQo3oO&$e)2HjwMgrEZ>r_+f$;f(?ZA`YC_H)a)ZlnA7aYeqhpf)$YW-iU z-{}9Uy%8C!YsnMY%W)22Kl}7K^x2a?hklR?E^S|G=$y^-(NeyV{w>Itwb{s*_13A) zQ!E!e12`9bkR5!G83e6^+;A#1m;M7;@n(SY;`oYgJ~cQ54}OyP%Xv6m_r&MsnvVgj z%jvv>q`d&`ciI3Ce^1trM96&b<7igx2;BkvHYn?{-Kg`dMH~b!|=y%WW ze1_domFbfKyQ3=l-8d_CGGi!cZ93>|<26JlEn+Yb$6fcXTqAIb1Mc2^vKGF4^9 zkqhDZZP=0Nw&MM%syEH&q5aj`Ur5X+o^LT=i6dvy&Bk*G&w8E3d>8ju>vb0O@vPTb zd`HeCz0Tr0p7lD5@5qy-*I9hWvtDQM9r>{S!t5W+J_>4-I#1IC`Oj@AWUMCC{(}d#ZO4^^7Wh_sud6^okGZygd)fygewx@+|ATlok(gNDSS!H|sU<-BEEmr4)w^(mmu!Gd^7a(Rh+tJ@(KRdq{v9ehw zj5_>ASbOQ$3K&!60pweV;QJWodp4Ui8+~A|I#Ue=S!1`eU9mqD%$YelB+P)f^9coW zn;MITS${hjnA7YXbHpFtFLFr9{89TMG24Khf6U&B4_>kdXIgL^d}BJucaGUWzK4D>^p)XrAM%Ik zb<@0AVkf?#{0@{6>xpMaPCy>rD10J>uLpl$kvMY`}U2c%#d^0K3RP>g3M_ zZx)B#t@%2Ui=EFZ52uq47wrdB`#q|C`b3%YVzxDZXXfuUTc?%ym9>2jJ#F1 z7lxB-(Z(dm*=z0Mz3?rVe?Qv#!Q;hi)*^S?X5{1;fx5S$ZWHR#SB`a8B8S&)sLTFY zcdk8jMH9;Nf96D3j+}NHmKTtx?XmN(N$y3CyxRr*B@Xk-(f^@jYTEP3)FzH4 zf^lrqV?nProSWG+^k%_g(lSo%dU9f6MoYa@9Y47WoYQ-=Q!0P@K{%8Kuxo1)au>okBvFRkdO?{d_F44FdPgyqN$3-M0DiU;_RfJHUj*ftZ+0>A z##UngGxm5p{7Lw30p77*0CC<&T{Urn+3zC6=V46ro-yHMXoT2TqRri)9ogE1Us%>Q zL6=JtmxQ|?Ea@2^`%_>-Pn9*D`P{wvY7;xL$JAaRzKeaWa4%6eQ{~;8-BpLR*^ROb zA73tXW1KsIuXWGLI&~6Xy>lx2)Oxmh)!r=G9{SB_kNCgO#s7za|K>Pio^klp8k~va zFz3=cFTWjA->uiP?Ocfu!Y>?rZ_nP;Cb>?f8%!KC@uXsJYQB$nf;igcmmw|!VmImb zG=5D0e)Y_iIN4QC-zerPX549+=bq<$&lT`dT(b13Ilxzw-xhw(W6?I^CHN6<##^@+ z`|c3VAs46IcKa*pYj`%S16>|vNxUE(`7!qC*ii-7^-hJq_*B_uQ81cQxdICm= zr9I>E{5j&qT;?;vDObDekoS89HY zds&U42V-DvlHJ(brNM3EV~+$U1TIS7+wa#s(StqV#Y651b3PWml$y``ST!Hj+2$i! z{{PQ>?0h~of6oQsuG@fHai293egriMoU@?+oAAE7*tWWP{?Ea4E&gAx==P|w$ccW} zA7+q7t@D4npS1kg(vRajzXs>})i~d;!a08>;-}984_P2&-!z+y*1|5Fy>2Wt{2x&F zdcFRyIX30qSZImAMogby!tVCNR(JVtlzj%y0ez>#HUi+U2NF;H9h@N2u295_MyC1EGjc53T? z40IqXPL7o8&o#`31HtXH`>nzT-~raU&9~8>2;be`6ycqO%LXpkzy;sgYK=>MC%wkM z%?0Dc{4iSU{~fkxm&5j~5WX1q)fTijY_ylp+UOtm|JZx?_$aG8fBbo767nPgR1yd` zO#)&kp*J;TNQ-4cPzR`5G1jeAL%`O7*jhyDg=!L_?Qn5Rywr;B2DI8qEW2w9O1j&H zNLz#UhE`kGc1Zy3gxCw^HiO{&-tTjs^E_uJlMASAzrWZ1@w{fvdCqgLpYyq&&)IR2 z_e?M5FJrTjiTqhJc+`nWn zM*Z#YZH@0iKPZ=c*#1?%6Fxib_)dUtwBSoI-p&`Y8+>ynXz38r1zMW2U7nrJw|__3 zzmC5Q>V?cyo~?b?2^nfMW)HgJsa>=Rb)&BG zE?ZV$ISX}jZoPOscp#67ex%Z-WI42NeAU(9n|nOQ*42!W3Vyf)x}?-IBcO5l->nK% ztOj2@6MXH?e#)f#PT?8OQDTU3K)D}zhlO_&{4_UeewtCWC#a{8z6!)sitdGQ-kS2Q zl1(u$>t}(FR%K~}C4bI&<8Nx5BJjF?>WJ}MroK`1iQf*S4^(kISE;_J`go_i zm1*E^_p{p{0#6zxkBc}VA?je7p`RBtkuk9HMck@~@J^1yXhz@GV_yrob06AKb*9Rn zVaPVA_f1h|vDQPb8DW%-L7RXFjwsTJdT(n2Ivb9qlX@o9X<;vu$5Csw*E_C_dM+_` z;0No7i~F8Ln|gnQF3Z+GQJ3YcHTn|L`ZAENOyNKJ#t}zW;tAk!;(DVGLCiM@j>KW? zdm3F?8Qv%LZ3wzDC$=}*2qX5l!ttETAo}Cr%|cs0hqlA^yb%WyN9ya9q@QCysh`u< zk9ajljRSKZ&HqX&Gv7yNt%`1(xf>2NnD_S<3T z=8i%)cMNv781(&|U#?}5*O<2A*~{Y7p!b&cw6V55Z47kGQil^62K`qi_lWe#i<}o| zrQX0-obzZ`(~cQE=xa9ojtrA=Dq1>TpOX|!hp|Ca!-5=Y$%T&l-D|G%~Ve{Zc5O#>U_S?YAQyW9Ho27} zT2EGap-az%9WJAd_mS^~-kbY0j(tkIobv5ETxB*#@pPjcVJO;S>sO~XBeI@cnfmDCsnv@jcwZt9m&4JK>L30L@{@_Lbp#Jfo}ANV}d;* zp8YSNiTjX;e73U}WnqJwPg|Ja6=o`Zc9pFkHynMo!o|^i7lVTY=|o--0OCQRv9+b)=45t%v&l#VR1)R-+E(i9& zCa=J+f^S4U5%h^N0n?287($x#Ri&fg*C~Uj@;=)hCej#N&>ouwTE~8M;+OSUka2XL zQy&Xy9{E#I2j_(}P#c@2zek;6`Z(BQW!*ufY4=inr2UM1kxB=Vru?STojAWh8APRn zNQ2*Y(w)cM{)qaKUI;#xaG;MNQI&-~TY$M7i#Z*KxgC!=o`5|&5%#aF=Hsw`(NFpa z_O4D})xLFjeCW3#-tjR3Z}#5ZKwiD7>V#o!9NAUnJ;C$yJga{kbb_>4!65q-?c=Y! zA$gzI+wfxh6{o^R^poJ%;hQ}HaC`!FD_(g5WLoa|m7u9Cv(=NITMxRr3i}iWDY5s6xll1-`gX z+*$9ned5m6inz0%2RtkQTwDwI_#EKmpRnhyf&Mg0`VQH$9^=oJ4Ke;Ka0krmybr_3 z=i2BppWqGcc_Z91t@ahu#2E^X)6L;4PRv> zbDM=ZwlLS(nDZR$LHM-n^avaD5$wSj_8|G(IQZP-;B(&r{iH2{^pkK&zX!-U6$vk7 z9WQAR?N{Rg!<22tw$axCwBu#K@yjePeaocX%!ChXr}8y;f_uRALpwHH#$V*#h0RCM zxqX0*V^x4%JhC3!9@-*#)!wO7vHg&W{@fWuJ7W0-`KIom8 zTT<`6Y8-4+MfIMmIA*pP?K9SI4>(rYu9UT57aRq+7jc4%KNpHA8b>_EIk?t4THvWC zVu(|Y*yOa8tMRI`pTOQZf^mNf<5swJDC1A9XDD;fdAIkftvQ|JH{R{J>L|wF{~V;8 zGZ}Qf8`@ik8KZy)#Qo*L(bih)vXZr?dA&0y(F9E@oqEA84bkbYE7yK?H-DG|k^^ZbY(OR|{ zMp>3o_)67bQSWENF>zBTaMMVX!~8mQILLmZ|E!mF5r3)v=r~}ZO`BPkyo5f6@Vf~= z&mZPYpB<;)8vWM>^IOX;n>~o%npuZfCBpaY)cw}XIs^NEsD5jzFZ5e0!k(tDQ0}ME zKgi_De=UHs9S4BN=s#xRe|Gju8%p87mK~fOFS%oBY!~o4^%iU32dDCu;QJEr9VNC; z8`ty0@Jnei&AJARjqm2br|rX;x=&uJPg{=g$;$>#gg?l^F4(Ktzp1FF9`&$atOw_c zwoFAm$^LCQ!q+YJ+y2gy5O?#;5p@$e=gy9ormSUAKR$?cljK@Hjd60$Id4D5d=Pf& zQwY2-*5YZ+|8NuZz|ud_tSg2Np;460>1~4lq4G!M8CKY4 zAv*oRdRBqw!g;ipBZ!NByT@7!+Eh9ox|3(`ylq=(JpDAr^v(gSkXPL?X}t6iS~v^) z*eE+T%xF${#`R9Zd%Zl?x;g~kf?X&t{EQ%16`|jjH&7AHHm2$LyX$0P+C0>KD|{gc zTS5E}U0xLrVvbhKt%|pzUtjfPuPr!o_bX%3uPyMwlKske`qeOLY*N3rjxw5$jWP}v zp`Oc`i0r!Tg0U32dYO+L$s%%o%wO zMUOCV2Ti~X$1J|Xm`~-qlPhPT50${{JH`1h+;NUO=Q5E89p6g$*6)OF0JtxEEd1Gk zCrTi@v!BYZK4(hKqjRxuYXC2mxkl2RcEs7%4YMkIIgFhNeeeV$-uacL`61ko78-`Q zgrK3;INW)MZ==|UVfgDrQr1)->kh!ZKF53)BLB1t^0k*dQJ%07fbOiv(;Qt)J-e%0 z4@2jf*a=>((5wI-kRKI(c1(kJE3|dmwm&6x*Ii8=GrG=bxF`zR7DYOdz`bqoJETrq z&=gzWn$~WCwpCv#dUBddsv{&HW-ktJ2X{6A%lSbM4*_JPQDpGw@Rb4E9a;1Ae zy}Fa0Yr=kkZVEjx?PVel3@2=!Q`~qU(l{7Gt&Nh5cY3gl^c& za~K(bon(0N-Gns<|9TX>vaqxKchmel+}}W(Q23t%+j34^9zOs->cQw~9oBYWKX9wA z3;tXJKWliHzR-jFfm?M3_`6j6%WoBa=6~9K1pc-ALV8MHxmN5)-Or8ZN;>Q_%A6lp zcPn|%F2ES_1zalo6<`YRDREbXaJ&R?)+EoDNd0ty&=V1U9N5{1_b8+E=F|rXKBpc$ z4A!*~xK^!^4kxji+2GaevnNVNf^Wd*I5M*nUjcP?0tRRgWZkMhuDPRM!Mh|I1k!?s zvgJtqn}PMpUdU4(*brR%fnnPZMuVPkj;LRk{)YBk{T*xv@B^N&Y=d%b#yYkG_>~FU z0sMW1?cf;J@*l}2@B(;_|2r24eBLMCf_uK~{|{#$xzEzs=?-Cksq?R0_}_thXW-j; zKk<|&!)UItjDw57|K$P3Zv?(0-KL$o8@QflCHC7m-$G1)PS9=(v^%<8%KQg_OX$-b zM4SUpwsEjZ`1nd1w;y$=vlcxy;MdMJ@(ut$z>d6Z4*b92J8_Uau)=MSjhb=K%ggNB zZ1jcwLtN!$#}IEJitjCa9|fJHZi?|3m=?6jro*@O(=RjI*v;{%F|+SE__haquR&jY z=)2EjY@tli3mVM411P`rnKc_Af3B}Hjb{4Y!*9R((@U02{}P@Sb3|P?c-0cvBMTu9 zSfCYBCnN2d7VbCeK|7^rr`K+03C9c`igE(+BXPg#(}ft1u=m^J<65Nh1^gz})~W2A zik1g~uPHNg?o?hxr{~*k-o@rMlJT?$IFuyUufrEwJOZmlqmkIA`%Pbxp*pgsU**m?-R1 zN4;Z8bHVc-+X;KoonPCw8uAS147_di1sIo)-<%O>e+P2wW3VZ;c*pdz{NuQ@R4?Cy zvlFXHqo?Fb{e=AS{qls9S>^Pxg})AXF7UP(vk7=B z29L--^30N|XCr)ZB+r-+xEUvSF!oQtaiN6Sset2p?5QWfOTP_%jc|M)`usiA-?9n! z_hJ0sGjrFjJ6JQl9&J|d!FTIMuN%J^ zvM+hcb_ zh({q09h{7F7zZ#P%$p1Q>m01%Osoags(KFM6qH~MXJU;yu!g`}^WjUeJBT&R#Tp*K zxazQm^?2WnHH4loKNo8?7iCobM&#F{zLL?a$CqNA=nDc|wyYNUrSN}aol9{pN?$+r zH+2nZQ?Pix1K&o8r@6no6Vq5WY{y^eood@Pk>|{-O;f_QeL?xQoLo5nMo`TOzIq{rG1E+ysb=F3__r}UWSMvEkN}0%(U#K&TKps;2 ziaf2VGXmY>QLL*<`;d0@m#7DLwER!n`_RdRuu(=}M_dS=k87^idvfJ=*z*vl>c6CH z&iCTJ#yQ5a9hm3BN_l^#l~F0?k84GJ%E^@-LKg3Y9>ofUrU&0eEO#xR=ig7h9Mj!V1>D25WC&?{{Sx@ixpuA?jc7%tIR}o3pL4&pfc-Z8>|MMUV=7D@!d_|Yj}BhpzE)_ zXy;3Hb<_XtA>+zDZyL)kFaE`bU*P=gj~@vfZ^V3TKWHus;I|HYs>PezOWbzAo888J zg1vD+X;SUcL^a`msW*4+JafWJHQ)o5oYnF_eAjp+QQhO2u(l){`?eAHF(G|xU1<8@ z?Kn4EMc#^MV#nD0mE;*(o|Uw+<=;>qaxHBg0>9fliNNof#zFSa;h9jEY4c3yVtkyV zjalH&@GX6)h+F4j-RrRq;`_7v|9-#vK68NYft&hkU-4`kdA?C=pSZmS?UT>Kox2B% z`{}>aKJ=7IMh34Zd^|Dl>wgNmxNp1B{3gasJ1_ZDv8S*Gs@z_@XBqu{6y>e!Y`({~ z9dMt`2F&n#{SiD|ITR5BJ_CUg%Ou=9Fh*^sE+IonG96bcjJ<@+i zo@L*U{rjfU-@LCn30J>Iz0L6(tAK~$(`f5&be~3^SDt{qvC<2e2Tth*K3!$+WAMj9 zF994V^b)}uDYMOWd>S_l;L|91On2^OTAzDi8yIAr|B>_{2pnCIPUmiZJTvYq3dFUugC8Lck${(I_ ztEPevyUENJ@gtyHZ<}eFBL0QX+O@&DH~Z10<+Bk#A{1MiC*wzy;`eRv-?WFy7!YRN z4#=W&O~jTMrD8ys!Y)=18nhU6`KIh$8`f^lezYF6Xa{Il7~js}`El6Sx`2QA?b0)i zEpuRBWBWxIPl=hkhO~?SzlQQ5(_Ewa!uS!lA#cg$v*SI`-KsH=MyfGb`0tEit{lUQ z==Wq*mz{S2ya3y8!*8E)!G^$hFG3!du`LE37j0b5xa^o32OyXAH?9?{CO0qn>d?kO zUWV(Sk3r=PG=`1f(NA{_YF!5!!$ME7kS};HKXmDw!qx2DiLNSls(A3Aj`LaziJOCjhI^-8-CM+Ce~HeqWGR|sJOEGFh^nH zjNb?1dlwTQ%d*59dO6k!yxP3aF2j0?Ov9hb^PpT(8K*v!Pqjf&hIRB|wv4LB5XHO- z`N_n5E4@$@@{D6Asik9f=-#BvmVH9$?KPB z%G<5<`xa;w^c~cB#3N1PVjMetd5?GkcN`V)Ok68%CfP;CmA(B=0eZ+PfJ4E)c?=nzwEEkjB{)2AH#a!EZX|z@Qo@p zjWcuaSaSQ^?A*0#Ot2}gS8WE&!q>W*Fi!X#d*&eKD&{@>T#r!P5o12Gq7J4KlC%}%i z{z>r9d-45#yDaDaUEI~;^s|y{^0_`fiH(gJ)m#&-BjOHUjJ-J1p<21*v^1=bBHCi+%*0YCff3|iqH$k{fVmK6$y+vFviHgZ9!#H|I|FG{cyM*@C3aw?d45~FOm4A5s$p) zxw5bXWB*kDV^=Wz)>%gW3GjzstqGJI1`NUHP3UWP*l|NBYjaMBXV^#X%R`uNu7$)s z()T`uwY=oJl_f8J+_cNSw7{xRcwm-yjtV2^)}imiir zeFr@Krg9mhBVfnZp`WIjlRIHwg?`iSb7e`o{lfj!ePae~$70WY0dShMR%L^))wi%# zAJn`&f_X_@hbY>Mdxy7$fMbrM|BRoJC+J|Fpo3#^hA0F)!+c|k%o~He?O*pU>wZky zj_OB32M8GL_!p!4&$yd?`wuJh5XPX+*iw(D?{`Dp z`+>dBJz*$3)7UUW?GaBS?k(imbKYHuyIDf#eSN<5)08+9_I}`4aIbQ6*wf!RTe**Z zI|*~~{nMC>-=?1n^J;f4-U3}Y4jm82-QT{BV;;KDXQfxu_c-k!KJ4f0Vo7UBTettv zT-LbRtQPbZZRxc3DU3zo*rg)`jJ7L0#rYt9l5ksDLOk`v`DWVn?7rL`1M&Hm;YR*Z z>{HS*?$ZXF$JP64H30Vk*ARQ^6fYWu_ z%RZB?C^|*FO`6e-JkF7#7m6P2wdn?FLg!E4acIIP&#`d;>PxpLh-Ws<&Tz*54)6@y zPFfGZIpnftwPyF{B=4P)-^jh=`^`V*-pS_PdH&S*&b}q-;jZ|TF5E%+m%shRQ?I)! zl)moD>2BRJJ`-ceQdh*Y0Qor2GN!G*_L?4Y~Mc8Ty_Mun%mAWu8g5?)(e4cN)}Rb&wju>>HeF7SEL*>-X2Q<#v%39 zNAT@)mj|{zI}GOsY`@bOV0{;4D@9v(fwxe8nqMY^F<`uK9Bfs;H67Sjdu=CZ+o0dQZdTs_oTuos`u0V98^#^n zzKb%-3>AB309s+#aZ;i`zi+-3FzzS}L+6P()Ayg?^Jtp_e0;c@cq%27o=Zbue4jG_A_+B#ddr`*}wh3E$RBF%B90k9fcXN=j072 zH(>1fQQ$GFBUBNJo72M33rEIz%hI*=@>q8+NF&I@^p%0MJmO7(o3%XPYwm@lZvhJu zUu)$GkmpS)HvxH1WF~)$v!Btbl)TBv+n14C4l%T%O(}U(fvYEH;9OpE{-L_8R+fz} z7}m;qq6;!x*+z6hMl0KoF7URpZ_x#wR`$CG<5BaaCZ_7_Atb_PX{G=kt-j0S&MwlaLQFB#9N9_(f2rc zX6Qq3?|H_w(47ll3(i^={;FARs2E8a4pMw-5BgICzSU?(j3n}_h>>KhZ)>%1R0aM{l^4j{rjr+Tf=^9XZ}&T1 zNB;V(l-C4b$-O}Mr(fBMQIBmPzp3$>VvTOV-e)UnU(LeR;pVFT?v4j(eiPs!+HUt{4z zV3*zQF_taCI9k19W6?K^_=*LA6843>rGhbqBNdKF)d`W#Q!lX>-|Po2VgD7pD?7Cg z_fHkbHB$And@A2R`SJAYQv7FkT?nJkX2Z?^nUi%X{juUf#=w8%^a-5AtZqt#}a7|-U6 zW#Q`N@icg#zp`Zk2X{Q9;g0_R?zkx#cYG6LAv|$yLbk4Cqpd6AdQ-mhK4?}i&P%Tc z>Dc40HDh=UTGs>p*H!y_w=Tksf=k9_;2H6Obd!M3K0IM6yf&>*53ieEPi{8{Ymp8Y zrGrZ$pZ&)D{w~SW3LMj4`Qq1HTzJ;7H2qGI=gyJ%68f{sk}ph{RT9Nqz)sN)zm)ZV zfWDV~;QqYTmeq%fS0}GdKOe=r-SN0FXnAH|$v9&N<@eNn>~9XtU$}Gdt4zQR@WZX( z+Z4W0_7(-tO133V_nj5q5FswK={3tL{HJu}^t)AgiVs)&O8J>=0zM=Tl=6?{fz$HL zKR+&b`w;ZEgN>{51$SHpAP-my>H4fps z82CWy@08ANA^p+LfZq}9BNlv?d~bWpjG^!!9U2bV0UYubg+rvSFIBE!d$4tZcFOnG zHsBHXk2RwG?W?@YDjzYcD<&BEua6l&O6V4^H>>AdcyZjkChmM#be*?)4fH+5#chw8*Lk=2jKCd*joxLOKJTs8VV*icD?`pn zfzWRj2>s@0%msK)TfZsu81va0jedB>))l`FJCQjir_dZ%XI|^A-iWwU@5Amb$*?di4LlLw>b$P-GX%~qMxBJcRJ|2oF!_8E z_yO(%!scz@;}o6g+~b`lXaadv*wA|RK@WyKs`i}PTg+2@sNh-7HkNH%;i*p74&`RH zBXnT5xOS08^W1%<_NcyRRG+M~UD_9!_}*#XufW$G`{fm_QTi$Uz&nj|DQN4~VatNp zBQffkwf%8A^p#_M8+$RV=?9o*o5BC^l5cVBdYqfS^9G$R)=17+JIW2@%VhSc$@7j{Q!Q_sE(u~h&g62`>22@yL<;Y-eC4|FW_ z0XP>nD8=W0A8^~>p6uA*tyVnoV0iRYXukPvcds|tJd|8ZS2v{gh*}H9&zy@jnPRUC z<%CrH$$HeD+W3IE1vbg{$VZL#uVI`^@J{SYp^MAzZ9UVhUJAaA=Od<;?PtHM0Rfo?>7Vf)6H9PvpY88@H>FZ4%_wz+7{Wrcd)Kq z_)plPeIWpUl!e}mW^=M3VAVPoc4niq+=_qke(PMrDZ7F8*~HnciC!b#D8?!4;MvNt z7htT*XH|5bZ-Xyd#5e=oxr>FZQ%>;{bWHX`480&!R}Gs;4sle&JAc9ZdV$G%8hIl{DkNVkc-C|< z#`)>K%l&3_Kd{*GHMb05@ip>_7&l>1mw(y+MVg(a+umQuPoj5g&I1_Zo!BS(+A2FW_sQz>X2+L| z_G~GIkKsJ{818^=41Q1WF&y0+#{WnTd<DEQw?OyTH%W@1EnAIG1VKGi<&N^P|crT&DC2q~+8l@V)qc5MA>zl#6~n5aWG( z;v5{lmvxU9`;F(H4^?GV(3jK%kEi$VT=vu)xZd470o zn+M-A@75}#`8T7CE63*=0`9rCND}{V?YFxVND61m^uH&KSH7pQdpr^B`hkAa3Hp zjX|^ekwjMcBk(;y%tO$)alQ1n3uF8xlk*(=N+t4&kmeX^Tj_*tg>9*Nx=$vmFTg$) zJX2;syw}_5#@UQgyzj!f3}q`O4s^c9`HV@VXIBMEwtH|7*(YH$6tE)YakeYzzSObF zxs>nJTn$AAbLVdWxl3C!#cQzrA8NXi{&0)Az~!B%dq}@Pw`?3N|oi~8SRgacloE=uc{LI6WK@U^OBB#su&{w z^p?G+roxW+Ug<{1{A9XuFMKwZ14a-1z@!}7zUV@u8TPa*xsFP=sqY0vTNc_nA)QxK zb{7xekNa2gSqeuG4y4Xe^8Gy530p=*!z7$%5qn(fUR4`EKpP=vk7pr%#<1pnuzhe1 zDAOspQ+xcO9PaI8o|t&Nb4pyp8^(Pr#;kZ36_+6-_FI1M3FzooV}B_g zVYO!0?11b_m}pSCG3>o4;=zPr&y4gkE)01DxhINxjk2X5njK&IFCO?e(+@o7z>aTw zs(XN=Ylx%qKa%s}hU`~!9t};NjXRZ=#Dd@UZ0*W-^!N@x&an%*suDb1gSVQrFP*&C z;W>4AFCRGTFmTZwka0u6m(i6*{CB{aw@_r!x)3vQ;wJEBx51V% z8hUH*#L|{RoM+qsp9=WUgFSyMpBdk(R51~!Op>Jn>x1sIV0n>_p3LhsMXHsX+ z`J_yue4M&4Zpspe1wE9uv#xzcd%V|Zf27DP!#Qnnj+s7;8}5!gI#J;Bf;Q4n==fpR z$y;lU0RM=Xn4lB+pG2P;5zj~I<(ALK`Fn3(Z{QrWS}z~PnZHLxEDzEe$p`xcEKca{ z0UjsqTQYf~i~Etc5NX1M^jDL#cR$ZO4AK5%E%&o6i zE^x{~@*ZUm!h(|5botL*?yU}E&!@_Mk8+I{RjQkrXHhu6MT}MfL(`u9yTQqk7LhLHWKjnC~zum&%k?%W-6M< zeBv+mmpGKZTKq3`xrJWwoqF#9d=j^&rIFW=ugro!X;ww+KF{tB(CRq+iDS@XWaGRg z^%p&(;qUWI#-YlEWy@CCjZmnw1c6s14!2=H!rbAzFVLH0@{ekH@fNApD z@IiCnmbfE|wHG!#_}0*d2fJfgbTAtp%I?u@cnR3>=+m|dzJKB0A~pf`ody3b+V%)H z{|;VV!F;-TB3?1`UH)b;*uD)kgM9z(*8mPEuY&du%>Uc|12%t4{IB3x(RRY-sqp{A zt>Lu%zZ(x#^8fiZ|1bNX`2Sx6F1hE@@&8;W;ugv-iZ?hacmw!fYdj=*9P$)W?&wR4 zPKWRRIN((2CnHxU>r8zw4Gk8vvoS86?MnZu4T)4T{iy7`%7hoC1~N8-d)(!>b--ra2CKsK56@oNm3pnk7z*ls?~T) ze)j{s=eUfI@I0~P(R6-tku5WlpL_yy8MAd=lou3FOk7PmMm<-9C!={2cv$91J=YHC zxo))eT(W+t7nlDDpI9>ok5JyyeRadYiO~;%2Eb22@ziR+F;CG=NjGd=Fu&OYdZWE3 z-4H&g*tb$|CEF)Y9Q|nAzuh}_`u64Hrju^mC1t2&KGViSx~***WEQre&Z8;3B>gAy z2KJx$lZ1!C@RQmx*l*}Hw&0)tD*aK2@J>1X4Q-aPycN~4j)yX^voy@7&b{eA| z$Jb zjpey6YZGyXjN>5gwE;d1{J`+*IBTPgvm_njJvegT@m#g#1#kOv-L4_;$)UX5m!IW3 ztu5e}mB7#MbzU~ToIEf0U|!PAN9}HRE~sl=*-yFRUnQ4Yrsf&*ru3_d{}p@B_IG zABXOM>nrml%+self^r45M)Pw``LQCz<1?BXW<2S9%X49)fzM?5?cUL`jZM|DLZhI! zyV0!P3EW0nsl$(BF9(l8dwEr3`ZF`N|LLwH`^31_idRav?%d-Y?d~^+hX7BN+uZVl z(Y5~CEPmEAWSitrWuQo&D+6^-PTpITFHT3Ux72(LfY&?z-9496ZJ&G4c_#Yngy6f# zdn}?j%Sc{A^Tq7T@6ab3G@Cq+;(;VjGypl&QYbx%#n|qLdW%W@N1MiXFct4&T93vd3e{Tpyj^TL))UzBS40N{ao@rif@#* zzZWWca1KD(&NHEpc&o5V@Ro|lkbF|IJ~dbcxfH(1hYDxKc?U=~=souq%W_S(EHt;= z3f?;19UyA&srAtJG`XAk?{Zf%hehD%l=(wf0(} zHF9x2HV_~{s)+8Zo)WgT_3FwBdLjA>ejck4gMj*U`UaNb-bE3|9eAVz@k^Ljggn-BHR8QQev0@KhzllkcV-EM=(a%7#JaLSY0Z6Zhb`}zN9p5=;A%Tm7mme4BPQv_!EvFN|lvk}Qj{9{y z9K6C)eb13Qu+mo^he4Mv~o*R}+5$#R}MfK5DX>mU}|{Jhi=&`wHSNP4^8_Ro5j z@%(A@Im8SQbc^K+T-t^4N?WV+XX4yRIZN7K9as~3DdxGlHaVxs^&RpKL#%%4u$b@C z$V0uJR%N5+cZx0mcej#$D!yF#rzqX>n>cIK<3-=UYqWkB`;PUpkGBASsC~zDJ@l6u zR^ZO!kWpO*IFn@UX*3x6+Bd(?DTMyP!tzFL(IO~PF)jD@$?UesA*A8~-c+Ueo3pNpc z!x>^7dA5u3f_b(p%wO!ePW*~Jh8UULbHN$0^0Tr?YWSA8bFz^e2)A1eqP2b!bz_Te{O7UQZ#_ODp480g@bi>1yB?>RR zU-e#wdeg~2m6y9X`h37#x-!L=xn=(O-9&-nBh!`bnCF(o9Xtb;t)1(Zy&YxK)mJ&k zEpu}}Wr~At8R|(C|9mRvBhs~9d$B7^4TXM@?kb%fVI&onbQ(=u8mUB#YC9IqsD5-I zm6h(;J|^e$l-jVW+&0c8Z({2r6-^bkROlgVVH-)ZrIrNZPhk(!E=D<_8}AhkJOJ58 z;Xqx6$b>FL!A9!7xb9>>>-!0Je8*5mwLx8h`u}n5|0wN$srH{S=~Vf1wg1>hPX0OC zf6BgUt&;cyffuNAm3FXn>!`*qw|k z!n{|Q4inWL*O?+Qy7Dcbcpn6 z1&YjZp?Lyni|HQF1LFZ&5 zpM1;?n>SQ(4d{P@xf48i5d1QE@MM2)+z*L7t}AsP+}DbibknxI74xj?HPYdT%5w+S zqcgr9+feca^>M$0e@NFiY+8=9;GJi@Ti*46oyM8)Fw-q|8fU|UOh0X>aYo!?`Z+rd zexh?E(i*Q2W?JJFf=p|?f`zosD|C*)dyQ8JGi}FCSn?O#V}kupA4$cJt2t-vs^=i5 znXt<#K9&A9u$#Ud1n&;r#=#!&8goG>Yj7t)FYNA1%{K(i^yv{M?)+`Q{Y4G)>BGc#4I|9zufVT_Y39#6!z{lWX~v(Au7q6x=XHIk zmobX0H-i<_tHjaXO7FPR=sw7xxHqjBeWULs$HTk`?i&bSA>)KUFs~|}kNBg!(=7yF zq1EWWF-6|vChUAR9}d4varala&i?MkQ~PdvVtOm=e&VcL9(1yYv~%X<;SHQG4|~De zj6)x>XC>b%WspONp{M)xsn}U*IK~rVjd4G9r5TIDfktNK=InzP$2=ou zZT1ZJY|j2mCjJNT-`H$qn470zT?!vF?O1bCk1&)tPuIgY!qN*DgWS3FPr&atWeAHv=}B|rKPxpW6H?B6rpdC&dvx&1*b$$STofu2Qs zTp8&O#Ag@#>N4yrr2_!opp3`$>$~UV8CK`refVy%y&v%%^OfAEcpaW!AdTK{m*bwG z?B;vH-dFqutVQtaw5R$4xK*$e{bps{L=1e#Ck<(yv!Z^;LX6ZN(C!0hCjffRc#YZF z*z+g@T~Tus^uG)`Bl<|@wBmY6@x9I=a;u+ryduVm{owsgdU#xce zm_XNnado|$<)>ey2|voc_WSHFx%0-c_t!^j%Gg2sw+HmEb691Zc&ig}zIS;l<9UDl z+AGtGai2N*o1F)}SDvwZ3H0~WA4YR5+>;AG?*i}&*oz_`aLarT-`jI2=DVM{vw+J7 zo42u5n44L^@9@d*9EH17JyzW!=;f@t0{8bI?rxr${gQ7^+1jz76ZARd9E~@}t_^~Z zP%$HnDYif8M4T%IZKN#Ce$67Uf&a8&tGQ%+r-A2k;^2M03Vj}C9NdI+0w!cv(70x0 zb8z4%1^?ILtlq3=!W$Is7xXX%2dcVM8A*qTUnOo9G#5U$JV)FO8C~rK@~Vm#_-|pG zpk9nNboxx>x9tbr<$U}R`ef4LkhiEb@@3OcdTg1-{2>0XfvKkDaEv;8B4}DYWRee}-X$MUy;pre^|x+;L4V(n zdq?umquZ3ueFx6!us-IiJOg?pmB%{Bv(e7TGEDmbYiPe>VaiztC0pqF&{TO#+C1ca zh>AwPN}Gq>2iCuEgdudFOMzn}IJ3ri+TJuaM*61aNzq)Uw(!_aHdk4?^_t812YN%~tVUZ)&-FEQuPN$R#+ zrLPwHX8Rp|2aW=-avX>1j8?TSieI9A;5(Shw*+0|nPM+uT6slz>N7*PfUZF7 zZh5TyTeLl=>8sN(FKKD=7(}1!e7#Sp{ZVl?()EjDU>^khC>aQS41XDLx-$@8hJKNs zqD_i^lM1%@T`DgUo|SBC<=saLo@i@5jF|WR*;=~_X2lZ)o_GLdSa;&jX1uGnQk znnd|WsDFKrIswiHbpg~3g!zkk?ZmHc2eNR_58`y^E7%tLY)v=KZ-lPeUJLzOUAEVC z1xmK>N+a7tIV)xRv!ral&R!FBCWi90i_fJzpyd5jzuD)7?UB5<%vKGh-OaY#Nz6 z!!xo5y6%n8Y21{Xvvysj(OhEYytL+Go}ISp{^)NRUz2H^e*p6ATysQeotaY#XJa9U z=9)&ik|`tN48YjlL(q*!P#1Mj>fY2@fO*22Dq92|Q7=!uO~lp>>gRkq>~mJiZlnAv zLeSe-w@`26o=0j}ChP23PCAj@yXz}%od=LNr`Yw^=)PI%ZLloyYocQPa z%yvh91)di8IvcU+9>{{6O8HXxgD1<6sc@$BN*p6~bDdvGl-IqJC};%!NwrHbkMIi&7tyvK zChI-fH{D-X;8a^LBxP2dz|aqv!|e73*@-l26`6 z9vE~-v;$n|!@YI7ZZ3Mll~F}|NGn{r7jhEUs1s}Ue{1x?tJb7wawXY-&aN{_97&Itde+Tnp|9kb9_&Ice zt5f*-Va3{VKM0OJlr$2v^D!t@CM?ZDcZi4;9JC-s0)CO^V>Y=!k6G% zZ*kU_<-_QQ^$_(+Xoor@z>4we&q%Q)fNsrE*RcGg(&AVu0) zIyd$iCG@EzqsN$dGe@{o-E);ZD;F)liX#mXkq!X5s1QjSA>qeJzT!e{oB^a@Rb{WLeF9 zxCzKFu)j%_;}SUQ{to=;PmDqH`#q&G{EcPN9b*zguH6zlechSj-xS}* z7~6{9-tYm{d(V5QSJ~0IZa&#x{P$oJnOK|&*&@5t68?#xX{a-L zl@X`Sl6r8@9m}`XWEkg@woKu?5>}hwGlRbGwa?^4{|tMIu<1x0XV2v8S{-}N1C?>c zKM(NCv9jl&yhVEsbgj}Sd0g)-$iRAgr1dKH#~j0|n+3at)Ao&W-Y7#PCV1h04Y&gS zh}J+hzsqPnauxCxqYQKz(4B7Hb2swVB5wimkWMhY)7x%%jm`D-`2UW#J%Il$%+Jec zPh4o-k*GVfBHDy_jd`AUmmh0z4Zm%;s0HO)a@IAZ~w0M`~{68qv~vjm(_=hl@sD^CAF>cxt1Uo_!I&7l`* z#!-pbdnP^)wmh4!pu8>M$fo5A2MPTuV2<^uJcXB>xNhh-eRNnR+VW{(Z$AKAR4?S^ zneatOwYeOxxe{<5h`;j<=ySmIN#BNXcbdl5Nq{Nkk3oGJeQ)&r)~V~;_zn0* z!awbQJY!M{JKkK}#axOug#B+3?SEG9D!@OBWVwvDhI;g}^oOV3pZhp^g`C^2 zBB{U31aI4m`L264SW%C$z70PPk^a3*)31Z^NQOfnd>?G$BY~IJO&j^>I>bh7f$v!d zXx?z}pzF>zu4MY{54DW1Gl%EA1RnDT;PY~^&*(q0ahg&64BGNfGs+UfjAdPA_zrdc z(OXdZ?}+P@fR1g^M~&)_qWrf|jz02oJ*A#TmuDE;hJ2aSo%gj#5XT5zg0rTO3&Jix zAEbUz+1mh5iZ;>TEM0y&-=SK>2;z5x`PM3aaG}EGSh=5k7)+gf~u%EoU zo3Uue!)_$?nsQv!rP=;Bpp%8TFS~2Cf&IX5@Xn_DbFt5SPs(-gfbCcLcGu#+T6Za* zyXzqL{NU^EtPfzGx)RsF684UNa@S@T{ALNq>Kr-a8*Vuco+l-5EOfeh9(ky*AuoH= ztcoR=qwFVVRjgifvMhU<*kiDn`EUPub!zdKyWMba{pOAL&fL7N(P-X`=NI_C7I0OFZ@Ql_s?WoI_zS)n=?Q#)73?rY_ZVjs za-#WB&{v`NHfR?SAIC*3h>@c(V3p)&d=fMtROf0tTGx!zunc|Uo$WNGO_AUgy z+-#0~>C3qz*P_48zl43J#XO_#&(N3DnP=oI_neWl8FraU>S{o*I9?rOA^+6H~-Oz;5`4@`7u9NU$6DEVv_>!h!v@}GVdb*_dz4E)l3 zF?UCT6|k?Bf&bo;+7{4uqvpFPWR2X+Kpc5O&s>jtAr=GvZpwaf!`jU`kJdwHy#x4`I_eyJ zTVv~}`7Qjtw&dVjQn(xK*7i6S@w_52RC$u7k7-I8)bk zFrL$EkQ=Crrrqo;v<+Xgm%o)rltD<`;(GySX+e)?zF<^bi1&Ea2U7Q7{*40{xL#`_DC86td?_`BLn|c*Honp_{;- zP-CHfUh?_uANhQ#J5BxG9c!{bma0eh$5MHmBeyLX%Npkp4@R-J;H_|9tW_F>tal;S z0|A@1EX}(jz7)T{j|JKlKSW(e58{B)<^i~=&IWvyYyv-YhUAAJD{egxbG6#E)~LLB zfZsa6SuTD7+gqn#?v@I8vw8_LO9ebyb%865YL=V#CA4k7Ck)Othdc0i2I{_v@+$l> zc3feX2mIcI^2ie~+hW81edycwp2>N%#fE*h8$K4S@YNa9t^)qzx+-~|aCJX)G^xII zVa=~joX_E2rhW+i2T|xo=u?-dpU|4v2O3%P(~3wy`ZsZ|sUu+8BluSE(>5e_d?lkb7X=2@(VWawnDx>))h?h&f|3EVJ4x{ij z!crmE=baPPzDzqFSBbFA-YLiCULr3)_+;7aP&b68HxxAgPRs7vrrHk_>hyi0xg z=%n~Dt(v}^JQHciMx|r1Uv09knjcr8^YZFV7BpQzVq5>KVn83Ns* z{vEQXj1%z*sei9Uyj-PcQ9c7clw-_{+O+}P*)DZh^d(Y$i`+xk{54TPnyq}H{}E_5 z&s~iG|BSt}eir=EiAR)d5eAKQ?;M~`O8SSBZqgV2&`!i7pPU@CK=I()ur?OHH;SQK z2M*l}9gULNC0*i~obgV~f~&<{1HyOF;XA7l6PhsA-Gmq;cE5OLXg~I;n)h4bOAMM1 zT}XcE-a8p9MD~&Ai8<#=4>B1vq8;bTZ!Q=Nr;D z)RUUlb#F5vrw4JaBKXmFx5&LrxRG$7!`C$*dDn)of>Mu&MI+&h^()w_0&Fcr{|2SI z1MvmKpX4KKJef+vxLsJ}clZ_HaYeexcBGcoOXoB{4r z_77>k-=F6DeTiw`$MEnOkB1V2MCx88ji&B(D$Yxq)YD_{ zQWjCN8R47rAD-ayW8GLo*qL4)ZsxvJ2OTD4(X}Obrb5Rz?_y)yI_UK_VNZsk2Ym>> z8ZDD>re%_*55<2Ubsnno znUf9<5PO?x@Sfajg8xEV!MpCCzZ(5id`(XpUP;N6$|sz>Qe>p!m84#%Xrxhgo5L#= z^e!2ZzRpd^j<27=Za)=kuKK9> z0Nr*vop24_U428J&N}eGs;m!|2nRA^L=_)_g+wEr`ID)&2N{f;6bF$M}Dj8d=7yI@t&$xxMM1W`Lo`%?flp;jmT3n znT6Q+zC9<)D4X?1%g9p?q?5q>06)kx2AnJISI8FyY=05zWnbibOW>?p=u2|qWe;oV;>|wDKd(FozxceQL?S9zHLEgCED8QMO#^RThjhBl(ydF`1EmofNi~q zw$jZb3v3vDq`C5^*-n%|=(#jKb-r>8Wdnz39M@HAEOfd{J`GEWEeV(JC?6;TDrzAXcx@)!@YxXN` z&3@f?&3w>R4~ApE`##K(rx7>+IG=dHuwV~*@!t8?LgS9Y&c1yb${ekFANpiu0zU$_ zz0J?h@UCAq!-4Jnr`Mq>6$1Ger79x)J#q)+&It3iq9t zq3rpBf%@@2@2{cs=MZ8@^t-?Q4(s&Gf%@}zn4hQ7p8;{=5MjsD0p4SW&3pVuU)UMS zJ`WGpmm$p0`;B`RzYl$Szj4o}QenuxOWolUaX!J}ho~dP`2>eY10Li)@AQ2gb{_CS zMc{+htM#I7MDp6vA<*}Usr@)z+Vwv18!^OE7!a0E1AfB8zCPdLJbfJV^eZ(_r^YY7 z{66$c!H_isIzN=Xwi$hTFL*I~cU6piA}pENmEif!&Dp>5#tQRKkAAJz`olAhiBpj~ zcBi4GzXB~S)8!7ScjMf^PS%f{Da(9O>x+_U9X@&}G-I&-oT9veGdBNFYjw_h?2qw2 z&(CrAm(b6I{z<`%nEzGS2hV_?@?_{YRDKAyo(V`Z9jN54d0J*ozvFR zk44$?;V1MBr1@Q!t-lQej(E1|FziibSHf0fzh@sT`VYWfN}b3GeET;1isiR9Zl&(& zM~G>IK019Vi1|m4HKyHS=lw|aiDN?F=`YH%&uRILaq}N``WYu5{u8vn*}C?vX#X74 ziGEC*XxHuFc+?$!G3LKo>qqpRL^%SZh_)Vc>V)qq@*lF(-_r6!#}nn>w9_y=Ipc}M z6Xo=qWuMn*`O#RSyva`AqviXMf0v!UTgwkYKYW{=zFo_Y98Hujv(vX|`OzbYb7H4& z((--C|AL+VqLv>zoG7oc(+joy$e~2}=j`;gT7LAeiSn!LG>qWRczwvf%uZjf<%bR? z$}hFkK`lS>mqdA`orb@HtVe^tDe$A$;jb8J9fmB(ay*B480U*`y~o%JJCM_t&Oau~ zOYJ(T50)?nUl;fSUHyPjhFDfkUKp^YU}eSq^ed1s8f5)8eE<4>W9y@O{Ra}|qwG59 z*C6W$+#{d*PNqj_`9Z|QumdE@b*3wbLJ%i5Mo_oAU`dp+Z;VD-6Xy3ZZodfo-bAHUWHA+9#tp5 zTj#Dhzl*Gk`G2F{qkMRSJ6D9K2+m6Jj1*yz<$Y^o{+CdG7aq=`giV~$+Zgj_pxjR6 zJ+Ja>&>rD$r?h#p-<{{g%ISk8zC${Qw1PpMo@_bC*m@l0dQ{mKtncEO|9h%#q@#=A z$AcQ{9i==4R{vgS%jw+&q6#nAMKWFjQNSfu66RTzW2xc-_p`Pr0>_#k>;5H zpS5%pFsSIdn8RTe zKhhzj+W`j~Rh^hy>}h|A(wjm=&+)@QO6H*-*iUXuJ+9BavGR9OuhTcQ zMLxrUPo$I1_~M)3J+bnG8ccRJ#mZqH%b$RDGVpj+d)Paj--!8VBE1o7)q>|=wKcOY zi}~R%Z}%7d|9Z?{hO!SK@2_|g+Pm<*G5<%jdM%{&u}ANY`AI9~*g=EtiTM?+WBhX&eYN&q=zHT^CN1GeK*JaS#}wH@BZ5H zIg)hrF#Pf@Ln0S5%;fw zZIM10p-D0S#h8bY!1H2UfJXr*h=UR~r4OzJJbf17MBy>KOM(-m1)MzR;yKV#7mfgX zNqc~Bb&>X-aEG+wb#%UF%SFc4zoKv5s(*wl!ZGR;{lmA>8}0tt{5Ibu^$%&$KeY$h z-WQYG@BD(>K4T_?zhG=d+yQ5;!#By8I`feC-%ejp&u8!*`0VjETo5Oqf91-rg)|8L zlspIi`^a;=ku*>KWolpZJ$VlFH-a(NseGidUtAmlxUg`p-gjfne&7vMP` zk61^$jP=Es|9a$2RrxJw17lbG9(_im7;6>Ym#Q)~XfH#XAEd*80cZWupP)D9|Aey_ zu*cv-?cfcpk%hFvlY;I6mOko~2mV5gDg;4y=l8=g{}H5N_mz2U1AWkO6Z+&YRDI;U zUW)f`1mYD=J>dUti1{a}GU!JHH1ixit-~eWi}g@&gE|4H{$VKJgf({h!gT>{RO`ky zCT)a&cK)kq``370!Sk}}2g*lqMg~3;_V~~aXl1?{8{38N`P_glPQ5cBWX-up6R{wwS>-?O~xAJaahf8mtJTo%Rr52-ZU zzuFzI@GGu1w*FAPZ^8S*m>+&-VtlMGe2E70cptnZ=HH=}51$?L-{qtM9~Zm*C$G^t zJLcDU;~>(ChKl~9KaXqQgGTxzc3QtXcwx0sO`pkHyc?;N4}o6dta-lLYXZmEvdxw$ z#?~90J&nGBKPGQ{z5e}`G5p`t=#`K3Y0@1$ZB%FT?X`JQv|PpxUU% z-7Dk?w7Xaw9D#dT1WZ0)7Ik(Jr@D3OTL99r~LFfl#NIq@%3+;$}*3W!J8_{n^D7lE!t`cI%d z+7017rv@oVWsP#ZP{7%BZPfJ@!??L+acz%cH4LtvY=XE^4#q%3H zvcJH6=zk{q|6}CA$5Ol(??6X_7aCjt4S7GZ%X1z&i(}=vcA96Xhzp1#hrB*mw>JHI z#$nOspYZc1eSQFI2ekBH>w`FiN$V4?i1~kRx2MzQQ|5E}iD|}j;C=X<3uR2RK75WH z(@cDm%IDZI%^W@lzE%#OgY!cQ#(fI50V@`CLfbJni!r`McyKO2t}EX8pcmR^&zsKQ z9nLqleh+ng)-KC64MG?7u$p7Qlh1PJFsSKK9<+?DbL{r{T^Mbww!ag5DSY0MAjD+jhCB{Bcy zP8#(*F?gAU;yluNX<4{6@d!hY!OoHDHR6FcsM;)yrfJaJ#W6ZUs;%s&ES`X6nc zqM(=XYs>$=%Cq^c@c5YDqv7?&&E@wz3V(9=C4<2(1Iw=0z0}`q(ex5$bK(vvjG|74SWgXjdAU}K9)Yd zSin9vLRqB~eyI8IqlMq39d|3=iMzEG_wGEn$Y|c46nD#h4_Uux$*nQ5PN+vOn=bB_ zVY&D;nica?mrY$Rhmw!vCq0W<3_nsQ;us5V8Iy|%IV{pgtG;_(@2$l5q!G-o@eW5=VQC+&bozA zw}Q_;eF85d)+|k*6HT7ov6^A6N3Y3hJ$!}LdU9oU>&Yrl^QN5>w}qc=ns0?d)1&Zt zr>!yS^^|6hWei=bcMi_{ti~D79GvIO!5vIL`tatrEwb-erXRmvHo>!ZIPWmluyPdLVHx$^ zUi&-CTOeW$7`PAG93x;O`P`A$Y~J*Wv73E+V&~_#g`xk*UV?r!;Z6g*lWmR`cM(ZH zU!%Dj?^K)7Jv-!l=1Cqhk?^!8@{D-osf$~2c7LsPux5G)KJt%a&Yl+-alQ|8KdQb= zFydWJJ7#p{;>`IO7!%T}ev9=ZKCrT_6J8VbW@{qLaQ%4kpL^bbk6f3xG08V0tq(88 zrQl7+6~H0=*sjM6n_4?cAU>VEByS~?f-ldx*kgzpbetUA|9PG;=_UEOov6@R- zv0s~chbH$U+ZFq=euuQHX31|>z^=;p46kC`YHb9Z07smOeBwshyr?r2-=j_TfjCd3 z33H%R>B^nRC#tEy=EBtodtXXoZ|H~TR*!T@l661oruBY zL%cq#(zuf6mx74HbO>?f*lrhoYjYXTr{QJJo5U4)ZJT7?{md&g#`Hdca}Ilk8P6=l zFY!iUhVhJn|F40jbnWEY=C!d7o@d%`ukRC{F)wv3mhX5sfy(dls=U!{UZdfDm2dr^ zX?~*z_o)G1W&vIl+(h;nyV=G*)P=awVo#qAJZxU+Tp7fCUJ5t>3;;jNdsO9mN4I0WC~INAbB_2;nCS^JeNgfLsGI94 z%G-5^fr}K3i1qclby~X49c_p@wKjri1M?#3EBi^g+HO;?^Tf^n3D`B!cMrzk1x#cB zCd}qUR$zCcDr5Iy(2FBj`=f~Ob_j7O96W;aD3PWKF>BbW`8}9#KXB`@308c1EzZ+m zU5KNif0)s19Q@{t*cm$BY5?wnUm4*nAbo*@d_^9ABc)ig%&@LZiTWA8A?; z1748vU@?EB)sVNUG1twQ>*kXyXJZYjuoknhCY7xxZvIJxu*7x+|6=$1u-)&`=y!wG zZ}Mzg?S89#)o=Cgbo#BsOTz2fed1+u`C=wk-@nu$IS1Ka?g>@=GXdouwm8EwY^ zH!;9XT)>Ud#xX!QK5fObm&I4$oD^wp7h)9fE+l#19{0Ums|e10nT$USxs~5V&I^e6 z!@lC2M@c_>Fz+hfZX#i{CNS^(1~jEPLL9$zp`b6JrA6&0S6+(#U4njIjQ-9>zpF5> zvsy6@u}?#wMJx7}G>3tYc|R|7^6Rhl%C;GwVHNV&hm~2zSu9(R*pKA*d^HjdOFyRI z@DT}zcAxb=@NQSuAz%{k)%{O;nWzod2OPM5xZnCZ?XoXAWxv&LS%v%Ew&fh_Z3n@d zVLd9k#hSQhGM@o%O6)XuAHUIqx$|NUGccE#SZl0zliBP$lXTTn*9x5p`O3psYvO!) z2c@U9bk3x;*Wi5eSTp;jao{cf6Z~>SA{Bpk~noRKB9=!9S4DjJfjJe8eejIl-9l{t%4=Fbt1D*_PRlEvC*f7l>=b@c@nN&3$TBT$8S;FUSO+=h4t}r1{0@On zJh}2>%+YMjRTbtDa|pN?3J*lu1YXGDffSsQ&h;BXJCP z{Wx?Q)<|QECzCPcc;Bmxjl_78Dftv);)Lnwn3y0BmC~&uY@l!wi4g9oM#-YLOcNr z{KGNI2J!k=5}y3tC&(Lv*G}Ml6L{mUqj$eToU!BM#+C-u`7rKVI0kvRYxh7O`8@7NvOs%Rd#smoz*}^Ba@OV;Icsz6 z*e8gED`KBKh&g%^;}di9%}Y!6Vt)4Hd^+N4KHP$L4UnY@jlACD(9HyF{+)Qb&^xZ~ z@e-r@+4+Ii&Yb+UV>=4_%t=?)4reZ+#}ZpU1KoZ2uXo*_9Wa_-oMklkVlD!R8C`^! z(It&W^ISZ2cFbtrWl(%PQT(Gl(2wq>({pM zb)BhJ7j3X{R~x8bH-+!&0xNs_e!opyS*MM<7FwDq)cHMM=X}o0CzDB=7Vxs>k9mCN zb331N-sgSZ@Ar9MnI|)cHwJU4@q@E=4r6u>lS9nmYgc;N7a40|4ks~(lQ*Bk9Ok&! z3rwoLDf#`CbPT(q(|GD+HL^@e^*4irO&j&U;!KX>h&D-+u;lJRcxpZ(zF_*H< zBwx03x#oCt8T0#gXLCzm5Y4{G--h0>EBEcO+j1+su1Aq^A46xFK^}UMy@naX{6yDV zgZ)JQ{xt6Im0puIys&Wp&{Qi&Gz8B}o~z@3raD4CAa90b*$C^-)pE?Rp8QJWYUsxc ziQ~3U#i=rKSt0QJ#ZS}U2lP2VI&mE*bbY?ucL&%MinXmx;5^@>sNtRl` zH_^SAJ<#6vMAu`XdsBn!`u2oPwRQ}F{H1FX8>VtivV)b$9vS0}b7RQHszPH3@=k`v zFpD}TDK`dSv}amj45D!wzw-4*1HJNW<SGP^j-|;E#MG zI%WGD{8yhmelJ>h7yzVtCp4rE99$64 z)lmUm?Jc)7#NqafjOSy&9!Q%UT@p>wnh{MBjgnoy_gv&5=#SPxxIdTCpJT1F8=;$8XBqmFid|n)w{djEweZ1f;D<}$i&w)R zm$3i7ioMoovro_%^b>xYu>e!qyUaN-mY>6!q4N~FG1-9f_c<>Mou|-^N`LC^H%WgR zf)zToJgmZd4)#Xoo$z=g@FC!6?15@8%s1TJgxffH<@e$D5%!8+hx9d?1N5rKKF9y8 z|4IC8=+E-MwsY0`IrPnI&^tdmYCyeg@xr4k8i3nVM*q{l?C*eIg!3rvqodp5h4gb# z_S~g(b7$psbF1LC0p#lYw4hOWU>#glo=2qGKRgIeHO~bd+(O{I0C+cmuRj>3 z{>}E;>DWBlYlC)4_viZT?iKWJ!|!ug|MuF)zRMbl(6_<*38S-Zm(F%9I5CF3-Dvi9 zqmVme=;5N9kCeg_WKW~RZTC9f1D?E!-f~_DPkP6H=Hk~RYdX4y9N61_4E-(bXg#OO zv2P*k^>XfV3#*Q#YB#}j?yf`Zl;{kYqY*X!> zm7jNw!SZ@^v(wPc(tcQWC`G>-9A30bH#<-VaOBUWpZ(!L{0RDfFz9GzP+!+Y?fE3RNHmoujK zGq%eZ<6`Du5xgX3c*!pwi=}`5%~9$7UmczP+4E!4(jBY_bi3I6L%Lm??|M}rzmT`q z=x2~kjeaH>=nmH8bq8MxbO*s0Li*)QHFyqgWw5nnWb=jBWZ2(i-pLVKB)g*4L8kh> z=?vr1T-iE9Meur$q& z=#btW(hWEr(vcE6q=B+SP&;)f9~au!^S>RRugOE`6(%2p&rHti6*Tt2`ld_tZf=_Elc&Dvo)2|ZA02gT3LBv}%GwZm*#kRWl8*SxU?U*^ z-=^+)Cif?KW4(=S^QxPiKa%xJ$+QN3-RK4^t`utAwvj8mDLSenQlqwP&T0Rx=zm5x zy|fV>wSVZ(9`xU8_uhK9hJF9h6;{uei&=jauf#Rub64WKwhhtT;jFXKtg~W2i()^@ z!a935>+A^YO!hqoC%4XCEwRofVVjU2o%&Re)$REJzcbdD^E=C&r#;rU%o8Db4iImQ|+*!={T!E3O9=Wp&Bw0(E$tgr?PeRuZ?YjF5|AGijO z=X*Jn&eyKf<$+(%!+F1+$t84AZ-)QW@O?1PVjWI_F06=I`{!=uv=8)jUkZGDHUvIC z*ALR=$R=q0Ai}zw0qY~M8*06TpZR_D7fKIDe`NUme;qoM3h39H;{!fIiw63y7wG5! zTGU?JM>Z@MkjugNXLjcOGv5r_GEjbU{-Bto?tcIu zGql3?IZP|0qc7zzt=bkN`>>IHn3E5WL(SUx?fKCvcgG0)f4lG>p@k!~(9yyXTo}QH z5nLFFClwBa_YuR>p^fOOmm7b=5nc7by=g(uJ`ksl7t=oCFQIk#hY+tmLSO9Oad>+8 z5&AMhUqp6e?g@Hf*gd%_Z)A7g0zu4IZP0U6+ z_ETs7<2`2s88Sx&&saGul$XN1cN{x?{ypmpXl#Avz2o=>=HIilsPJAuo4B9%|0lOe zopQ5Gc%APq6PNj*lbq^oTrN z%4S|#o*s!m8yL$qz$e}Koen>i>-RnWOgSlE``9RAZ$=Y?GdMTpaN>))v2%QNT0>ef zMgJ~ahvH)%lfD0}68;FoizVu9e`?-7VsTt7k;(g5P5jW1u|xxN_Z|83ONk}AB%i~N zIP3I5;(AUthDc+{^JIJ&b_eHSJ7T7~A#GyhhKdOy4oqzrd*fsHLm3zqVuF4w8%OMT zJ|SbVGmXK=&*q=VVs|=%&)=&d|1EMdSUYXr?qp+P_TX1EFlO(~utOc&H-xxbGY2k5 zm*Tj{9s9tSV$MJ0th_y{IF3v4Q-wK@Z^+>It;QhMYjHl-Yuz#O#Dx5;eh2+X4jO-$ zkc@SL_Ur#KV!uWv9MRKj&B&*G=sa8n-_Jip9}ll$@|ntU=D+LGY<$zg^b9Zl%;KX9 zo^QG4;U$+{(|Oy^W8Q^}FDRd~7C(_i=X`DbGJJk(F4(Z{Sh?l?(EVnH!nH!~(L&C* z+mRdoDeqIHTqZ&OfqV`fO9PX`$QzmD9iLd^Bsq4%ytz2uJM33n|H_P9fPQ@-w ze|_O4>94(KVLCl$LHeubHKad@%=>rb-`V|_W6}pcKRW%NYe%Is?c}@JK|Y=xk!Sn< zHj>`=9WT8feTi_<=2f4J{$>I>mj>qKNum?8IeDy(DjCkn6C)>&a=FEWoII`MSIh!o}YexY?BQnz z=7mvvgJX#@^U3FP5&Fu79M9u;8OL{Wd>_YY9IxhhF2^f5lCL%MA&%%FGuLrco}gtM z$rF@{UDK~TL8;ia{mK)RYUiA}OSN;J&lBWwE>~{;%J{p|e_efNTH}*!pNf$qh*d*|(O#$cYx2JZ^`SN>=|uCIs*lF^1YFAN3`cU77S#-T z<8zkg7LK9jSQT<2GVzLu)R!7Veq38e#qu9y%SZy*=PmtyP}h*W5HpoaB1!)6IJL== z~=#Qfr`yRV=dUYh;65+l4_Zq-! zBS(KMk$o9lX}U2sAU|*JI_@FoHLZ#cygr}n zHtfYd-L%IW@Q!j(D4(%gpD#0pt*_>`-j3d*>C4m`qt4gzGP}MGBi~hz zj@~-GU$v-|C-NhMa*I4kzKf$PJ^-w*LngnLdSq4(*O*+r809iHb(4?_irTax;RuiWPUD!Q%ue|xrmOiXfu)wze^n;f!!jD1!-T{J?q?i}w| zJ;ggrU6{e`X}%6JU;jjXW7TnW-&B3$L(JR5z$_WStStnyq2~4=b33SpbTGGrYDfoj zYu*`RZe0y&aESRC80XL%$W7N|$If|1a(an1q53v9mvbn0^bqT!DOeZEv62qf1@(!R zZZdT`$D5eZc5uYZJNHxXWsQCC_HE6`ZQ=T#|CQHC`tZm)`MqB!?NREFmG(7~+%Gx7 z<-M#6Y6{L6r94a2uf$eH9m@j?$xE~b+MsKTAAe}wBKXPtP1M7smdGM(R@12oJO3-* ztr5=StQmA8&o*KcEFayrWIyehh_1D&eLNxhL_&DyS1RidjW;?0^vpW33`7bl^|uAb(GUwi2d z@CKZgE1c};-eLbb^G<4tZsV8bdoFK->V@s2UGitOEYNsP_v-u0srA4!yH7`M9Z%iQ zaJI}to^jz*;fbVl*)`vbj7JltG??ytEjPN^Osxu!#?io9&|*!ELB{lV1R}!z>R3hIKJ&6d+SGc6*I>dZ>ete}?l$&c}0~ z++z9nGOBeD$l|IgD_LE&5DahST(t-CHDZhU=Hw6Y3(){aNnags8{}(i%aE=JDyEA6HU~kL#&r#8OS-zrjqskZ-;VRy z=?!FW)mB#BWLJy%5H#G-My`u?j&rnfSx{q}>*8nObr5b#d$W9vWuEN`)p-uTbNt)~ zzh5<$-EjbMRv$0jS?)6S_doTn>}`*2 z@qhKzC7JbJ*B8l?nKiY=RF})z&ob2Fia#Xz*zcQ8uFm)a>=EDEwxs-=vh_FLe@XxT z_juX;J0cy+BISKG@R&s8Q{U2kpZoD!6J7ggH*!HD8%36toRiCqPUo;gFSWlX_?DA%RbSE49xD&K+G?ha zX4-)Mpg%PI(>tn*rgo6A9{3^ljotKr&%#K@Pj^s%o@e#Fz0Q6DeehK;4BFDDBl1^L zN5;^@vG;w6>_%wgcxa=>B0RwE-r0-2F^BFU5$L5#)j)CePaIv-H+b={$g&zMXh2*ZHEOhxDl_(m(q>jvmr?>Shh>`zYJ@M)WnV?-lvJqr)oE_b_gU z`^&VLP!)ju*27Twug z=d;{DzAg0+E8pgc#7fi!aTPQ2aTPXB>(tjt)L*Ug zMs@5CzUlm#rB`VEw3luz6YZ>=;p(98gpZh7=kTO5_{8FIiLPaFbSzvC>mQYO+>C1+ z`J>UV)P1LseXBPsFY^WT^WD%|jY&12@wjU5E zKyGX``{6m?{v^8->tczU4M)4Ozja94UIQ?(x5N)y2VXbkG(C1ZDCYH7y71K zYx$p{jUI2??Ba3Q>t7t=dUwg|DX(YH^>80F2X+76$o}4&RTs1Plqtfe4EW^c!(%># zGY+3_0-qc%xp}qtWZ|i2HGaXrcsxf}95;Szv-Cne@bRWUv3x{*SDQ8H8l1jD_aski zE`)bFmptu<&Ko%w-Ot~LZ!8DSYAf8PaQl_(Mq>jRgS}}iepr!?S3>w)J1WtocO)ax zzR5vuY)`*xfbV%Tdw^Y?j_A^p*dp9B8o&Fm=bs$Iec@ml*@x$#CmH***G zD)k1wN}^@(DryKcSH-?S@Xet=`lqMdTD1j*PRYiI^CYptkG81EONK@5R$)Bk1nVuere{W zKS^{oa7+f{t*eQz_u;$M7kIbcQ06V|!6z(<{Lyr}vz1%i?>)_(Tb?HPn11cF{Suti zAI5FuiG%dZ?A7R-V3C>M5X31hOv}b{12z^Lr(}8Uhk$8b?@ZqtC2t4(R%0;ocd$3n zSbDO#S*gj;;4*Kf<5}8k=EpLoFcv@V`fkV4hOJZmb$hxudMtH}MRTQZ1bB))Q8~MebZ}v3H%}&UJru|LpUE zbIBcATbG5-leG7~(7Dg~!q9n=_T~rYrmw*LOn0vKsW~lMjgwoX2MG5^x<@y*z-}{p zZ0LRIK#Y7uyXSD-ttDLpE^}%^ZKtpuEk`Dq9D2WpXPj+L{c8+tN3I>+bGl3eZ_bVE z5L%=9j%-P8KAJ*()>;r9kUV#E#diFAL>ESN)Iy(i-Ojz&5l7!s#$00$?SM|)mWU+R z9bNIHsiAwaHm5vZ89#|a9hDQUS2WS!Unn2aO|mE1^Fez~bI;~h?g{+Ip3c|2eq>?t5`5Ploym7Xxf-drnwOtKeGx3eHU6ty)qYJ`G^oQ&RqU;B#oxWle_!)tx zdYh-8PfeypH_n}L2KuiL-ngw9d$nI_^{8=p=X7}I{Byip6YP(qTlKi6x%AkFA6;9m)y2b1L?7UI( zw_4q>C5GG@I|HAqQIRdtGukem1--29kJM|w@5YwLeSF!DM^gm{t=&9LWsS3@^L$t| zRdPMYJWUO+>)b-+8Ho|!F^V{k(TsZx<7aQR!UvvF;#>;;nsw}>eC?xGCA!jITD3&J zcPrW3OUF@tF**Qb5y>b$ac}EtbPL;}@wM^siTXwGd#6iqyupoC&!^z+6F!xAaMEb+ zD(M4WWgX7LuRZJ|Ku-E+sp;_Sb@&4&&rD=jzk@k$zI$%u?z^|`WNg&lnrZiB_{1}p zr!!`IUYY0T(5MRkZyW2Kk6e=Xa@d@6F|S^Gz$5&BE#}=VeK7Kcm4UXqSnY;D1}f4w zY`1%0qnm|}=gPbTj~&V3Zvs6hhmiVWbi=Yw1^X#I)1Ji#0UqaK9(&-?4o0`}ZZVub z%C&mo3Vts!cm=@HDo?`MLZBIL# zF#QbSggGyP6Rj3r1}CZtamTo2#J~nj<$q^81b-Nc3yJi*M+~@n3oU)gLB?BN&IlFL2QC z?cm$V8ThmC{Q-1=XAE5ko)KMmJFtBizZ^G@VY*=C0p39dGGnUcS@QE#OyMUPWD-C3 zOa?i~joZjB$RW(Fy}t}OiFF}gSoeImuUZ=!(W_u>IN8U^Bs$mg%S-8l7LJ8>O$4@+ zfbnEtJq5aT7IbSYdLipWR@&EmN`GBHK0(;l!aB=btEKJ!DbTZ8{LIj4P6t=(YI`Qf zD_MJy_|4Mc#%I|7;ve~SI?d7x`Mefilb&@OI$=X6(F5PW`c3|tZ%l$_vTptIL_KtV zW-b>?=VYrY(s5pcznk`$pWv9f5I^Gv@A0Yc@|ISA#5)k3h|kmxuj5d4q`q^a*V)7O z4`cUJJvaG&-H5N7aHJdhSbQzD#e;@o(6EAVmk?W6}Y_!sD|27Ocd)l0prs`3A8WPUBoGa9$X?8e{Q-agNq$Jv|t@BwH?^>XOO3BY0xfYksTK@g; zf7Of3oKom}in(+6p*gI3HqoDXKGt93=54~jd0SdyUERhvQnz^>6Myl^2VG4>qbtIP z#g8?7i#3B@(ACGa*bL-IS*fB2>NA@SqB6@1Wmgp(SR1dVztA1<5##k^0$9Kc9N)D+@DeTGJJRDX3 zO7+dffDF;MXi*GE)6@4Z@s|@L+7sw`PO@*#1}~oP>;h-a zv^ygB21VfmG5EnK_`+yp8th%|krUdB)ncoZyn)~IRr42lxAvThuRL?-*ER#Mte}? zeJ?U$t>hxNhboqvZg@QK3lH!>dqTYz3Eorx9bZ4*yM`9XA0^=B|H7Kf)AOMHU(){9 zp1LI4GDW#hqcd(HX5juv`TmXA682-)Xho)K;(t8;%(@wy%GamAe@S-w-8c77ukt#7 z%)5*68PJ}t488q);^AVac}wN<-2DEAZS&zFy~v7j-S{gHtA8fAuls@7&At^N~>-UxJ4OG+Arj$%Og1yrJ|)?6srpz5U$_`u*N$en zNc{U>0-9{#Z|R!m(nmk)4^vO%<}s#u4A!XT@mOm-^RxfHBr|s7ZB4?p$~E7bZi?U(UuzKTle;n`~CdUiR=dDOk`iN0iQ#3{Y&p> zEqwj)^7R`cWqsYm)yPlaJl<{PUG1;*Zk!mL^LSV5NAI>oPFd5+^ZHNx&2ttGUWb$0 z&_N$)KnLCWYy4Nh`4lqVKE^qdYq$RiF$Rp?)n079dFI@q#xMULH?JR{U+%y9=>8)- z=KpKY>aM>(^xxV+?D`n$TfCQlcWLPViM}fu=lXD>?+Pb&ul>gy!vHo z|GQUY&!qjW-@hVz21mcQ_qo#6_+`lCGqrWz^z2~!^U6NT#I~RJ}TF>_CuhM%@ zT#=QIck4H!x30+Q+oJtWma0y8k1v3KNFRd!=)fx0-W{w3WHJ-)mRdkemf1(y zeQr;*;ahj`ZSf4zFRO2pOl9{`t?Z*NbYrZsV>Gau>eUY#-`l+UbM-9i5jZ>t9A4`A z>}~z&-EADmlu% z(<9v!d`R+}aP!oG?HQTPJ!@pPfM-eX#P{;HF`Y|hTaJtaUOg24Rw;jm+}OmkIqGwd zu@AZTjw&Ca<>mR?`z#W}7*eO}wVIY`tt` z<~rAWa!WOR_w?-16%E+!o-+Q=x_9KyOY0c4_tbYLHeQ*X@P6K>&Fqc-dX!FEi~Wf2 z!1w1`;x8VKdYzdu6W03d|KrON^)ue$jW0)Mh2PGt&5y5Mw+LPQM0l%zgLfc;e!K>K zm&>1{z9i6>>3(%=QlE75`50Z=KyQBQBEB;}LLC!y@p0Pr@XLz-IyYx0`FZ9?YFcW! zJ{?`Ue1>|_A(pi?&wb|R=DFlfQXYYp1mDb{!&CcDBE$O6wJ%wY@6+xvmhU$$27XtR zfFIWk{H_rE3O=~~%Np>T`(Jrj%061kHtOPs>OPrxP<~yN^6NdPa=peZe=fzFxO3@1 z72EUV=MvkJvRTR=0!*aSbAAhL#Nj%-Vv2WrfO{(NbKQh3QaKJ%W6qeJT5SARxB5HU zm$Ye|PG7SoQ+62NavSY>}zd0>;JV7dsJ`C!W1J# z#R<3bUfa$Nbi%HkADm1(=#Ax%wh)-OcD{8o?JNoUgO7`AXCv*%$88VSn6HkP@z4Fs znAa)2udd&SADz2CeyrE|9``(UJ$L;t%e>C(-1FEQ-SzROd7U5Udeb9b#{{GIw!Wp@ z-`snpm(HO7RvvekFU|Q9?7I1)g8vYGdNi={$&VY`=1KW-{F(ak+1J;Psc%3(E>S;L zy}o`#-++EhRX-klef?PV2J}O^L!+l&hL1NsAV0wev5vmEYf1c8&>7~>{bR(?9>QKB zpIP^=Yze)A&#SW~n0VkIhQ~dZf%YobpgV8k{9x$3jyT<4a*i*8ZM%r>g!Q10NF{`WD?0dbc%+4bgp5&TEm zmpmdGY_3~7R)+6&<1g-Q!gddx-$`u3dH7}A5{d8cC9kUV>+>Vy`+yOIC7pupIy!p4W8;8%vukO!7PmyiSr2#^IsxPv^3^HATj+ad6mw zIMx>u+}d{}FtUz1yt~?00iy8^#ZyLSqPBA23GjdL|Cf+}D_SFT75i zFMIf!w%9(Pllu#35W4{;4mu}S+A z_{AQ2`9>|fWt`zMpuHzS)&zx$qk$#gTpmkN$MiA$5r_soTfv}C?7AoJbz z_#^8wXX0OlpTrdTP0@ZeGF%(}LmveW57Ev{{4d;f$!*mU`>lBVU)R-bnzX(;GTG=H zlV7&+E^Aolk_VM*)&F&_^9!`&1-_1wReH$#*&QV&VN~12iVxj|y?K{>jmS&owc&f* zMvMu$sr*K-t9q%IZW7%sADm)to6m@SJ;+P{D7hRO3!_YO?IV9mO^h`-sJSbKKdoBn0V zrL`BRmZG(r3D$MI!+7^^L>?84pJLq$-tK!TawG|7?uk{daWG$fFxUA5@N06!UQ@rC zUd?riUX-2M(7%Sh;pk6)-`y`6G6`MrS~(2tgMkB?n!gA z^ib}&b5nZ|U;LuEv9db$6=Kg3`~bH!j*9=Ztw z+Ms>%)Al2A1KYY&{k4Ld!w3A!vTcug*p>$S8NT*0^4bJ)au{y3Y2fxy-{9}<-aj;) zZlEs?POC$3+EfImwpVj`IIS&$(;mj6b>4Qi&FfVOukfJD@`>vtH?Gc8Mx<(g0{^zd(DGf;3d5(8WiPCo@NCukCSdO0eP@3P zzpKUUPvXo^88~DRt#Xs6S!ER378vg|CJQXdq z#_#O!3D$U;b%cX@Mb8ntzMp2y%NVoP_pZ~9zrH`g`tISKYTnWM7L4|>uNA!P`sQ1~ z`koW1SmR)pd?nYZI_nd-=AKK2*7s)mRcY4uoc@&7H#n~KtvLZ6``h>y-|SP4oj7o* z+f=pQ*ZK(N#p@8}dfJPJ>`B zzhK2F*?c-S?$PbFGu1(!iSt~Zi7(hZ6E|6&Ssb%t+Pi;ndx|$W(YEqFyur65Lp9BK zZ`XX!Z;=hI>8U32`h{YXg6Aa5n|>fuz7iUjleY%<6hR=f+EFPVKZ zGW!(fO)+X!AMmm-AfsQ8jE;P~RJn~b9=|KWyn}Db3z8cl?3*(8Hn+>t++ zjiu)q&c*Z*}$Jk2ZYCX=?o@Bq&U$8FGm37{n$bKRi>z%<^wLh86SVu9|&R{Q6!#Gm| z#$##p!0}l8EsV#m!P4WIeBANqdy?t*<;OEQKb{7zdFMIUK<$K|-2snKUJ>DRbtqT1_7$dYfiA36?(AB= zb9BYE(6VcwX-lDPS3~2L5DRw|GQeo7E90A@YoZ5@#BMBNZp}IE`|;2@u;@|TYRvLx z^)pE=7{!rDcjVeo42O*^p-tK-#G2S|D8GnXpXNUKL9~x^-)!Rie9ql|Lu=UGbFn7! zLzPb^^AUX4!d`GES4sf;iahK)fxUcXwhw@PaNofG_B`yv&kh&%W^DsU@si=@>Joh) zT(9Zm^K}V#_5}RF=~#uQ;ziCcTjwLbZ{gbJCzp5YnE6-Q%bs;Ir+A2uoSd$HKF zmGHjKSVh13E#8-kje6Ew`I&i#pg-3_+dh%(|IV&4kpt6^e|_TM4l8$gw)Od36j_%2 zj%2GG_uGveWNCi)XVGuPD*HFmuK30i?G^p<8`iT9Pqk)sy^4M(r#2ve-x2h?%Jkd+ z(*^bE*wX&G=2>&KK9lrUYgzKM%MF@27oJV5Pm)+-)%j8FtDB4-Ui`CS^8(-@xUyfH zsrMz1Kg_oTuT4gmX5kJ{I|P>-%yBre#C&UMM*l$UGJK27^cQ;OWWBN&Kndz(gnIR7TN1=X7CNp>n9-k;Y-Mh=r^kx&g zMoyBpCHmGZerhXO>2-daZ)M&`Z2YO{DVfLNenV@4n53U9YJ znA;BG-wyPmFYIC7wFbR&Cg#^iljQ0S_H*qqBYR2y-5vaQe)^eRJ8Z7Tk6T`-y$CUI zHYOPz=85z*dBySjy8QAtwy!IrW6anze|ecEpgYCqP1Gqx*D zj|A;k4r(9ylJ;r4gKwDj)t;Gm_Uw+f>D=@)L=#i_`L^`1dSkTSt@l#>+^`^$HT@%= zLpssoakzQ@E9i*!0ktvd&?gd?| zi0i8+Rx46Ld>nfxwYdjctND5`CVSGtZ2X#r>}ux0zp5cSYu}3JtDxQ8%){~zaSi>6 zYDO41tpZM~ES!|*-5>W}VlbeQnzR3}urG1_7L8i@wnW$NafKKVAKPz|cwqDXi;eZk zONn3PnI_gwob?sXo#=fO{eQ4t+&XtSh1~W4di;((!F`QKYpJOPnJ`#O8vBB{H|qn8 z^Iyo%cqjQ6#V?C_rJI3g^ZaG7eh^@ZW##hROS{ z^Vmapx9yv-Ve-Dyy)JUybWOk3n;AccXRwV-zrHX>`)=~GnzxPUdX%H1M#oxmj&L+E z`QZENee&!1hTnS~ALiTsruHQ_u=ht!C10Q2$7#GZjO!ERVZ3g^35@H)!Z?0{93U7) zZ{&T^9Beyn@LPu``bN`J&Gq;y%+hmB|8D^?z&FnAiJmb>&!pbvlYcMT;w@(%9?V}N z$kpZK5Ax7{p+D+X9QqS)j(flQ)au)6z}xV5{*!0i+&Z}L=bG>{@?=BTDucUrKS&>E z3b(6Adl&S6D3rG$STFy^d&P5zZO~pj?b7L=3BlmU`o_~XF01K>SIEyG+cf)9;xE1I z?X#f;PdA#JTC1jd9j<>4_gp`1t%p&z*2A~Sw}7kz%uM`yDt1PZ4AeF+vv-XAKRQ&8 zJhO}a*x0s(*rhIc$Ec(#T=2Ou)`?E;+Nni<-lqeqK1C^|Jik z&`0|9x5#q4qFx_yXiHnCk^4$I8J>&dm$NGx?^`uq{Kj8f?fHFE`R^m2HOKsC%Aj$+ zSGM+P#k*gc*ml{a-nQwZy#t$|@fp6U=Y@;1X!+HGZr=MSq&g@l< zzXY$!^QhkexholxyBfbsZI7dc*w7UbuLAk(IraBp;F|`&rDwYlJ_oNnFddpRpZP0; z#!X+jW?g?QzIi(PziQ@1`@dI&Zvox$LUe~*4F<=*6ThXmwgA61H?x?NFN9>3%+x}jXMCc_`*d1b^@}~1_lf`FXx(}S5 zLnoR|kjtx^oEQ$)+v(%(J0*MCwU*(3543nE@DqH**Tj>=Z_42}^T}%sLm_NAlQH}kxqL3euapUS?-EcDT|U(Wrq1D|^E=drTQr+VdUHIr3v+&B4(97=gIpRFT6bgljp2vBp`wBxI9w6sht12hkpo8! zeuJl*?#GXWcc<`Up;Sl*beP{O{0{MxuHt2WFY!B||E}+!w>0FFyw}I|{rt+*2Yx@} z|9|j%k>5}G?d7+J-)?@r{C4p(`>QYKW;uOD1O6;d&$0;_v=sl6J=#CN^d2mQOkd1< zOXqkKWcN+%>m;x1-0d-+80F2$Ah&Gd zy6~Le1N_LnKc-_h*L5xR@n`31?zhLzn7jSsER(`qU=SH#r*p6312O6y5#{TjQLe_G=$LlKaAjKe4)s40IG4@myG!D&6Uv<~!zU zp1gCcPIbbcqWdV;r3N~ahtQcw?_%0u4-L+e+(S28yA+O+)udw=ySa~*X6Pe&gViI-*2L;Ni=OKUki z??S6PISW2q51p6plDx1FT#wBXnqqXA>gU7kt23W>^I~09+q zyI&VxN6G2z@XgERW?C6x(%Q)C*6Hqg0v{lAoo6$j_kwx1?N`&j*%w@7*OFvvpM617 zrMLApc#2um$PM1gwt3jSsV!*bg&zK=PW86F0B@H*R%1_*j}E?8(fj9it~1-oABx@2 z>1L&0k?tmg%%Q%yHJ-UC(y^Os28ONZjWka|8{Ocko;UaKZ|ddQJ)ApV49OVAcHVBE z**EP9Z08f#_f~gbyl)|TEbQj8pXXY~k|&h$@I3mujtn$A!?#jLa&y$rjPen`)Arl- zcM~@Bna3CpGRN=Tcns`;m6J6DSHV;B;jV$-58MQeEj1tE=X5`;N7h>11O7U^b4S6v zZc;$Mpke!v?Pf$O^LAW{M|O1H=ymKu4%;&Uxifs<*m3VLv|8zbpZ#p`#FK0dThbtc z6C+==q323qQxR{`7}d|cF*_FduKv{30miswD^jN`dh zhBCVU(Tk{AgKit1Ta6y^DfXsE;Eic$NZs8{1MJuZx!A7f<(@ZNvaMtUpJUTg)9dZr zS)D={)`n*CeK!y8*vdO!;@cbG_mAPv{0e(P#o#@KZNNQ)uj@?dnw94O zYr==%LcZOIjx3AZB^#FJA;UZr&!^_a*|at?FEvBX%LL{n@Lwx2FUM-P7ucO_yV6xS zec&d>R*bjB=f$wqzR1C=_*r+|9c5ogG3V|%#|L%a?P=US_fGhG#rNDZ8GNgnuwUe` z7fAkeI`u>#Q)^$M{YWOzdAaMaT%E{Xi;Yq;uIgC#K9Jk0b#U)%((PFt%PY{fN_f~$ zpb@*y^s?RfGWI+L&LXq-!XNegA=ZtNftk0SiT$%b#hibfpSe~<6Gbbouuz|rnxUW*@yUD@1Ese&p5C1QFl&1k`?{4^~_bFYnk!= zv#;g+{q7p?Wk!2!*}aPQ@q4eku0G?lc9uKmxfDKYYuq{aGt_{}%l^7gEaWP8U-BM% zhYEMD_OzF9ax2fX_B%fjx^MOl?!MlKmTK*ou}jVsZ4Kl{!7l?1&HJqx9#GnE?NR*5 zt-MphZ;f_}{ni98efRDB!h4WEc6|Z1sd%VwoY!&gXsCmsnN!A{WZdI|cipu*V0$*# z1RrqPjM3a~LUM;IqSn zVVKXlwRWOw^B`;UpP;kKk?3?r2U$C_*rz|tTHL@|Y-24ZORPn=p857xtqvL6%`II9ZOHBLo;`Ra@%byF>7(t$0y9_o zj=v56w3s(5Lk&dvuP2F9_n~*}*^EAX_1oSTu1!Ww2V$wmdRa%;96j7Ktzh>~j!785 z1NV&U^U)Ox&;=+a1^)%bQSLZauI?By=F!cEgSasD)uW$xJaKup5*uO0e9zS;usYEc z`%km)3uL<#_AB|>*O6yHH73}H7xsQRFRl7MdPjS|6t=B!J?&EQG%l7#^!<)K(>s#n z(VnEedmsl{KevgSS8+}KWp9oz%}2WCW9yy9yg2`FD;wDQB6=?TUG1G69WOj*>3aA% zhhK$ff;UdYKq=LhY{=bEG@m z=tgfUcz0rVweWs3;5<-2M86DfgkdZ{qAFngLR2_reF+_mscB_kjJ`gAvF+o@z(soO zTzic85Fb5N9DP+8@F@pArvRT*flrKeWAo@Y26+;~aUA~41?V=%w=6%)=83g_2T|*H z@Nuup|1h|Q|A2IDUtn(1*C(=0c0PiAZSh!geDl7CY;^ra*j4f6Tox_ZFNY;N8PQ>{>BCH9OTola-^=+4aP^w!lRM)(lahgFQQEo%f>ermnXW) zBgz$B*3ygI;a{NogV<`(VYus}C*`B{%=nfF|MjkiOql%G0k_hW5qa+|h+S_yail0sng7Gw2uo!^!#c1OADwQESAE1^jgXRcF<;t!ud) z^{2*r*#^G94?eR98?Ey_Sk8Dd%-j4(#P}Z6`S>2(i|@gC*7sn4;CrxnkncgHMKN9S zA9y(|YSr!s4| zP*XLigE^<4>$!I7Z0+*uCDUZaqmxCSjW!gY6%#LDo{@f1&$^nHs*mImKjN1okMO^@ zyzSy7`pGaZ$v0>Z@Kr4cH?QF2oZX>o$Qj1hsjx5WR_wE>z1zbvjC<*+m!-q_yb1pS z>117>RC_b2JzX%@s==*sGp|Ocz8idZ-_u+h-Ni*VesDZ{N?j9=`8M%`szZ`HuTbmc z=!(l(zwc)qU&eY~%(`BL{<$&DIyZDiw9dc_`9yt!mSYzWWH|bj;=1x4pXsgvTc5Zi z!Bu=d|Gs2B=0JVXc#LcqjHlQ3wNrDg=Ywd=be-AcbI7H*6bU83SE6MSi_BD9UrxO z*T!>?&qwtRe5ZrhsUkjFsKwsD>=OFF5cpFYGG=SIiO#3sqv#fv+yhUY!kn*&3GXJ; zzbScM%D&god3;F%IxoG)B>F#*JZ;*CR?+{;&HoXMVL5Gu`JdB={2y>@ByNLs4-FWY zBd?JAw^W_2TKGjFpXR{)La%+SkYC8GhiaRbdT=gVn`?P+F55T0Ub^I)V%f&kv{N5T z@$U`Ms+JmZ;usq!{-*2?XZrtO<>FVMN4@-9zACLvXK&!WzFzoe<~(e8YtHW4jhrdE z8AV@aXcOlfk?RN1D%Ol@p_1dn$o!%)4}UuGptJpL#D7Ka`)9!);I$QV7j$hH<6W?k zxp>IbqqF|U^l66kSMNs86t=lJdCKuz^}F~!->`Hk=;t81#JJUu0rY4@ejFrMOMWaJ zmtNS%%tmg!hM)B{E5s+uA5Acp4R|8<+YEH=1L)=)E_6Fw00*ig6)jqi1Lt&Lo<_~7 zwI|;(cQyVh$Za=EmzRv4FfNn;v{PxfjrwD8!qjr#*xBMY2FQ)hzL ziXTv%K%2u?YC^{+THp0oMBBjcvgS|BeRpKTJe#@E5nEQ>$%O9%pX1V!y zZD{_R*i$%rhw-tyNiu?!0UU47#Guby*SLyfW*r{7{RaC(^S*hOcvqvZLMN;9Ww8k@ zhsmGd-pS*9C_cu1yHL*~|BUg$|HRyQr25Q#V-}UAPxa<#{mK5{c&hU=)q8eN-%Wj} z;_nonOGW}mOk7UkyH%Sn)f#8rhT%P2Sh;WH;Ss>|Sg^~FaftrtUH1&WPBWLqCbsMY zj*bqM0h8&Y7nemwwmI zr~BUVY8M+h3A|&^Wa6yjeAistUZ|Vm&JAwDo5S!mdx9M!`ZK{KtQYGczmwwppMHnS zAN7dM9|aF6e%9@6PexbNBllL35cRshS-ez^n={yJk3;8iCc2OD=s+sa zVUp)&p>o_<{ea6=I4CzkY;wQj<25yDvj=JW?x`lntI3&y-W+=MKn*_4+C#2GCQ3eW zD*p25k>G!I)DO(S_vANrC{{V+)u^}RF8sjc|yltw*{t<69PbukI9Yj(Z0E z`qqCAVngMNlavflYxh=0UdHF)FtMRuy2$z`ZlLX_u7fd{}=Y<1Fq! z@I6-ll|yA6b18jd9X=a};5#Pvmwd@-YIxPXCGp^Dc-AEGN%EpeAMfNZ`D?v!qjvyZ z(^B{BK6HWmhz**KJz8{mr#Y|Ota_f)@$sL2VA|zp?}u}=(9WP7E$Eq* z<1n0~B^A4VkPoc(Xh&CE!`fTQ8oZjdxP&!%75c9~M*mpI$ucmW0J~Jo%X-d-pa19$ zgZxCHc!I!(zq&2(l{fONmFe}okIs5HaRf7+++k(lIfvNejpJHxAPe6?-c_gPbo^4d z(HPijhw^{bGXre32EL{3-NsfMz8}uhLOaFwZt3}p;qT-wBNq+9m+KM@*&g=2lB;IT zv-u#DKLa}Sz(d%UWJ7l`;^<_Srt<#Kg`65qvTbyrJD+Cv4>iyrYhNqW#8jb0)jlM0~IC^En`Wl8+6-(lMJ)30qYcdG2QF znoo`;pLoh@>bNFYr^;Wawhtq_qdz#XNwA`QaL%+5)+1;?k_2W^!HoTyaOmiY#f)JQ zV`*ee?_+H5Wlda)U6`l5>KD{s(RYv$!grHAOl}Q&-;D&v;h28@8>ePGgd| z3F^Mqw^CD5`x4>2Y)h@uQP}(WI*zTXk=edup8Vse^O;>9m0$I!wDMS)n&J3*%f8aX zF(Nyc`boY5*H7^djj>@F_(oqeX2(xlALU!%^kbR%L9V;6xm`wwGXJ692M#cXG>&^79?Ma?<{K?1Wmw~5mCnmpF zHupO4o<2oRv2rcz)7T8c@9_NQeemNl-o>A@FG4*0KJc<^oIPKO-c0&~fSg)f#CcN3`ILh)lvfHeV<0jj;RKS}y=XD?t54i8vm(hFhPTr=)|GfMh z*zg9|OSSbVmERCM-T{v}TrU0)sz>SWH87WgqwX;`O9i*X>>UT&9;@>AQ|%ufBu7X1 zM#1(tP>(PAr*@4THKg6~H&;V57mHCFU@UTtk9-qH&OuIFQJy}EY$JPu%NJKy16@H^ zUMwp)IwARO`#ophmLNuD`xx)m$P{ch>|;fn!tWSc z?ECJIl<)5)zlrv7t@sS3_#dYh{ftfJ>zk)uLf-Y8`I}Xc3HYv7j zhj?uvCL+aq#c&k7hm+UMo8!%d9(U}fP2n9s^;6K*w=C%mr2zaRYzb8X@NNkb8!{YfdF)P3_JU_1|?_SMYhBrT{Nrm}=;liui zmfX)god>@HpIf@&mj*uI{CV&|;dl+}s3mgB8vNzVf8pfn!#UzwLhr%*&3ot`j`iNo zeYvfYi`GQ^HEzA6U&?jH$z?Cz8os{o#a!p2Om1r(eM~;(*9%s{J>(~w?>IQu7{a!R z4>BG%C;9w`p*cZrHFKi;X(`5eygYi^6HC6e@==LAdcoQ=dzRpTUcTLcT&_Ja{#oj~ z(%P}yDPv4txeh-uwKErysePFHI4%x7DnoG z8zS|e2mTHwUkvS=oe!#HMz?nsOtg2lFtK}QXM;2QxRNljwxY~1VPa@l5lmhW4QnH3 z_r|X|C2GBSQPmfYHwGK&z|-T#HR?ZxoPnA_9y4{p5At`Vp%er=W>y>@kd-X z(7sw~-nT-l0^vBsuY5jQr?lg<@ef{%~&vwSBo;JSf9fYZ5)fWhhL#3ulQ zX~2NX*c5-GxQ`m2Ti0s0Nw5vtbu)q68*Y~G2LA%3Jh6OvV3oX9KJ?J#*F zj_>JQx|7krOu~Ou@ud^+AFay! zkIDw|#>J8x+XoiiNLFjw#gq`=v;ajPUS>wqX*H0 z4A{RK_*hv#+{eZtVqg9Ta>w!UX=p#{M1V(kXJP?}c^mPM5l;xOixXLEuLu6tKjzr6R8ALCQc4TMKyURIm*s*MzWT*H} zG8YB%<{Z9b@6T5Jh@Q{AM>6*h z=JifN-h3zRbDqm#dy#AkUpIU?kgZltb$Suow_f6e8i0lAo9r<`-?Zma|IGDfuG7yw z!99&jGPc>@J%&8Zy}bsG;|ZOz@mppbt?Z{{_n{9-j`~h7JXZJYe@l0khQCi+7IuYr zu{yp*zv^Y1h(OPspRIK9>!(((Z<39=mK==g2YuWFpVT)L3)f3u#W$n8r)v+DdtDj& zC3}S6*n~|;`|sX!1KEnc_Q>87!0UPFNB$nqXMVxG0PeSN?|5-Vl3|T}#JjS6y)$$! z*qj$ScQT!Oz7ZL3TKGP-TIADc?zaZ9MWKGDkjcio`-}s5(~RR(ca1)z0vXSJqmJ`3 zcb_&5uDCXN-kb;H4a;;RK5v8LX>Hu-NIdQCX;xl!dK&|m$@bVW2n6MoVP4TXZsNE91Q9hl8@2UF*JE1bsycZ?$2beCVs3sebRj@2dwI_ z#N$7qUSFlHV;HJwT6KokHL;tz#iw|ApC!+4ySVxT-k|!WchL5u$Ej_&I%;bhrh?jr zn}NeJ;Go)u+lNux@DBPe*wOExc4<{m+pua-ZNmwXsx=Od2M^^spN7WkS~GB{1GeGX zhHK~-8(^-_v9(Ll^~%vv4Nks-Trv=Ci8OSTaDN3erY~As4~=K5dFem9NrS? zTSd$*{$=?(7ja~Ef92|Rhp;XCKOyydSJ)Y)Q`?KZbdeDAl z1Gyp-+;4{N$Ki#_0f{frbF!!5@7U2qJRbhZ)aHoyMX}qgj#jPpBUNjan_D%0XT-g1 z4S7MUk5Z3UbeJ~d+@DTe$2j>3yyj2z>zncs>7{SYv{j7{jHA7`!x!$r2d)&ozMW@X zA0yO4(EAzuoLn0b_^NW*sr?bX#p}}%Iv!ZiISyYxX!I7xlvziiYmT97j-qR}HS0BJ zHGy7mR$ebSk^QHwG2vn@Q{d$rr&AtW?;E@slsjiKd+15*&Ff=Mmpm!254=9m2QJI& z1MMEY05^Lc)*od8`nf+(Kff@f?)L@OkJGUf+O#^CaGS4ZzP`_zIo^8tL*HYJ?AeFd zvmbMv|6%4I`%UVHf0y#Gq~27YNt^e?`9&6dCJT8_+`WR&WMNO&U(#o?;8XcuC11-( zKDrY6vxUlI6UB}m!;h3aeX&S~-~ExUCSn}-Ab+4IxXSN-OWw!f=!!ya9{ibPU#M{L zWsQFmGku9k6@Qjy_(0VSMxVPy_#EsI5VT;v;JrHS#%ZD zt7$^^twh#vz7{s7MEt+tCoNe$PJeU^;t=w22Z}S3t%jqqp-853azTyqU$qaVUmcjE zqc_M|_!H!Re2|Qd$N4wEvGUjP^A@UxC<497m2GXY6Y{dx#6b3vFRRTBY2~70$w@=* zU4y-CSf(1v{{7rAf;GKExmayZN#W~m_7zTl?&7kX zZEdf?XT@>ZHRWP?+Z+% z{qXmy-(xNRF3C{6H(5QKv(xJQ_`0+a*(g`-XM3kK4v3Q({<<95rzrmRO{Lez+$WCE zMdg|vPHyYp)ZS8bafFvSU(es1Z|3XeW$af5?R5^KYke7+NO|}a^C7t=L7Zn5Ib&Xl zRpEC3c_`b5s2m@75ar zJNZF#oZ-F9xn9?!+&A%d$P)U->w*V4Z{@4!;PLWf>|M=%*Y066=viK-wn*=K;)&N6 z;)zu=xc6g;?923_>Bg9;qXG^tRX=mraqnu{TooO7eLmOU6TI_OWZ*sGK@=n3v*b1KfBSxZHjuxAk`P?M+{{xeb<=**(Bv zXrcOP>}^G3?PdIoW2^29_U0JcufO)O?-I`tA+BL?oq&REcQos=mEu9RdFCT5qh)H7-0z{!2f@v%|A-MxY?aB|+pC>RZnpPrPz zpK2eRho}KsREVD*sJ95$mXUw0;>+zLr7Z*@E8nWX78u=6IJ6bG$xzfUA*_8t`*)<9rGjYK{~O{6>tkINr?7 zWnECKMezXMIo5w)xmq+w?tC|MBG~VN|Aphv=wF3?M^|h|_ipjw=!z#(x|VDAo;|vP z__l>!$EF?C+qh=m6m;7?hs_K|Cvb7j`+{)ibngQ z__%xm|H)?feGU9nzD+Kla3?-34@Ik!tV*tP_I&1@=e@1=+jfoJ z{%>A74qOKIE6`_|{#2O$l#)XS*eIyYV0dQir1EwM4=ls3LgKE6v$%-M40PIbVV@XeTxe8nE7PxWw*?W<&Ka=BQ`u%FTm z6#4xQ`n(}p*@vyl)O%695B^^J+qkc_rZ&VI z-E;fQb;ZvpM_i#_JXf&?I^%qKm5WpUznP1Ylbi9Ct%*$g@(oiH-}5HcQa*0_mwnYQ z8|6LgkL&)oOw7M*I(@0D?O9jtldtAo$#omZy%c%ZL+j>ym3<58Tlia&JJhf6Gf`-_ z_(%9T_37Z1-)FyM*T2U8BzZP8#=6%&^?cpwUT51&)<=!~%jV^h%~>;vK;HJ5!`oS# zS}XJKuItxY(_F9QTl@J|mIVDeHR5IUy%v1$wluf&n;cPGQyXhJ zznTB~<{I)py^B61?>?_z{n$s&Dbp9~8O;dwZ9l$J@279~kq>Hv{OI_G+W#iGqJGJH zpQk^+h@H0iN3{73`g0|H`A2@a$Qhef&D-Yl8mlr$37I zN!@*Z(4SLGe`au9JX~`_zPtR~D9@c}_rWWlGV#Z%*A#~H{)4&B{$LG+aUe{?z>kL_ z(5_mK+=m<&aC9<=aNhlQ>p(V6$0O`}me+*o8vp6nlcrClWMi9W%2Um}8CAp%R6#>} zz#V)T_p?V|+K)fluIL04JFvg(g>@hJzg0o(z+FSc4oo0+-~&gVWbN75fy$N|aPT4E zRfrv!7>XU>KHt&(LhQhVAa{g&BO2xK&Ea1d?}W2X zwh_(hg_iBcPnGM)I>(optB{%H)7!(G?F4Snv}bGXZt73s6YFf2$C6)@s}fy*H5vK3 z_FpIam(5-4y?BrD@m>Dw9Jx)s&0l!b>-YeE4_V}$EV6)&H?nr~`q=0WZ0ZNJ?^GML z)Jb+a>EvH8NLNB5>!7j8$;6XxPNW-yzRiFpDbI7M^`tfQFZd1nxlcWxqK>VLSJfD+ zBNO{>1V|U>bx^l1bE#o&q+sez( z7VsD0wEBJrYvWGfpX7e(p4t6(8QL~Dhg#1opMEgCfSQ8|ucME#B<^k9QgiS8Ez?(e z9gF$3jPnlMz_)h6qde-}|9e3Hie&)tzRXy!Gb{@|dIGZ0PGGt*fSc$-TSyKfp4P}g z#5ft>ZsoCkL4MtgZ5Oap9^t2Xx4il0{_5r#{cCTY(XV@6aJ~^d5{@?m8|AP)S-EI; z3IFZm$wj`AW37D3|7^uW)QY7(@$%2Xdp;N9J%5HAcO$Ywk)E-2G1uSA^&&lE>xEo@ z2iJ>qjIC8%Ka=Z4I>ur-#`p{5WwFZ555Jl-wQ7@r9q`D&U`86tmjOx>z{ev>GCy4;vugHjLu9FY4Q@KjM!24dnN3^e=5b%-Ww)DMC$gZX6qQ3XM`Mzs^{N}%;eO(uQ z6fWz(@J&ZcNA0s=I$FFI-2QVGd*4~3*t-CqIC(w=6UnTRn#A{-d~a)%|5N=SMu~ky z9NI+e-u`a#dj1?*r&zKkWWKMJ^{l()C;s}i^!202NS7nq{RQJc1Dd~?b<*c#H`@Hq z*cqGu2HENW$7%v<$e72`zOLVz8$0`FtQ*(%xM+Nh+N#z19-^%S_;snRZ*o)&bGR+n-}}kC zsk)1CVm)MUDQEoTTif3U|3+tUpz(sW>)?5tCEv%9?-g@Vdx7?%b`OzcJv*4Kd?mN^ z{7B^*2cuID3s2gfyMQaXz`=&I3RD=*LHq*IgU;)5h13HPu!hyijc| z=BT!&0dLoqWX~3Ox!SyeZ-|cTJjr|Gk)5$ynLT*&H0gW??mw*UW@w)5cvT&GCf}#_ zY!Usb>F%EAb+^r{>h-Yoc$=R%E!wYVqUhtJZL8*0dy&39=-_LZThWr0=t{Jvg#XH0 zT?dTP^m7d~2K&tcWU!^>@6LC4*&8RfUECV2=<~pB(Zw%b2oJ32|4#L}-hrFwpO1~L5L0CNv}AH_IH*sxQWa8RtudFY6!6Gy6 zc;AW#%iyQwjQi)*_g&7o6O7yNQ^w8s4Nt9(#m%_mv>j*MWwH1(+S_ASTw7k5n0sEO zHwm4hz-HZybPWBy|!Zl&P-2;*3n`sQp|;R3<=ss ztaidoL2NrYQR>h_OWJ9PIMWGG?Vzo{UOqDhY&GPFmU|9D&-;D$<(z$PNkFV<_aEnz z?6uckmuEfeSsAdOZieQ>){pl?`|K2eU{*U3$vUd=F7+3Isw{0!IhNhpFO&@{H z>xhPHYMQ=MR|?`7T%LKyzg8wZhZN z-V=Vd#<}-mGzUEh-<8m2c5wL)c*Y&YoX_(#=srA4kp7)_v~eH5xPHpk898+UHvN^@ zA}=-|Z8=ky&K_tYNbTrYRzS?F!ZWxr}9`7t!(Y}-#fAz2SYHkp*Dm)iu)p@}iw zj}HD2fHfj#Te4oRkMmFCoY(Tyw%M%X*OB9=c=P%j$WieU=Z^3RyZygtpZ)8+4f1`_ z%Gm>RRUp!S5&a{tehQmg7JvI()>GmO$-5tpQ`@Axi~UgVHQNYg|Dt``A#`-!iQ#T= zzJs=WD_0Hps8i_;L?j+j2fD_pjoqb-u)>5B@r>Y0>ZXef z%6lDodP@20|CjDkna9C@-8eNn7oLfEE#KPGF7vHtuWR@T z`#DSHS>)~S!BbT-=6RaB>lkYz`Y&x>4#>C7Ub9S|Nje!3*xdVushbr1-06wqC$YfM0jBzX zp1y;-rf1B1z!yD}Tb%ee_qFKuqt=--)PAw^ofcU!=1XER<{M2v&l#p(Qh3Id(CjYc zj;lwheL?S({s6kcQ^0$tXG&Q1LdgH?_PM{DV(71mSKd3Y5c+;4^UdS$Zv3qTrhBgl zgaoFK0@Hi2x$k2?OahkE(BCxEzQ{fe+{ynPFckWDCH#wB-b)|(n%S4n_iOZuQ#Ryl zQ^OkPNAow#82K&m(BQ|Nm0O$Jb$E4&L9VPjS2=$taYhI~C$>w1FB|_VRR_6}@f3O; zG8+BXGL|Cd)WckC9pnnyE_$>6g<@ow5@1rTO)+$k^Tw#d#h16V7is9yQe+qtPX(4m ze8YUKSS3@!yReB8c*gp&bddLYCm8xaf$3UemB_vPRAe5zUV0tmTtf%hjLfJbj}+6_ zJo;*&4+Dn$wP6@w9(Hbcfk|(!x>8`jWefa|GbTN4ILB^jv23h|ObaFC}yg!)p@M+Up1i#)t?&ebs(Aj%wV|cpN!S|mN zcF-IHb}L>>?epnyW>_s{JT|P>I$-r!608)sZo{fI304P~kLZ#mmYMJcqSGN(*z8_l zAnPi0$<$?-e4ou<*t}$Q1F|>tzdFEQWP$4UBPYF2Z2G_-JW|GmCg-oJ16`sXx-TlU5OBny6($%5sXMHhr2mSmX z?Y__$HD=En%RyTlcPi zfU)i2R|Sl#KDlT8ZNRgW=P>X__tAPg&s(&t)^C0C+4Z-xK3iyS>(*!2OW90McI)L? z6$5qJh}P}}z702W$NSvx?|sOlH!QwUjozzNPODO5THm0(!kqHZ8}$7~=;!O-pBD%{ z$-6f$_iecJ>-U9>dJlK6ALYq~#`rdTw4r+72FAFBF=%6-#(J{%9RAXOtuMIGw?XP{VSK>8HCtu39-@97FOQ& zo$vcg6JLBOcp|vrqs<~?k0#^RNt~FH$GmM~Pm|4G)%aYQ*7)I#jG#hq!&GUCqc;%t-l{JamKYg>fv#!PHC3b5U%ChiQpP$ba! zblIW_luw|%v9YXrwI@`aOL;E!r&B(i@?5F!4OLH3kwqV%>;wEQhCeMJH=gWq;(qt>Mv=b^MCayh!4?KLITD~Z<& zUh;IQ#M=ytZKC|Wg>#s{$#Q-T_m&&~m>A%XJZt5x9)wH|pnTz(6-Fi_=*|Mg!WlNiy%W9hLFT?KI z(a*YgKL@OS{@&5g^1=Ffj(&b#)>D|(Ci?20spVb4sajXicy736sp#*T9xOBAl!^m# zPgFzu1;k3s1Fwx|=7rvP`_7YLyoREGiEgWe!aKw~LgeTi%t-sXK$zRxDJ{w z*jN>EMK60Hc^~LWcLw?w|I_dtuKBi!mvV1e)50C&=BxxAnG-)1@aqG9XJbnsvgO1A z)0UtT8>rpPQ)GiHu_fs6qqD_Mw%MO}r_l_|Yj$;)E#38W*|J@`%5L5DOxc=UYs#8- zHI+5)YAkEm)lgQm>pyt^pS=Gm@BfSU_w)WAdH-eJe~I@!yx+}xaCg^U-na6;h4*WD z4-W788SkIv{c~lve)s2PYrgvx-ap9u2YA1(>}wTSZI1wpN0;%ph5J6>r@+r%a$?H; zV*|Xj;KtGisGj7kR0+7vwUwZ7-w^r|m@twikJp?FBi)A|cE6 zLe{eLaCG|v;N98i&&vnMyT~^}rv;Xqzzxxb2RN(Dd7ARH?3Z+O(Y5JtZ93A~x}L2~ zhkGAl?zcFvm3kjy+cPT5H#7M>vF#k;Ee-of*}weqV&Cy>+oPqs=P=td{Kz8eZ~r1a zFLujcMCxxD8`JOCEdGl~4d-^vUyU_*tD5Vq=PK)YuJ!zJ>$xODyM?q{7;iWD!M<{ zb-s7@OFJq3-blaH*MFJXZ_USVN)PYZH%01akBP&(BtyMI>J>WbP0UblH1$S1>UlEM zJ9T5E{?zDrzpvkzetfS`@0EBx{joKRR{+z#5OZAKcU8|M@&kO^{J(Ot$&dB$cg5## zjBJ~Nz1C;>{B9QGVl%kt=g4zmD?j9OZLqN6N3D{0c|;2dO`r z@=GYc#8G|`^`+cTx!+O##~UJ7Vq;!&;)Y25iQL${SM=Wy*(T)&C_msRf06oQDSwXg z=i=qT8*hkIg10NGZiw7nQPQT5&|4>BYuI3%s}l@gMe*q)ZmN;%)h@3=7t3CK*nTH= zmo*<>5LrPR`6@4V9sT(5tCsT3Cx@K`#6n z<7yyx<|g*=L}l`!;*;`ycHli3hvI%lU}x_Ey)Qaj|7PMl zkw2PWjmsahH-5prW+{A`v%l@HSmXMM>66@G$+IV^mzkc!>vJ~;ZI9%=e?jD!u_qR= zCq~59wPy5!^m}_G^+v|))xVwdki4E6GrgJiqmY@p{3gg0`AVu9Z9FZ~$2cd1sr>9@WuhnRZk0y?3{b+i7sa zi9^S&Jtera5j!~UfQ-E@I4b%Zqy2HR79;n-u5KQ+x52~``%1>VPb58nj16dr>;XkbzPiJ*38XN51okEAKCPD1$rVb zjX0wyzr;~~5qE=L%KelhpWF4*&C9vAzeIN|bj!|T(2Pz>c$;4CzGQumC()A$!>FGQ zZtAKG>vsj~cSU^tg17wI)Nd5dH+jPYliHS!wEq8NMWp_Zp4i-Kj#Q+_oqp=|$LrPq zuP0LTn+n!uQo`B?@2W`T7e8AuIKSw8@8sKPCxvgji$19z+%-O-&-%Zjd@IItEPsyjJ(O=AnOOc^%D+STt`Ujlk5K*)(xFZ%Ga;9r_xRH`s&4$Q#qqmoLRGMfCMj$B7%_A5rV5Hyv79 z#Cczg{kK|)EsD@;?jwYjijSvlYnbdqP%|=M%24ce8EXxDxE@_hjm3AF<4?6$mh$BN zxgYxpv6Ejx8#Rm3$ujmFgYPr-I1=0B7tGUszllC3#Q44mo!bRARrFsKhfO_pyP|^+ zZcdE568yNCUoH5*@P*`}7JGi7Wil=)3!X-Y3Ve+5Gk>SQXC|7gp3Fcyzs;Dw9UoJ$ zo$;{7_Id>$5jf`=cSN#A^8VqbthSxl>PtM(`gZ0(oqz>XIV+swVT>vMr|L@joQ>X( zZ;Z7B7i29(2Q73wrToK`1FMvBU?=w%Ddiue{DW!A3n?#5Q*NCTDeX+9KDxk^a`07f zE~T6`slO;qIXprA=rrYi%E8T)cEDTl?Mx}R@He^KsmGS}Pp40`~|uo^^P&W30Qhl>Ax2nZs|83k1#IBb*xE^O(b?!@whUn_biHi zC3@OEE1t{=VjPNmDft<@9b;y^Z6_`H(k{2hY`;5~G0XbN7(^GGF1~`(cS-Iiq;7H? z&Kggk>nJvFef;EoU%hEp7JkBvueNmS`t}NJi|o6!*R# z(222ze~+&YTO@oSphM8pvCxKmeCFV%@!j!<#a?fme^2{IclkHud&U@cr{f&oa#v=2 z+YAkJev4g1i`18Pgr44k|B5}99(*emx-i>k`AO)KjJcV^&NSaaw%s`{i8AY%T8&@~)r0=HZ{pIxi9XCi&kdcTZOA@0Tjn)+Vu8zF8f{esM`JxP78tmF8oA zT!X*HOHJx<6Lty*iKErW{*@f__p)E@J{z%%y`Qq$64?Wj!v}em{&&;=)1HRK5&ADy zQ}*KHj1LiZC*Fyz9!=XT`|)M+ZA-505#Yrumd)iV+Lk)Cw{(}%#%!_Q>#0y}lMa3H zA^VQG_qQt4=PCcL!~~IX?#HHB##Tn%mER`bMI`VLerWsbes5(=I%De52j;vh0-Y^^ni&ZxtWjY;ZegzG{=03*svxehGDr zhCh(_Ls@>d{_rNoTY{anAOD|?>{Zzp;8kfd4LZpBEyI3RY#is~M=Wr*^Ih4rM((nE z#ReK0b}{1-m(MN3@e6Q@8WSQ&Tcz4;tc_4H%tsmud+kf=@`EsS>7v;QB@MOrS+jQZn z#;H5Seii@G_N|8M-xU47qEJ7&QXMCX|~ zisYM^`~dw8dIry{F%4So>`Tsg@pJ9tJg+QT_k45CH;)7_{n?S=gRdXy8>J#fU-Qqc zFX5xb9z=Ltu~E7^L#__Hj@T&KXU+tC$3>qvEVvRc&xNZgyV!alC+yR~buigf)?+Za zbQW^yapcn3Y2?xqY2;GDQA19;Rbs7Lz61O}bgci0F&UM6L*qWN1|C7|cWiktHTG%T zwnxU2Dx*$_-8G&M8TFV$Ms2XhCUUjhbJ{YhU2c!reixTfhd*YgjOwnTde~h09MX)5&ZX z>fOn^X{>JUwsi8`pGRI>$*<$gvzgahj6a_94pQ>zn0nmc@|rIEpT{FUbsuTU<;nMv&bGEA-`e+<=Dnx%X~uYS)=Tyqvg2OadeV%#`n36+Jm@0uDdJA^ z_@MLnnl%rL4^Fx-eb^YgIY)EsX54V$d(!FSh8n9Yd%OIis{^Zyxcs8aFTPcN(WRv> zEp=(BOG}5B|Jl`Jx_ZoXa$sDq>*_IGJ*LZ-x_qh2mzsWYu8o9-&8G*OPcJr~s?GMn zaP3?IZPEEz_z4Z|i{aj{yZ7s+50GoCB(`Yha<;g9smqtTe5uQqo(t_5zO9m(TWv7= zUGhS=p1^*0P8$2&lSA6?S~;DF$1gryE#wZKN4)&(@>gV^`R?|WsesrJ3`^XYuj+X=B4N9LHthIhMVliZLrX8T=yorgbW=Q>|V z_x&B#dUwXw`)i5oZP|67o1ORM40tek5ImS1v*R8}iwAL-cdYr;fDa$*Vth5_C%Jm2 zC-@>?i+nI2->?dN#L7db@Ayw6|Eb`yaSv?yBilT192d-S+v_d(YvMwD-1fUTE)0L% zE-pB2{^KyU>BYIg^u2%!gWZ=6M)%J)o`7!Ubn(Y>x-=y2d1!qm9}YLpK<3y8&VBuE zvOjw_jdid+;_7`|y^r`z8nL#m*eP<>pBwMu-bcFkk?G_R_dfC<{DJE$8jojW%MTLI z$dnUI+95K6>nm#d^`_ScxcztR~IAlg3x3a7hGJhalt*G z-|OeIHfUU&v%Oc7xWozmbjVA#KV7qXzxKA@uO-Jhle?axEOq#4?j)BGW9x3>|8De5 z2or~S$ynlM9mC%;U(@;CLq=j+^ue6+cJ zqeq3ck3QT!j~Kr58Jn{&i90Ox$XUlj97xeQJL^#=B_8zCxsvZx>nu9G`h_BL!ZaLN zZRA0fIA%56aR!Mk7O>(=>%`++L43t8o=MQZ6mR$8|kZ`zAAIe2Z&p?%|~3+ zR_1-1me=1+zUFzvzm(Xqm-&9t9{N_^hTHkRlQ^n=?&X&I)iz?jZlB56`iLVbWqZg! zzKAyJt?zE*yVfmv8|sPO+DqL3+xY&$m30FWck)5vz`W+o?cBn5TNvk!#9VudA8}#p z0*ot{7^~7>9rE{<+PVR$_W)(mMk~+D`Cs~MA-~~A8AJ2RnFBJ8gWha&EX1cRag42> zn7P+8wspjk-N<;P4{86YmA4U}*5COR#&gI!y7M{OlsvvSF_!=47uCiZ;~7nVpQZjf z#`9e5Z39LMS;8;MzcW>qAnsxx&vNFc+@GQ)V?C`% zS|T~P>xt_wJXNj#SM772oxEW!{6O)_FANmxYTImhj}xQRwh;0}3HEwVToI6*@pnE< z{O`NBeyv@nP8az^dT2ji8y_x!pL{<&MZPvEJe@e@FVfbD5o(+L{xRaS_k6>&{o4cY zDz<+Mi6bt2-DB`$dnE2I{Vb&4dfpXmZE1hPGcf02c)LzdptM>mu3LJB`0wzKlA}2v zzG;(BE!jgH^r{7c(wTL&R~5rcR%_XH1;V$&r{ohee$AVF zV~q@H$7;sPA;-L7$GRtG*Z4@HjguAMCT<&WKJ8zpWUzajGKk&dlrVh05wB0?m}>tT zw=XNI@Jo9DpClzQc^af(5k;=GLcJlS|RIq9AGd=kFi&Z!pv&Xk=*HWoQl=w1As z`J56f^t|6~PRk%WO&dgZnii9t1cs@y)704ejx{%@_>7e!=fv|@rs@<<-|^F7`i+@m zw`HWb{1hL%{Vpy)4S(!T`DsY}T$8o$n0FNTITHLF0e)tY56#;dK?Xksj=q^r2KQQc zx<<7Xfv1vVuP<%&ccN;`~OA&j9B9WL=YU7cNC-Y35H& zAFtT%$Dl{>WBX(LSlq{x{@di9-0JPFkP?eI&R06)B6mYC zhZl=EJ&);Z%eFr-=V|hu0xxHsWSp>do;x;gQtE0Klbu{k`-elrgU3__G@g?24Q*?UO3mty7UCu0Bmpe)= z?BTvJUsH$m2^-swlRH|E)W5LPqlF*mZtj!Zk#6c=W!SCtaz`k4t3kP&&{Vj06nCWD zbJmh0eIoadllZlGCbs&tiLEnp1ChO&+CG&#L>;?K@^wa(Ht)rg+z$pn7zn-CMBF%X zDmRh8GwGXc^R(=60Q){EUzDpN^Z4nssc2LBZQ#DI`%HA3(e8vmq@R1c>ZCeyuXup+ zM%pML|91i38uj@r_k&3=t*HjySBQ;IkWvZc}%xPO@zc1pwYUnO2;JvhIw=2A!^PW%E zWBjH-Nb?1{g3QS`B@pSmRgueroZHwr7BJUle;}ew33Oq17%P{tlK=gy6-u>b@%Kyo z-OqO~TXp1pUv+nBpBk9cx3jynhqX8m>dAY_H42X{&&l-+{)o1EthSnI z%XuC;+o_}-#*=4!L%YB?)~@rLV>c!0ii*h#Yr{_BkvztoUQMBbkB{5!QQrTAao5-I zytBN3+~pcS8GFqiqgN{M*!iCFuktf^+|0bTd3Tno4>kGf8uXz@XAH)NuebQ{^t`GK zQ;Df!!+$8gb4XcrzR0Rs$f|Lj?g02Sm>#7R`80waWv)Xu?R&MXO&$J9*{Lz?Q-PHx zu^JlqIpkAtYriF1W|SqVBWv)^oF`K=$edHt%behPzKZKNWbUc@kN6$!+pGUD$8O7% zad|U7cKcmi|1tcrJNI3>GsV`+y^7A`6?7iI2d91qPQ8rI;{ZC3{b_OP;+SskY~!d% zEGz?0_#4wDSTTj{JdJL=lwrn8@p|^1zQcpg)r%cT7Iq{fup=3X9)1+DT{ZOZqtIiG zM2|HBJysTaEH8R24|*)q&MLjEZt9_$t-MLi_`wi5KN#yyd# zcXig$Ej^b%rsw*)sjsr^Pn>lV^sz>JrasnLC!=hXwmtLCDy~Z~pPlWUS@j9vd>!y! z0Nk$y{_}~G1#S0whNnw;Mr`0beCwr+EZV~UZ58Xb#$2;Z`bXgx63-~n>6p5~0@f%p z=o?j|ITxTHrGu*aBB@c{n<% z!RVX#a>$)$>iHO_WoN6ak@*{V0xffWmHu?G0A0H|r@q~_n~QSaV(RST_I^&j$K|Ch zS`D4b#B;^(Z(LqlWS=-r#pM7ePPu1|X?Ocxk2@>(UYTqfE+l`2di+fbxRcN1uORQ= ztNscyw*Ye=%wIw3h+gsCI@>iI>K;4c z&fbup&W1;E<4g_~XVSGrO}t-lZBboYRHvV*t@C~-?oUMjExG9rU@Q7E`p4hd`Y=~E zd-#0abD%FAM87%$KM3>Q>?FGI0rY|=&a~-7BNEyI2W(%~mt(eh=dS-0S!F2S57B`ZsNv2b{e5P_9iO3dx9mlY|KCo( zj|+<@&IIqbU=!K(?zf3_WdS#j;9zzHE}t*woW!_}-{;3|O;4n?MTo~wAHELK-G}dn zeK@o|v1wy2JWA@_Wjy}F+4_1X-d$Sfx51k_{5^)nle+n;;&%n{JX_9v`sd0gWVW}v zu=qGvxB2dmRqN8xbT*7}dUUq&Z!W~Ve=Z%3$A~iHAY52<^g^|>aCL6U`B~4uZLzC! zON?dcjJM+I+%nmEUJ!oB?+Trp%ip;C%}MSm#BV6Q-M(q}9<=T%g4|Vfzr{FC&bAWn z>n%OM=n$NB-YY)#8Ex0mhsc~0U}5M?&PJ!{`qvNUU!P8AAUPKlK7!b{ZNnF}EB|tJ z=X88e)A`jYkLjx^`$X^UeLgxv3-xSyaB=ekTkawULsxSy|KIqXyZXMTcFe-ZGCEI{ z?w?_VXJ65JEu?D=i~H(TX=Ty6 z=bLlBc_eu0&yEBieEmq@C>1gKntyJ66%c)F`M52j~4+c>k6@E=a_(J}UmNvjg>5smV z#nqF)`}O4R8oF!f=FNTQ^X3jq&YAAYIcF>9;DbLzOaw3XpK+Utn9N6x7Kzd5IrZo03o zqpfwwkU3veA#%z@`jEw5I~o|s`GYo~6VJ%^&#E*^8&TTue{n={cDE|cAM3qG4`^-r z#ql^SYHY(bdV!}+zY6}c;r=p-gXyFFV%nFV#L9s;MGhW39zjo2pzF6&1CgoIe>+v5 z(6BgA-?2e>Kw>d%le{9o-mKbghWC6EyJTXVMu_{me@uKVM?9RyG80eG6O0IKQCVtB(U=Dpcl_*Icj*PH zEB~viROEZnBiQ&F!>eKF5^UL>wI#2nDd%^nftU=Bygx_cDrJ)U)1B!Pf$6V^*QG~S zztEwp?Kbaf#toYsUWWd}jvIE;iW?Rscap>nn?sJIUMt^aH~T>DFKSquiO5Fz`4 zTJq9G>aZ91_fXHL^wyok1KUMDqz;eXDsjGQ`Clg%({7Kx*H2DIUHMx(J^t40F9!w| zeOV2V*XZzL^kvM8wns6)1}k>g=aHXe?02Js`2u^ZnfD#{&K|gjwN4k$tLMah4}~gJ zn?Io1!ptS`<@zlJU!J$6xKXuL@v9rB4lkvzm+%2p#0vYZg_p^GGLq{PT}?uKwax4= z8&3Jt)nOmEvoUY{4WsHkS^)(V;b>6XX9#ei?h@D(GXO zr!8N_WAfG)5)QVjfJ9PGi~*o z`JXdK@@qxbvL5;GQ-_K1w|`uk zrs7@B4ZR~$dxN}(w5=P`yq+3_ot8Pmn^R_ zuDtj9{D#Gw6}!CI+45$?voFq^zbD16!OqO?l~C8_Gl9^Hn@I)1Y~J<_|MZ zk2UsV*4WQEPtRG7-NsFk7vAgiDw7OwEKMFP+x{@qxnt`goHhuyzSum6BtMU-KX%p` zD(0`VZo+;rY!Op!A2Z4jmYyWBJ#){*$CqkH;nXb;RF@N%*31v>(j@d{E=_u&0ezd$ zM(#0|*l|o0I$gWG1{q$?2K$}i`+eSNl83u3GtRM&{-1jpL$4rut!ngYqEirkaU)~- zKKj?4_i3St=p#0I#)mgC)@JTjdbmqL582f-QFZQVA$Tm&Cy zzBk_)<+UxxTBqyH3rWJF&bcqqR>WVyulr0+)b&&hnEl{4ev7mP93eT?s1 zPaiTCq06@Imgv%@OrC8$qmzCo>vZJaNqFa3V*_2YvKSk%^5vk10X_xVjBjWKfgcCa zp?dhgP%peBP*8Bm@5qcQ#(Mk8+XikR z@5*O^B@`FL0XmCHu~dn)8OH7Jr4mS1{*sv@hj%V&nNLGNj%1IFGMI z+L|tR7a7_*%$<_7^%Q^eliIS!`@os#_Q|~SkyECGzOtErJ@XHb+Bh{oR~@drytQ4| ze4T3Y^hmJ=(cQ_HJ*qrxm26bV#6pGxmR?dw^65sJCTi=35y4O zJ?&3!)i=zf>~>&wJG%1EX)40qYGe_(S_kY(xQAjK2JC97KXZ$|p}Pa*ri(GlZ_%ID+_)bup1t+F3NAf!>6y^b@88}#KQ~TT{9ZjCm&Yl44DI9Z;!D1oJV;K*xZmSITA42n z_xD6Rr1{#uWZIHq19q8v&uH&4TQ4QLL)*?eoefxK9l(VaZ)vFWC6nFAxt}c)mFR@s z^W#E{kCy2kFB89UlCwW%myE8p!{Rvxu;CvVtw$p8nYP_=um4Neh%ImI*~$?-6tB^P z9amqqDm7woRjW4J|F|PVxxGi@yoq(6%~)gi*%w*&*`t&1v(KaL-bLJJ)4rTHww~~8 z&kXyHP~;Z5o9MH~easqn{4U!Zw|zGx`ppJI?>QxQ*4gjk`ptM=GFg|HelyLuZTcs4 zZ+Q2WBj8K3;7h&ajx}TC3x66(!I!B<9^koNy>;#wJ#w}6UTNLe6l8ztnm5k@UlMGV zXfI~7lo4OvK3Y^X-o&$yjY-C{X&LfOPm8UW$Y`vYLq?0+MF?E%^_n+cj}*|pGavQ& z$Tw||{Yq=>aa=RUZsSuN*WzQh-^Fol_+xkCTJpVH(dqkM=))ID_JZk$q=gU2eV3*V z>k~G%4`oZen|-nA#CHFQ&|g|A1flS~q(9;a%JVto8U>^OY~WjQ{1kT&aVdzaO8X)(X}3n%8Ie71iJy zVfYl`8?i3t8{rH0@?8mSW(Sw=z;|bd+$GMFJ1Xv4gY@t8mC59%BlB|o7gO^o_q@aY zi$kBQWC)=d;vT+UqR$$qfcy zW#*5QbI!g`w#)7NWcywG3_Q0S4X#ednXB5>0S=`Dl$cDJ^3B?|UADhz$JzLs?g|V9 zcd3E9!TCmhww-3pE}r?xnb6SmA7#zo4Xg})SFNmR`chf&faQNWdSu-HwCNuWKgvz; zZS}M9qns`J0L%B3|0`|Z(<`vs!1pwi!T0p#v-CY}guj~!PuAh|Jspp)zQgyl0p2gc z_Y@y~(9Pww>dA51TD+&cWrWlIR&r(rg3klI=6`r2LH=EO&jv@*vw8do-3;ZrM~y6@l_uYUtV=*`PO#R zR|MK%!o{?OkAG)AC+I<_8`Fajb4J?h|FGTOqe<;K^dZJ~=5t1VKQ<1h4ZQT1mzH*& zzT>AI0>8oFW#}89$=Y`exE)X9LvSkHeW&e<^Ni(-^PwbPoJsiNOmpZTv&9!@O=e#l z+A-nl@Wr8QNM9W5yU>jJp(kcmgub0$9y&-2*u@HyaZ_hs%md1vp%iyeDd%FXAXwTG9- z_V5O4&zZQD=-(pW*?XA(vjZVB&+9~RWm4xW;Ln*=sc{`n-vM9nj3zjn7o9Ku)n4YG z#r#Jw|B=jp6!X_ZXS|*^*;l92_=83)dei|u>YJn@9oWJ4jpy%p{-Sg2n8aUvwmMiF ziAg+-oTop`Po`bdV&ixE$Yl1jmJI_orB>(dfjpMSR2C*9bbbWYk!_4N__I54Ur^t&lN=*)~u2>_ylWl z9c!|HwYfHQ`i}V_*2-A3A?e}#5$8q^v7IZzH?i+SD$+M6i6-Vl6K6VT;uxWcUoM+w z+|ikHH{eDa_IcFHTx2cc<>s?Z@BZ~;(7VT>cYG6mLWN%Q!b5}42f*8xS;yb8M!#nb zUa{#O^i`d2KO}_(Uy)6m$S_F zGcoRGtnnYS#(&PV?;OT&(p5Q>@-V(ZH?JbMPSRUgs)+f=sbET8cy(j&d&w`T&MhTsiGj$U9H5vSx;?hZS zIAql0TKuJx4koVWyOUPBy!L#~mkQ38a?Tf%*G?z*+jsh}Km&dc4fq{2;ALbI*G~Gv zwv*0umy{{KN2zg^J7q+P<6-lcj(7pk(xGKUo8CJ4F8OXK8PWdEE3 z?H4UP>|i)6ceknbuIGNg5#wiW75UB@EC0v%66?O_sCD0y$2~xeA$OVg0IBlW#Psr* z;a4{Ndw}y{YkgtgUBu()rmp9?+n6P;=McEbI!paw*$rjH1NUBHsC$W_@3CB55Ip>| zusim;@!!OTYd^Hd*3+I#oNQi``3Ao#f<_2V&Jsgw77r|u`x^PYq4r4#5*Pog^+KyHd4 zH=ROmdK0AGPVjcXDI}44w3lDss z7yd5`dj)JZxF3$6r-^G*a?T{v}2p3cFW8Q%@To5j9!@Mgw$XQOwXn!$f;>L7aOsWCr9nY-;j7T4Rw{Q=L1 z|Ck+%%{~+2cj4yPZ67hQVQMgR>G84K@8Y)e!ymg%--NCWM!VcQgyF|Iv)AyQ;LV1X z_eKtC7c;0{3)>q*uk{J^T7R8n8}kutV-`7VWAa6>wYDrqBly;q)icWHrfm;*3y%9Y z<2&;?^!O)2Pdss5Xv_B&gr54*wV|!g%nxn8zasRnUnviL8+q#B<0C@hC$d6^zUK|S z@gq;@@H1jp<7qo^zrxl*>}oRD5>h87-+juG@BaEN+SDvclJ9^`Z@%cx)|N#-g-s3Z z_kH3lbZ7HN4$r2>8vikC{Bb&RmiC0_Fn%X3i9RDb>k*t$BRQi+aYpH!Q9jNnKQ@J) zwpX#QdK10FY4k!z(F@tJc_N%qh8^7u%Z@JJvZKQm)3BoxJ3DOX3_Cm4+_1Bo!QX7k zujVhdIvsQPD>gad1)&`;U3(TbIa4^(E#C@D$Iue9$$8ka$+7Q(op-bHo%x*EHqQRe zslSr%%;z01X`%0jJ)u5wV0JL)KJ4H+fI%N~>|k!PCte+oNJ={vDe@@x;gQw6dGXYo&~02(n2&yafXrf6V)Cv8NddrY7uc-aP)D$s7E@fZH@|oyxH-41{bu zr&kU8!pu25p;>vZ?$>EsFShCFb-z)smwi4G+#3ZB>foXeoMex$%0{=tKL1F3pC4nN z+c*~6=QAzbf*u(5va;{RURL(K>~q=ovd?AT%RU$TTG{8|uCdPrM?c0hIQqj|7leL* zo#OaGb;>4A71h;rksoPXQC&e-LVOiNCvW1bv(8ZV{LZ?G_-NYp%Q@(*lbKGW8=sSA zNPFh9v%MdLwa^Z^ZxXrz%nZ6AbcFqD&=K};oQ^Djj#NNLt_{5cjL)oE#F|yHb_-d< zO4jld(2?sxtgZ0uL)u5bO20zOk3!3xYaFwWlr&75^IuUWeG9P$Nr=(cR|EsAKL^>|)hoJsMd2^bM@;CqpabptQ|my}jn$ST#lE0G z1-eem7)&qwNPERr$)92JT*>e=Vy4YdrKV5&_)a^PT60F(&}_%aD>KHJ?|E|jcE6%~ z8{V0bK2BI-?3;7f=MEM7Mz{RF{4u|;ubXG6rK9b$;F97iYrRkLL8IK}+d8aoJ7eeb z*Am)J;Hi!8T>Y;zcFOjI*k|Xa|4p}_QtkvtxOal~zO`{u_U~YKg2RGqt_#=m0ax?B z?!t;2n{NGwd9QduoT=_uyGw(_jOj(UB7D}lobT@{93UoAx_f0?PjAQFOMfSB%HG}N z79Sq(Wy;^Fypbt)AFz0{WO>^e(6(lio79s=9)AGWP5vz4ig=)*DpM~^W z&%1)HE$vTu2If5MSKB&?30$oe*DXC0HDb1+Ki?-g2se?RaS!oas}=-GXV%qTC9znm zwd}eAVzKrT$17i(9A5J#-}rvjUi8@H4Zo%=k8#Ug+X2glru$TM*42!Aj(2=ZZ2kk1 zd$QsA9xZ#_W*O(wJ9w!_j2YU-^%ei*c_8m*Z8wrvGDtsT zfsw?e%h$C22Hx8|sNkSo@1Rj`-a9yRCDK>k0gqbJF;doTLVq85E_aSrhxWf0>YdsD5-1I_H`h@=pSrDETifeB+2QHL>T8{^+OD4; zD3u(Z@~(q-*;=5KoSJph+4BN}u-D%yag|>KPPb18Ts4~CI{MhDjjpQ!He;AmGh^%J z{-gPHbo&CHS9vG5$Q-m&(Ix)@zG^G49*}vT;66jZG@g`<67DS-1*sO zztD-}(1~Nhe`TpzeX`!95}EFNgl>=uhBsnz$AMo8HsWCF2>F57-I)lrhQp zYJsziVXdaN3v6}9P{df$)$>K8+dRe`Cv^&ZiWK)(jG^}E>KF9d+5!2t*=v@`^Hfbm z1UC1+5#27iO$9%9dgA!G6WkmuCXwu&7d?|(ocK5QwdnSvF1_erf9D;$=_lMTYuGxf zHldYIvyW`rP&6iyHq-$7pab?o8&&}STFR4YLqD{s657E1Wxx8Zia?9Wy~HuLe&Tjs&)C*!*)1CxkMtq!KSeI( z*ZJ-%jOUPdbmw!l`5ne{6Jz;reo<|#QFk=`eU|#`7|(OHw+$HetT8^xbBi^ee#VnS zza8WNHpi1=jHiTh*%z`l^^UcvH}*w5wqY^jbHcg*SakbGYE@1q&-GGsc8+s)5d%n?KT1gzn zZt`$T8z&j>*QLD?#7>p79(m8nTQLi*7=sq?_>w1m9&h18oU*9I zg8(juzFGQu!5U8wva76vvrIQ)Nt$=&C&2r^g!b9>o#T(saeU|aG`YaDt#)M}%G^6d zPNrY!OK7H)+ilqT9g)lA{ZRHvlBZ4h8o3|s8(ltd(Bgr^@IykwwXFiDwe6DYMA{QR zp&J|$Ufa$Yt>9@I;c0%wp7wa-`NgkgPmhKVe^#5^Uy!SoyvZ4p?=|y_cff~F`{m>f z&CKIs&g_5Bfq%AnW^0Xt@XTVz@Ry9?fw5|v*jrRiR@P;JhRXn;hBr!ndfQK!i~ra zk^}u|*1dV7$-}q63vhNCJbXW6n5X%}Pjlu;%*qCyceBpWy3%=CL7hgq@a${hDf$@~ zJkz$B@Br8IlXBq|YM=!#g0o_Kb%5_9&?V##^3ad&6d1n_-+F>E9>PX}Jmz;Egol(l zt&NPD{Vd-Jk0{SRo_F)Czgho+l=*>mHL&iNT;^lc;o{3%+OZ|gn9E$&&|aVEN25!A zOD^-+dK`^zpUR%@q0R%$!3isoFXmFVkooO~w)_?Au$y(<%^DR$^KKubw#~C(TLNqs zeoJ7hhqW(6biWSO_oK!{6X&)|s}R<=m0J9|wPI z*=9Ly2rl$Uoea3}Ja9?Ig%I$vapBXEXbcy8+UOQp`^N^N#@dTqGuYZ2vPqh?Z%kTy z&cw89{~O2JA7b4jv2~x)d5Cp)uKB`Kqh`P0So7V?;pf)e?73X*QQIG(Y%TaI{8uaZ zYV%*A|W4A|-6UiOjT&P2{@$t|x_zLw|Ntfx&U%-r%5kxeq&1qxp#>*kzW z^;yiVxj#O)vi|toN*IsKrSYISmj=gNs{S}?w$1ltwn_9rCncw)>U`uPwXeNU?GwGi zQO=mPo=JO)&Qz?=pFnKziSRLpw8OcR%^WcPZ#B19Me1LuI)2|nU-0-_=iUAB!(n6v zUoQDmSeqhfoX)$YpU`iK#cIbS6nX${>FVbP-KjeOZ{G)fxaT6i_v+!tgE%SxNg6iwUBi=NSz?RJw|(ao#ctBrv3qB%jMMV z;WvePQdXFwmh|(?9`BO2WgOCWA!j(aZM3aZx7K(s^<<2CT_J5rztUDf_9x}`_-7#F z2wzf=RDNqjLe9WoDl-pkml($1xt>dNLP@1h=G zc#`&LyY%H7ulCKnAz-xe3~gLBPPOGcTfJi=ZSLY(=ut8Id;pvm_)R|%U9w42=nPE1 z{{x&=0(-HcoHX9%CGuDsvs{f*vr7LkYL4z5zjv)?@?PK)?j-)Z^ZVPQ(MRRmFMz*6 z*2{#szwTDxm#<9>Z-S-;3z4s$uHG>ZUCyn*O=p}UM=xcJf5-e(5}aoIA-d%IwC8_1 zf5%?nBJI?0&K?9O>X^5GfjMWH z*#10v4Eud}lS%UT*L|aAU&|PLdST*^Vd2p8>@F5^5%5P_cMS~(38_De3kes2yQK+9g#7Xrr`zcd}zXZ z+hb}(4|hV={DXnw7GMOf)m1P~na47j2XJZzPKT(o6uejl4&2JT1$XRypUiVgKj32m zTxC82$IY}YZE|iH`}P2POkgEzA!9K5r>wS675_JV$~Q6|8}`Qcz>2Rj-;&Cjj?*q{D)6Y?94KZV)g3s- z8hl$7+qkt%o*Ca`d^=Nteq`?yGG_3!tBPL{d*-052XzGIyLd-=p48g~ z&J|NsiK^^JS1O7tGy5ya-T}d0U@99HyQSjkiCDwbP#f4T|(x=pS_W2C!yq0#P z4XL}C_G_uv!mpOHDyv*{g$pTL&QJO+vC0dnFJqCmiz)M4U=q^HP9&e_ROlMjhMK;ffdDUw+j06zh4#mX}4O_!cX&j zhf$9+U&fFHzA$DPql{0+(KPKHa3h zvHsc9H&IXaxm{Mnx5C4#{&8gvWOrBQaAl4^fy{9s#mC;xU4k8}^Z+_pxsSBtNZ9sS z@$$3rTXEy0$Kx$c3I~u=MP3nIr2Lh8WH)BfyFV7;x%$4z{YOfCT1Pyyxx_O&MLe^s zm!`%ulX&9jRKKb;V)A&2Rpf1o$0{=RuNAMw_&-D3Al}8|24&23z#S!cYx^*ZUcUx< zA$bJlu3hlhe#afhl3uax<6XeQbs1-B?6J6i*W2sgY>wTIFD7GeNE*BS?p((1+{a=A znkoOF#HcwzY>AWj%nuNwCV~#r%xS4QC4O{jTs||#w$op~z#Hg_%oxlU^q(wWP*cuL z_9<|-Wyhd5XgYUOwjEDm9n%jYUgu8{lOQ$EA#fd*|Ec7`PVe)P=yNLeIO113Feog) zZo$$#>ylxan6FUs+L*Ah?SxF2y|p|!vagcu#^1Wn$c3fP%%q#MZ2{Ep6zXrarKlj# zr5C8K>Da>wT)u{F+TGa0d>*^Bd$6IIgFd|LqCnTzu~V8Q`e^L_)}j;4!|o-BT{w3& zZP>g-gwNTIU5nJc2b(z`Ha#WS^fbWppAvf@@04&5x>c0@tM;kCpS&SReSPJ<13LDG zCD?)JwA&$eyV%Yw(tOxFObP$(xSLOD=->V0{sM_vC-vw%EATEOR))goNsJfo+Era7ast-?@DY9mDjYr6Wr}!?o&3Y5ciR>xrvR~ zQf$Nqu!(Wni2W`7*D{A9<`6s?-QL6h&A{asViUA-?m)B5?_|`l1rk^=mi_|t`(hL1 z<*#iMBzMJP2W8heXxTs=ykczz8z_^%k+sojm-hOF_6mG!`75xt$JKEpx?OB`rZQ){ zOsDLZl-cWGmscK+ZWsF;9oQRXxq9pUJPRF8cc&|NcVbgl1I%i`4Y{{7eZI_nE#;fA zd)2LS>v>zAGVx4!-)-0o)&M7`ou|z!7r6YJasI#CV@Y2~vY0J<*?vXxJT#By%2`9n zS(*3)iML_fulq`En}g*jcbvIyzMLh!_ye3xt{e^~YV)xIt=miY>OtGgHKkYAIdmP2y{8s!3qMnI{A3+aw5AqYcSn(t1gOA+J@1V!D z>F?v+Zley**#3&`eYa1|nvaYsz6sgb-7n|;x?QFX|1Rtqk%h4X%&t3tJz{fH^^PEI zt!=_SnR;^HZ`&3ZpeGTz+V%w~U|iXZS)VSxQ`q~WkC3+f56}l~_^=0*xyii5=GiyG z9FIM(W%w0{UtS4zi1=!E&7{7cUkUZ4-I>()Ti?8def&i2k@h_@H`ZomZlJ4py4ZeW z&q}{@_+M=G?Xhe&bR+l?U>AN8yK;e__z@t-TYdy4PcCssPXK4pz1cBudvnyRd+;CV z^N9bzB-4KYI0+7kuI?YO#g}jH1r|a6ns(&)4q*Q){%PtGY}YGPo8RyqV0^46N-J#|TY0*AG`uvz3;)=TVm3(*tRQU7QBZo}qUd<>-C7}_(+ zKCFs&TV<`ZA+TveUou$x0oD{fJaHHr7T>~OS>sRh*N5G`eCKb>-yyi*V=l(H@K2C& z$vnI9r#T3o%J?RN13jYyT`vL;v0oMV_wfHrzGI#6eakl1N!GFH_r#fC4l|jX%%Oxi z$hyvC&G&*QC9HXvG4%4itVy2X`!K0<8fC|T|5Y!Kn*Atq_6_FyKzqg>87F=Ofvy{< zznt+2PS;KpT^shdz((LHuoc_U<>>Y5F2dd$*ovQxlzV{rZTL#m$-56~#kZAsOq+eF z&$o5dU0$daFJET*M(n4}f8bmBX8Cti@omfx-64Gd6Lf>pN9}j0k6nFmB7Irk)!@&g zpZ^t*{JJ(bc zf9D!+@y2qswHMsq!ai9C{C84Ur|xakS+^AbOkgSSko_sRB6h@u;G@7w@J8(C*RuY# zjK4VzEf7DFrL4~~#w+{cW$+-K4h?=aR_|8kDs_eKWvVNEdt@BI&*)$L52Sy_YS1EJ zDgFrZEMu27Hr7toLe>eth~=!4>BX_Immo2hb-$?VkHSmx<)8mn|Sk7ee%ab#hXQK|!BhBX!&r)CLe}_>w&=r!p z{5q`mLPlNlxz?&L^gl@b5WiZf%P+_~X|I<09sJ~ZtyTX3YuRknrA+GbYc}di9jVKC zJXVbpUp)n%AikkWSL4LLO690=XI7=g6;AZ?m~Z%b^swGVz?iid($B;2)`A4A1mILbah#y*!=JQA-$2e0MsO@5NYVR8XyvW_3T#MZ#i9y+qGU}bQi z2Oolt4+cV=M*;)=N7cYV{KqA3+0Oe^XeaMl*o*KRrNH*9>u76TIexESR3TkgM&63o zjs^yD{-6y2_lWPGRcVwqqO{@v;)vqxZdIB;)_ad0(AxBiRm^rnjcvF_FYvVKSE-0< zxWB9q`w8|5KB2@=n!=U{tw65F$@kTryUik+FA zOH=gMc3FDcGczuadzUFXy~!~D%yCpXlcfK&hF-etz`mM+A2*~xyILf?!2 zjN)Ow=i}R9)AbZT;@i~)gqOw6Oyaz~WAW`6%YXADzMV0i3n9MUVD~;EgAZ8oe!ieQ zdn13WSU>R}0-@jdFK%u0PHC<7P7ZG(=8o8Apht?#Q+jwUy6t%d>adRAdr?Dk`(hPq3!3Fh*#W;{H1#*?#(8S zOYls^3+Sn_vzbWDLDgA3T^*h;vO2MYBxcNRbpH9u7ZyMBY^Ar_^j7egOjQ06j zrL2UqC;a}_muTOEj4$o`eP$nPFA}-6;d$vtr@r*#TUoNBiZNpU7+ynPjr3KSJ*D+g z>=BVGpD#hStkN#t>(BPLR%sLWw(?x(o3b}Y^R?dK^|fw6$NT_#=}TFQdSd-F02gH4 z@Im6nh&|=a-kerl%W16;ypZ!!^X#>4mOp=2ASCcotV0j@Besj1n2Y@HqrDbjC@>ZH zJaJuMM>a6&rVVTz!vo-u*nNw>#D;qSyj$y;u$TBY`$~ZQBIZ>O?016?#lT+T-uM}J zh_yx!5Z-)6)v1^1`!;Z(1souLS8FG0vxW87kq=*I4uS&;9FX$5!Pm!#C3GLMmBiBP2iBFqxyV>gzpfbWY1 z)(PL|hRa`#F8QAI{S(G|Ww$QUvRkY8-dwNTPQ~{DzOUk2=X!0_a>I`iU!~iUc`qcp z!M8X6kZWHUzmrby$Cc?$8rgpzvOoC}P2ID^1QmTus^8DF0bBOEO4C~hkiANmf`3V} zS7b=p%e)uuL2o57G*j|LBHJl+4q^*$+c6)IJxuxe@%ft)PVX-?B_;=@`U}PH`DK2o z{z7p%sbkHj29ot-)1jep9ZPDSU%C5{Ij7UJ#Pf@re^baZWplRQ=%abueeEA3S}>f5u`353V0{ z@x?t8<=*PT!v1M+97J0;Ji(>H?e%v@_8Gro-Azuw#Xd~}8u z>e=$(;^qgo+(nMCuI60+zwtYF^?gt6n8n>~be<~RKf}C7koyV4wwC)d?9(F?c&|}5 zU17t`-wI->*u4KV?kts~uV}p%lKcF=dR1CkwC?%loNpcpUiz~m!3SSI(uduw(bxQQ z>r3?PayKcln<~j6cDGVj+T*Ze8anG>lN`&BJ|Q}4_Hpj`hO#q0Moh2cmS4e1Y#Jh# zO@o}l*i6s5=leHA?jd$iAF%4h-&lOl4q#&-zBa$(u2kyj6x{VUUH2R)ZfnL4cpB?8 zmG!yVYxXTUQJW}}F|8V<#!20JubCS_#vbDX${ zhxj25W+M{6H~Z832Ag*xscR+WL(BfI5ASe%cr)2B9%Vlr=dM&@ve>cOPO^Vw4++lo z)hFkJe{_ggZKm92@Wkx7{p>$!C!-u^?Ms_h#J@9RS|!^u3_B)UhWK>H9P~rzuf(4z zz^`O@@#%&W>(9IoHs>L+{>*3R-tEbBR}7s>-RCCVinnJzJKH;F7|qxACC3g)ImdkN zIcDSLaL+O8{yQb_u*x#&y?KUno+vY>TuoDVnQCY#6F-(StK#`=?RrJjQw`m`C$=1Q z3aBf6*!@T>%oBf|h0V_hd_hKr&aBbeWG|10A8Ed0&EneS!K;GzeyVGsS6!LEHS5j_ zY^$2F^V58RuD-|RJQ^Q6Cz^@hC*@MM%Zh{73r}M57Wjy9hTRIUfe+(Xzs2AEeE&OW zg$<(*!gJ)0@Z9Oczew8B@k7FYI3j1P`hef?k(rR!(3Powd(QfV3D}_BGSD|(8M#@F zv0DAuXIi?k99WY$9-ANOi&}T6lgwCi&V1T-%*$TRd4uLrSNId*NemeUo`#&bbEFO3 zGcd=VtMD_GxNQf*CF*> zoQxl#?N1j!8;4r2Kh1fZxYiS5wDr5J_0V=}aehqlSP!PFJX^c9p>^;M-sM)YPcxr0 z=^@U|mdUkOi`zEF^=!`bAf0~ULiD@IBvZWCV?18Sd-$YbXL@$~IHPO^4UqHC=6ek~ zYtRMrOc|bh?(X-Y_Ion_Cor#61GD9?{EosytROD3@OeDvrL)@*xmNt}MUEFge6e{} z>jIJJgDMhGYMb2_|HCty?GE+-Bj^|J_NXrLqvo4bd1i=lrp$}+)W3!C*z-?mcZhNP z3E|ZRypZ9}2fWN2?S?##PM5f8v2|?zhAGR`u-9cRZMfL6M$&y_=Z#IMgPf5+BHpfD zCk4Lm(7L7b>zqIwiBF3H*2Fs-#|?^I7ERV>j(G z?xiFqxxBZ|lQA0t6T^ zV8DO}&hVHR1{j!<2@R8kwv!qI=8*t)Z8HPYNu!&niJI!Bx;Oe#rK5gT8zoT_B~cQk zRa)IdNtISj)mF__dVO29Rr6O9rB!d$)V)z#eaZi~kB$sJm|-4C)30|V#6J7I_u6Z( z*IxVh?U(3Z&Yeg8dCPxWi#v0o%-eS(Z3oi6#OBk!_c;8Ej^kYz?~v}K^&xEu(!P#& zaJ1^8+&PrHa#y*xque=^yK+~#@1c(p`l#I92gXvuSSojo<$JiGILv1m`Pg8EQIee| zLfR?Fq%b`tFlsKL}7CE(v0;sc@QWiOebp6?9m5UoGZWZaXRynni zLN+cssDy&38btR8s)T^|)^;BMkgvKf!SWjuER$fnaCldUtd1D>rS8KWT zMpIgj^gVYFy&w^pI^p0 z(-N;qEGrEXVaoakYrGx{2q;?QWE*8IN#KUt&Kq_tjpk{iy8V_Yh;nP`9MQRR9xFAN z)n_HQ^c==3jZ`hDJlQO>j8OWPH7}8u$vKGvtkCQU^}F>v4fqrnm@39}i0uJZVf#wf zjGZN=C<^1vMHq6_szEI+SuvfumCxBIY12G*s@cvi82c9(@K)fiT>Uy^7{5{He@F%Cuu&ggc%}&!bb0pVI+Ui8}j%DmkYL%*d=(0?1vh&S4CzOK2jy z))Cr3rM0SW1I?{U!v`|Un z_>&eDNdO;tos%kH?*Z72_${p@VQuE)3-X_DF!pUmK@<*3@~lP?3GdqiRguFQcKR${ znicPqD;lLbvDa#yvQMK%=Ru;RET=Wf$oOj_RP1sj53pdjBXNKgx*hQYtlE77%irUS z9bow$P#&6FsuVN|tHbVxDbS~+9;V7lp4X_jR!M49a49L|u2T{kRo5wTbhlm!A${X5 zl=Ka8uSVG+?$OA*i@Wi>i#PUBc6UE==XR^fhsnFg8GM)$d(^AZ1we5*!wY znA^*%`^dLX%kHDhKD-RGwNVy>*8=!_k1a{E;f#f9Oioy^MX(2&aNR-)Og+IAj}7ah z%vmWVDYG^#ha+MG*__mga|~sg8UnH11Q$Ufpi|O%yv<(UCAS*UCDJ( zqx}j|xr0Z$DB7t7x~SACHex6DcVRs>AY@IRYt65hYJgMC!V5O4TN?B8xCg&X@G|GC zI(^`Cf|F@zre@%!ktu>9PUn#B*Fj6c0Sud z(KapBL8Ue^`Zk{I0DIA*9bhj=2(j7`IHoZ=EMa*Wmy z<6xm`h=aPtn2(bm>(Pec3KE4npOC1Cry{e~2f%&h$^g}wJUc)oTYqu@;~$J}p<=t7 z-9mHiYH|xjI(TIZ7-WBZ6UAhge>2tPf!QsfXi9Jk&2}kxu5~G1AY->$+eq#nwX~6v zJ^k*@6jb_ao2ahzmo|aY$(haMU(%ldhZgkCyOe{FW|wLakVlnAHd9%Z!<#9zjDujN zmkH+V>Fdu9kbil9coS7u^p{a)Wq$!ef>X_7I8N0MQDHStZxS3VI6%oYyuO+8Ym_+% z32V6<40^3V<-|H3-bl4|ng@NY2Rzg3xf|4Xy$0%=*nouG1`ZPM@7HEQaQj8gLVpFM zXHk0g0DLp!-z$y3jX-$uld+A84D=eP8J4LoX>pn27SK6dkdMj`$F#IeZrcoqolOpR zf!+F1(cdQaXs8Y4%55?>TCGjcjYzv3@1nSnguETHyNd!HsOatFAphk~tteAS7O-o= z;51z$x+d2;LDvtrRl)=mXUiMLZtQp4@Qx`Xa^N?QcAo3n8*hajc_Gplxh*VD$` z9MYKP=hSF}I4I!yP6jrP?ZT9tOlc-p!FMD%(n(=S4s=pRQjy}exICSZ1FUl$;J^-~ zq^t@Cm$ND&Z7u*RZM%k&Rl5o@0&a`vMw?n{Ctv$8p407u z;4F@7x73sb-rM4xy&%ZIR*A>07^O$ACgz~hIml2P3l?M=c6i>PWnhj%-0(3T16&yw zOU~qIC&eT&>YQXP03MP9s8yHL*-i>s6u>EFan!K_78#JsgFFf3;^|JxTZgfjHdhJD zU{ioJv-XixCxC9nvPIh<`*=9_p(fWVfIzz-mELwBK)9W!K`-025SFn+(DmkgWiLDB zv4Hf731S|-Sat}_5(mr9Ni_rio=-9cK9)nZoJIDlkjNCbN^Yx)W4?gZ8Cwd?0L=(G zS?>i85&}-P-8$FHa_vG7$al!KUMhAx2NAtf4lMzO%f2P#k>!92#^drXp-7i_j&~{1 zrIhYcgG;I0r68r)t)$RZk0XTVp8lXpK1B&ErHG=;Eun;>6qis&k;6-m|xFw1jf-%a+ELdwuPmCuwf$3==lSN5MgT7nb*1!%bwkg@o zGza#znY>(yf?#tQ3RH?Kp3RiwGKhDkg9o-z4sYfJ4^Z*w@8prKl_B#Lw;7`h7gaQ_ZUDh~G!Dl0?oK`QquzHKzu>#A<0_!7Cg zg-T150(i+1S7r-^m#Qd}SSnYxQF>{AaVs^J^3+xes3IlQr+_EL`dr{Wxjr$+#`0kZ z-&qGwVRjCs2940+nicFqLGSKWN_7+YS2-aKui{WO%d4~q)HI<6C7isx5gL&OjV-p1k$#4nXKS9r41aKL$F^fKsoF$w_}C%HNHUSu#eSJ8+LGi zzKuMRoU?-}IZ}8BrliE|K#<{(9n{v5ZWEi;*M`kHP_@&XMJ?LNYgK%9p{hXD$%0VY zL5v(#8#Sy0MH|F5A%O^7`Y0nI5mcF6!p>(xLi0*tq(m)B1X7$u_H{!fQ6S6BS}>%f zRjG7A;ZY#s6>S`XVa=w7yD4Pn{%%kKISTR6u9UmT$9cV*qFkAS*vNSS<++^i7Q`Uk zO|f9Y|(ga)CV6BvfjamHq4@GUr(L^V=Ep zehk{f)ENE{B6CJ<3|dkU!?X5#h3!R<68zIY7}x2RPLOMZP9R`bmXuT*ts=ncxwBEB$DfE<(ept(hb<8?KD6`a(oaF-0rNxthMax*Q}WYJvA(3C|N46wGc1TN4HS6?&k%JX8xd^FHQnM0-WsxQ7E;r^R z7bKcxa$15+D^~nLc`Nj>$&eaP4Wo50bAbRw+1<2iAzpde2>>(Sl4o`jWHbC^?D-^f z_yk7bJzc^QoE63)7Yum;i;@v024RR3TAR^z+0vjtROZcLSK@7KzRv(Z%A@j;5YC$Z4np* zYFL37rqfZ>pBUip^2&tgORzBM%R05;~Y@%+&7Pd5D@jmMs|DP3}L5VmmF+%{@-$)Q29-C~1O=pH}|(Vii+U+s}0Cf0jo$b)f(yOE;E z-a+#Bx@zd9SFUd(&l2t%q~sDYp72tKZz~m+szvm!$|X!sm2;3HRi1^|r}m>vahV(d z2>R3{a{G7?>3#h{$eYV$|5mCjmtlUGTke8MBku?@Ogphs@c?^4T>`jIT3sGI+f-=sC7TLOzGzpWQP=E3qxQ6c zjR^hxE(I|Q(%u^L0v=}W(@aP9hM7|A#xCNs-Q=;V&~bxS7j%A~Eo4PTv>o)g-p( zDF+?_l~dgZK~R;_0W2v`AAktPJ&!;jcfzP$v2mEH19m5l{!?}*jM_CjhnYOo=A7G0 zxi&e6lr~|o_CvKpEiPwaTj#QXw@>yTq)ML>L+)}ux1U1G9d+a`=V|0R zWZyxmJCx{t3a{Yq{Wvb+)q^y*g2xY$Z{;c9BNShy1P)Mf6)*3nfV1EK2!&TGIoRY^ zb6DvctJUB^imu_YgOpw)M<0R2#o}hoI37y0K9GO7>w2Z{*R3adw~v;GeyThYn(| z%aKPYx{0R_Qg##19Hi2wL8O#7E1~`58{mok6dZ8W4pDZ1yAP3Pi|oOuwkScQZ{@Xz zDYuoE4^kD+2g$STlo!i5s08*?agdjA%CMb>4p4GCj~}4I_WtlA{gHx+|BD6C3kZi)8uy#ASJ%%1lGE~2hvVpm?wd4!$Z-%)EEYu2Oi>)y;OKe^Y10! zUhF{w&%1S7;tA+Z2?p-2hu&el^B*8WZ?Bww_ zCoJ8$w$MCXyWcs%cACT1p0ld3MS5*Q5(?TKb8Qs2JHX?!_KOf&+SCkmp|(4+j)$H0 z3VW0wrJ$KkLuYhAqVP!vF+}ME#0tNqjOLKP9Bdl`28fO@@HnHe9Ws$3@;aZ>AWtTA zF-gQ%8?u|4utH#QK~9QD&b$S}9Rx`O4xr_32B|4<7cJkR+j-<7Bq|6yRw0dqVJKo8 za+O;WDSj!$kR5BPTB5I~bzMv@!Yapvi7yT#D-4ZHE_Y%^3Qhq7lIrO~-yBDOvyuvn zUR82{ScfdaxSY52qYMZr45%=>`g8+eqZ7wIDhz`mn=q#4Z9^#IwI^+8G~HQh(b46G zSy#o7qRa)kFUv}Xtg}fUmpY3vGbcu#g<@-kDCdOFK*Dkw`i94P%YX%R?$eO-@~yQn z#}7W~N^@aHOF{-?{RvzVXM3n5$A9QZp^P|TCC?_5HhFa#GG>r*E7tpPKmqt@IgZl8?5VA z9$+LSWr2~B3b_zR&X6W!mVSt!6$?*6YP5zJl0r5>N35-R98c?Zhoc#oZJ3&X)rC1= zQGuOf4%Qe+#*tk}5~sg0$p!N--~uZR>>pv^fJO1cWNvZ69A2?#bs2UZp2g9ERm}hg zup5Q7N1Q6e>>P&;8GFfwq==kqt+ko|${}_dGDa270Qy*u>pJ7nYA1HbQD9?(9R(g1 z;2i?1v4w*H&su~)5Vy*6V98buVu8=bAr?ezaT}5f9k8e1gLxm<>Bdp~mBkEGaqck7 zh8nO%=qFz|ECA&QSp>C+T2#=Flw}C?!(-(kq+7EL8D$$-YO^h@{k`k*q-$2kCm>0L z4WYd%%;tEOl&HWYxgyTih9JS`;F1E`1bjl0R~&we@h#RS>=4MzOKK3BgQV6Vy-CAq z8`jr}Q`@Yigj{`1O>o-+y&L@3qC$_zKo4&NoE)(>oQ58R2`6TC#)Yvep@T;6I|LaJ zxEGcL;G1opfubPP92F-z1&dhGip80bAv(y|^H3ZD*wr?dTdb={DcTk6@T%Q~)vC3L z!=)&9!t`I@BghT3!_d~8=OTUe8TL7j9aDm-S;8)C>ZQ;7CH8I+73cfTN*|lWCh22A zi!+C3i!;;5<}7DPh>Gz(h>D=G0eJTGL0)v0`T=^tPP==q^X0U@?bB*l{lE{WkR)2dp5^IWodnC4-nJ7*w3* zxKv%NzW1!`$8fj-i&Ezhj+SOSd1)!UO%$(+bI?=8rI2uWZYc%3&LXAWZN>SJyJs+q zgQp(Nqn`<-mQqM@g_cr5aio`$cZnmjl)_8A^ZRk98=Sxcsv=CU9!wf6$)HKiDBn0Zf_B}mKsPS5^8`Ez+Fi&EbvU33 z=Q?-;XE7ZLQsz2T=(yfaxv-fcol0UeeC>qSUI-YD>~NPOwiWg~9zvI0qC&mP0ewH( z&7sP>d(I-I(&LD4C9k4*w!_6h#aUBE;W!E^Do2qL?sec8Dc{R+j8y3rWeQ8hKz*ts zJ4h*&M=>Q;v|LslkwFS9EqJaphL4@Tn-RcHyusxQ4?r?pZ6!z`ILWFxK)pOwT2z9a`sTz!0;J!ypn|FH&mj z9Wc{`H*i=Xk{iSjakf-|@nr+gz?jl6%>PhDV6vXws0Cmu-{jE`ngsnY$yWa)4vs;g z8Bgs7W7TGN11o$SXxX7cpG-Al>NAecg4k%N1wrYQA? zU}~3VAHpIi(T6DBE2s8QuD9Q_hibj~C16JVDwM+6e#H$vvtKRkqej02T5DkA3Fr>R zjRKvc13a>uDg#<K~h6Za;gm=k!j_v}fsO}ohpxxbJ{P9=7p$o)J*iHg>?Tub= zfAAAF;t|%qf-dTavb~U&F$Mi>IxEegjM$^kuRul&88OKkv#_}2Muw3m?99z9UIht~ zutV?L&i7cyQyetwq91MP;-w~bAa0S z@$z=6_Gxq5DI)x1Q_Fd3JI;W$!gfjs|Ja;^C$^J&g_hY)$rVV*ui&BWd7@!`N3&tuaV>aZH0VM3BbtYOOkm6B;DcR&yU{-x>`j(2_W& zsjuN4*f`f}Ad(evOyhP5D{RuGr3PU#K!SH2hXFUePKymveH{|~>p85rne|#|5Z*^f z2;dwT2F4AVZx9<63Bi6|1Oe>Vu-Co9R)`H;*eW(Kw!L523SmTmd9<`igTXYo842;t z!lGN*tmQD?0VE^`#94W5Kuck~Tab|6!a>68TeKL)yA_5+9lvg2dBhU&EF>VS1_7&R z9l`S9co&a0EdgQ3j)Vd@Qy;W%4MJJI4GDgTUCVI{GlR!=-dINYcFofVHzMR^JLJ%E zNbN!-3(2w%3Ket$ENGY9K=m&0b%C>M=>*XU*=?tbGKAviRKL&&U2u$yvzpj(DDz32 zZ=z<7@#qK?EG>8h9yeEjGw>)r4$^ZAkKL({mATD@cctnU1-Xm18L+hkiha7#3 zk{x0Pz>FPyjKZ?mwt;Rrcnqd%vCT6*viBI}dvNeU>0a6U80b|6J20Wj_2V!_i(Qsq zCfARGIfyd3<#OdX%`W%gx#*B9M`41JXOH9DPp)7jD<`o)tK{r)N~{t^l1_Q{C}o_0 zjAykRJr3HB67Dr}@HqL_h{i)}XVO8#v~h;HMh!&Kg;d5=FNMcWb^!sj?dh?mawum{NPR#u1v^g9P6&4UM+Wo0{f5<+sC~a`aUgrghCn;5*p8sP*u~SM=0_z5>gNIAW&$(R!3j^kxRDiuzb9_u(`G+} zl>{y8Dg0G>nsk8J!#N&E8eoD>H`_P)SK&qhc7M|5i0T$LXt5AJVSxzQA8#cMPiXwKNTLo*iNGaM~MJH@={ph9AHjrHf3gd{cg439q zSp~A9rdC1rP>>$#ROeO-fAI23AvYFQl3P}iC@;(Tm2l+Z>6LH=5Ggg;in_5bHMR=w zTykg?1WE2g$!;Z$mb+!|Dp=roeI?F{MT)z}DthVRiB**A0dWc_ys`opI<&w_oLynP zqrJSef`UslH~LtDgvt^=ixNw<+6wZkqJ+x*NKmyb5|)XCW!$@h8q2ig3Q7ppmFwef zJTBLwE2t`1m&d{D4qWQcf-7jw5tx@XKurODFXPZ_vP|>Ay-OOw(ulQr1A%c4D;XPI zRA5TD<%-*&0g2Ol=ms!nh9nhAKpgfxr~#Ym+erAR?wvwGAUBY`>$MZNYT08q6VVD6Ah6A#6f1`p z1uPDeDo75mRoG1n7C<*5a*?-ikLo@=&BYW<4n|_1l|gW7z<6sp7>3inMReV4S+BqA zlr_>0U_S--QTW*gJ5VqvAyT%f^>*-N4qZ5HPe@*9%DgGwK@Q!;24L>OB&^O^JIh#| z1v~TDoOwLkoH;uy+fEgsvD?9DjLtCDRr>k*=`uVJ;NB{Z)^E*0WtIeI5_9>Q6P<%h z!xQXV@JO%>6cHpXab!ayEdDbh@B{lRI6~Oe>R(FO+)4pK#4ZOB6tKNPNy_#N%EKir z{C`oNp9W&L%d@B(Xa{0bxKpnGBf9R?^V6MW6vjzX3Pi2iH55Y->K5{0yoX0>XrKqO zD*VY6?^iLRCGy;#zzJfBoIns;;wZu1mRTYsj?z*dLEWf26hJVm&SD;Mhc$=+B^(75 z@UB$qm`!lyIWVS`${e1(s|Ioi;;TfyXSGrj`Ky%_g4k*$iXe@1VFZQMiWfm;wNeK; zZ>&}-2>ff5Sp<y#?0mDZ_A1as?xNb_xwtN$C_ zYyi*p^~*)^-0#C+Bbx`4sF~mFOksVhn}uS~*dpgpz`IpQJlSn>`D+-Ey1#7)qCSMN!%}EXR=+91fwm#6Bg9s+oPx;w*-+PlMo~@$x@lYML{Lq^t&sD)X>h zK%4o8&tk>)%Nf*2>>mPy-0v)+-7xs%{{c`BsKKvGlsX{bs+%G@7IR6FdbA@Cj%B4Ykg#fRdhM+JsNjwy}5L4U^veCWz| zoX`F}aOAk^M_19~qIm5wwTcp+6OIP{m|N%s=ydtSi8@d=b`nZL<)j+7z-s;Q!G8ibu{UNipX$&LoQG z&xkGWeS_5l%=NuNYz5z0If??ov$rtwALA7aC-`GgluG}&ItO5ue%w{Vu-!i)h-&H0 zau9{9Z}uQk8&zk;;Lka7V({n0;Ln|y6N4WEMK6u10Sta_%#}jbzJbz{(_x2h4WXZ@|t zS^=$I!&acu4YiJPb2kJ=d45XHpn(6UV(23^5dZvD!13Y2}tu#hTP_ z$qhg(czZA;f@jZ0z72f;X*Gr33qP%dFtGAZ3#4v5CnrD^yl=xSN^g@xc&@$;8$b0k zauCnipFw)~?Q#ImvA5&d=zpx<7<0179<_P>NcG^4OHi&rOoeabA zd6*phBLER${SVOw!V69>ydAgLlEF0i-31Foq!(5oR#P8p0A5$@6aJNCJwX zcjMF#VfEb%SQPcLqrtyL%*z63#Qh!^$$%{ZgdsE%Md(8#DTEm`l7A0#L{Yi&9(F2= zYKfm`0{0XDmGukckG&U1Z-0#9?}ZT$Vd1@OAd0Z@UUB%D{RN1Cs8sj`5exglJP?cd z8R!TF-UoLltbh1@%$dMS)DbTu^aOBrhAG1 zA=E-V`C+7E0tJK~gtZSt%0O%GkFfqY!pui7Vubl9MuLIXV8aa{^nR4dS%krlu_5=r z083)bF$=6o$8ZRUuoz=UeF7st&KzNkBl`*F6yz%WN#+#esUs9LB_C%_F`oFR&@c8} z`cur|Mp*e2J6cBlVQTHVFh9Cv&@-ASotg)iXzPX229{+ulzY?^`m|7Z?O}CvgChDU&vaDMOXmw z$miLB$Zvce*a1Eo`T}+b;+ZcnCH^%qvoB!9(O>-w%;oE z^nVd%cR)M#MW$B8ED_HjEFxY4iK!tTLg@PvJ6Hwua4q~`0lh?ihk+w{V6JZniVs03 zhSm~@$Ix0H@d{cgBc4F${xVaGXeIDvCi@V^zswF6(VFjf*})823;Z5)2`Z8JJ$4j) z_V;jjjT!iGxLN{1O5p%Fjxdk78(|~M2J-(Co9y?o*-$S1`^=d~dKK|7LibmgvxfZG zSJ*%rVdX1K4WgX;512EJ{Lmi=YaUhp2(GW74}m{s7t!e-v&ja?Kqb!vq4s|js|~0Y zzs8(`{U!bs*nluP%gzas8T@mM31Ohflr+NFU%)31VeT)P8o}z75a#{@^z$!Se+*&b zuNbcjtoS-s>#KkO!UCj`%-5L`LRk1Zh!Xf;_3KRNRH-r>jAEH8Wt@5gu%5qRJ~66q zFr|vx;ctMfAWVLP4Mh;Tzln6v3;#FafsQc$P3#4XruIz`#y>@`xQROl2&5pLi}Vu0 zB=(5!TkNced;b>R{QyPqZ-EsE<9`eKgK+k5#qJLL9mC6f(d*x_FocM74I2lY)@qE` zP$>M5K$Tfc@gLzcfKEK$X4V)&|F@YEMHv1zK#8#SZKkG0{y)Jh7E{js6HekWWjA~c z5&&5eXBPo1S9y+cH^SN+bNUfR{u%wCzw|$|VNtIBe*t1lGV&e9{RrdVVa_nZGU9H8 z)$cGN8P)%lDG`9s_iunO<{1AsU<-y>K^R0BZ?IvJUTd&ZL4*+~83Gn5H}1b+S~R!r6C8F&4tG!aoN`PlTzT!$k~a6n{=STE)tz z-y`XCrt%&f$^hoxpO+L-F8K43z{2u-r6(IGmi+}ujv_ndmz)jIbN~A!#q)<~_I;Am zjWG2-38+i{_v1YXs2zR3q|`uhJs*(H29O>2B^aB1sPBVj7Xq}xIQT={?dLxTD4@OK2PKG_`G_=_K`)JnGy$r%8KOqg35avH2%2q#tYqW^PKPe4m5tcqF%DQnGHjP*& zE)B&I&c#J);8PNhA~yReX())$`)Sca*L z-^6`+#9~Ql$cwO;6se7*#NCLcKPL^pK8uB0v{SVPX>VIH`eit=AFAY@@CO$7x3!jI}4`RVDU=|3o zUl1*nzkn4&ESg5U2xoDX7~{oZN8`(=`9+KYVfl-qtouuFS3xZEC21&waPCVY)&Dyf z8DfRs0n`zCG9opMt9&uU${9c%Vc^SB7=K1t*DVh~>j%b2Dx6#3;ls+4;;xF8#x*CK7sviMUJj#{&`nnxM^-A%HX#V)#np#?c#G6@X4))c_D_My zNswU1GZ;S`#1wJe2GbTtGosBiFlGQ(ERIqS&SD*z9=K8p#UsfbxV==+Z!*>RsT#a& z+Mk3IXQJa&sha|wN8Rud?G*Q%lCn~Sb7z-=8ws;rF=MPak6(CRA7&##ILEUz3ZP%v z9KYA@_kzAq=JUM8&b4}U`-`xEyLG`<^ow);5UarIE{TCOVX&AVi@E)m8eeQY<~Ckb z89xrGU~|deJ>Esm@a}=P37(6cnPEIC&?3N+#+vw<28}Po^!-BjB!u)_l$DvqC?!QE(=6P66ATbQZ;JmdKs@es&EbYp_%keh<@AuuVS&`(v89 zN-!4c@2J2FCDJexf>DYQ3X7!Q;;7+5o24Iiz?>z4xi!bL)v(D8!rMIu1`nGc;}zjG z=|D;fUUn&Q$x-NN`uJC4G@vIiQVPFA6@Y+0TokmIVR?))u&i@PJn7~f9V_-7T| zN}f@1H05QA@DsxgY2j|s9~91nj*4)!5Z5>2xDU-?`|bykDq9@cHaN2g`V@vs3mjPR za+P**d9Z@IRt2tP9-AWzf@Kp9iYeQZppkZAeazZ5AH4e7QeviJ5Bh;u1#wgG&K^{C zKS}O|tim(^+arzWW#2TZz#}ckTxb%P<%=9%9lVN5_3#75U@aooICzM zGlY@ZTyT+0+c})$vi3>Pv^E(N%(Mw>ffxtOHv)&@MZVH@t#9V!@i@d<@hI_zz(QzBUraEo@kf zOG|)9yu1XSb>c>L$^tS6o3EP1?QB~JCn{pKEgaq`NsDkdF`%KhJMWVb zhA**HYi0qLpD}!F#S0oz@D77tBjaWGmg4ZDL+qJM2Y85v+yG8RIneWE!vHsT2E;25z?Sqefo?9i zEBrNatrEhjWW_xppeJ063LxHaPqI9RXB@)7Gstff&o~te;p)6yl<@*#QL@b$giBJJ zg1biv+}IevMQUel0QY5tuT`df040MR;sR8?L%hu;g!}pM80xgbD=Q>(+)1j*a%>3i zYq8>1Q?85SxzNRnxS-S}9Gt@4N))%6x}9)y!Wmc`E%fl%0L6MZ-U*NGn#?}dW(A#hI!{e$S!eg|byU}pJhWq@%jYvr7_ok{F zwLJW-HX$JmUx>}r*reeV28qprZ&$ZiBSSdj9*hoAdaDv1!j%a%gp_ScaEOB2S`5_>dd|aXh3{;TUkpSv*G7Lkd!okI2!JRC|Oc zPE!35NBSgAt$Fe!rC#I6pQOrb6y$nFyexi_qK7#uc#m*6Limq3-~v%P!sjr_BaSkL z`)Gn8d-f!f+#rZO*rQPfcc}4%SD4i7;DSyZXjPb~U$i*gxQ}Up z@44RAVT0btZoHXBx>Xl9Gvx+I65bjhJTPUmEofXIJ!X`C~cX6Nv{VJRei|4#-&WfRjF(Hh@EYJQ1PWh1o z2Y&b#CoF@hWuU5ZT!n+U8dfm~!6FlOCAbWSaD&-pxMe59IoaQ)R#kvp2#MYfrMe8X z1Jf#Z3}%)=i;*iTPUF<9N{LQrUm;nkEW=AZP@*mmrk8<;$ao7%qD%Fu6ze{SX5l}b zL3cev36-LX6Rl(vw}5A_>R*Q2o(Dr{cc~L~<4cR^RLteI5UpTUfJqawpCo*MVAp8a zz`w-_EeIrJqzq(2yI9q{T{sv(ViZTp!t-5)+?cfT)56tP3Ro=#XV2&2^vwq5*j5oM_7JW?J9!9TfMUlT3gaAI!Nc1o3JP zFEqSM#=GCUe7benZ*Z1@k)JT?H`DsTPs8(R3iudAE@`+1&0o@t@j-2Oz_ZRdq{rvq zr<1^&WF)sS9-K*UJSWdGc5MXiGe9m_=!8FC4X*`b5a6vI31=9t7ONHbSGHTzP|)pS z=|p_MdX_Z)6paic{`^Mf9N|&$Y5+{grGD&p-0r~5X-nV^$40%aI{bJ^LghT19XUka zTSCdn;oU?q;J_RRV+=z+KBAu*-rxu|2Np2V59FVW-5P3JApe+Uur4|Wy1}6gTsbP5 z5$*J17h;!Lihx67n}29X=Z$FzB^Mm5xCiN228pL zU^^<{cj{aVPCw}J|A%Ye^ezfBeOM&Ez;>`0>=#S>_n!A6<6dA_x@SD5JB*9X;Xg+j zbS>LKUbGsd1vF!^d71t5%=)3(-e`t*S5sAsF`9wl0iXNy(-mfE7PP`n0s`487i0-x z`^w#Q$IIBOUhLJUTIGyA4gTR~w~V^rcj8{_>|M641-6=n>Co+ z(I&|h<6TMzi4H0i^yx}K_Y8@w`^{r9+nfg{;V?kA#?ou(YT{M0K^C5$Z%@+(0w(8~ zm;dg8x5Jv8$v0Gw{M}(N8;dme{jQ}+SzC5Td#yc6azz7P-LX>~0^94-_ zn(u+#npxnVh4c=vG`)}QL2I$t zUIL9+@a_QYiKk%2ue8>yE64(@jI*k{Y5F4fEbpN;rm^*05pRyXWvyE1IiVivxDaN~ z&6|(~ZiLvCG@Md(Rw3f1vkfyIBY%M$a8Eo4pD1BB7b+LpTkQQZ<~Ggo2f_5k;K-u% z-6UHB&QaD7?^O_kZNg{KdZzdIF2?T{PlHx=f@33})+^@%-gDN3#IE2CUTg+-1h^j{Er3?A&US0~kJ%yI$-+^bw zLG1Hk(ELn`Z{w%|UBS;D8mAv4YT-+F^S$>~Mo$TYQxoSG>2LY4wQR-lG56VUL!ZNB zQ?isr1?-V~`u_g$=!JXr-gC-(?lhXmVvYlDFH3&7hfa9dHF((0za!)2w!6sq7R=e4 zzfi{0>D_|zX8L{~+;eFg~0Ows6Y8Gmk`1Wm{8srS5fqQ2&oUgy!h_~|BnevYr@zc%F zZL~`xM*LAz{$W#mpAjEvhVHdS+-1bqnBrTFcx(KJjQB`1#0BK$rxgdi(?6~88Brpo z`LxSO7-@!X-PnicR{1v?`R9y$BTC$OFvHiJ--@^TYsFjjTk#j0Z-$3?{mk&&Z*(xy z4Bajx-h!VIou7|+y;m3ojCyW|DQ>Rcioe+Tw94NP9uI=Ac|Vx(%RHY4_4i8i4;T%M zG(-0eBi@3y8Q-5Y^3NIN_ZaaJBmSU#qxk&#Z7>pA{h9F_>{|b{@cZ8zK1TQR<88&i zU-;5$?|%67pnUUw`k+xE-VEKkF$d3XBW{MD_``qVGot_BDn|43HSfnw&2sbf)`-rR zZ^d6Me9ZghM~ntq>;0hdnfo)(ua$p4_(Dt7KO@b+ZKhYv)@Y%dyK49dBo8gPb z-yhcejp5GYZ!7+C*T=m7TkZXz=O_AEY(Ku#@vJij+*;q(`0v;LZll0RGjyBr<)!v- zrvDp__RZt@LBsRa_6@+d0;ToP4FA31bHDz~@~c_?Z;kqX^)|1%?AGU8_ZGxK}1yl+&$FTB{L@DN=KW;GCo?{p@&5@^duIFKYfbrP{5RVt&HKqrKg{~#3Zs2jGrWi1T{iM3 zjeIkFjqG`Nn#X6(Z^c{maVu-43^hY{E8k2X&GAin7zc)9p) zreCiVo@V}Qj=$3OUuk_ae}7PWKVuYdH$(UHMm%i9&HUd?zs>a3Oz%$`?X~!WnckY) zH;T{G&sO|D3;k-%=jGz_%dP*Q{zi<3&Fg3G&n)km_m|n8YOddk-)}u#MuC>R(JKF- z@tgA>6u)2pt^Qj1W_hNSZ*IR;{^jO>zuSAI<9W4yYbBfEtLw869gy$7w= zzjuER8qX`u|Iap`R|=0;>;GW)>x1C?Dn2fR|AXN5YJL-5OP4-`BcP2N=`nf>opv5+ zr>#ef&(Pi@M-I{^oDgnWajeIg8c4f7(CLKagna?%(}OFBPwHq%9=(ELrAQ zwPs!a=Ht}zRwQaep2Rk>-rnWQSFffG`;WlA3f~v=fhX2|K4=u5w^Eh{n1lT^{XG3B zeV4v&+ex#8zhJdY?rC?y;%T#WcJ?oK_S02qTG}VQLHZ8+s#KFkrEbd#$!ZC)9_bs> zH2V?hNnCyYSLw}`tb~{6Sf(u7r47=DEH3t(3JZ@pq z=cUV*v-FetY2U}`-R#4-r@6-ZHOmL-la@cQ{3h+S{C75D`TyAarG#`?`g`_K=@LE8 ze$u*(_2acRpR@d%rQP~Pyb@~%Ey4Gv1)$nq@S}qg(0rjnfQjN*M^6Lm#CNIb`v!Ug zuA;O~f^`s@{u`IX_Yz$~`jf!Gr|4PwAaHgQ?Vyj~Zp5c(Jzmc8C3+40Py8{opQqoY z>%i{MQVICF8!NDk{+^g5zW+)A+_in*uMn+f%h(D=AN!RLV({!c^gUdgDHJIliqJp* z^|$Es$O(GQ&V58Gvoe{{@BH=`?xejzDqG$uwMo11dNCjS0Q*Vlxbzw6kn~;LWMLf;o|L=er59bNF46I;D5A*J90>MYFs|dXpure}7%N zZE+dT&6GR;{~_K2^i7E{*FUkmlJC0!s}#M1zCzPfpueF{>+Qj7fc*u1=S8&rHd?;) zRPUYd*E^ce-!{TKIp43R^Lopy^Y7Z<(!RI-RPSGt_HQwp%bn_- z={nWhEA>jNyGvcc_AA|Iy1qjlUF+q?_$~WCcRg)e*ZCg)9YF9e*3!=a`Rv zLGsZs_t6ELkKWMjqu;dpNVM?}@^sq=x;prGtzWSwyMM{{-L~(_N30xk_^N%W?Mq$j zt-sdsrp~{zO4eYvDF5#6^KA+HpUC2QkPWg^z0X>|YTMcNcEB*la_oXN)4f_+Exilh zPs;yd`ELtGdiSV*n9mFG?%t7@NXScwHro;v?rrs@rfA)uAU)qwTHk-`KH9Sl@pAVc z(H|LO@`3|a@eBv-uZr4y7T-(PoJ>tT~NQD{Z{WE;a9@%8~7EF`t{Ctb$+^&ZoYN$N1lD}wQ>D(t{HfU zesqTDN7y0u8nzJ>>~-ugyUBL3w}8@ZX0#WdpS_L$0v~)k2`TKo@4$b*9P`p&6#nnO z{IAMCeeZPR_l3vNqjZMa>6a{1bm$PBc=L}EbuJrNefP89PmlljMIuZ4Zs!xbc1=%S zoqBro!qmj{^sYURPF$b7dTo5_*woa-)G@ks``KqqMRvD}Ja+2LsbjP-S37h1qF1OE?|KGgl{Wj9wVK zb`3R+yrI$goW0G*lRv(29J>~ba`({q^{X?ZS8vRWPhA?jFg|+z+Qfyo9((_@MRT@?jhCd?jc!EEB@%;=@5vCG%T zZ_JD$GI?`mdi27?Katl;Q}8Ux-yMo)@e%3bBg%@89X}!GieIa(R@mwj#DK(4^dZv3 zv&{%ay;i;m+wl`^i*{S%5n<~m-k&SVwc2i_x5nQJMY?!yeMEUk$K=9Kj8B9hn>2!- zXj6ng>`x2E#yH$R?D4$X|Gy6eOzZvw>(tbb+Z=zX9pA71{nB4*``_>K=5d+g^WEJq zeZIhb9!&Mz_bGPYwK~Pu?_2KGbSq z1`^u%wQFO#bZd;pXl1di*N@$H%}kA5xO(GqYcQ>mx^7I|*beASPEA~bdY0_ z)8kV@K6DN59dZF`W9KKH9@j_z#2ZJa#vr;i+gb=hV{*;Wj80y?HGXYW$iUY|ry&N9 zUDj8oB?`8NF%OgbS9_se(A@R$^EWSD8lM`yG(L0Tidg-7`v892n3&PAL%`qYYthPY zym{@dz$T%cn8$Wc`PKqWk57(Gjm_i5=*0QAj9-|UZY`EEzNvAHa{R^xz+t+Htol_H+uVS(Ey>t4??P(D? z(_FYCI)L{M19q;lix+k60hn}s;^O$VY1i1)xNCkUEi73CXMt!pZ(PMLygvFt~@$UvIK@?IR6fRUzsGb&VynJZHhH!okI*8!DXdt72CUTtm{*R_d>$!XWc@fobq z_{ANr*WSbqK0odnbDh6=8K%*Rs~26@q5KSNp`ANjCxzB0^u1}L;7-!xt_tM z5?CeL#zq8J|???Knh6|6G;q5s>i>1z|u?4a}Gm#^M9dE;rJ7h-qKxBSE#2eurz zZ!YML$ex~j`n4F;e5LV=Ma^QR;zo-9%updkq|EVSlSYi_**&X!ZJn1@0nIPa#99gB>9kv(yD!=|A^E;3iR zJbuq$7bzt~f;+qRuKf*WesOB-84z;8-m$ml>BZfHB~%{2Ar?+N8Jv->&ePXvL3Ji4 z0J~|rhW%muKRR~tEimHUxNw_hgh}x-WWzg8cjaCmyEO`efGr2{2u-z0gMLh1oz$B& z9`7y%)^>5a+3l!ckaXd~GlcD~8zLbKjXynpV{{tC4fO8r^offgOhz(fNFg;DF<9#^ zT-8Y+xX7eS-}ndUPU`jXi&t-6UnJwo)yr2FN!D8dR2FN)l-z7VPaGecx_0}HB@a?2 zz-nH1K|Gs+AL=yO=IF!}MCI{|_oUyv(aM<~yFPhsylGz*oOZs-JsEfETpPO$;e4P; zxGztQL;9N9;u2E44jXbTAY0sN0v!GC9_ZeEyi z0l#Kk<1wllBbV|)B ziDq=g1dY+?Xp6p_6hNEAz81yr$S_kA&x~Fld&|U>&Y6YiAkfj+FXK0^j6tTn2;M0m zGEI*{9GSR*enGe|K z*q+^&^l;Z+gsq6CCuyV8z^UtaZl>!+^eR`4DhT)NZbmc_G$XtAHk0=3zS(@(wO2gM zM>Rd!h&Jm2zKqAAKzV%BCnNx zX9Dw2&A#>jn>}AfkLX1VNuPrFPfXwqH$WyPF5iG42i+GUg1*EEg`FLgTrjo%W;dGd8G{V2!P+{3Q3m(Dj;9oO}%)4;|H zS9UB`<_zfn#qqn!2qbUnUoDguECNODzfFZ|a1X9GO%{vn$ouT|MH>;eh#jCW#vF}( zcpeF2&tXKBMSHMAzs zE};(s>BcalaY(69xSCyHg8C!6*#U)hduw_ZC+?m)D37iKm&0e@ylZuU~|!JP}n-7Ef&;7lhJuwfX-$N+__(w zEl^B_g~LTKQC+(^P6vSC0JEU+1mFYL1ZR2%D#EyK1w-Q4#pYA1rlEPe=*So}d!0b& z+kdPzbu8c;j=XMu*Xvw#5CmdI7=Ugf+=0WOpP)A%pu^X$xj;$o*NU;D4C(=NaDnH6 z;sC%?SI@(G<|44Z+XB?UQo*rF{|~f?U|Tvpc3UWEPrUK&*vT6re&y;6xJR=Q5yu+q za{JM-nK5&`S>x~&S`_%v>aoeQr^UL9-3R(AB0GM;dQvWXTR+z(55uQ=E@28^knhHTa1r-`XU}!#P+^z&f0yHJ zUU0JKFptE&K=$@*zxU_X-ZMOw;oEWlz%LJZe-4F*Oz7tBgR?lIx6io^dj;<4!x?zt z<;eM5zZc&3(oGmN6Bm*JH4;|d4aAr|BT45Jp$UpQm8BKXV9&p+6m?duX$Sc~(D ztLb(dTFME0zm0b-i0HkXzw;bM%ZF|`bMYeA_`E)RbD`4&gFV@xTIfiDLkc}25XWv2 z45DuYg6JTD5POLi%-|fdZ})ij8SFKkf_eKjC1)a~72`|`!#jF$k=+x9s_4Eb5H~8`Q(0D=dLJj?m zUJ~~Bg2F%{(aVYwc_A-R?}NA`WwA(b371q{`{5Vp4KV2D=)B(F+c3#+E_L6}Ki>ac z&ZP^zy?tGm`p)GYuTi~k96|AamxEE^T<&&0t_XZp=YiID8OxL69cMV9Dh?GNX-8Nb z7BVdP9dJANy*Nn*O{D|zwOA_-p*3FRAIk4RyMDMdMZi7}D#?S9#i?F;8O!7u49>Yi z5iIJ^Q~#`$Av zgnFDs6#AS6PpJnLLS7fL&|%LDgxQTOSm=F+!9e1}9w?bT(o2jzQn&PC)$&1HpuOwH znM)URDLl;*;k)KU&V9J*yxOrTpL5>>=gyw+{+{&yHaKTLY&7#L|pnf^g6f@I_JHl{Cm>--heqF*0`K5FP?u-dfywI zZg0%LKJCo_6*>_L-FZ(zxbvRk192ybk=V1L(a-|7UcL`k3oo8um55{G^=Z3`6tZOG z2}Kriwn%2|e+!s6k+y6pom5Iccg9)f{x>DWrLTvpn*hd7{KW%m{Pq5~?TQF#tqE5Z z@6vaX&KADPkivAi@HH&a@q$>WvqFryuOLgHuYMsEv~mOj%EoI%%#6^8{M(>uEH7*) z(4#z@G&B(GgdV)eljvj!HCQCOo)g_9SD(PldOr1eFG)PM?k?HBlN%@>X+w#+nsjLjP^b>Y!B zu9y#>>pidQrGsfSmfHc|TR9l{aDBy6;W>Ooi{V;|-3h#CUc^l>SB5ZrVN~ZC;a9bV z{HpUqsHDTM=B^+1s>lK=r3Jh~9)49Kdwz`(ot@*dii`$7{Hg;bp*4M};8Q`OSAjq{ zrFo_U&@%q9zME3a(LlhrgF9^JvUg7L?@8}_gMaVsJlKWZ9*1iNj=x}z`#jv``^!S! zW0?EA`QWACA&!>`Zkp}HDctbJx#Cxk^$P5a(PQqoR=ThT)TU?Rs6MXv^L7v>aL?@B z(;mB(d&sfO$eZ?Kz2}devAcKg)GW?HrVj7oL-w@%Vw*S;c=PPIgQxke+>+w?mGf?< z(QP93Vfc?`4|k~iVCnA4pX<3JgLSUsKVU}MG?esqTxg5U>7soz*no|N*wfgwbgBoB z34&W{Q18BW7X~if@E0#c*2fvf$)u%7d+33NZasHVH>58)hXyFK0Ovgp4OqZB(4l>- z@uQ84Y{`eflM6mTDLy6~4*1<$cxG@dHcgyu@Dlc3^2XsCozj?VwiBYX^lC0w2@9PQ#d-7m$v&fqaqPcPQSy@{N^9E;&8e(@YvW^s;rkAQGq zdHed~SYW}T)en>KWmx07-^&~4>-|_i@wWVMG3@Yp67mbLc^<=if6vD|Uf1C*)thc| znwszr#=a8o2@VY4rCsM5zF%@p%4u?%Qh4?Crj+v%7(9nb%>7-kfB$8U4wtwncUS%% zJWsn-3($Avk9)6`ICtfFtIG~@&K7y%eC!tY*SzArd4J?7czGO8NrEFqH~~fp)b?vp z-LH)&@i&pY)=6A{JQ=?(o;=R)$ASSw`NFNXoLH!Fv`Eh}tk}ReYjm!5dJj?x{vCIc z{m<#Y?AbqWcFrq@KoEHxhR!=TG#tCHyANlTwZnDR+lyNQr&#crnNIG*Z5w>fdP4(q z&*l1`bICzh#Q)Citv58l?O>Z;(bD-m46%Z8ax&)^p(p}{2!?a#9b}nv+ORm3Wdozh zundCjdGIWrL!Dj3HZ*+i54_JQMib%X^UIT$9k<*zFuAxEPS|>dX zmwg_zOPS6BG=bL#^ybUq#l)YeVA9~v2rx;&<=wlE>lQ$lc>mdq?O@W4FZM8Hd3ol3 z)Jvs`*M?F4_?Psc}7*$>AY^ov3%y(e#&&BBa>`+ULS z9X`L44i^m=AmOz~Pf-G`5iq@01sLO}^1m~s|J_d=I9y*bRuwi?`U8?JiC{o@A%@Zy z;eSwPELTq8~Wt|F7~pe$lxHg}8)M$EygIl;`@UAXUTPanUOWPVTU%i|C>fPUJdOJFR^GdNxB$Ubi0e(Br=^px(ixJARs`{I_n{a)ZFjnEbMWXPvhc$665co!j)J zw2+N=93Jp_j~Pp2`OvXA7DnvhYjHH5>7u65NM&?9(F^JR+|5sL*#C|fvb;wf#Lr7% zKHdvOy$tI_ssbI9?tKu8bc(wflh49;JmW5W$1CFA6U;&c9&r2L3uWR{Z$Gk7kYMDk zelH6~;(=TtRl!s+vS2D0SuhohypxZZ3N5Uf3`QQB3LJT8DiC=mo)DIr3Pc{73Pc{7 z3Pj$FXJI9#f{_JN!N`KCU?d*jmRJhJ6$}O93U&fPPaig>FY%hf7iJ2s`$D?=%>BJR5d1!lE{3ffuolnaJuz=r@L?xss>9RW zo&?#mOFi|(lThzIB!29sIPX^C_hCVlZ=e<5xgFk(+ioxnc!Apmq&bcK&%N9bc4+R@ z4{XiL7!H^xKbQx!{zE3Q$3++uY=Z-CHG?s90#V*yJI0(!d2X6Jarqil5DEkg8-jhcN!Nnblw+0q<{F!TEwSh}JHt{%>#%*oU+g`RV zY8QFCRlsvRu8ex`;$clOaODk{iOd5_A>LM$|8XvdhFCVa&WQ(u1<{L01Y^>eXljcR zmvc{JzZutOJg2T@+QM#^Q|VLKKT;H7w*6V;sWihc?>_e+-;(oYJ&b6>y@L0s7z>|x zMi`7a)zfnr+oo9*E?sGA3DWDi!<=|@KD|= z7e)A+#tJQBCOzwZed?g@5SbcixO#S5O!_)$;=zvcrpw9ftfN;|Dh9 zCtzW*QgZqNp2>GVfR0a_JOQlpvnpPG_n~^CAg3uf-fDh$wjP>?!XP^KJ(@vSHTu&D z?|kzmzmxmn!%k@(+mFBPHLMJ;@UnBqxssT^a7?D;m`vfA%o*(E=sK0gMs9d(A$ntB zoOHSD-De)U>tZ)vr!0<3`C zEZ}?Zk_TV*MY_l%tgq`GU%ZFsKg9BH(e8s;?_Ct!pB39E4))^F(53tjkay{Uhb|Ol z;2+4Y9higQPORr_H(rP8=h#jsI7;7Rv3H+4&oMwDKGVQ4p_2*Y-yIn~Y%AaCv*#Yb zyIXO)htrLgcL&E)%*4~4$n4YJ!FHap09fb4CFiu$?>vNGIDF8#$JRJ-?dHaMKK#PA zVr)OcuDDycYXIwr+1_(STfyT!-o2_V{Ckg0q7J$%-`aOE@S98CaMj&|hp^r^591evN|;=5KF@*WT!o#ZrOy zVl7|!=7Uzf-)wKx=@~8;+s_0Z8+o%6EgI?3Ef2vGM>dCNspq*(ot{Ul$(UVbvZsI7!0VggpbsgI=%sgZs6;>&>y3AJ)3|GJB7Yv9Xr*z!hD4dTl%U z^>7(ae+zQ7@Z;Q`&-;7sujdmNZ7)8=?RhE+gY)Z5_PBGWwn%HkcYm5JJQ+nGJ(B(L*2=+L3N&lHb;l&RAl$mqAch`}) z{#xhy%MRw3iR&+4>tG-Laof6^z$2xk6F-Jk*z4kWdSttc(HH!8y4l*^`x=3FkuUaM zz=J$4>t2s3%ny<1aNhI(A`!B>D}Vdl=Pn#xeY~xeSU^96(aZOLq@2 z{6Wl}&v9yYg7X?~=k*>`D#kYR-j((rGx?i)qr5$Q-&3_0vKp~V z*o!*aR*@s#@d<7F_iiFCC4ATHP9YFR2T9;zwfDvno=M|17A)R)mpOYF<7rEq#+PQvve#VV~4T<6vv4lNe!)V8m7Y{8j^Z#r8Q{0xR@TkXo znu8%I>pg@xygTH~ozcZHIQ%f;5|1gqAMk4VwDy{ZQdxobU-Jehn`E z@f82uHR{&nXXM(E$sSZQLf>?*#GvHrxs) zuwnk(S*(EFit6Dz(~P={Kjg#{1Y^Lh-0dIvjy7(8IITTA0-nzCb@VQ8l?xk@{FOesQ+g4K`bDfP&d@SO95Z{^wkT)RlTbeP zJbl5ryLg_;ANla7{+F;wkLf$6Hr~FYeC|viI~J!bdfz1B?<(h8sr;16 z}VnL0_=DNXByUpg2~) z_hx6`_38Tf3GaV;Qy)Kx?>1!D$Gz)*oBb{!XVcvBb?9p0d@P(Xel}i9Sj#xL#_;U{ zfBzD?ChjKe7LuFhd$BvS>@9xLVR$+I`2EN2_Vix&UN>>A?v8)>#&_^~qqnY(#do{f zUzD4?>%-51dwU6R!v+WOZW~s*yqjYD@P+r9$_)+Ri(d31?=>Z-yAc;9=d$;=`}!Na zfPvEyZx_3B-Xa+08$?d`4Go@VxDPj;>=AuUw-gqt7$M9+f zss&H3xOLaBPpeI|de-l=+-ahXtoA+!1_N$+K-a}Ytrxdcr%U|y-U_?Xi9h$bxQGr6 zV7RsH68;-(FLdx26hAHSLa#s}1MtpXn)jZ6*h@QjlE9x*u)vLCJhVYrKLcUAq~PFj z{4*@Ay|!D>x&fDsP*@cE?5mGEk2sIq=sXg~-2%6^a-{N>KH~l~AJ^Q&@vCsRzyS{H zMEbFMEs8wYjh|WI*vtFq!`VNs4QJ1=207V1W_Fne-WkRf$~(_k^Ev#g9Srpb?!xQi zc;$k1gf`}H7F_hK`#yRLT;?2X@%984q(i3;w?5T-zXt&`-96WF8PdPy;Z7lM(J5~0 zSNf3;-uHXHst!WF;+HWl_uwuXJ0lC-!wVmtp*&CG=eZhk8GiHEZM@;|xOF`&w#2*9 zv6D9fP4Iymc=7%D&%f5Wx7&q+a|5fX-B?YvFmWRX@;mOj3oFQ{&*t-ZN8%y;02N=O zJFTbk*kbf-hSA-gg@4h;TVzHv`ImK8mv={ow@>YdRs4xy$r~|9#p^j{Xl!TBjIA`? z_(ctk;%rY{Su~EoTIhF8y=TF?BxBIRFWlgCL<69yaN68u>(O>caGWz{zJ1esv8nB* z7rs!Ta|u@8X)L5)8-HHU^RTRb7L9{h&zXL_^nM{QALMa`Apy_#@gN$%2XNeZ&he8c z?sqUm-D*2qFTU`FwhDpOAuUOJE8@qw9`i8fUV6RbV$shf;YXnSc>GRNAcP-FDhk>! z9R&}#?@VJbc>N8*5XA1oEMcs>NY&3K6~&#w4=V*D_!CQkFn{t1!5%!=&-Yyn@4i2J zy`i{0ufGA+h;HW1%>7w}+S=b`i0gvC9;n}VL~m{k9o!hS6UT=agJ3`Mex?TN=-k$K z&fBhxOM&;JB)W=~{_ z-lVmy89nD7^u{*tK}`nRaBjzq7k`cB-rx^k#~$VVTMTJGZu;Xf?3OEJ@`Lr)=IaU5TSEDFNw4HTYKPCx6N~eomcDSW{FKXoa^Prv{*j~g)z=-ZZ@>O%-Fd^&dd(Y;){}2KT5lOTTJL=G z(R%+c9IcPO#q^Bzuaf?`F>Lx^nf}r7)}!@}UoxHj3*%df{euzH!~MVdGuD6Se>qyO zlioLKdb$2F@{XhRsdpZ&FTCq$eGUJ7BtPZy-+A}Zdc}K=)@#R2FIWE)?=?LWy8bk% zezt%0==5FhKRW-xUo$;!KrY3fN$LAg(7uK7E2I3!KVZjq0=R^gwEw>J)-wI0dzZ^8NC^>Ir2@b8(v7b;);#kDA_C z#=p5gFg@JA(@LNJShU_Iz5b7)^{n*mdDD}Yf1!MR(rZ3pdUZ%2@$G-o^!3Mt$}b)N z_^bC}H;g)eC!|+}(jO@O%;znArJY9` zh_F)p8I>Nc|G7Vw{cqUuVSPz@?3>a0n)IcAh}O5H4{k^6d(xY}9j#Y<&ivc|PPASv zeeS!_dY$zA_e|gY(c<&7L3-!^F@4Wa(mrkfZbB8(2is>}>9hZ3db#$^OWzBnuUxY7 zWqIP_vw;7j`d9ohrVj!5ucUpae$@0a0OG8*#9&Z2mpO}9e zPcWTkqQ;-CD%0nHsQJ_Q6HPC7ecj?ef{jnv^iMLq-1uMf6w{Z0VEK~1|GY5a!}(`W zZi@Y$v- zV;oid8IoRy#8K&|pKIx3D15O0=H=h)G1FPNsPwbPO|L}G!TPKEy!DR-4!rm@h4i@e z{S&5lJhnLhM(J%S)63=Gc9ZENKve(Qe39w9K+wNE*8ZaS~OQR%1dFumTIrKEqXN)Ml3O|n07%F+)2sQ*I#8R@YXo4yT1_0L_NSokzN zrMP}`N?(^Xojo^LKk+YE`Rck%?FmU1nW_ojI{xm21 zjjN`o;UCVwg8v)R2mZ?Rs_NqQJ&-=~53&zLoj)tzGQFJtTkM$ll+zFX@o2sJJEq5h zsPUs==jimA?;f2#_fMub15xFh`QFj#S2%Fu6ASgPj=xa<`WMq#4Z;4IlfJNLI!}(^ z`8VL}|89ET%cZn`)bE?#3Pjbe8_jMg`#*B?ad2hxZB%k(+;2m2-c zxAFU?hs$64zpQ@ZTJjpkVNw21KMEC#50`18?AQH>=^2;{_V0Sx&p+1m1kxjm692}f z*D{mhe@57gn3KMNP*nQStIdA6{ri>w_~Vp6663$Z`8OG7wU&g*wDeY5n5rlw?B5+qzy9=SyP!!>udGR*f3E2z*QZshzwLzS2Pl8Ad^OUyt~H(WU*uoXzq9qG zPoaFl^CPMBvE!yM0zvzo(wFHNK5Y=A?AJD!o<`2W@oQ4)I~z?Ocyh5`{Y5L^#!F0Z z@N&^$VBfvJRd<=b3Iy%ff63BszSQ(KAXvUO=?xU{84acHlD_nE(^<@5`T^;Cyz#*& z6Y3u$(wl$&Fn#d+ospjBjS)WK^LIgd`zxdM72kfR>7A(jXFlq1{Me8_d4F{JwY|Eu%f*ZB*kFUE`gt5^E?2TkYT9PIxU>t;VbZTdD!9_$}A z(qq4C`W}EPNPCTqKW)+ve$Vty#6{I#$E@k|$RGAg>bLr%rYA!A=VZU>4^6KEg7rHo zJu`3mt~q7_`|ka1`uNd${U=QC1A^t7mHo*D)5~4I6Q4FcJif0g{nTen=Q2F1prrf_ z9GLLo^)ZF6s4O zG@acfnE#gawJ(`I5YnA5TmG$oV|pbJY`=Qx9qZA0lk~1Ho8E=_e=vPU`s!Cr50`&L zdi?9Ahp*q0(r3P5Ixi!^`dg5`{!P<4Oa{xpB0afnI{Qzs{&uBLecSYXw0uyn_&ckg ziSL;n&Oa@E`JYYi47E?2^u&Lfo&fF{6OS`}Fw}k%(rbSrI{k+9(I=Un0D}4NN}sPWJzTz;zc>GO zo@)955G;Q}`t~zS?+VpVyY$v;Oy@p~VEUZ&O*)28IQ^3Jmgk!up1-Y2U#K^I5V^YdbobZ{roegx558l|CyHF_Y%`5fnfVCNUy%z z^c?zcu>3pH2VY@&LumYN*|heVYd3u+q-Ujf{=Dho`T3Ca{Jo}EBR&2rxqb|B;R&Ba zX#I3T>1WQHuKSac^etVcuXt8U?N@i3&V5S3`Z1wK4N2)7Ay}eBN2BhbpN7e7P zbdJyPucZE}KVtUF>CLmIv;PIlH@ap1kA2j1p5{S)O8UyjOm9N^VES9OUOoAk=h znVt!y?~>lW6rFxR`qrPA9`=9KPyeUU>8Jhl%cgII`saf5+8+Z$Ks~vLgjCj?mSEWh0d?M^h#~eY{6l{@()UHMzL^d0Ht(oeof_K|;Z{Fzk# zZMT{}6w(i*uitJut09=a;h(I0&WlZ-hI9C!mWw~r8Pn&ie_0@KNXK0kHHJ92P@?Zj z=lBaf?I#^q{L|m!+rMOdl#!zsoN(J>0*xlz!$FrZK?@{%eyx;U? ztKX9J``s3$_0IDFVl!Rtrm_pSbBkC|R& z{-wQx@h2mF@jBDP_eXi@yVsk(3;&|(XY-`#d$1W*ziSPq4L$%(bF%EwqGOr**i_Af5GuTAw7RrwB9Iv;HA-ei}c}pqV;y^ zV=ps3Jb&wwzWoZ*t5H7uSE!!>=?Cqm=R@^3Dm{0v={2U8w9k-hdS590l+y2?R(fQP z_A5zWb;k5?{mmMMD}RC_I$McW!X<~;Rc^@{_D~kUKOoxOK;|l7e3+o z-=&u@@gE^U>*RrSDygPM?(STsD0)RR7J=M<0x~-zI(Qp+oz@^Q%kx?rUWq z^&d6<3_fCdYnlGB`uaor!SkbE_BY;OdQF-BvG+#P?QAZ+J|9Rg_xvLHrlak*44FP+ z`4`TQVfnZAX46+f`h@h!x5&Rx{m)3B{zcQdJ{KJS7Nk2PrgMHARlnPBGre5>IBz#y z?O$?!jlSb(`~B}So!1YzP$>VZ{L77*9HF_CeIZmo`_kv$WBPE&e(X`!|C`25 z58ofuNUwXJ>D(U^ygnzSH@@F=E^`I-wDitN(|H?@@uN__PU&mEDf^-JnUKEyTc(G{ zhZ*U6A2dCQ@(1%@kY4v8(;Hzw*#9@AcYN6N!H|DD(lxWx3V8Pe@3Nmf7$f#{C-mU%7*FT^JiB2+*hLQFG|mE zM(eB6>%ShYZ%W_(Mzp>wed?R0FNMnIJjTl3^{r^VN_zc2M(c6uyWcjQ>jTK5aDFGH zXTD=P=eNQ7ZfbDVYpDO!|EQI}^FK`I z_z=v$Rr>hroK!3HOgJ>C2Bcefhb?{dZ6L=uer>`&U#^$@ozBeAD^- zFlzoaS#Nr|>(l%()5k;QU;QyFf9na;**;O@+r&xJ!{w`etfe3PY12EAJ~%$qOW(Y~ z^m6{~|BUG~NFO!+OufMLc$xAqz0mYYWL`8rDF5tDrVo}$zx5*1%lUWEe02JOTTFM* zO@jG%DgS{xOy~M}uz$@;Z)u56zvSz8nm&d889aXyS6lt>++{kik3sv5()V8~J@ovj zMS6v6dJFtR6_)hBjP!Ez%ZbyLzTEt2=#1&*>c8Tw>1(0(tEjZ{t)Dl&T>I?af3zO! zHoaW`NxaJRY^eU)mH$XCTF*=0?J+%E|HIM`@}@VJ>EBHkO)pnJ3ztmi`hC>-pSx^& zx$=!XV0yXwn|ko*{OcYvJv{#!SNW2!J=%WDfax*#9~>X1mA>^6(>eY`o&OWBGre5> z)DD_HZsTVf@IH&OKPSE1`bpOtEq!==TUGkZ(9!v?yxH_}_6Of`wBGQGruSL>l$?Ll zZ#BIZ{WG}!zbXHgMob@o9vpx6r8mFbbQ#7`#hdJopSnnOs_!w;*b*mx8G}e2L3}&TQMA`Q~5W%&-8NT>y(}ewO?N8XC^Ft zx$-Ycud<9w`p2sDP3TeM&+Plnej}WZI)Ar+P5GCppMzgFeI53r`p4R&>2b4PsGnh# zZ|?)9=izx&`s|eH9jN(W|D9L*#c9(U%J{eUA=CTd9}X$xzpV6KzhgSZsQkM=YK^eKef`kU_V&@N!cIzjHNHve-;)^uP#%+tDiN!T>DjgPP!Gl z#Q#R=5=!c~NqV{Sr&anY=6_M`AOC{oABPyFH?Nq^@<-|Ye_{Hhr7yHkv+A$ri>5E2 zd{ODwq>q--vwvmj^TGu`w)ZIhc@Lu`q!q;)D_>|Ot-MZ<# ze+%~iex+~!yJ&q>`p8$L!+uox7r$zHyXgi0rj@?tYtj0$^!(RNUka6fTYAG*w7xHW z|C`Zz>p!_McJd75^G-e@gnS^l<&pOYi$POCQ#kr8oY2w7xF=U_V;lmcIC( z(fYphp@V2WR%Pwm^8IMNMtUV{1)s403F)hkiq;#Yk3BkCZ;{^qm}tFSdhJ!wdYAM~ zzW5vAU%&LJ$42YJ(z`07^>OL-k2gKMel{(=y2|wM{l~oY_!Fb`W#4|a=_{f0cU}7a zlS~iy|8410Pmb0Pq_;lB^lJh}K)B*Ttjt zPU+j%MC*C!GtV|XT>pd8=bsa;k4j&9UbOv5>BHBWz7uMnS?PVxH@)2as;}Pka`Wr{ z!q_39Ix1|pxqthQqPh20ZS3S}C$66V^PWs@9==6=!>rY1O8R_d~ z^iJtR4bkcQq$htmS|66aA-yv+znhTW)EJ$9M*6n&WGMZj^qLzjeRzCWmF}cWXZqm! z|EBchi%bvq-(BfVH=DkKF%I7f^8@E6tbJm)m>%vw)zasrm+PN%w_5sg{d4{{(5!{q`2q$3l9O^qrqIeH#8_{!{S3Rr=VAP2UfdFDrc{V|o?r<69wpzx0Whm>zz9 zHY|Ou)%0-vk4vw($8@f51no~t?{71`0{-CxFN!|{SI`HgHzFCbkeNdp^U`Z9s>J^4 z73{BFL0^~7^)38YsJ|tZZ}VkVzFZmqGA}p1vW$Q2(!>34!>`|0So-k(hh6FIKWF-C zsQxRet$!!(HGLj>u>Vy{-|R4*^XK6GTfOwgSDGF^Kbxh;J53Lt->uSH?=wB@f2Z`R zY_$D8=_BV&505`X(s#N{51$`n(#N_@4`08hrMJI2I{$g;%@<5Bcm6l`m|pJuPv=cP z2-W|xZ~vm{Jb#1rzb?J;lIhFP@vYGRcBDIfriaV#JjvRBT6%bVsFpr?+0uvWCm}ui zV6@&SJ@HVq-XeYHVbixz{^0oCE`60RR^k)(uS@#!Bc_MTHy}O#y6F5zr8f*l=RYaE z=8e($&q}X)Q*{1I(&wdz+jm|1+?x;W2itdB`phqw9&X3wgB&cEu(*1omFhxYNU z&_C*=SO22v;refszW>(f^exhNf5~)SUxW5Lq#wM^^zi+6PI}whP3QR$EdPk~_IH>b zZvP4Ct?x9w2K@)$O2+@LcO9({jvcL!zuWY1|DRR<9q) z-ZWwQn2ir57CGn*MH|J*8a&~H@&f3{Y;u(ZhdXw1Evq+9E6FI{12|65B!Fu zFSkB8B7NN2zr=psZ&~_q{nV;_1HWzhF8qsH|H*yO^oCIXYEt^i51HOprhfN+$MkUj z&M3X}yQXgNvS0T{rq^5lNu!wFXG(hOyyR56`cM zrSC6W`mjDOJ@MzJhx^yG^uZO=!`IJcKmA{rUWN7zUY|FlH~yvRb)oZXM|#H>P0xk; z?}7B?FPYwe{t?xG4%SRBH~x+Ojp>{}2CpAgKWXj1wQhQNep)Ae<;$jr>#srj!G`I4 z{u;EOmR|E!)60#ot(&Ho8(*_uGkp+e6{?`*{M@>Np8dL|FE_sSNl(H!#*Y&FQ{S-k z9ijGVSNWWOFrCgtrFXt%`dk@(Zrk)s$bOe^|2w89%A`;1m_A=d-~6uW<;qv}J=4SM zfBnjTW7qU;)PL0Yxb)Aahp+#`NXJXnjZe-lI(qk3R>} zGmkMnJigXG)z078Ri=lp5B1XLq=)YxoBi~UjrOli`pVU&4~NR1mEQJv(}&8`-})0w zZz`i#|G4Sp+NbG>rf-!=AFnpO-1s;5B-6{aZ|hS`57$q>$~X0sribf)M0)4bOb^%p zg!IbVXnj`tyz~|HqTu{=N&3*!E&Wia{@10);--iD&yMuYYohhar&<4*f0pUfq5SKm zcRt(naQT|0SJp-AZNB|7dYAO8u}|iG}&qsPql#VgIJ24?izD{k-(H zM6|vlJ$|j};q{YE>4VQVo#TJh^?9(~^m6+fX0JOs{cO^7-v1$slIzpl3Dd*l&#wII zZ&3cB{g(~3*8bBkFrBXfqzd`!&SxXi>qGr}Q~K;%Wk1w^ccqVwm>w>_^9<|1BX2W(I#m8@=?%YZ zdbs~4r0>7o^sxVp(ktE>oxVl-^1DoD{|lb~?b2u89c{l$`oeom58t2lOW%2~>C>U| z4ND(;U$p%R>5~)D_GhH8{#vxYAl>EZdwiuCs1FufDykLn-uziB$JKf&{VN9pH& z%XF@91?%rX`qXcmUKgt0s%KjJFMrVVuzz*Z;~z3zCw9sBPBXLywwf?Tz=l+E# zz3KN%uM3^uUGlH<_f4Nh{z3oyrN=&MdieYvk?#C~>8&CAlYaR>W_q$r`3I%5jrUwXOxXQh|RKk-LL``<3TxlI1!((9n(Q&PT#E9jfj%ayNj{%HTY zq_h8_eM|CRlWtZ@``^YD^sOuCJJQSb?|tdz){kNzH_x>HwdDM*y@H;+f}XyD-hKr= zcLja$3i{X;^ljA7(;x2~+Y}eYNpW1vf&)M19BTt#3$}s}gDv1gV1x8}@Hp(%fp129 zT;UpU2;pjlE5SD*98=f<--z%5`Xl{W6KBOSkok`&JRr6yJ`K{ZW{`e0g7m8nd;?ew z(yvNz5aF1@4)}V64{)AR-veKV@UFt!;3Eicf%Izzq#qL?^BV`5-zdoZ2Bi0aw3h=} z4_yj(f~ZL#x6qAnPFwGQT>I`Bj6=uL@*-F_8J~VfkbX}Z-Eok|_lq539ArIKgU<#lK(9V=efH`T zWOzg2HHBxui>Rk*V`?0H4Z>r_R3FIv^G3G;q@60!0X_R4QMtugkns}=k0{)ya9V5t zFXQKmlE%~`<{LLZ);Tr{{w?wu2ET^#w1CVv2|ftDN?`}|@}Dt%L7V|;ciNb01Zg(` z?!t}(((WSWKY5gw^CU1e1^x{D?gD!dpEaghK(F6}Z09PmLh&2FWATgPGtP{lbGt*&AwJW{}JPto=z}sLi2KL~%3S-IvUkyJGFi!+i z`ylP_8B;sppCJ7@$b2~8r2jb(*Tg9j|3qkp^H_#Sgi~pSN$SlClhm8QXTT2U&$L%9 z9!y(3?Saom{5qHbSHVBK+R3dL-DU7ik8?6h#?&16?#DT~S))4x{x|&Y2cL=bIgoa; zAnkM--42j;+Ks6ekap5Ww;80JN|1IIalgQJoCoRmAjp1|2icE06i$k9#aDtn{s8wQ z-gyM_Je~k)Zw#c~CA}S_y;g;jVqEbxAdinJejE2ev^N9N-W165d`RpP6ClUey(v2{ zca82g$m5sA88HuXT*!iPFay&6CXoIm!PDqJ^~O{!_)3IpjH!Lxzw!LvGrF@N(~pC1 zL4WE~I1AEVM&Txq=U<~SwT$~jo`3V;uUF!F3G)2QfUJiGkmari*>9>qws#Cr-28?b$NIPkecJ?RD zzg>{^yeiI#eIVN<4YIzPjc%j#8u8%QE&U?Mc9{cNpHm>~Z$jY#F{k*f!cE}4XrD%7 zDgpjH!ga<}1<3pzqq~gzd)DhBNWUk=Au$co?`n|gs*G+-`u6)R-HJF0((fUVe)oa& zJEw3)Y*KuK!j)h<{EQh>`&gHF1;TsA)EdbASB>sCNWVux`kfcs#A=X!Z~dyJ+cdiC zAdjCHC&W&Wez$@2I}OtBCWULoO2s?i%i!Mu)>pvP4%mk9wlTE~(%&VcI|9<*A&~vK z17toKkolw)-=O$vkmvi>doA4tNWT}vNwE`TIg=pst2erJ(ksO6aZ5h~vYeA3^B)D7 z|FFVcV!Ps76;6OJMfvKCscNtl;VNTl_dS;Xj?tY1S>73tevgQGF$vOd2c+Kzzv9u| z19|+KI4=%>^g9pI?@o|@w=3KzCKO)_z6Ac&7*jFuPJ}CrsjYWgzMDpO8l=CIAoCv- zvtk`cfA_~M-Ja3i0eSq2I4kyn^tTJ7zb#@TNWbgB7sH=~F;xTpEW*{s)ZV)+pIxK7 z2-3fKkok>^17Z_M|EfUNXQk1tkiPX!OSdeJfb?$=q|c{{u)#Dpy#jA-F>_HyA9IcWpPH#f%LZ-WV$A!+aSGK-2Y`uzW}lxXF>Wq3DVy& z@D}(nYD^7+HzPb?Om%>?-)?m4LAGxl$noLeZDwx=q`fVW@oS2o135knflN0bJuSTf zWV*QGs}#RGV(HdE`nv@3xDk+chCtR!R%{VtAnRrQm(1@qqq_p~_!)6jYy(*@EnpSc z2r|C}$oy)-6zZeKn2Lc-2v-%mi)r&YZ%=3IyH=o?}Vep=^P7G(cie!X!HDxh;rv+qrniZc^d=q>GP)HY>*wHMv%euOii05iYXh0C)#$cJPl%P`>O9TeUI#y>jHxm3IKrdGR34=LoY8Ft=~p9lq^}VV`YpTw(yvjF=|+t1ko2tB zB36Q|HwUC&yAPUQTVOr>*fgeA!RI5qVoc329`>h=?jYllZ##Gs`e_q*8(0Ifzpg!C z$FCaQdGM!TZ_b$N1Ahhc{Jhbv18F~QbQ}9(&b3(Q+PV~To(E>Yul$%ZMKE;zCnXWR2`w|?t|7zpFt1SI?xB4sS^;dC9%z`X` z5~SbtMz>CSg}B{i>1ROJ`y}X{KOp zDqJNxir+hn`%3t?YfNo|&p>#?m|6ho@4V3+1nF--$o$*ICh_1t^LG_wx)r0l1oHSP zaahcN^tTzLze$k()`7L~BW_GpflouY(wN#gWA?X=?gB`^=0J|qBOvV!fV9`A_^jg7 zAjj!ykm)L=uXS3wC6MW6L2ukw{2<75S%up`9#;#}PBqAK?wvNSi{l{Mu?u9qWQ}fz z^d>PbZoSg#WgYx+*j)x$o_Ub@&4AdNpP4qM#zDNwk{L6m`atHBH@b}={Y!%MuS(o= zEj$O(zhRK+hK%lj^bWCEtN__=`yJ-jHb}oVK)e!{SvRJZLA)ZFSu&=kK-!-)x_u!1 z%7LusHnBk*yEo>Xg}(LkcAek(ISbE%Og9ZO-5|*N$%FKxOY!ZBZv@$HF_7sT>1*w3 zZ;@*wkT6&u98d(6LOkm;6;?gGf;C&WQ9 z4bs0xkbWgV`c(_!ryMgi##9W%Pj6-_jH#`=&Hkp*odfCD49I*&#JrdUc|JHG{W^H5 zM|Th8@oVC|H~`YGJV?JfLHgCMaEroC3fC(f2d{#kwZ>E>h@ULY#Ehx!R?C0O==Q$^ z&()C6`kgW7uW(%_d0k&qnB;YR{%7sDhEp+T1;>#*E~zld_)qt_I}1 z{NOe#Z!>ru!kcNUw{?*Ha~5QICqb5XT=Bz-?*e&VRNR8+f5<0$bIkcX{2}R2r@|!t zN#A70EjGoRMI1-+xCMnt9=CEMo(sa>oY?q6OE>j`nDaiw#~U%L6GVDL8fmN zn?dFq2br!)VFzTowdY#86_DvBLFPNE@F3`&#~{HA1y{V4f6R%70Blw6(H>#Tw`|jjqV;uJG;izCP+IQMt2>g zohguZ+Cci*1k%q2kbc&Hv|k0%&q|{k18Kj)nA(e*{avHG1JeFHNc%G&?M#8RGih`u zK-w8MriMZKIb?JPLE6cHwBvyEZ~vJ#4zG&~;sD6&R13)KRNCk^Nv{=f%j&I@Y5f9ALb{uAn{!kF6o$(Zw9gm;ap zRgiX9jP3+Tf5t%C?-Sd_8j$V3Rb%NkjqWnV2p8pz|9!SBHDC1Yw1{5Ha~#?&ata*P<=I*|EQgG}!zy!K>^Uji9FtMHK6r}$2V z8^k)rS1COEB#uUF-ZO1K(^B|9(Qn(hp1bcHoVaH8@)JGN0 zifxK-R=8TMQ2g!_Eq$X{4bo1f!aF~1`Uc4OHHGKIDaB7HJRs&2pH;XD{5r3@Rc3Dq zq`d`&C&UrO4=J1#+Z3Nsc=Nqs$2(mu&AnkQ2+#)tAKB;h(=qP^w@s>UVvLB~G z_RF|fAuc`6`tc~}^&6u*1oHS!F)hYG_Tz)fn6m{xr$G8S2GY+Fg>zzu;#48Zy)H@ zEBH5>KW6sV#RYKy^sWma)1{4Wlk{5A5tm}-*E~qS zra}5OsqmnfSA3VkEn=hM>%p(X?}RZ`1AYzRYGZ2eD)VR8=+1yF#}vr%eL&2C^dkd4 z9`Q{I*Ms!S0lo77sLC%chyx(Y-wLw)8Kaw)UMI%HmB(257r}o;f0_lq0>5XBsR{7! z5gs?D`a#<5GrG+n{ZD}OD-Lo#Q2~1Ml?u&QjP4%j%~y=6P0*XK7~OTyo3DVJ2aJQX zGYWD(F=BLwLE0HIrusnI$s64qNIQ)n?d&|-{M!QApO?gGu?u9qHGwQ&qtQ)DuM+ou z#L~}$?9VeG+iL=3`;3BLMtzMKQv=}NBHV9GwS%T7iS$GPhU;Ut0 z??yK#JtHQ?J;(go2I<#2NWWIV{|!Hujj4I?ZxEg{rp7?pA2qsJkbZT5^s7mXi<|#_ zmFL$C$aK?2cM|0BgJM=pfUK`tkbYHy^s7SQt?yg>8tD0}@QgU2_%Vh1#H`}m!8Mep z&6sKdzl3nwn5qNmXWZz{;=OeGF$pri5rsR&R>e0dTqQb+-@$wDOus13g0wTCaFbZ0 z_$q~W@jgA%ZGt?0UEz6gTJe(#4~lukcPU&2vVCG8>wD`zjmzRN$bQoXvfQmkw?%rL z7!z0i!`f#N{0hc_F_3-^f%LN<{37bJ&zR~0R}sz{Q_UdrX)?Mi_+0@$ADRXEd}su` z4tAQszeKtwW6A;fJm>(wQvkYq;MF*89Ax=ML6$Eswu#js%eVD^EZf?~>6S0qO4$$o#Wnix>mx z@A{slTQj;VAdjCBN5wXf{A)V1(|Ne=q`ageo7n`Ga&tK2I+4Sq`!6GpTdv0F;xYA9^p!3 zY6ri6LHpZAcM)Xz36SZ>6z&tVitkXkNvv0Vox;@$ui^JMSk4vDt7makYz5gabs+tS z8{Hb|`}lnirrQuFL6&n2d@?u$E}=Yw##A2s9KtzcDg)APi_xtFS-!1*vhrxP+Z1jP>lD9%-z|9!&btYa_D4Y0XTQQ3u}Sd>g%9w1C_H`#uLHk|abgF*ufpRuKpwxQ@SHfM_z8sv#GK-@3h#g0+G!VLeXoeKVjg5WHG!

    *+yqc6PFqS8`lrcgj@FPWGcG5gvN#_C!O5M1cq77+K)Gs<07neOeMNr zc223fU8^IDcy_QRV@8D6p$%Iwovlq(7apk@b+nv}=_$X>Ms*svj#*6`Jv^}eAyyYy$H~}1=K53GCMy82RaO%`x z+}ii>QO!tM^&R>2jEp?v@laiBLk(+qbVl;TQ8JfhEOZ?7sgzlO*CpsRm&0*}RlBrs zH8Bb@<4Z@w_)Q2Olo>mynnlWE0YIQ)i`tOJ+I|`5W@p{5A$dMz*bb_yM@L6~rJ&f+c$m~U;ut-s&6U#2T!{jHLJ+U% zNS?nqQpNe29a7YmdM8+257^z$!SyNh$kzr(`^c9H zzJT7c@q862@UHSpiuzuYq0FNdS-;UVvX zxD_8WlE>aEjYsajG|Q)Tlyh&@mqyX;JhwJ|kP63B{=7{2=!sJb`zDIZBC8+1gOr=W zX3NM^@_jt>t2*v4uj_kdfk%dX!Y+MGW{s}K1EaPIOV4uqP@mrJl+Pa4lugZJT+It~ zhemBwhQ8d&lFj3(SiM=n$ET6T#k3la$UCuCXVw_~hMRs3pij6v#p4~?K2|r9@k0F} zPkVjIOFdlr-7+mI;~Sr>;kCoze%?~|LCe^&qYm|>XE`N%kL)oya^*v=jnveMdb6Vr z$=U~QF&W7>>s1vwH`eDGIAW|z#Iv#R$eKBB-r};SIh-ze>JadPA#ZXR3FpkD{Km(%rR1Xa4{@qVL{ z5qh*Pn+<1{e$vh_6;?e?sV&&!eK0rNz0szN);wxylBk?%xOLS(9pSpublakNJWFW2 z<5oRTXL0Se&GU}BMn^5Y=8ll}!zQ^mP|yCv$3$7TE%odc^ui>LG8#3R3%TSI`SzvU z>Br|_$Bt@LP(Gh&JXv!KF&wcqdruoR1y?4G;-!IYn2(P3q388wth&#%HGfGdH_A3v z-WhGQFEvk{jZgFG0@1WvrrMVIvo+pYkCfz0d5j}Z53_0?tPV6D^~xJ0@+5zZqmNVS zmUtgj8TD1|Dq~(0)^gJQOtN-$XjEsoM|H}gP4<7dfgFfpgbc5!)l7M_#&S2e@t)UQ z$Cg>w*gbG`xt?ijjgdo@v~<}&X4W3r857^D;A_-z*6>Cv6q|I?8r7@zbKv@=DRvgQ zN?te1kuRM@^&8aSwwQyImZcxAti3C$w-}`=&{^mHIl_$!* zEw|S^;`N)0;XQ2fZoV9G3<=X0^=tk&#O_v})9}dudBZ)dmd|&qyZ;xB9tUrGm>Vu$ z##UD!nycjk^(bmv00q<&W30V;(yZ-y^{=k> ztkK5Vnf?fu46pw=f_jrsnbEcZ3w_c66 zw&c$?`9Qz?%y0C&U51q!1Rv{&A2(=lAG?i%?a_qiCZOgmB02h`yl&ih*4TJ({N$5{4*r*os_YM86??8(uC}(H2udNp~SB#UN;t! z{ETcbS*y0_JT2N%9C=U<`?$ zI*=6L!lPnh@*gB+RbYdo z@lvl9z77r+3dvl4&n083nrXED)D=_LY7tZ4YT@S;YM$f9K)lgBOcRrG+S2!GD4r)4;rg$o1ZDHSrUk!Z8uNm@UwAUK?6@2 zel~7Qvw-uJUybXYu--Mx$CA#khU;(D#|In@v>G`!D?QVAQ>KCZRdWJom3mZ4b!+`Q z{yufpaD5J`;pE@N5~Bw9v)A)dPK{Z{@t93oGz#Gc8uqz(lue=JK-u|RWtb4(s0nV> ztC&%51o*ralx4tbG#%Gi(>R4_(BD3vu%O$<0gE29$XUc8f7TJ{bA)VaV%zl(LlYfR zb8kl8&XqqK|9)>%oY4G+98nXR+<3jyp^4*A6O6`@MAOHi+3h$2o-i^iCTA0;Lo@ci z$^CA&8DM0kBh+!pj!o`(piXakivhdZ*Cu-zm!WX_*}$6X^BgxLn~S(lgKXTj(Urem zKR0D_Dl4}f=;;A0o-SYo?%mjG*YFiYAB#TYNrcoK@|;v++^_$t$9gqtY{NGWn`W&Z zK6;sZgpKgA`34X8n&tzzz_)fAzCQTxwcE&U%;$!Us#H4cTW=dY!}PgLqbAir^R3Ya zkN5wrMjO84=5woh$4zsPk9}>1Lor{QlC!gB*x1U3PV=kzU*86_d0Lh{h23Q12~r!Z zcRBHKEPZaQnX<8bTY&pTANtok$xkkmV14wV#fI;%_~_F?y_(Qu^W+}6uHthao5!ni zJ;m1+o2QFSXi%6PlxdkQR-_M+&qiHQqesFSg=MY}(q4>8q*TZkDF?9HFTVH+Q@p zslk@3Oidi_2JeUXnpE8$+W3~tn`cq3dAibgLTR2Vs|gJ@i(mDwgRe`4@kUYLDYFSJ zHh8he*U)KF7n`SYZ9*5DDH%4U#pbEyn$V(ASRK~D(aBi<`S!mNInA_lZGu;gUBKb( zq_Kz{-X?XyZs2~%zcG}JTq*LoNxdEAb8c;x(<^ze#5fuBZHa7-70b7lnj@?F)>3nn z)V{UUEC+HvHPsBqw?4Ha$7aotHGON!s3iio;)0_ znI93rT6Q>EtS#AnXs!M%;-fo#8MS(2#K(VGWsrQN%J{ICe1p8=Hu;Yv6XS2>8L0r7>{l88HU5@2?;Bg}n%yq_>ZD_5EzWe##aAdd*9X^ z$BlI9=lvb~?5O+Y(U$31TKZ&#9bDE@V&9C2caLGhxqc0TMwVsG& zD8$1&Kq7%cp|X$witk6*S8!ZSpWCS6NKbd*>ktlnovLI`HehW1b+@l;VJ>i(s;XRHgF=rPEMDfuovbjn=TwEc zuIf4{O5}#jsaiCQ`M5>g9NDCo@%SQN>fy#Yi^-bSt&p0mw0QSVas}C4C#o5Wf^#ST zrYiQx+U?$ZbL8CpF_-Jvz5kd(ULX!}Ofk=W2J9`PEPlQCytsULw_07h50^LZ-<|(< z_SfBdaeu#D-JYEd;q&JU9EP;hlp|No{Py_*)^Gv*ju*(Mne*&bJTGg{->Y?=ZO!W! zy;#pSXU8Gk+`97;|Cn2R_T$##vmIl?rYUDYfs#@sD4KJ}LIuWN3xXZUcy6s2x{WFS=eU?+T; z8oPMJZ?AD!l)JwEh^d{u?Z{&q4~>y-@6N=by-?%&4LtFJ z?t9Ft;nPf1PCZdM@$`sOx0{-<+$_ACTKVJ&7cX&iD#Rf{GmNfcWXEkGC{M|6P4p4yA#yModr8VIV~rU zCMd_vVoy*`JyCt!VxI}>vQZGdH*v`tsG~BXJ>CNxSpFiN}Izq zl4SVNWI%CHguKm%q2uE*`_YQcQ(zR*x<)7RO{#*E+G zdcLLH;$-O2D;^{b%y$cygZacr$5wELUUISeY+ofhTZz9*9geyL$6KH2)}Q@tw6l|a zb_b*CEqAb!g$#O?P=I7g?oQ}Mx8eOc$7Y$2x3ina>xU(8vnO1*DqOg;voF8T-oH6; zSD(BCKC?FQLi*ag-cy@z7zMw*l|TDC+*|dtx2i1f@0RN?v&;4B{=TeUt#0m?*NgQ( z-n@TP6&H`o>#NzHtMwlr*Q>|7+5Ph0i!{HhTP9tPf{jZtmvG z_4(`1et}IRNO$$=D+dD%-`)@?kb#ujgN9m#e$4&Whl^*xr5Q zPR-A6>-)PeW%VAn%KYQv)irM5Gn`tHcAak;(7NUA{bK!aj!gx=b1ZJ@Sl~u{HNr%*>*dAe9d2&t49z|+9`0witHocJi@W4u z>yByix!6(ZJp8$a3&W@J`8)da4ZSOHbV_)L0C#Esuu)5MgM8k+LpH~h&wfx~FF(#n zWXgDtx>X+GZrE?a6UN`90E`p(@x6Rg|MM>76xWdl-t4-Le)Dp?kUz|P*YbO)U3cAc zFPGK)>T337zFx8u@+skOo8+SV@dvlfRx2HOE4i`KbqCkO_-8UkveUiA;N-g>J=ynX zIKFZ4eQ?9{AwK8I{_*Z={;-(c&Tkg8%lYM}|8IKokl}reHpLU__*Rb%zJ2}OWBNIF zoO|f@`^FRwOfL;mjg^fwa;aB{*G5Ux18~+)4W@ZRrYyzOf$~kQ&GEFy>C(Us!SAZ+`GBwM0gaQz5DzQE?Seh z<2N0Tx^&NZKJn)3ud@%2x0kck-RuHSv%enJ^UH^`&-}rY6<0%ikl{znKhSeKqs!&~ zrI#@o>DbdZpKg=+f4|1+$5-FywEhjISfakoi?I2oP`l=Q+-S_p`Mqn#eT{hNq0(Kf z=eL)i=y9YC82#rC_tR&r>BK*$>Gg(<$soV@YjOF=_X#>gx2x41Iu~?~+!y}i_3HAE zvjZxsZbQY@a*bD?S+H)Gt_^E8J7C$Oud#(@AFuDP(f7PT($&PCJvzn@*N>P^yZf}< z*FO1*)vtd3M^kd5*kkDt zm+=TK<>1>JbA-;)n>)Nv@6ueM3m-7FY2cH)w{TpH_!>UD-*``EgSdkn?%n(O?$>DSC#-VA&suFZ@lHH9J%qv9kyEWD1BT`Jcsy+XpDmR z1BW60FZaKb0;79<`So{q(oFIH(qJ*qebL$*%{d(y>`is<(Q{1Q*{Da(LjA%v#Gz5~ zNJ*OJ@H3n6WOn^0Tl#mkov({>;s0ir-)#oRK@~62DZ@a-x!jy%#ix=xy#<5J54b<~ zd{gbG+-t#4Td_0T< zDa4FjREQTw4Cie)o8$#_ds}y0Z-0al&&YX!lH4Qix0~=tdhS*K!7V0qt?Zs5&)3IA zgDP&a(Kz?#0*%7i!@D#r)>{%}rB`-C6i`cDBd8-BEzA@(BwF4+d8M z6cvaMo>S?ML++{c<3Zzw%#-O4L;R`qhY|l&>fL%~+(D<(?{>eQP``HoPG-K_+USIYPpIE5d_1B4IKZE*dvXUW#{ZLbAn&)FPQM@hPp3aTA5Ydke)K$@{eFBn zoqpGUPS!fE_nb_-+d=os$<$+E8}6;ssdrDt)2a8b0Vf-HoL_i4>$y<;WNpvck+>)S z6i(-!*F2QWA@4+&W#6&Or!9GZm7NoNqB`H8V!V}3q(081oksm>weOp6K&!>QbEmik zSTT-3r)f4gJg3#~)SuA){kKcp&31|lv%loHzwHzyyEY9QfKH`9Zpb-}ez$t`G}9E` zkK{a1m}lELad+fd(_u~&dsP_a#Qz9|IDDcz5^dvdNz`Dc=||5wx|vXhJlzhRQ(R0$ zYGCkAOOFgLBT^GCmkrLo{8ZLXTfZ@8>kN+}GWHHMw}i|7{^m>M@ihJUrCVFf^=+K~ z{~uq0v@-tzU1&$#`tRK3H}2Kb^cPfr$KH)6jxQKe@NK=(4~*{9(I*(cU&>fF;Gxfk z20l^K`jt%VV7UbZjQ;UK!Vl-2%78eH7oS#c>*xut3qPezN8t76)0Y&d-cDZ9j_byS zA8>j2I`5*S-EPO{$nP1snw;#?(EoPPFz00QGcJBz$IB0VZuyA|jJcxV&7HI)zWwhW zzMj6&y%OXQ<(j7UNZLW`!$zg4W>loPhj@vU-tBeI=2X`-dcops*%|B z1J-%hqu{g!@0%ffe#vh6uiw{_TR|(UiT!p!pXB#{ZtniT3WoG!d)%z>`}@O5%pQ`A z7ONxfYvcay((lTME5rQ`gQw~kWA@oXKZofyJY+Q4It}Ol;8?Jn-ACXkN4c|pp|voMeJUY0}UYiV5$ncU#=GSe>`BX z)9Usb8=qF|oB6|;-=SQdbHl>VUUX<@PTBapG>=e#4k|06Y@-(qVA z_q1;8?{+G8Y&@w8?&rWpv&HQdwu#&z7~vj!nqi;)dzRh5I6lK8MmGabsVnG*6Y>U50dt=kV|6*(lV1~-(6DH z^YzC^w=D&2b)7yK;!riBR@f1Z5!YK~o@dfIJZtRPWcOJz++A}-iZ%@IuJ3Os~Qgt6yQ>0lifvk4+4fTh%>h6-;^Dtz) zQ+1ZNZf`xFrEUnTf)(sj#cX!@*I)CCB~Fj#X-ze9V7x`cqy_+ohu5we zZm1MP%1*ozbfP=7b?#0-+?Pup>>#REUl!}@)%nY=yF^ z-tOpDWsln@^s3+p`pz$}erKQGxvMQ6p&J4>)otGCwL4pjZYho%xV^_q4YpsyyS!at z4?PYa^1Ww6AFgkh&F(L7R+8M1muP4|z`s9~Ku+q~p<&-Ot$H{1^I<*b>4(uJ-tAU9 zx41crTkro1Pcv`m-eUawl+&6Hf_`6fvSHsf@y5Wn*}_%lw|76n$qpvR!)czZD?InS zQK94F{(OQp8yY_0c@th+pP&Lq5b$g&KAo;{f&m(5`QQ#plXu{!C>xxzKR@BHw`0|9 z_GcN_%Mrc~dNR(}^bO?Se)$sp1cT}}TQMBP<+jlKvpfB5cR*`8)6!mEuWlF4n=hMR zFFxbYhIgygHP7+LJ@?Ew^u*kDPJtyk(w#n`rRZD-~jrVEYoYxcb)~p)eLl!r85B@|vZLYlz*?>&`aps=$rpz7V$;hYe z96b#uEOHPrx%LkEt}FRk&hFs0((QP_%P!vNbGmj|fMYyDjr~D@c$>e&4mEVeFls-+ zBzKrvoFwz7bnrb1Z~Hle_EfGMoKf%*yisn_EvI9%Qf7Q8B|p#d#L<7K)I7`pm|AV> z(XJm|VDAQm#`Y(JW-iyJ7GsTXoXh#`?B9zuXL#ciE!#Mos>GnO<9mg_K;Wf$R-*aiICLZR4){TDAJ+ATM>@$Xd9ZL|7Jo7GhiTBwe2Mc{zuWrN| z_r^B8F#{T8jZ5psUEgo@6~JBOX&a|rFYd1Am>K?nqd46J*y{1&?h&H{1{xpGaI=6s z!Ek%{H@&xHqvEWj`2%Kh@mxtp*Mq9G_qN_my;|IHIv9t-ev2tXbZy;an!X!g%A0rh zH&iY>l^;KRz`RJfH5MP|mtp+RRdDnE+-$58M^5^aA^9M=W{Y#MIIKpdSF4J*`9*4w zi;wJ9wC66V3-_cDn{Y_a9S--wQE)i)b;*mc%ep;E-RVy{hOLvg-EYzt4ykizF3EJF zzZ72{um6}Mc=ZidmX)hIPSJqQif zu7bH{(`V)rjVx>FDmq*JL>-mCr80JX+jaEs(P&1BXV}!@f;bX3)UF za?39p6OVhknT(45X4f{KKg@kV<(qo^cs>7$ao)W;N1eMXxH*i8NhST#_;CMbEmg}= zEM}kK=viN}*>Yn-^`G$=-R*~v7*zG5Cf+`<5K(cw+#aiJbC3>GJZYEG$J_1(+jnz| z`+J8& zLyg(ck;5ylUpC<8*goM@dW1mfKqa$Ie5>zpWdElX`XjaO7&5BbKdtHUaK;WVI#)}c zHtjqAK8^eCsd9dKxj=Z&O+@0Q39oRs@bY-{E#_h9Rkc636t6hN?mjKx<`(RP`o>v> zt|D8}flLxJ2eCPV_~wXjJR8RvKjGYG?!d)TPE3X~{^<_6_a7DU6M6A-Fz&lG?wc0w zB4kTtYiu18mRl^hwN?%}k3LNKNLz8hGQYsF-`c<7r(KS%p8tr8zazrcK)^W$Dmo9( z_b%Ys6@?C$xMnj=jP|__~6M5 z<(rfA>AHt1t`uvyb^z zjz>4sg-JAEGqytScE?=ek^5c`*;E&pgu&t$EYLyFC(NI0&G95}G&>DC@_R*x3@S03 ziM4WEWBc!a^OGx^-uLG{P4dka$lGVxa;;-n6~T|E>^k7wt>Za`DVv^WRq>;Yn5cYo5L!`(B0uZajG4y}oMFdN?K0iMaaHw-u z1v)3zit$Ey_$qyLf`W1A`g(~)m$!)hVi z3(oJ|CX(HQ$_uqI7ni$FRG_AaHceG(gP7C|9SM_6GVgubOImeX71b$@JwxXUweu(y z-ZxIaP+?`um9>73388o_RC=KbzJGvk@Q6iO_@>!{TMJ(CixoQupdvRRQl#(I?mJ)y z2fs2#SC@$Qe#FO|`6%?UG~a2GFC^hf30EEsxivd;WaBdP@n0o7XuFS!x%c<$)kh57 z_!Kq2^u(1%^yN3cj}kskct~kkV=7?(GWT~EE;yUj{-iAs&n)ZE+-N<&V|*H0y;c`! z8onIEyZE>fDE&EZpyNZ{wAjwRccgRfzXo}z!9$4c(`t!zV^?T;AJugM-CZX6k4Az` zU&i9Q7@b%51=u$@il5FK-l^QjY7bgcgmnQM5$jz(GI!lOjr$%tl?M4Sp^Wtc*s6fF zpmgl8Nb-rQ#gF%UvHU#s2fWtt<34*`Sh02E^-aR`{xgugb+G!-eNUL>v+v;&e?N`_2SBU1SDMh$ozjGsZk0}8lSx@?N|~NoO{3&o1YS}O%;)%HpgTDns@flVf5 zttk^&skAH;oWMdckTswZ>qkJ#4oVYRx>uUe(w))?Y%?hvO-X1K)k-I@tW->BbCpV$ zDNe+NVj?_h`Cu)zO%x7*wuD}3LQ8i_6I!}en$XgX(u9_-l_s=wrF5C#1eSQr#_=SD zMIx32V-86v%q_%ForX;j8PELd6*cz2q4I zt@=S}LQD5b6I!}cn$Xg%(g|!-T4ypYu+OCIlulrqN!e)11lF09m8K-zx>8ER zB@;taSg2Uh*htzzVGn3a=#(b3bgML>r5mN|3|%QrXmgiJ!#5L)Q&^~2(O65`0nn=L zl_s=wr*s0FOv+kQCa}t+EHx$kHL)&*g^Cr8)wX>DWU)hL=w4~Ut=cKwW$0FELYuo$ zI)Qa2Wu+us+A_Rtx_qS zKsZ`rR0@kkED6S9TkQZ@tW<{Xl_s=CbxOAin@q}D=>)>jlHwBxM@z&TP{rWkX!SX_ zst<0J|6Nu6%p*Ej0l~qFG65w~^ri$3W4~4F9On-meeAJg^Ck2NZLVR4`@s1lqR%vt8@aJOv+kQ5?V!-(u9^SmBwu$#;34Q zaYjKec}9f;pe?Can$Xgn(u9_7l_s=wqcowVYo!S-T`8SFcw17p6c#GZ=;|cTsBi$Z zh4xAlTDns@fo&#bttknuqDtum!V?oiQ&^~2(b#UQ9UzP2p~7Bar?3UIW;IF^TDn%6 z(9)ICgqALqh9@S5rm#@4qOsZ5H9!_CnxT8839Tia(g|!cDH~0hz&ew%(v*a@$Wm!I zYGQl}3l%FG>up^FWU=xYx>uUeTGA;^Xz502LQB_56I!}bI)QNL#NredDpoXB+iC~M zVvQB{nUtN0QX0;ln3O;`dm`R|Dh3Z{ugf`mUFZS+H=R9?=@H%b#)x>h=Yl}h2)iSa4K$FH}P4H*$+vD+x@ zGbuZz39X^6(u9_7lqR%vtu&#fE2Rl7T`CRlPb!qcLd6*cz2q4c4uH0#UTH#0cS;jl zx>dT#(6!QpHg}~op`}ZuF@Q*gQdp>1(b#S48X$|kLSdgt*(sgCHj}c+$ZE|^Xsc8y zoj~|}VqFRg6)PIsZM6erv33f3g`L6{(3;gKoxnPiveJ|ZgfAxsq_9x2qOsXFV1O)E zAVc>`6I$~-r4!g@QZ|~B&?>5xCbV>=G@+$SrQzR6g;H3kSkYK->lz@74U(aIr3tMi zoze+xGbtNQNoW<-N)uYTQku}xrP6T!q(UhyRGd*zNuCkVsvne2V4q3ZY03n)nUsyD zB(z1=N)uYTQW}1u7@t7+gd$F1p<*Dbw?rQACVD{MAjq7@C@M!vqsJ()ht#U zTcs1&WK!0elF%xul!l`yCM6J#qKH#iBw|T07TZM(ki|-8=w4|;Yhag=wVH*{W@(g8 zV4X=>X-YVcVrBy2Jc@V&su(<+$9Bt%Hs?;Zp{MxYm~fwYM90!2JhlR2Hwx+CVg`f_ zc}_)*&2!sjjv%9pDR6+)wo$Js2`$|zO=#&>X+ldkN)uYTRyu)ICS|E9;dV-eQdp=s zqhOFcBcL^8P&$EqCS|8739X_wBWpAZq0Le&O=#&#X+levO2Yw_N~W+-v7)h;w1dK4 zVFzdnYn4u5qtZH)sZyHI>MWIp^C(88uu!q0vD?-)Ko$oWg?%Pvr!=88s#TiM(v8xD zmadg1v~;C(0x_bB@hL1+tY~bv)eexw$}8*@c9~4A(uCI3MrlGz*Gdywx>7oU@Il4U z6c#F0G&b962gqVYGjy*sp*5;gn$Xg%(u9_7lqR%vtu&#fE2R?%A5OLpr!M3I~NfpjFu^oxoP5O(s*VG@;d5DGhH~j3Ts2G2TU+ z;Xx-@VUdVMIu_fy2FT*QlA(L039Tia(yhWqVXY8euoOjTb(KoPGnS+qP{rWk88txAkY6`f>(1EjXLy{06z zbf+|-rCX&F*kn@Hnv&2es+1vjld@Affo&#bqbUik`MCFDk%X46lujUgU&)oiLd6+ft>hU2ZApXD z3G7wcDQq+On~bd1EQGemN@+q%mrCO~AjYS#P_d%1+152c7O!lE?v*CAmUK!du+5}w zG$o-`R4Ywr=}KurOP5N+2bKz@uu!q0vEJ4-Ko%P$L-$G(T1z^m2`$|!oxmoOveuLd zEGrc!5ZCbYJ;N++;UX`RVbDGfhTEFrY|OQqpQO41FeV({=I z>n$yH&ak zpF@PXJT`If+x(uBCbI`k9`OeMWR><}ji_Gqmjw=x+JwEPB(!v=G@+$ir4!hwv{qPU z@|Q}(4;DjHSg1IoV30f`pfzt$n$Xg{(u9`olqR%vt2Cjd8>I;?T`Ns!=}PGY!bz6; zrm#?PMprL+Muh{QEwopf(9)gKgqCiVCbV>;bOP&4%1Tov5H7aVBZY;EGrBs-GXh$h z2Birt-78IK=}zecwwaWTrX;kAYNZJ+T`8SFc;ZsG6c#GZ=xQa;2xvj-Vq zQfWBlk~D>diWQC3wypuP*boZ)Ov+B_1h$!!jiw~D=GRISTDnpi{<&C3Xp^F$qVe$0 z6(_Jz478;HdAxt_f%DG;q<=0dM?jl-P&$EqCS|8739X_=X+lfaN)uYTQX2lbSe!uk z=ORvFk%%S1SZo(DKo&cR!akF-Q#yfdCS{{36If?bR+h9t|`9dyIf?xfjtb52%O;4tmHJ0UdNNqJ!=c9dwV_?>s_CBFfMKL%KF1 zxau*3q97Vd;UcQwy;oa}G(tu6ivL0Q&^~2(b#PpFhCYZE`@z2Wv6rk+f2$v zQzo#^q^vY$0^zlaQ7J4`tY~aAm4Yl*Dns{5C$P(;Y&9j}*40zGQCMeER!S3EMWxbk zQN{Qa7AjUWHj;J#v}${$6WFP=&17nnPGFr$S!v1y!u1rRQdp=sqpOxYBcQFwpfsVS zd!-32-6>6I=~n3kHY%+%nJT5>Sc&n3R)489oC`^s!a~K0#!Au-3VVf}!WPh$+bCUU z=t^n0kx~?))dW7?PjDj@C$LZqw5=fLLzK|uol6g#a~U9=ODSknI4JA^Z9$#VgqCiU zCbV>|G@+#{rQt}5b%Zu4nn_zM#VRfmu}H^aTh{U@c6=VkGaH}BuvKU_6!5f$-$ zqRfs3ZYaQEp0m;+9M%~S&gBefhydqa#$Mh(U(q z32zL->uir;tbx4$cZP z9E=qZ&cF(2hyX`W1rZL03aA$#2&XVb9fELjQqSUSc{yIBg~7C?moNB|(NGE@BQrIJhFna7IPUJ4A%j9wI9U=QadcuOK2E zoDfJHf)KL`!XX4fhVuquIzia(A7t1>9}xDt2ZRmlkrjlk<1w8e>;jKD1Yz@bl;OqM zHy>Z2J;H|OfUvnZAZ#g)=>%bKZcHZ#+iYVxL3j}lS4a@{o(37VnFfR{qX8kJ<}(a} zuuU__u%|MhUVtEMWDF!WB?g48egX0QKU7u__SZ#L5VpSs8MdTFRuJ}w1sS$~1%y3a z0bx^CK-g6kQ56xk3&nJ0MA*3!WrDExB*?HE$PHFw1lTkYMA!fk5H<-!nIJ6v4>GLm z4+yK>V-7`alwp;0V6h51AS`%}IRs((ZA>SK(WHwkBg(3X$_TJtASw}r(0-61#vTyD=>d&(6bTxl z2oc6WBA6Hu;)XGUAcXsZ43WKdlPEZ?BFQ^ez3F@1eu8v?3)GNYHIB#eph`ZywtP<3fQPv8=jDD_3w1WB~$~r-fpvocp4mUzcoINkM-tc;*32kQd+?bot(&)~S zCbV>;G@+$&3&h-nmadd0v~;O7rq)GM3JVoy6bzDQR5$?Il6s{HE!`_!Jf@Ry20ox-fc1^Ap%-Qg)g$fo&#bqbchQT`8SFOuCCDDJ)d1 zXlyezfh&F}lx;=^pJhuUyqDNy zgtkDqG?9jDC^&(bc9s-{Vj!!l%+InRyPt9Qz`gqg$oDMKJ}Mj(_JFn^cwf;ZLQBIX z+mbb!h0tcHl};e4E(HKFKV+l*=+~6+1O6 zfo&!wT-{g!LaPY=Z=?w=4W~HL@Dl|m5VPCRz_)TUAhQ59OgCMZX zem7sP&tIcL?|(uq@w5Ev>{tAmR%KtvYq(g?Z!bTgRq(Yse3kO{ak1+&ZXLA0uaDJS zw;%8YyzABK4&MmHr*G%i`1+DP67LOHMqf3zs{~$4*OAP;b#PE+t4F7n908dCJ z2%j~J$pj(h6OswSC%%G=aUjn!4iwS}VjRfJ7zgr*aUhTIO{jnv5%MxdgaV5=kVp7t zQb717Qb33Ud6Kaqj~E*YSrG>cSq0(iIzh%LQAk%rGz1CaKp~?b#*4g+@gk2HFY*Yn zp^!lk<3(PEI8XqB7%%cNe2OC=#*4fRpU()0@uHAU5aUHbCW!GOFJrvOBgTt7V!X&B z#*0EaL5vrL9EcKm#CVZMj2DF*f*3Cf=>*|$@gQToD6oPUFY+?Pfg*^A@ggr{yeMQ9 z#CVaHF4nGTsu_n*rgRpLlL|iEd z1mP^MAY;_Yvy3`JYq~L zXc5GiR7fX?F)1%Y(8&WFj}ns!!citc##fb)K@eh7Uc`8nM>yRhCKH6W`yj(H8Zn0; z#;|-|#H&2Ou?_(-hUH~AAt4~futH&i7{dxO#IQWVaR31^n&oBKV;|EALgXrtg0SB_ z$Qal1EaO@pF|HMI2x45z%dp=%=0IG_%NXJE2z!hJ!Y<%|uw6Hz2pIJWMF?Wl%gY$` z@`zC{j}Yq$B0-2;c@d*t9x>|W5u;uqgCIt|yo^z=kV61sT_LL=Z2gL|2pIngIR!EP z74!;1gv*N<{|XrdF%srwjD&@Bh=h5B4Lbp0Z%#mrj)fe87#;I6M#lmxh|w`GV{|N} z6U69PU=axmtRP0mybLS%142y9ix?;Kh;cHHuvR>>h=h3=BW59;AV$nW4nbJ;9CHX_ z>@1`c#MoKTCkU&0gN#u$&oYYU5f;q`#3-7VVa;nmSkW2~BWodtAjH!`20>W57-fPO zSqoVOF|y`mSj-k#L5!?<77;TK5UGe61TnJaSw_}8Lf9Z6#L2t}GxPy5#^z;=v4yOH z7-RD?#@IYUh%Ep?47PdMfN)x11u@v>Wem0j7Qr@;5Loko!L~puLO9LK7;Fm}1Tom= zWem1?#9*6847LRp;WUpJZ1af0Hjfx=^9X@84_ZMCws{$%X&x}@7Lo~K)XmEnbqnbb zVe_aK#Q2++G5+Qe<8L8{AjaQ<3=uYu7=QDK@i&hce+#lEB1G7{h>^HJ3SuPA%NU9C zs7KVzBgW(cD~K^UFGKt-WDvyYT*x4Z(K#<;bj~A2=RB$fF;2Jr9yTIbjME7mRN4dD znW0W;LQCUnMx6<4R9a^;RZ0_Do#+=)C&F%u6Idt)vI+*tGb$VaZ9;UnSQ4S7JEaLN zjlgisoxmoO5?wf^B(#dquOpp6MAk%{!a~K0#(rDv09l;V%+QEjN1D(Y)hSJA={6&4 zGz+24f?G8fNN8!?zmX=iG;ZohBLt^7frVm4W4Emf!$QpWjB(Tk-#Bg_b)^%~Se3bq5bt>qJ1 z>no)REscRUS`R;7aRLj)ipECL4uDo|uQZ{hJEarYW>PkqlF%xul_s=wrE~%j%@gBO zSg1IotCl@z7lO_{(plM?GrqE13vBp!j0CbTr3i;+e&PjCVe%@c77 z3l%FGD@i*j#3OgBU_5+d!GzYXR%t>@HyK&2SqNxC9D^jP_n>LR$$qD^XDbTa`AMOtsR4RwuUVMx6)+ z3Qi#0P!XrFNW_w0EVhdnAd8R43=MY+^hv^gQZCD|HHUK-%}QXKNeSmKrX;kA;1Nce d(9&=dBaNOXn9wFIl}1ZT(oI-=_doFSe*vA2*wz35 literal 0 HcmV?d00001 diff --git a/ios/libs/spirv-cross/libspirv-cross-msl.a b/ios/libs/spirv-cross/libspirv-cross-msl.a new file mode 100644 index 0000000000000000000000000000000000000000..851e79503d3a71de2eb89ba015564739d5e338f0 GIT binary patch literal 1598024 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¬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

    |puK~T8_ox3K^;^yO=cVMI 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 literal 0 HcmV?d00001

    h2A>{I*!ejkVRyaY1+9LV%D3Xg~b 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

    • (args)...); + var.self = id; + return var; + } + + template + T &get(uint32_t id) + { + return variant_get(ir.ids[id]); + } + + template + T *maybe_get(uint32_t id) + { + if (ir.ids[id].get_type() == static_cast(T::type)) + return &get(id); + else + return nullptr; + } + + template + const T &get(uint32_t id) const + { + return variant_get(ir.ids[id]); + } + + template + const T *maybe_get(uint32_t id) const + { + if (ir.ids[id].get_type() == T::type) + return &get(id); + else + return nullptr; + } + + // This must be an ordered data structure so we always pick the same type aliases. + SmallVector global_struct_cache; + + bool types_are_logically_equivalent(const SPIRType &a, const SPIRType &b) const; + bool variable_storage_is_aliased(const SPIRVariable &v) const; +}; +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/include/spirv_cross/spirv_reflect.hpp b/ios/include/spirv_cross/spirv_reflect.hpp new file mode 100644 index 00000000..844d3f1e --- /dev/null +++ b/ios/include/spirv_cross/spirv_reflect.hpp @@ -0,0 +1,83 @@ +/* + * Copyright 2018-2020 Bradley Austin Davis + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SPIRV_CROSS_REFLECT_HPP +#define SPIRV_CROSS_REFLECT_HPP + +#include "spirv_glsl.hpp" +#include + +namespace simple_json +{ +class Stream; +} + +namespace SPIRV_CROSS_NAMESPACE +{ +class CompilerReflection : public CompilerGLSL +{ + using Parent = CompilerGLSL; + +public: + explicit CompilerReflection(std::vector spirv_) + : Parent(std::move(spirv_)) + { + options.vulkan_semantics = true; + } + + CompilerReflection(const uint32_t *ir_, size_t word_count) + : Parent(ir_, word_count) + { + options.vulkan_semantics = true; + } + + explicit CompilerReflection(const ParsedIR &ir_) + : CompilerGLSL(ir_) + { + options.vulkan_semantics = true; + } + + explicit CompilerReflection(ParsedIR &&ir_) + : CompilerGLSL(std::move(ir_)) + { + options.vulkan_semantics = true; + } + + void set_format(const std::string &format); + std::string compile() override; + +private: + static std::string execution_model_to_str(spv::ExecutionModel model); + + void emit_entry_points(); + void emit_types(); + void emit_resources(); + void emit_specialization_constants(); + + void emit_type(const SPIRType &type, bool &emitted_open_tag); + void emit_type_member(const SPIRType &type, uint32_t index); + void emit_type_member_qualifiers(const SPIRType &type, uint32_t index); + void emit_type_array(const SPIRType &type); + void emit_resources(const char *tag, const SmallVector &resources); + + std::string to_member_name(const SPIRType &type, uint32_t index) const; + + std::shared_ptr json_stream; +}; + +} // namespace SPIRV_CROSS_NAMESPACE + +#endif diff --git a/ios/libs/glslang/libOGLCompiler.a b/ios/libs/glslang/libOGLCompiler.a new file mode 100644 index 0000000000000000000000000000000000000000..66381014693bc07cc845f7458d2a03ad7170bfa3 GIT binary patch literal 2344 zcmai0O>7fK82y}tg2G=*A^|E=m$pc`IPBUcCK9QV*5*et#ELBh71DTP57=Vt1;?NW zI9R=u1BW2x&;t?&Dz)L%1HDyMTJ_$lsyHEmsvdf2duT2oLU`Zqti2vcGSbeQH}Cu2 z&VIY&@xfzmvt0dT@FVAN!nV528MBk=blS0#mUYB-AOx~w+heH|SSPwPD8y*t{OL^g zxK)^*DP}W-Ho_g66(f3IV_IWTV^iZ-Kp{RqlfIYtyymLf4SA|jk@Hz1vo6sZ1>>L(>*9=$j|EjM z4R+l!N{xDWN}^w1{PSuD5vme&13c)%W$}P$Kd#%p>eDy6w$?1pL2GKh6=S}9KcEmT zIp4xSHzA7Ib6j|%U5WUyy^^6d?+}YC|nZk92c?(gqZdhl8_0=n?)>zN)sx}J!?r!3D2+r^N?s%es zo&GD@2Yv?y9s>Tbh3F;Bwqu<4X&g1{q*7gqR z`Dgt@4_9waEv-!d{OxkTcpSYq-#6;{jA&g?3x1pVP`EZc2m8jbo-haN8s5kQ54_Mu zPUumB7jyPN?&AOb^bp_vFxSU?CZ6+i5qBRoGj-(C1-!>WqTD&)E~0o*a~rr5d_;2# zh`k%%r}=Pz6D#oGxW9nx^90Coe`x+&fD_*V@&4jp13CVl))#>se@FA%0Z!nZ^EVj3 z0OUOW&N%O6pywumoOe`n8~7ghh~^&ycY~vT{<`4BIDs7gKI1D`|1Ml%`1j4=i zH*@Tha4()T_@B(NAHuygZtxiRZd|wY4ZZ|258DB)|Dq=z09oIrW4>TLvYwxyYst^} z(BJ}MROfM&Uo`krgMVu9Zw$ZQljz8FK^$*NSD23idV2jPsqAwcJ!}ABEcs9KMAg}UrM*- cHM99M1>vNMy_2L`^(#rgPx!s#_q?xO0~yxW>;M1& literal 0 HcmV?d00001 diff --git a/ios/libs/glslang/libOSDependent.a b/ios/libs/glslang/libOSDependent.a new file mode 100644 index 0000000000000000000000000000000000000000..f094128e9be95acb27e4c44d33a5c26c1769c7d9 GIT binary patch literal 3272 zcmb7GO>7%Q6dtbwNz+m)Q7Du`x3ra7fy3HyV-AEmjolx~NlNTifK(=%-AQa^{eyR1 zQd|k6A_#~>EO9_wpa-NH6~uu92P8tnp$8-ygsL7}sRxS+2}C7oR8zj$ovrOHiN%v< zzWLs~_hx3_?C#s~yjs-KFZAyWJ{wZxmIQ~C!AK+$R0d^vpAy7`GaXcvp>SB1!wNcE zrur!zNWMH4iyxGe6O*ZUj6e?a4syju$ddwx1)dOC5qMVM1%cNEu7fZ4SI{VZWjr!# zn1-604Gtb+)*&N5ts05EHWxqHIU7Eb%d9m$k)-fXC6dQgqr~Dzz3!M#cFZRg+PT6$ zm>euJh8Rb3I-9>I#t;lf3?r}IweTzwnPdi2O}6SOLJC5R!X{TLq|!yE>M_+)Jx2`% zVH7K63u7#sFP<9BmvR;>ny@0?e75J-89Tk3&rl>ROs4wtrkO7lH8zk(B82?(_iz7f zAOx9ky8D1r5;_?T@)#P=)vCg6Ar*m3!nPMW-grDNlv-@wa>fo%#a~LbxI0=9{yZKJ z8SQcI8R;Pv*M=jd)27*`pfom;8fhuqeMDO-;%^&!kA!#`OUvs_*if2C93N{rxchSb z`mnFHgi+6X&>g!3P?k82`pm9wj)u^zqua7p; z_w%`EjrjIo{&e}(Z+xWkGmq0OkJfHZ9H?Qv>XM&chHmqnGi0S%_SKrBq*MT*@0>B(=<`Jz=gw@u#rMPGa~x?sk45OJ*TmepGxQdo{o-Eu@V4LAcjGNWQq3~X zxh(dK81S+EfSXqzPcki^Eo2NPzn-zua_rdHQ93$tY&;d8Ov*Z&!Cls6D=(Xj$(r~g z4Uo5S@17zgPyyn4Bu+axJP&*vdJBlVlqfhjYyh`HpB8#u=%;|#Tp$K~m=GiC;ECse z_yz^|zk|yBr)wZ2q4M@OJ^Z4)jX9_VoCdq#vY68tmx^ZE0F?-uh{1fLQ7wBWxA&hyV@ zFOd7Y@-7CP^LxXE=do>?yyM|%tlvJr=;60L_Ln?-+{3^0@Q*xv+QT<_*1O=DzwY5r zd+f^|{)WfCqaaBHBQa*FTH2`;5}91--kPLq(Go^6u~uQ!t*BYO8tEwBx|C;Y*LGd& zreLW3NqFm}Rg0>EW!G3VTSECkGbkVl?a--~Rdn?w%OnQHZx%@asM;LW(sOi1%@`gp zTFRjaobzfsbtW@rS{8Hc6xC52TCAlrnWd>YjTu<1UC(Vb)Q0Uk`vmrG;bomF{8t!T zZBWBFnH_M;4?$UWn&~>z2eNs+WWc%ogtH~JsCR73EHEuIlhInrS!T7A?L|AkUR~57Bg|OWZ+I`6GgLbd*Z$UrgUwzlE+W-In literal 0 HcmV?d00001 diff --git a/ios/libs/glslang/libSPIRV.a b/ios/libs/glslang/libSPIRV.a new file mode 100644 index 0000000000000000000000000000000000000000..68c4420129db3ce52941cdaa4f9daa6cf6f05d11 GIT binary patch literal 663464 zcmeFa4P2Dhl|O!G#+LzNUKCL<5!AeZX%dF_X|)a@2GpnlG%sy43@|!_2nzT@Od>+t zjMAhbwoPl=igvdPWc_W^NF(X)N_5*Ly4(JeY+rWwmljR89i{EAF;T|E%>R4t%gi$~ z&kU$ZlkUHMLJrS;J@?#m&pG$pb1!oiIGSo)pN^krxhpF(E%?upmzkZPpKr;`PD{(p zv>-!dTQW2Aa&pqrab>mn>nyf3E8pJDbc{)pLwl<_dVXRluZq z0{&FO4X8%tMs5-CujKbsS^ifAB7I20zn1X0EY~5w>m*!!npjVPZX z;VKEYO1MwLUr5NN$np}FOSoOazmo9(O8B0H^RE^4?w4@4ggp}eSi<=0M7fm`epSNX zOPB+hK60d*$6l1^ao51dn@WoGx z?_Q5wfX{wfz)cGU?3C$?BwQ}@y)yp= z+1?4+-qK=GuS0&1$nt*K&$nc~^AewA37?bjJJpO0|6v0AHrgS$Zn1#bB?3Mm;TI+B zmhdGBev3H=hT!Ga+^`ksWpkT9-Nq%V+gmxRwtcv`|+ zR*Q0W2_Kj67ZS2HGG9WEgx{0!-zB{5K2h#75+0K94GAaTFY+Id@QV_@A>o}5i2QB| z-;nUG2Sxg4CG3&#l!S{vBl4e-a7aR*gz2A^{YvPO@I?tvOE~LuqFj}PUy$&xB|IwO zuO&=;NR-c%@E!@*OZY_z|4Kr?gr#;-≠eC456dbCt-yNy01%@0PGZ!aWl9N_a%V zpGo+*L$otZ%A3^^?vQXu!kQXU?#mLsDB-Y#chrjf&q?T!@Rt%kE#OZiTw5o;&Fclct6spg4FXPU5b(T&|Jf+MH*OTrC*kKe ziSJ^v5N9UBdY-BE3bzHzfSlW|4l&76G4=@Q$tGyII0%+r)RV zgzrk2*ecR*mC!2TJrY(+=#y~pVNw3nPR3^baS}^@M8NO23HX>y|7)2(Lw*m*?@9^l z9v9`0e^J2Q+Xei*{7#hc$uEfXnhpU+Wc~Wji|@k{&V5vTFO_hwZ2yn#B7Lufr4oKY zwv+sr$UiRoKO?_?Bfq~V;lJ(><$f>m_|h)MypG8%Q^Gg9#P?l$1nlS(@W&EP{*w4! zFX2lP#y=s_AC&Nbgzd7OGxGbPCq=nl3E!4*qU`?-kI3(raP^nP_bZ?S;rV5m?w0U9 ziEp<2?vmw;pBCl6vs=Jj59Wvb|zyDRjY}xORB;MbU z-)2dte~|TFka&Mimh*g_vCQkt>}Q}0!L@q@td;3Ao)OsQH&i;m|e?hkUs)T70{;h<5+0RX16Xh33I9;YMk?lMv(?`D|%C*Yx|0ln*WcefV z`|C3Qfc$=3!u1l~D`A0zt7QGdvR(1ByRpHN<*2PKt6jO#+2m-bEvbuA%1Wg+Y;e}P9WBl= z3NOwq*`nXfVv9B>r()xlqRsC5+U1Sw);XINXK6C?d4{veVkxYtaW*#>yBzL@;;fSL zWfc~Cpz&a-b8b?cG6Qz`tM0P+_D%sZJY-k3}N>(kai7b-q2x7WwbF-_YZbd~V z`qK=+l3m>BayB^|T9(v1)-`LW9T-V&lXFAk7Uvj!6#$)k8f!P#J6AO|5`CN>&akPU zipI@NH9838ud8pacQmZCWZf-(scgiAa_ZYH*_CAtEzTy%FeT-3M)I~eYlzAqO}3Wm zbwu@5f;+?50?8G2OD39Lxse#QS}=K_P(I4g&{sK{fDQD6ez~k{AT4IY z(d2ei*SD56)H=68$LY~AD|_?CS}c+>P|{uF4kA(F4q+BSbzwtf+TGPUnGw@2>I67u znHsYtSMnq`g)q^UtePfA&H75`wwBFJe7zP_s=0-5wp;Qmi>ZLKRu);gQRuNilTn!> zyo5y(kx!@~NO%$Aiy|_8h}e>7dS!x)5xt#o{)%V^Oj_$~2w~HRGVW&LidsIWQSiyG zX>4eLk=GovkRFqT_ePv}j{`Q}w&KQm#bMD4l{apURY(W~LO%-PISTQW8y%ZAM=b>s z)Hv!LO)DW3YLw^*$12C&yc#Cv7^LE*HaBBoIAbtDuEL8<>6WsFDCp;cTIJ5Q+$xR1 zF1hYzvgpW8Z`^=siq@LDIk32C7*UGlxto{NH#%Bimd9)^KQM*>H`8LutPFBDU&i5d z4AfiE*bsAC0tK;qz=nv{uKrRW(FNVERqt%n>TE($2@Ft@^M8+H!I66R^}RAksOY5p2E3eqqD{h4fQZOX>5qze!gs8 zpZv%z+u&Fih2{mSv$6+QETcVFxGX7IUB8MlO6(;i)s@1S4#PO2jfiD^C5=R`!7FJc zz@$O04_^gW)vRWbTva=oHFO2-MC0=-X(}fBji*6(v(O;=>{#G#jwMx)Eo6Pv+JaJ1 zvxUyl&$haoV+wTSS8T4{=xC0j)R3>N6e$*jvn0K4x@l#(`yM2RWqwKGyal=MOle4TM-(FE@ zM|Ms<|XcEp|6VHFxNsEcYO&>;{N# zYGBotl9KuoSj18uD3_7l?s7D{>@B2S`Ox!a$_GLb;o~S+vbjNQ!#EAHK<~{BjZL*s z!nK?lgo3k)lc9){ff7Q=zy};!%ee`AfncQq{%vn*46R7?DPx5 zUtqU?1QdX)i?}t`lowpdl=Dh4ro13>$yjnFYX=sKS}A-9h?P>nSIVD!p?sud`Y2Y$ zM>^oESqiI`1;l)QrO;fEn_2b(?&VnCNSeU?5iq@08^MEmRRZtNXN({AOnww>`lp`B zkH;9VZYFES8br3eB1fZVvavvvg%#bjP?a=#CZwX~APubtZ8R!G#@=`oPR`XR9GuL3 zJO+N{D&%7`gsWjdH)dO%jnVHK#(*xMf3b`pcST;1HBo*{#*`I;Y^kY~4SP55>cs!Y zaWq#oJ7cU7H`F)gCx`DkG^C6w7-R)q`fKMN?PBV$d~LWtTEwr0<~Z^WtO$A1t&PK= z^`KcK6}dzx{EM|r>ME?kX#!=&Tqd$YaGErg@~}*-S2sI$Gb}L*J-t zM^@0Cln|D<%C%GX(IP%BnvB=-_ZX7lQYtCgQfbHP)%sMjh4XB!yWUy7c`d~uMS9Ola++HkYNX3g`eMda zFW0@H8mCSa^kmPYD5iR+I9a@$M)Gjr3e-wg)zn`$;`z-^=laIAYfHA#gt;4=IWc%@ zt-DFaI9(1hyz0irW}5JvwfLpX0_WX^YQ!0|z$IC71x*%U)|%GVH*S?@!k2@Nbz?OS zZr3{8^;c4PGfu8W&%)b!IX&a7`tmCU&af}1r@#sKWmO7CFT@*JhS`gZGKge+6w~NE z?lum0k`f;X2PoNb_zH>zZrQECUW2;J+30XLl`TV>&}8sCY%5ub&k&yeps*xucbRBG z0^{G-Z6oL_`EJM?oYw zO5IlVd4y~y(RevJ(h@PpZf{21QHvew6G0SZtEz#NhEj+wMny~JMnnYL*ES)>1rkYy zFiQ-_*Mya~K&mLR0byS>u0^1;)3G6nff244a>iFng{nwoVfEBBZfwPQ6%O^+H8^W& z64cCwjlG&^w!AtM|3@JU##s$Q1r8f3?UZ-_ayJz~2|Ad{v)^Bdb9$8szik-3(f>wA ztsSxI_C_9&8)dY-M{A>?2t`HNDW2Y_(>=dIFuw6=!teImvS=_L>3IAo; z8=LG1F>B>qxncQ+yquDf8iaT*+oC;0%fd(zD{QB@TSpBJBJIsMigPy9IHMuUL&T)H zCvh&TvAGLhYn1@<_0&YXkYJawL6;D z;lw)6zEqT=>Rd+Q7xI7dc?+xolu>7HJVTthiBaHm8Y_qns26Ws310Zqj7pxWOH1pr zF%COVSLEkXm!IVeKF~}miPjiXS{FW{Tf`Ltb(JM}Erpi6rd{c4l8b_<4_4XQgjfTj ze%UIK&nr0_=(OMNUR!p*!_nMC3*OyqU)$KU)zMU|l^i7{xjYP@xygbMHW6yTFVax3 zfY|t3a@FKws`(`oI&HT$i4Z$nq)=^?kdc~05f;E9-(Ci3MD_zp<3H_OYX=;-C!)Pp z5wK>!^$Hurk3@ znTwq@jR+o*Ve%0y1#**5nS1EqFK}$!=)}z_t$Ys96HJ#WMZ?CHCfRs;&D zT;F1^MR+~}nfVlPovH0x$ed`iO1V*HbsY8<=a|@I(Nhqp!J}HC7GmpEn((I4PW6z=*r5= zY>!u3qXcyDt|8aUm1}}hMqN4y+%t+O5qa$*yofX}WS`3DACJdPwWQ4OaoNM7(w0nn z1FXEuql+@YE3d4!GQ{~6&RlmxxzkZgYHKCMjd5Ejw+Q~f^;ll~_G7_X8Dv(rWD9m2 zG{qLwsd3?d&A0(1b|!o!Et4cbP!d_TGWbo%jX^Mw7AJ+33*tHzJy6ru#1mH8$F?}jiFhN2-qJgSWANc>Mkk8zyKT{X=i zV?%=OI5&q~`LyJ-Yfg^jgAt%gWr~h8S;H_o4K-Om~1e2)!??ufGSu zt%zz5MC!_An5*5VL_IMGU2)_%&Bo3qWPfJ4(v~jAr+=k=MDfXAX>-xs^jF+o6wm#Y zwx^`O(ivCWj?x2?Sv~@Xh{Y;ZrPxX1|53e8kxUv+hpTEUlolVl-$iTJN4zaCPG>^U zeGtWz#}fxyV?JojT@9tiZ{uB6FQHc0m9lu4VRrQxg&AB|)1YGCa3k)j+LUa3_nHS+ z6f|$#vbn`w-&}wv0{9&{zN5fb~poS%@8ZHeC-bZzSPWyP~lP z_nPS%UIlh3xFlQyw<(&Voi40DYB-;_YsrK55W89)C`(_JcI#$$LkqtGLOV7~ZWFa? z$C<9YLcXfH#FD?(-Gti~JPUUh;NK+{`12b`R%X2eS^5yFcb#?B5xu_(zJM5Vk+U}QNzwCzR9S3H#2MKI+$hpHK zp|~946b$rZ5#zx76u7{RN?8DPbvg*if)%(MjsacCkYx*%P41Ac^!mb*uMke{59b*e z3sHBmySWDLP-$Qi#{{WD`74}T`3nsqWFaztRU^a+cB(Y{Swt6DzQtH|y3gQPnm0Hd zP4X5U)zCWS^yrQI_rzdD;;|3Sd6&84oY8rqNv+ zt%Yo?A&nQ2Prr5qx(^7ARY{z$hG0rnN*Y?4S~+n!X>&@pIcuOn8XK^lo#OeC;0lh~ zvADm_uanog^-Bo~^H*N992rUA?0P5OjS0vQ9Rg<46mSnSryy3WPAgP~t0!J2S_ytH zShNB@$zJT)zogqaW2WOir)w;t2w z)j)tWY2HoKTS0kZc2+c&JDYKK5|l`hTotuw#0(OKma>o|#VqZN%4nLa=>nV=(j;Fn zm(idOv*ZyQkU|S^OSKNO@KQ=Bixn6#e%;lqgB*2O?r6Ptv$Lr+Do^o3n;Tl(8-%FW zop`CKu|XB?Zk^&L6M z`80oA{|4AV(LCS*&-3ct%H)%8*+|zY4LSHrFdKy#RAcp1>H*E5macDelMn@ z?UGd*NgM@n$j-c+0OED6dYCuhwI-p;E1c^#;8n(mcM3KAgy}gc33OCufnaI1()c7% zJ3%8%j~3%m9I|DyvN19|o`bk=9bsNT?;;4JCO`o6Pg@mIpE_(cR*k4txM2|JL{}q5 zS_hFcRzR$_xN$R1vjUCjnJl~<>^Ta{h`ybOY@c2)6$Y->D37oKbZx0|*41GIYfWQ) zy<=muQ!Cwc=F2MW3?5kmeth_0gz#fismCVcp{8t4Y_N+QO-=MToZhs{g5@C{N5~Uh zJjNq^tpNdI$qP)Yo(RFQHl6@k+}hyS;I2^wh$K{2rp8LS+u5>w4ZTsKvjXsv4Brf* zQ^bkYD-vL2(!sz*3!WYkB&tB~SWPui1fgmz@G@eAF&Mc#0(J2Eks5l?LK!DT5$X`Z z$~dgTQW4f1%oJ>)g(i3&9FN^yuBAeBvedMZ&R2NxU8t$X_eHEj^gT&9t}{;ACd4o-Qj}TWq04tM&0KS7sJ6 zv!Z2YOD$LkW6;^MqET~VARL=|=1v|at`WjtFE1Zf)N(j1O6qhr?UX6Jhq_g9zmQjr zG?Nf&AhYx;N|QI1?j(cdO7`sIXc|&`9ID1zQ{UK(qm9OmI`d~mOeA=j9+eJP6dK{B zzqyEDWX=gxEj)%L(#yp8VthqIPH_}#1#SdteMuot^au7c^hmtqC^E6cuL0Zx#W+S_ zWR#IdMM10sg+g!%rfScWf~o5C>d)%TloRG^G0v;OX=P>OIL~solvncbzlalDj*Ey; z(gr2x)NbAY6+IriCfI^v9K3`qAMzCjC#IX*aXKX_3TiRlyjx2p$tkN-hMuPtd)XL; z@(5v=tz4?ZKxiHx@??bY+j4mOIwVY+OO#-9Ft|`6B1&5vm5XC@{-B=VXHL%mHE>Np znY1ghYp><5ejOgtQZo5{NGpNE*m{BAN3v`XOE0#=&xrryUJ@=i)HlN9 zfhNtg0~G|m;eN*5$Pz^UxZ*3U?2j3CmI8Tm4;NkJUldR#@y86)z4-Hzj0;a?sx@Tb6F9QF<$a_mvHdpObaq0 zEn*~o%yz#V*Z(CK%l_Pk@xfm!3;2E_q;SCd66EIWoF?biCWQ19HWxb@8XL&*ySf3f zQFxgQv34SmDR>|+mOwV1O^H#74k&o!VaTmBwJrKaRh=jkk#ceHJgdTjvzklB+4g&!y<>Ck(g9$O?;9Q*8}M9vuzGB zpSbys&ZE19@F-m_Hz?@Yi85YZnG{i9kwz&|N%JlTZC3&nH9{H%Nlb^l!|-Q6oG9Dj zzqmETA91_PE%!&~xf$0y!jKP2IWqpFqk=ddUtwziDO&F5yZCW%|J8RgzOm>Jg>1>t zp~w{NP`JT4o}pZAALANH&|@S#y1{7>-x|!hojA4ty37`%U>W8T3zf#%8c91IniI3h zcc$^zaQFm_=XKr7Tz^;PX<8{XnH1?CwO8Z=baH%%TjP)NG0%_xMmyAq!xD&$h7l_v zOw{r>3$ZF=ypi~qZ8d+LP;Mqe3C-+x*Eb_nqc$fO*TwS zz?ct&JViX@CqmEZF=EXz96c<{V;Us$K|W<_wIm5>5#t~>8WkJeOeU7d!kG|Piy;26+x!-bwpNyWuNl`~anmYj>FbsX3HFM_Ag4As@Uq%w`G*;F%85S3 z1&Ba2Rb;t*O?wz59s`StpcS{q>D>*@u10MMBHGQeXxc5?u)$gD#v27u(M24TW>}hC z6MsK~g2sa3vmsO~Sj+FY(*RY}o~1zhh!}iJ@`Kl1PLl%O@LPD4sR$$mE&lnHK>oyT`U=rHEl@jtV&%>2i|MEOs zwDMv-FUYDxu-i>5yG$Km8rS=bsRJv#O=o4Pwjmem!> zBy1G}56i{2w{-B+uTbAi4}?X`84L$X4u37U64DB%JMs=k@X@-fn846C>)c9*@gqU* zY7e|~eD$5kmy+?x0?ds8iCg$5Ra}k_(E?Kn%muhf#(iNF09?U>I{sxD9X-#X2=i_SI zdU+LFr>=Uh0awu@P|DY2>Qt2*tH6Xb=g^;YAirSPrVDa6cvI3+5FDs%K}&`L?Hz*% zj6!lFQ7X{x^&%^4?<+)BwuU_Z6Hz-fTc|KP&5?O)A5G1uCddcR*#?9Y`24_8gqCT>fZ22nH z5_dfw2Gl26&N62cS}1A2pV!%p=V%=3nj;&^6@_r@h`+H3>f=IlV`Qm3ElP_WEe>)r zL>9}JSOrB;1ZE!(&#E#S|GYy=7@KFgD=RZC_%HHzkz&cr%*)A1OUuf$SaS-fd{sR8 z#~cmoDjO>{Zn?9O@qa(P_=oqeVaz}u^uLMtS!Kfi((r?S$@m#E@?UlT*XI+N8>tTd zsqe}7oqo)eh<^w}!vjL%ckx|Wa(`v;Tm5GKNw7Wo?Z!(+_FW*zCa^YDhM zq3x-57R(k!w!La(F@}Nm5MBqzT)icaR|s!!)$c{^@5vqq|Jw+Zg8!}!{>py~v{xW9 z!rNni5bY`YZ2TW1lO*I7v~5!Y#@ozgxM&XFVdItUJu4gBhW51oLcjFrx45vfFj%AK z9a%#nG86Mm_${wCF;}oy;5Yu~>c~WrDR%qvmSCup%&sP zT6?`=?In-V-Yw|tdfp)jG+_$6Q+|KRiBTbmu$hUUFKsZfQ6PEE6DD?J6JrTTTZJF` zcR>Ce1YC(Sy_9&F|NI@sSKnS~?!B}eCe1y|UQzFO9pJecvS=&@^v2g&j zeQKr&W2|9aUMi2iM0ruxTV(Tj89U@nK$)EnjSd^lo#r&#fWa_33u`M8;GAYKcN#!L8m~4z9qHzsHft~PQVnr+-JsEV6Z4_m zQ~2qk@;$fOdNT~>6B(C^USBkkZ8~9Kl}W7aHFN8h!`|!Iz%bfBna#S|W&1y$#JaR~ zetk4!@BooGS9mbPv16?pq!=j%PUDX&MaC3P66p;^{Uo+x|%3(ee{TO4k z{OMFz(n^h4(Tm0rjm~O54Rb(CjD^Yu`RFqdd}P4*!4qAVwl4;s6oX%iz&C}x?=}9Y zNAc9#EB_JvV*o$15Pl}!i2FPnZ2`{^f4IOO95>LLc%9=Qd6?5j;&N$wA^JMX+kda| zrQVC{4CvE{zD-C6pKhOszQC);;$D5nWbC^De#Jb7t|L>*=(+E(t}68162`BbSAWNR zr)Pj)uVcOdzuqqS^)to+wVu*3h790-8s)tx|2BA6;p)9l^6U)3vsF=fc81{D`!qcJ zL-4GucN%zx@T?|Xk7qB0@oZpipdH1RbFj{d)-yos3r6s)X-3~%$+IuZJZ+leKX&r+ zXd84C#uYhlRJmz+j^H`Y)eUgzC3?q_eFoD*>Gd$tk%}U z)DH1Qk)*E|IK_RzHaZ{jKEYjgc)cMpe!bzQtOWP`!;}_pi0`~Fj`=e1yV(%eIeix! zP)RV8pUZ2_x~BCWBCn-PJZ&=fnZsm`lFuQs8~D?_4MV>W>@htU zA-m_0>^?@ay99D`G2~}4M(S@33$?0V zqtEX*_}+cj;5$Fr=o@;d)aot1-s+z{yUqhB|j6eHqfTCnEiE zqme*@{CLAo939hCkhq(8AB{WQ`Wk=~5-*C(Qnq(C3Tk0ZSU>GLKHxaZCcraz1H zXOP~E^y=hb`rje_Iiw#$`hk>S`Z1&*LHe}GXn$5P{TE1o9qBblpLY#T_; zWt)0niwT{}y3$)+hhg(3dWZ*7F@9-J4wc&m%oEwYsW-7r>EP`^`G0pEer1hq!235- zGtx~qtCz9de?)!Qp5@x~^cgIN^VK|)_2s#kAKC8kJ~nW~Z|yx|N*;Zsp~yE>R|Gqn zY{25z>sEiYeCg``ri@49XOTVFIhj?GoSu%KSHP$7;N|(S(-#@y*Pp&^Uy737$ym=; zteXqx4By|n`m1lbjV#|_nAWNK?1$YL*4Li-kIs1Z1lo*4n`Ha%FvRgTo2yyZk)!iR z>Wr-N^rgvp-B_=Rj|o>Z+Kv01%{u=kHZ8$o>$Mx$Cdc!hz3tEM+Dm0=y@)zOKc0j< zG^3An-iLYpDbSwkU|&wosfuTn+mBw`MS9~MQ(PaV4aTv`{q3yl#ZzS4i@gBp-HRiIzL$*b z&^hR-(s{OlRKv{mH0MR2!8ub(pX*86sMo*_U4*<;`5AtHWhwR;lul)|d8NoZi*a8> zd(>vD(dJ7=xqR4kJ(FxckBRlC0xzmZc@Oyg{S3O7Xh(L&%rrKTn#g>qkFeepGxJp$ zA?trv$oFg>+PD19;B%lJ@h#aQ!@!^FdjA_`CPGI2x520S0hvYnL;34$$kEEYq zgTzfK9G#CeyJ7kWyWp>k!|z_uX*$yT(6-$WH{!rJzK`-f&HqvG9>(foqj}w?2S%x{ zcSmf!YW@^0hi6O}7AJELXszWx#v^f*H-g(C6%bm;) zdA`|R?#55wY}yY1mHW*G*CF5Y7unhJb1c)T-#9dg~?US5VD)rZ0(Z9))_ zt_?hoVzey^NpBu%=dIP-+Q3@F(=@aL*6}%&o^u{ z@Up0%J|$Sc6nI9f?}9C?>KAgJn=bk{u>N7th3G~2^u)9N-{bov*>0E%&QH$*2jZt^ znQsqpqXHjT|=uGpj9`m4M{6ni!|2#s56DrYKEwfu@VnN8(R`zNBZL) zFCV+WUtSGQdH&$f9eQlgdJaAWH^!d|nK$S8J$n`3^Zh_JWF5-5fiLCHlldo8Z39IA z;ZHH&1=K%x?cJlJbIC@YIr6fJRSp@KT1yi`c@{GMP!H&z`tNL00@e)C&5XGh>%rWo z@`$#nKVzG069pf0*#>?m8KKI|hfm=G=Z&~N>a*=Vf29L*)Ag%C>ku2wS7UHNmU$WL zj|ctcU>~PV?}6Mor;$5kcKojMUeGzUYkEw%Pc3Z?Zs;92io?d7lFCqh1O zogw5D@w}dVAfAsVr}V}=gnmBgF%KERE3k!zI)b*%Zn!OPce@If#wB#x45>dq0>4H& zd|o}xDFtS}XMjy^7+lzG`o;n;e1kovlx?JYX%9}cBEJaf3ay?{a@7l2k!ngBv4MZh zQ`n)?khi&zA-&JGm+!_;!cDe;9gy=RXLrE9slq;$c=9={orDC?+mz6!%8=|xfNboX zDfm{KcRP3&2KEftUx7Z#zSUknA3v(T>Z5IXu#elP>-X{8P0{c#q7 zbc0xbz2L#qs4M0yKo^u0-l1SVpZsMLW`s)6u@`Y3L;Ug!7yY zH=f~b1@)iONxNq$T!MK@&eA&V0lq!cS${K^o74DrI=*pqlc>exXUS5|#0BL{ zX@+WB$`IsnIRhKEEj=h_($fVkxtu{6y>YI_yzzX{NXfBM)C-Yg$m8v!jken~?cb(p zA7!-d&%ivL107%I^qJA;B3Vgzg5St5VnaK$_If}=@2%9IIZ%dZ=mLGrNT)K|JVisI zk?NyjDwT`uBkk5;A49k3_u;)cdLMy#x}Nnf)6NsV@8`I<#f<+8fbY7+cbzZ zo;rtZ+K+D|%70b1OEiQ(KA_7>!OIG-aJ$C~TTa<6INE`otFNDx4GNi>I2V0A9D@$& zkO8W{vFJejMszrR0k*la)1c#3{cwDTH25y(I0(DSHG%d2lSY@7-p~4XYUtsb!}_1# zhpMoTCH~+LYi`aeR(Swr3u26Ci26s}wBP$HhpK}- zX841@@+fdrIy+onA6;8CP&xtocJ$-Lej{2r>}C1-k7M7P+J|{vYS@)R{dw@a(Xczk z&f?Y&$Ets{%<3&;Ija34*bZcKRD%a;Usm+B_7EJ&M?gG9YaqQexCYW=@Rax3;2PMh zsXugGuzqQb`a{sOY7Nz+K9_Ik-vgdhJgx0Nd`)=B&XM*sjG;jNo~h%j-*bJieh2DD zQU9zL%_Uo5i{t;tUI(i~0qq!1rRl>2dLTjZ0AD095b+LOX^NFQX= z{tB|2_A};Bw3na8UaBr^A7g_IB-+tF=FBvb+wpy>4Cw~4TjP-~bVD#t>4tMy*MYSS zor(j%sI+*=5It|`!6M<4!dmKq-Z~9iIOCR~lrjU$i-UcZVPIWz;h$1G89r`GKUOZ* zsu48QTdTzL4MBvHdw}2+sote6K>;)eU71ANqTGwa9Ud7}Du-NO3c)T}-D0|IN;tJ(KQ ztX<7sI3D$h2YLI@H$oPPZ`WMbe0YHzhPGgyz%vZ<^h$N975o@j z)9rfekjleO>n5Iqye-c%)+n5)u zgY{SkU&3BygS)QaOL0>=+pw28jXc%fDcIWKZPGleeF@q0?(X*TrT7V-XYwo391=ez z#Ou#F)!OPs+1>aF$ARWq(c-x%JbycA6b%Q(<75+l3UjW$UHD$4`S!v$Rg7=N!!CT^ zrTK=f*q^QWhFs{+m-VS{;(IEibet_bDAc`961cql$6&gMG_-8*c$k)MBh|7ImWPw_%enG5l=(?04w!UBG! zbMF@Vb{J>zc%x+CaSrR4z6T+Dhd*WWIiR;0{17hqrFz2rPv`agPw*8ezjwI*=?uy% zxkm6LeD&0}`cdcZ{*JjZ&pglH_YXJ^MZC&(BhEavF)KW-$;Z+b`?`T^BK&96HuZG~ ze)_7E#l9UW6MQ!0QF>K%T9;$$VqT`jxY$>T{aw|?V&9I7ra+mN-xm8epDFhB7!yYj z5LsFOR-% zw_&XjzAoSbr(jphZ%qm(#2}zt96Rd;-J!?Nc4OY?dq1F=wU?8Psc8N-Y~|@b|Dms< zJn)RSpK< z0*&HuzA*^BlQD^lVA zT=f#tU(%%GENk=8o4UH&9~$jHz+N4e{!+qc7~@vy-I(X301qVf{Qx}BjjOhYRVN|*X8)5IH#(@nK_LIvQ5My7Q(lTak?;$QqaMLaZnt> zrR_ynJB5fPIL6}#w7ju825)F%#LS>6#rRD_e39xe&OtHy2V8s*Hw%Rg>Bl5}w1bQT1?j6-~0bzPqH? z{n(^l*vP&eOD0)&e3JPTA5c7EDe6{b*?d(<2d-bK%40s-PrFc7Th0YKxT_6aI0GGN zgY2U^uJ%d2)F!Wo_IW+@sjU~TJ1G88(SXK*DEfnJLfb;KZG80JoW*=cZe?e&pQzjd z8oiCV1p#vqv*_D_zRlom7x1L>8BgGz@Q4GUnW46#T;Zm-xZJa*tfgHq9mdfI8mC zYbAANvS4TX@dfSeCl++H4=r%S8xGc>UR(RWBK;>w|0&Y{1?eWF8xPXiE7c31 zb3R6_Ll5SP=AL4DwPPN{TI@!jJBuhDK=|(3bnqse&A{Eo@eZYT_go`lgZP+o*LMqha}Y;EesI@!i+U+8Jq`2gqPfqt`4U;% zRN^(n(M=_pkUD``2CNp7M| z*R6{YQ=ZtF@p9S;qDL;;B>SJ*CR{L{6Lax9;amk7O?1JcOza2GoHW@EzL|jeZtq-B z)4qE_Rr{_5j&{$2lcpl17bE@4NPiOPPayqE3rMcH4ov9X@uXp3$NPrf9r4f^XuGH5 za}n`@Cow)+f0wo|179q~nknlAp9Jm-5I%mB0elm>?m3^pN5|!UCg$5TGk?eX#@-#X znUCh5{DEeiMaEr=7$bvcZ=AWUJbp@Bd6{9?UU!{))K%virMPDITthF}6>*SFZs3~% zJZVkE895DJb5FIww-`6F^ID3*CppzNbsJzD%8^|%^uE9U%p%rR3VXOtwpI4NKbPv& zVJ_wy;!oHO?CjFN-o1C}rNTY-8`#-S)UC91?xl8L#(8EH${7raCr*J5G+x4g2y}O$ z4Vq6g@{E|%G|ZpkFFsE=|8$A`&Nu_>TnfC%*SP=5#iKpg>lh7&kv7nmc$3OIz*lbk zj@WawW$vuH6|{m}r!`T9a>VDv6C|gJHm>>1=l&$!=SVzZ25%F-M$4|fv<9mnqu32? z3#%Zv*mQzFS-_GB{&WGmiQv!zW+3>=0ydH0@dYf7;E4rnO4~y1IItezr(k`=!)^H8 zfwfl+ew_y#YJdZcaU#Y}xJ*I}F6ZqVY`))tw|_%2nbz$!I9H-EV0`ZR;6Lyj`Q1-b ze3GOQjdPIJ{&x+%%wV&+t}Prrjk%+7IZ$`UV~q2vR(^x`Brmp2)s{aAef_qS&BTjl z=$E*(LM~qpppQi)M*!o}mRNVOwEVcU_JT!*IqP3WKXDV;t8v#bpW$q30peTx$Yvn< zqkcCd-;8|l8owt)v9TA|8KFx|SRWIxPH^`?#>(=(xj)AM8vr^0YoXMTmcQ>YL+?KD zwFh&Gv$wOypzn4qU1H5Jv7C0$XeMaW{$x?_*Js;&KIqLIlbD74sNcap^)*p)Aq7{lJo5v%%Oo z6XR&#ZA2do^ufBq`l7x%QfxlzZ$I{C)K(kl7BE|uHO}t%oe;t@d#eT zVz(vH+GZo#2ss5#lS7qwsSkQXC)cbBB>O-2q-Z`|AQX_Q?$U9g+j1=%eaZo390H zi@saXKW_`Xa7AsQehbFU+k#BwZ9#TjQCq0r0>0&K8D(3LWmnV|>bFc1ZRy#Q7uV_E zKO>!z{@Fom26Qs%k^JX(?u|<;!>Cx8_^Vd)E`^?CW@7t$%Moi!v+_~68GRJE1?6uIGz>n^z;N@njp zop$cg*J=F3r~h&7%+6n4o7{Qd<81WEBzE>WKF>+;J0$fx*z>0l|4FuB>Sx*6Q<$R*kU8({VAk`1 zUi@rEtl4##gPtP9gZ$xcoY1jc@9sih_#J!Z91qr)d4TeR_X@Wl7N4i{dLrGNj=j`0CVjeMUZyiP zu=#)?vMlv^hv>s>whhqu_&)OJMC(@Ec?j>bE~Usvald3AFNeN)!VrIkL08Zn7Q_jU zxG)!SamV*&?2mtT1o*CRb&qyp&8>&;av9(spznZ7V*L%afqjT89?XGn6M5^wd-W4- zKBSGL!9Tdq5I<6bww^#+fBSs=v-_}q2Vn!;fVy?4i@w$mXNkIo%aA-$ zOQ zPu(x#1Bvcl&_;|6XX`SL#+Ldm#H7s-v>5_zyojNsGe%WL#RvA_EYEH-uYVcxWIS{6 zB4RyCF%KC!b1^(MI2XGS2dJfYU@kC*m~-I>(iSfvbiLUj{MB>@g_sS#E@>VHJuG(t z^f{-!MlLA+RD5iEFi5}qz#n}48A1BFDil7FHpt`jy9HD+F=!U6e_h%ry#pB&H{JF$@sQ-ES0p<#DS>wMltgBfi0tDlMMY?W;!DlbvzZpI_aq6K^>Kcv+KYaw-++qd?Vv`O6ZJx&Wt-j%x=zj&@B!U zpz-jMmImq#f^ePhz+98fpi2Ww3>qMh(*QO?R2ra6EE>3C@!1DN1GSzCrB2ozC&oZA z`<(B>*Aw#iII*sxjuT~KjkEMa7^e@hC-32%fKlAj^w4?=*P|L;VV?8w)2RmI*+S?m z*ZD$U(j7$u*pFH+Ox~B0a#PVjG#mI7^!A&OEhMvum)fKbCtIKVp)*R@;o*74UhgdC zqxQgCynPeer#7{3XYhV4nttbuzh6c?3LMCGaGB_SCeC?3%QA*14db3H@tvibi|dr_h*4-ksuh)bzf2GL7gkJk92N7xRDq zI@^E^cI@yB#&ru0R}(ouXlyYXWEzcOhRf!o@-LDNbt&LI=D z`;$+g-L3FjGVFs0FB&Jt`xL|YX}t71J=XK@`Dc(#e*yFCowR&Z@H*yP;;8J*Qy9z5 z8XAFDeCC&FjH0X=KC?LNH_2x<_xU#5X(S#M@lnzGemI-ucAv4_%e*M<5xi8d+j@WarJ zgE*%Q>|u0tqvw-h_Qw_KM%aUaF~`!49@sI8uEr}I^G@Os@Xm19{&&AjZ=23?>HqJ%iZ?NBnm~!le$!5F7UB4+p#{5WoR^q=&=&jH}1t8N`&9qW=sX90m~!tZ=A< zk4z7T_*!F)fz2Lr?>+x@4UU81X*E8tv!8#4t#n_vN>+y8WdN*SX z^^12Ul>>bFli;$o1Ca?jLpB|F$ zT=q#Hr$+XD3bN1dH}?7=!%6OvP8&{zY>|4D{KZFq!YbcGy7CvFhYou0*UWkWknWv) z6SgSD0K=~DN|OHKld#RwRr%0o75I^N_s zGegMbHF%HX*GcSbFV^DGtX+E%>vHHc^aIIk>NgE*=E%3`st`v)<%j3(d(bR( z5Z>t26Y6g!?5km7)NTCu=mYmA3%1TN1vn6zbcQ*i6>z1L+(=^_rXCPNaSsc5d|cr0Fd6Z}d(f8q=H!Z}}fNX}?|uru-gP+a2F)EjJ@+GuaA z_$I83$$AaW4+M{$!o4iwgNU|n#Ct`i^!cebZG5XLN?WFFHmhpKC~YR*PPBD@vurbC zX49~?%^2lPW##~`YA+Fi>-FHPiOdoePvk2+tF?HB(S?uq4%QTtc6TtuVhGwDm9z`c zIodd|K2r_Ow@NYZba!;F!4t8@BgPb_(qI9H1hbG!W$np zqB&$gUsGD26w0VIrF5uSqeF)@?`MSj1eis?XOS1SR_TFAvE7+IwvsKuibdF}84%s^$vKRLQ(_xoHl=;7i12VGQ zi1fd*Q9MfSVpjUOr;=x#) zQO05_u(c|FpBrr)PeG5}#L8WW(b1!a3HhpxYV1jAUdbO|HY~LcO$+jKK5S-gOUn0X zXq+DGuZd>^b|UgPKmQCdIan8ppIxwZwPh4Pb6SBH)V!w_h5CD^d(Iz8H!W?U zqfednSJGQMG#;8)$nWx9@U2F)7ptH1IZjG0zO{t`t11-)~6?2w+t4J zLO%ATPN{l}Vxjcr*^Kv)O;dvMv0d`Z7R+@-dnk*008hWNq|g^neu`V-pEV^zKlmRn z-@(l5yW!7LbUqM`?-Wj!6>mkA*(hW3HN76-KiQTUa(D;M?*=vfRKsRb_94eNT%Lam zz7oieG`v-&YcBC3wvy`%NAm7k7wUXcG@Ux z?;*TH(2JjV^g*!;OQAOqqrmS%kWI$-&XD_~xYMr6&^cv1Y`Qb3FKoJC9<5jMohy4Q zgm=-8^09>5Q<1tw*keeK>5Fein_|9a1ZcVgK7?WDiyam4B_vB<>=%|=e~tKk^HbQT zOTDakPR&K$%%FVQO8aS)&A?B%U!hyGpT?WCkVQe?fjYyjgM1URESRTg6R|$N2YHS6 zx)eU`=u_dO_TCrBrtZS~13LJCN4ad|bH(@B!9D}{aQj>Td|%lC9?c#+9sQ`e3bzA1 z8lM~83sv=dH2ZXKjQTy`8|7P~_;oJVN&aK5hxyqR>=t~d!xmR>&gq@QsQt~oXd{|W zPL&}Zp>-KS`%KuAhBS)}J}5moXF|S`Cq~ep+6c@E#^FJl8$aPZg1D&QoM8Rv@rYPI zvFAj)eq87$+MGnLA3?*h*3X#q`CHgOutODZ7U}UO(E;gh{QODi5QDcqG&(@W_DoLC zBRU-ZijX-60K?bmFNhXMKMgI#_= z%u_N$tuZY>P(L3wKahXKd`;0Py>(9dFtrr#YY=abrIYwRX!Tnzys2d5Z?S~>IjDXh zh5@=RV+w2p#N?R~LzlV}avO0n&>{2rdX1*{q`j6}$Tnp_zoyR_N{M4%;qTSrjqdmf z->^N*U^m8WL;0t0Klvp5#dWh6`}*KhUWORLdc+V8BDTQ`J!m(~9P!|HbHeex=9BTy zx^e$Hqt!K92ETHK0kIf>zn3wDw_^-D3`y(T5L-lf8HkCv9dUp=&<4f+;r+T1iXp5= z3}NTN_-A*}eFW(I`yj{W^BBUU_1$>0jp~-cCZ3PF)IZf-YDho~p@=6WAIz9zyJ5%E zsaE*y@P?~yS?tNUodbJ5A|LUZadT|qZqYk<C1~KByvKG-h#Lw(Yq4#3W;0zRZmg3EZ)GT__BQ4qXunji&R=j!LihI94&^#SH zkqWxSVa=q&z9_|;bQj>u^TB7N^62f{11S`5lHBLTS}ILpheGl}M~Z8A8D{QQa};;Z z-|w2w-wqIC{6f%wM|;EcIK<9s^+QTFztVWq zL99orJDzw`g$u=-##(={KP%I*rd-C!)-4Yk1|C7&t@;}-=kL24F~ds`J6wXd+ZPA^ zrb|9zlc-HIc*F}HFIs>Is=9PaO6oe7;Q z{&oWCc2!>BTr~=Lf%{01v5*xfad%3T7iXS<_9Snn8Vs9uUN6dU{f+TZc?0Y~vYFq+ z`X>MJMEpJpkjkjIR`s^E`1=e28OF=dTg+{;Jo%Wt_(|5B)oaI~tv^rGhdOgFRp;&Z zYtP%onW?rNMT;WY27Rk@YrE>qxZKBS&%({}41&(Y*~!5L6dwS-TF8dm7Nl-tR=T6dZ9@5`fa@*s_OfcA6t(U&x&!ZRtYKQPPzv0jQ1KJO~ z|8b1rZ!Cqr@8L(xE5+A)zE~#D*hO4D;rk~3o)7tc=?)0Forj%|&S1Fy*KxWV#E0X_7*VqPnzyl%;bBHt}%Cuu0m*PyT z6!G^(_@;OZb^gT5zf5VOyqVgx2z>&1c1SlLx}4hPWu@-1;VznPS=kmZ3)xHch?k$K zncbyZUbPLq)zdL;bpJfltK1g^8iF6h_+egJzK6(6HZuQqEDh|K>CL1{2 zVe0bxukH2kV7?#DYw1lf%o?%HWtA2FqCKwnAA8+9(a^8(p?d*lGyZjg!y30C5QBK+Fzw zEO6|G{YCnW;{e<#Z5aD+vct?AZ~VOm8Vl@Pp2qPOX_t$)4f>k*&v{1n4?CC7E74NZ zKQG7o7v-wpSK(>Af01_C{bNs%5BcP!d3u@X1U-qdwQ*lgBn@~uj)N#?qc{kv%W)8C zmy1Ih{HlDO3WM`x{yOaEFBtE&mx=w%{5i){*3b5oKZpA-u>0c|V?SfK6K^6pk&nGj zJlnq=7SUeV9(_OfE20doEgk$Ii}HD&|B61b_li|7 zd|nk#JhR;}@b7phMYrxwF*Z7%+xbnjPdWg7&B5th9zaIRq?))WS?6e14{|MsWC$L1)6EAeEK77t(81VbA@AZF~`Tl<1mfl&0 z8%O9)QX6d9Ezmtf&^zcfos0sjH-*GSKO3V*}z%sgY4Z6RVhm$fbI>$rd0nHpp3+eZA|C}Z5ndBo^+ zV;%;LlWZ0Z4>1O7^B zbN?G+PW}^T8QXD}N}XlY!H=Ll%jmv=RlbdR*$sce(iOS)$Stxr(;c?a)0o$EN5bfl zn#2OKKWUD7&iz|KPt|Ci5wb|lfiBI%WzfrEbPSmjVN=oGAf(N3SsvbIc)m`XTrb3! z=h4fU=hkt|vuhR0dmFOc(;Q{4!QVv3^MGHOH=%1Ucs|7%obRP!^PL9U?roH%`95x= zzsnTgr^?WLFU5T0trpBT#qtI7)O^2-y_bjd=ImgsY>(#b3UTQ^$Orr#DxnMDgFQ6V z&U`yj=U3y!~s1Ikz~uZMF~l~+~Ca(LRDV48UX%71QVMXF)uCPxK) zwPWxA&HvXh|9OvKU-}Hr=kRkJzIN?;x9y<$PvY}`<}tF@%YwgkQw2liWhest#3yeM)$yO+hD&;3hTWnjJ< zv2XY~&R+4O=3*&y9Gx|HHwEWwX_NkZ)oqGCUqr`2=m4V8&~ET5?)(ky#^0pEnjKi5 zmGMGH^5Fqx3xmg%Zqn*D^560K)a3JZAkRI1i~Iw}=x^E3n+(aYGgJD01HJrTh%>!S z76Mw&MMjzR?^mkCXP4gW6{mF!0e@)P)8HE0#Go*k`)2UMsvj=(fH&J)J8MJM7@6p&cz)8_@cp2{NKp#|*eFORsPq+f>O5DHU^NM*U zJ6)|owMLXLkNj*N(`4({VApn=){Ihn-5p8%-JEVyrTk9h-wb7+h5yBWY*Ng(eo5ab z9}D6-5q~1&zlvGr{7bk(<_kU(zL_CP<9sRn1PW&=PcmVjF=d48)n}Hl!-qPON2{^6 zFDf0Td6QbJ!&0OU^K_tX1J2rUPubHUbl5Yf{{#FTzxz!|C#I4A1%Dqh?$Tqg_dd+} zPyhFh@9)4|LS|IP`3v_f!dX-b-U55D0P@)X*z4)oL)%e5LT8Ze|A3BsQRi>CTW!b+ z%8ND2;6H?H-=!np+m;38#e9_0%5Wv$moAMiFK8Y}?v-BfA0ioX5$odZ+ie35;GM!o zpSE3ijK8}>>n|r^TIVMdQaXvYsj&5*WI$4Ye+MeW-t=q4b4aIop}lALzLw_c zDC+N#^K=pW)pyWux}^6r#-tN(zhAV+Bk7&d$ok7L2WLQYJK}b{x?>88oN* z58Mp73c6D}J?NkMPR1Bi+i7wvBwrE}5<8O@AwH z5YJM(-{JBvrEmXivDcJ6*?Gq z3@}#O2avy(^e}y=q5ZdTRxnCe-#CPBYA9U3wX z4T)BIvg`Qm(P||Km0&yZodXuVTS#6S_iMRjNsfJ2mX3^o#A_A zeVdu=50XK@13zwgVCJ*G3cMj|SCiqQ#yYRhFkN?tw zH2MMFGVuU6w+?=THwN*m!`jiCC;D4{(eP9I5|WQet*wYfP2ul5srwefwh(&;#5Qq1 z><6(o;r1>1RB=SqHjgC&fAV=-t>IrPmm%ykv${tzeM%GbbEOIQDy~uVi&4k?=(Gxo z37Q8#`6=v$Xq++6Ewy@Mm*~6dd4JBBI!5|ef+(z^ha<{!D-m!I*7kNA^lA82mROI-s%dRQPJPTARChONYy3(44QA^H`ld6 zpM@8Cf^0FBhxn!7-Cyw5{TjaPxrWJmQG##N@tvxv+oQQlO}tsAsXK&w)KpgScqzW; zYQBeHgWjU~F2#4c=6lG@`fta#!m||LOrH7opszbMWfA+|f19SPSNom{%Fff|nKgMN z_iohWrE6kcOHq&Rn+E#V#Ic%@cdaJRrMWBPMIPNZRrNgDyJN^xv3Yc#9QL_S+1ei1 zO3KzIzb&mfJ$s1GVCkIn2RI`=pN%~w&iVa*Q?LKF;GXh=^i`{K(w-Z2_LTD`^wPak z@)gp4a#^(fq&Nmwp=9d{}^WV!1H%WNo)MbWQQuSxCV8m;3s~*2YYtUKNk*|4Q#&WpXI*#3;zC3;N6F-9UIy1TAQDA%gf*q-Y(Y@ znmvM!ZrLw&3$1n1O{8PSsvD_eaA))XBk$egqpYsQ@8_A}GLvwX1PGu>pq3