gl-transitions 1.74.0 → 1.76.0

package/msl/VerticalClose.metal

@@ -0,0 +1,100 @@
+// VerticalClose — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/VerticalClose.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image closes in from the left and right edges toward the middle
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e15 = uv[0u];
+    float _e17 = uv[1u];
+    metal::float4 _e20 = _to.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e15 = uv_1[0u];
+    float _e17 = uv_1[1u];
+    metal::float4 _e20 = _from.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float s = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e18 = uv_2[0u];
+    float _e21 = uniforms.progress;
+    float _e27 = uniforms.progress;
+    s = (2.0 - metal::abs((_e18 - 0.5) / (_e21 - 1.0))) - (2.0 * _e27);
+    metal::float2 _e30 = uv_2;
+    param = _e30;
+    metal::float4 _e31 = getFromColor(param, _from, _sampler);
+    metal::float2 _e32 = uv_2;
+    param_1 = _e32;
+    metal::float4 _e33 = getToColor(param_1, _sampler, _to);
+    float _e34 = s;
+    return metal::mix(_e31, _e33, metal::float4(metal::smoothstep(0.5, 0.0, _e34)));
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_2 = {};
+    metal::float2 _e14 = _uv_1;
+    param_2 = _e14;
+    metal::float4 _e15 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e15;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/VerticalOpen.metal

@@ -0,0 +1,103 @@
+// VerticalOpen — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/VerticalOpen.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image opens from a line in the middle toward the left and right edges
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e15 = uv[0u];
+    float _e17 = uv[1u];
+    metal::float4 _e20 = _to.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e15 = uv_1[0u];
+    float _e17 = uv_1[1u];
+    metal::float4 _e20 = _from.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float regress = {};
+    float s = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e19 = uniforms.progress;
+    regress = 1.0 - _e19;
+    float _e22 = uv_2[0u];
+    float _e24 = regress;
+    float _e29 = regress;
+    s = (2.0 - metal::abs((_e22 - 0.5) / (_e24 - 1.0))) - (2.0 * _e29);
+    metal::float2 _e32 = uv_2;
+    param = _e32;
+    metal::float4 _e33 = getFromColor(param, _from, _sampler);
+    metal::float2 _e34 = uv_2;
+    param_1 = _e34;
+    metal::float4 _e35 = getToColor(param_1, _sampler, _to);
+    float _e36 = s;
+    return metal::mix(_e33, _e35, metal::float4(metal::smoothstep(0.0, 0.5, _e36)));
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_2 = {};
+    metal::float2 _e14 = _uv_1;
+    param_2 = _e14;
+    metal::float4 _e15 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e15;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/WaterDrop.metal

