gl-transitions 1.74.0 → 1.76.0

package/wgsl/Swirl.wgsl

@@ -0,0 +1,124 @@
+// Swirl — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Swirl.glsl
+// Author: Sergey Kosarevsky
+// License: MIT
+// Description: Both images swirl around the center while crossfading
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e17 = (*uv)[0u];
+    let _e19 = (*uv)[1u];
+    let _e22 = textureSampleLevel(_to, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e17 = (*uv_1)[0u];
+    let _e19 = (*uv_1)[1u];
+    let _e22 = textureSampleLevel(_from, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn transition(UV: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var Radius: f32;
+    var T: f32;
+    var Dist: f32;
+    var Percent: f32;
+    var A: f32;
+    var local: f32;
+    var Theta: f32;
+    var S: f32;
+    var C: f32;
+    var C0_: vec4<f32>;
+    var param: vec2<f32>;
+    var C1_: vec4<f32>;
+    var param_1: vec2<f32>;
+
+    Radius = 1f;
+    let _e30 = uniforms.progress;
+    T = _e30;
+    let _e31 = (*UV);
+    (*UV) = (_e31 - vec2<f32>(0.5f, 0.5f));
+    let _e33 = (*UV);
+    Dist = length(_e33);
+    let _e35 = Dist;
+    let _e36 = Radius;
+    if (_e35 < _e36) {
+        let _e38 = Radius;
+        let _e39 = Dist;
+        let _e41 = Radius;
+        Percent = ((_e38 - _e39) / _e41);
+        let _e43 = T;
+        if (_e43 <= 0.5f) {
+            let _e45 = T;
+            local = mix(0f, 1f, (_e45 / 0.5f));
+        } else {
+            let _e48 = T;
+            local = mix(1f, 0f, ((_e48 - 0.5f) / 0.5f));
+        }
+        let _e52 = local;
+        A = _e52;
+        let _e53 = Percent;
+        let _e54 = Percent;
+        let _e56 = A;
+        Theta = ((((_e53 * _e54) * _e56) * 8f) * 3.14159f);
+        let _e60 = Theta;
+        S = sin(_e60);
+        let _e62 = Theta;
+        C = cos(_e62);
+        let _e64 = (*UV);
+        let _e65 = C;
+        let _e66 = S;
+        let _e70 = (*UV);
+        let _e71 = S;
+        let _e72 = C;
+        (*UV) = vec2<f32>(dot(_e64, vec2<f32>(_e65, -(_e66))), dot(_e70, vec2<f32>(_e71, _e72)));
+    }
+    let _e76 = (*UV);
+    (*UV) = (_e76 + vec2<f32>(0.5f, 0.5f));
+    let _e78 = (*UV);
+    param = _e78;
+    let _e79 = getFromColor((&param));
+    C0_ = _e79;
+    let _e80 = (*UV);
+    param_1 = _e80;
+    let _e81 = getToColor((&param_1));
+    C1_ = _e81;
+    let _e82 = C0_;
+    let _e83 = C1_;
+    let _e84 = T;
+    return mix(_e82, _e83, vec4(_e84));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_2 = _e16;
+    let _e17 = transition((&param_2));
+    _fragColor = _e17;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/TVStatic.wgsl

@@ -0,0 +1,106 @@
+// TVStatic — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/TVStatic.glsl
+// Author: Brandon Anzaldi
+// License: MIT
+// Description: Cuts to full-screen TV static, then to the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    offset: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn noise(co: ptr<function, vec2<f32>>) -> f32 {
+    var a: f32;
+    var b: f32;
+    var c: f32;
+    var dt: f32;
+    var sn: f32;
+
+    a = 12.9898f;
+    b = 78.233f;
+    c = 43758.547f;
+    let _e22 = (*co);
+    let _e24 = uniforms.progress;
+    let _e26 = a;
+    let _e27 = b;
+    dt = dot((_e22 * _e24), vec2<f32>(_e26, _e27));
+    let _e30 = dt;
+    sn = (_e30 - (floor((_e30 / 3.14f)) * 3.14f));
+    let _e35 = sn;
+    let _e37 = c;
+    return fract((sin(_e35) * _e37));
+}
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn transition(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e21 = uniforms.progress;
+    let _e23 = uniforms.offset;
+    if (_e21 < _e23) {
+        let _e25 = (*p);
+        param = _e25;
+        let _e26 = getFromColor((&param));
+        return _e26;
+    } else {
+        let _e28 = uniforms.progress;
+        let _e30 = uniforms.offset;
+        if (_e28 > (1f - _e30)) {
+            let _e33 = (*p);
+            param_1 = _e33;
+            let _e34 = getToColor((&param_1));
+            return _e34;
+        } else {
+            let _e35 = (*p);
+            param_2 = _e35;
+            let _e36 = noise((&param_2));
+            let _e37 = vec3(_e36);
+            return vec4<f32>(_e37.x, _e37.y, _e37.z, 1f);
+        }
+    }
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_3 = _e17;
+    let _e18 = transition((&param_3));
+    _fragColor = _e18;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/TilesWave.wgsl

@@ -0,0 +1,262 @@
+// TilesWave — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/TilesWave.glsl
+// Author: numb3r23
+// License: MIT
+// Description: The incoming image is revealed tile by tile in a diagonal wave
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    tileCount: vec2<i32>,
+    flipX: i32,
+    flipY: i32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var tileSize: vec2<f32>;
+    var posInTile: vec2<f32>;
+    var tileNum: vec2<f32>;
+    var countTiles: f32;
+    var offset: f32;
+    var timeOffset: f32;
+    var sinTime: f32;
+    var texC: vec2<f32>;
+    var param: vec2<f32>;
+    var local: f32;
+    var param_1: vec2<f32>;
+    var local_1: f32;
+    var globalUV: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var local_2: f32;
+    var param_4: vec2<f32>;
+    var local_3: f32;
+    var globalUV_1: vec2<f32>;
+    var param_5: vec2<f32>;
+    var phi_149_: bool;
+    var phi_199_: bool;
+    var phi_261_: bool;
+    var phi_314_: bool;
+
+    let _e38 = uniforms.tileCount;
+    tileSize = (vec2(1f) / vec2<f32>(_e38));
+    let _e42 = (*uv_2);
+    let _e44 = uniforms.tileCount;
+    posInTile = fract((_e42 * vec2<f32>(_e44)));
+    let _e48 = (*uv_2);
+    let _e50 = uniforms.tileCount;
+    tileNum = floor((_e48 * vec2<f32>(_e50)));
+    let _e56 = uniforms.tileCount[0u];
+    let _e59 = uniforms.tileCount[1u];
+    countTiles = f32((_e56 * _e59));
+    let _e63 = tileNum[1u];
+    let _e65 = tileNum[0u];
+    let _e68 = uniforms.tileCount[1u];
+    let _e72 = countTiles;
+    offset = ((_e63 + (_e65 * f32(_e68))) / _e72);
+    let _e75 = uniforms.progress;
+    let _e76 = offset;
+    let _e78 = countTiles;
+    timeOffset = clamp(((_e75 - _e76) * _e78), 0f, 0.5f);
+    let _e81 = timeOffset;
+    sinTime = (1f - abs(cos((fract(_e81) * 3.1415925f))));
+    let _e87 = posInTile;
+    texC = _e87;
+    let _e88 = sinTime;
+    if (_e88 <= 0.5f) {
+        let _e91 = uniforms.flipX;
+        if (_e91 != 0i) {
+            let _e94 = texC[0u];
+            let _e95 = sinTime;
+            let _e96 = (_e94 < _e95);
+            phi_149_ = _e96;
+            if !(_e96) {
+                let _e99 = texC[0u];
+                let _e100 = sinTime;
+                phi_149_ = (_e99 > (1f - _e100));
+            }
+            let _e104 = phi_149_;
+            if _e104 {
+                let _e105 = (*uv_2);
+                param = _e105;
+                let _e106 = getFromColor((&param));
+                return _e106;
+            }
+            let _e108 = texC[0u];
+            if (_e108 < 0.5f) {
+                let _e111 = texC[0u];
+                let _e112 = sinTime;
+                let _e115 = sinTime;
+                local = (((_e111 - _e112) * 0.5f) / (0.5f - _e115));
+            } else {
+                let _e119 = texC[0u];
+                let _e122 = sinTime;
+                local = ((((_e119 - 0.5f) * 0.5f) / (0.5f - _e122)) + 0.5f);
+            }
+            let _e126 = local;
+            texC[0u] = _e126;
+        }
+        let _e129 = uniforms.flipY;
+        if (_e129 != 0i) {
+            let _e132 = texC[1u];
+            let _e133 = sinTime;
+            let _e134 = (_e132 < _e133);
+            phi_199_ = _e134;
+            if !(_e134) {
+                let _e137 = texC[1u];
+                let _e138 = sinTime;
+                phi_199_ = (_e137 > (1f - _e138));
+            }
+            let _e142 = phi_199_;
+            if _e142 {
+                let _e143 = (*uv_2);
+                param_1 = _e143;
+                let _e144 = getFromColor((&param_1));
+                return _e144;
+            }
+            let _e146 = texC[1u];
+            if (_e146 < 0.5f) {
+                let _e149 = texC[1u];
+                let _e150 = sinTime;
+                let _e153 = sinTime;
+                local_1 = (((_e149 - _e150) * 0.5f) / (0.5f - _e153));
+            } else {
+                let _e157 = texC[1u];
+                let _e160 = sinTime;
+                local_1 = ((((_e157 - 0.5f) * 0.5f) / (0.5f - _e160)) + 0.5f);
+            }
+            let _e164 = local_1;
+            texC[1u] = _e164;
+        }
+        let _e166 = tileNum;
+        let _e167 = tileSize;
+        let _e169 = texC;
+        let _e170 = tileSize;
+        globalUV = ((_e166 * _e167) + (_e169 * _e170));
+        let _e173 = globalUV;
+        param_2 = _e173;
+        let _e174 = getFromColor((&param_2));
+        return _e174;
+    } else {
+        let _e176 = uniforms.flipX;
+        if (_e176 != 0i) {
+            let _e179 = texC[0u];
+            let _e180 = sinTime;
+            let _e181 = (_e179 > _e180);
+            phi_261_ = _e181;
+            if !(_e181) {
+                let _e184 = texC[0u];
+                let _e185 = sinTime;
+                phi_261_ = (_e184 < (1f - _e185));
+            }
+            let _e189 = phi_261_;
+            if _e189 {
+                let _e190 = (*uv_2);
+                param_3 = _e190;
+                let _e191 = getToColor((&param_3));
+                return _e191;
+            }
+            let _e193 = texC[0u];
+            if (_e193 < 0.5f) {
+                let _e196 = texC[0u];
+                let _e197 = sinTime;
+                let _e200 = sinTime;
+                local_2 = (((_e196 - _e197) * 0.5f) / (0.5f - _e200));
+            } else {
+                let _e204 = texC[0u];
+                let _e207 = sinTime;
+                local_2 = ((((_e204 - 0.5f) * 0.5f) / (0.5f - _e207)) + 0.5f);
+            }
+            let _e211 = local_2;
+            texC[0u] = _e211;
+            let _e214 = texC[0u];
+            texC[0u] = (1f - _e214);
+        }
+        let _e218 = uniforms.flipY;
+        if (_e218 != 0i) {
+            let _e221 = texC[1u];
+            let _e222 = sinTime;
+            let _e223 = (_e221 > _e222);
+            phi_314_ = _e223;
+            if !(_e223) {
+                let _e226 = texC[1u];
+                let _e227 = sinTime;
+                phi_314_ = (_e226 < (1f - _e227));
+            }
+            let _e231 = phi_314_;
+            if _e231 {
+                let _e232 = (*uv_2);
+                param_4 = _e232;
+                let _e233 = getToColor((&param_4));
+                return _e233;
+            }
+            let _e235 = texC[1u];
+            if (_e235 < 0.5f) {
+                let _e238 = texC[1u];
+                let _e239 = sinTime;
+                let _e242 = sinTime;
+                local_3 = (((_e238 - _e239) * 0.5f) / (0.5f - _e242));
+            } else {
+                let _e246 = texC[1u];
+                let _e249 = sinTime;
+                local_3 = ((((_e246 - 0.5f) * 0.5f) / (0.5f - _e249)) + 0.5f);
+            }
+            let _e253 = local_3;
+            texC[1u] = _e253;
+            let _e256 = texC[1u];
+            texC[1u] = (1f - _e256);
+        }
+        let _e259 = tileNum;
+        let _e260 = tileSize;
+        let _e262 = texC;
+        let _e263 = tileSize;
+        globalUV_1 = ((_e259 * _e260) + (_e262 * _e263));
+        let _e266 = globalUV_1;
+        param_5 = _e266;
+        let _e267 = getToColor((&param_5));
+        return _e267;
+    }
+}
+
+fn main_1() {
+    var param_6: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_6 = _e17;
+    let _e18 = transition((&param_6));
+    _fragColor = _e18;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/TopBottom.wgsl

@@ -0,0 +1,109 @@
+// TopBottom — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/TopBottom.glsl
+// Author: zhmy
+// License: MIT
+// Description: The outgoing image shrinks away upward while the incoming one slides in from the bottom
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e24 = (*uv)[0u];
+    let _e26 = (*uv)[1u];
+    let _e29 = textureSampleLevel(_from, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e24 = (*uv_1)[0u];
+    let _e26 = (*uv_1)[1u];
+    let _e29 = textureSampleLevel(_to, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_74_: bool;
+
+    let _e23 = (*p);
+    let _e25 = all((vec2<f32>(0f, 0f) < _e23));
+    phi_74_ = _e25;
+    if _e25 {
+        let _e26 = (*p);
+        phi_74_ = all((_e26 < vec2<f32>(1f, 1f)));
+    }
+    let _e30 = phi_74_;
+    return _e30;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var spto: vec2<f32>;
+    var size: f32;
+    var spfr: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    spto = vec2<f32>(-1f, -1f);
+    let _e31 = uniforms.progress;
+    size = mix(1f, 3f, (_e31 * 0.2f));
+    let _e34 = (*uv_2);
+    let _e36 = size;
+    spto = (((_e34 + vec2<f32>(-0.5f, -0.5f)) * vec2(_e36)) + vec2<f32>(0.5f, 0.5f));
+    let _e40 = (*uv_2);
+    let _e42 = uniforms.progress;
+    spfr = (_e40 + vec2<f32>(0f, (1f - _e42)));
+    let _e46 = spfr;
+    param = _e46;
+    let _e47 = inBounds((&param));
+    if _e47 {
+        let _e48 = spfr;
+        param_1 = _e48;
+        let _e49 = getToColor((&param_1));
+        return _e49;
+    } else {
+        let _e50 = spto;
+        param_2 = _e50;
+        let _e51 = inBounds((&param_2));
+        if _e51 {
+            let _e52 = spto;
+            param_3 = _e52;
+            let _e53 = getFromColor((&param_3));
+            let _e55 = uniforms.progress;
+            return (_e53 * (1f - _e55));
+        } else {
+            return vec4<f32>(0f, 0f, 0f, 1f);
+        }
+    }
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e23 = _uv_1;
+    param_4 = _e23;
+    let _e24 = transition((&param_4));
+    _fragColor = _e24;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/VerticalClose.wgsl

@@ -0,0 +1,72 @@
+// VerticalClose — WGSL, 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
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e15 = (*uv)[0u];
+    let _e17 = (*uv)[1u];
+    let _e20 = textureSampleLevel(_to, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e15 = (*uv_1)[0u];
+    let _e17 = (*uv_1)[1u];
+    let _e20 = textureSampleLevel(_from, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var s: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e18 = (*uv_2)[0u];
+    let _e21 = uniforms.progress;
+    let _e27 = uniforms.progress;
+    s = ((2f - abs(((_e18 - 0.5f) / (_e21 - 1f)))) - (2f * _e27));
+    let _e30 = (*uv_2);
+    param = _e30;
+    let _e31 = getFromColor((&param));
+    let _e32 = (*uv_2);
+    param_1 = _e32;
+    let _e33 = getToColor((&param_1));
+    let _e34 = s;
+    return mix(_e31, _e33, vec4(smoothstep(0.5f, 0f, _e34)));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e14 = _uv_1;
+    param_2 = _e14;
+    let _e15 = transition((&param_2));
+    _fragColor = _e15;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}