未成功引ncnn

-/*
- * Copyright 2024 LiveKit, 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.
- */
-
-package io.livekit.android.room.track.video
-import livekit.org.webrtc.VideoFrame
-import java.nio.ByteBuffer
-// Native OpenCV implementation via JNI
-
-class OpenCVVideoProcessor : ChainVideoProcessor() {
-
-    companion object {
-        init {
-            System.loadLibrary("rvmncnn")
-        }
-    }
-
-    private external fun processI420(y: ByteArray, u: ByteArray, v: ByteArray, width: Int, height: Int, rotation: Int, timestamp: Long): Array<ByteArray>
-
-    override fun onFrameCaptured(frame: VideoFrame) {
-        val buffer = frame.buffer
-        if (buffer !is VideoFrame.I420Buffer) {
-            continueChain(frame)
-            return
-        }
-
-        val yArray = ByteArray(buffer.strideY * buffer.height)
-        buffer.dataY.get(yArray)
-        val uArray = ByteArray(buffer.strideU * (buffer.height + 1) / 2)
-        buffer.dataU.get(uArray)
-        val vArray = ByteArray(buffer.strideV * (buffer.height + 1) / 2)
-        buffer.dataV.get(vArray)
-
-        val result = processI420(yArray, uArray, vArray, buffer.width, buffer.height, frame.rotation, frame.timestampNs)
-
-        val newY = ByteBuffer.wrap(result[0])
-        val newU = ByteBuffer.wrap(result[1])
-        val newV = ByteBuffer.wrap(result[2])
-
-        val newBuffer = livekit.org.webrtc.JavaI420Buffer.wrap(buffer.width, buffer.height, newY, buffer.width, newU, buffer.width / 2, newV, buffer.width / 2, null)
-
-        val newFrame = VideoFrame(newBuffer, frame.rotation, frame.timestampNs)
-        continueChain(newFrame)
-    }
-}
\ No newline at end of file

-cmake_minimum_required(VERSION 3.10)
-
-set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/opencv-mobile-4.11.0-android/sdk/native/jni)
-find_package(OpenCV REQUIRED core imgproc)
-
-set(ncnn_DIR ${CMAKE_SOURCE_DIR}/ncnn-20250503-android-vulkan/${ANDROID_ABI}/lib/cmake/ncnn)
-find_package(ncnn REQUIRED)
-
-add_library(rvmncnn SHARED rvmncnn.cpp rvm.cpp ndkcamera.cpp opencv_processor.cpp)
-
-target_link_libraries(rvmncnn ncnn ${OpenCV_LIBS} camera2ndk mediandk)
\ No newline at end of file

-# 背景图片替换功能使用说明
-
-## 功能概述
-此修改允许将Robust Video Matting (RVM)的背景从单一颜色替换为指定的图片。
-
-## 使用方式
-
-### 1. Java/Kotlin层调用
-```java
-// 设置背景图片
-Bitmap backgroundBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.background);
-RVMNcnn.setBackgroundImage(backgroundBitmap);
-
-// 清除背景图片，恢复默认颜色
-RVMNcnn.setBackgroundImage(null);
-```
-
-### 2. JNI接口
-新增JNI函数：
-- `Java_org_example_project_RVMNcnn_setBackgroundImage(JNIEnv* env, jobject thiz, jobject bitmap)`
-
-### 3. C++层API
-新增RVM类方法：
-- `void set_background_image(const cv::Mat& background)` - 设置背景图片
-- `void clear_background_image()` - 清除背景图片，使用默认颜色
-
-## 技术细节
-
-### 背景图片处理
-- 支持RGBA_8888和RGB_565格式的Bitmap
-- 自动转换为OpenCV BGR格式
-- 支持任意尺寸的图片，会自动缩放适配
-- 如果未设置背景图片，使用默认颜色RGB(120, 255, 155)
-
-### 混合算法
-使用alpha混合公式：
-```
-result = foreground * alpha + background * (1 - alpha)
-```
-
-### 性能考虑
-- 背景图片会在设置时进行一次格式转换和缩放
-- 每帧渲染时进行实时像素采样
-- 建议使用与输入视频分辨率相近的背景图片以获得最佳性能
-
-## 注意事项
-1. 背景图片应该是RGB或RGBA格式的8位图像
-2. 图片尺寸不需要与输入视频完全一致，会自动适配
-3. 设置null可以恢复默认的背景颜色
-4. 背景图片会在RVM实例销毁时自动释放
\ No newline at end of file

-//
-// 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 maxMeshOutputVerticesEXT;
-    int maxMeshOutputPrimitivesEXT;
-    int maxMeshWorkGroupSizeX_EXT;
-    int maxMeshWorkGroupSizeY_EXT;
-    int maxMeshWorkGroupSizeZ_EXT;
-    int maxTaskWorkGroupSizeX_EXT;
-    int maxTaskWorkGroupSizeY_EXT;
-    int maxTaskWorkGroupSizeZ_EXT;
-    int maxMeshViewCountEXT;
-    int maxDualSourceDrawBuffersEXT;
-
-    TLimits limits;
-};
-
-#endif // _RESOURCE_LIMITS_INCLUDED_

-/**
-    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 <stdbool.h>
-#include <stdlib.h>
-
-#include "glslang_c_shader_types.h"
-#include "visibility.h"
-
-typedef struct glslang_shader_s glslang_shader_t;
-typedef struct glslang_program_s glslang_program_t;
-typedef struct glslang_mapper_s glslang_mapper_t;
-typedef struct glslang_resolver_s glslang_resolver_t;
-
-/* Version counterpart */
-typedef struct glslang_version_s {
-    int major;
-    int minor;
-    int patch;
-    const char* flavor;
-} glslang_version_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 max_mesh_output_vertices_ext;
-    int max_mesh_output_primitives_ext;
-    int max_mesh_work_group_size_x_ext;
-    int max_mesh_work_group_size_y_ext;
-    int max_mesh_work_group_size_z_ext;
-    int max_task_work_group_size_x_ext;
-    int max_task_work_group_size_y_ext;
-    int max_task_work_group_size_z_ext;
-    int max_mesh_view_count_ext;
-    union
-    {
-        int max_dual_source_draw_buffers_ext;
-
-        /* Incorrectly capitalized name retained for backward compatibility */
-        int maxDualSourceDrawBuffersEXT;
-    };
-
-    glslang_limits_t limits;
-} glslang_resource_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;
-
-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;
-    glsl_include_callbacks_t callbacks;
-    void* callbacks_ctx;
-} glslang_input_t;
-
-/* SpvOptions counterpart */
-typedef struct glslang_spv_options_s {
-    bool generate_debug_info;
-    bool strip_debug_info;
-    bool disable_optimizer;
-    bool optimize_size;
-    bool disassemble;
-    bool validate;
-    bool emit_nonsemantic_shader_debug_info;
-    bool emit_nonsemantic_shader_debug_source;
-    bool compile_only;
-    bool optimize_allow_expanded_id_bound;
-} glslang_spv_options_t;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-GLSLANG_EXPORT void glslang_get_version(glslang_version_t* version);
-
-GLSLANG_EXPORT int glslang_initialize_process(void);
-GLSLANG_EXPORT void glslang_finalize_process(void);
-
-GLSLANG_EXPORT glslang_shader_t* glslang_shader_create(const glslang_input_t* input);
-GLSLANG_EXPORT void glslang_shader_delete(glslang_shader_t* shader);
-GLSLANG_EXPORT void glslang_shader_set_preamble(glslang_shader_t* shader, const char* s);
-GLSLANG_EXPORT void glslang_shader_shift_binding(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base);
-GLSLANG_EXPORT void glslang_shader_shift_binding_for_set(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base, unsigned int set);
-GLSLANG_EXPORT void glslang_shader_set_options(glslang_shader_t* shader, int options); // glslang_shader_options_t
-GLSLANG_EXPORT void glslang_shader_set_glsl_version(glslang_shader_t* shader, int version);
-GLSLANG_EXPORT void glslang_shader_set_default_uniform_block_set_and_binding(glslang_shader_t* shader, unsigned int set, unsigned int binding);
-GLSLANG_EXPORT void glslang_shader_set_default_uniform_block_name(glslang_shader_t* shader, const char *name);
-GLSLANG_EXPORT void glslang_shader_set_resource_set_binding(glslang_shader_t* shader, const char *const *bindings, unsigned int num_bindings);
-GLSLANG_EXPORT int glslang_shader_preprocess(glslang_shader_t* shader, const glslang_input_t* input);
-GLSLANG_EXPORT int glslang_shader_parse(glslang_shader_t* shader, const glslang_input_t* input);
-GLSLANG_EXPORT const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader);
-GLSLANG_EXPORT void glslang_shader_set_preprocessed_code(glslang_shader_t* shader, const char* code);
-GLSLANG_EXPORT const char* glslang_shader_get_info_log(glslang_shader_t* shader);
-GLSLANG_EXPORT const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader);
-
-GLSLANG_EXPORT glslang_program_t* glslang_program_create(void);
-GLSLANG_EXPORT void glslang_program_delete(glslang_program_t* program);
-GLSLANG_EXPORT void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader);
-GLSLANG_EXPORT int glslang_program_link(glslang_program_t* program, int messages); // glslang_messages_t
-GLSLANG_EXPORT void glslang_program_add_source_text(glslang_program_t* program, glslang_stage_t stage, const char* text, size_t len);
-GLSLANG_EXPORT void glslang_program_set_source_file(glslang_program_t* program, glslang_stage_t stage, const char* file);
-GLSLANG_EXPORT int glslang_program_map_io(glslang_program_t* program);
-GLSLANG_EXPORT int glslang_program_map_io_with_resolver_and_mapper(glslang_program_t* program, glslang_resolver_t* resolver, glslang_mapper_t* mapper);
-GLSLANG_EXPORT void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage);
-GLSLANG_EXPORT void glslang_program_SPIRV_generate_with_options(glslang_program_t* program, glslang_stage_t stage, glslang_spv_options_t* spv_options);
-GLSLANG_EXPORT size_t glslang_program_SPIRV_get_size(glslang_program_t* program);
-GLSLANG_EXPORT void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int*);
-GLSLANG_EXPORT unsigned int* glslang_program_SPIRV_get_ptr(glslang_program_t* program);
-GLSLANG_EXPORT const char* glslang_program_SPIRV_get_messages(glslang_program_t* program);
-GLSLANG_EXPORT const char* glslang_program_get_info_log(glslang_program_t* program);
-GLSLANG_EXPORT const char* glslang_program_get_info_debug_log(glslang_program_t* program);
-
-GLSLANG_EXPORT glslang_mapper_t* glslang_glsl_mapper_create(void);
-GLSLANG_EXPORT void glslang_glsl_mapper_delete(glslang_mapper_t* mapper);
-
-GLSLANG_EXPORT glslang_resolver_t* glslang_glsl_resolver_create(glslang_program_t* program, glslang_stage_t stage);
-GLSLANG_EXPORT void glslang_glsl_resolver_delete(glslang_resolver_t* resolver);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */

