// 法线分布函数 D：GGX / Trowbridge-Reitz
//   D(h) = a² / ( π ( (n·h)² (a² - 1) + 1 )² )
float MyD_GGX(float NoH, float a2)
{
    float d = (NoH * a2 - NoH) * NoH + 1.0;   // = NoH²(a²-1)+1，写成两次 MAD
    return a2 / (PI * d * d);
}

// 可见性项 V = G2 / (4 NoL NoV)，G2 用高度相关（Height-Correlated）Smith-GGX
//   V = 0.5 / ( NoL * sqrt(NoV²(1-a²) + a²) + NoV * sqrt(NoL²(1-a²) + a²) )
float MyV_SmithGGXCorrelated(float NoV, float NoL, float a2)
{
    float lambdaV = NoL * sqrt((NoV - NoV * a2) * NoV + a2);
    float lambdaL = NoV * sqrt((NoL - NoL * a2) * NoL + a2);
    return 0.5 / max(lambdaV + lambdaL, 1e-5);
}

// 菲涅尔 F：Schlick 近似  F = F0 + (F90 - F0)(1 - cosθ)^5
vec3 MyF_Schlick(vec3 f0, float f90, float cosTheta)
{
    float x  = 1.0 - cosTheta;
    float x2 = x * x;
    float x5 = x2 * x2 * x;                    // 手写 pow5，比 pow() 便宜且没有 pow(0,5) 的边界问题
    return f0 + (f90 - f0) * x5;
}

// 漫反射：Lambert。能量守恒要求 ∫ f_d cosθ dω = albedo，所以要除以 π
float MyFd_Lambert()
{
    return INV_PI;
}

// 由表面参数推出 BRDF 需要的量（与光源无关，每像素算一次）
struct MyMaterial
{
    vec3  diffuseColor;        // 进入 Lambert 的颜色
    vec3  f0;                  // 正入射镜面反射率
    float perceptualRoughness;
    float a2;                  // α² ，α = perceptualRoughness²
    vec3  energyCompensation;  // 多次散射补偿系数，由 DFG 算出，默认 1
};

MyMaterial MyInitMaterial(vec3 albedo, float metallic, float perceptualRoughness)
{
    MyMaterial m;
    // 金属度工作流：金属没有漫反射，基础色就是 F0；电介质 F0 固定 0.04，基础色进漫反射。
    // 电介质表面先被镜面反射走约 4%，剩下的才进入次表面形成漫反射，所以乘 (1 - 0.04)
    m.diffuseColor = albedo * (1.0 - metallic) * (1.0 - MY_DIELECTRIC_F0);
    m.f0 = mix(vec3(MY_DIELECTRIC_F0), albedo, metallic);
    m.perceptualRoughness = max(perceptualRoughness, MY_MIN_PERCEPTUAL_ROUGHNESS);
    float a = m.perceptualRoughness * m.perceptualRoughness;   // 感知粗糙度平方 = GGX 的 α
    m.a2 = a * a;
    m.energyCompensation = vec3(1.0);
    return m;
}

// 单个光源方向 L 上的 BRDF：分别返回漫反射项 fd 与镜面项 fs（单位 1/sr），
// 还没乘入射光和 NoL —— 那是“光照”的事，不是“材质”的事。
void MyDirectBRDF(MyMaterial m, vec3 N, vec3 V, vec3 L,
                  out vec3 fd, out vec3 fs, out float NoL)
{
    vec3 H = SafeNormalize(L + V);
    float NoV = abs(dot(N, V)) + 1e-5;         // 法线贴图会让 N 背向视线，取绝对值避免除 0
    NoL = saturate(dot(N, L));
    float NoH = saturate(dot(N, H));
    float LoH = saturate(dot(L, H));           // = VoH，半角向量两侧对称

    float D   = MyD_GGX(NoH, m.a2);
    float Vis = MyV_SmithGGXCorrelated(NoV, NoL, m.a2);
    vec3  F   = MyF_Schlick(m.f0, 1.0, LoH);

    fs = (D * Vis) * F * m.energyCompensation;
    fd = m.diffuseColor * MyFd_Lambert();
}

