gl-transitions 1.74.0 → 1.76.0

package/msl/DirectionalScaled.metal

@@ -0,0 +1,147 @@
+// DirectionalScaled — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DirectionalScaled.glsl
+// Author: Thibaut Foussard
+// License: MIT
+// Description: Like Directional, with both images scaled down while they slide
+// 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::float2 direction;
+    float scale;
+    char _pad4[4];
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e19 = uv[0u];
+    float _e21 = uv[1u];
+    metal::float4 _e24 = _from.sample(_sampler, metal::float2(_e19, 1.0 - _e21), metal::level(0.0));
+    return _e24;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e19 = uv_1[0u];
+    float _e21 = uv_1[1u];
+    metal::float4 _e24 = _to.sample(_sampler, metal::float2(_e19, 1.0 - _e21), metal::level(0.0));
+    return _e24;
+}
+
+float parabola(
+    thread float& x
+) {
+    float y = {};
+    float _e19 = x;
+    y = metal::pow(metal::sin(_e19 * 3.1415927), 1.0);
+    float _e23 = y;
+    return _e23;
+}
+
+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 easedProgress = {};
+    metal::float2 p = {};
+    metal::float2 f = {};
+    float s = {};
+    float param = {};
+    float mixer = {};
+    metal::float4 col = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    float border = {};
+    float _e29 = uniforms.progress;
+    easedProgress = metal::pow(metal::sin((_e29 * 3.1415927) / 2.0), 3.0);
+    metal::float2 _e34 = uv_2;
+    float _e35 = easedProgress;
+    metal::float2 _e37 = uniforms.direction;
+    p = _e34 + (metal::sign(_e37) * _e35);
+    metal::float2 _e41 = p;
+    f = metal::fract(_e41);
+    float _e44 = uniforms.scale;
+    float _e48 = uniforms.progress;
+    param = _e48;
+    float _e49 = parabola(param);
+    s = 1.0 - ((1.0 - (1.0 / _e44)) * _e49);
+    metal::float2 _e52 = f;
+    float _e55 = s;
+    f = ((_e52 - metal::float2(0.5)) * _e55) + metal::float2(0.5);
+    float _e60 = p[1u];
+    float _e63 = p[1u];
+    float _e67 = p[0u];
+    float _e71 = p[0u];
+    mixer = ((metal::step(0.0, _e60) * metal::step(_e63, 1.0)) * metal::step(0.0, _e67)) * metal::step(_e71, 1.0);
+    metal::float2 _e74 = f;
+    param_1 = _e74;
+    metal::float4 _e75 = getToColor(param_1, _sampler, _to);
+    metal::float2 _e76 = f;
+    param_2 = _e76;
+    metal::float4 _e77 = getFromColor(param_2, _from, _sampler);
+    float _e78 = mixer;
+    col = metal::mix(_e75, _e77, metal::float4(_e78));
+    float _e82 = f[0u];
+    float _e85 = f[0u];
+    float _e90 = f[1u];
+    float _e94 = f[1u];
+    border = ((metal::step(0.0, _e82) * metal::step(0.0, 1.0 - _e85)) * metal::step(0.0, _e90)) * metal::step(0.0, 1.0 - _e94);
+    float _e98 = border;
+    metal::float4 _e99 = col;
+    col = _e99 * _e98;
+    metal::float4 _e101 = col;
+    return _e101;
+}
+
+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_3 = {};
+    metal::float2 _e18 = _uv_1;
+    param_3 = _e18;
+    metal::float4 _e19 = transition(param_3, _from, _sampler, _to, uniforms);
+    _fragColor = _e19;
+    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/DoomScreenTransition.metal