-/**
-    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,
-    GLSLANG_STAGE_RAYGEN_NV = GLSLANG_STAGE_RAYGEN,
-    GLSLANG_STAGE_INTERSECT,
-    GLSLANG_STAGE_INTERSECT_NV = GLSLANG_STAGE_INTERSECT,
-    GLSLANG_STAGE_ANYHIT,
-    GLSLANG_STAGE_ANYHIT_NV = GLSLANG_STAGE_ANYHIT,
-    GLSLANG_STAGE_CLOSESTHIT,
-    GLSLANG_STAGE_CLOSESTHIT_NV = GLSLANG_STAGE_CLOSESTHIT,
-    GLSLANG_STAGE_MISS,
-    GLSLANG_STAGE_MISS_NV = GLSLANG_STAGE_MISS,
-    GLSLANG_STAGE_CALLABLE,
-    GLSLANG_STAGE_CALLABLE_NV = GLSLANG_STAGE_CALLABLE,
-    GLSLANG_STAGE_TASK,
-    GLSLANG_STAGE_TASK_NV = GLSLANG_STAGE_TASK,
-    GLSLANG_STAGE_MESH,
-    GLSLANG_STAGE_MESH_NV = GLSLANG_STAGE_MESH,
-    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_MASK = (1 << GLSLANG_STAGE_RAYGEN),
-    GLSLANG_STAGE_RAYGEN_NV_MASK = GLSLANG_STAGE_RAYGEN_MASK,
-    GLSLANG_STAGE_INTERSECT_MASK = (1 << GLSLANG_STAGE_INTERSECT),
-    GLSLANG_STAGE_INTERSECT_NV_MASK = GLSLANG_STAGE_INTERSECT_MASK,
-    GLSLANG_STAGE_ANYHIT_MASK = (1 << GLSLANG_STAGE_ANYHIT),
-    GLSLANG_STAGE_ANYHIT_NV_MASK = GLSLANG_STAGE_ANYHIT_MASK,
-    GLSLANG_STAGE_CLOSESTHIT_MASK = (1 << GLSLANG_STAGE_CLOSESTHIT),
-    GLSLANG_STAGE_CLOSESTHIT_NV_MASK = GLSLANG_STAGE_CLOSESTHIT_MASK,
-    GLSLANG_STAGE_MISS_MASK = (1 << GLSLANG_STAGE_MISS),
-    GLSLANG_STAGE_MISS_NV_MASK = GLSLANG_STAGE_MISS_MASK,
-    GLSLANG_STAGE_CALLABLE_MASK = (1 << GLSLANG_STAGE_CALLABLE),
-    GLSLANG_STAGE_CALLABLE_NV_MASK = GLSLANG_STAGE_CALLABLE_MASK,
-    GLSLANG_STAGE_TASK_MASK = (1 << GLSLANG_STAGE_TASK),
-    GLSLANG_STAGE_TASK_NV_MASK = GLSLANG_STAGE_TASK_MASK,
-    GLSLANG_STAGE_MESH_MASK = (1 << GLSLANG_STAGE_MESH),
-    GLSLANG_STAGE_MESH_NV_MASK = GLSLANG_STAGE_MESH_MASK,
-    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_VULKAN_1_2 = (1 << 22) | (2 << 12),
-    GLSLANG_TARGET_VULKAN_1_3 = (1 << 22) | (3 << 12),
-    GLSLANG_TARGET_VULKAN_1_4 = (1 << 22) | (4 << 12),
-    GLSLANG_TARGET_OPENGL_450 = 450,
-    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 6),
-} 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),
-    GLSLANG_TARGET_SPV_1_6 = (1 << 16) | (6 << 8),
-    LAST_ELEMENT_MARKER(GLSLANG_TARGET_LANGUAGE_VERSION_COUNT = 7),
-} glslang_target_language_version_t;
-
-/* EShExecutable counterpart */
-typedef enum { GLSLANG_EX_VERTEX_FRAGMENT, GLSLANG_EX_FRAGMENT } glslang_executable_t;
-
-// EShOptimizationLevel counterpart
-// This enum is not used in the current C interface, but could be added at a later date.
-// GLSLANG_OPT_NONE is the current default.
-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),
-    GLSLANG_MSG_ENHANCED                    = (1 << 15),
-    GLSLANG_MSG_ABSOLUTE_PATH               = (1 << 16),
-    GLSLANG_MSG_DISPLAY_ERROR_COLUMN        = (1 << 17),
-    GLSLANG_MSG_LINK_TIME_OPTIMIZATION_BIT  = (1 << 18),
-    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;
-
-/* Shader options */
-typedef enum {
-    GLSLANG_SHADER_DEFAULT_BIT = 0,
-    GLSLANG_SHADER_AUTO_MAP_BINDINGS = (1 << 0),
-    GLSLANG_SHADER_AUTO_MAP_LOCATIONS = (1 << 1),
-    GLSLANG_SHADER_VULKAN_RULES_RELAXED = (1 << 2),
-    LAST_ELEMENT_MARKER(GLSLANG_SHADER_COUNT),
-} glslang_shader_options_t;
-
-/* TResourceType counterpart */
-typedef enum {
-    GLSLANG_RESOURCE_TYPE_SAMPLER,
-    GLSLANG_RESOURCE_TYPE_TEXTURE,
-    GLSLANG_RESOURCE_TYPE_IMAGE,
-    GLSLANG_RESOURCE_TYPE_UBO,
-    GLSLANG_RESOURCE_TYPE_SSBO,
-    GLSLANG_RESOURCE_TYPE_UAV,
-    LAST_ELEMENT_MARKER(GLSLANG_RESOURCE_TYPE_COUNT),
-} glslang_resource_type_t;
-
-#undef LAST_ELEMENT_MARKER
-
-#endif

-//
-// Copyright (C) 2023 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.
-//
-#ifdef GLSLANG_IS_SHARED_LIBRARY
-    #ifdef _WIN32
-        #ifdef GLSLANG_EXPORTING
-            #define GLSLANG_EXPORT __declspec(dllexport)
-        #else
-            #define GLSLANG_EXPORT __declspec(dllimport)
-        #endif
-    #elif __GNUC__ >= 4
-        #define GLSLANG_EXPORT __attribute__((visibility("default")))
-    #endif
-#endif // GLSLANG_IS_SHARED_LIBRARY
-
-#ifndef GLSLANG_EXPORT
-#define GLSLANG_EXPORT
-#endif
-
-// Symbols marked with this macro are only meant for public use by the test suite
-// and do not appear in publicly installed headers. They are not considered to be
-// part of the glslang library ABI.
-#define GLSLANG_EXPORT_FOR_TESTS GLSLANG_EXPORT