// 第一步：只有主光、没有阴影、没有环境光的最小 PBR。（GLSL 版，对应 Ch11/Step1_DirectPBR.shader）
// 目的：先单独验证 BRDF（D、V、F、Lambert 与 π 的约定）是否正确，再往上加东西。
Shader "Cookbook/Ch11/Step1_DirectPBR"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }
        Pass
        {
            Tags { "LightMode"="UniversalForward" }
            GLSLPROGRAM
            uniform vec4  _BaseColor;
            uniform float _Metallic;
            uniform float _Smoothness;
            // MyPBR_BRDF.glsl 里的 LUT 分支要用到这张贴图的声明（本步不启用）
            uniform sampler2D _DFGLut;
            #include "Ch11/MyPBR_BRDF.glsl"

            VARYING vec3 positionWS;
            VARYING vec3 normalWS;

            #ifdef VERTEX
            void main()
            {
                positionWS  = TransformObjectToWorld(positionOS.xyz);
                gl_Position = TransformWorldToHClip(positionWS);
                normalWS    = TransformObjectToWorldNormal(normalOS);
            }
            #endif

            #ifdef FRAGMENT
            void main()
            {
                vec3 N = normalize(normalWS);
                vec3 V = GetWorldSpaceNormalizeViewDir(positionWS);
                Light light = GetMainLight();

                MyMaterial m = MyInitMaterial(_BaseColor.rgb, _Metallic, 1.0 - _Smoothness);
                vec3 fd, fs; float NoL;
                MyDirectBRDF(m, N, V, light.direction, fd, fs, NoL);

                // 渲染方程只剩一项：Lo = f(l,v) · E⊥ · NoL，E⊥ = π · light.color
                vec3 Lo = (fd + fs) * PI * light.color * NoL;
                fragColor = vec4(Lo, 1.0);
            }
            #endif
            ENDGLSL
        }
    }
}