@@ -0,0 +1,212 @@
+// DoomScreenTransition — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DoomScreenTransition.glsl
+// Author: Zeh Fernando
+// License: MIT
+// Description: The outgoing image melts down in uneven columns, like the Doom screen wipe
+// 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;
+    int bars;
+    float amplitude;
+    float noise;
+    float frequency;
+    float dripScale;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e30 = uv[0u];
+    float _e32 = uv[1u];
+    metal::float4 _e35 = _to.sample(_sampler, metal::float2(_e30, 1.0 - _e32), metal::level(0.0));
+    return _e35;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e30 = uv_1[0u];
+    float _e32 = uv_1[1u];
+    metal::float4 _e35 = _from.sample(_sampler, metal::float2(_e30, 1.0 - _e32), metal::level(0.0));
+    return _e35;
+}
+
+float drip(
+    thread int& num,
+    constant Uniforms& uniforms
+) {
+    int _e29 = num;
+    int _e32 = uniforms.bars;
+    float _e39 = uniforms.dripScale;
+    return metal::sin((static_cast<float>(_e29) / static_cast<float>(as_type<int>(as_type<uint>(_e32) - as_type<uint>(1)))) * 3.141592) * _e39;
+}
+
+float rand(
+    thread int& num_1
+) {
+    int _e29 = num_1;
+    float _e31 = static_cast<float>(_e29) * 67123.31;
+    int _e36 = num_1;
+    int _e41 = num_1;
+    return metal::fract(((_e31 - (metal::floor(_e31 / 12.0) * 12.0)) * metal::sin(static_cast<float>(_e36) * 10.3)) * metal::cos(static_cast<float>(_e41)));
+}
+
+float wave(
+    thread int& num_2,
+    constant Uniforms& uniforms
+) {
+    float fn = {};
+    int _e30 = num_2;
+    float _e33 = uniforms.frequency;
+    int _e37 = uniforms.bars;
+    fn = ((static_cast<float>(_e30) * _e33) * 0.1) * static_cast<float>(_e37);
+    float _e40 = fn;
+    float _e43 = fn;
+    float _e47 = fn;
+    return (((metal::cos(_e40 * 0.5) * metal::cos(_e43 * 0.13)) * metal::sin((_e47 + 10.0) * 0.3)) / 2.0) + 0.5;
+}
+
+float pos(
+    thread int& num_3,
+    constant Uniforms& uniforms
+) {
+    float local = {};
+    int param = {};
+    int param_1 = {};
+    int param_2 = {};
+    float local_1 = {};
+    int param_3 = {};
+    float _e36 = uniforms.noise;
+    if (_e36 == 0.0) {
+        int _e38 = num_3;
+        param = _e38;
+        float _e39 = wave(param, uniforms);
+        local = _e39;
+    } else {
+        int _e40 = num_3;
+        param_1 = _e40;
+        float _e41 = wave(param_1, uniforms);
+        int _e42 = num_3;
+        param_2 = _e42;
+        float _e43 = rand(param_2);
+        float _e45 = uniforms.noise;
+        local = metal::mix(_e41, _e43, _e45);
+    }
+    float _e47 = local;
+    float _e49 = uniforms.dripScale;
+    if (_e49 == 0.0) {
+        local_1 = 0.0;
+    } else {
+        int _e51 = num_3;
+        param_3 = _e51;
+        float _e52 = drip(param_3, uniforms);
+        local_1 = _e52;
+    }
+    float _e53 = local_1;
+    return _e47 + _e53;
+}
+
+int naga_f2i32(float value) {
+    return static_cast<int>(metal::clamp(value, -2147483600.0, 2147483500.0));
+}
+
+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
+) {
+    int bar = {};
+    float scale = {};
+    int param_4 = {};
+    float phase = {};
+    float posY = {};
+    metal::float2 p = {};
+    metal::float4 c = {};
+    metal::float2 param_5 = {};
+    metal::float2 param_6 = {};
+    float _e39 = uv_2[0u];
+    int _e41 = uniforms.bars;
+    bar = naga_f2i32(_e39 * static_cast<float>(_e41));
+    int _e45 = bar;
+    param_4 = _e45;
+    float _e46 = pos(param_4, uniforms);
+    float _e48 = uniforms.amplitude;
+    scale = 1.0 + (_e46 * _e48);
+    float _e52 = uniforms.progress;
+    float _e53 = scale;
+    phase = _e52 * _e53;
+    float _e56 = uv_2[1u];
+    posY = _e56 / 1.0;
+    float _e58 = phase;
+    float _e59 = posY;
+    if ((_e58 + _e59) < 1.0) {
+        float _e63 = uv_2[0u];
+        float _e65 = uv_2[1u];
+        float _e66 = phase;
+        p = metal::float2(_e63, _e65 + metal::mix(0.0, 1.0, _e66)) / metal::float2(1.0, 1.0);
+        metal::float2 _e71 = p;
+        param_5 = _e71;
+        metal::float4 _e72 = getFromColor(param_5, _from, _sampler);
+        c = _e72;
+    } else {
+        metal::float2 _e73 = uv_2;
+        p = _e73 / metal::float2(1.0, 1.0);
+        metal::float2 _e75 = p;
+        param_6 = _e75;
+        metal::float4 _e76 = getToColor(param_6, _sampler, _to);
+        c = _e76;
+    }
+    metal::float4 _e77 = c;
+    return _e77;
+}
+
+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_7 = {};
+    metal::float2 _e29 = _uv_1;
+    param_7 = _e29;
+    metal::float4 _e30 = transition(param_7, _from, _sampler, _to, uniforms);
+    _fragColor = _e30;
+    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/Dreamy.metal