-//
-// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
-// Copyright (C) 2012-2013 LunarG, Inc.
-// Copyright (C) 2017, 2022-2024 Arm Limited.
-// Copyright (C) 2015-2018 Google, Inc.
-// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
-// Modifications Copyright (C) 2024 Valve Corporation.
-//
-// 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), vulkanRelaxed(false) {}
-    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"
-    bool vulkanRelaxed; // relax changes to GLSL for Vulkan, allowing some GL-specific to be compiled to Vulkan SPIR-V target
-};
-
-//
-// 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_atomic_counter_ops    = "GL_ARB_shader_atomic_counter_ops";
-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_ARB_draw_instanced               = "GL_ARB_draw_instanced";
-const char* const E_GL_ARB_fragment_coord_conventions   = "GL_ARB_fragment_coord_conventions";
-const char* const E_GL_ARB_bindless_texture             = "GL_ARB_bindless_texture";
-
-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_rotate           = "GL_KHR_shader_subgroup_rotate";
-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_KHR_cooperative_matrix               = "GL_KHR_cooperative_matrix";
-
-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_ray_cull_mask                    = "GL_EXT_ray_cull_mask";
-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";
-const char* const E_GL_EXT_fragment_shading_rate            = "GL_EXT_fragment_shading_rate";
-const char* const E_GL_EXT_shader_image_int64               = "GL_EXT_shader_image_int64";
-const char* const E_GL_EXT_null_initializer                 = "GL_EXT_null_initializer";
-const char* const E_GL_EXT_shared_memory_block              = "GL_EXT_shared_memory_block";
-const char* const E_GL_EXT_subgroup_uniform_control_flow    = "GL_EXT_subgroup_uniform_control_flow";
-const char* const E_GL_EXT_spirv_intrinsics                 = "GL_EXT_spirv_intrinsics";
-const char* const E_GL_EXT_fragment_shader_barycentric      = "GL_EXT_fragment_shader_barycentric";
-const char* const E_GL_EXT_mesh_shader                      = "GL_EXT_mesh_shader";
-const char* const E_GL_EXT_opacity_micromap                 = "GL_EXT_opacity_micromap";
-const char* const E_GL_EXT_shader_quad_control              = "GL_EXT_shader_quad_control";
-const char* const E_GL_EXT_draw_instanced                   = "GL_EXT_draw_instanced";
-const char* const E_GL_EXT_texture_array                    = "GL_EXT_texture_array";
-const char* const E_GL_EXT_maximal_reconvergence            = "GL_EXT_maximal_reconvergence";
-const char* const E_GL_EXT_expect_assume                    = "GL_EXT_expect_assume";
-const char* const E_GL_EXT_control_flow_attributes2         = "GL_EXT_control_flow_attributes2";
-const char* const E_GL_EXT_spec_constant_composites         = "GL_EXT_spec_constant_composites";
-const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_offset_non_const";
-const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
-
-// 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]);
-
-// Array of extensions to cover both extensions providing ray tracing capabilities.
-const char* const ray_tracing_EXTs[] = { E_GL_EXT_ray_query, E_GL_EXT_ray_tracing };
-const int Num_ray_tracing_EXTs = sizeof(ray_tracing_EXTs) / sizeof(ray_tracing_EXTs[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_ARB_shading_language_include             = "GL_ARB_shading_language_include";
-
-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_AMD_shader_early_and_late_fragment_tests = "GL_AMD_shader_early_and_late_fragment_tests";
-
-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_ray_tracing_motion_blur               = "GL_NV_ray_tracing_motion_blur";
-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";
-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";
-const char* const E_GL_NV_shader_invocation_reorder             = "GL_NV_shader_invocation_reorder";
-const char* const E_GL_EXT_ray_tracing_position_fetch           = "GL_EXT_ray_tracing_position_fetch";
-const char* const E_GL_NV_displacement_micromap                 = "GL_NV_displacement_micromap";
-const char* const E_GL_NV_shader_atomic_fp16_vector             = "GL_NV_shader_atomic_fp16_vector";
-const char* const E_GL_NV_cooperative_matrix2                   = "GL_NV_cooperative_matrix2";
-const char* const E_GL_NV_cooperative_vector                    = "GL_NV_cooperative_vector";
-const char* const E_GL_NV_cluster_acceleration_structure        = "GL_NV_cluster_acceleration_structure";
-const char* const E_GL_NV_linear_swept_spheres                  = "GL_NV_linear_swept_spheres";
-
-// ARM
-const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
-
-// 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_QCOM_image_processing                    = "GL_QCOM_image_processing";
-const char* const E_GL_QCOM_image_processing2                   = "GL_QCOM_image_processing2";
-
-// 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";
-const char* const E_GL_EXT_terminate_invocation = "GL_EXT_terminate_invocation";
-
-const char* const E_GL_EXT_shader_atomic_float = "GL_EXT_shader_atomic_float";
-const char* const E_GL_EXT_shader_atomic_float2 = "GL_EXT_shader_atomic_float2";
-
-const char* const E_GL_EXT_shader_tile_image = "GL_EXT_shader_tile_image";
-
-const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod";
-
-const char* const E_GL_EXT_integer_dot_product                    = "GL_EXT_integer_dot_product";
-
-// 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]);
-
-const char* const AEP_mesh_shader[] = { E_GL_NV_mesh_shader, E_GL_EXT_mesh_shader };
-const int Num_AEP_mesh_shader = sizeof(AEP_mesh_shader)/sizeof(AEP_mesh_shader[0]);
-
-} // end namespace glslang
-
-#endif // _VERSIONS_INCLUDED_

-//
-// 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 <string>
-
-#include "../Include/ResourceLimits.h"
-#include "../Include/visibility.h"
-
-// Return pointer to user-writable Resource to pass through API in
-// future-proof way.
-GLSLANG_EXPORT extern TBuiltInResource* GetResources();
-
-// 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.
-GLSLANG_EXPORT extern const TBuiltInResource* GetDefaultResources();
-
-// Returns the DefaultTBuiltInResource as a human-readable string.
-GLSLANG_EXPORT std::string GetDefaultTBuiltInResourceString();
-
-// Decodes the resource limits from |config| to |resources|.
-GLSLANG_EXPORT void DecodeResourceLimits(TBuiltInResource* resources, char* config);
-
-#endif  // _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_

-//
-// 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 "../Include/visibility.h"
-#include "../MachineIndependent/Versions.h"
-
-#include <cstring>
-#include <vector>
-
-#ifdef _WIN32
-    #define C_DECL __cdecl
-#else
-    #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
-
-//
-// Call before doing any other compiler/linker operations.
-//
-// (Call once per process, not once per thread.)
-//
-GLSLANG_EXPORT int ShInitialize();
-
-//
-// Call this at process shutdown to clean up memory.
-//
-GLSLANG_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,
-    EShLangTask,
-    EShLangTaskNV = EShLangTask,
-    EShLangMesh,
-    EShLangMeshNV = EShLangMesh,
-    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,
-    EShLangTaskMask           = (1 << EShLangTask),
-    EShLangTaskNVMask         = EShLangTaskMask,
-    EShLangMeshMask           = (1 << EShLangMesh),
-    EShLangMeshNVMask         = EShLangMeshMask,
-    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,             // as GLSL dialect, specifies KHR_vulkan_glsl extension
-    EShClientOpenGL,             // as GLSL dialect, specifies ARB_gl_spirv extension
-    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
-    EShTargetVulkan_1_3 = (1 << 22) | (3 << 12),      // Vulkan 1.3
-    EShTargetVulkan_1_4 = (1 << 22) | (4 << 12),      // Vulkan 1.4
-    EShTargetOpenGL_450 = 450,                        // OpenGL
-    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 6),
-} 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
-    EShTargetSpv_1_6 = (1 << 16) | (6 << 8),          // SPIR-V 1.6
-    LAST_ELEMENT_MARKER(EShTargetLanguageVersionCount = 7),
-} EShTargetLanguageVersion;
-
-//
-// 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
-};
-
-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)
-    bool vulkanRulesRelaxed;
-};
-
-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
-};
-
-GLSLANG_EXPORT 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
-    EShMsgEnhanced             = (1 << 15), // enhanced message readability
-    EShMsgAbsolutePath         = (1 << 16), // Output Absolute path for messages
-    EShMsgDisplayErrorColumn   = (1 << 17), // Display error message column aswell as line
-    EShMsgLinkTimeOptimization = (1 << 18), // perform cross-stage optimizations during linking
-    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. Its 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.
-//
-GLSLANG_EXPORT ShHandle ShConstructCompiler(const EShLanguage, int /*debugOptions unused*/); // one per shader
-GLSLANG_EXPORT ShHandle ShConstructLinker(const EShExecutable, int /*debugOptions unused*/); // one per shader pair
-GLSLANG_EXPORT ShHandle ShConstructUniformMap();                 // one per uniform namespace (currently entire program object)
-GLSLANG_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.
-//
-GLSLANG_EXPORT int ShCompile(const ShHandle, const char* const shaderStrings[], const int numStrings,
-                             const int* lengths, const EShOptimizationLevel, const TBuiltInResource* resources,
-                             int,                      // debugOptions unused
-                             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
-                             const char* fileName = nullptr
-);
-
-GLSLANG_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.
-//
-GLSLANG_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.
-//
-GLSLANG_EXPORT const char* ShGetInfoLog(const ShHandle);
-GLSLANG_EXPORT const void* ShGetExecutable(const ShHandle);
-GLSLANG_EXPORT int ShSetVirtualAttributeBindings(const ShHandle, const ShBindingTable*);   // to detect user aliasing
-GLSLANG_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
-//
-GLSLANG_EXPORT int ShExcludeAttributes(const ShHandle, int *attributes, int count);
-
-//
-// Returns the location ID of the named uniform.
-// Returns -1 if error.
-//
-GLSLANG_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 <list>
-#include <string>
-#include <utility>
-
-class TCompiler;
-class TInfoSink;
-
-namespace glslang {
-
-struct Version {
-    int major;
-    int minor;
-    int patch;
-    const char* flavor;
-};
-
-GLSLANG_EXPORT Version GetVersion();
-GLSLANG_EXPORT const char* GetEsslVersionString();
-GLSLANG_EXPORT const char* GetGlslVersionString();
-GLSLANG_EXPORT int GetKhronosToolId();
-
-class TIntermediate;
-class TProgram;
-class TPoolAllocator;
-class TIoMapResolver;
-
-// Call this exactly once per process before using anything else
-GLSLANG_EXPORT bool InitializeProcess();
-
-// Call once per process to tear down everything
-GLSLANG_EXPORT void FinalizeProcess();
-
-// Resource type for IO resolver
-enum TResourceType {
-    EResSampler,
-    EResTexture,
-    EResImage,
-    EResUbo,
-    EResSsbo,
-    EResUav,
-    EResCount
-};
-
-enum TBlockStorageClass
-{
-    EbsUniform = 0,
-    EbsStorageBuffer,
-    EbsPushConstant,
-    EbsNone,    // not a uniform or buffer variable
-    EbsCount,
-};
-
-// 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:
-    GLSLANG_EXPORT explicit TShader(EShLanguage);
-    GLSLANG_EXPORT virtual ~TShader();
-    GLSLANG_EXPORT void setStrings(const char* const* s, int n);
-    GLSLANG_EXPORT void setStringsWithLengths(
-        const char* const* s, const int* l, int n);
-    GLSLANG_EXPORT void setStringsWithLengthsAndNames(
-        const char* const* s, const int* l, const char* const* names, int n);
-    void setPreamble(const char* s) { preamble = s; }
-    GLSLANG_EXPORT void setEntryPoint(const char* entryPoint);
-    GLSLANG_EXPORT void setSourceEntryPoint(const char* sourceEntryPointName);
-    GLSLANG_EXPORT void addProcesses(const std::vector<std::string>&);
-    GLSLANG_EXPORT void setUniqueId(unsigned long long id);
-    GLSLANG_EXPORT void setOverrideVersion(int version);
-    GLSLANG_EXPORT void setDebugInfo(bool debugInfo);
-
-    // IO resolver binding data: see comments in ShaderLang.cpp
-    GLSLANG_EXPORT void setShiftBinding(TResourceType res, unsigned int base);
-    GLSLANG_EXPORT void setShiftSamplerBinding(unsigned int base);  // DEPRECATED: use setShiftBinding
-    GLSLANG_EXPORT void setShiftTextureBinding(unsigned int base);  // DEPRECATED: use setShiftBinding
-    GLSLANG_EXPORT void setShiftImageBinding(unsigned int base);    // DEPRECATED: use setShiftBinding
-    GLSLANG_EXPORT void setShiftUboBinding(unsigned int base);      // DEPRECATED: use setShiftBinding
-    GLSLANG_EXPORT void setShiftUavBinding(unsigned int base);      // DEPRECATED: use setShiftBinding
-    GLSLANG_EXPORT void setShiftCbufferBinding(unsigned int base);  // synonym for setShiftUboBinding
-    GLSLANG_EXPORT void setShiftSsboBinding(unsigned int base);     // DEPRECATED: use setShiftBinding
-    GLSLANG_EXPORT void setShiftBindingForSet(TResourceType res, unsigned int base, unsigned int set);
-    GLSLANG_EXPORT void setResourceSetBinding(const std::vector<std::string>& base);
-    GLSLANG_EXPORT void setAutoMapBindings(bool map);
-    GLSLANG_EXPORT void setAutoMapLocations(bool map);
-    GLSLANG_EXPORT void addUniformLocationOverride(const char* name, int loc);
-    GLSLANG_EXPORT void setUniformLocationBase(int base);
-    GLSLANG_EXPORT void setInvertY(bool invert);
-    GLSLANG_EXPORT void setDxPositionW(bool dxPosW);
-    GLSLANG_EXPORT void setEnhancedMsgs();
-#ifdef ENABLE_HLSL
-    GLSLANG_EXPORT void setHlslIoMapping(bool hlslIoMap);
-    GLSLANG_EXPORT void setFlattenUniformArrays(bool flatten);
-#endif
-    GLSLANG_EXPORT void setNoStorageFormat(bool useUnknownFormat);
-    GLSLANG_EXPORT void setNanMinMaxClamp(bool nanMinMaxClamp);
-    GLSLANG_EXPORT void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode);
-    GLSLANG_EXPORT void addBlockStorageOverride(const char* nameStr, glslang::TBlockStorageClass backing);
-
-    GLSLANG_EXPORT void setGlobalUniformBlockName(const char* name);
-    GLSLANG_EXPORT void setAtomicCounterBlockName(const char* name);
-    GLSLANG_EXPORT void setGlobalUniformSet(unsigned int set);
-    GLSLANG_EXPORT void setGlobalUniformBinding(unsigned int binding);
-    GLSLANG_EXPORT void setAtomicCounterBlockSet(unsigned int set);
-    GLSLANG_EXPORT void setAtomicCounterBlockBinding(unsigned int binding);
-
-    GLSLANG_EXPORT void addSourceText(const char* text, size_t len);
-    GLSLANG_EXPORT void setSourceFile(const char* file);
-
-    // 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 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.
-    //                 For example, to choose the Vulkan dialect of GLSL defined by
-    //                 version 100 of the KHR_vulkan_glsl extension: lang = EShSourceGlsl,
-    //                 dialect = EShClientVulkan, and version = 100.
-    //
-    //                 See the definitions of TEnvironment, EShSource, EShLanguage,
-    //                 and EShClient for choices and more detail.
-    //
-    // setEnvClient:   The client that will be hosting the execution, and its 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
-
-    void setEnvInputVulkanRulesRelaxed() { environment.input.vulkanRulesRelaxed = true; }
-    bool getEnvInputVulkanRulesRelaxed() const { return environment.input.vulkanRulesRelaxed; }
-
-    void setCompileOnly() { compileOnly = true; }
-    bool getCompileOnly() const { return compileOnly; }
-
-    // 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 { }
-    };
-
-    GLSLANG_EXPORT 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.
-    GLSLANG_EXPORT bool preprocess(
-        const TBuiltInResource* builtInResources, int defaultVersion,
-        EProfile defaultProfile, bool forceDefaultVersionAndProfile,
-        bool forwardCompatible, EShMessages message, std::string* outputString,
-        Includer& includer);
-
-    GLSLANG_EXPORT const char* getInfoLog();
-    GLSLANG_EXPORT 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;
-
-    // overrides #version in shader source or default version if #version isn't present
-    int overrideVersion;
-
-    TEnvironment environment;
-
-    // Indicates this shader is meant to be used without linking
-    bool compileOnly = false;
-
-    friend class TProgram;
-
-private:
-    TShader& operator=(TShader&);
-};
-
-//
-// 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:
-    GLSLANG_EXPORT TObjectReflection(const std::string& pName, const TType& pType, int pOffset, int pGLDefineType, int pSize, int pIndex);
-
-    const TType* getType() const { return type; }
-    GLSLANG_EXPORT int getBinding() const;
-    GLSLANG_EXPORT void dump() const;
-    static TObjectReflection badReflection() { return TObjectReflection(); }
-
-    GLSLANG_EXPORT unsigned int layoutLocation() const;
-
-    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, TIntermediate& stageIntermediate) = 0;
-};
-
-// 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; }
-    bool virtual setAutoPushConstantBlock(const char*, unsigned int, TLayoutPacking) { return false; }
-};
-
-// Get the default GLSL IO mapper
-GLSLANG_EXPORT TIoMapper* GetGlslIoMapper();
-
-// 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:
-    GLSLANG_EXPORT TProgram();
-    GLSLANG_EXPORT virtual ~TProgram();
-    void addShader(TShader* shader) { stages[shader->stage].push_back(shader); }
-    std::list<TShader*>& getShaders(EShLanguage stage) { return stages[stage]; }
-    // Link Validation interface
-    GLSLANG_EXPORT bool link(EShMessages);
-    GLSLANG_EXPORT const char* getInfoLog();
-    GLSLANG_EXPORT const char* getInfoDebugLog();
-
-    TIntermediate* getIntermediate(EShLanguage stage) const { return intermediate[stage]; }
-
-    // Reflection Interface
-
-    // call first, to do liveness analysis, index mapping, etc.; returns false on failure
-    GLSLANG_EXPORT bool buildReflection(int opts = EShReflectionDefault);
-    GLSLANG_EXPORT unsigned getLocalSize(int dim) const;                  // return dim'th local size
-    GLSLANG_EXPORT int getReflectionIndex(const char *name) const;
-    GLSLANG_EXPORT int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const;
-    GLSLANG_EXPORT int getNumUniformVariables() const;
-    GLSLANG_EXPORT const TObjectReflection& getUniform(int index) const;
-    GLSLANG_EXPORT int getNumUniformBlocks() const;
-    GLSLANG_EXPORT const TObjectReflection& getUniformBlock(int index) const;
-    GLSLANG_EXPORT int getNumPipeInputs() const;
-    GLSLANG_EXPORT const TObjectReflection& getPipeInput(int index) const;
-    GLSLANG_EXPORT int getNumPipeOutputs() const;
-    GLSLANG_EXPORT const TObjectReflection& getPipeOutput(int index) const;
-    GLSLANG_EXPORT int getNumBufferVariables() const;
-    GLSLANG_EXPORT const TObjectReflection& getBufferVariable(int index) const;
-    GLSLANG_EXPORT int getNumBufferBlocks() const;
-    GLSLANG_EXPORT const TObjectReflection& getBufferBlock(int index) const;
-    GLSLANG_EXPORT int getNumAtomicCounters() const;
-    GLSLANG_EXPORT 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(); }
-
-    GLSLANG_EXPORT void dumpReflection();
-
-    // Get the IO resolver to use for mapIO
-    GLSLANG_EXPORT TIoMapResolver* getGlslIoResolver(EShLanguage stage);
-
-    // 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.
-    GLSLANG_EXPORT bool mapIO(TIoMapResolver* pResolver = nullptr, TIoMapper* pIoMapper = nullptr);
-
-protected:
-    GLSLANG_EXPORT bool linkStage(EShLanguage, EShMessages);
-    GLSLANG_EXPORT bool crossStageCheck(EShMessages);
-
-    TPoolAllocator* pool;
-    std::list<TShader*> stages[EShLangCount];
-    TIntermediate* intermediate[EShLangCount];
-    bool newedIntermediate[EShLangCount];      // track which intermediate were "new" versus reusing a singleton unit in a stage
-    TInfoSink* infoSink;
-    TReflection* reflection;
-    bool linked;
-
-private:
-    TProgram(TProgram&);
-    TProgram& operator=(TProgram&);
-};
-
-} // end namespace glslang
-
-#endif // _COMPILER_INTERFACE_INCLUDED_

