Attachment 120995 Details for Bug 93681 – new.shader_test

new.shader_test

t.new.shader_test (text/plain), 33.47 KB, created by Matt Turner on 2016-01-13 00:29:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Matt Turner

Created: 2016-01-13 00:29:24 UTC

Size: 33.47 KB

patch

obsolete

>[require]
>GLSL >= 1.40
>
>[vertex shader passthrough]
>
>[fragment shader]
>#version 140
>#extension GL_ARB_fragment_coord_conventions : enable
>#extension GL_ARB_shader_bit_encoding : require
>layout(origin_upper_left ) in vec4 gl_FragCoord;
>out vec4 fsout_c0;
>out vec4 fsout_c1;
>out vec4 fsout_c2;
>out vec4 fsout_c3;
>out vec4 fsout_c4;
>out vec4 fsout_c5;
>out vec4 fsout_c6;
>out vec4 fsout_c7;
>vec4 temps[295];
>vec4 temps_9_14[6];
>vec4 temps_15_20[6];
>vec4 temps_21_25[5];
>vec4 temps_26_30[5];
>
>int addr0;
>uniform uvec4 fsconst0[4];
>void main(void)
>{
>temps[0] = vec4(((gl_FragCoord)));
>temps[0].y = float(((gl_FragCoord) * uintBitsToFloat(fsconst0[2].zzzz) + uintBitsToFloat(fsconst0[2].wwww)).y);
>temps[1] = vec4(((vec4(0,0,0,1))));
>temps[2].x = float(((uintBitsToFloat(fsconst0[1].xxxx) * (vec4(3,3,3,3)))).x);
>temps[2].x = float((cos( temps[2].xxxx )).x);
>temps[2].x = float((abs( temps[2].xxxx )).x);
>temps[3].x = float((((vec4(2.0999999,2.0999999,2.0999999,2.0999999)) * uintBitsToFloat(fsconst0[1].xxxx))).x);
>temps[3].x = float((sin( temps[3].xxxx )).x);
>temps[3].x = float((abs( temps[3].xxxx )).x);
>temps[4].w = float(((vec4(1,1,1,1)).w));
>temps[5].x = float((sin(uintBitsToFloat(fsconst0[1].xxxx))).x);
>temps[4].x = float((( temps[5].xxxx  * (vec4(40,40,40,40)))).x);
>temps[4].y = float(((vec4(50,50,50,50)).y));
>temps[5].x = float((cos(uintBitsToFloat(fsconst0[1].xxxx))).x);
>temps[5].x = float(( temps[5].xxxx  * (vec4(40,40,40,40)) + (vec4(100,100,100,100))).x);
>temps[4].z = float(( temps[5].xxxx .z));
>temps[6] = vec4(( temps[4] ));
>temps[7].xzw = vec3(((vec4(-50,-50,100,400)).xzw));
>temps[8].x = float(( temps[3].xxxx  * (vec4(40,40,40,40)) + (vec4(-10,-10,-10,-10))).x);
>temps[7].y = float(( temps[8].xxxx .y));
>temps_9_14[0] = vec4(( temps[7] ));
>temps[7].xzw = vec3(((vec4(-15,-15,100,100)).xzw));
>temps[8].x = float(( temps[2].xxxx  * (vec4(15,15,15,15)) + (vec4(-15,-15,-15,-15))).x);
>temps[7].y = float(( temps[8].xxxx .y));
>temps_9_14[1] = vec4(( temps[7] ));
>temps[7].xzw = vec3(((vec4(0,0,100,25)).xzw));
>temps[8].x = float((((vec4(3.3000002,3.3000002,3.3000002,3.3000002)) * uintBitsToFloat(fsconst0[1].xxxx))).x);
>temps[8].x = float((sin( temps[8].xxxx )).x);
>temps[8].x = float((abs( temps[8].xxxx )).x);
>temps[8].x = float(( temps[8].xxxx  * (vec4(25,25,25,25)) + (vec4(-20,-20,-20,-20))).x);
>temps[7].y = float(( temps[8].xxxx .y));
>temps_9_14[2] = vec4(( temps[7] ));
>temps[7].xzw = vec3(((vec4(15,15,100,100)).xzw));
>temps[2].x = float(( temps[2].xxxx  * (vec4(15,15,15,15)) + (vec4(-15,-15,-15,-15))).x);
>temps[7].y = float(( temps[2].xxxx .y));
>temps_9_14[3] = vec4(( temps[7] ));
>temps[2].xzw = vec3(((vec4(50,50,100,400)).xzw));
>temps[3].x = float(( temps[3].xxxx  * (vec4(40,40,40,40)) + (vec4(-10,-10,-10,-10))).x);
>temps[2].y = float(( temps[3].xxxx .y));
>temps_9_14[4] = vec4(( temps[2] ));
>temps[2].w = float(((vec4(3,3,3,3)).w));
>temps[2].x = float(( temps[4].xxxx .x));
>temps[2].y = float(((vec4(50,50,50,50)).y));
>temps[2].z = float(( temps[5].xxxx .z));
>temps_9_14[5] = vec4(( temps[2] ));
>temps_15_20[0] = vec4(((vec4(1,0,0,1))));
>temps_15_20[1] = vec4(((vec4(0,1,0,1))));
>temps_15_20[2] = vec4(((vec4(0,0,1,1))));
>temps_15_20[3] = vec4(((vec4(0,1,0,1))));
>temps_15_20[4] = vec4(((vec4(1,0,0,1))));
>temps_15_20[5] = vec4(((vec4(10,10,10,0))));
>temps_21_25[0] = vec4(((vec4(0,1,0,-25))));
>temps_21_25[1] = vec4(((vec4(1,0,0,-100))));
>temps_21_25[2] = vec4(((vec4(0,-1,0,-75))));
>temps_21_25[3] = vec4(((vec4(-1,0,0,-100))));
>temps_21_25[4] = vec4(((vec4(0,0,-1,-200))));
>temps_26_30[0] = vec4(((vec4(0.76999998,0.63999999,0.30000001,0.69999999))));
>temps_26_30[1] = vec4(((vec4(1,0.15000001,0.15000001,0.1))));
>temps_26_30[2] = vec4(((vec4(0.76999998,0.63999999,0.38,0.1))));
>temps_26_30[3] = vec4(((vec4(0.15000001,1,0.15000001,0.1))));
>temps_26_30[4] = vec4(((vec4(0.76999998,0.63999999,0.38,0.1))));
>temps[2].x = float(1.0/(uintBitsToFloat(fsconst0[0].xxxx)));
>temps[2].y = float(1.0/(uintBitsToFloat(fsconst0[0].yyyy)));
>temps[2].xy = vec2((( temps[0].xyyy  *  temps[2].xyyy )).xy);
>temps[3].xyz = vec3(((vec4(0,25,-50,0)).xyz));
>temps[4].z = float(((vec4(1,1,1,1)).z));
>temps[4].x = mix(vec4((vec4(-0.80000001,-0.80000001,-0.80000001,-0.80000001))), vec4((vec4(0.80000001,0.80000001,0.80000001,0.80000001))), vec4( temps[2].xxxx )).x;
>temps[2].x = mix(vec4((vec4(-0.44999999,-0.44999999,-0.44999999,-0.44999999))), vec4((vec4(0.44999999,0.44999999,0.44999999,0.44999999))), vec4( temps[2].yyyy )).x;
>temps[4].y = float(( temps[2].xxxx .y));
>temps[2].x = float(dot(vec3( temps[4].xyzz ), vec3( temps[4].xyzz )));
>temps[2].x = float(inversesqrt( temps[2].xxxx .x));
>temps[2].xyz = vec3((( temps[4].xyzz  *  temps[2].xxxx )).xyz);
>temps[4] = vec4(((vec4(0.5,0,0,0))));
>temps[5].x = float(((vec4(1,1,1,1)).x));
>temps[7].x = float(((vec4(1,1,1,1)).x));
>temps[8].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>do {
>	temps[31].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[8].xxxx)), ivec4((ivec4(4,4,4,4)))).x) * uint(0xffffffff)));
>	if (any(bvec4(floatBitsToUint(temps[31].xxxx)))) {
>		break;
>	}
>	temps[32].x = float(( temps[8].xxxx .x));
>	temps[7].x = float((( temps[7].xxxx  *  temps[5].xxxx )).x);
>	temps[33].xyz = vec3(( temps[3].xyzx .xyz));
>	temps[34].xyz = vec3(( temps[2].xyzx .xyz));
>	temps[35].x = float(( temps[5].xxxx .x));
>	temps[36].x = float(((vec4(10000000,10000000,10000000,10000000)).x));
>	temps[37].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>	temps[38].xyz = vec3(((vec4(0,1,0,0)).xyz));
>	temps[39].xyz = vec3(((vec4(0,0,0,0)).xyz));
>	temps[40].xyz = vec3(((vec4(0,0,0,0)).xyz));
>	temps[41].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>	do {
>		temps[42].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[41].xxxx)), ivec4((ivec4(6,6,6,6)))).x) * uint(0xffffffff)));
>		if (any(bvec4(floatBitsToUint(temps[42].xxxx)))) {
>			break;
>		}
>		temps[43].x = float(ivec4(floatBitsToInt(temps[41].xxxx)));
>		temps[44].x = float((max( temps[43].xxxx , (vec4(0,0,0,0)))));
>		temps[45].x = float((min( temps[44].xxxx , (vec4(5,5,5,5)))));
>		temps[46].x = float(intBitsToFloat(ivec4( temps[45].xxxx )));
>		addr0 = int(floatBitsToInt(temps[46].xxxx));
>		temps[47].x = float(( temps_9_14[addr0].wwww .x));
>		temps[48].x = float(ivec4(floatBitsToInt(temps[41].xxxx)));
>		temps[49].x = float((max( temps[48].xxxx , (vec4(0,0,0,0)))));
>		temps[50].x = float((min( temps[49].xxxx , (vec4(5,5,5,5)))));
>		temps[51].x = float(intBitsToFloat(ivec4( temps[50].xxxx )));
>		addr0 = int(floatBitsToInt(temps[51].xxxx));
>		addr0 = int(floatBitsToInt(temps[51].xxxx));
>		temps[52].xyz = vec3((( temps_9_14[addr0].xyzz  +  -temps[33].xyzz )).xyz);
>		temps[53].x = float(dot(vec3( temps[52].xyzz ), vec3( temps[34].xyzz )));
>		temps[54].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[53].xxxx ), vec4((vec4(0,0,0,0)))).x) * uint(0xffffffff)));
>		if (any(bvec4(floatBitsToUint(temps[54].xxxx)))) {
>			temps[55].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>		} else {
>			temps[56].x = float(dot(vec3( temps[52].xyzz ), vec3( temps[52].xyzz )));
>			temps[57].x = float(( -temps[53].xxxx  *  temps[53].xxxx  +  temps[56].xxxx ).x);
>			temps[58].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[47].xxxx ), vec4( temps[57].xxxx )).x) * uint(0xffffffff)));
>			if (any(bvec4(floatBitsToUint(temps[58].xxxx)))) {
>				temps[55].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>			} else {
>				temps[59].x = float((( temps[47].xxxx  +  -temps[57].xxxx )).x);
>				temps[60].x = float(inversesqrt( temps[59].xxxx .x));
>				temps[60].x = float((( temps[60].xxxx  *  temps[59].xxxx )).x);
>				temps[60].x = mix( temps[60].xxxx , (vec4(0,0,0,0)), greaterThanEqual( -temps[59].xxxx , vec4(0.0))).x;
>				temps[61].x = float((( temps[53].xxxx  +  -temps[60].xxxx )).x);
>				temps[55].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>			}
>		}
>		temps[62].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[61].xxxx ), vec4( temps[36].xxxx )).x) * uint(0xffffffff)));
>		temps[63].x = float(uintBitsToFloat((floatBitsToUint(temps[55].xxxx) & floatBitsToUint(temps[62].xxxx))).x);
>		if (any(bvec4(floatBitsToUint(temps[63].xxxx)))) {
>			temps[39].xyz = vec3(( temps[34].xyzz  *  temps[61].xxxx  +  temps[33].xyzz ).xyz);
>			temps[64].x = float(ivec4(floatBitsToInt(temps[41].xxxx)));
>			temps[65].x = float((max( temps[64].xxxx , (vec4(0,0,0,0)))));
>			temps[66].x = float((min( temps[65].xxxx , (vec4(5,5,5,5)))));
>			temps[67].x = float(intBitsToFloat(ivec4( temps[66].xxxx )));
>			addr0 = int(floatBitsToInt(temps[67].xxxx));
>			addr0 = int(floatBitsToInt(temps[67].xxxx));
>			temps[68].xyz = vec3((( temps[39].xyzz  +  -temps_9_14[addr0].xyzz )).xyz);
>			temps[69].x = float(dot(vec3( temps[68].xyzz ), vec3( temps[68].xyzz )));
>			temps[70].x = float(inversesqrt( temps[69].xxxx .x));
>			temps[38].xyz = vec3((( temps[68].xyzz  *  temps[70].xxxx )).xyz);
>			temps[71].x = float(ivec4(floatBitsToInt(temps[41].xxxx)));
>			temps[72].x = float((max( temps[71].xxxx , (vec4(0,0,0,0)))));
>			temps[73].x = float((min( temps[72].xxxx , (vec4(5,5,5,5)))));
>			temps[74].x = float(intBitsToFloat(ivec4( temps[73].xxxx )));
>			addr0 = int(floatBitsToInt(temps[74].xxxx));
>			temps[40].xyz = vec3(( temps_15_20[addr0].xyzx .xyz));
>			temps[75].x = float(ivec4(floatBitsToInt(temps[41].xxxx)));
>			temps[76].x = float((max( temps[75].xxxx , (vec4(0,0,0,0)))));
>			temps[77].x = float((min( temps[76].xxxx , (vec4(5,5,5,5)))));
>			temps[78].x = float(intBitsToFloat(ivec4( temps[77].xxxx )));
>			addr0 = int(floatBitsToInt(temps[78].xxxx));
>			temps[35].x = float(( temps_15_20[addr0].wwww .x));
>			temps[36].x = float(( temps[61].xxxx .x));
>			temps[37].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>		}
>		temps[41].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[41].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>	} while(true);
>	temps[79].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>	do {
>		temps[80].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[79].xxxx)), ivec4((ivec4(5,5,5,5)))).x) * uint(0xffffffff)));
>		if (any(bvec4(floatBitsToUint(temps[80].xxxx)))) {
>			break;
>		}
>		temps[81].x = float(ivec4(floatBitsToInt(temps[79].xxxx)));
>		temps[82].x = float((max( temps[81].xxxx , (vec4(0,0,0,0)))));
>		temps[83].x = float((min( temps[82].xxxx , (vec4(4,4,4,4)))));
>		temps[84].x = float(intBitsToFloat(ivec4( temps[83].xxxx )));
>		addr0 = int(floatBitsToInt(temps[84].xxxx));
>		temps[85].xyz = vec3(( temps_21_25[addr0].xyzx .xyz));
>		temps[86].x = float(dot(vec3( temps[85].xyzz ), vec3( temps[34].xyzz )));
>		temps[87].x = float((abs( temps[86].xxxx )).x);
>		temps[88].x = float(uintBitsToFloat(uint(lessThan(vec4((vec4(0.001,0.001,0.001,0.001))), vec4( temps[87].xxxx )).x) * uint(0xffffffff)));
>		if (any(bvec4(floatBitsToUint(temps[88].xxxx)))) {
>			temps[89].x = float(ivec4(floatBitsToInt(temps[79].xxxx)));
>			temps[90].x = float((max( temps[89].xxxx , (vec4(0,0,0,0)))));
>			temps[91].x = float((min( temps[90].xxxx , (vec4(4,4,4,4)))));
>			temps[92].x = float(intBitsToFloat(ivec4( temps[91].xxxx )));
>			temps[93].x = float(dot(vec3( temps[85].xyzz ), vec3( temps[33].xyzz )));
>			addr0 = int(floatBitsToInt(temps[92].xxxx));
>			temps[94].x = float((( temps_21_25[addr0].wwww  +  -temps[93].xxxx )).x);
>			temps[95].x = float(1.0/( temps[86].xxxx ));
>			temps[96].x = float((( temps[94].xxxx  *  temps[95].xxxx )).x);
>			temps[97].x = float(uintBitsToFloat(uint(lessThan(vec4((vec4(0,0,0,0))), vec4( temps[96].xxxx )).x) * uint(0xffffffff)));
>			temps[98].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[96].xxxx ), vec4( temps[36].xxxx )).x) * uint(0xffffffff)));
>			temps[99].x = float(uintBitsToFloat((floatBitsToUint(temps[97].xxxx) & floatBitsToUint(temps[98].xxxx))).x);
>			if (any(bvec4(floatBitsToUint(temps[99].xxxx)))) {
>				temps[39].xyz = vec3(( temps[34].xyzz  *  temps[96].xxxx  +  temps[33].xyzz ).xyz);
>				temps[38].xyz = vec3(( temps[85].xyzx .xyz));
>				temps[100].x = float(ivec4(floatBitsToInt(temps[79].xxxx)));
>				temps[101].x = float((max( temps[100].xxxx , (vec4(0,0,0,0)))));
>				temps[102].x = float((min( temps[101].xxxx , (vec4(4,4,4,4)))));
>				temps[103].x = float(intBitsToFloat(ivec4( temps[102].xxxx )));
>				addr0 = int(floatBitsToInt(temps[103].xxxx));
>				temps[40].xyz = vec3(( temps_26_30[addr0].xyzx .xyz));
>				temps[104].x = float(ivec4(floatBitsToInt(temps[79].xxxx)));
>				temps[105].x = float((max( temps[104].xxxx , (vec4(0,0,0,0)))));
>				temps[106].x = float((min( temps[105].xxxx , (vec4(4,4,4,4)))));
>				temps[107].x = float(intBitsToFloat(ivec4( temps[106].xxxx )));
>				addr0 = int(floatBitsToInt(temps[107].xxxx));
>				temps[35].x = float(( temps_26_30[addr0].wwww .x));
>				temps[36].x = float(( temps[96].xxxx .x));
>				temps[37].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>			}
>		}
>		temps[79].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[79].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>	} while(true);
>	if (any(bvec4(floatBitsToUint(temps[37].xxxx)))) {
>		temps[108].xyz = vec3((( temps[6].xyzz  +  -temps[39].xyzz )).xyz);
>		temps[109].x = float(dot(vec3( temps[108].xyzz ), vec3( temps[108].xyzz )));
>		temps[110].x = float(inversesqrt( temps[109].xxxx .x));
>		temps[110].x = float((( temps[110].xxxx  *  temps[109].xxxx )).x);
>		temps[111].x = mix( temps[110].xxxx , (vec4(0,0,0,0)), greaterThanEqual( -temps[109].xxxx , vec4(0.0))).x;
>		temps[112].x = float(1.0/( temps[111].xxxx ));
>		temps[113].xyz = vec3((( temps[108].xyzz  *  temps[112].xxxx )).xyz);
>		temps[114].xyz = vec3((( temps[40].xyzz  * (vec4(0.25,0.25,0.25,0.25)))).xyz);
>		temps[115].xyz = vec3(( temps[114].xyzz .xyz));
>		temps[115].xyz = clamp(temps[115].xyz, 0.0, 1.0);
>		temps[116].x = float(dot(vec3( temps[38].xyzz ), vec3( temps[113].xyzz )));
>		temps[117].x = float(1.0/( temps[111].xxxx ));
>		temps[118].x = float((( temps[117].xxxx  *  temps[111].xxxx )).x);
>		temps[119].x = float(( temps[118].xxxx .x));
>		temps[119].x = clamp(temps[119].x, 0.0, 1.0);
>		temps[120].x = float((( temps[116].xxxx  *  temps[119].xxxx )).x);
>		temps[121].xyz = vec3((( temps[120].xxxx  *  temps[40].xyzz )).xyz);
>		temps[122].xyz = vec3(( temps[121].xyzz .xyz));
>		temps[122].xyz = clamp(temps[122].xyz, 0.0, 1.0);
>		temps[123].x = float(dot(vec3( temps[38].xyzz ), vec3( temps[2].xyzz )));
>		temps[124].x = float((abs( temps[123].xxxx )).x);
>		temps[125].x = float((min( temps[124].xxxx , (vec4(0.5,0.5,0.5,0.5)))));
>		temps[126].x = float(( temps[125].xxxx .x));
>		temps[126].x = clamp(temps[126].x, 0.0, 1.0);
>		temps[127].x = float((((vec4(1,1,1,1)) +  -temps[126].xxxx )).x);
>		temps[128].x = float((( temps[127].xxxx  *  temps[127].xxxx )).x);
>		temps[35].x = float((( temps[128].xxxx  *  temps[35].xxxx )).x);
>		temps[129].xyz = vec3((( temps[39].xyzz  +  -temps[3].xyzz )).xyz);
>		temps[130].x = float(dot(vec3( temps[129].xyzz ), vec3( temps[129].xyzz )));
>		temps[131].x = float(inversesqrt( temps[130].xxxx .x));
>		temps[132].xyz = vec3((( temps[129].xyzz  *  temps[131].xxxx )).xyz);
>		temps[33].xyz = vec3((( temps[39].xyzz  +  temps[38].xyzz )).xyz);
>		temps[133].x = float(dot(vec3( temps[38].xyzz ), vec3( temps[132].xyzz )));
>		temps[134].xyz = vec3((( temps[133].xxxx  *  temps[38].xyzz )).xyz);
>		temps[135].xyz = vec3((((vec4(2,2,2,2)) *  temps[134].xyzz )).xyz);
>		temps[136].xyz = vec3((( temps[132].xyzz  +  -temps[135].xyzz )).xyz);
>		temps[137].x = float(dot(vec3( temps[136].xyzz ), vec3( temps[136].xyzz )));
>		temps[138].x = float(inversesqrt( temps[137].xxxx .x));
>		temps[139].xyz = vec3((( temps[136].xyzz  *  temps[138].xxxx )).xyz);
>		temps[34].xyz = vec3(( temps[139].xyzx .xyz));
>		temps[140].x = float(dot(vec3( temps[38].xyzz ), vec3( temps[113].xyzz )));
>		temps[141].xyz = vec3((( temps[140].xxxx  *  temps[38].xyzz )).xyz);
>		temps[142].xyz = vec3((((vec4(2,2,2,2)) *  temps[141].xyzz )).xyz);
>		temps[143].xyz = vec3((( temps[113].xyzz  +  -temps[142].xyzz )).xyz);
>		temps[144].x = float(dot(vec3( temps[143].xyzz ), vec3( temps[139].xyzz )));
>		temps[145].x = float(( temps[144].xxxx .x));
>		temps[145].x = clamp(temps[145].x, 0.0, 1.0);
>		temps[146].x = float(pow( temps[145].xxxx , (vec4(3,3,3,3))));
>		temps[147].xyz = vec3(( temps[115].xyzx .xyz));
>		temps[148].xyz = vec3(( temps[33].xyzx .xyz));
>		temps[149].x = float(((vec4(1,1,1,1)).x));
>		temps[150].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[8].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>		if (any(bvec4(floatBitsToUint(temps[150].xxxx)))) {
>			temps[151].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>			do {
>				temps[152].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[151].xxxx)), ivec4((ivec4(64,64,64,64)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[152].xxxx)))) {
>					break;
>				}
>				temps[153].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[32].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[153].xxxx)))) {
>					temps[154].x = float(((vec4(4,4,4,4)).x));
>				} else {
>					temps[154].x = float(((vec4(1,1,1,1)).x));
>				}
>				temps[155].x = float(ivec4(floatBitsToInt(temps[151].xxxx)));
>				temps[156].x = float(1.0/( temps[154].xxxx ));
>				temps[157].x = float((( temps[155].xxxx  *  temps[156].xxxx )).x);
>				temps[158].x = float((floor( temps[157].xxxx )).x);
>				temps[159].x = float((( temps[154].xxxx  *  temps[158].xxxx )).x);
>				temps[160].x = float((( temps[155].xxxx  +  -temps[159].xxxx )).x);
>				temps[161].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[32].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[161].xxxx)))) {
>					temps[162].x = float(((vec4(4,4,4,4)).x));
>				} else {
>					temps[162].x = float(((vec4(1,1,1,1)).x));
>				}
>				temps[163].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[32].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[163].xxxx)))) {
>					temps[164].x = float(((vec4(4,4,4,4)).x));
>				} else {
>					temps[164].x = float(((vec4(1,1,1,1)).x));
>				}
>				temps[165].x = float(ivec4(floatBitsToInt(temps[151].xxxx)));
>				temps[166].x = float((( temps[165].xxxx  *  temps[162].xxxx )).x);
>				temps[167].x = float(1.0/( temps[164].xxxx ));
>				temps[168].x = float((( temps[166].xxxx  *  temps[167].xxxx )).x);
>				temps[169].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[32].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[169].xxxx)))) {
>					temps[170].x = float(((vec4(4,4,4,4)).x));
>				} else {
>					temps[170].x = float(((vec4(1,1,1,1)).x));
>				}
>				temps[171].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[32].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[171].xxxx)))) {
>					temps[172].x = float(((vec4(4,4,4,4)).x));
>				} else {
>					temps[172].x = float(((vec4(1,1,1,1)).x));
>				}
>				temps[173].x = float(uintBitsToFloat(uint(equal(uvec4(floatBitsToUint(temps[32].xxxx)), uvec4(uvec4(ivec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[173].xxxx)))) {
>					temps[174].x = float(((vec4(4,4,4,4)).x));
>				} else {
>					temps[174].x = float(((vec4(1,1,1,1)).x));
>				}
>				temps[175].x = float(ivec4(floatBitsToInt(temps[151].xxxx)));
>				temps[176].x = float((( temps[175].xxxx  *  temps[170].xxxx )).x);
>				temps[177].x = float((( temps[176].xxxx  *  temps[172].xxxx )).x);
>				temps[178].x = float(( temps[160].xxxx .x));
>				temps[178].y = float(( temps[168].xxxx .y));
>				temps[179].x = float(1.0/( temps[174].xxxx ));
>				temps[180].x = float((( temps[177].xxxx  *  temps[179].xxxx )).x);
>				temps[181].x = float((floor( temps[180].xxxx )).x);
>				temps[182].x = float((( temps[174].xxxx  *  temps[181].xxxx )).x);
>				temps[183].x = float((( temps[177].xxxx  +  -temps[182].xxxx )).x);
>				temps[178].z = float(( temps[183].xxxx .z));
>				temps[184].xyz = vec3((( temps[6].xyzz  +  temps[178].xyzz )).xyz);
>				temps[185].xyz = vec3(( temps[148].xyzx .xyz));
>				temps[186].xyz = vec3((( temps[184].xyzz  +  -temps[148].xyzz )).xyz);
>				temps[187].x = float(dot(vec3( temps[186].xyzz ), vec3( temps[186].xyzz )));
>				temps[188].x = float(inversesqrt( temps[187].xxxx .x));
>				temps[188].x = float((( temps[188].xxxx  *  temps[187].xxxx )).x);
>				temps[189].x = mix( temps[188].xxxx , (vec4(0,0,0,0)), greaterThanEqual( -temps[187].xxxx , vec4(0.0))).x;
>				temps[190].x = float(dot(vec3( temps[186].xyzz ), vec3( temps[186].xyzz )));
>				temps[191].x = float(inversesqrt( temps[190].xxxx .x));
>				temps[192].xyz = vec3((( temps[186].xyzz  *  temps[191].xxxx )).xyz);
>				temps[193].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>				temps[194].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>				do {
>					temps[195].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[194].xxxx)), ivec4((ivec4(5,5,5,5)))).x) * uint(0xffffffff)));
>					if (any(bvec4(floatBitsToUint(temps[195].xxxx)))) {
>						break;
>					}
>					temps[196].x = float(ivec4(floatBitsToInt(temps[194].xxxx)));
>					temps[197].x = float((max( temps[196].xxxx , (vec4(0,0,0,0)))));
>					temps[198].x = float((min( temps[197].xxxx , (vec4(5,5,5,5)))));
>					temps[199].x = float(intBitsToFloat(ivec4( temps[198].xxxx )));
>					addr0 = int(floatBitsToInt(temps[199].xxxx));
>					temps[200].x = float(( temps_9_14[addr0].wwww .x));
>					temps[201].x = float(ivec4(floatBitsToInt(temps[194].xxxx)));
>					temps[202].x = float((max( temps[201].xxxx , (vec4(0,0,0,0)))));
>					temps[203].x = float((min( temps[202].xxxx , (vec4(5,5,5,5)))));
>					temps[204].x = float(intBitsToFloat(ivec4( temps[203].xxxx )));
>					addr0 = int(floatBitsToInt(temps[204].xxxx));
>					addr0 = int(floatBitsToInt(temps[204].xxxx));
>					temps[205].xyz = vec3((( temps_9_14[addr0].xyzz  +  -temps[185].xyzz )).xyz);
>					temps[206].x = float(dot(vec3( temps[205].xyzz ), vec3( temps[192].xyzz )));
>					temps[207].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[206].xxxx ), vec4((vec4(0,0,0,0)))).x) * uint(0xffffffff)));
>					if (any(bvec4(floatBitsToUint(temps[207].xxxx)))) {
>						temps[208].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>					} else {
>						temps[209].x = float(dot(vec3( temps[205].xyzz ), vec3( temps[205].xyzz )));
>						temps[210].x = float(( -temps[206].xxxx  *  temps[206].xxxx  +  temps[209].xxxx ).x);
>						temps[211].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[200].xxxx ), vec4( temps[210].xxxx )).x) * uint(0xffffffff)));
>						if (any(bvec4(floatBitsToUint(temps[211].xxxx)))) {
>							temps[208].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>						} else {
>							temps[212].x = float((( temps[200].xxxx  +  -temps[210].xxxx )).x);
>							temps[213].x = float(inversesqrt( temps[212].xxxx .x));
>							temps[213].x = float((( temps[213].xxxx  *  temps[212].xxxx )).x);
>							temps[213].x = mix( temps[213].xxxx , (vec4(0,0,0,0)), greaterThanEqual( -temps[212].xxxx , vec4(0.0))).x;
>							temps[214].x = float((( temps[206].xxxx  +  -temps[213].xxxx )).x);
>							temps[208].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>						}
>					}
>					temps[215].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[214].xxxx ), vec4( temps[189].xxxx )).x) * uint(0xffffffff)));
>					temps[216].x = float(uintBitsToFloat((floatBitsToUint(temps[208].xxxx) & floatBitsToUint(temps[215].xxxx))).x);
>					if (any(bvec4(floatBitsToUint(temps[216].xxxx)))) {
>						temps[189].x = float(( temps[214].xxxx .x));
>						temps[193].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>					}
>					temps[194].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[194].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>				} while(true);
>				temps[217].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>				do {
>					temps[218].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[217].xxxx)), ivec4((ivec4(5,5,5,5)))).x) * uint(0xffffffff)));
>					if (any(bvec4(floatBitsToUint(temps[218].xxxx)))) {
>						break;
>					}
>					temps[219].x = float(ivec4(floatBitsToInt(temps[217].xxxx)));
>					temps[220].x = float((max( temps[219].xxxx , (vec4(0,0,0,0)))));
>					temps[221].x = float((min( temps[220].xxxx , (vec4(4,4,4,4)))));
>					temps[222].x = float(intBitsToFloat(ivec4( temps[221].xxxx )));
>					addr0 = int(floatBitsToInt(temps[222].xxxx));
>					temps[223].xyz = vec3(( temps_21_25[addr0].xyzx .xyz));
>					temps[224].x = float(dot(vec3( temps[223].xyzz ), vec3( temps[192].xyzz )));
>					temps[225].x = float((abs( temps[224].xxxx )).x);
>					temps[226].x = float(uintBitsToFloat(uint(lessThan(vec4((vec4(0.001,0.001,0.001,0.001))), vec4( temps[225].xxxx )).x) * uint(0xffffffff)));
>					if (any(bvec4(floatBitsToUint(temps[226].xxxx)))) {
>						temps[227].x = float(ivec4(floatBitsToInt(temps[217].xxxx)));
>						temps[228].x = float((max( temps[227].xxxx , (vec4(0,0,0,0)))));
>						temps[229].x = float((min( temps[228].xxxx , (vec4(4,4,4,4)))));
>						temps[230].x = float(intBitsToFloat(ivec4( temps[229].xxxx )));
>						temps[231].x = float(dot(vec3( temps[223].xyzz ), vec3( temps[185].xyzz )));
>						addr0 = int(floatBitsToInt(temps[230].xxxx));
>						temps[232].x = float((( temps_21_25[addr0].wwww  +  -temps[231].xxxx )).x);
>						temps[233].x = float(1.0/( temps[224].xxxx ));
>						temps[234].x = float((( temps[232].xxxx  *  temps[233].xxxx )).x);
>						temps[235].x = float(uintBitsToFloat(uint(lessThan(vec4((vec4(0,0,0,0))), vec4( temps[234].xxxx )).x) * uint(0xffffffff)));
>						temps[236].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[234].xxxx ), vec4( temps[189].xxxx )).x) * uint(0xffffffff)));
>						temps[237].x = float(uintBitsToFloat((floatBitsToUint(temps[235].xxxx) & floatBitsToUint(temps[236].xxxx))).x);
>						if (any(bvec4(floatBitsToUint(temps[237].xxxx)))) {
>							temps[189].x = float(( temps[234].xxxx .x));
>							temps[193].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>						}
>					}
>					temps[217].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[217].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>				} while(true);
>				if (any(bvec4(floatBitsToUint(temps[193].xxxx)))) {
>					temps[149].x = float((( temps[149].xxxx  + (vec4(-0.015625,-0.015625,-0.015625,-0.015625)))).x);
>				}
>				temps[151].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[151].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>			} while(true);
>		} else {
>			temps[149].x = float(((vec4(0.33000001,0.33000001,0.33000001,0.33000001)).x));
>			temps[238].xyz = vec3(( temps[33].xyzx .xyz));
>			temps[239].xyz = vec3((( temps[6].xyzz  +  -temps[33].xyzz )).xyz);
>			temps[240].x = float(dot(vec3( temps[239].xyzz ), vec3( temps[239].xyzz )));
>			temps[241].x = float(inversesqrt( temps[240].xxxx .x));
>			temps[241].x = float((( temps[241].xxxx  *  temps[240].xxxx )).x);
>			temps[242].x = mix( temps[241].xxxx , (vec4(0,0,0,0)), greaterThanEqual( -temps[240].xxxx , vec4(0.0))).x;
>			temps[243].x = float(dot(vec3( temps[239].xyzz ), vec3( temps[239].xyzz )));
>			temps[244].x = float(inversesqrt( temps[243].xxxx .x));
>			temps[245].xyz = vec3((( temps[239].xyzz  *  temps[244].xxxx )).xyz);
>			temps[246].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>			temps[247].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>			do {
>				temps[248].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[247].xxxx)), ivec4((ivec4(5,5,5,5)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[248].xxxx)))) {
>					break;
>				}
>				temps[249].x = float(ivec4(floatBitsToInt(temps[247].xxxx)));
>				temps[250].x = float((max( temps[249].xxxx , (vec4(0,0,0,0)))));
>				temps[251].x = float((min( temps[250].xxxx , (vec4(5,5,5,5)))));
>				temps[252].x = float(intBitsToFloat(ivec4( temps[251].xxxx )));
>				addr0 = int(floatBitsToInt(temps[252].xxxx));
>				temps[253].x = float(( temps_9_14[addr0].wwww .x));
>				temps[254].x = float(ivec4(floatBitsToInt(temps[247].xxxx)));
>				temps[255].x = float((max( temps[254].xxxx , (vec4(0,0,0,0)))));
>				temps[256].x = float((min( temps[255].xxxx , (vec4(5,5,5,5)))));
>				temps[257].x = float(intBitsToFloat(ivec4( temps[256].xxxx )));
>				addr0 = int(floatBitsToInt(temps[257].xxxx));
>				addr0 = int(floatBitsToInt(temps[257].xxxx));
>				temps[258].xyz = vec3((( temps_9_14[addr0].xyzz  +  -temps[238].xyzz )).xyz);
>				temps[259].x = float(dot(vec3( temps[258].xyzz ), vec3( temps[245].xyzz )));
>				temps[260].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[259].xxxx ), vec4((vec4(0,0,0,0)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[260].xxxx)))) {
>					temps[261].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>				} else {
>					temps[262].x = float(dot(vec3( temps[258].xyzz ), vec3( temps[258].xyzz )));
>					temps[263].x = float(( -temps[259].xxxx  *  temps[259].xxxx  +  temps[262].xxxx ).x);
>					temps[264].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[253].xxxx ), vec4( temps[263].xxxx )).x) * uint(0xffffffff)));
>					if (any(bvec4(floatBitsToUint(temps[264].xxxx)))) {
>						temps[261].x = float((uintBitsToFloat(uvec4(0U,0U,0U,0U)).x));
>					} else {
>						temps[265].x = float((( temps[253].xxxx  +  -temps[263].xxxx )).x);
>						temps[266].x = float(inversesqrt( temps[265].xxxx .x));
>						temps[266].x = float((( temps[266].xxxx  *  temps[265].xxxx )).x);
>						temps[266].x = mix( temps[266].xxxx , (vec4(0,0,0,0)), greaterThanEqual( -temps[265].xxxx , vec4(0.0))).x;
>						temps[267].x = float((( temps[259].xxxx  +  -temps[266].xxxx )).x);
>						temps[261].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>					}
>				}
>				temps[268].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[267].xxxx ), vec4( temps[242].xxxx )).x) * uint(0xffffffff)));
>				temps[269].x = float(uintBitsToFloat((floatBitsToUint(temps[261].xxxx) & floatBitsToUint(temps[268].xxxx))).x);
>				if (any(bvec4(floatBitsToUint(temps[269].xxxx)))) {
>					temps[242].x = float(( temps[267].xxxx .x));
>					temps[246].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>				}
>				temps[247].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[247].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>			} while(true);
>			temps[270].x = float((intBitsToFloat(ivec4(0,0,0,0)).x));
>			do {
>				temps[271].x = float(uintBitsToFloat(uint(greaterThanEqual(ivec4(floatBitsToInt(temps[270].xxxx)), ivec4((ivec4(5,5,5,5)))).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[271].xxxx)))) {
>					break;
>				}
>				temps[272].x = float(ivec4(floatBitsToInt(temps[270].xxxx)));
>				temps[273].x = float((max( temps[272].xxxx , (vec4(0,0,0,0)))));
>				temps[274].x = float((min( temps[273].xxxx , (vec4(4,4,4,4)))));
>				temps[275].x = float(intBitsToFloat(ivec4( temps[274].xxxx )));
>				addr0 = int(floatBitsToInt(temps[275].xxxx));
>				temps[276].xyz = vec3(( temps_21_25[addr0].xyzx .xyz));
>				temps[277].x = float(dot(vec3( temps[276].xyzz ), vec3( temps[245].xyzz )));
>				temps[278].x = float((abs( temps[277].xxxx )).x);
>				temps[279].x = float(uintBitsToFloat(uint(lessThan(vec4((vec4(0.001,0.001,0.001,0.001))), vec4( temps[278].xxxx )).x) * uint(0xffffffff)));
>				if (any(bvec4(floatBitsToUint(temps[279].xxxx)))) {
>					temps[280].x = float(ivec4(floatBitsToInt(temps[270].xxxx)));
>					temps[281].x = float((max( temps[280].xxxx , (vec4(0,0,0,0)))));
>					temps[282].x = float((min( temps[281].xxxx , (vec4(4,4,4,4)))));
>					temps[283].x = float(intBitsToFloat(ivec4( temps[282].xxxx )));
>					temps[284].x = float(dot(vec3( temps[276].xyzz ), vec3( temps[238].xyzz )));
>					addr0 = int(floatBitsToInt(temps[283].xxxx));
>					temps[285].x = float((( temps_21_25[addr0].wwww  +  -temps[284].xxxx )).x);
>					temps[286].x = float(1.0/( temps[277].xxxx ));
>					temps[287].x = float((( temps[285].xxxx  *  temps[286].xxxx )).x);
>					temps[288].x = float(uintBitsToFloat(uint(lessThan(vec4((vec4(0,0,0,0))), vec4( temps[287].xxxx )).x) * uint(0xffffffff)));
>					temps[289].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[287].xxxx ), vec4( temps[242].xxxx )).x) * uint(0xffffffff)));
>					temps[290].x = float(uintBitsToFloat((floatBitsToUint(temps[288].xxxx) & floatBitsToUint(temps[289].xxxx))).x);
>					if (any(bvec4(floatBitsToUint(temps[290].xxxx)))) {
>						temps[242].x = float(( temps[287].xxxx .x));
>						temps[246].x = float((uintBitsToFloat(uvec4(4294967295U,4294967295U,4294967295U,4294967295U)).x));
>					}
>				}
>				temps[270].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[270].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>			} while(true);
>			if (any(bvec4(floatBitsToUint(temps[246].xxxx)))) {
>				temps[149].x = float(((vec4(0,0,0,0)).x));
>			}
>		}
>		temps[291].xyz = vec3((( temps[122].xyzz  +  temps[146].xxxx )).xyz);
>		temps[147].xyz = vec3(( temps[149].xxxx  *  temps[291].xyzz  +  temps[115].xyzz ).xyz);
>		temps[292].w = float(((vec4(1,1,1,1)).w));
>		temps[292].xyz = vec3(( temps[147].xyzx .xyz));
>		temps[293] = vec4(( temps[292] ));
>	} else {
>		temps[35].x = float(((vec4(0,0,0,0)).x));
>		temps[293] = vec4(((vec4(0,0,0,0))));
>	}
>	temps[3].xyz = vec3(( temps[33].xyzx .xyz));
>	temps[2].xyz = vec3(( temps[34].xyzx .xyz));
>	temps[5].x = float(( temps[35].xxxx .x));
>	temps[4] = mix(vec4( temps[4] ), vec4( temps[293] ), vec4( temps[7].xxxx ));
>	temps[294].x = float(uintBitsToFloat(uint(lessThan(vec4( temps[35].xxxx ), vec4((vec4(0.001,0.001,0.001,0.001)))).x) * uint(0xffffffff)));
>	if (any(bvec4(floatBitsToUint(temps[294].xxxx)))) {
>		break;
>	}
>	temps[8].x = float(intBitsToFloat(ivec4((uvec4(floatBitsToUint(temps[8].xxxx)) + uvec4(uvec4(ivec4(1,1,1,1)))))).x);
>} while(true);
>temps[1].xyz = vec3(( temps[4].xyzx .xyz));
>temps[1].w = float(((vec4(1,1,1,1)).w));
>fsout_c0 = vec4(( temps[1] ));
>fsout_c1 = fsout_c0;
>fsout_c2 = fsout_c0;
>fsout_c3 = fsout_c0;
>fsout_c4 = fsout_c0;
>fsout_c5 = fsout_c0;
>fsout_c6 = fsout_c0;
>fsout_c7 = fsout_c0;
>}
>
>
>
>[test]

Actions: View

Attachments on bug 93681: 120988 | 120995 | 120996 | 144417 | 144421

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.