@@ -0,0 +1,133 @@
+// Dreamy — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Dreamy.glsl
+// Author: mikolalysenko
+// License: MIT
+// Description: A crossfade with a gentle wavy distortion
+// 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 _e16 = uv[0u];
+    float _e18 = uv[1u];
+    metal::float4 _e21 = _to.sample(_sampler, metal::float2(_e16, 1.0 - _e18), metal::level(0.0));
+    return _e21;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e16 = uv_1[0u];
+    float _e18 = uv_1[1u];
+    metal::float4 _e21 = _from.sample(_sampler, metal::float2(_e16, 1.0 - _e18), metal::level(0.0));
+    return _e21;
+}
+
+metal::float2 offset(
+    thread float& progress,
+    thread float& x,
+    thread float& theta
+) {
+    float phase = {};
+    float shifty = {};
+    float _e19 = progress;
+    float _e20 = progress;
+    float _e22 = progress;
+    float _e24 = theta;
+    phase = ((_e19 * _e20) + _e22) + _e24;
+    float _e26 = progress;
+    float _e28 = progress;
+    float _e29 = x;
+    shifty = (0.03 * _e26) * metal::cos(10.0 * (_e28 + _e29));
+    float _e34 = shifty;
+    return metal::float2(0.0, _e34);
+}
+
+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
+) {
+    float param = {};
+    float param_1 = {};
+    float param_2 = {};
+    metal::float2 param_3 = {};
+    float param_4 = {};
+    float param_5 = {};
+    float param_6 = {};
+    metal::float2 param_7 = {};
+    metal::float2 _e23 = p;
+    float _e25 = uniforms.progress;
+    param = _e25;
+    float _e27 = p[0u];
+    param_1 = _e27;
+    param_2 = 0.0;
+    metal::float2 _e28 = offset(param, param_1, param_2);
+    param_3 = _e23 + _e28;
+    metal::float4 _e30 = getFromColor(param_3, _from, _sampler);
+    metal::float2 _e31 = p;
+    float _e33 = uniforms.progress;
+    param_4 = 1.0 - _e33;
+    float _e36 = p[0u];
+    param_5 = _e36;
+    param_6 = 3.14;
+    metal::float2 _e37 = offset(param_4, param_5, param_6);
+    param_7 = _e31 + _e37;
+    metal::float4 _e39 = getToColor(param_7, _sampler, _to);
+    float _e41 = uniforms.progress;
+    return metal::mix(_e30, _e39, metal::float4(_e41));
+}
+
+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 _e15 = _uv_1;
+    param_8 = _e15;
+    metal::float4 _e16 = transition(param_8, _from, _sampler, _to, uniforms);
+    _fragColor = _e16;
+    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/DreamyZoom.metal