-/**
-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 "../Include/glslang_c_interface.h"
-#include "../Include/visibility.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Returns a struct that can be use to create custom resource values.
-GLSLANG_EXPORT glslang_resource_t* glslang_resource(void);
-
-// 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.
-GLSLANG_EXPORT const glslang_resource_t* glslang_default_resource(void);
-
-// Returns the DefaultTBuiltInResource as a human-readable string.
-// NOTE: User is responsible for freeing this string.
-GLSLANG_EXPORT const char* glslang_default_resource_string();
-
-// Decodes the resource limits from |config| to |resources|.
-GLSLANG_EXPORT void glslang_decode_resource_limits(glslang_resource_t* resources, char* config);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_

-//
-// 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
-
-#include <string>
-#include <vector>
-
-#include "Logger.h"
-#include "glslang/Include/visibility.h"
-
-namespace glslang {
-class TIntermediate;
-
-struct SpvOptions {
-    bool generateDebugInfo {false};
-    bool stripDebugInfo {false};
-    bool disableOptimizer {true};
-    bool optimizeSize {false};
-    bool disassemble {false};
-    bool validate {false};
-    bool emitNonSemanticShaderDebugInfo {false};
-    bool emitNonSemanticShaderDebugSource{ false };
-    bool compileOnly{false};
-    bool optimizerAllowExpandedIDBound{false};
-};
-
-GLSLANG_EXPORT void GetSpirvVersion(std::string&);
-GLSLANG_EXPORT int GetSpirvGeneratorVersion();
-GLSLANG_EXPORT void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                                 SpvOptions* options = nullptr);
-GLSLANG_EXPORT void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                                 spv::SpvBuildLogger* logger, SpvOptions* options = nullptr);
-GLSLANG_EXPORT bool OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
-GLSLANG_EXPORT bool OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
-
-}

-//
-// 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 <string>
-#include <vector>
-#include "glslang/Include/visibility.h"
-
-namespace spv {
-
-// A class for holding all SPIR-V build status messages, including
-// missing/TBD functionalities, warnings, and errors.
-class GLSLANG_EXPORT SpvBuildLogger {
-public:
-    SpvBuildLogger() {}
-
-    // 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;
-
-private:
-    SpvBuildLogger(const SpvBuildLogger&);
-
-    std::vector<std::string> tbdFeatures;
-    std::vector<std::string> missingFeatures;
-    std::vector<std::string> warnings;
-    std::vector<std::string> errors;
-};
-
-} // end spv namespace
-
-#endif // GLSLANG_SPIRV_LOGGER_H

-//
-// 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 <string>
-#include <vector>
-#include <cstdlib>
-#include <exception>
-
-#ifdef GLSLANG_IS_SHARED_LIBRARY
-    #ifdef _WIN32
-        #ifdef GLSLANG_EXPORTING
-            #define GLSLANG_EXPORT __declspec(dllexport)
-        #else
-            #define GLSLANG_EXPORT __declspec(dllimport)
-        #endif
-    #elif __GNUC__ >= 4
-        #define GLSLANG_EXPORT __attribute__((visibility("default")))
-    #endif
-#endif // GLSLANG_IS_SHARED_LIBRARY
-#ifndef GLSLANG_EXPORT
-#define GLSLANG_EXPORT
-#endif
-
-namespace spv {
-
-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
-
-#include <functional>
-#include <cstdint>
-#include <unordered_map>
-#include <unordered_set>
-#include <map>
-#include <set>
-#include <cassert>
-
-#include "spirv.hpp"
-
-namespace spv {
-
-static inline constexpr Id NoResult = 0;
-
-// class to hold SPIR-V binary data for remapping, DCE, and debug stripping
-class GLSLANG_EXPORT 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<std::uint32_t>& spv, const std::vector<std::string>& whiteListStrings,
-              std::uint32_t opts = DO_EVERYTHING);
-
-   // remap on an existing binary in memory - legacy interface without white list
-   void remap(std::vector<std::uint32_t>& spv, std::uint32_t opts = DO_EVERYTHING);
-
-   // Type for error/log handler functions
-   typedef std::function<void(const std::string&)> errorfn_t;
-   typedef std::function<void(const std::string&)> 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<spv::Id, spv::Id> idmap_t;
-   typedef std::unordered_set<spv::Id>          idset_t;
-   typedef std::unordered_map<spv::Id, int>     blockmap_t;
-
-   void remap(std::uint32_t opts = DO_EVERYTHING);
-
-   // Map of names to IDs
-   typedef std::unordered_map<std::string, spv::Id> namemap_t;
-
-   typedef std::uint32_t spirword_t;
-
-   typedef std::pair<unsigned, unsigned> range_t;
-   typedef std::function<void(spv::Id&)>                idfn_t;
-   typedef std::function<bool(spv::Op, unsigned start)> 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<spirword_t>        typeentry_t;
-   typedef std::map<spv::Id, typeentry_t> globaltypes_t;
-
-   // A set that preserves position order, and a reverse map
-   typedef std::set<int>                    posmap_t;
-   typedef std::unordered_map<spv::Id, int> posmap_rev_t;
-
-   // Maps and ID to the size of its base type, if known.
-   typedef std::unordered_map<spv::Id, unsigned> 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;
-
-   bool isStripOp(spv::Op opCode, unsigned start) 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<bool> 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<spirword_t> spv;      // SPIR words
-
-   std::vector<std::string> stripWhiteList;
-
-   namemap_t               nameMap;  // ID names from OpName
-
-   // Since we want to also do binary ops, we can't use std::vector<bool>.  we could use
-   // boost::dynamic_bitset, but we're trying to avoid a boost dependency.
-   typedef std::uint64_t bits_t;
-   std::vector<bits_t> 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<spv::Id, range_t> fnPos;
-
-   // Which functions are called, anywhere in the module, with a call count
-   std::unordered_map<spv::Id, int> 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<spv::Id>  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<range_t> 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 // SPIRVREMAPPER_H

-//
-// 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
-
-#if ENABLE_OPT
-#include <vector>
-#include <ostream>
-#include <unordered_set>
-#include "spirv-tools/libspirv.h"
-#endif
-
-#include "glslang/MachineIndependent/Versions.h"
-#include "glslang/Include/visibility.h"
-#include "GlslangToSpv.h"
-#include "Logger.h"
-
-namespace glslang {
-
-#if ENABLE_OPT
-
-class TIntermediate;
-
-// Translate glslang's view of target versioning to what SPIRV-Tools uses.
-GLSLANG_EXPORT spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger);
-GLSLANG_EXPORT spv_target_env MapToSpirvToolsEnv(const glslang::TIntermediate& intermediate, spv::SpvBuildLogger* logger);
-
-// Use the SPIRV-Tools disassembler to print SPIR-V using a SPV_ENV_UNIVERSAL_1_3 environment.
-GLSLANG_EXPORT void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv);
-
-// Use the SPIRV-Tools disassembler to print SPIR-V with a provided SPIR-V environment.
-GLSLANG_EXPORT void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv,
-                                          spv_target_env requested_context);
-
-// Apply the SPIRV-Tools validator to generated SPIR-V.
-GLSLANG_EXPORT void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                                       spv::SpvBuildLogger*, bool prelegalization);
-
-// Apply the SPIRV-Tools optimizer to generated SPIR-V.  HLSL SPIR-V is legalized in the process.
-GLSLANG_EXPORT void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                                        spv::SpvBuildLogger*, const SpvOptions*);
-
-// Apply the SPIRV-Tools EliminateDeadInputComponents pass to generated SPIR-V. Put result in |spirv|.
-GLSLANG_EXPORT void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
-                                                           spv::SpvBuildLogger*);
-
-// Apply the SPIRV-Tools AnalyzeDeadOutputStores pass to generated SPIR-V. Put result in |live_locs|.
-// Return true if the result is valid.
-GLSLANG_EXPORT bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
-                                                      std::unordered_set<uint32_t>* live_locs,
-                                                      std::unordered_set<uint32_t>* live_builtins,
-                                                      spv::SpvBuildLogger*);
-
-// Apply the SPIRV-Tools EliminateDeadOutputStores and AggressiveDeadCodeElimination passes to generated SPIR-V using
-// |live_locs|. Put result in |spirv|.
-GLSLANG_EXPORT void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
-                                                        std::unordered_set<uint32_t>* live_locs,
-                                                        std::unordered_set<uint32_t>* live_builtins,
-                                                        spv::SpvBuildLogger*);
-
-// Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V.  This is implicitly done by
-// SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
-// optimization is disabled.
-GLSLANG_EXPORT void SpirvToolsStripDebugInfo(const glslang::TIntermediate& intermediate,
-                                             std::vector<unsigned int>& spirv, spv::SpvBuildLogger*);
-
-#endif
-
-} // end namespace glslang
-
-#endif // GLSLANG_SPV_TOOLS_H

-//
-// 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 <iostream>
-#include <vector>
-
-#include "glslang/Include/visibility.h"
-
-namespace spv {
-
-    // disassemble with glslang custom disassembler
-    GLSLANG_EXPORT void Disassemble(std::ostream& out, const std::vector<unsigned int>&);
-
-}  // end namespace spv
-
-#endif // disassembler_H

-// Copyright (C) 2020 The Khronos Group 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 The Khronos Group 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_BUILD_INFO
-#define GLSLANG_BUILD_INFO
-
-#define GLSLANG_VERSION_MAJOR 15
-#define GLSLANG_VERSION_MINOR 1
-#define GLSLANG_VERSION_PATCH 0
-#define GLSLANG_VERSION_FLAVOR ""
-
-#define GLSLANG_VERSION_GREATER_THAN(major, minor, patch) \
-    ((GLSLANG_VERSION_MAJOR) > (major) || ((major) == GLSLANG_VERSION_MAJOR && \
-    ((GLSLANG_VERSION_MINOR) > (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
-     (GLSLANG_VERSION_PATCH) > (patch)))))
-
-#define GLSLANG_VERSION_GREATER_OR_EQUAL_TO(major, minor, patch) \
-    ((GLSLANG_VERSION_MAJOR) > (major) || ((major) == GLSLANG_VERSION_MAJOR && \
-    ((GLSLANG_VERSION_MINOR) > (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
-     (GLSLANG_VERSION_PATCH >= (patch))))))
-
-#define GLSLANG_VERSION_LESS_THAN(major, minor, patch) \
-    ((GLSLANG_VERSION_MAJOR) < (major) || ((major) == GLSLANG_VERSION_MAJOR && \
-    ((GLSLANG_VERSION_MINOR) < (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
-     (GLSLANG_VERSION_PATCH) < (patch)))))
-
-#define GLSLANG_VERSION_LESS_OR_EQUAL_TO(major, minor, patch) \
-    ((GLSLANG_VERSION_MAJOR) < (major) || ((major) == GLSLANG_VERSION_MAJOR && \
-    ((GLSLANG_VERSION_MINOR) < (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
-     (GLSLANG_VERSION_PATCH <= (patch))))))
-
-#endif // GLSLANG_BUILD_INFO

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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 NCNN_ALLOCATOR_H
-#define NCNN_ALLOCATOR_H
-
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif
-
-#include "platform.h"
-
-#include <stdlib.h>
-
-#if NCNN_PLATFORM_API
-#if __ANDROID_API__ >= 26
-#include <android/hardware_buffer.h>
-#endif // __ANDROID_API__ >= 26
-#endif // NCNN_PLATFORM_API
-
-namespace ncnn {
-
-// the alignment of all the allocated buffers
-#if NCNN_AVX512
-#define NCNN_MALLOC_ALIGN 64
-#elif NCNN_AVX
-#define NCNN_MALLOC_ALIGN 32
-#else
-#define NCNN_MALLOC_ALIGN 16
-#endif
-
-// we have some optimized kernels that may overread buffer a bit in loop
-// it is common to interleave next-loop data load with arithmetic instructions
-// allocating more bytes keeps us safe from SEGV_ACCERR failure
-#define NCNN_MALLOC_OVERREAD 64
-
-// Aligns a pointer to the specified number of bytes
-// ptr Aligned pointer
-// n Alignment size that must be a power of two
-template<typename _Tp>
-static NCNN_FORCEINLINE _Tp* alignPtr(_Tp* ptr, int n = (int)sizeof(_Tp))
-{
-    return (_Tp*)(((size_t)ptr + n - 1) & -n);
-}
-
-// Aligns a buffer size to the specified number of bytes
-// The function returns the minimum number that is greater or equal to sz and is divisible by n
-// sz Buffer size to align
-// n Alignment size that must be a power of two
-static NCNN_FORCEINLINE size_t alignSize(size_t sz, int n)
-{
-    return (sz + n - 1) & -n;
-}
-
-static NCNN_FORCEINLINE void* fastMalloc(size_t size)
-{
-#if _MSC_VER
-    return _aligned_malloc(size, NCNN_MALLOC_ALIGN);
-#elif (defined(__unix__) || defined(__APPLE__)) && _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
-    void* ptr = 0;
-    if (posix_memalign(&ptr, NCNN_MALLOC_ALIGN, size + NCNN_MALLOC_OVERREAD))
-        ptr = 0;
-    return ptr;
-#elif __ANDROID__ && __ANDROID_API__ < 17
-    return memalign(NCNN_MALLOC_ALIGN, size + NCNN_MALLOC_OVERREAD);
-#else
-    unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + NCNN_MALLOC_ALIGN + NCNN_MALLOC_OVERREAD);
-    if (!udata)
-        return 0;
-    unsigned char** adata = alignPtr((unsigned char**)udata + 1, NCNN_MALLOC_ALIGN);
-    adata[-1] = udata;
-    return adata;
-#endif
-}
-
-static NCNN_FORCEINLINE void fastFree(void* ptr)
-{
-    if (ptr)
-    {
-#if _MSC_VER
-        _aligned_free(ptr);
-#elif (defined(__unix__) || defined(__APPLE__)) && _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
-        free(ptr);
-#elif __ANDROID__ && __ANDROID_API__ < 17
-        free(ptr);
-#else
-        unsigned char* udata = ((unsigned char**)ptr)[-1];
-        free(udata);
-#endif
-    }
-}
-
-#if NCNN_THREADS
-// exchange-add operation for atomic operations on reference counters
-#if defined __riscv && !defined __riscv_atomic
-// riscv target without A extension
-static NCNN_FORCEINLINE int NCNN_XADD(int* addr, int delta)
-{
-    int tmp = *addr;
-    *addr += delta;
-    return tmp;
-}
-#elif defined __INTEL_COMPILER && !(defined WIN32 || defined _WIN32)
-// atomic increment on the linux version of the Intel(tm) compiler
-#define NCNN_XADD(addr, delta) (int)_InterlockedExchangeAdd(const_cast<void*>(reinterpret_cast<volatile void*>(addr)), delta)
-#elif defined __GNUC__
-#if defined __clang__ && __clang_major__ >= 3 && !defined __ANDROID__ && !defined __EMSCRIPTEN__ && !defined(__CUDACC__)
-#ifdef __ATOMIC_ACQ_REL
-#define NCNN_XADD(addr, delta) __c11_atomic_fetch_add((_Atomic(int)*)(addr), delta, __ATOMIC_ACQ_REL)
-#else
-#define NCNN_XADD(addr, delta) __atomic_fetch_add((_Atomic(int)*)(addr), delta, 4)
-#endif
-#else
-#if defined __ATOMIC_ACQ_REL && !defined __clang__
-// version for gcc >= 4.7
-#define NCNN_XADD(addr, delta) (int)__atomic_fetch_add((unsigned*)(addr), (unsigned)(delta), __ATOMIC_ACQ_REL)
-#else
-#define NCNN_XADD(addr, delta) (int)__sync_fetch_and_add((unsigned*)(addr), (unsigned)(delta))
-#endif
-#endif
-#elif defined _MSC_VER && !defined RC_INVOKED
-#define NCNN_XADD(addr, delta) (int)_InterlockedExchangeAdd((long volatile*)addr, delta)
-#else
-// thread-unsafe branch
-static NCNN_FORCEINLINE int NCNN_XADD(int* addr, int delta)
-{
-    int tmp = *addr;
-    *addr += delta;
-    return tmp;
-}
-#endif
-#else  // NCNN_THREADS
-static NCNN_FORCEINLINE int NCNN_XADD(int* addr, int delta)
-{
-    int tmp = *addr;
-    *addr += delta;
-    return tmp;
-}
-#endif // NCNN_THREADS
-
-class NCNN_EXPORT Allocator
-{
-public:
-    virtual ~Allocator();
-    virtual void* fastMalloc(size_t size) = 0;
-    virtual void fastFree(void* ptr) = 0;
-};
-
-class PoolAllocatorPrivate;
-class NCNN_EXPORT PoolAllocator : public Allocator
-{
-public:
-    PoolAllocator();
-    ~PoolAllocator();
-
-    // ratio range 0 ~ 1
-    // default cr = 0
-    void set_size_compare_ratio(float scr);
-
-    // budget drop threshold
-    // default threshold = 10
-    void set_size_drop_threshold(size_t);
-
-    // release all budgets immediately
-    void clear();
-
-    virtual void* fastMalloc(size_t size);
-    virtual void fastFree(void* ptr);
-
-private:
-    PoolAllocator(const PoolAllocator&);
-    PoolAllocator& operator=(const PoolAllocator&);
-
-private:
-    PoolAllocatorPrivate* const d;
-};
-
-class UnlockedPoolAllocatorPrivate;
-class NCNN_EXPORT UnlockedPoolAllocator : public Allocator
-{
-public:
-    UnlockedPoolAllocator();
-    ~UnlockedPoolAllocator();
-
-    // ratio range 0 ~ 1
-    // default cr = 0
-    void set_size_compare_ratio(float scr);
-
-    // budget drop threshold
-    // default threshold = 10
-    void set_size_drop_threshold(size_t);
-
-    // release all budgets immediately
-    void clear();
-
-    virtual void* fastMalloc(size_t size);
-    virtual void fastFree(void* ptr);
-
-private:
-    UnlockedPoolAllocator(const UnlockedPoolAllocator&);
-    UnlockedPoolAllocator& operator=(const UnlockedPoolAllocator&);
-
-private:
-    UnlockedPoolAllocatorPrivate* const d;
-};
-
-#if NCNN_VULKAN
-
-class VulkanDevice;
-
-class NCNN_EXPORT VkBufferMemory
-{
-public:
-    VkBuffer buffer;
-
-    // the base offset assigned by allocator
-    size_t offset;
-    size_t capacity;
-
-    VkDeviceMemory memory;
-    void* mapped_ptr;
-
-    // buffer state, modified by command functions internally
-    mutable VkAccessFlags access_flags;
-    mutable VkPipelineStageFlags stage_flags;
-
-    // initialize and modified by mat
-    int refcount;
-};
-
-class NCNN_EXPORT VkImageMemory
-{
-public:
-    VkImage image;
-    VkImageView imageview;
-
-    // underlying info assigned by allocator
-    int width;
-    int height;
-    int depth;
-    VkFormat format;
-
-    VkDeviceMemory memory;
-    void* mapped_ptr;
-
-    // the base offset assigned by allocator
-    size_t bind_offset;
-    size_t bind_capacity;
-
-    // image state, modified by command functions internally
-    mutable VkAccessFlags access_flags;
-    mutable VkImageLayout image_layout;
-    mutable VkPipelineStageFlags stage_flags;
-
-    // in-execution state, modified by command functions internally
-    mutable int command_refcount;
-
-    // initialize and modified by mat
-    int refcount;
-};
-
-class NCNN_EXPORT VkAllocator
-{
-public:
-    explicit VkAllocator(const VulkanDevice* _vkdev);
-    virtual ~VkAllocator();
-
-    virtual void clear();
-
-    virtual VkBufferMemory* fastMalloc(size_t size) = 0;
-    virtual void fastFree(VkBufferMemory* ptr) = 0;
-    virtual int flush(VkBufferMemory* ptr);
-    virtual int invalidate(VkBufferMemory* ptr);
-
-    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack) = 0;
-    virtual void fastFree(VkImageMemory* ptr) = 0;
-
-public:
-    const VulkanDevice* vkdev;
-    uint32_t buffer_memory_type_index;
-    uint32_t image_memory_type_index;
-    uint32_t reserved_type_index;
-    bool mappable;
-    bool coherent;
-
-protected:
-    VkBuffer create_buffer(size_t size, VkBufferUsageFlags usage);
-    VkDeviceMemory allocate_memory(size_t size, uint32_t memory_type_index);
-    VkDeviceMemory allocate_dedicated_memory(size_t size, uint32_t memory_type_index, VkImage image, VkBuffer buffer);
-
-    VkImage create_image(int width, int height, int depth, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage);
-    VkImageView create_imageview(VkImage image, VkFormat format);
-};
-
-class VkBlobAllocatorPrivate;
-class NCNN_EXPORT VkBlobAllocator : public VkAllocator
-{
-public:
-    explicit VkBlobAllocator(const VulkanDevice* vkdev, size_t preferred_block_size = 16 * 1024 * 1024); // 16M
-    virtual ~VkBlobAllocator();
-
-public:
-    // release all budgets immediately
-    virtual void clear();
-
-    virtual VkBufferMemory* fastMalloc(size_t size);
-    virtual void fastFree(VkBufferMemory* ptr);
-    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
-    virtual void fastFree(VkImageMemory* ptr);
-
-private:
-    VkBlobAllocator(const VkBlobAllocator&);
-    VkBlobAllocator& operator=(const VkBlobAllocator&);
-
-private:
-    VkBlobAllocatorPrivate* const d;
-};
-
-class VkWeightAllocatorPrivate;
-class NCNN_EXPORT VkWeightAllocator : public VkAllocator
-{
-public:
-    explicit VkWeightAllocator(const VulkanDevice* vkdev, size_t preferred_block_size = 8 * 1024 * 1024); // 8M
-    virtual ~VkWeightAllocator();
-
-public:
-    // release all blocks immediately
-    virtual void clear();
-
-public:
-    virtual VkBufferMemory* fastMalloc(size_t size);
-    virtual void fastFree(VkBufferMemory* ptr);
-    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
-    virtual void fastFree(VkImageMemory* ptr);
-
-private:
-    VkWeightAllocator(const VkWeightAllocator&);
-    VkWeightAllocator& operator=(const VkWeightAllocator&);
-
-private:
-    VkWeightAllocatorPrivate* const d;
-};
-
-class VkStagingAllocatorPrivate;
-class NCNN_EXPORT VkStagingAllocator : public VkAllocator
-{
-public:
-    explicit VkStagingAllocator(const VulkanDevice* vkdev);
-    virtual ~VkStagingAllocator();
-
-public:
-    // ratio range 0 ~ 1
-    // default cr = 0.75
-    void set_size_compare_ratio(float scr);
-
-    // release all budgets immediately
-    virtual void clear();
-
-    virtual VkBufferMemory* fastMalloc(size_t size);
-    virtual void fastFree(VkBufferMemory* ptr);
-    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
-    virtual void fastFree(VkImageMemory* ptr);
-
-private:
-    VkStagingAllocator(const VkStagingAllocator&);
-    VkStagingAllocator& operator=(const VkStagingAllocator&);
-
-private:
-    VkStagingAllocatorPrivate* const d;
-};
-
-class VkWeightStagingAllocatorPrivate;
-class NCNN_EXPORT VkWeightStagingAllocator : public VkAllocator
-{
-public:
-    explicit VkWeightStagingAllocator(const VulkanDevice* vkdev);
-    virtual ~VkWeightStagingAllocator();
-
-public:
-    virtual VkBufferMemory* fastMalloc(size_t size);
-    virtual void fastFree(VkBufferMemory* ptr);
-    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
-    virtual void fastFree(VkImageMemory* ptr);
-
-private:
-    VkWeightStagingAllocator(const VkWeightStagingAllocator&);
-    VkWeightStagingAllocator& operator=(const VkWeightStagingAllocator&);
-
-private:
-    VkWeightStagingAllocatorPrivate* const d;
-};
-
-#if NCNN_PLATFORM_API
-#if __ANDROID_API__ >= 26
-class NCNN_EXPORT VkAndroidHardwareBufferImageAllocator : public VkAllocator
-{
-public:
-    VkAndroidHardwareBufferImageAllocator(const VulkanDevice* _vkdev, AHardwareBuffer* _hb);
-    virtual ~VkAndroidHardwareBufferImageAllocator();
-
-public:
-    virtual VkBufferMemory* fastMalloc(size_t size);
-    virtual void fastFree(VkBufferMemory* ptr);
-    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
-    virtual void fastFree(VkImageMemory* ptr);
-
-private:
-    VkAndroidHardwareBufferImageAllocator(const VkAndroidHardwareBufferImageAllocator&);
-    VkAndroidHardwareBufferImageAllocator& operator=(const VkAndroidHardwareBufferImageAllocator&);
-
-public:
-    int init();
-
-    int width() const;
-    int height() const;
-    uint64_t external_format() const;
-
-public:
-    AHardwareBuffer* hb;
-    AHardwareBuffer_Desc bufferDesc;
-    VkAndroidHardwareBufferFormatPropertiesANDROID bufferFormatProperties;
-    VkAndroidHardwareBufferPropertiesANDROID bufferProperties;
-    VkSamplerYcbcrConversionKHR samplerYcbcrConversion;
-};
-#endif // __ANDROID_API__ >= 26
-#endif // NCNN_PLATFORM_API
-
-#endif // NCNN_VULKAN
-
-} // namespace ncnn
-
-#endif // NCNN_ALLOCATOR_H

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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 NCNN_BENCHMARK_H
-#define NCNN_BENCHMARK_H
-
-#include "layer.h"
-#include "mat.h"
-#include "platform.h"
-
-namespace ncnn {
-
-// get now timestamp in ms
-NCNN_EXPORT double get_current_time();
-
-// sleep milliseconds
-NCNN_EXPORT void sleep(unsigned long long int milliseconds = 1000);
-
-#if NCNN_BENCHMARK
-
-NCNN_EXPORT void benchmark(const Layer* layer, double start, double end);
-NCNN_EXPORT void benchmark(const Layer* layer, const Mat& bottom_blob, Mat& top_blob, double start, double end);
-
-#endif // NCNN_BENCHMARK
-
-} // namespace ncnn
-
-#endif // NCNN_BENCHMARK_H

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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 NCNN_BLOB_H
-#define NCNN_BLOB_H
-
-#include "mat.h"
-#include "platform.h"
-
-namespace ncnn {
-
-class NCNN_EXPORT Blob
-{
-public:
-    // empty
-    Blob();
-
-public:
-#if NCNN_STRING
-    // blob name
-    std::string name;
-#endif // NCNN_STRING
-    // layer index which produce this blob as output
-    int producer;
-    // layer index which need this blob as input
-    int consumer;
-    // shape hint
-    Mat shape;
-};
-
-} // namespace ncnn
-
-#endif // NCNN_BLOB_H

-/* Tencent is pleased to support the open source community by making ncnn available.
- *
- * Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
- *
- * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
- * in compliance with the License. You may obtain a copy of the License at
- *
- * https://opensource.org/licenses/BSD-3-Clause
- *
- * 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 NCNN_C_API_H
-#define NCNN_C_API_H
-
-#include "platform.h"
-
-#if NCNN_C_API
-
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-NCNN_EXPORT const char* ncnn_version(void);
-
-/* allocator api */
-typedef struct __ncnn_allocator_t* ncnn_allocator_t;
-struct NCNN_EXPORT __ncnn_allocator_t
-{
-    void* pthis;
-
-    void* (*fast_malloc)(ncnn_allocator_t allocator, size_t size);
-    void (*fast_free)(ncnn_allocator_t allocator, void* ptr);
-};
-
-NCNN_EXPORT ncnn_allocator_t ncnn_allocator_create_pool_allocator(void);
-NCNN_EXPORT ncnn_allocator_t ncnn_allocator_create_unlocked_pool_allocator(void);
-NCNN_EXPORT void ncnn_allocator_destroy(ncnn_allocator_t allocator);
-
-/* option api */
-typedef struct __ncnn_option_t* ncnn_option_t;
-
-NCNN_EXPORT ncnn_option_t ncnn_option_create(void);
-NCNN_EXPORT void ncnn_option_destroy(ncnn_option_t opt);
-
-NCNN_EXPORT int ncnn_option_get_num_threads(const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_option_set_num_threads(ncnn_option_t opt, int num_threads);
-
-NCNN_EXPORT int ncnn_option_get_use_local_pool_allocator(const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_option_set_use_local_pool_allocator(ncnn_option_t opt, int use_local_pool_allocator);
-
-NCNN_EXPORT void ncnn_option_set_blob_allocator(ncnn_option_t opt, ncnn_allocator_t allocator);
-NCNN_EXPORT void ncnn_option_set_workspace_allocator(ncnn_option_t opt, ncnn_allocator_t allocator);
-
-NCNN_EXPORT int ncnn_option_get_use_vulkan_compute(const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_option_set_use_vulkan_compute(ncnn_option_t opt, int use_vulkan_compute);
-
-/* mat api */
-typedef struct __ncnn_mat_t* ncnn_mat_t;
-
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create(void);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_1d(int w, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_2d(int w, int h, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_3d(int w, int h, int c, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_4d(int w, int h, int d, int c, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_1d(int w, void* data, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_2d(int w, int h, void* data, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_3d(int w, int h, int c, void* data, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_4d(int w, int h, int d, int c, void* data, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_1d_elem(int w, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_2d_elem(int w, int h, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_3d_elem(int w, int h, int c, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_4d_elem(int w, int h, int d, int c, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_1d_elem(int w, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_2d_elem(int w, int h, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_3d_elem(int w, int h, int c, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_4d_elem(int w, int h, int d, int c, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
-NCNN_EXPORT void ncnn_mat_destroy(ncnn_mat_t mat);
-
-NCNN_EXPORT void ncnn_mat_fill_float(ncnn_mat_t mat, float v);
-
-NCNN_EXPORT ncnn_mat_t ncnn_mat_clone(const ncnn_mat_t mat, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_1d(const ncnn_mat_t mat, int w, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_2d(const ncnn_mat_t mat, int w, int h, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_3d(const ncnn_mat_t mat, int w, int h, int c, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_4d(const ncnn_mat_t mat, int w, int h, int d, int c, ncnn_allocator_t allocator);
-
-NCNN_EXPORT int ncnn_mat_get_dims(const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_mat_get_w(const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_mat_get_h(const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_mat_get_d(const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_mat_get_c(const ncnn_mat_t mat);
-NCNN_EXPORT size_t ncnn_mat_get_elemsize(const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_mat_get_elempack(const ncnn_mat_t mat);
-NCNN_EXPORT size_t ncnn_mat_get_cstep(const ncnn_mat_t mat);
-NCNN_EXPORT void* ncnn_mat_get_data(const ncnn_mat_t mat);
-
-NCNN_EXPORT void* ncnn_mat_get_channel_data(const ncnn_mat_t mat, int c);
-
-#if NCNN_PIXEL
-
-/* mat pixel api */
-#define NCNN_MAT_PIXEL_RGB       1
-#define NCNN_MAT_PIXEL_BGR       2
-#define NCNN_MAT_PIXEL_GRAY      3
-#define NCNN_MAT_PIXEL_RGBA      4
-#define NCNN_MAT_PIXEL_BGRA      5
-#define NCNN_MAT_PIXEL_X2Y(X, Y) (X | (Y << 16))
-NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels(const unsigned char* pixels, int type, int w, int h, int stride, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels_resize(const unsigned char* pixels, int type, int w, int h, int stride, int target_width, int target_height, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels_roi(const unsigned char* pixels, int type, int w, int h, int stride, int roix, int roiy, int roiw, int roih, ncnn_allocator_t allocator);
-NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels_roi_resize(const unsigned char* pixels, int type, int w, int h, int stride, int roix, int roiy, int roiw, int roih, int target_width, int target_height, ncnn_allocator_t allocator);
-NCNN_EXPORT void ncnn_mat_to_pixels(const ncnn_mat_t mat, unsigned char* pixels, int type, int stride);
-NCNN_EXPORT void ncnn_mat_to_pixels_resize(const ncnn_mat_t mat, unsigned char* pixels, int type, int target_width, int target_height, int target_stride);
-
-#endif /* NCNN_PIXEL */
-
-NCNN_EXPORT void ncnn_mat_substract_mean_normalize(ncnn_mat_t mat, const float* mean_vals, const float* norm_vals);
-
-NCNN_EXPORT void ncnn_convert_packing(const ncnn_mat_t src, ncnn_mat_t* dst, int elempack, const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_flatten(const ncnn_mat_t src, ncnn_mat_t* dst, const ncnn_option_t opt);
-
-/* blob api */
-typedef struct __ncnn_blob_t* ncnn_blob_t;
-
-#if NCNN_STRING
-NCNN_EXPORT const char* ncnn_blob_get_name(const ncnn_blob_t blob);
-#endif /* NCNN_STRING */
-
-NCNN_EXPORT int ncnn_blob_get_producer(const ncnn_blob_t blob);
-NCNN_EXPORT int ncnn_blob_get_consumer(const ncnn_blob_t blob);
-
-NCNN_EXPORT void ncnn_blob_get_shape(const ncnn_blob_t blob, int* dims, int* w, int* h, int* c);
-
-/* paramdict api */
-typedef struct __ncnn_paramdict_t* ncnn_paramdict_t;
-
-NCNN_EXPORT ncnn_paramdict_t ncnn_paramdict_create(void);
-NCNN_EXPORT void ncnn_paramdict_destroy(ncnn_paramdict_t pd);
-
-NCNN_EXPORT int ncnn_paramdict_get_type(const ncnn_paramdict_t pd, int id);
-
-NCNN_EXPORT int ncnn_paramdict_get_int(const ncnn_paramdict_t pd, int id, int def);
-NCNN_EXPORT float ncnn_paramdict_get_float(const ncnn_paramdict_t pd, int id, float def);
-NCNN_EXPORT ncnn_mat_t ncnn_paramdict_get_array(const ncnn_paramdict_t pd, int id, const ncnn_mat_t def);
-
-NCNN_EXPORT void ncnn_paramdict_set_int(ncnn_paramdict_t pd, int id, int i);
-NCNN_EXPORT void ncnn_paramdict_set_float(ncnn_paramdict_t pd, int id, float f);
-NCNN_EXPORT void ncnn_paramdict_set_array(ncnn_paramdict_t pd, int id, const ncnn_mat_t v);
-
-/* datareader api */
-typedef struct __ncnn_datareader_t* ncnn_datareader_t;
-struct NCNN_EXPORT __ncnn_datareader_t
-{
-    void* pthis;
-
-#if NCNN_STRING
-    int (*scan)(ncnn_datareader_t dr, const char* format, void* p);
-#endif /* NCNN_STRING */
-    size_t (*read)(ncnn_datareader_t dr, void* buf, size_t size);
-};
-
-NCNN_EXPORT ncnn_datareader_t ncnn_datareader_create(void);
-#if NCNN_STDIO
-NCNN_EXPORT ncnn_datareader_t ncnn_datareader_create_from_stdio(FILE* fp);
-#endif /* NCNN_STDIO */
-NCNN_EXPORT ncnn_datareader_t ncnn_datareader_create_from_memory(const unsigned char** mem);
-NCNN_EXPORT void ncnn_datareader_destroy(ncnn_datareader_t dr);
-
-/* modelbin api */
-typedef struct __ncnn_modelbin_t* ncnn_modelbin_t;
-struct NCNN_EXPORT __ncnn_modelbin_t
-{
-    void* pthis;
-
-    ncnn_mat_t (*load_1d)(const ncnn_modelbin_t mb, int w, int type);
-    ncnn_mat_t (*load_2d)(const ncnn_modelbin_t mb, int w, int h, int type);
-    ncnn_mat_t (*load_3d)(const ncnn_modelbin_t mb, int w, int h, int c, int type);
-};
-
-NCNN_EXPORT ncnn_modelbin_t ncnn_modelbin_create_from_datareader(const ncnn_datareader_t dr);
-NCNN_EXPORT ncnn_modelbin_t ncnn_modelbin_create_from_mat_array(const ncnn_mat_t* weights, int n);
-NCNN_EXPORT void ncnn_modelbin_destroy(ncnn_modelbin_t mb);
-
-/* layer api */
-typedef struct __ncnn_layer_t* ncnn_layer_t;
-struct NCNN_EXPORT __ncnn_layer_t
-{
-    void* pthis;
-
-    int (*load_param)(ncnn_layer_t layer, const ncnn_paramdict_t pd);
-    int (*load_model)(ncnn_layer_t layer, const ncnn_modelbin_t mb);
-
-    int (*create_pipeline)(ncnn_layer_t layer, const ncnn_option_t opt);
-    int (*destroy_pipeline)(ncnn_layer_t layer, const ncnn_option_t opt);
-
-    int (*forward_1)(const ncnn_layer_t layer, const ncnn_mat_t bottom_blob, ncnn_mat_t* top_blob, const ncnn_option_t opt);
-    int (*forward_n)(const ncnn_layer_t layer, const ncnn_mat_t* bottom_blobs, int n, ncnn_mat_t* top_blobs, int n2, const ncnn_option_t opt);
-
-    int (*forward_inplace_1)(const ncnn_layer_t layer, ncnn_mat_t bottom_top_blob, const ncnn_option_t opt);
-    int (*forward_inplace_n)(const ncnn_layer_t layer, ncnn_mat_t* bottom_top_blobs, int n, const ncnn_option_t opt);
-};
-
-NCNN_EXPORT ncnn_layer_t ncnn_layer_create(void);
-NCNN_EXPORT ncnn_layer_t ncnn_layer_create_by_typeindex(int typeindex);
-#if NCNN_STRING
-NCNN_EXPORT ncnn_layer_t ncnn_layer_create_by_type(const char* type);
-NCNN_EXPORT int ncnn_layer_type_to_index(const char* type);
-#endif /* NCNN_STRING */
-NCNN_EXPORT void ncnn_layer_destroy(ncnn_layer_t layer);
-
-#if NCNN_STRING
-NCNN_EXPORT const char* ncnn_layer_get_name(const ncnn_layer_t layer);
-#endif /* NCNN_STRING */
-
-NCNN_EXPORT int ncnn_layer_get_typeindex(const ncnn_layer_t layer);
-#if NCNN_STRING
-NCNN_EXPORT const char* ncnn_layer_get_type(const ncnn_layer_t layer);
-#endif /* NCNN_STRING */
-
-NCNN_EXPORT int ncnn_layer_get_one_blob_only(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_support_inplace(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_support_vulkan(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_support_packing(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_support_bf16_storage(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_support_fp16_storage(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_support_image_storage(const ncnn_layer_t layer);
-
-NCNN_EXPORT void ncnn_layer_set_one_blob_only(ncnn_layer_t layer, int enable);
-NCNN_EXPORT void ncnn_layer_set_support_inplace(ncnn_layer_t layer, int enable);
-NCNN_EXPORT void ncnn_layer_set_support_vulkan(ncnn_layer_t layer, int enable);
-NCNN_EXPORT void ncnn_layer_set_support_packing(ncnn_layer_t layer, int enable);
-NCNN_EXPORT void ncnn_layer_set_support_bf16_storage(ncnn_layer_t layer, int enable);
-NCNN_EXPORT void ncnn_layer_set_support_fp16_storage(ncnn_layer_t layer, int enable);
-NCNN_EXPORT void ncnn_layer_set_support_image_storage(ncnn_layer_t layer, int enable);
-
-NCNN_EXPORT int ncnn_layer_get_bottom_count(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_bottom(const ncnn_layer_t layer, int i);
-NCNN_EXPORT int ncnn_layer_get_top_count(const ncnn_layer_t layer);
-NCNN_EXPORT int ncnn_layer_get_top(const ncnn_layer_t layer, int i);
-
-NCNN_EXPORT void ncnn_blob_get_bottom_shape(const ncnn_layer_t layer, int i, int* dims, int* w, int* h, int* c);
-NCNN_EXPORT void ncnn_blob_get_top_shape(const ncnn_layer_t layer, int i, int* dims, int* w, int* h, int* c);
-
-/* layer factory function */
-typedef ncnn_layer_t (*ncnn_layer_creator_t)(void* userdata);
-typedef void (*ncnn_layer_destroyer_t)(ncnn_layer_t layer, void* userdata);
-
-typedef struct __ncnn_net_custom_layer_factory_t* ncnn_net_custom_layer_factory_t;
-struct __ncnn_net_custom_layer_factory_t
-{
-    ncnn_layer_creator_t creator;
-    ncnn_layer_destroyer_t destroyer;
-    void* userdata;
-    ncnn_net_custom_layer_factory_t next;
-};
-
-/* net api */
-typedef struct __ncnn_net_t* ncnn_net_t;
-struct __ncnn_net_t
-{
-    void* pthis;
-
-    ncnn_net_custom_layer_factory_t custom_layer_factory;
-};
-
-NCNN_EXPORT ncnn_net_t ncnn_net_create(void);
-NCNN_EXPORT void ncnn_net_destroy(ncnn_net_t net);
-
-NCNN_EXPORT ncnn_option_t ncnn_net_get_option(ncnn_net_t net);
-NCNN_EXPORT void ncnn_net_set_option(ncnn_net_t net, ncnn_option_t opt);
-
-#if NCNN_VULKAN
-NCNN_EXPORT void ncnn_net_set_vulkan_device(ncnn_net_t net, int device_index);
-#endif
-
-#if NCNN_STRING
-NCNN_EXPORT void ncnn_net_register_custom_layer_by_type(ncnn_net_t net, const char* type, ncnn_layer_creator_t creator, ncnn_layer_destroyer_t destroyer, void* userdata);
-#endif /* NCNN_STRING */
-NCNN_EXPORT void ncnn_net_register_custom_layer_by_typeindex(ncnn_net_t net, int typeindex, ncnn_layer_creator_t creator, ncnn_layer_destroyer_t destroyer, void* userdata);
-
-#if NCNN_STDIO
-#if NCNN_STRING
-NCNN_EXPORT int ncnn_net_load_param(ncnn_net_t net, const char* path);
-#endif /* NCNN_STRING */
-NCNN_EXPORT int ncnn_net_load_param_bin(ncnn_net_t net, const char* path);
-NCNN_EXPORT int ncnn_net_load_model(ncnn_net_t net, const char* path);
-#endif /* NCNN_STDIO */
-
-#if NCNN_STDIO
-#if NCNN_STRING
-NCNN_EXPORT int ncnn_net_load_param_memory(ncnn_net_t net, const char* mem);
-#endif /* NCNN_STRING */
-#endif /* NCNN_STDIO */
-NCNN_EXPORT int ncnn_net_load_param_bin_memory(ncnn_net_t net, const unsigned char* mem);
-NCNN_EXPORT int ncnn_net_load_model_memory(ncnn_net_t net, const unsigned char* mem);
-
-#if NCNN_STRING
-NCNN_EXPORT int ncnn_net_load_param_datareader(ncnn_net_t net, const ncnn_datareader_t dr);
-#endif /* NCNN_STRING */
-NCNN_EXPORT int ncnn_net_load_param_bin_datareader(ncnn_net_t net, const ncnn_datareader_t dr);
-NCNN_EXPORT int ncnn_net_load_model_datareader(ncnn_net_t net, const ncnn_datareader_t dr);
-
-NCNN_EXPORT void ncnn_net_clear(ncnn_net_t net);
-
-NCNN_EXPORT int ncnn_net_get_input_count(const ncnn_net_t net);
-NCNN_EXPORT int ncnn_net_get_output_count(const ncnn_net_t net);
-#if NCNN_STRING
-NCNN_EXPORT const char* ncnn_net_get_input_name(const ncnn_net_t net, int i);
-NCNN_EXPORT const char* ncnn_net_get_output_name(const ncnn_net_t net, int i);
-#endif /* NCNN_STRING */
-NCNN_EXPORT int ncnn_net_get_input_index(const ncnn_net_t net, int i);
-NCNN_EXPORT int ncnn_net_get_output_index(const ncnn_net_t net, int i);
-
-/* extractor api */
-typedef struct __ncnn_extractor_t* ncnn_extractor_t;
-
-NCNN_EXPORT ncnn_extractor_t ncnn_extractor_create(ncnn_net_t net);
-NCNN_EXPORT void ncnn_extractor_destroy(ncnn_extractor_t ex);
-
-NCNN_EXPORT void ncnn_extractor_set_option(ncnn_extractor_t ex, const ncnn_option_t opt);
-
-#if NCNN_STRING
-NCNN_EXPORT int ncnn_extractor_input(ncnn_extractor_t ex, const char* name, const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_extractor_extract(ncnn_extractor_t ex, const char* name, ncnn_mat_t* mat);
-#endif /* NCNN_STRING */
-NCNN_EXPORT int ncnn_extractor_input_index(ncnn_extractor_t ex, int index, const ncnn_mat_t mat);
-NCNN_EXPORT int ncnn_extractor_extract_index(ncnn_extractor_t ex, int index, ncnn_mat_t* mat);
-
-/* mat process api */
-#define NCNN_BORDER_CONSTANT    0
-#define NCNN_BORDER_REPLICATE   1
-#define NCNN_BORDER_REFLECT     2
-#define NCNN_BORDER_TRANSPARENT -233
-NCNN_EXPORT void ncnn_copy_make_border(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, int type, float v, const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_copy_make_border_3d(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, int front, int behind, int type, float v, const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_copy_cut_border(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, const ncnn_option_t opt);
-NCNN_EXPORT void ncnn_copy_cut_border_3d(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, int front, int behind, const ncnn_option_t opt);
-
-#if NCNN_PIXEL_DRAWING
-/* mat pixel drawing api*/
-NCNN_EXPORT void ncnn_draw_rectangle_c1(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_rectangle_c2(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_rectangle_c3(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_rectangle_c4(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
-
-NCNN_EXPORT void ncnn_draw_text_c1(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
-NCNN_EXPORT void ncnn_draw_text_c2(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
-NCNN_EXPORT void ncnn_draw_text_c3(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
-NCNN_EXPORT void ncnn_draw_text_c4(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
-
-NCNN_EXPORT void ncnn_draw_circle_c1(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_circle_c2(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_circle_c3(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_circle_c4(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
-
-NCNN_EXPORT void ncnn_draw_line_c1(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_line_c2(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_line_c3(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
-NCNN_EXPORT void ncnn_draw_line_c4(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
-#endif /* NCNN_PIXEL_DRAWING */
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* NCNN_C_API */
-
-#endif /* NCNN_C_API_H */

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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 NCNN_COMMAND_H
-#define NCNN_COMMAND_H
-
-#include "platform.h"
-
-#if NCNN_VULKAN
-
-#include "mat.h"
-
-namespace ncnn {
-
-class Pipeline;
-#if NCNN_PLATFORM_API
-#if __ANDROID_API__ >= 26
-class ImportAndroidHardwareBufferPipeline;
-#endif // __ANDROID_API__ >= 26
-#endif // NCNN_PLATFORM_API
-class VkComputePrivate;
-class NCNN_EXPORT VkCompute
-{
-public:
-    explicit VkCompute(const VulkanDevice* vkdev);
-    virtual ~VkCompute();
-
-public:
-    void record_upload(const Mat& src, VkMat& dst, const Option& opt);
-
-    void record_upload(const Mat& src, VkImageMat& dst, const Option& opt);
-
-    void record_download(const VkMat& src, Mat& dst, const Option& opt);
-
-    void record_download(const VkImageMat& src, Mat& dst, const Option& opt);
-
-    void record_buffer_to_image(const VkMat& src, VkImageMat& dst, const Option& opt);
-
-    void record_image_to_buffer(const VkImageMat& src, VkMat& dst, const Option& opt);
-
-    void record_clone(const Mat& src, VkMat& dst, const Option& opt);
-
-    void record_clone(const Mat& src, VkImageMat& dst, const Option& opt);
-
-    void record_clone(const VkMat& src, Mat& dst, const Option& opt);
-
-    void record_clone(const VkImageMat& src, Mat& dst, const Option& opt);
-
-    void record_clone(const VkMat& src, VkMat& dst, const Option& opt);
-
-    void record_clone(const VkImageMat& src, VkImageMat& dst, const Option& opt);
-
-    void record_clone(const VkMat& src, VkImageMat& dst, const Option& opt);
-
-    void record_clone(const VkImageMat& src, VkMat& dst, const Option& opt);
-
-    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& bindings, const std::vector<vk_constant_type>& constants, const VkMat& dispatcher);
-
-    void record_pipeline(const Pipeline* pipeline, const std::vector<VkImageMat>& bindings, const std::vector<vk_constant_type>& constants, const VkImageMat& dispatcher);
-
-    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& buffer_bindings, const std::vector<VkImageMat>& image_bindings, const std::vector<vk_constant_type>& constants, const VkMat& dispatcher);
-    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& buffer_bindings, const std::vector<VkImageMat>& image_bindings, const std::vector<vk_constant_type>& constants, const VkImageMat& dispatcher);
-    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& buffer_bindings, const std::vector<VkImageMat>& image_bindings, const std::vector<vk_constant_type>& constants, const Mat& dispatcher);
-
-#if NCNN_BENCHMARK
-    void record_write_timestamp(uint32_t query);
-#endif // NCNN_BENCHMARK
-
-#if NCNN_PLATFORM_API
-#if __ANDROID_API__ >= 26
-    void record_import_android_hardware_buffer(const ImportAndroidHardwareBufferPipeline* pipeline, const VkImageMat& src, const VkMat& dst);
-
-    void record_import_android_hardware_buffer(const ImportAndroidHardwareBufferPipeline* pipeline, const VkImageMat& src, const VkImageMat& dst);
-#endif // __ANDROID_API__ >= 26
-#endif // NCNN_PLATFORM_API
-
-    int submit_and_wait();
-
-    int reset();
-
-#if NCNN_BENCHMARK
-    int create_query_pool(uint32_t query_count);
-
-    int get_query_pool_results(uint32_t first_query, uint32_t query_count, std::vector<uint64_t>& results);
-#endif // NCNN_BENCHMARK
-
-protected:
-    const VulkanDevice* vkdev;
-
-    void barrier_readwrite(const VkMat& binding);
-    void barrier_readwrite(const VkImageMat& binding);
-    void barrier_readonly(const VkImageMat& binding);
-
-private:
-    VkComputePrivate* const d;
-};
-
-class VkTransferPrivate;
-class NCNN_EXPORT VkTransfer
-{
-public:
-    explicit VkTransfer(const VulkanDevice* vkdev);
-    virtual ~VkTransfer();
-
-public:
-    void record_upload(const Mat& src, VkMat& dst, const Option& opt, bool flatten = true);
-
-    void record_upload(const Mat& src, VkImageMat& dst, const Option& opt);
-
-    int submit_and_wait();
-
-protected:
-    const VulkanDevice* vkdev;
-
-private:
-    VkTransferPrivate* const d;
-};
-
-} // namespace ncnn
-
-#endif // NCNN_VULKAN
-
-#endif // NCNN_COMMAND_H

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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 NCNN_CPU_H
-#define NCNN_CPU_H
-
-#include <stddef.h>
-
-#if defined _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif
-#if defined __ANDROID__ || defined __linux__
-#include <sched.h> // cpu_set_t
-#endif
-
-#include "platform.h"
-
-namespace ncnn {
-
-class NCNN_EXPORT CpuSet
-{
-public:
-    CpuSet();
-    void enable(int cpu);
-    void disable(int cpu);
-    void disable_all();
-    bool is_enabled(int cpu) const;
-    int num_enabled() const;
-
-public:
-#if defined _WIN32
-    ULONG_PTR mask;
-#endif
-#if defined __ANDROID__ || defined __linux__
-    cpu_set_t cpu_set;
-#endif
-#if __APPLE__
-    unsigned int policy;
-#endif
-};
-
-// test optional cpu features
-// edsp = armv7 edsp
-NCNN_EXPORT int cpu_support_arm_edsp();
-// neon = armv7 neon or aarch64 asimd
-NCNN_EXPORT int cpu_support_arm_neon();
-// vfpv4 = armv7 fp16 + fma
-NCNN_EXPORT int cpu_support_arm_vfpv4();
-// asimdhp = aarch64 asimd half precision
-NCNN_EXPORT int cpu_support_arm_asimdhp();
-// cpuid = aarch64 cpuid info
-NCNN_EXPORT int cpu_support_arm_cpuid();
-// asimddp = aarch64 asimd dot product
-NCNN_EXPORT int cpu_support_arm_asimddp();
-// asimdfhm = aarch64 asimd fhm
-NCNN_EXPORT int cpu_support_arm_asimdfhm();
-// bf16 = aarch64 bf16
-NCNN_EXPORT int cpu_support_arm_bf16();
-// i8mm = aarch64 i8mm
-NCNN_EXPORT int cpu_support_arm_i8mm();
-// sve = aarch64 sve
-NCNN_EXPORT int cpu_support_arm_sve();
-// sve2 = aarch64 sve2
-NCNN_EXPORT int cpu_support_arm_sve2();
-// svebf16 = aarch64 svebf16
-NCNN_EXPORT int cpu_support_arm_svebf16();
-// svei8mm = aarch64 svei8mm
-NCNN_EXPORT int cpu_support_arm_svei8mm();
-// svef32mm = aarch64 svef32mm
-NCNN_EXPORT int cpu_support_arm_svef32mm();
-
-// avx = x86 avx
-NCNN_EXPORT int cpu_support_x86_avx();
-// fma = x86 fma
-NCNN_EXPORT int cpu_support_x86_fma();
-// xop = x86 xop
-NCNN_EXPORT int cpu_support_x86_xop();
-// f16c = x86 f16c
-NCNN_EXPORT int cpu_support_x86_f16c();
-// avx2 = x86 avx2 + fma + f16c
-NCNN_EXPORT int cpu_support_x86_avx2();
-// avx_vnni = x86 avx vnni
-NCNN_EXPORT int cpu_support_x86_avx_vnni();
-// avx_vnni_int8 = x86 avx vnni int8
-NCNN_EXPORT int cpu_support_x86_avx_vnni_int8();
-// avx_vnni_int16 = x86 avx vnni int16
-NCNN_EXPORT int cpu_support_x86_avx_vnni_int16();
-// avx_ne_convert = x86 avx ne convert
-NCNN_EXPORT int cpu_support_x86_avx_ne_convert();
-// avx512 = x86 avx512f + avx512cd + avx512bw + avx512dq + avx512vl
-NCNN_EXPORT int cpu_support_x86_avx512();
-// avx512_vnni = x86 avx512 vnni
-NCNN_EXPORT int cpu_support_x86_avx512_vnni();
-// avx512_bf16 = x86 avx512 bf16
-NCNN_EXPORT int cpu_support_x86_avx512_bf16();
-// avx512_fp16 = x86 avx512 fp16
-NCNN_EXPORT int cpu_support_x86_avx512_fp16();
-
-// lsx = loongarch lsx
-NCNN_EXPORT int cpu_support_loongarch_lsx();
-// lasx = loongarch lasx
-NCNN_EXPORT int cpu_support_loongarch_lasx();
-
-// msa = mips mas
-NCNN_EXPORT int cpu_support_mips_msa();
-// mmi = loongson mmi
-NCNN_EXPORT int cpu_support_loongson_mmi();
-
-// v = riscv vector
-NCNN_EXPORT int cpu_support_riscv_v();
-// zfh = riscv half-precision float
-NCNN_EXPORT int cpu_support_riscv_zfh();
-// zvfh = riscv vector half-precision float
-NCNN_EXPORT int cpu_support_riscv_zvfh();
-// xtheadvector = riscv xtheadvector
-NCNN_EXPORT int cpu_support_riscv_xtheadvector();
-// vlenb = riscv vector length in bytes
-NCNN_EXPORT int cpu_riscv_vlenb();
-
-// cpu info
-NCNN_EXPORT int get_cpu_count();
-NCNN_EXPORT int get_little_cpu_count();
-NCNN_EXPORT int get_big_cpu_count();
-
-NCNN_EXPORT int get_physical_cpu_count();
-NCNN_EXPORT int get_physical_little_cpu_count();
-NCNN_EXPORT int get_physical_big_cpu_count();
-
-// cpu l2 varies from 64k to 1M, but l3 can be zero
-NCNN_EXPORT int get_cpu_level2_cache_size();
-NCNN_EXPORT int get_cpu_level3_cache_size();
-
-// bind all threads on little clusters if powersave enabled
-// affects HMP arch cpu like ARM big.LITTLE
-// only implemented on android at the moment
-// switching powersave is expensive and not thread-safe
-// 0 = all cores enabled(default)
-// 1 = only little clusters enabled
-// 2 = only big clusters enabled
-// return 0 if success for setter function
-NCNN_EXPORT int get_cpu_powersave();
-NCNN_EXPORT int set_cpu_powersave(int powersave);
-
-// convenient wrapper
-NCNN_EXPORT const CpuSet& get_cpu_thread_affinity_mask(int powersave);
-
-// set explicit thread affinity
-NCNN_EXPORT int set_cpu_thread_affinity(const CpuSet& thread_affinity_mask);
-
-// runtime thread affinity info
-NCNN_EXPORT int is_current_thread_running_on_a53_a55();
-
-// misc function wrapper for openmp routines
-NCNN_EXPORT int get_omp_num_threads();
-NCNN_EXPORT void set_omp_num_threads(int num_threads);
-
-NCNN_EXPORT int get_omp_dynamic();
-NCNN_EXPORT void set_omp_dynamic(int dynamic);
-
-NCNN_EXPORT int get_omp_thread_num();
-
-NCNN_EXPORT int get_kmp_blocktime();
-NCNN_EXPORT void set_kmp_blocktime(int time_ms);
-
-// need to flush denormals on Intel Chipset.
-// Other architectures such as ARM can be added as needed.
-// 0 = DAZ OFF, FTZ OFF
-// 1 = DAZ ON , FTZ OFF
-// 2 = DAZ OFF, FTZ ON
-// 3 = DAZ ON,  FTZ ON
-NCNN_EXPORT int get_flush_denormals();
-NCNN_EXPORT int set_flush_denormals(int flush_denormals);
-
-} // namespace ncnn
-
-#endif // NCNN_CPU_H

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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 NCNN_DATAREADER_H
-#define NCNN_DATAREADER_H
-
-#include "platform.h"
-#if NCNN_STDIO
-#include <stdio.h>
-#endif
-
-#if NCNN_PLATFORM_API
-#if __ANDROID_API__ >= 9
-#include <android/asset_manager.h>
-#endif
-#endif // NCNN_PLATFORM_API
-
-namespace ncnn {
-
-// data read wrapper
-class NCNN_EXPORT DataReader
-{
-public:
-    DataReader();
-    virtual ~DataReader();
-
-#if NCNN_STRING
-    // parse plain param text
-    // return 1 if scan success
-    virtual int scan(const char* format, void* p) const;
-#endif // NCNN_STRING
-
-    // read binary param and model data
-    // return bytes read
-    virtual size_t read(void* buf, size_t size) const;
-
-    // get model data reference
-    // return bytes referenced
-    virtual size_t reference(size_t size, const void** buf) const;
-};
-
-#if NCNN_STDIO
-class DataReaderFromStdioPrivate;
-class NCNN_EXPORT DataReaderFromStdio : public DataReader
-{
-public:
-    explicit DataReaderFromStdio(FILE* fp);
-    virtual ~DataReaderFromStdio();
-
-#if NCNN_STRING
-    virtual int scan(const char* format, void* p) const;
-#endif // NCNN_STRING
-    virtual size_t read(void* buf, size_t size) const;
-
-private:
-    DataReaderFromStdio(const DataReaderFromStdio&);
-    DataReaderFromStdio& operator=(const DataReaderFromStdio&);
-
-private:
-    DataReaderFromStdioPrivate* const d;
-};
-#endif // NCNN_STDIO
-
-class DataReaderFromMemoryPrivate;
-class NCNN_EXPORT DataReaderFromMemory : public DataReader
-{
-public:
-    explicit DataReaderFromMemory(const unsigned char*& mem);
-    virtual ~DataReaderFromMemory();
-
-#if NCNN_STRING
-    virtual int scan(const char* format, void* p) const;
-#endif // NCNN_STRING
-    virtual size_t read(void* buf, size_t size) const;
-    virtual size_t reference(size_t size, const void** buf) const;
-
-private:
-    DataReaderFromMemory(const DataReaderFromMemory&);
-    DataReaderFromMemory& operator=(const DataReaderFromMemory&);
-
-private:
-    DataReaderFromMemoryPrivate* const d;
-};
-
-#if NCNN_PLATFORM_API
-#if __ANDROID_API__ >= 9
-class DataReaderFromAndroidAssetPrivate;
-class NCNN_EXPORT DataReaderFromAndroidAsset : public DataReader
-{
-public:
-    explicit DataReaderFromAndroidAsset(AAsset* asset);
-    virtual ~DataReaderFromAndroidAsset();
-
-#if NCNN_STRING
-    virtual int scan(const char* format, void* p) const;
-#endif // NCNN_STRING
-    virtual size_t read(void* buf, size_t size) const;
-
-private:
-    DataReaderFromAndroidAsset(const DataReaderFromAndroidAsset&);
-    DataReaderFromAndroidAsset& operator=(const DataReaderFromAndroidAsset&);
-
-private:
-    DataReaderFromAndroidAssetPrivate* const d;
-};
-#endif // __ANDROID_API__ >= 9
-#endif // NCNN_PLATFORM_API
-
-} // namespace ncnn
-
-#endif // NCNN_DATAREADER_H

-// Tencent is pleased to support the open source community by making ncnn available.
-//
-// Copyright (C) 2025 THL A29 Limited, a Tencent company. All rights reserved.
-//
-// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// https://opensource.org/licenses/BSD-3-Clause
-//
-// 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.
-
-#include "mat.h"
-
-namespace ncnn {
-
-// count how many blobs are referenced inside expression
-NCNN_EXPORT int count_expression_blobs(const std::string& expr);
-
-// resolve reshape shape from expression and input blobs
-// resolve slice indices(starts, ends) from expression and input blobs
-// see docs/developer-guide/expression.md
-// return 0 if success
-NCNN_EXPORT int eval_list_expression(const std::string& expr, const std::vector<Mat>& blobs, std::vector<int>& outlist);
-
-} // namespace ncnn