// 第 11 章最终成果：完全手写 BRDF 的 PBR Shader，可直接在项目中使用。（GLSL 版，对应 Ch11/MyPBR.shader）
// 支持：Forward / Forward+、主光与附加光阴影、SH + 反射探针 IBL、DFG（解析或 LUT）、多次散射补偿、
//       法线贴图、Mask Map（R 金属 G AO A 光滑）、自发光、SSAO、Rendering Debugger。
// （HLSL 版另外支持光照贴图、Light Layers、SRP Batcher、GPU Instancing，网页版没有这些功能）
Shader "Cookbook/Ch11/MyPBR"
{
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry" }

        GLSLINCLUDE
        // 所有 Pass 共享同一份材质属性声明，保证 SRP Batcher 兼容
        #include "Ch11/MyPBR_Input.glsl"
        ENDGLSL

        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode"="UniversalForward" }
            ZWrite On
            Cull Back

            GLSLPROGRAM
            // ---- 材质关键字（只编译用到的组合）----
            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local_fragment _MASKMAP
            #pragma shader_feature_local_fragment _EMISSION
            #pragma shader_feature_local_fragment _DFG_LUT
            #pragma shader_feature_local_fragment _ALPHATEST_ON

            // ---- URP 管线关键字：_MAIN_LIGHT_SHADOWS、_ADDITIONAL_LIGHTS、_SHADOWS_SOFT 等网页版引擎始终打开 ----
            // ---- 调试：网页版模拟的 Rendering Debugger ----
            #pragma multi_compile_fragment _ DEBUG_DISPLAY

            #include "Ch11/MyPBR_ForwardPass.glsl"
            #include "Ch11/DebugDisplay.glsl"

            #ifdef VERTEX
            void main() { MyPBRVert(); }
            #endif

            #ifdef FRAGMENT
            void main()
            {
            #if defined(DEBUG_DISPLAY)
                // 让 Rendering Debugger 的材质视图 / 材质校验也能作用于 MyPBR：
                // 把我们的表面参数交给调试函数（HLSL 版是翻译成 URP 的 SurfaceData 再交给 CanDebugOverrideOutputColor）
                MySurface s  = MySampleSurface(uv);
                InputData id = MyInitInputData(s.normalTS);
                MyMaterial m = MyInitMaterial(s.albedo, s.metallic, s.perceptualRoughness);
                vec4 debugColor;
                if (CanDebugOverrideOutputColor(s.albedo, s.alpha, m.f0, s.metallic, 1.0 - s.perceptualRoughness,
                                                s.occlusion, s.emission, id.normalWS, debugColor))
                {
                    fragColor = debugColor;
                    return;
                }
            #endif
                fragColor = MyPBRFrag();
            }
            #endif
            ENDGLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }
            ZWrite On
            ZTest LEqual
            ColorMask 0
            Cull Back

            GLSLPROGRAM
            #pragma shader_feature_local _ALPHATEST_ON
            // 方向光与点/聚光的法线偏移公式不同，URP 用 _CASTING_PUNCTUAL_LIGHT_SHADOW 关键字区分（网页版是 uniform）
            #include "Ch11/MyPBR_DepthPasses.glsl"
            #ifdef VERTEX
            void main() { MyShadowVert(); }
            #endif
            #ifdef FRAGMENT
            void main() { fragColor = MyShadowFrag(); }
            #endif
            ENDGLSL
        }

        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }
            ZWrite On
            ColorMask R
            Cull Back

            GLSLPROGRAM
            #pragma shader_feature_local _ALPHATEST_ON
            #include "Ch11/MyPBR_DepthPasses.glsl"
            #ifdef VERTEX
            void main() { MyDepthVert(); }
            #endif
            #ifdef FRAGMENT
            void main() { fragColor = MyDepthFrag(); }
            #endif
            ENDGLSL
        }

        Pass
        {
            Name "DepthNormals"
            Tags { "LightMode"="DepthNormals" }
            ZWrite On
            Cull Back

            GLSLPROGRAM
            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _ALPHATEST_ON
            #include "Ch11/MyPBR_DepthPasses.glsl"
            #ifdef VERTEX
            void main() { MyDepthNormalsVert(); }
            #endif
            #ifdef FRAGMENT
            void main() { fragColor = MyDepthNormalsFrag(); }
            #endif
            ENDGLSL
        }

        Pass
        {
            Name "Meta"
            Tags { "LightMode"="Meta" }
            Cull Off

            GLSLPROGRAM
            #pragma shader_feature_local_fragment _MASKMAP
            #pragma shader_feature_local_fragment _EMISSION
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #include "Ch11/MyPBR_MetaPass.glsl"
            #ifdef VERTEX
            void main() { MyMetaVert(); }
            #endif
            #ifdef FRAGMENT
            void main() { fragColor = MyMetaFrag(); }
            #endif
            ENDGLSL
        }
    }
}

// 所有材质属性（贴图除外）都放进 UnityPerMaterial，且每个 Pass 看到的布局完全一致，
// 这是 SRP Batcher 兼容的硬条件。贴图本身不进 CBUFFER，但 _ST 要进。
// （WebGL 没有 SRP Batcher，这里都是普通 uniform）
uniform vec4  _BaseMap_ST;
uniform vec4  _BaseColor;
uniform float _Metallic;
uniform float _Smoothness;
uniform float _OcclusionStrength;
uniform float _BumpScale;
uniform vec4  _EmissionColor;
uniform float _Cutoff;
uniform float _EnergyCompensation;   // 0 = 只算单次散射，1 = 加多次散射能量补偿
uniform float _SpecularOcclusion;    // 0 = 关，1 = 用 AO 推算镜面遮蔽

uniform sampler2D _BaseMap;
uniform sampler2D _MaskMap;      // R 金属度  G AO  A 光滑度（与配套贴图约定一致）
uniform sampler2D _BumpMap;
uniform sampler2D _EmissionMap;
uniform sampler2D _DFGLut;       // 程序生成的环境 BRDF 查找表（RG = A, B），贴图自身是双线性 + Clamp
// HLSL 版里 Mask 与自发光借用 _BaseMap 的采样器以节省采样器槽位；GLSL 的 sampler2D 自带采样状态，没有这个问题。

