xref: /dports/math/curv/curv-0.5/tests/gpu/snowman.gpu

{
  is_2d: #false;
  is_3d: #true;
  bbox: [[-21.3125,-7.625,-15.4375],[20.875,47.4375,15.4375]];
  shader:
    "#define AA 1
    |#define TAA 1
    |#define FDUR 0.04
    |const vec3 background_colour = vec3(1,1,1);
    |const int ray_max_iter = 200;
    |const float ray_max_depth = 400.0;
    |#ifdef GLSLVIEWER
    |uniform vec3 u_eye3d;
    |uniform vec3 u_centre3d;
    |uniform vec3 u_up3d;
    |#endif
    |uniform float rv_smoothness;
    |float dist(vec4 r0)
    |{
    |  /* constants */
    |  float r1 = 1.0/0.0;
    |  vec3 r3 = vec3(0.0,0.0,0.0);
    |  float r15 = 5.0;
    |  float r17 = rv_smoothness;
    |  float r19 = 0.5;
    |  float r24 = 0.0;
    |  float r25 = 1.0;
    |  vec3 r38 = vec3(-1.0,-2.0,4.5);
    |  vec3 r53 = vec3(1.0,-2.0,4.5);
    |  vec3 r68 = vec3(0.0,0.0,4.5);
    |  float r81 = 4.0;
    |  vec3 r131 = vec3(0.0,12.0,0.0);
    |  float r143 = 10.0;
    |  vec3 r162 = vec3(0.0,12.0,9.8);
    |  vec3 r177 = vec3(0.0,10.0,9.6);
    |  vec3 r192 = vec3(0.0,8.0,9.0);
    |  vec3 r207 = vec3(-10.0,12.0,0.0);
    |  float r217 = -1.5707963267948966;
    |  vec3 r218 = vec3(0.0,1.0,0.0);
    |  float r265 = 1.5;
    |  vec3 r313 = vec3(10.0,12.0,0.0);
    |  float r323 = 1.5707963267948966;
    |  vec3 r324 = vec3(0.0,1.0,0.0);
    |  vec3 r418 = vec3(0.0,32.0,0.0);
    |  float r430 = 15.0;
    |  /* body */
    |  float r2 = r0.x;
    |  float r4 = r3.x;
    |  float r5 = r2-r4;
    |  float r6 = r0.y;
    |  float r7 = r3.y;
    |  float r8 = r6-r7;
    |  float r9 = r0.z;
    |  float r10 = r3.z;
    |  float r11 = r9-r10;
    |  float r12 = r0.w;
    |  vec3 r13 = vec3(r5,r8,r11);
    |  float r14 = length(r13);
    |  float r16 = r14-r15;
    |  bool r18 =(r1 == r1);
    |  float r20 = r16-r1;
    |  float r21 = r19*r20;
    |  float r22 = r21/r17;
    |  float r23 = r19+r22;
    |  float r26 = max(r23,r24);
    |  float r27 = min(r26,r25);
    |  float r28 = r25-r27;
    |  float r29 = r16*r28;
    |  float r30 = r1*r27;
    |  float r31 = r29+r30;
    |  float r32 = r17*r27;
    |  float r33 = r25-r27;
    |  float r34 = r32*r33;
    |  float r35 = r31-r34;
    |  float r36 =(r18 ? r16 : r35);
    |  float r37 = r0.x;
    |  float r39 = r38.x;
    |  float r40 = r37-r39;
    |  float r41 = r0.y;
    |  float r42 = r38.y;
    |  float r43 = r41-r42;
    |  float r44 = r0.z;
    |  float r45 = r38.z;
    |  float r46 = r44-r45;
    |  float r47 = r0.w;
    |  vec3 r48 = vec3(r40,r43,r46);
    |  float r49 = length(r48);
    |  float r50 = r49-r19;
    |  float r51 = min(r36,r50);
    |  float r52 = r0.x;
    |  float r54 = r53.x;
    |  float r55 = r52-r54;
    |  float r56 = r0.y;
    |  float r57 = r53.y;
    |  float r58 = r56-r57;
    |  float r59 = r0.z;
    |  float r60 = r53.z;
    |  float r61 = r59-r60;
    |  float r62 = r0.w;
    |  vec3 r63 = vec3(r55,r58,r61);
    |  float r64 = length(r63);
    |  float r65 = r64-r19;
    |  float r66 = min(r51,r65);
    |  float r67 = r0.x;
    |  float r69 = r68.x;
    |  float r70 = r67-r69;
    |  float r71 = r0.y;
    |  float r72 = r68.y;
    |  float r73 = r71-r72;
    |  float r74 = r0.z;
    |  float r75 = r68.z;
    |  float r76 = r74-r75;
    |  float r77 = r0.w;
    |  vec2 r78 = vec2(r70,r73);
    |  float r79 = length(r78);
    |  vec2 r80 = vec2(r79,r76);
    |  vec2 r82 = vec2(r24,r81);
    |  vec2 r83 = r80-r82;
    |  vec2 r84 = vec2(r81,r19);
    |  float r85 = length(r84);
    |  vec2 r86 = vec2(r85);
    |  vec2 r87 = r84/r86;
    |  float r88 = dot(r83,r87);
    |  float r89 = r87.y;
    |  float r90 = r87.x;
    |  float r91 = -(r90);
    |  vec2 r92 = vec2(r89,r91);
    |  float r93 = dot(r83,r92);
    |  float r94 = r80.y;
    |  float r95 = -(r94);
    |  float r96 = max(r88,r95);
    |  float r97=r96;
    |  float r98 = r80.y;
    |  bool r99 = r98>r81;
    |  bool r100 = r93<r24;
    |  bool r101 =(r99 && r100);
    |  if (r101) {
    |  float r102 = length(r83);
    |  float r103 = max(r97,r102);
    |  r97=r103;
    |  }
    |  float r104 = r80.x;
    |  bool r105 = r104>r19;
    |  vec2 r106 = vec2(r81,r19);
    |  float r107 = length(r106);
    |  bool r108 = r93>r107;
    |  bool r109 =(r105 && r108);
    |  if (r109) {
    |  vec2 r110 = vec2(r19,r24);
    |  vec2 r111 = r80-r110;
    |  float r112 = length(r111);
    |  float r113 = max(r97,r112);
    |  r97=r113;
    |  }
    |  bool r114 =(r66 == r1);
    |  float r115 = r97-r66;
    |  float r116 = r19*r115;
    |  float r117 = r116/r17;
    |  float r118 = r19+r117;
    |  float r119 = max(r118,r24);
    |  float r120 = min(r119,r25);
    |  float r121 = r25-r120;
    |  float r122 = r97*r121;
    |  float r123 = r66*r120;
    |  float r124 = r122+r123;
    |  float r125 = r17*r120;
    |  float r126 = r25-r120;
    |  float r127 = r125*r126;
    |  float r128 = r124-r127;
    |  float r129 =(r114 ? r97 : r128);
    |  float r130 = r0.x;
    |  float r132 = r131.x;
    |  float r133 = r130-r132;
    |  float r134 = r0.y;
    |  float r135 = r131.y;
    |  float r136 = r134-r135;
    |  float r137 = r0.z;
    |  float r138 = r131.z;
    |  float r139 = r137-r138;
    |  float r140 = r0.w;
    |  vec3 r141 = vec3(r133,r136,r139);
    |  float r142 = length(r141);
    |  float r144 = r142-r143;
    |  bool r145 =(r129 == r1);
    |  float r146 = r144-r129;
    |  float r147 = r19*r146;
    |  float r148 = r147/r17;
    |  float r149 = r19+r148;
    |  float r150 = max(r149,r24);
    |  float r151 = min(r150,r25);
    |  float r152 = r25-r151;
    |  float r153 = r144*r152;
    |  float r154 = r129*r151;
    |  float r155 = r153+r154;
    |  float r156 = r17*r151;
    |  float r157 = r25-r151;
    |  float r158 = r156*r157;
    |  float r159 = r155-r158;
    |  float r160 =(r145 ? r144 : r159);
    |  float r161 = r0.x;
    |  float r163 = r162.x;
    |  float r164 = r161-r163;
    |  float r165 = r0.y;
    |  float r166 = r162.y;
    |  float r167 = r165-r166;
    |  float r168 = r0.z;
    |  float r169 = r162.z;
    |  float r170 = r168-r169;
    |  float r171 = r0.w;
    |  vec3 r172 = vec3(r164,r167,r170);
    |  float r173 = length(r172);
    |  float r174 = r173-r19;
    |  float r175 = min(r160,r174);
    |  float r176 = r0.x;
    |  float r178 = r177.x;
    |  float r179 = r176-r178;
    |  float r180 = r0.y;
    |  float r181 = r177.y;
    |  float r182 = r180-r181;
    |  float r183 = r0.z;
    |  float r184 = r177.z;
    |  float r185 = r183-r184;
    |  float r186 = r0.w;
    |  vec3 r187 = vec3(r179,r182,r185);
    |  float r188 = length(r187);
    |  float r189 = r188-r19;
    |  float r190 = min(r175,r189);
    |  float r191 = r0.x;
    |  float r193 = r192.x;
    |  float r194 = r191-r193;
    |  float r195 = r0.y;
    |  float r196 = r192.y;
    |  float r197 = r195-r196;
    |  float r198 = r0.z;
    |  float r199 = r192.z;
    |  float r200 = r198-r199;
    |  float r201 = r0.w;
    |  vec3 r202 = vec3(r194,r197,r200);
    |  float r203 = length(r202);
    |  float r204 = r203-r19;
    |  float r205 = min(r190,r204);
    |  float r206 = r0.x;
    |  float r208 = r207.x;
    |  float r209 = r206-r208;
    |  float r210 = r0.y;
    |  float r211 = r207.y;
    |  float r212 = r210-r211;
    |  float r213 = r0.z;
    |  float r214 = r207.z;
    |  float r215 = r213-r214;
    |  float r216 = r0.w;
    |  vec3 r219 = vec3(r209,r212,r215);
    |  float r220 = cos(r217);
    |  vec3 r221 = vec3(r220);
    |  vec3 r222 = r219*r221;
    |  float r223 = r218.y;
    |  float r224 = r219.z;
    |  float r225 = r223*r224;
    |  float r226 = r218.z;
    |  float r227 = r219.y;
    |  float r228 = r226*r227;
    |  float r229 = r225-r228;
    |  float r230 = r218.z;
    |  float r231 = r219.x;
    |  float r232 = r230*r231;
    |  float r233 = r218.x;
    |  float r234 = r219.z;
    |  float r235 = r233*r234;
    |  float r236 = r232-r235;
    |  float r237 = r218.x;
    |  float r238 = r219.y;
    |  float r239 = r237*r238;
    |  float r240 = r218.y;
    |  float r241 = r219.x;
    |  float r242 = r240*r241;
    |  float r243 = r239-r242;
    |  vec3 r244 = vec3(r229,r236,r243);
    |  float r245 = sin(r217);
    |  vec3 r246 = vec3(r245);
    |  vec3 r247 = r244*r246;
    |  vec3 r248 = r222-r247;
    |  float r249 = cos(r217);
    |  float r250 = r25-r249;
    |  vec3 r251 = vec3(r250);
    |  vec3 r252 = r219*r251;
    |  float r253 = dot(r218,r252);
    |  vec3 r254 = vec3(r253);
    |  vec3 r255 = r218*r254;
    |  vec3 r256 = r248+r255;
    |  float r257 = r256.x;
    |  float r258 = r256.y;
    |  float r259 = r256.z;
    |  vec2 r260 = vec2(r257,r258);
    |  float r261 = length(r260);
    |  vec2 r262 = vec2(r261,r259);
    |  vec2 r263 = vec2(r24,r143);
    |  vec2 r264 = r262-r263;
    |  vec2 r266 = vec2(r143,r265);
    |  float r267 = length(r266);
    |  vec2 r268 = vec2(r267);
    |  vec2 r269 = r266/r268;
    |  float r270 = dot(r264,r269);
    |  float r271 = r269.y;
    |  float r272 = r269.x;
    |  float r273 = -(r272);
    |  vec2 r274 = vec2(r271,r273);
    |  float r275 = dot(r264,r274);
    |  float r276 = r262.y;
    |  float r277 = -(r276);
    |  float r278 = max(r270,r277);
    |  float r279=r278;
    |  float r280 = r262.y;
    |  bool r281 = r280>r143;
    |  bool r282 = r275<r24;
    |  bool r283 =(r281 && r282);
    |  if (r283) {
    |  float r284 = length(r264);
    |  float r285 = max(r279,r284);
    |  r279=r285;
    |  }
    |  float r286 = r262.x;
    |  bool r287 = r286>r265;
    |  vec2 r288 = vec2(r143,r265);
    |  float r289 = length(r288);
    |  bool r290 = r275>r289;
    |  bool r291 =(r287 && r290);
    |  if (r291) {
    |  vec2 r292 = vec2(r265,r24);
    |  vec2 r293 = r262-r292;
    |  float r294 = length(r293);
    |  float r295 = max(r279,r294);
    |  r279=r295;
    |  }
    |  bool r296 =(r205 == r1);
    |  float r297 = r279-r205;
    |  float r298 = r19*r297;
    |  float r299 = r298/r17;
    |  float r300 = r19+r299;
    |  float r301 = max(r300,r24);
    |  float r302 = min(r301,r25);
    |  float r303 = r25-r302;
    |  float r304 = r279*r303;
    |  float r305 = r205*r302;
    |  float r306 = r304+r305;
    |  float r307 = r17*r302;
    |  float r308 = r25-r302;
    |  float r309 = r307*r308;
    |  float r310 = r306-r309;
    |  float r311 =(r296 ? r279 : r310);
    |  float r312 = r0.x;
    |  float r314 = r313.x;
    |  float r315 = r312-r314;
    |  float r316 = r0.y;
    |  float r317 = r313.y;
    |  float r318 = r316-r317;
    |  float r319 = r0.z;
    |  float r320 = r313.z;
    |  float r321 = r319-r320;
    |  float r322 = r0.w;
    |  vec3 r325 = vec3(r315,r318,r321);
    |  float r326 = cos(r323);
    |  vec3 r327 = vec3(r326);
    |  vec3 r328 = r325*r327;
    |  float r329 = r324.y;
    |  float r330 = r325.z;
    |  float r331 = r329*r330;
    |  float r332 = r324.z;
    |  float r333 = r325.y;
    |  float r334 = r332*r333;
    |  float r335 = r331-r334;
    |  float r336 = r324.z;
    |  float r337 = r325.x;
    |  float r338 = r336*r337;
    |  float r339 = r324.x;
    |  float r340 = r325.z;
    |  float r341 = r339*r340;
    |  float r342 = r338-r341;
    |  float r343 = r324.x;
    |  float r344 = r325.y;
    |  float r345 = r343*r344;
    |  float r346 = r324.y;
    |  float r347 = r325.x;
    |  float r348 = r346*r347;
    |  float r349 = r345-r348;
    |  vec3 r350 = vec3(r335,r342,r349);
    |  float r351 = sin(r323);
    |  vec3 r352 = vec3(r351);
    |  vec3 r353 = r350*r352;
    |  vec3 r354 = r328-r353;
    |  float r355 = cos(r323);
    |  float r356 = r25-r355;
    |  vec3 r357 = vec3(r356);
    |  vec3 r358 = r325*r357;
    |  float r359 = dot(r324,r358);
    |  vec3 r360 = vec3(r359);
    |  vec3 r361 = r324*r360;
    |  vec3 r362 = r354+r361;
    |  float r363 = r362.x;
    |  float r364 = r362.y;
    |  float r365 = r362.z;
    |  vec2 r366 = vec2(r363,r364);
    |  float r367 = length(r366);
    |  vec2 r368 = vec2(r367,r365);
    |  vec2 r369 = vec2(r24,r143);
    |  vec2 r370 = r368-r369;
    |  vec2 r371 = vec2(r143,r265);
    |  float r372 = length(r371);
    |  vec2 r373 = vec2(r372);
    |  vec2 r374 = r371/r373;
    |  float r375 = dot(r370,r374);
    |  float r376 = r374.y;
    |  float r377 = r374.x;
    |  float r378 = -(r377);
    |  vec2 r379 = vec2(r376,r378);
    |  float r380 = dot(r370,r379);
    |  float r381 = r368.y;
    |  float r382 = -(r381);
    |  float r383 = max(r375,r382);
    |  float r384=r383;
    |  float r385 = r368.y;
    |  bool r386 = r385>r143;
    |  bool r387 = r380<r24;
    |  bool r388 =(r386 && r387);
    |  if (r388) {
    |  float r389 = length(r370);
    |  float r390 = max(r384,r389);
    |  r384=r390;
    |  }
    |  float r391 = r368.x;
    |  bool r392 = r391>r265;
    |  vec2 r393 = vec2(r143,r265);
    |  float r394 = length(r393);
    |  bool r395 = r380>r394;
    |  bool r396 =(r392 && r395);
    |  if (r396) {
    |  vec2 r397 = vec2(r265,r24);
    |  vec2 r398 = r368-r397;
    |  float r399 = length(r398);
    |  float r400 = max(r384,r399);
    |  r384=r400;
    |  }
    |  bool r401 =(r311 == r1);
    |  float r402 = r384-r311;
    |  float r403 = r19*r402;
    |  float r404 = r403/r17;
    |  float r405 = r19+r404;
    |  float r406 = max(r405,r24);
    |  float r407 = min(r406,r25);
    |  float r408 = r25-r407;
    |  float r409 = r384*r408;
    |  float r410 = r311*r407;
    |  float r411 = r409+r410;
    |  float r412 = r17*r407;
    |  float r413 = r25-r407;
    |  float r414 = r412*r413;
    |  float r415 = r411-r414;
    |  float r416 =(r401 ? r384 : r415);
    |  float r417 = r0.x;
    |  float r419 = r418.x;
    |  float r420 = r417-r419;
    |  float r421 = r0.y;
    |  float r422 = r418.y;
    |  float r423 = r421-r422;
    |  float r424 = r0.z;
    |  float r425 = r418.z;
    |  float r426 = r424-r425;
    |  float r427 = r0.w;
    |  vec3 r428 = vec3(r420,r423,r426);
    |  float r429 = length(r428);
    |  float r431 = r429-r430;
    |  bool r432 =(r416 == r1);
    |  float r433 = r431-r416;
    |  float r434 = r19*r433;
    |  float r435 = r434/r17;
    |  float r436 = r19+r435;
    |  float r437 = max(r436,r24);
    |  float r438 = min(r437,r25);
    |  float r439 = r25-r438;
    |  float r440 = r431*r439;
    |  float r441 = r416*r438;
    |  float r442 = r440+r441;
    |  float r443 = r17*r438;
    |  float r444 = r25-r438;
    |  float r445 = r443*r444;
    |  float r446 = r442-r445;
    |  float r447 =(r432 ? r431 : r446);
    |  return r447;
    |}
    |vec3 colour(vec4 r0)
    |{
    |  /* constants */
    |  float r1 = 1.0/0.0;
    |  vec3 r3 = vec3(0.0,0.0,0.0);
    |  float r15 = 5.0;
    |  float r17 = rv_smoothness;
    |  float r19 = 0.5;
    |  float r24 = 0.0;
    |  float r25 = 1.0;
    |  vec3 r38 = vec3(-1.0,-2.0,4.5);
    |  vec3 r53 = vec3(1.0,-2.0,4.5);
    |  vec3 r68 = vec3(0.0,0.0,4.5);
    |  float r81 = 4.0;
    |  vec3 r131 = vec3(0.0,12.0,0.0);
    |  float r143 = 10.0;
    |  vec3 r162 = vec3(0.0,12.0,9.8);
    |  vec3 r177 = vec3(0.0,10.0,9.6);
    |  vec3 r192 = vec3(0.0,8.0,9.0);
    |  vec3 r207 = vec3(-10.0,12.0,0.0);
    |  float r217 = -1.5707963267948966;
    |  vec3 r218 = vec3(0.0,1.0,0.0);
    |  float r265 = 1.5;
    |  vec3 r313 = vec3(10.0,12.0,0.0);
    |  float r323 = 1.5707963267948966;
    |  vec3 r324 = vec3(0.0,1.0,0.0);
    |  vec3 r418 = vec3(0.0,32.0,0.0);
    |  float r430 = 15.0;
    |  float r446 = 0.8;
    |  vec3 r447 = vec3(r446,r446,r19);
    |  float r448 = 2.2;
    |  vec3 r449 = vec3(r448);
    |  vec3 r450 = pow(r447,r449);
    |  /* body */
    |  float r2 = r0.x;
    |  float r4 = r3.x;
    |  float r5 = r2-r4;
    |  float r6 = r0.y;
    |  float r7 = r3.y;
    |  float r8 = r6-r7;
    |  float r9 = r0.z;
    |  float r10 = r3.z;
    |  float r11 = r9-r10;
    |  float r12 = r0.w;
    |  vec3 r13 = vec3(r5,r8,r11);
    |  float r14 = length(r13);
    |  float r16 = r14-r15;
    |  bool r18 =(r1 == r1);
    |  float r20 = r16-r1;
    |  float r21 = r19*r20;
    |  float r22 = r21/r17;
    |  float r23 = r19+r22;
    |  float r26 = max(r23,r24);
    |  float r27 = min(r26,r25);
    |  float r28 = r25-r27;
    |  float r29 = r16*r28;
    |  float r30 = r1*r27;
    |  float r31 = r29+r30;
    |  float r32 = r17*r27;
    |  float r33 = r25-r27;
    |  float r34 = r32*r33;
    |  float r35 = r31-r34;
    |  float r36 =(r18 ? r16 : r35);
    |  float r37 = r0.x;
    |  float r39 = r38.x;
    |  float r40 = r37-r39;
    |  float r41 = r0.y;
    |  float r42 = r38.y;
    |  float r43 = r41-r42;
    |  float r44 = r0.z;
    |  float r45 = r38.z;
    |  float r46 = r44-r45;
    |  float r47 = r0.w;
    |  vec3 r48 = vec3(r40,r43,r46);
    |  float r49 = length(r48);
    |  float r50 = r49-r19;
    |  float r51 = min(r36,r50);
    |  float r52 = r0.x;
    |  float r54 = r53.x;
    |  float r55 = r52-r54;
    |  float r56 = r0.y;
    |  float r57 = r53.y;
    |  float r58 = r56-r57;
    |  float r59 = r0.z;
    |  float r60 = r53.z;
    |  float r61 = r59-r60;
    |  float r62 = r0.w;
    |  vec3 r63 = vec3(r55,r58,r61);
    |  float r64 = length(r63);
    |  float r65 = r64-r19;
    |  float r66 = min(r51,r65);
    |  float r67 = r0.x;
    |  float r69 = r68.x;
    |  float r70 = r67-r69;
    |  float r71 = r0.y;
    |  float r72 = r68.y;
    |  float r73 = r71-r72;
    |  float r74 = r0.z;
    |  float r75 = r68.z;
    |  float r76 = r74-r75;
    |  float r77 = r0.w;
    |  vec2 r78 = vec2(r70,r73);
    |  float r79 = length(r78);
    |  vec2 r80 = vec2(r79,r76);
    |  vec2 r82 = vec2(r24,r81);
    |  vec2 r83 = r80-r82;
    |  vec2 r84 = vec2(r81,r19);
    |  float r85 = length(r84);
    |  vec2 r86 = vec2(r85);
    |  vec2 r87 = r84/r86;
    |  float r88 = dot(r83,r87);
    |  float r89 = r87.y;
    |  float r90 = r87.x;
    |  float r91 = -(r90);
    |  vec2 r92 = vec2(r89,r91);
    |  float r93 = dot(r83,r92);
    |  float r94 = r80.y;
    |  float r95 = -(r94);
    |  float r96 = max(r88,r95);
    |  float r97=r96;
    |  float r98 = r80.y;
    |  bool r99 = r98>r81;
    |  bool r100 = r93<r24;
    |  bool r101 =(r99 && r100);
    |  if (r101) {
    |  float r102 = length(r83);
    |  float r103 = max(r97,r102);
    |  r97=r103;
    |  }
    |  float r104 = r80.x;
    |  bool r105 = r104>r19;
    |  vec2 r106 = vec2(r81,r19);
    |  float r107 = length(r106);
    |  bool r108 = r93>r107;
    |  bool r109 =(r105 && r108);
    |  if (r109) {
    |  vec2 r110 = vec2(r19,r24);
    |  vec2 r111 = r80-r110;
    |  float r112 = length(r111);
    |  float r113 = max(r97,r112);
    |  r97=r113;
    |  }
    |  bool r114 =(r66 == r1);
    |  float r115 = r97-r66;
    |  float r116 = r19*r115;
    |  float r117 = r116/r17;
    |  float r118 = r19+r117;
    |  float r119 = max(r118,r24);
    |  float r120 = min(r119,r25);
    |  float r121 = r25-r120;
    |  float r122 = r97*r121;
    |  float r123 = r66*r120;
    |  float r124 = r122+r123;
    |  float r125 = r17*r120;
    |  float r126 = r25-r120;
    |  float r127 = r125*r126;
    |  float r128 = r124-r127;
    |  float r129 =(r114 ? r97 : r128);
    |  float r130 = r0.x;
    |  float r132 = r131.x;
    |  float r133 = r130-r132;
    |  float r134 = r0.y;
    |  float r135 = r131.y;
    |  float r136 = r134-r135;
    |  float r137 = r0.z;
    |  float r138 = r131.z;
    |  float r139 = r137-r138;
    |  float r140 = r0.w;
    |  vec3 r141 = vec3(r133,r136,r139);
    |  float r142 = length(r141);
    |  float r144 = r142-r143;
    |  bool r145 =(r129 == r1);
    |  float r146 = r144-r129;
    |  float r147 = r19*r146;
    |  float r148 = r147/r17;
    |  float r149 = r19+r148;
    |  float r150 = max(r149,r24);
    |  float r151 = min(r150,r25);
    |  float r152 = r25-r151;
    |  float r153 = r144*r152;
    |  float r154 = r129*r151;
    |  float r155 = r153+r154;
    |  float r156 = r17*r151;
    |  float r157 = r25-r151;
    |  float r158 = r156*r157;
    |  float r159 = r155-r158;
    |  float r160 =(r145 ? r144 : r159);
    |  float r161 = r0.x;
    |  float r163 = r162.x;
    |  float r164 = r161-r163;
    |  float r165 = r0.y;
    |  float r166 = r162.y;
    |  float r167 = r165-r166;
    |  float r168 = r0.z;
    |  float r169 = r162.z;
    |  float r170 = r168-r169;
    |  float r171 = r0.w;
    |  vec3 r172 = vec3(r164,r167,r170);
    |  float r173 = length(r172);
    |  float r174 = r173-r19;
    |  float r175 = min(r160,r174);
    |  float r176 = r0.x;
    |  float r178 = r177.x;
    |  float r179 = r176-r178;
    |  float r180 = r0.y;
    |  float r181 = r177.y;
    |  float r182 = r180-r181;
    |  float r183 = r0.z;
    |  float r184 = r177.z;
    |  float r185 = r183-r184;
    |  float r186 = r0.w;
    |  vec3 r187 = vec3(r179,r182,r185);
    |  float r188 = length(r187);
    |  float r189 = r188-r19;
    |  float r190 = min(r175,r189);
    |  float r191 = r0.x;
    |  float r193 = r192.x;
    |  float r194 = r191-r193;
    |  float r195 = r0.y;
    |  float r196 = r192.y;
    |  float r197 = r195-r196;
    |  float r198 = r0.z;
    |  float r199 = r192.z;
    |  float r200 = r198-r199;
    |  float r201 = r0.w;
    |  vec3 r202 = vec3(r194,r197,r200);
    |  float r203 = length(r202);
    |  float r204 = r203-r19;
    |  float r205 = min(r190,r204);
    |  float r206 = r0.x;
    |  float r208 = r207.x;
    |  float r209 = r206-r208;
    |  float r210 = r0.y;
    |  float r211 = r207.y;
    |  float r212 = r210-r211;
    |  float r213 = r0.z;
    |  float r214 = r207.z;
    |  float r215 = r213-r214;
    |  float r216 = r0.w;
    |  vec3 r219 = vec3(r209,r212,r215);
    |  float r220 = cos(r217);
    |  vec3 r221 = vec3(r220);
    |  vec3 r222 = r219*r221;
    |  float r223 = r218.y;
    |  float r224 = r219.z;
    |  float r225 = r223*r224;
    |  float r226 = r218.z;
    |  float r227 = r219.y;
    |  float r228 = r226*r227;
    |  float r229 = r225-r228;
    |  float r230 = r218.z;
    |  float r231 = r219.x;
    |  float r232 = r230*r231;
    |  float r233 = r218.x;
    |  float r234 = r219.z;
    |  float r235 = r233*r234;
    |  float r236 = r232-r235;
    |  float r237 = r218.x;
    |  float r238 = r219.y;
    |  float r239 = r237*r238;
    |  float r240 = r218.y;
    |  float r241 = r219.x;
    |  float r242 = r240*r241;
    |  float r243 = r239-r242;
    |  vec3 r244 = vec3(r229,r236,r243);
    |  float r245 = sin(r217);
    |  vec3 r246 = vec3(r245);
    |  vec3 r247 = r244*r246;
    |  vec3 r248 = r222-r247;
    |  float r249 = cos(r217);
    |  float r250 = r25-r249;
    |  vec3 r251 = vec3(r250);
    |  vec3 r252 = r219*r251;
    |  float r253 = dot(r218,r252);
    |  vec3 r254 = vec3(r253);
    |  vec3 r255 = r218*r254;
    |  vec3 r256 = r248+r255;
    |  float r257 = r256.x;
    |  float r258 = r256.y;
    |  float r259 = r256.z;
    |  vec2 r260 = vec2(r257,r258);
    |  float r261 = length(r260);
    |  vec2 r262 = vec2(r261,r259);
    |  vec2 r263 = vec2(r24,r143);
    |  vec2 r264 = r262-r263;
    |  vec2 r266 = vec2(r143,r265);
    |  float r267 = length(r266);
    |  vec2 r268 = vec2(r267);
    |  vec2 r269 = r266/r268;
    |  float r270 = dot(r264,r269);
    |  float r271 = r269.y;
    |  float r272 = r269.x;
    |  float r273 = -(r272);
    |  vec2 r274 = vec2(r271,r273);
    |  float r275 = dot(r264,r274);
    |  float r276 = r262.y;
    |  float r277 = -(r276);
    |  float r278 = max(r270,r277);
    |  float r279=r278;
    |  float r280 = r262.y;
    |  bool r281 = r280>r143;
    |  bool r282 = r275<r24;
    |  bool r283 =(r281 && r282);
    |  if (r283) {
    |  float r284 = length(r264);
    |  float r285 = max(r279,r284);
    |  r279=r285;
    |  }
    |  float r286 = r262.x;
    |  bool r287 = r286>r265;
    |  vec2 r288 = vec2(r143,r265);
    |  float r289 = length(r288);
    |  bool r290 = r275>r289;
    |  bool r291 =(r287 && r290);
    |  if (r291) {
    |  vec2 r292 = vec2(r265,r24);
    |  vec2 r293 = r262-r292;
    |  float r294 = length(r293);
    |  float r295 = max(r279,r294);
    |  r279=r295;
    |  }
    |  bool r296 =(r205 == r1);
    |  float r297 = r279-r205;
    |  float r298 = r19*r297;
    |  float r299 = r298/r17;
    |  float r300 = r19+r299;
    |  float r301 = max(r300,r24);
    |  float r302 = min(r301,r25);
    |  float r303 = r25-r302;
    |  float r304 = r279*r303;
    |  float r305 = r205*r302;
    |  float r306 = r304+r305;
    |  float r307 = r17*r302;
    |  float r308 = r25-r302;
    |  float r309 = r307*r308;
    |  float r310 = r306-r309;
    |  float r311 =(r296 ? r279 : r310);
    |  float r312 = r0.x;
    |  float r314 = r313.x;
    |  float r315 = r312-r314;
    |  float r316 = r0.y;
    |  float r317 = r313.y;
    |  float r318 = r316-r317;
    |  float r319 = r0.z;
    |  float r320 = r313.z;
    |  float r321 = r319-r320;
    |  float r322 = r0.w;
    |  vec3 r325 = vec3(r315,r318,r321);
    |  float r326 = cos(r323);
    |  vec3 r327 = vec3(r326);
    |  vec3 r328 = r325*r327;
    |  float r329 = r324.y;
    |  float r330 = r325.z;
    |  float r331 = r329*r330;
    |  float r332 = r324.z;
    |  float r333 = r325.y;
    |  float r334 = r332*r333;
    |  float r335 = r331-r334;
    |  float r336 = r324.z;
    |  float r337 = r325.x;
    |  float r338 = r336*r337;
    |  float r339 = r324.x;
    |  float r340 = r325.z;
    |  float r341 = r339*r340;
    |  float r342 = r338-r341;
    |  float r343 = r324.x;
    |  float r344 = r325.y;
    |  float r345 = r343*r344;
    |  float r346 = r324.y;
    |  float r347 = r325.x;
    |  float r348 = r346*r347;
    |  float r349 = r345-r348;
    |  vec3 r350 = vec3(r335,r342,r349);
    |  float r351 = sin(r323);
    |  vec3 r352 = vec3(r351);
    |  vec3 r353 = r350*r352;
    |  vec3 r354 = r328-r353;
    |  float r355 = cos(r323);
    |  float r356 = r25-r355;
    |  vec3 r357 = vec3(r356);
    |  vec3 r358 = r325*r357;
    |  float r359 = dot(r324,r358);
    |  vec3 r360 = vec3(r359);
    |  vec3 r361 = r324*r360;
    |  vec3 r362 = r354+r361;
    |  float r363 = r362.x;
    |  float r364 = r362.y;
    |  float r365 = r362.z;
    |  vec2 r366 = vec2(r363,r364);
    |  float r367 = length(r366);
    |  vec2 r368 = vec2(r367,r365);
    |  vec2 r369 = vec2(r24,r143);
    |  vec2 r370 = r368-r369;
    |  vec2 r371 = vec2(r143,r265);
    |  float r372 = length(r371);
    |  vec2 r373 = vec2(r372);
    |  vec2 r374 = r371/r373;
    |  float r375 = dot(r370,r374);
    |  float r376 = r374.y;
    |  float r377 = r374.x;
    |  float r378 = -(r377);
    |  vec2 r379 = vec2(r376,r378);
    |  float r380 = dot(r370,r379);
    |  float r381 = r368.y;
    |  float r382 = -(r381);
    |  float r383 = max(r375,r382);
    |  float r384=r383;
    |  float r385 = r368.y;
    |  bool r386 = r385>r143;
    |  bool r387 = r380<r24;
    |  bool r388 =(r386 && r387);
    |  if (r388) {
    |  float r389 = length(r370);
    |  float r390 = max(r384,r389);
    |  r384=r390;
    |  }
    |  float r391 = r368.x;
    |  bool r392 = r391>r265;
    |  vec2 r393 = vec2(r143,r265);
    |  float r394 = length(r393);
    |  bool r395 = r380>r394;
    |  bool r396 =(r392 && r395);
    |  if (r396) {
    |  vec2 r397 = vec2(r265,r24);
    |  vec2 r398 = r368-r397;
    |  float r399 = length(r398);
    |  float r400 = max(r384,r399);
    |  r384=r400;
    |  }
    |  bool r401 =(r311 == r1);
    |  float r402 = r384-r311;
    |  float r403 = r19*r402;
    |  float r404 = r403/r17;
    |  float r405 = r19+r404;
    |  float r406 = max(r405,r24);
    |  float r407 = min(r406,r25);
    |  float r408 = r25-r407;
    |  float r409 = r384*r408;
    |  float r410 = r311*r407;
    |  float r411 = r409+r410;
    |  float r412 = r17*r407;
    |  float r413 = r25-r407;
    |  float r414 = r412*r413;
    |  float r415 = r411-r414;
    |  float r416 =(r401 ? r384 : r415);
    |  float r417 = r0.x;
    |  float r419 = r418.x;
    |  float r420 = r417-r419;
    |  float r421 = r0.y;
    |  float r422 = r418.y;
    |  float r423 = r421-r422;
    |  float r424 = r0.z;
    |  float r425 = r418.z;
    |  float r426 = r424-r425;
    |  float r427 = r0.w;
    |  vec3 r428 = vec3(r420,r423,r426);
    |  float r429 = length(r428);
    |  float r431 = r429-r430;
    |  bool r432 = r431<=r24;
    |  bool r433 = r431<=r416;
    |  bool r434 =(r432 || r433);
    |  float r435 = r0.x;
    |  float r436 = r418.x;
    |  float r437 = r435-r436;
    |  float r438 = r0.y;
    |  float r439 = r418.y;
    |  float r440 = r438-r439;
    |  float r441 = r0.z;
    |  float r442 = r418.z;
    |  float r443 = r441-r442;
    |  float r444 = r0.w;
    |  vec4 r445 = vec4(r437,r440,r443,r444);
    |  float r451 = r0.x;
    |  float r452 = r3.x;
    |  float r453 = r451-r452;
    |  float r454 = r0.y;
    |  float r455 = r3.y;
    |  float r456 = r454-r455;
    |  float r457 = r0.z;
    |  float r458 = r3.z;
    |  float r459 = r457-r458;
    |  float r460 = r0.w;
    |  vec3 r461 = vec3(r453,r456,r459);
    |  float r462 = length(r461);
    |  float r463 = r462-r15;
    |  bool r464 =(r1 == r1);
    |  float r465 = r463-r1;
    |  float r466 = r19*r465;
    |  float r467 = r466/r17;
    |  float r468 = r19+r467;
    |  float r469 = max(r468,r24);
    |  float r470 = min(r469,r25);
    |  float r471 = r25-r470;
    |  float r472 = r463*r471;
    |  float r473 = r1*r470;
    |  float r474 = r472+r473;
    |  float r475 = r17*r470;
    |  float r476 = r25-r470;
    |  float r477 = r475*r476;
    |  float r478 = r474-r477;
    |  float r479 =(r464 ? r463 : r478);
    |  float r480 = r0.x;
    |  float r481 = r38.x;
    |  float r482 = r480-r481;
    |  float r483 = r0.y;
    |  float r484 = r38.y;
    |  float r485 = r483-r484;
    |  float r486 = r0.z;
    |  float r487 = r38.z;
    |  float r488 = r486-r487;
    |  float r489 = r0.w;
    |  vec3 r490 = vec3(r482,r485,r488);
    |  float r491 = length(r490);
    |  float r492 = r491-r19;
    |  float r493 = min(r479,r492);
    |  float r494 = r0.x;
    |  float r495 = r53.x;
    |  float r496 = r494-r495;
    |  float r497 = r0.y;
    |  float r498 = r53.y;
    |  float r499 = r497-r498;
    |  float r500 = r0.z;
    |  float r501 = r53.z;
    |  float r502 = r500-r501;
    |  float r503 = r0.w;
    |  vec3 r504 = vec3(r496,r499,r502);
    |  float r505 = length(r504);
    |  float r506 = r505-r19;
    |  float r507 = min(r493,r506);
    |  float r508 = r0.x;
    |  float r509 = r68.x;
    |  float r510 = r508-r509;
    |  float r511 = r0.y;
    |  float r512 = r68.y;
    |  float r513 = r511-r512;
    |  float r514 = r0.z;
    |  float r515 = r68.z;
    |  float r516 = r514-r515;
    |  float r517 = r0.w;
    |  vec2 r518 = vec2(r510,r513);
    |  float r519 = length(r518);
    |  vec2 r520 = vec2(r519,r516);
    |  vec2 r521 = vec2(r24,r81);
    |  vec2 r522 = r520-r521;
    |  vec2 r523 = vec2(r81,r19);
    |  float r524 = length(r523);
    |  vec2 r525 = vec2(r524);
    |  vec2 r526 = r523/r525;
    |  float r527 = dot(r522,r526);
    |  float r528 = r526.y;
    |  float r529 = r526.x;
    |  float r530 = -(r529);
    |  vec2 r531 = vec2(r528,r530);
    |  float r532 = dot(r522,r531);
    |  float r533 = r520.y;
    |  float r534 = -(r533);
    |  float r535 = max(r527,r534);
    |  float r536=r535;
    |  float r537 = r520.y;
    |  bool r538 = r537>r81;
    |  bool r539 = r532<r24;
    |  bool r540 =(r538 && r539);
    |  if (r540) {
    |  float r541 = length(r522);
    |  float r542 = max(r536,r541);
    |  r536=r542;
    |  }
    |  float r543 = r520.x;
    |  bool r544 = r543>r19;
    |  vec2 r545 = vec2(r81,r19);
    |  float r546 = length(r545);
    |  bool r547 = r532>r546;
    |  bool r548 =(r544 && r547);
    |  if (r548) {
    |  vec2 r549 = vec2(r19,r24);
    |  vec2 r550 = r520-r549;
    |  float r551 = length(r550);
    |  float r552 = max(r536,r551);
    |  r536=r552;
    |  }
    |  bool r553 =(r507 == r1);
    |  float r554 = r536-r507;
    |  float r555 = r19*r554;
    |  float r556 = r555/r17;
    |  float r557 = r19+r556;
    |  float r558 = max(r557,r24);
    |  float r559 = min(r558,r25);
    |  float r560 = r25-r559;
    |  float r561 = r536*r560;
    |  float r562 = r507*r559;
    |  float r563 = r561+r562;
    |  float r564 = r17*r559;
    |  float r565 = r25-r559;
    |  float r566 = r564*r565;
    |  float r567 = r563-r566;
    |  float r568 =(r553 ? r536 : r567);
    |  float r569 = r0.x;
    |  float r570 = r131.x;
    |  float r571 = r569-r570;
    |  float r572 = r0.y;
    |  float r573 = r131.y;
    |  float r574 = r572-r573;
    |  float r575 = r0.z;
    |  float r576 = r131.z;
    |  float r577 = r575-r576;
    |  float r578 = r0.w;
    |  vec3 r579 = vec3(r571,r574,r577);
    |  float r580 = length(r579);
    |  float r581 = r580-r143;
    |  bool r582 =(r568 == r1);
    |  float r583 = r581-r568;
    |  float r584 = r19*r583;
    |  float r585 = r584/r17;
    |  float r586 = r19+r585;
    |  float r587 = max(r586,r24);
    |  float r588 = min(r587,r25);
    |  float r589 = r25-r588;
    |  float r590 = r581*r589;
    |  float r591 = r568*r588;
    |  float r592 = r590+r591;
    |  float r593 = r17*r588;
    |  float r594 = r25-r588;
    |  float r595 = r593*r594;
    |  float r596 = r592-r595;
    |  float r597 =(r582 ? r581 : r596);
    |  float r598 = r0.x;
    |  float r599 = r162.x;
    |  float r600 = r598-r599;
    |  float r601 = r0.y;
    |  float r602 = r162.y;
    |  float r603 = r601-r602;
    |  float r604 = r0.z;
    |  float r605 = r162.z;
    |  float r606 = r604-r605;
    |  float r607 = r0.w;
    |  vec3 r608 = vec3(r600,r603,r606);
    |  float r609 = length(r608);
    |  float r610 = r609-r19;
    |  float r611 = min(r597,r610);
    |  float r612 = r0.x;
    |  float r613 = r177.x;
    |  float r614 = r612-r613;
    |  float r615 = r0.y;
    |  float r616 = r177.y;
    |  float r617 = r615-r616;
    |  float r618 = r0.z;
    |  float r619 = r177.z;
    |  float r620 = r618-r619;
    |  float r621 = r0.w;
    |  vec3 r622 = vec3(r614,r617,r620);
    |  float r623 = length(r622);
    |  float r624 = r623-r19;
    |  float r625 = min(r611,r624);
    |  float r626 = r0.x;
    |  float r627 = r192.x;
    |  float r628 = r626-r627;
    |  float r629 = r0.y;
    |  float r630 = r192.y;
    |  float r631 = r629-r630;
    |  float r632 = r0.z;
    |  float r633 = r192.z;
    |  float r634 = r632-r633;
    |  float r635 = r0.w;
    |  vec3 r636 = vec3(r628,r631,r634);
    |  float r637 = length(r636);
    |  float r638 = r637-r19;
    |  float r639 = min(r625,r638);
    |  float r640 = r0.x;
    |  float r641 = r207.x;
    |  float r642 = r640-r641;
    |  float r643 = r0.y;
    |  float r644 = r207.y;
    |  float r645 = r643-r644;
    |  float r646 = r0.z;
    |  float r647 = r207.z;
    |  float r648 = r646-r647;
    |  float r649 = r0.w;
    |  vec3 r650 = vec3(r642,r645,r648);
    |  float r651 = cos(r217);
    |  vec3 r652 = vec3(r651);
    |  vec3 r653 = r650*r652;
    |  float r654 = r218.y;
    |  float r655 = r650.z;
    |  float r656 = r654*r655;
    |  float r657 = r218.z;
    |  float r658 = r650.y;
    |  float r659 = r657*r658;
    |  float r660 = r656-r659;
    |  float r661 = r218.z;
    |  float r662 = r650.x;
    |  float r663 = r661*r662;
    |  float r664 = r218.x;
    |  float r665 = r650.z;
    |  float r666 = r664*r665;
    |  float r667 = r663-r666;
    |  float r668 = r218.x;
    |  float r669 = r650.y;
    |  float r670 = r668*r669;
    |  float r671 = r218.y;
    |  float r672 = r650.x;
    |  float r673 = r671*r672;
    |  float r674 = r670-r673;
    |  vec3 r675 = vec3(r660,r667,r674);
    |  float r676 = sin(r217);
    |  vec3 r677 = vec3(r676);
    |  vec3 r678 = r675*r677;
    |  vec3 r679 = r653-r678;
    |  float r680 = cos(r217);
    |  float r681 = r25-r680;
    |  vec3 r682 = vec3(r681);
    |  vec3 r683 = r650*r682;
    |  float r684 = dot(r218,r683);
    |  vec3 r685 = vec3(r684);
    |  vec3 r686 = r218*r685;
    |  vec3 r687 = r679+r686;
    |  float r688 = r687.x;
    |  float r689 = r687.y;
    |  float r690 = r687.z;
    |  vec2 r691 = vec2(r688,r689);
    |  float r692 = length(r691);
    |  vec2 r693 = vec2(r692,r690);
    |  vec2 r694 = vec2(r24,r143);
    |  vec2 r695 = r693-r694;
    |  vec2 r696 = vec2(r143,r265);
    |  float r697 = length(r696);
    |  vec2 r698 = vec2(r697);
    |  vec2 r699 = r696/r698;
    |  float r700 = dot(r695,r699);
    |  float r701 = r699.y;
    |  float r702 = r699.x;
    |  float r703 = -(r702);
    |  vec2 r704 = vec2(r701,r703);
    |  float r705 = dot(r695,r704);
    |  float r706 = r693.y;
    |  float r707 = -(r706);
    |  float r708 = max(r700,r707);
    |  float r709=r708;
    |  float r710 = r693.y;
    |  bool r711 = r710>r143;
    |  bool r712 = r705<r24;
    |  bool r713 =(r711 && r712);
    |  if (r713) {
    |  float r714 = length(r695);
    |  float r715 = max(r709,r714);
    |  r709=r715;
    |  }
    |  float r716 = r693.x;
    |  bool r717 = r716>r265;
    |  vec2 r718 = vec2(r143,r265);
    |  float r719 = length(r718);
    |  bool r720 = r705>r719;
    |  bool r721 =(r717 && r720);
    |  if (r721) {
    |  vec2 r722 = vec2(r265,r24);
    |  vec2 r723 = r693-r722;
    |  float r724 = length(r723);
    |  float r725 = max(r709,r724);
    |  r709=r725;
    |  }
    |  bool r726 =(r639 == r1);
    |  float r727 = r709-r639;
    |  float r728 = r19*r727;
    |  float r729 = r728/r17;
    |  float r730 = r19+r729;
    |  float r731 = max(r730,r24);
    |  float r732 = min(r731,r25);
    |  float r733 = r25-r732;
    |  float r734 = r709*r733;
    |  float r735 = r639*r732;
    |  float r736 = r734+r735;
    |  float r737 = r17*r732;
    |  float r738 = r25-r732;
    |  float r739 = r737*r738;
    |  float r740 = r736-r739;
    |  float r741 =(r726 ? r709 : r740);
    |  float r742 = r0.x;
    |  float r743 = r313.x;
    |  float r744 = r742-r743;
    |  float r745 = r0.y;
    |  float r746 = r313.y;
    |  float r747 = r745-r746;
    |  float r748 = r0.z;
    |  float r749 = r313.z;
    |  float r750 = r748-r749;
    |  float r751 = r0.w;
    |  vec3 r752 = vec3(r744,r747,r750);
    |  float r753 = cos(r323);
    |  vec3 r754 = vec3(r753);
    |  vec3 r755 = r752*r754;
    |  float r756 = r324.y;
    |  float r757 = r752.z;
    |  float r758 = r756*r757;
    |  float r759 = r324.z;
    |  float r760 = r752.y;
    |  float r761 = r759*r760;
    |  float r762 = r758-r761;
    |  float r763 = r324.z;
    |  float r764 = r752.x;
    |  float r765 = r763*r764;
    |  float r766 = r324.x;
    |  float r767 = r752.z;
    |  float r768 = r766*r767;
    |  float r769 = r765-r768;
    |  float r770 = r324.x;
    |  float r771 = r752.y;
    |  float r772 = r770*r771;
    |  float r773 = r324.y;
    |  float r774 = r752.x;
    |  float r775 = r773*r774;
    |  float r776 = r772-r775;
    |  vec3 r777 = vec3(r762,r769,r776);
    |  float r778 = sin(r323);
    |  vec3 r779 = vec3(r778);
    |  vec3 r780 = r777*r779;
    |  vec3 r781 = r755-r780;
    |  float r782 = cos(r323);
    |  float r783 = r25-r782;
    |  vec3 r784 = vec3(r783);
    |  vec3 r785 = r752*r784;
    |  float r786 = dot(r324,r785);
    |  vec3 r787 = vec3(r786);
    |  vec3 r788 = r324*r787;
    |  vec3 r789 = r781+r788;
    |  float r790 = r789.x;
    |  float r791 = r789.y;
    |  float r792 = r789.z;
    |  vec2 r793 = vec2(r790,r791);
    |  float r794 = length(r793);
    |  vec2 r795 = vec2(r794,r792);
    |  vec2 r796 = vec2(r24,r143);
    |  vec2 r797 = r795-r796;
    |  vec2 r798 = vec2(r143,r265);
    |  float r799 = length(r798);
    |  vec2 r800 = vec2(r799);
    |  vec2 r801 = r798/r800;
    |  float r802 = dot(r797,r801);
    |  float r803 = r801.y;
    |  float r804 = r801.x;
    |  float r805 = -(r804);
    |  vec2 r806 = vec2(r803,r805);
    |  float r807 = dot(r797,r806);
    |  float r808 = r795.y;
    |  float r809 = -(r808);
    |  float r810 = max(r802,r809);
    |  float r811=r810;
    |  float r812 = r795.y;
    |  bool r813 = r812>r143;
    |  bool r814 = r807<r24;
    |  bool r815 =(r813 && r814);
    |  if (r815) {
    |  float r816 = length(r797);
    |  float r817 = max(r811,r816);
    |  r811=r817;
    |  }
    |  float r818 = r795.x;
    |  bool r819 = r818>r265;
    |  vec2 r820 = vec2(r143,r265);
    |  float r821 = length(r820);
    |  bool r822 = r807>r821;
    |  bool r823 =(r819 && r822);
    |  if (r823) {
    |  vec2 r824 = vec2(r265,r24);
    |  vec2 r825 = r795-r824;
    |  float r826 = length(r825);
    |  float r827 = max(r811,r826);
    |  r811=r827;
    |  }
    |  bool r828 = r811<=r24;
    |  bool r829 = r811<=r741;
    |  bool r830 =(r828 || r829);
    |  float r831 = r0.x;
    |  float r832 = r313.x;
    |  float r833 = r831-r832;
    |  float r834 = r0.y;
    |  float r835 = r313.y;
    |  float r836 = r834-r835;
    |  float r837 = r0.z;
    |  float r838 = r313.z;
    |  float r839 = r837-r838;
    |  float r840 = r0.w;
    |  vec3 r841 = vec3(r833,r836,r839);
    |  float r842 = cos(r323);
    |  vec3 r843 = vec3(r842);
    |  vec3 r844 = r841*r843;
    |  float r845 = r324.y;
    |  float r846 = r841.z;
    |  float r847 = r845*r846;
    |  float r848 = r324.z;
    |  float r849 = r841.y;
    |  float r850 = r848*r849;
    |  float r851 = r847-r850;
    |  float r852 = r324.z;
    |  float r853 = r841.x;
    |  float r854 = r852*r853;
    |  float r855 = r324.x;
    |  float r856 = r841.z;
    |  float r857 = r855*r856;
    |  float r858 = r854-r857;
    |  float r859 = r324.x;
    |  float r860 = r841.y;
    |  float r861 = r859*r860;
    |  float r862 = r324.y;
    |  float r863 = r841.x;
    |  float r864 = r862*r863;
    |  float r865 = r861-r864;
    |  vec3 r866 = vec3(r851,r858,r865);
    |  float r867 = sin(r323);
    |  vec3 r868 = vec3(r867);
    |  vec3 r869 = r866*r868;
    |  vec3 r870 = r844-r869;
    |  float r871 = cos(r323);
    |  float r872 = r25-r871;
    |  vec3 r873 = vec3(r872);
    |  vec3 r874 = r841*r873;
    |  float r875 = dot(r324,r874);
    |  vec3 r876 = vec3(r875);
    |  vec3 r877 = r324*r876;
    |  vec3 r878 = r870+r877;
    |  float r879 = r878.x;
    |  float r880 = r878.y;
    |  float r881 = r878.z;
    |  vec4 r882 = vec4(r879,r880,r881,r840);
    |  float r883 = r0.x;
    |  float r884 = r3.x;
    |  float r885 = r883-r884;
    |  float r886 = r0.y;
    |  float r887 = r3.y;
    |  float r888 = r886-r887;
    |  float r889 = r0.z;
    |  float r890 = r3.z;
    |  float r891 = r889-r890;
    |  float r892 = r0.w;
    |  vec3 r893 = vec3(r885,r888,r891);
    |  float r894 = length(r893);
    |  float r895 = r894-r15;
    |  bool r896 =(r1 == r1);
    |  float r897 = r895-r1;
    |  float r898 = r19*r897;
    |  float r899 = r898/r17;
    |  float r900 = r19+r899;
    |  float r901 = max(r900,r24);
    |  float r902 = min(r901,r25);
    |  float r903 = r25-r902;
    |  float r904 = r895*r903;
    |  float r905 = r1*r902;
    |  float r906 = r904+r905;
    |  float r907 = r17*r902;
    |  float r908 = r25-r902;
    |  float r909 = r907*r908;
    |  float r910 = r906-r909;
    |  float r911 =(r896 ? r895 : r910);
    |  float r912 = r0.x;
    |  float r913 = r38.x;
    |  float r914 = r912-r913;
    |  float r915 = r0.y;
    |  float r916 = r38.y;
    |  float r917 = r915-r916;
    |  float r918 = r0.z;
    |  float r919 = r38.z;
    |  float r920 = r918-r919;
    |  float r921 = r0.w;
    |  vec3 r922 = vec3(r914,r917,r920);
    |  float r923 = length(r922);
    |  float r924 = r923-r19;
    |  float r925 = min(r911,r924);
    |  float r926 = r0.x;
    |  float r927 = r53.x;
    |  float r928 = r926-r927;
    |  float r929 = r0.y;
    |  float r930 = r53.y;
    |  float r931 = r929-r930;
    |  float r932 = r0.z;
    |  float r933 = r53.z;
    |  float r934 = r932-r933;
    |  float r935 = r0.w;
    |  vec3 r936 = vec3(r928,r931,r934);
    |  float r937 = length(r936);
    |  float r938 = r937-r19;
    |  float r939 = min(r925,r938);
    |  float r940 = r0.x;
    |  float r941 = r68.x;
    |  float r942 = r940-r941;
    |  float r943 = r0.y;
    |  float r944 = r68.y;
    |  float r945 = r943-r944;
    |  float r946 = r0.z;
    |  float r947 = r68.z;
    |  float r948 = r946-r947;
    |  float r949 = r0.w;
    |  vec2 r950 = vec2(r942,r945);
    |  float r951 = length(r950);
    |  vec2 r952 = vec2(r951,r948);
    |  vec2 r953 = vec2(r24,r81);
    |  vec2 r954 = r952-r953;
    |  vec2 r955 = vec2(r81,r19);
    |  float r956 = length(r955);
    |  vec2 r957 = vec2(r956);
    |  vec2 r958 = r955/r957;
    |  float r959 = dot(r954,r958);
    |  float r960 = r958.y;
    |  float r961 = r958.x;
    |  float r962 = -(r961);
    |  vec2 r963 = vec2(r960,r962);
    |  float r964 = dot(r954,r963);
    |  float r965 = r952.y;
    |  float r966 = -(r965);
    |  float r967 = max(r959,r966);
    |  float r968=r967;
    |  float r969 = r952.y;
    |  bool r970 = r969>r81;
    |  bool r971 = r964<r24;
    |  bool r972 =(r970 && r971);
    |  if (r972) {
    |  float r973 = length(r954);
    |  float r974 = max(r968,r973);
    |  r968=r974;
    |  }
    |  float r975 = r952.x;
    |  bool r976 = r975>r19;
    |  vec2 r977 = vec2(r81,r19);
    |  float r978 = length(r977);
    |  bool r979 = r964>r978;
    |  bool r980 =(r976 && r979);
    |  if (r980) {
    |  vec2 r981 = vec2(r19,r24);
    |  vec2 r982 = r952-r981;
    |  float r983 = length(r982);
    |  float r984 = max(r968,r983);
    |  r968=r984;
    |  }
    |  bool r985 =(r939 == r1);
    |  float r986 = r968-r939;
    |  float r987 = r19*r986;
    |  float r988 = r987/r17;
    |  float r989 = r19+r988;
    |  float r990 = max(r989,r24);
    |  float r991 = min(r990,r25);
    |  float r992 = r25-r991;
    |  float r993 = r968*r992;
    |  float r994 = r939*r991;
    |  float r995 = r993+r994;
    |  float r996 = r17*r991;
    |  float r997 = r25-r991;
    |  float r998 = r996*r997;
    |  float r999 = r995-r998;
    |  float r1000 =(r985 ? r968 : r999);
    |  float r1001 = r0.x;
    |  float r1002 = r131.x;
    |  float r1003 = r1001-r1002;
    |  float r1004 = r0.y;
    |  float r1005 = r131.y;
    |  float r1006 = r1004-r1005;
    |  float r1007 = r0.z;
    |  float r1008 = r131.z;
    |  float r1009 = r1007-r1008;
    |  float r1010 = r0.w;
    |  vec3 r1011 = vec3(r1003,r1006,r1009);
    |  float r1012 = length(r1011);
    |  float r1013 = r1012-r143;
    |  bool r1014 =(r1000 == r1);
    |  float r1015 = r1013-r1000;
    |  float r1016 = r19*r1015;
    |  float r1017 = r1016/r17;
    |  float r1018 = r19+r1017;
    |  float r1019 = max(r1018,r24);
    |  float r1020 = min(r1019,r25);
    |  float r1021 = r25-r1020;
    |  float r1022 = r1013*r1021;
    |  float r1023 = r1000*r1020;
    |  float r1024 = r1022+r1023;
    |  float r1025 = r17*r1020;
    |  float r1026 = r25-r1020;
    |  float r1027 = r1025*r1026;
    |  float r1028 = r1024-r1027;
    |  float r1029 =(r1014 ? r1013 : r1028);
    |  float r1030 = r0.x;
    |  float r1031 = r162.x;
    |  float r1032 = r1030-r1031;
    |  float r1033 = r0.y;
    |  float r1034 = r162.y;
    |  float r1035 = r1033-r1034;
    |  float r1036 = r0.z;
    |  float r1037 = r162.z;
    |  float r1038 = r1036-r1037;
    |  float r1039 = r0.w;
    |  vec3 r1040 = vec3(r1032,r1035,r1038);
    |  float r1041 = length(r1040);
    |  float r1042 = r1041-r19;
    |  float r1043 = min(r1029,r1042);
    |  float r1044 = r0.x;
    |  float r1045 = r177.x;
    |  float r1046 = r1044-r1045;
    |  float r1047 = r0.y;
    |  float r1048 = r177.y;
    |  float r1049 = r1047-r1048;
    |  float r1050 = r0.z;
    |  float r1051 = r177.z;
    |  float r1052 = r1050-r1051;
    |  float r1053 = r0.w;
    |  vec3 r1054 = vec3(r1046,r1049,r1052);
    |  float r1055 = length(r1054);
    |  float r1056 = r1055-r19;
    |  float r1057 = min(r1043,r1056);
    |  float r1058 = r0.x;
    |  float r1059 = r192.x;
    |  float r1060 = r1058-r1059;
    |  float r1061 = r0.y;
    |  float r1062 = r192.y;
    |  float r1063 = r1061-r1062;
    |  float r1064 = r0.z;
    |  float r1065 = r192.z;
    |  float r1066 = r1064-r1065;
    |  float r1067 = r0.w;
    |  vec3 r1068 = vec3(r1060,r1063,r1066);
    |  float r1069 = length(r1068);
    |  float r1070 = r1069-r19;
    |  float r1071 = min(r1057,r1070);
    |  float r1072 = r0.x;
    |  float r1073 = r207.x;
    |  float r1074 = r1072-r1073;
    |  float r1075 = r0.y;
    |  float r1076 = r207.y;
    |  float r1077 = r1075-r1076;
    |  float r1078 = r0.z;
    |  float r1079 = r207.z;
    |  float r1080 = r1078-r1079;
    |  float r1081 = r0.w;
    |  vec3 r1082 = vec3(r1074,r1077,r1080);
    |  float r1083 = cos(r217);
    |  vec3 r1084 = vec3(r1083);
    |  vec3 r1085 = r1082*r1084;
    |  float r1086 = r218.y;
    |  float r1087 = r1082.z;
    |  float r1088 = r1086*r1087;
    |  float r1089 = r218.z;
    |  float r1090 = r1082.y;
    |  float r1091 = r1089*r1090;
    |  float r1092 = r1088-r1091;
    |  float r1093 = r218.z;
    |  float r1094 = r1082.x;
    |  float r1095 = r1093*r1094;
    |  float r1096 = r218.x;
    |  float r1097 = r1082.z;
    |  float r1098 = r1096*r1097;
    |  float r1099 = r1095-r1098;
    |  float r1100 = r218.x;
    |  float r1101 = r1082.y;
    |  float r1102 = r1100*r1101;
    |  float r1103 = r218.y;
    |  float r1104 = r1082.x;
    |  float r1105 = r1103*r1104;
    |  float r1106 = r1102-r1105;
    |  vec3 r1107 = vec3(r1092,r1099,r1106);
    |  float r1108 = sin(r217);
    |  vec3 r1109 = vec3(r1108);
    |  vec3 r1110 = r1107*r1109;
    |  vec3 r1111 = r1085-r1110;
    |  float r1112 = cos(r217);
    |  float r1113 = r25-r1112;
    |  vec3 r1114 = vec3(r1113);
    |  vec3 r1115 = r1082*r1114;
    |  float r1116 = dot(r218,r1115);
    |  vec3 r1117 = vec3(r1116);
    |  vec3 r1118 = r218*r1117;
    |  vec3 r1119 = r1111+r1118;
    |  float r1120 = r1119.x;
    |  float r1121 = r1119.y;
    |  float r1122 = r1119.z;
    |  vec2 r1123 = vec2(r1120,r1121);
    |  float r1124 = length(r1123);
    |  vec2 r1125 = vec2(r1124,r1122);
    |  vec2 r1126 = vec2(r24,r143);
    |  vec2 r1127 = r1125-r1126;
    |  vec2 r1128 = vec2(r143,r265);
    |  float r1129 = length(r1128);
    |  vec2 r1130 = vec2(r1129);
    |  vec2 r1131 = r1128/r1130;
    |  float r1132 = dot(r1127,r1131);
    |  float r1133 = r1131.y;
    |  float r1134 = r1131.x;
    |  float r1135 = -(r1134);
    |  vec2 r1136 = vec2(r1133,r1135);
    |  float r1137 = dot(r1127,r1136);
    |  float r1138 = r1125.y;
    |  float r1139 = -(r1138);
    |  float r1140 = max(r1132,r1139);
    |  float r1141=r1140;
    |  float r1142 = r1125.y;
    |  bool r1143 = r1142>r143;
    |  bool r1144 = r1137<r24;
    |  bool r1145 =(r1143 && r1144);
    |  if (r1145) {
    |  float r1146 = length(r1127);
    |  float r1147 = max(r1141,r1146);
    |  r1141=r1147;
    |  }
    |  float r1148 = r1125.x;
    |  bool r1149 = r1148>r265;
    |  vec2 r1150 = vec2(r143,r265);
    |  float r1151 = length(r1150);
    |  bool r1152 = r1137>r1151;
    |  bool r1153 =(r1149 && r1152);
    |  if (r1153) {
    |  vec2 r1154 = vec2(r265,r24);
    |  vec2 r1155 = r1125-r1154;
    |  float r1156 = length(r1155);
    |  float r1157 = max(r1141,r1156);
    |  r1141=r1157;
    |  }
    |  bool r1158 = r1141<=r24;
    |  bool r1159 = r1141<=r1071;
    |  bool r1160 =(r1158 || r1159);
    |  float r1161 = r0.x;
    |  float r1162 = r207.x;
    |  float r1163 = r1161-r1162;
    |  float r1164 = r0.y;
    |  float r1165 = r207.y;
    |  float r1166 = r1164-r1165;
    |  float r1167 = r0.z;
    |  float r1168 = r207.z;
    |  float r1169 = r1167-r1168;
    |  float r1170 = r0.w;
    |  vec3 r1171 = vec3(r1163,r1166,r1169);
    |  float r1172 = cos(r217);
    |  vec3 r1173 = vec3(r1172);
    |  vec3 r1174 = r1171*r1173;
    |  float r1175 = r218.y;
    |  float r1176 = r1171.z;
    |  float r1177 = r1175*r1176;
    |  float r1178 = r218.z;
    |  float r1179 = r1171.y;
    |  float r1180 = r1178*r1179;
    |  float r1181 = r1177-r1180;
    |  float r1182 = r218.z;
    |  float r1183 = r1171.x;
    |  float r1184 = r1182*r1183;
    |  float r1185 = r218.x;
    |  float r1186 = r1171.z;
    |  float r1187 = r1185*r1186;
    |  float r1188 = r1184-r1187;
    |  float r1189 = r218.x;
    |  float r1190 = r1171.y;
    |  float r1191 = r1189*r1190;
    |  float r1192 = r218.y;
    |  float r1193 = r1171.x;
    |  float r1194 = r1192*r1193;
    |  float r1195 = r1191-r1194;
    |  vec3 r1196 = vec3(r1181,r1188,r1195);
    |  float r1197 = sin(r217);
    |  vec3 r1198 = vec3(r1197);
    |  vec3 r1199 = r1196*r1198;
    |  vec3 r1200 = r1174-r1199;
    |  float r1201 = cos(r217);
    |  float r1202 = r25-r1201;
    |  vec3 r1203 = vec3(r1202);
    |  vec3 r1204 = r1171*r1203;
    |  float r1205 = dot(r218,r1204);
    |  vec3 r1206 = vec3(r1205);
    |  vec3 r1207 = r218*r1206;
    |  vec3 r1208 = r1200+r1207;
    |  float r1209 = r1208.x;
    |  float r1210 = r1208.y;
    |  float r1211 = r1208.z;
    |  vec4 r1212 = vec4(r1209,r1210,r1211,r1170);
    |  float r1213 = r0.x;
    |  float r1214 = r3.x;
    |  float r1215 = r1213-r1214;
    |  float r1216 = r0.y;
    |  float r1217 = r3.y;
    |  float r1218 = r1216-r1217;
    |  float r1219 = r0.z;
    |  float r1220 = r3.z;
    |  float r1221 = r1219-r1220;
    |  float r1222 = r0.w;
    |  vec3 r1223 = vec3(r1215,r1218,r1221);
    |  float r1224 = length(r1223);
    |  float r1225 = r1224-r15;
    |  bool r1226 =(r1 == r1);
    |  float r1227 = r1225-r1;
    |  float r1228 = r19*r1227;
    |  float r1229 = r1228/r17;
    |  float r1230 = r19+r1229;
    |  float r1231 = max(r1230,r24);
    |  float r1232 = min(r1231,r25);
    |  float r1233 = r25-r1232;
    |  float r1234 = r1225*r1233;
    |  float r1235 = r1*r1232;
    |  float r1236 = r1234+r1235;
    |  float r1237 = r17*r1232;
    |  float r1238 = r25-r1232;
    |  float r1239 = r1237*r1238;
    |  float r1240 = r1236-r1239;
    |  float r1241 =(r1226 ? r1225 : r1240);
    |  float r1242 = r0.x;
    |  float r1243 = r38.x;
    |  float r1244 = r1242-r1243;
    |  float r1245 = r0.y;
    |  float r1246 = r38.y;
    |  float r1247 = r1245-r1246;
    |  float r1248 = r0.z;
    |  float r1249 = r38.z;
    |  float r1250 = r1248-r1249;
    |  float r1251 = r0.w;
    |  vec3 r1252 = vec3(r1244,r1247,r1250);
    |  float r1253 = length(r1252);
    |  float r1254 = r1253-r19;
    |  float r1255 = min(r1241,r1254);
    |  float r1256 = r0.x;
    |  float r1257 = r53.x;
    |  float r1258 = r1256-r1257;
    |  float r1259 = r0.y;
    |  float r1260 = r53.y;
    |  float r1261 = r1259-r1260;
    |  float r1262 = r0.z;
    |  float r1263 = r53.z;
    |  float r1264 = r1262-r1263;
    |  float r1265 = r0.w;
    |  vec3 r1266 = vec3(r1258,r1261,r1264);
    |  float r1267 = length(r1266);
    |  float r1268 = r1267-r19;
    |  float r1269 = min(r1255,r1268);
    |  float r1270 = r0.x;
    |  float r1271 = r68.x;
    |  float r1272 = r1270-r1271;
    |  float r1273 = r0.y;
    |  float r1274 = r68.y;
    |  float r1275 = r1273-r1274;
    |  float r1276 = r0.z;
    |  float r1277 = r68.z;
    |  float r1278 = r1276-r1277;
    |  float r1279 = r0.w;
    |  vec2 r1280 = vec2(r1272,r1275);
    |  float r1281 = length(r1280);
    |  vec2 r1282 = vec2(r1281,r1278);
    |  vec2 r1283 = vec2(r24,r81);
    |  vec2 r1284 = r1282-r1283;
    |  vec2 r1285 = vec2(r81,r19);
    |  float r1286 = length(r1285);
    |  vec2 r1287 = vec2(r1286);
    |  vec2 r1288 = r1285/r1287;
    |  float r1289 = dot(r1284,r1288);
    |  float r1290 = r1288.y;
    |  float r1291 = r1288.x;
    |  float r1292 = -(r1291);
    |  vec2 r1293 = vec2(r1290,r1292);
    |  float r1294 = dot(r1284,r1293);
    |  float r1295 = r1282.y;
    |  float r1296 = -(r1295);
    |  float r1297 = max(r1289,r1296);
    |  float r1298=r1297;
    |  float r1299 = r1282.y;
    |  bool r1300 = r1299>r81;
    |  bool r1301 = r1294<r24;
    |  bool r1302 =(r1300 && r1301);
    |  if (r1302) {
    |  float r1303 = length(r1284);
    |  float r1304 = max(r1298,r1303);
    |  r1298=r1304;
    |  }
    |  float r1305 = r1282.x;
    |  bool r1306 = r1305>r19;
    |  vec2 r1307 = vec2(r81,r19);
    |  float r1308 = length(r1307);
    |  bool r1309 = r1294>r1308;
    |  bool r1310 =(r1306 && r1309);
    |  if (r1310) {
    |  vec2 r1311 = vec2(r19,r24);
    |  vec2 r1312 = r1282-r1311;
    |  float r1313 = length(r1312);
    |  float r1314 = max(r1298,r1313);
    |  r1298=r1314;
    |  }
    |  bool r1315 =(r1269 == r1);
    |  float r1316 = r1298-r1269;
    |  float r1317 = r19*r1316;
    |  float r1318 = r1317/r17;
    |  float r1319 = r19+r1318;
    |  float r1320 = max(r1319,r24);
    |  float r1321 = min(r1320,r25);
    |  float r1322 = r25-r1321;
    |  float r1323 = r1298*r1322;
    |  float r1324 = r1269*r1321;
    |  float r1325 = r1323+r1324;
    |  float r1326 = r17*r1321;
    |  float r1327 = r25-r1321;
    |  float r1328 = r1326*r1327;
    |  float r1329 = r1325-r1328;
    |  float r1330 =(r1315 ? r1298 : r1329);
    |  float r1331 = r0.x;
    |  float r1332 = r131.x;
    |  float r1333 = r1331-r1332;
    |  float r1334 = r0.y;
    |  float r1335 = r131.y;
    |  float r1336 = r1334-r1335;
    |  float r1337 = r0.z;
    |  float r1338 = r131.z;
    |  float r1339 = r1337-r1338;
    |  float r1340 = r0.w;
    |  vec3 r1341 = vec3(r1333,r1336,r1339);
    |  float r1342 = length(r1341);
    |  float r1343 = r1342-r143;
    |  bool r1344 =(r1330 == r1);
    |  float r1345 = r1343-r1330;
    |  float r1346 = r19*r1345;
    |  float r1347 = r1346/r17;
    |  float r1348 = r19+r1347;
    |  float r1349 = max(r1348,r24);
    |  float r1350 = min(r1349,r25);
    |  float r1351 = r25-r1350;
    |  float r1352 = r1343*r1351;
    |  float r1353 = r1330*r1350;
    |  float r1354 = r1352+r1353;
    |  float r1355 = r17*r1350;
    |  float r1356 = r25-r1350;
    |  float r1357 = r1355*r1356;
    |  float r1358 = r1354-r1357;
    |  float r1359 =(r1344 ? r1343 : r1358);
    |  float r1360 = r0.x;
    |  float r1361 = r162.x;
    |  float r1362 = r1360-r1361;
    |  float r1363 = r0.y;
    |  float r1364 = r162.y;
    |  float r1365 = r1363-r1364;
    |  float r1366 = r0.z;
    |  float r1367 = r162.z;
    |  float r1368 = r1366-r1367;
    |  float r1369 = r0.w;
    |  vec3 r1370 = vec3(r1362,r1365,r1368);
    |  float r1371 = length(r1370);
    |  float r1372 = r1371-r19;
    |  float r1373 = min(r1359,r1372);
    |  float r1374 = r0.x;
    |  float r1375 = r177.x;
    |  float r1376 = r1374-r1375;
    |  float r1377 = r0.y;
    |  float r1378 = r177.y;
    |  float r1379 = r1377-r1378;
    |  float r1380 = r0.z;
    |  float r1381 = r177.z;
    |  float r1382 = r1380-r1381;
    |  float r1383 = r0.w;
    |  vec3 r1384 = vec3(r1376,r1379,r1382);
    |  float r1385 = length(r1384);
    |  float r1386 = r1385-r19;
    |  float r1387 = min(r1373,r1386);
    |  float r1388 = r0.x;
    |  float r1389 = r192.x;
    |  float r1390 = r1388-r1389;
    |  float r1391 = r0.y;
    |  float r1392 = r192.y;
    |  float r1393 = r1391-r1392;
    |  float r1394 = r0.z;
    |  float r1395 = r192.z;
    |  float r1396 = r1394-r1395;
    |  float r1397 = r0.w;
    |  vec3 r1398 = vec3(r1390,r1393,r1396);
    |  float r1399 = length(r1398);
    |  float r1400 = r1399-r19;
    |  bool r1401 = r1400<=r24;
    |  bool r1402 = r1400<=r1387;
    |  bool r1403 =(r1401 || r1402);
    |  float r1404 = r0.x;
    |  float r1405 = r192.x;
    |  float r1406 = r1404-r1405;
    |  float r1407 = r0.y;
    |  float r1408 = r192.y;
    |  float r1409 = r1407-r1408;
    |  float r1410 = r0.z;
    |  float r1411 = r192.z;
    |  float r1412 = r1410-r1411;
    |  float r1413 = r0.w;
    |  vec4 r1414 = vec4(r1406,r1409,r1412,r1413);
    |  float r1415 = r0.x;
    |  float r1416 = r3.x;
    |  float r1417 = r1415-r1416;
    |  float r1418 = r0.y;
    |  float r1419 = r3.y;
    |  float r1420 = r1418-r1419;
    |  float r1421 = r0.z;
    |  float r1422 = r3.z;
    |  float r1423 = r1421-r1422;
    |  float r1424 = r0.w;
    |  vec3 r1425 = vec3(r1417,r1420,r1423);
    |  float r1426 = length(r1425);
    |  float r1427 = r1426-r15;
    |  bool r1428 =(r1 == r1);
    |  float r1429 = r1427-r1;
    |  float r1430 = r19*r1429;
    |  float r1431 = r1430/r17;
    |  float r1432 = r19+r1431;
    |  float r1433 = max(r1432,r24);
    |  float r1434 = min(r1433,r25);
    |  float r1435 = r25-r1434;
    |  float r1436 = r1427*r1435;
    |  float r1437 = r1*r1434;
    |  float r1438 = r1436+r1437;
    |  float r1439 = r17*r1434;
    |  float r1440 = r25-r1434;
    |  float r1441 = r1439*r1440;
    |  float r1442 = r1438-r1441;
    |  float r1443 =(r1428 ? r1427 : r1442);
    |  float r1444 = r0.x;
    |  float r1445 = r38.x;
    |  float r1446 = r1444-r1445;
    |  float r1447 = r0.y;
    |  float r1448 = r38.y;
    |  float r1449 = r1447-r1448;
    |  float r1450 = r0.z;
    |  float r1451 = r38.z;
    |  float r1452 = r1450-r1451;
    |  float r1453 = r0.w;
    |  vec3 r1454 = vec3(r1446,r1449,r1452);
    |  float r1455 = length(r1454);
    |  float r1456 = r1455-r19;
    |  float r1457 = min(r1443,r1456);
    |  float r1458 = r0.x;
    |  float r1459 = r53.x;
    |  float r1460 = r1458-r1459;
    |  float r1461 = r0.y;
    |  float r1462 = r53.y;
    |  float r1463 = r1461-r1462;
    |  float r1464 = r0.z;
    |  float r1465 = r53.z;
    |  float r1466 = r1464-r1465;
    |  float r1467 = r0.w;
    |  vec3 r1468 = vec3(r1460,r1463,r1466);
    |  float r1469 = length(r1468);
    |  float r1470 = r1469-r19;
    |  float r1471 = min(r1457,r1470);
    |  float r1472 = r0.x;
    |  float r1473 = r68.x;
    |  float r1474 = r1472-r1473;
    |  float r1475 = r0.y;
    |  float r1476 = r68.y;
    |  float r1477 = r1475-r1476;
    |  float r1478 = r0.z;
    |  float r1479 = r68.z;
    |  float r1480 = r1478-r1479;
    |  float r1481 = r0.w;
    |  vec2 r1482 = vec2(r1474,r1477);
    |  float r1483 = length(r1482);
    |  vec2 r1484 = vec2(r1483,r1480);
    |  vec2 r1485 = vec2(r24,r81);
    |  vec2 r1486 = r1484-r1485;
    |  vec2 r1487 = vec2(r81,r19);
    |  float r1488 = length(r1487);
    |  vec2 r1489 = vec2(r1488);
    |  vec2 r1490 = r1487/r1489;
    |  float r1491 = dot(r1486,r1490);
    |  float r1492 = r1490.y;
    |  float r1493 = r1490.x;
    |  float r1494 = -(r1493);
    |  vec2 r1495 = vec2(r1492,r1494);
    |  float r1496 = dot(r1486,r1495);
    |  float r1497 = r1484.y;
    |  float r1498 = -(r1497);
    |  float r1499 = max(r1491,r1498);
    |  float r1500=r1499;
    |  float r1501 = r1484.y;
    |  bool r1502 = r1501>r81;
    |  bool r1503 = r1496<r24;
    |  bool r1504 =(r1502 && r1503);
    |  if (r1504) {
    |  float r1505 = length(r1486);
    |  float r1506 = max(r1500,r1505);
    |  r1500=r1506;
    |  }
    |  float r1507 = r1484.x;
    |  bool r1508 = r1507>r19;
    |  vec2 r1509 = vec2(r81,r19);
    |  float r1510 = length(r1509);
    |  bool r1511 = r1496>r1510;
    |  bool r1512 =(r1508 && r1511);
    |  if (r1512) {
    |  vec2 r1513 = vec2(r19,r24);
    |  vec2 r1514 = r1484-r1513;
    |  float r1515 = length(r1514);
    |  float r1516 = max(r1500,r1515);
    |  r1500=r1516;
    |  }
    |  bool r1517 =(r1471 == r1);
    |  float r1518 = r1500-r1471;
    |  float r1519 = r19*r1518;
    |  float r1520 = r1519/r17;
    |  float r1521 = r19+r1520;
    |  float r1522 = max(r1521,r24);
    |  float r1523 = min(r1522,r25);
    |  float r1524 = r25-r1523;
    |  float r1525 = r1500*r1524;
    |  float r1526 = r1471*r1523;
    |  float r1527 = r1525+r1526;
    |  float r1528 = r17*r1523;
    |  float r1529 = r25-r1523;
    |  float r1530 = r1528*r1529;
    |  float r1531 = r1527-r1530;
    |  float r1532 =(r1517 ? r1500 : r1531);
    |  float r1533 = r0.x;
    |  float r1534 = r131.x;
    |  float r1535 = r1533-r1534;
    |  float r1536 = r0.y;
    |  float r1537 = r131.y;
    |  float r1538 = r1536-r1537;
    |  float r1539 = r0.z;
    |  float r1540 = r131.z;
    |  float r1541 = r1539-r1540;
    |  float r1542 = r0.w;
    |  vec3 r1543 = vec3(r1535,r1538,r1541);
    |  float r1544 = length(r1543);
    |  float r1545 = r1544-r143;
    |  bool r1546 =(r1532 == r1);
    |  float r1547 = r1545-r1532;
    |  float r1548 = r19*r1547;
    |  float r1549 = r1548/r17;
    |  float r1550 = r19+r1549;
    |  float r1551 = max(r1550,r24);
    |  float r1552 = min(r1551,r25);
    |  float r1553 = r25-r1552;
    |  float r1554 = r1545*r1553;
    |  float r1555 = r1532*r1552;
    |  float r1556 = r1554+r1555;
    |  float r1557 = r17*r1552;
    |  float r1558 = r25-r1552;
    |  float r1559 = r1557*r1558;
    |  float r1560 = r1556-r1559;
    |  float r1561 =(r1546 ? r1545 : r1560);
    |  float r1562 = r0.x;
    |  float r1563 = r162.x;
    |  float r1564 = r1562-r1563;
    |  float r1565 = r0.y;
    |  float r1566 = r162.y;
    |  float r1567 = r1565-r1566;
    |  float r1568 = r0.z;
    |  float r1569 = r162.z;
    |  float r1570 = r1568-r1569;
    |  float r1571 = r0.w;
    |  vec3 r1572 = vec3(r1564,r1567,r1570);
    |  float r1573 = length(r1572);
    |  float r1574 = r1573-r19;
    |  float r1575 = min(r1561,r1574);
    |  float r1576 = r0.x;
    |  float r1577 = r177.x;
    |  float r1578 = r1576-r1577;
    |  float r1579 = r0.y;
    |  float r1580 = r177.y;
    |  float r1581 = r1579-r1580;
    |  float r1582 = r0.z;
    |  float r1583 = r177.z;
    |  float r1584 = r1582-r1583;
    |  float r1585 = r0.w;
    |  vec3 r1586 = vec3(r1578,r1581,r1584);
    |  float r1587 = length(r1586);
    |  float r1588 = r1587-r19;
    |  bool r1589 = r1588<=r24;
    |  bool r1590 = r1588<=r1575;
    |  bool r1591 =(r1589 || r1590);
    |  float r1592 = r0.x;
    |  float r1593 = r177.x;
    |  float r1594 = r1592-r1593;
    |  float r1595 = r0.y;
    |  float r1596 = r177.y;
    |  float r1597 = r1595-r1596;
    |  float r1598 = r0.z;
    |  float r1599 = r177.z;
    |  float r1600 = r1598-r1599;
    |  float r1601 = r0.w;
    |  vec4 r1602 = vec4(r1594,r1597,r1600,r1601);
    |  float r1603 = r0.x;
    |  float r1604 = r3.x;
    |  float r1605 = r1603-r1604;
    |  float r1606 = r0.y;
    |  float r1607 = r3.y;
    |  float r1608 = r1606-r1607;
    |  float r1609 = r0.z;
    |  float r1610 = r3.z;
    |  float r1611 = r1609-r1610;
    |  float r1612 = r0.w;
    |  vec3 r1613 = vec3(r1605,r1608,r1611);
    |  float r1614 = length(r1613);
    |  float r1615 = r1614-r15;
    |  bool r1616 =(r1 == r1);
    |  float r1617 = r1615-r1;
    |  float r1618 = r19*r1617;
    |  float r1619 = r1618/r17;
    |  float r1620 = r19+r1619;
    |  float r1621 = max(r1620,r24);
    |  float r1622 = min(r1621,r25);
    |  float r1623 = r25-r1622;
    |  float r1624 = r1615*r1623;
    |  float r1625 = r1*r1622;
    |  float r1626 = r1624+r1625;
    |  float r1627 = r17*r1622;
    |  float r1628 = r25-r1622;
    |  float r1629 = r1627*r1628;
    |  float r1630 = r1626-r1629;
    |  float r1631 =(r1616 ? r1615 : r1630);
    |  float r1632 = r0.x;
    |  float r1633 = r38.x;
    |  float r1634 = r1632-r1633;
    |  float r1635 = r0.y;
    |  float r1636 = r38.y;
    |  float r1637 = r1635-r1636;
    |  float r1638 = r0.z;
    |  float r1639 = r38.z;
    |  float r1640 = r1638-r1639;
    |  float r1641 = r0.w;
    |  vec3 r1642 = vec3(r1634,r1637,r1640);
    |  float r1643 = length(r1642);
    |  float r1644 = r1643-r19;
    |  float r1645 = min(r1631,r1644);
    |  float r1646 = r0.x;
    |  float r1647 = r53.x;
    |  float r1648 = r1646-r1647;
    |  float r1649 = r0.y;
    |  float r1650 = r53.y;
    |  float r1651 = r1649-r1650;
    |  float r1652 = r0.z;
    |  float r1653 = r53.z;
    |  float r1654 = r1652-r1653;
    |  float r1655 = r0.w;
    |  vec3 r1656 = vec3(r1648,r1651,r1654);
    |  float r1657 = length(r1656);
    |  float r1658 = r1657-r19;
    |  float r1659 = min(r1645,r1658);
    |  float r1660 = r0.x;
    |  float r1661 = r68.x;
    |  float r1662 = r1660-r1661;
    |  float r1663 = r0.y;
    |  float r1664 = r68.y;
    |  float r1665 = r1663-r1664;
    |  float r1666 = r0.z;
    |  float r1667 = r68.z;
    |  float r1668 = r1666-r1667;
    |  float r1669 = r0.w;
    |  vec2 r1670 = vec2(r1662,r1665);
    |  float r1671 = length(r1670);
    |  vec2 r1672 = vec2(r1671,r1668);
    |  vec2 r1673 = vec2(r24,r81);
    |  vec2 r1674 = r1672-r1673;
    |  vec2 r1675 = vec2(r81,r19);
    |  float r1676 = length(r1675);
    |  vec2 r1677 = vec2(r1676);
    |  vec2 r1678 = r1675/r1677;
    |  float r1679 = dot(r1674,r1678);
    |  float r1680 = r1678.y;
    |  float r1681 = r1678.x;
    |  float r1682 = -(r1681);
    |  vec2 r1683 = vec2(r1680,r1682);
    |  float r1684 = dot(r1674,r1683);
    |  float r1685 = r1672.y;
    |  float r1686 = -(r1685);
    |  float r1687 = max(r1679,r1686);
    |  float r1688=r1687;
    |  float r1689 = r1672.y;
    |  bool r1690 = r1689>r81;
    |  bool r1691 = r1684<r24;
    |  bool r1692 =(r1690 && r1691);
    |  if (r1692) {
    |  float r1693 = length(r1674);
    |  float r1694 = max(r1688,r1693);
    |  r1688=r1694;
    |  }
    |  float r1695 = r1672.x;
    |  bool r1696 = r1695>r19;
    |  vec2 r1697 = vec2(r81,r19);
    |  float r1698 = length(r1697);
    |  bool r1699 = r1684>r1698;
    |  bool r1700 =(r1696 && r1699);
    |  if (r1700) {
    |  vec2 r1701 = vec2(r19,r24);
    |  vec2 r1702 = r1672-r1701;
    |  float r1703 = length(r1702);
    |  float r1704 = max(r1688,r1703);
    |  r1688=r1704;
    |  }
    |  bool r1705 =(r1659 == r1);
    |  float r1706 = r1688-r1659;
    |  float r1707 = r19*r1706;
    |  float r1708 = r1707/r17;
    |  float r1709 = r19+r1708;
    |  float r1710 = max(r1709,r24);
    |  float r1711 = min(r1710,r25);
    |  float r1712 = r25-r1711;
    |  float r1713 = r1688*r1712;
    |  float r1714 = r1659*r1711;
    |  float r1715 = r1713+r1714;
    |  float r1716 = r17*r1711;
    |  float r1717 = r25-r1711;
    |  float r1718 = r1716*r1717;
    |  float r1719 = r1715-r1718;
    |  float r1720 =(r1705 ? r1688 : r1719);
    |  float r1721 = r0.x;
    |  float r1722 = r131.x;
    |  float r1723 = r1721-r1722;
    |  float r1724 = r0.y;
    |  float r1725 = r131.y;
    |  float r1726 = r1724-r1725;
    |  float r1727 = r0.z;
    |  float r1728 = r131.z;
    |  float r1729 = r1727-r1728;
    |  float r1730 = r0.w;
    |  vec3 r1731 = vec3(r1723,r1726,r1729);
    |  float r1732 = length(r1731);
    |  float r1733 = r1732-r143;
    |  bool r1734 =(r1720 == r1);
    |  float r1735 = r1733-r1720;
    |  float r1736 = r19*r1735;
    |  float r1737 = r1736/r17;
    |  float r1738 = r19+r1737;
    |  float r1739 = max(r1738,r24);
    |  float r1740 = min(r1739,r25);
    |  float r1741 = r25-r1740;
    |  float r1742 = r1733*r1741;
    |  float r1743 = r1720*r1740;
    |  float r1744 = r1742+r1743;
    |  float r1745 = r17*r1740;
    |  float r1746 = r25-r1740;
    |  float r1747 = r1745*r1746;
    |  float r1748 = r1744-r1747;
    |  float r1749 =(r1734 ? r1733 : r1748);
    |  float r1750 = r0.x;
    |  float r1751 = r162.x;
    |  float r1752 = r1750-r1751;
    |  float r1753 = r0.y;
    |  float r1754 = r162.y;
    |  float r1755 = r1753-r1754;
    |  float r1756 = r0.z;
    |  float r1757 = r162.z;
    |  float r1758 = r1756-r1757;
    |  float r1759 = r0.w;
    |  vec3 r1760 = vec3(r1752,r1755,r1758);
    |  float r1761 = length(r1760);
    |  float r1762 = r1761-r19;
    |  bool r1763 = r1762<=r24;
    |  bool r1764 = r1762<=r1749;
    |  bool r1765 =(r1763 || r1764);
    |  float r1766 = r0.x;
    |  float r1767 = r162.x;
    |  float r1768 = r1766-r1767;
    |  float r1769 = r0.y;
    |  float r1770 = r162.y;
    |  float r1771 = r1769-r1770;
    |  float r1772 = r0.z;
    |  float r1773 = r162.z;
    |  float r1774 = r1772-r1773;
    |  float r1775 = r0.w;
    |  vec4 r1776 = vec4(r1768,r1771,r1774,r1775);
    |  float r1777 = r0.x;
    |  float r1778 = r3.x;
    |  float r1779 = r1777-r1778;
    |  float r1780 = r0.y;
    |  float r1781 = r3.y;
    |  float r1782 = r1780-r1781;
    |  float r1783 = r0.z;
    |  float r1784 = r3.z;
    |  float r1785 = r1783-r1784;
    |  float r1786 = r0.w;
    |  vec3 r1787 = vec3(r1779,r1782,r1785);
    |  float r1788 = length(r1787);
    |  float r1789 = r1788-r15;
    |  bool r1790 =(r1 == r1);
    |  float r1791 = r1789-r1;
    |  float r1792 = r19*r1791;
    |  float r1793 = r1792/r17;
    |  float r1794 = r19+r1793;
    |  float r1795 = max(r1794,r24);
    |  float r1796 = min(r1795,r25);
    |  float r1797 = r25-r1796;
    |  float r1798 = r1789*r1797;
    |  float r1799 = r1*r1796;
    |  float r1800 = r1798+r1799;
    |  float r1801 = r17*r1796;
    |  float r1802 = r25-r1796;
    |  float r1803 = r1801*r1802;
    |  float r1804 = r1800-r1803;
    |  float r1805 =(r1790 ? r1789 : r1804);
    |  float r1806 = r0.x;
    |  float r1807 = r38.x;
    |  float r1808 = r1806-r1807;
    |  float r1809 = r0.y;
    |  float r1810 = r38.y;
    |  float r1811 = r1809-r1810;
    |  float r1812 = r0.z;
    |  float r1813 = r38.z;
    |  float r1814 = r1812-r1813;
    |  float r1815 = r0.w;
    |  vec3 r1816 = vec3(r1808,r1811,r1814);
    |  float r1817 = length(r1816);
    |  float r1818 = r1817-r19;
    |  float r1819 = min(r1805,r1818);
    |  float r1820 = r0.x;
    |  float r1821 = r53.x;
    |  float r1822 = r1820-r1821;
    |  float r1823 = r0.y;
    |  float r1824 = r53.y;
    |  float r1825 = r1823-r1824;
    |  float r1826 = r0.z;
    |  float r1827 = r53.z;
    |  float r1828 = r1826-r1827;
    |  float r1829 = r0.w;
    |  vec3 r1830 = vec3(r1822,r1825,r1828);
    |  float r1831 = length(r1830);
    |  float r1832 = r1831-r19;
    |  float r1833 = min(r1819,r1832);
    |  float r1834 = r0.x;
    |  float r1835 = r68.x;
    |  float r1836 = r1834-r1835;
    |  float r1837 = r0.y;
    |  float r1838 = r68.y;
    |  float r1839 = r1837-r1838;
    |  float r1840 = r0.z;
    |  float r1841 = r68.z;
    |  float r1842 = r1840-r1841;
    |  float r1843 = r0.w;
    |  vec2 r1844 = vec2(r1836,r1839);
    |  float r1845 = length(r1844);
    |  vec2 r1846 = vec2(r1845,r1842);
    |  vec2 r1847 = vec2(r24,r81);
    |  vec2 r1848 = r1846-r1847;
    |  vec2 r1849 = vec2(r81,r19);
    |  float r1850 = length(r1849);
    |  vec2 r1851 = vec2(r1850);
    |  vec2 r1852 = r1849/r1851;
    |  float r1853 = dot(r1848,r1852);
    |  float r1854 = r1852.y;
    |  float r1855 = r1852.x;
    |  float r1856 = -(r1855);
    |  vec2 r1857 = vec2(r1854,r1856);
    |  float r1858 = dot(r1848,r1857);
    |  float r1859 = r1846.y;
    |  float r1860 = -(r1859);
    |  float r1861 = max(r1853,r1860);
    |  float r1862=r1861;
    |  float r1863 = r1846.y;
    |  bool r1864 = r1863>r81;
    |  bool r1865 = r1858<r24;
    |  bool r1866 =(r1864 && r1865);
    |  if (r1866) {
    |  float r1867 = length(r1848);
    |  float r1868 = max(r1862,r1867);
    |  r1862=r1868;
    |  }
    |  float r1869 = r1846.x;
    |  bool r1870 = r1869>r19;
    |  vec2 r1871 = vec2(r81,r19);
    |  float r1872 = length(r1871);
    |  bool r1873 = r1858>r1872;
    |  bool r1874 =(r1870 && r1873);
    |  if (r1874) {
    |  vec2 r1875 = vec2(r19,r24);
    |  vec2 r1876 = r1846-r1875;
    |  float r1877 = length(r1876);
    |  float r1878 = max(r1862,r1877);
    |  r1862=r1878;
    |  }
    |  bool r1879 =(r1833 == r1);
    |  float r1880 = r1862-r1833;
    |  float r1881 = r19*r1880;
    |  float r1882 = r1881/r17;
    |  float r1883 = r19+r1882;
    |  float r1884 = max(r1883,r24);
    |  float r1885 = min(r1884,r25);
    |  float r1886 = r25-r1885;
    |  float r1887 = r1862*r1886;
    |  float r1888 = r1833*r1885;
    |  float r1889 = r1887+r1888;
    |  float r1890 = r17*r1885;
    |  float r1891 = r25-r1885;
    |  float r1892 = r1890*r1891;
    |  float r1893 = r1889-r1892;
    |  float r1894 =(r1879 ? r1862 : r1893);
    |  float r1895 = r0.x;
    |  float r1896 = r131.x;
    |  float r1897 = r1895-r1896;
    |  float r1898 = r0.y;
    |  float r1899 = r131.y;
    |  float r1900 = r1898-r1899;
    |  float r1901 = r0.z;
    |  float r1902 = r131.z;
    |  float r1903 = r1901-r1902;
    |  float r1904 = r0.w;
    |  vec3 r1905 = vec3(r1897,r1900,r1903);
    |  float r1906 = length(r1905);
    |  float r1907 = r1906-r143;
    |  bool r1908 = r1907<=r24;
    |  bool r1909 = r1907<=r1894;
    |  bool r1910 =(r1908 || r1909);
    |  float r1911 = r0.x;
    |  float r1912 = r131.x;
    |  float r1913 = r1911-r1912;
    |  float r1914 = r0.y;
    |  float r1915 = r131.y;
    |  float r1916 = r1914-r1915;
    |  float r1917 = r0.z;
    |  float r1918 = r131.z;
    |  float r1919 = r1917-r1918;
    |  float r1920 = r0.w;
    |  vec4 r1921 = vec4(r1913,r1916,r1919,r1920);
    |  float r1922 = r0.x;
    |  float r1923 = r3.x;
    |  float r1924 = r1922-r1923;
    |  float r1925 = r0.y;
    |  float r1926 = r3.y;
    |  float r1927 = r1925-r1926;
    |  float r1928 = r0.z;
    |  float r1929 = r3.z;
    |  float r1930 = r1928-r1929;
    |  float r1931 = r0.w;
    |  vec3 r1932 = vec3(r1924,r1927,r1930);
    |  float r1933 = length(r1932);
    |  float r1934 = r1933-r15;
    |  bool r1935 =(r1 == r1);
    |  float r1936 = r1934-r1;
    |  float r1937 = r19*r1936;
    |  float r1938 = r1937/r17;
    |  float r1939 = r19+r1938;
    |  float r1940 = max(r1939,r24);
    |  float r1941 = min(r1940,r25);
    |  float r1942 = r25-r1941;
    |  float r1943 = r1934*r1942;
    |  float r1944 = r1*r1941;
    |  float r1945 = r1943+r1944;
    |  float r1946 = r17*r1941;
    |  float r1947 = r25-r1941;
    |  float r1948 = r1946*r1947;
    |  float r1949 = r1945-r1948;
    |  float r1950 =(r1935 ? r1934 : r1949);
    |  float r1951 = r0.x;
    |  float r1952 = r38.x;
    |  float r1953 = r1951-r1952;
    |  float r1954 = r0.y;
    |  float r1955 = r38.y;
    |  float r1956 = r1954-r1955;
    |  float r1957 = r0.z;
    |  float r1958 = r38.z;
    |  float r1959 = r1957-r1958;
    |  float r1960 = r0.w;
    |  vec3 r1961 = vec3(r1953,r1956,r1959);
    |  float r1962 = length(r1961);
    |  float r1963 = r1962-r19;
    |  float r1964 = min(r1950,r1963);
    |  float r1965 = r0.x;
    |  float r1966 = r53.x;
    |  float r1967 = r1965-r1966;
    |  float r1968 = r0.y;
    |  float r1969 = r53.y;
    |  float r1970 = r1968-r1969;
    |  float r1971 = r0.z;
    |  float r1972 = r53.z;
    |  float r1973 = r1971-r1972;
    |  float r1974 = r0.w;
    |  vec3 r1975 = vec3(r1967,r1970,r1973);
    |  float r1976 = length(r1975);
    |  float r1977 = r1976-r19;
    |  float r1978 = min(r1964,r1977);
    |  float r1979 = r0.x;
    |  float r1980 = r68.x;
    |  float r1981 = r1979-r1980;
    |  float r1982 = r0.y;
    |  float r1983 = r68.y;
    |  float r1984 = r1982-r1983;
    |  float r1985 = r0.z;
    |  float r1986 = r68.z;
    |  float r1987 = r1985-r1986;
    |  float r1988 = r0.w;
    |  vec2 r1989 = vec2(r1981,r1984);
    |  float r1990 = length(r1989);
    |  vec2 r1991 = vec2(r1990,r1987);
    |  vec2 r1992 = vec2(r24,r81);
    |  vec2 r1993 = r1991-r1992;
    |  vec2 r1994 = vec2(r81,r19);
    |  float r1995 = length(r1994);
    |  vec2 r1996 = vec2(r1995);
    |  vec2 r1997 = r1994/r1996;
    |  float r1998 = dot(r1993,r1997);
    |  float r1999 = r1997.y;
    |  float r2000 = r1997.x;
    |  float r2001 = -(r2000);
    |  vec2 r2002 = vec2(r1999,r2001);
    |  float r2003 = dot(r1993,r2002);
    |  float r2004 = r1991.y;
    |  float r2005 = -(r2004);
    |  float r2006 = max(r1998,r2005);
    |  float r2007=r2006;
    |  float r2008 = r1991.y;
    |  bool r2009 = r2008>r81;
    |  bool r2010 = r2003<r24;
    |  bool r2011 =(r2009 && r2010);
    |  if (r2011) {
    |  float r2012 = length(r1993);
    |  float r2013 = max(r2007,r2012);
    |  r2007=r2013;
    |  }
    |  float r2014 = r1991.x;
    |  bool r2015 = r2014>r19;
    |  vec2 r2016 = vec2(r81,r19);
    |  float r2017 = length(r2016);
    |  bool r2018 = r2003>r2017;
    |  bool r2019 =(r2015 && r2018);
    |  if (r2019) {
    |  vec2 r2020 = vec2(r19,r24);
    |  vec2 r2021 = r1991-r2020;
    |  float r2022 = length(r2021);
    |  float r2023 = max(r2007,r2022);
    |  r2007=r2023;
    |  }
    |  bool r2024 = r2007<=r24;
    |  bool r2025 = r2007<=r1978;
    |  bool r2026 =(r2024 || r2025);
    |  float r2027 = r0.x;
    |  float r2028 = r68.x;
    |  float r2029 = r2027-r2028;
    |  float r2030 = r0.y;
    |  float r2031 = r68.y;
    |  float r2032 = r2030-r2031;
    |  float r2033 = r0.z;
    |  float r2034 = r68.z;
    |  float r2035 = r2033-r2034;
    |  float r2036 = r0.w;
    |  vec4 r2037 = vec4(r2029,r2032,r2035,r2036);
    |  float r2038 = r0.x;
    |  float r2039 = r3.x;
    |  float r2040 = r2038-r2039;
    |  float r2041 = r0.y;
    |  float r2042 = r3.y;
    |  float r2043 = r2041-r2042;
    |  float r2044 = r0.z;
    |  float r2045 = r3.z;
    |  float r2046 = r2044-r2045;
    |  float r2047 = r0.w;
    |  vec3 r2048 = vec3(r2040,r2043,r2046);
    |  float r2049 = length(r2048);
    |  float r2050 = r2049-r15;
    |  bool r2051 =(r1 == r1);
    |  float r2052 = r2050-r1;
    |  float r2053 = r19*r2052;
    |  float r2054 = r2053/r17;
    |  float r2055 = r19+r2054;
    |  float r2056 = max(r2055,r24);
    |  float r2057 = min(r2056,r25);
    |  float r2058 = r25-r2057;
    |  float r2059 = r2050*r2058;
    |  float r2060 = r1*r2057;
    |  float r2061 = r2059+r2060;
    |  float r2062 = r17*r2057;
    |  float r2063 = r25-r2057;
    |  float r2064 = r2062*r2063;
    |  float r2065 = r2061-r2064;
    |  float r2066 =(r2051 ? r2050 : r2065);
    |  float r2067 = r0.x;
    |  float r2068 = r38.x;
    |  float r2069 = r2067-r2068;
    |  float r2070 = r0.y;
    |  float r2071 = r38.y;
    |  float r2072 = r2070-r2071;
    |  float r2073 = r0.z;
    |  float r2074 = r38.z;
    |  float r2075 = r2073-r2074;
    |  float r2076 = r0.w;
    |  vec3 r2077 = vec3(r2069,r2072,r2075);
    |  float r2078 = length(r2077);
    |  float r2079 = r2078-r19;
    |  float r2080 = min(r2066,r2079);
    |  float r2081 = r0.x;
    |  float r2082 = r53.x;
    |  float r2083 = r2081-r2082;
    |  float r2084 = r0.y;
    |  float r2085 = r53.y;
    |  float r2086 = r2084-r2085;
    |  float r2087 = r0.z;
    |  float r2088 = r53.z;
    |  float r2089 = r2087-r2088;
    |  float r2090 = r0.w;
    |  vec3 r2091 = vec3(r2083,r2086,r2089);
    |  float r2092 = length(r2091);
    |  float r2093 = r2092-r19;
    |  bool r2094 = r2093<=r24;
    |  bool r2095 = r2093<=r2080;
    |  bool r2096 =(r2094 || r2095);
    |  float r2097 = r0.x;
    |  float r2098 = r53.x;
    |  float r2099 = r2097-r2098;
    |  float r2100 = r0.y;
    |  float r2101 = r53.y;
    |  float r2102 = r2100-r2101;
    |  float r2103 = r0.z;
    |  float r2104 = r53.z;
    |  float r2105 = r2103-r2104;
    |  float r2106 = r0.w;
    |  vec4 r2107 = vec4(r2099,r2102,r2105,r2106);
    |  float r2108 = r0.x;
    |  float r2109 = r3.x;
    |  float r2110 = r2108-r2109;
    |  float r2111 = r0.y;
    |  float r2112 = r3.y;
    |  float r2113 = r2111-r2112;
    |  float r2114 = r0.z;
    |  float r2115 = r3.z;
    |  float r2116 = r2114-r2115;
    |  float r2117 = r0.w;
    |  vec3 r2118 = vec3(r2110,r2113,r2116);
    |  float r2119 = length(r2118);
    |  float r2120 = r2119-r15;
    |  bool r2121 =(r1 == r1);
    |  float r2122 = r2120-r1;
    |  float r2123 = r19*r2122;
    |  float r2124 = r2123/r17;
    |  float r2125 = r19+r2124;
    |  float r2126 = max(r2125,r24);
    |  float r2127 = min(r2126,r25);
    |  float r2128 = r25-r2127;
    |  float r2129 = r2120*r2128;
    |  float r2130 = r1*r2127;
    |  float r2131 = r2129+r2130;
    |  float r2132 = r17*r2127;
    |  float r2133 = r25-r2127;
    |  float r2134 = r2132*r2133;
    |  float r2135 = r2131-r2134;
    |  float r2136 =(r2121 ? r2120 : r2135);
    |  float r2137 = r0.x;
    |  float r2138 = r38.x;
    |  float r2139 = r2137-r2138;
    |  float r2140 = r0.y;
    |  float r2141 = r38.y;
    |  float r2142 = r2140-r2141;
    |  float r2143 = r0.z;
    |  float r2144 = r38.z;
    |  float r2145 = r2143-r2144;
    |  float r2146 = r0.w;
    |  vec3 r2147 = vec3(r2139,r2142,r2145);
    |  float r2148 = length(r2147);
    |  float r2149 = r2148-r19;
    |  bool r2150 = r2149<=r24;
    |  bool r2151 = r2149<=r2136;
    |  bool r2152 =(r2150 || r2151);
    |  float r2153 = r0.x;
    |  float r2154 = r38.x;
    |  float r2155 = r2153-r2154;
    |  float r2156 = r0.y;
    |  float r2157 = r38.y;
    |  float r2158 = r2156-r2157;
    |  float r2159 = r0.z;
    |  float r2160 = r38.z;
    |  float r2161 = r2159-r2160;
    |  float r2162 = r0.w;
    |  vec4 r2163 = vec4(r2155,r2158,r2161,r2162);
    |  float r2164 = r0.x;
    |  float r2165 = r3.x;
    |  float r2166 = r2164-r2165;
    |  float r2167 = r0.y;
    |  float r2168 = r3.y;
    |  float r2169 = r2167-r2168;
    |  float r2170 = r0.z;
    |  float r2171 = r3.z;
    |  float r2172 = r2170-r2171;
    |  float r2173 = r0.w;
    |  vec3 r2174 = vec3(r2166,r2169,r2172);
    |  float r2175 = length(r2174);
    |  float r2176 = r2175-r15;
    |  bool r2177 = r2176<=r24;
    |  bool r2178 = r2176<=r1;
    |  bool r2179 =(r2177 || r2178);
    |  float r2180 = r0.x;
    |  float r2181 = r3.x;
    |  float r2182 = r2180-r2181;
    |  float r2183 = r0.y;
    |  float r2184 = r3.y;
    |  float r2185 = r2183-r2184;
    |  float r2186 = r0.z;
    |  float r2187 = r3.z;
    |  float r2188 = r2186-r2187;
    |  float r2189 = r0.w;
    |  vec4 r2190 = vec4(r2182,r2185,r2188,r2189);
    |  vec3 r2191 =(r2179 ? r450 : r450);
    |  vec3 r2192 =(r2152 ? r450 : r2191);
    |  vec3 r2193 =(r2096 ? r450 : r2192);
    |  vec3 r2194 =(r2026 ? r450 : r2193);
    |  vec3 r2195 =(r1910 ? r450 : r2194);
    |  vec3 r2196 =(r1765 ? r450 : r2195);
    |  vec3 r2197 =(r1591 ? r450 : r2196);
    |  vec3 r2198 =(r1403 ? r450 : r2197);
    |  vec3 r2199 =(r1160 ? r450 : r2198);
    |  vec3 r2200 =(r830 ? r450 : r2199);
    |  vec3 r2201 =(r434 ? r450 : r2200);
    |  return r2201;
    |}
    |const vec3 bbox_min = vec3(-21.3125,-7.625,-15.4375);
    |const vec3 bbox_max = vec3(20.875,47.4375,15.4375);
    |// ray marching. ro is ray origin, rd is ray direction (unit vector).
    |// result is (t,r,g,b), where
    |//  * t is the distance that we marched,
    |//  * r,g,b is the colour of the distance field at the point we ended up at.
    |//    (-1,-1,-1) means no object was hit.
    |vec4 castRay( in vec3 ro, in vec3 rd, float time )
    |{
    |    float tmin = 0.0;
    |    float tmax = ray_max_depth;
    |
    |    float t = tmin;
    |    vec3 c = vec3(-1.0,-1.0,-1.0);
    |    for (int i=0; i<ray_max_iter; i++) {
    |        float precis = 0.0005*t;
    |        vec4 p = vec4(ro+rd*t,time);
    |        float d = dist(p);
    |        if (abs(d) < abs(precis)) {
    |            c = colour(p);
    |            break;
    |        }
    |        t += d;
    |        if (t > tmax) break;
    |    }
    |    return vec4( t, c );
    |}
    |vec3 calcNormal( in vec3 pos, float time )
    |{
    |    vec2 e = vec2(1.0,-1.0)*0.5773*0.0005;
    |    return normalize( e.xyy*dist( vec4(pos + e.xyy,time) ) +
    |                      e.yyx*dist( vec4(pos + e.yyx,time) ) +
    |                      e.yxy*dist( vec4(pos + e.yxy,time) ) +
    |                      e.xxx*dist( vec4(pos + e.xxx,time) ) );
    |}
    |float calcAO( in vec3 pos, in vec3 nor, float time )
    |{
    |    float occ = 0.0;
    |    float sca = 1.0;
    |    for( int i=0; i<5; i++ )
    |    {
    |        float hr = 0.01 + 0.12*float(i)/4.0;
    |        vec3 aopos =  nor * hr + pos;
    |        float dd = dist( vec4(aopos,time) );
    |        occ += -(dd-hr)*sca;
    |        sca *= 0.95;
    |    }
    |    return clamp( 1.0 - 3.0*occ, 0.0, 1.0 );
    |}
    |// in ro: ray origin
    |// in rd: ray direction
    |// out: rgb colour
    |vec3 render( in vec3 ro, in vec3 rd, float time )
    |{
    |    //vec3 col = vec3(0.7, 0.9, 1.0) +rd.z*0.8;
    |    vec3 col = background_colour;
    |    vec4 res = castRay(ro,rd, time);
    |    float t = res.x;
    |    vec3 c = res.yzw;
    |    if( c.x>=0.0 )
    |    {
    |        vec3 pos = ro + t*rd;
    |        vec3 nor = calcNormal( pos, time );
    |        vec3 ref = reflect( rd, nor );
    |
    |        // material
    |        col = c;
    |
    |        // lighting
    |        float occ = calcAO( pos, nor, time );
    |        vec3  lig = normalize( vec3(-0.4, 0.6, 0.7) );
    |        float amb = clamp( 0.5+0.5*nor.z, 0.0, 1.0 );
    |        float dif = clamp( dot( nor, lig ), 0.0, 1.0 );
    |        float bac = clamp( dot( nor, normalize(vec3(-lig.x,lig.y,0.0))), 0.0, 1.0 )*clamp( 1.0-pos.z,0.0,1.0);
    |        float dom = smoothstep( -0.1, 0.1, ref.z );
    |        float fre = pow( clamp(1.0+dot(nor,rd),0.0,1.0), 2.0 );
    |        float spe = pow(clamp( dot( ref, lig ), 0.0, 1.0 ),16.0);
    |
    |        vec3 lin = vec3(0.0);
    |        lin += 1.30*dif*vec3(1.00,0.80,0.55);
    |        lin += 2.00*spe*vec3(1.00,0.90,0.70)*dif;
    |        lin += 0.40*amb*vec3(0.40,0.60,1.00)*occ;
    |        lin += 0.50*dom*vec3(0.40,0.60,1.00)*occ;
    |        lin += 0.50*bac*vec3(0.35,0.35,0.35)*occ;
    |        lin += 0.25*fre*vec3(1.00,1.00,1.00)*occ;
    |        vec3 iqcol = col*lin;
    |
    |        //col = mix( col, vec3(0.8,0.9,1.0), 1.0-exp( -0.0002*t*t*t ) );
    |        col = mix(col,iqcol, 0.5);
    |    }
    |
    |    return vec3( clamp(col,0.0,1.0) );
    |}
    |// Create a matrix to transform coordinates to look towards a given point.
    |// * `eye` is the position of the camera.
    |// * `centre` is the position to look towards.
    |// * `up` is the 'up' direction.
    |mat3 look_at(vec3 eye, vec3 centre, vec3 up)
    |{
    |    vec3 ww = normalize(centre - eye);
    |    vec3 uu = normalize(cross(ww, up));
    |    vec3 vv = normalize(cross(uu, ww));
    |    return mat3(uu, vv, ww);
    |}
    |// Generate a ray direction for ray-casting.
    |// * `camera` is the camera look-at matrix.
    |// * `pos` is the screen position, normally in the range -1..1
    |// * `lens` is the lens length of the camera (encodes field-of-view).
    |//   0 is very wide, and 2 is a good default.
    |vec3 ray_direction(mat3 camera, vec2 pos, float lens)
    |{
    |    return normalize(camera * vec3(pos, lens));
    |}
    |void mainImage( out vec4 fragColour, in vec2 fragCoord )
    |{
    |    vec3 col = vec3(0.0);
    |    const vec3 origin = (bbox_min + bbox_max) / 2.0;
    |    const vec3 radius = (bbox_max - bbox_min) / 2.0;
    |    float r = max(radius.x, max(radius.y, radius.z)) / 1.3;
    |#if AA>1
    |  for (int m=0; m<AA; ++m)
    |  for (int n=0; n<AA; ++n) {
    |    vec2 o = vec2(float(m),float(n)) / float(AA) - 0.5;
    |#else
    |    const vec2 o = vec2(0.0);
    |#endif
    |    vec2 p = -1.0 + 2.0 * (fragCoord+o) / iResolution.xy;
    |    p.x *= iResolution.x/iResolution.y;
    |
    |#ifdef GLSLVIEWER
    |    vec3 eye = vec3(u_eye3d.x, -u_eye3d.z, u_eye3d.y)*r + origin;
    |    vec3 centre = vec3(u_centre3d.x, -u_centre3d.z, u_centre3d.y)*r + origin;
    |    vec3 up = vec3(u_up3d.x, -u_up3d.z, u_up3d.y);
    |#else
    |    vec3 eye = vec3(2.6, -4.5, 3.0);
    |    vec3 centre = vec3(0.0, 0.0, 0.0);
    |    vec3 up = vec3(-0.25, 0.433, 0.866);
    |#endif
    |    mat3 camera = look_at(eye, centre, up);
    |    vec3 dir = ray_direction(camera, p, 2.5);
    |
    |#if TAA>1
    |  for (int t=0; t<TAA; ++t) {
    |    float time = iTime + float(t)/float(TAA)*float(FDUR);
    |#else
    |    float time = iTime;
    |#endif
    |    col += render( eye, dir, time );
    |
    |#if TAA>1
    |  }
    |#endif
    |#if AA>1
    |  }
    |#endif
    |#if AA>1 || TAA>1
    |    col /= float(AA*AA*TAA);
    |#endif
    |
    |    // convert linear RGB to sRGB
    |    col = pow(col, vec3(0.454545454545454545));
    |    fragColour = vec4(col,1.0);
    |}
    ";
  parameters: [
    {name: "rv_smoothness", type: "float", value: 1.75, label: "smoothness", config: {slider:[0.01,5]}};
  ];
}