@@ -0,0 +1,182 @@
+// DreamyZoom — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DreamyZoom.glsl
+// Author: Zeh Fernando
+// License: MIT
+// Description: Zooms and rotates into a bright flash, then out 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 rotation;
+    float scale;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e21 = uv[0u];
+    float _e23 = uv[1u];
+    metal::float4 _e26 = _to.sample(_sampler, metal::float2(_e21, 1.0 - _e23), metal::level(0.0));
+    return _e26;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e21 = uv_1[0u];
+    float _e23 = uv_1[1u];
+    metal::float4 _e26 = _from.sample(_sampler, metal::float2(_e21, 1.0 - _e23), metal::level(0.0));
+    return _e26;
+}
+
+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 phase = {};
+    float local = {};
+    float angleOffset = {};
+    float local_1 = {};
+    float newScale = {};
+    float local_2 = {};
+    metal::float2 center = {};
+    metal::float2 assumedCenter = {};
+    metal::float2 p = {};
+    float angle = {};
+    float dist = {};
+    metal::float4 c = {};
+    metal::float4 local_3 = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float local_4 = {};
+    float _e37 = uniforms.progress;
+    if (_e37 < 0.5) {
+        float _e40 = uniforms.progress;
+        local = _e40 * 2.0;
+    } else {
+        float _e43 = uniforms.progress;
+        local = (_e43 - 0.5) * 2.0;
+    }
+    float _e46 = local;
+    phase = _e46;
+    float _e48 = uniforms.progress;
+    if (_e48 < 0.5) {
+        float _e51 = uniforms.rotation;
+        float _e53 = phase;
+        local_1 = metal::mix(0.0, _e51 * 0.03926991, _e53);
+    } else {
+        float _e56 = uniforms.rotation;
+        float _e59 = phase;
+        local_1 = metal::mix(-(_e56) * 0.03926991, 0.0, _e59);
+    }
+    float _e61 = local_1;
+    angleOffset = _e61;
+    float _e63 = uniforms.progress;
+    if (_e63 < 0.5) {
+        float _e66 = uniforms.scale;
+        float _e67 = phase;
+        local_2 = metal::mix(1.0, _e66, _e67);
+    } else {
+        float _e70 = uniforms.scale;
+        float _e71 = phase;
+        local_2 = metal::mix(_e70, 1.0, _e71);
+    }
+    float _e73 = local_2;
+    newScale = _e73;
+    center = metal::float2(0.0, 0.0);
+    assumedCenter = metal::float2(0.5, 0.5);
+    metal::float2 _e74 = uv_2;
+    float _e76 = newScale;
+    float _e80 = uniforms.ratio;
+    p = ((_e74 - metal::float2(0.5, 0.5)) / metal::float2(_e76)) * metal::float2(_e80, 1.0);
+    float _e84 = p[1u];
+    float _e86 = p[0u];
+    float _e88 = angleOffset;
+    angle = metal::atan2(_e84, _e86) + _e88;
+    metal::float2 _e90 = center;
+    metal::float2 _e91 = p;
+    dist = metal::distance(_e90, _e91);
+    float _e93 = angle;
+    float _e95 = dist;
+    float _e98 = uniforms.ratio;
+    p[0u] = ((metal::cos(_e93) * _e95) / _e98) + 0.5;
+    float _e102 = angle;
+    float _e104 = dist;
+    p[1u] = (metal::sin(_e102) * _e104) + 0.5;
+    float _e109 = uniforms.progress;
+    if (_e109 < 0.5) {
+        metal::float2 _e111 = p;
+        param = _e111;
+        metal::float4 _e112 = getFromColor(param, _from, _sampler);
+        local_3 = _e112;
+    } else {
+        metal::float2 _e113 = p;
+        param_1 = _e113;
+        metal::float4 _e114 = getToColor(param_1, _sampler, _to);
+        local_3 = _e114;
+    }
+    metal::float4 _e115 = local_3;
+    c = _e115;
+    metal::float4 _e116 = c;
+    float _e118 = uniforms.progress;
+    if (_e118 < 0.5) {
+        float _e120 = phase;
+        local_4 = metal::mix(0.0, 1.0, _e120);
+    } else {
+        float _e122 = phase;
+        local_4 = metal::mix(1.0, 0.0, _e122);
+    }
+    float _e124 = local_4;
+    return _e116 + metal::float4(_e124);
+}
+
+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 _e20 = _uv_1;
+    param_2 = _e20;
+    metal::float4 _e21 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e21;
+    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 };
+}