// 表面参数：全部在“线性空间、物理含义明确”的单位下
struct MySurface
{
    vec3  albedo;               // 基础色（金属时就是 F0 的颜色）
    float alpha;
    float metallic;
    float perceptualRoughness;  // 感知粗糙度 = 1 - smoothness，美术直接调的那个值
    float occlusion;            // 材质 AO（只影响间接光）
    vec3  normalTS;             // 切线空间法线
    vec3  emission;
};

#ifdef FRAGMENT
MySurface MySampleSurface(vec2 uv)
{
    MySurface s;
    vec4 base = texture(_BaseMap, uv) * _BaseColor;
    s.albedo = base.rgb;
    s.alpha  = base.a;
#if defined(_ALPHATEST_ON)
    if (s.alpha - _Cutoff < 0.0) discard;
#endif

#if defined(_MASKMAP)
    vec4 mask = texture(_MaskMap, uv);
    // （smooth 是 GLSL 的关键字（插值限定符），变量改名为 smoothness）
    s.metallic   = mask.r;                       // 有 Mask 时金属度完全由贴图决定（与 URP Lit 一致）
    float smoothness = mask.a * _Smoothness;         // 光滑度 = 贴图 × 滑条，滑条当总强度用
    s.occlusion  = LerpWhiteTo(mask.g, _OcclusionStrength);
#else
    s.metallic   = _Metallic;
    float smoothness = _Smoothness;
    s.occlusion  = 1.0;
#endif
    s.perceptualRoughness = 1.0 - smoothness;

#if defined(_NORMALMAP)
    s.normalTS = UnpackNormalScale(texture(_BumpMap, uv), _BumpScale);
#else
    s.normalTS = vec3(0, 0, 1);
#endif

#if defined(_EMISSION)
    s.emission = texture(_EmissionMap, uv).rgb * _EmissionColor.rgb;
#else
    s.emission = vec3(0.0);
#endif
    return s;
}
#endif

Pass
{
    Name "ForwardLit"
    Tags { "LightMode"="UniversalForward" }
    ZWrite On
    Cull Back

    GLSLPROGRAM
    // ---- 材质关键字（只编译用到的组合）----
    #pragma shader_feature_local _NORMALMAP
    #pragma shader_feature_local_fragment _MASKMAP
    #pragma shader_feature_local_fragment _EMISSION
    #pragma shader_feature_local_fragment _DFG_LUT
    #pragma shader_feature_local_fragment _ALPHATEST_ON

    // ---- URP 管线关键字：_MAIN_LIGHT_SHADOWS、_ADDITIONAL_LIGHTS、_SHADOWS_SOFT 等网页版引擎始终打开 ----
    // ---- 调试：网页版模拟的 Rendering Debugger ----
    #pragma multi_compile_fragment _ DEBUG_DISPLAY

    #include "Ch11/MyPBR_ForwardPass.glsl"
    #include "Ch11/DebugDisplay.glsl"

    #ifdef VERTEX
    void main() { MyPBRVert(); }
    #endif

    #ifdef FRAGMENT
    void main()
    {
    #if defined(DEBUG_DISPLAY)
        // 让 Rendering Debugger 的材质视图 / 材质校验也能作用于 MyPBR：
        // 把我们的表面参数交给调试函数（HLSL 版是翻译成 URP 的 SurfaceData 再交给 CanDebugOverrideOutputColor）
        MySurface s  = MySampleSurface(uv);
        InputData id = MyInitInputData(s.normalTS);
        MyMaterial m = MyInitMaterial(s.albedo, s.metallic, s.perceptualRoughness);
        vec4 debugColor;
        if (CanDebugOverrideOutputColor(s.albedo, s.alpha, m.f0, s.metallic, 1.0 - s.perceptualRoughness,
                                        s.occlusion, s.emission, id.normalWS, debugColor))
        {
            fragColor = debugColor;
            return;
        }
    #endif
        fragColor = MyPBRFrag();
    }
    #endif
    ENDGLSL
}

// WebGL 不允许结构体做 varying：HLSL 的 Varyings 拆成单独的变量（顶点输入 Attributes 由引擎固定命名：positionOS、normalOS……）
VARYING vec2  uv;
VARYING vec3  positionWS;
VARYING vec3  normalWS;
#if defined(_NORMALMAP)
VARYING vec4  tangentWS;      // xyz 切线，w 副切线符号
#endif
VARYING float fogFactor;
#if defined(_ADDITIONAL_LIGHTS_VERTEX)
VARYING vec3  vertexLight;
#endif
// 光照贴图 UV / 逐顶点 SH：网页版没有光照贴图，SH 在片元里逐像素求