@@ -0,0 +1,126 @@
+// WaterDrop — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/WaterDrop.glsl
+// Author: Paweł Płóciennik
+// License: MIT
+// Description: Ripples spread from the center like a drop falling into water, crossfading to the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+    float amplitude;
+    float speed;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e17 = uv[0u];
+    float _e19 = uv[1u];
+    metal::float4 _e22 = _to.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e17 = uv_1[0u];
+    float _e19 = uv_1[1u];
+    metal::float4 _e22 = _from.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float4 transition(
+    thread metal::float2& p,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 dir = {};
+    float dist = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 offset = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 _e23 = p;
+    dir = _e23 - metal::float2(0.5, 0.5);
+    metal::float2 _e25 = dir;
+    dist = metal::length(_e25);
+    float _e27 = dist;
+    float _e29 = uniforms.progress;
+    if (_e27 > _e29) {
+        metal::float2 _e31 = p;
+        param = _e31;
+        metal::float4 _e32 = getFromColor(param, _from, _sampler);
+        metal::float2 _e33 = p;
+        param_1 = _e33;
+        metal::float4 _e34 = getToColor(param_1, _sampler, _to);
+        float _e36 = uniforms.progress;
+        return metal::mix(_e32, _e34, metal::float4(_e36));
+    } else {
+        metal::float2 _e39 = dir;
+        float _e40 = dist;
+        float _e42 = uniforms.amplitude;
+        float _e45 = uniforms.progress;
+        float _e47 = uniforms.speed;
+        offset = _e39 * metal::sin((_e40 * _e42) - (_e45 * _e47));
+        metal::float2 _e52 = p;
+        metal::float2 _e53 = offset;
+        param_2 = _e52 + _e53;
+        metal::float4 _e55 = getFromColor(param_2, _from, _sampler);
+        metal::float2 _e56 = p;
+        param_3 = _e56;
+        metal::float4 _e57 = getToColor(param_3, _sampler, _to);
+        float _e59 = uniforms.progress;
+        return metal::mix(_e55, _e57, metal::float4(_e59));
+    }
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_4 = {};
+    metal::float2 _e16 = _uv_1;
+    param_4 = _e16;
+    metal::float4 _e17 = transition(param_4, _from, _sampler, _to, uniforms);
+    _fragColor = _e17;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/ZoomInCircles.metal

@@ -0,0 +1,169 @@
+// ZoomInCircles — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomInCircles.glsl
+// Author: dycm8009
+// License: MIT
+// Description: Concentric rings of the outgoing image zoom at different speeds before revealing the incoming one
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e25 = uv[0u];
+    float _e27 = uv[1u];
+    metal::float4 _e30 = _to.sample(_sampler, metal::float2(_e25, 1.0 - _e27), metal::level(0.0));
+    return _e30;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e25 = uv_1[0u];
+    float _e27 = uv_1[1u];
+    metal::float4 _e30 = _from.sample(_sampler, metal::float2(_e25, 1.0 - _e27), metal::level(0.0));
+    return _e30;
+}
+
+metal::float2 zoom(
+    thread metal::float2& uv_2,
+    thread float& amount
+) {
+    metal::float2 _e25 = uv_2;
+    float _e28 = amount;
+    return metal::float2(0.5) + ((_e25 - metal::float2(0.5)) * _e28);
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_3,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 ratio2_ = {};
+    metal::float2 r = {};
+    float pro = {};
+    float z = {};
+    float t = {};
+    metal::float2 param = {};
+    float param_1 = {};
+    metal::float2 param_2 = {};
+    float param_3 = {};
+    metal::float2 param_4 = {};
+    float param_5 = {};
+    metal::float2 param_6 = {};
+    metal::float2 param_7 = {};
+    float _e38 = uniforms.ratio;
+    ratio2_ = metal::float2(1.0, 1.0 / _e38);
+    metal::float2 _e41 = uv_3;
+    metal::float2 _e44 = ratio2_;
+    r = ((_e41 - metal::float2(0.5)) * _e44) * 2.0;
+    float _e48 = uniforms.progress;
+    pro = _e48 / 0.8;
+    float _e50 = pro;
+    z = _e50 * 0.2;
+    t = 0.0;
+    float _e52 = pro;
+    if (_e52 > 1.0) {
+        float _e54 = pro;
+        z = 0.2 + ((_e54 - 1.0) * 5.0);
+        float _e59 = uniforms.progress;
+        t = metal::clamp((_e59 - 0.8) / 0.07, 0.0, 1.0);
+    }
+    metal::float2 _e63 = r;
+    float _e65 = z;
+    if (metal::length(_e63) < (0.5 + _e65)) {
+    } else {
+        metal::float2 _e68 = r;
+        float _e70 = z;
+        if (metal::length(_e68) < (0.8 + (_e70 * 1.5))) {
+            float _e74 = pro;
+            metal::float2 _e77 = uv_3;
+            param = _e77;
+            param_1 = 1.0 - (0.15 * _e74);
+            metal::float2 _e78 = zoom(param, param_1);
+            uv_3 = _e78;
+            float _e79 = t;
+            t = _e79 * 0.5;
+        } else {
+            metal::float2 _e81 = r;
+            float _e83 = z;
+            if (metal::length(_e81) < (1.2 + (_e83 * 2.5))) {
+                float _e87 = pro;
+                metal::float2 _e90 = uv_3;
+                param_2 = _e90;
+                param_3 = 1.0 - (0.2 * _e87);
+                metal::float2 _e91 = zoom(param_2, param_3);
+                uv_3 = _e91;
+                float _e92 = t;
+                t = _e92 * 0.2;
+            } else {
+                float _e94 = pro;
+                metal::float2 _e97 = uv_3;
+                param_4 = _e97;
+                param_5 = 1.0 - (0.25 * _e94);
+                metal::float2 _e98 = zoom(param_4, param_5);
+                uv_3 = _e98;
+            }
+        }
+    }
+    metal::float2 _e99 = uv_3;
+    param_6 = _e99;
+    metal::float4 _e100 = getFromColor(param_6, _from, _sampler);
+    metal::float2 _e101 = uv_3;
+    param_7 = _e101;
+    metal::float4 _e102 = getToColor(param_7, _sampler, _to);
+    float _e103 = t;
+    return metal::mix(_e100, _e102, metal::float4(_e103));
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_8 = {};
+    metal::float2 _e24 = _uv_1;
+    param_8 = _e24;
+    metal::float4 _e25 = transition(param_8, _from, _sampler, _to, uniforms);
+    _fragColor = _e25;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/ZoomLeftWipe.metal

@@ -0,0 +1,152 @@
+// ZoomLeftWipe — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomLeftWipe.glsl
+// Author: Handk
+// License: MIT
+// Description: Zooms into the outgoing image, then the incoming one wipes in from right to left
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+    float zoom_quickness;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e17 = uv[0u];
+    float _e19 = uv[1u];
+    metal::float4 _e22 = _to.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e17 = uv_1[0u];
+    float _e19 = uv_1[1u];
+    metal::float4 _e22 = _from.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float2 zoom(
+    thread metal::float2& uv_2,
+    thread float& amount
+) {
+    float _e17 = amount;
+    if (_e17 < 0.5) {
+        metal::float2 _e19 = uv_2;
+        float _e22 = amount;
+        return metal::float2(0.5) + ((_e19 - metal::float2(0.5)) * (1.0 - _e22));
+    } else {
+        metal::float2 _e27 = uv_2;
+        float _e30 = amount;
+        return metal::float2(0.5) + ((_e27 - metal::float2(0.5)) * _e30);
+    }
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_3,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float nQuick = {};
+    metal::float4 c = {};
+    metal::float2 param = {};
+    float param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 p = {};
+    metal::float4 d = {};
+    metal::float2 param_4 = {};
+    metal::float4 e = {};
+    metal::float2 param_5 = {};
+    metal::float4 f = {};
+    float _e29 = uniforms.zoom_quickness;
+    nQuick = metal::clamp(_e29, 0.0, 0.5);
+    float _e32 = uniforms.progress;
+    if (_e32 < 0.5) {
+        float _e34 = nQuick;
+        float _e36 = uniforms.progress;
+        metal::float2 _e38 = uv_3;
+        param = _e38;
+        param_1 = metal::smoothstep(0.0, _e34, _e36);
+        metal::float2 _e39 = zoom(param, param_1);
+        param_2 = _e39;
+        metal::float4 _e40 = getFromColor(param_2, _from, _sampler);
+        metal::float2 _e41 = uv_3;
+        param_3 = _e41;
+        metal::float4 _e42 = getToColor(param_3, _sampler, _to);
+        float _e44 = uniforms.progress;
+        c = metal::mix(_e40, _e42, metal::float4(metal::step(0.5, _e44)));
+        metal::float4 _e48 = c;
+        return _e48;
+    } else {
+        metal::float2 _e49 = uv_3;
+        p = _e49 / metal::float2(1.0, 1.0);
+        metal::float2 _e51 = p;
+        param_4 = _e51;
+        metal::float4 _e52 = getFromColor(param_4, _from, _sampler);
+        d = _e52;
+        metal::float2 _e53 = p;
+        param_5 = _e53;
+        metal::float4 _e54 = getToColor(param_5, _sampler, _to);
+        e = _e54;
+        metal::float4 _e55 = d;
+        metal::float4 _e56 = e;
+        float _e58 = p[0u];
+        float _e61 = uniforms.progress;
+        f = metal::mix(_e55, _e56, metal::float4(metal::step(1.0 - _e58, (_e61 - 0.5) * 2.0)));
+        metal::float4 _e67 = f;
+        return _e67;
+    }
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_6 = {};
+    metal::float2 _e16 = _uv_1;
+    param_6 = _e16;
+    metal::float4 _e17 = transition(param_6, _from, _sampler, _to, uniforms);
+    _fragColor = _e17;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}