#ifdef VERTEX
void MyPBRVert()
{
    VertexPositionInputs pos = GetVertexPositionInputs(positionOS.xyz);
    VertexNormalInputs   nrm = GetVertexNormalInputs(normalOS, tangentOS);

    gl_Position = pos.positionCS;
    positionWS  = pos.positionWS;
    uv          = TransformTex(texcoord0.xy, _BaseMap_ST);
    normalWS    = nrm.normalWS;
#if defined(_NORMALMAP)
    // 镜像缩放（负缩放）会翻转副切线方向，GetOddNegativeScale 负责修正
    tangentWS   = vec4(nrm.tangentWS, tangentOS.w * GetOddNegativeScale());
#endif
    fogFactor   = ComputeFogFactor(pos.positionCS.z);

#if defined(_ADDITIONAL_LIGHTS_VERTEX)
    // 逐顶点附加光：只累加 color * atten * NoL（漫反射的 E/π），镜面无法逐顶点
    vec3 vl = vec3(0.0);
    int n = GetAdditionalLightsCount();
    for (int i = 0; i < n; ++i)
    {
        Light l = GetAdditionalLight(i, pos.positionWS);
        vl += l.color * l.distanceAttenuation * saturate(dot(nrm.normalWS, l.direction));
    }
    vertexLight = vl;
#endif
}
#endif

// 填 URP 的 InputData：它只是“像素的几何与环境数据”的容器，
// 填好它，阴影、SSAO、附加光循环都能直接用
InputData MyInitInputData(vec3 normalTS)
{
    InputData d = InitInputData();
    d.positionWS = positionWS;
    d.positionCS = gl_FragCoord;
#if defined(_NORMALMAP)
    float sgn = tangentWS.w;
    vec3 bitangent = sgn * cross(normalWS, tangentWS.xyz);
    mat3 tbn = mat3(tangentWS.xyz, bitangent, normalWS);   // GLSL 的 mat3 按列构造：列就是 T/B/N
    d.tangentToWorld = tbn;
    d.normalWS = TransformTangentToWorld(normalTS, tbn);
#else
    d.normalWS = normalWS;
#endif
    d.normalWS = NormalizeNormalPerPixel(d.normalWS);   // 插值后长度不为 1，必须重新归一化
    d.viewDirectionWS = GetWorldSpaceNormalizeViewDir(positionWS);
    d.shadowCoord = TransformWorldToShadowCoord(positionWS);
    d.fogCoord = fogFactor;
#if defined(_ADDITIONAL_LIGHTS_VERTEX)
    d.vertexLighting = vertexLight;
#endif
    d.bakedGI = SampleSH(d.normalWS);                     // 网页版没有光照贴图：逐像素 SH
    d.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(gl_FragCoord);
    d.shadowMask = vec4(1.0);
    return d;
}

vec4 MyPBRFrag()
{
    MySurface s  = MySampleSurface(uv);
    InputData id = MyInitInputData(s.normalTS);
    MyMaterial m = MyInitMaterial(s.albedo, s.metallic, s.perceptualRoughness);

    // HLSL 版在 DEBUG_DISPLAY 下把表面参数交给 Rendering Debugger；网页版的调试视图见 Ch11/MyPBRDebug.glsl
    MyLightingTerms t = MyComputeLighting(s, m, id);
    vec3 color = t.directDiffuse + t.directSpecular + t.indirectDiffuse + t.indirectSpecular + t.emission;
    color = MixFog(color, id.fogCoord);
    return vec4(color, 1.0);
}

// 一盏灯对出射辐射率的贡献：Lo = f(l,v) * E⊥ * NoL
// Unity 的光源约定：light.color 是“白色 Lambert 表面正对灯时看到的亮度”，
// 即 Lo = albedo/π * E⊥  =>  E⊥ = π * light.color。所以这里乘 π，与 BRDF 里的 1/π 互相抵消。
void MyAccumulateLight(MyMaterial m, vec3 N, vec3 V, Light light, inout MyLightingTerms t)
{
    vec3 fd, fs; float NoL;
    MyDirectBRDF(m, N, V, light.direction, fd, fs, NoL);
    vec3 E = PI * light.color * (light.distanceAttenuation * light.shadowAttenuation) * NoL;
    t.directDiffuse  += fd * E;
    t.directSpecular += fs * E;
}

MyLightingTerms MyComputeLighting(MySurface s, inout MyMaterial m, InputData inputData)
{
    MyLightingTerms t;
    t.directDiffuse = vec3(0.0); t.directSpecular = vec3(0.0);
    t.indirectDiffuse = vec3(0.0); t.indirectSpecular = vec3(0.0); t.emission = vec3(0.0);
    vec3 N = inputData.normalWS;
    vec3 V = inputData.viewDirectionWS;
    float NoV = saturate(dot(N, V)) + 1e-5;

    // ---- 环境 BRDF 与能量补偿：只和 NoV、粗糙度有关，先算好给直接光也用 ----
    vec2 dfg = MyEnvDFG(NoV, m.perceptualRoughness);
    m.energyCompensation = mix(vec3(1.0), MyEnergyCompensation(dfg, m.f0), _EnergyCompensation);

    // ---- 遮蔽：材质 AO 与 SSAO 取最小值（URP 的约定）----
    AmbientOcclusionFactor ao = GetScreenSpaceAmbientOcclusion(inputData.normalizedScreenSpaceUV);
    ao.indirectAmbientOcclusion = min(ao.indirectAmbientOcclusion, s.occlusion);
    vec4 shadowMask = inputData.shadowMask;

    // ---- 主光 ----
    Light mainLight = MyGetMainLight(inputData, shadowMask, ao);   // 已含阴影、SSAO 直接光部分
    // （HLSL 版这里还有 MixRealtimeAndBakedGI 与 Light Layers 判断；网页版没有光照贴图和灯光层）
    MyAccumulateLight(m, N, V, mainLight, t);

    // ---- 附加光：Forward 逐物体列表 / Forward+ 全部可见光 ----
#if defined(_ADDITIONAL_LIGHTS)
    // HLSL 版用 LIGHT_LOOP_BEGIN/END（Forward+ 下展开成分簇迭代器）；
    // 网页版的 GetAdditionalLightsCount() 已经按渲染路径返回本像素要算的灯数，普通 for 循环即可
    int lightCount = GetAdditionalLightsCount();
    for (int lightIndex = 0; lightIndex < lightCount; lightIndex++)
    {
        Light light = MyGetAdditionalLight(lightIndex, inputData, shadowMask, ao);
        MyAccumulateLight(m, N, V, light, t);
    }
#endif

#if defined(_ADDITIONAL_LIGHTS_VERTEX)
    // 逐顶点附加光只有漫反射：顶点里累加的是 color * atten * NoL，等价于 E/π
    t.directDiffuse += inputData.vertexLighting * m.diffuseColor;
#endif

    // ---- 间接漫反射：SH（或光照贴图）----
    // Unity 的 SH / 光照贴图里存的是 E/π（“已经除过 π 的辐照度”），直接乘漫反射色即可
    t.indirectDiffuse = inputData.bakedGI * m.diffuseColor * ao.indirectAmbientOcclusion;

    // ---- 间接镜面：split-sum = 预滤波环境 × 环境 BRDF ----
    vec3 R = reflect(-V, N);
    vec3 prefiltered = MySamplePrefilteredEnv(R, m.perceptualRoughness, inputData.positionWS, inputData.normalizedScreenSpaceUV);
    vec3 envBRDF = m.f0 * dfg.x + dfg.y;     // F90 = 1
    float specOcc = mix(ao.indirectAmbientOcclusion,
                        MySpecularOcclusion(NoV, ao.indirectAmbientOcclusion, m.perceptualRoughness),
                        _SpecularOcclusion);
    t.indirectSpecular = prefiltered * envBRDF * m.energyCompensation * specOcc;

    t.emission = s.emission;
    return t;
}