#version 450
layout(location = 0) out vec4 out0;
layout(std140) uniform uBlock4 {
float u0;
} u4;
layout(std140) uniform uBlock6 {
float u0;
} u6;
layout(std140) uniform uBlock8 {
float u0;
} u8;
in float vf0;
in float vf1;
in float vf2;
void main() {
float t0 = (0*0);
float t1 = (1-0);
float t2 = (float(0.7)*t1);
float t3 = (t0+t2);
float t4 = (vf0*vf0);
float t5 = (vf2*vf2);
float t6 = (t4+t5);
float t7 = sqrt(t6);
float t8 = atan(t7,vf1);
float t9 = (3.1415927/2);
float t10 = (t8-t9);
float t11 = (float(22.4)/180);
float t12 = (t11*3.1415927);
float t13 = (t12/2);
float t14 = sin(t13);
float t15 = sin(t12);
float t16 = (1*t15);
float t17 = cos(0);
float t18 = (t16*t17);
float t19 = (t18*0);
float t20 = sin(t12);
float t21 = (1*t20);
float t22 = sin(0);
float t23 = (t21*t22);
float t24 = (t23*0);
float t25 = (t19-t24);
float t26 = cos(t12);
float t27 = (1*t26);
float t28 = (t27*0);
float t29 = (t18*1);
float t30 = (t28-t29);
float t31 = (t30*t30);
float t32 = (t25*t25);
float t33 = (t31+t32);
float t34 = (t23*1);
float t35 = (t27*0);
float t36 = (t34-t35);
float t37 = (t36*t36);
float t38 = (t33+t37);
float t39 = sqrt(t38);
float t40 = (t25/t39);
float t41 = (t14*t40);
float t42 = (t41*t41);
float t43 = (t36/t39);
float t44 = (t14*t43);
float t45 = (t44*t44);
float t46 = (t42+t45);
float t47 = (2*t46);
float t48 = (1-t47);
float t49 = (float(27.4)*840);
float t50 = (u4.u0/t49);
float t51 = (t50*3.1415927);
float t52 = (t51*2);
float t53 = sin(t52);
float t54 = (t53*float(2.5e-3));
float t55 = (t48*t54);
float t56 = (t30/t39);
float t57 = (t14*t56);
float t58 = (t57*t41);
float t59 = cos(t13);
float t60 = (t44*t59);
float t61 = (t58-t60);
float t62 = (2*t61);
float t63 = (t62*0);
float t64 = (t55+t63);
float t65 = (t57*t44);
float t66 = (t41*t59);
float t67 = (t65+t66);
float t68 = (2*t67);
float t69 = (u4.u0/t49);
float t70 = (t69*3.1415927);
float t71 = (t70*2);
float t72 = cos(t71);
float t73 = (t72*float(2.5e-3));
float t74 = (t68*t73);
float t75 = (t64+t74);
float t76 = (t75*t75);
float t77 = (t65-t66);
float t78 = (2*t77);
float t79 = (t78*t54);
float t80 = (t41*t44);
float t81 = (t57*t59);
float t82 = (t80+t81);
float t83 = (2*t82);
float t84 = (t83*0);
float t85 = (t79+t84);
float t86 = (t57*t57);
float t87 = (t86+t42);
float t88 = (2*t87);
float t89 = (1-t88);
float t90 = (t89*t73);
float t91 = (t85+t90);
float t92 = (t91*t91);
float t93 = (t76+t92);
float t94 = sqrt(t93);
float t95 = (t58+t60);
float t96 = (2*t95);
float t97 = (t96*t54);
float t98 = (t86+t45);
float t99 = (2*t98);
float t100 = (1-t99);
float t101 = (t100*0);
float t102 = (t97+t101);
float t103 = (t80-t81);
float t104 = (2*t103);
float t105 = (t104*t73);
float t106 = (t102+t105);
float t107 = atan(t94,t106);
float t108 = (3.1415927/2);
float t109 = (t107-t108);
float t110 = (t10-t109);
float t111 = abs(t110);
float t112 = (t111/2);
float t113 = sin(t112);
float t114 = (t113*t113);
float t115 = cos(t109);
float t116 = cos(t10);
float t117 = (t115*t116);
float t118 = atan(vf0,vf2);
float t119 = (t118+3.1415927);
float t120 = (3.1415927*2);
float t121 = mod(t119,t120);
float t122 = (t121-3.1415927);
float t123 = atan(t75,t91);
float t124 = (t123+3.1415927);
float t125 = (3.1415927*2);
float t126 = mod(t124,t125);
float t127 = (t126-3.1415927);
float t128 = (t122-t127);
float t129 = abs(t128);
float t130 = (t129/2);
float t131 = sin(t130);
float t132 = (t131*t131);
float t133 = (t117*t132);
float t134 = (t114+t133);
float t135 = sqrt(t134);
float t136 = asin(t135);
float t137 = (2*t136);
float t138 = (t75*t75);
float t139 = (t106*t106);
float t140 = (t138+t139);
float t141 = (t91*t91);
float t142 = (t140+t141);
float t143 = sqrt(t142);
float t144 = (t143*float(1.4959787e8));
float t145 = (2*t144);
float t146 = (float(3474.4)/t145);
float t147 = asin(t146);
float t148 = (2*t147);
float t149 = (t148*4);
float t150 = (t137/t149);
float t151 = smoothstep(float(0.95),1,t150);
float t152 = (1-t151);
float t153 = (1-t152);
float t154 = (t153*0);
float t155 = (t152+t154);
float t156 = (t3*t155);
float t157 = (t12/2);
float t158 = sin(t157);
float t159 = sin(t12);
float t160 = (1*t159);
float t161 = cos(0);
float t162 = (t160*t161);
float t163 = (t162*0);
float t164 = sin(t12);
float t165 = (1*t164);
float t166 = sin(0);
float t167 = (t165*t166);
float t168 = (t167*0);
float t169 = (t163-t168);
float t170 = cos(t12);
float t171 = (1*t170);
float t172 = (t171*0);
float t173 = (t162*1);
float t174 = (t172-t173);
float t175 = (t174*t174);
float t176 = (t169*t169);
float t177 = (t175+t176);
float t178 = (t167*1);
float t179 = (t171*0);
float t180 = (t178-t179);
float t181 = (t180*t180);
float t182 = (t177+t181);
float t183 = sqrt(t182);
float t184 = (t169/t183);
float t185 = (t158*t184);
float t186 = (t185*t185);
float t187 = (t180/t183);
float t188 = (t158*t187);
float t189 = (t188*t188);
float t190 = (t186+t189);
float t191 = (2*t190);
float t192 = (1-t191);
float t193 = (365*840);
float t194 = (u4.u0/t193);
float t195 = (t194*3.1415927);
float t196 = (t195*2);
float t197 = sin(t196);
float t198 = (t197*1);
float t199 = (-1);
float t200 = (t198*t199);
float t201 = (t192*t200);
float t202 = (t174/t183);
float t203 = (t158*t202);
float t204 = (t203*t185);
float t205 = cos(t157);
float t206 = (t188*t205);
float t207 = (t204-t206);
float t208 = (2*t207);
float t209 = (t208*0);
float t210 = (t201+t209);
float t211 = (t203*t188);
float t212 = (t185*t205);
float t213 = (t211+t212);
float t214 = (2*t213);
float t215 = (u4.u0/t193);
float t216 = (t215*3.1415927);
float t217 = (t216*2);
float t218 = cos(t217);
float t219 = (t218*1);
float t220 = (t219*t199);
float t221 = (t214*t220);
float t222 = (t210+t221);
float t223 = (t222*t222);
float t224 = (t211-t212);
float t225 = (2*t224);
float t226 = (t225*t200);
float t227 = (t185*t188);
float t228 = (t203*t205);
float t229 = (t227+t228);
float t230 = (2*t229);
float t231 = (t230*0);
float t232 = (t226+t231);
float t233 = (t203*t203);
float t234 = (t233+t186);
float t235 = (2*t234);
float t236 = (1-t235);
float t237 = (t236*t220);
float t238 = (t232+t237);
float t239 = (t238*t238);
float t240 = (t223+t239);
float t241 = sqrt(t240);
float t242 = (t204+t206);
float t243 = (2*t242);
float t244 = (t243*t200);
float t245 = (t233+t189);
float t246 = (2*t245);
float t247 = (1-t246);
float t248 = (t247*0);
float t249 = (t244+t248);
float t250 = (t227-t228);
float t251 = (2*t250);
float t252 = (t251*t220);
float t253 = (t249+t252);
float t254 = atan(t241,t253);
float t255 = (3.1415927/2);
float t256 = (t254-t255);
vec4 t257 = vec4(0,1,0,0);
float t258 = mod(u4.u0,840);
float t259 = (t258/840);
float t260 = (t259*3.1415927);
float t261 = (t260*2);
float t262 = (t261/2);
float t263 = sin(t262);
float t264 = (0*0);
float t265 = (1*1);
float t266 = (t264+t265);
float t267 = (0*0);
float t268 = (t266+t267);
float t269 = sqrt(t268);
float t270 = (1/t269);
float t271 = (t263*t270);
float t272 = (t271*t271);
float t273 = (0/t269);
float t274 = (t263*t273);
float t275 = (t274*t274);
float t276 = (t272+t275);
float t277 = (2*t276);
float t278 = (1-t277);
float t279 = (3.1415927/4);
float t280 = (t279/2);
float t281 = sin(t280);
float t282 = sin(t279);
float t283 = (1*t282);
float t284 = cos(0);
float t285 = (t283*t284);
float t286 = (t285*0);
float t287 = sin(t279);
float t288 = (1*t287);
float t289 = sin(0);
float t290 = (t288*t289);
float t291 = (t290*0);
float t292 = (t286-t291);
float t293 = cos(t279);
float t294 = (1*t293);
float t295 = (t294*0);
float t296 = (t285*1);
float t297 = (t295-t296);
float t298 = (t297*t297);
float t299 = (t292*t292);
float t300 = (t298+t299);
float t301 = (t290*1);
float t302 = (t294*0);
float t303 = (t301-t302);
float t304 = (t303*t303);
float t305 = (t300+t304);
float t306 = sqrt(t305);
float t307 = (t292/t306);
float t308 = (t281*t307);
float t309 = (t308*t308);
float t310 = (t303/t306);
float t311 = (t281*t310);
float t312 = (t311*t311);
float t313 = (t309+t312);
float t314 = (2*t313);
float t315 = (1-t314);
float t316 = (t278*t315);
float t317 = (0+t316);
float t318 = (0/t269);
float t319 = (t263*t318);
float t320 = (t319*t271);
float t321 = cos(t262);
float t322 = (t274*t321);
float t323 = (t320-t322);
float t324 = (2*t323);
float t325 = (t297/t306);
float t326 = (t281*t325);
float t327 = (t326*t308);
float t328 = cos(t280);
float t329 = (t311*t328);
float t330 = (t327+t329);
float t331 = (2*t330);
float t332 = (t324*t331);
float t333 = (t317+t332);
float t334 = (t319*t274);
float t335 = (t271*t321);
float t336 = (t334+t335);
float t337 = (2*t336);
float t338 = (t326*t311);
float t339 = (t308*t328);
float t340 = (t338-t339);
float t341 = (2*t340);
float t342 = (t337*t341);
float t343 = (t333+t342);
float t344 = (t327-t329);
float t345 = (2*t344);
float t346 = (t278*t345);
float t347 = (0+t346);
float t348 = (t326*t326);
float t349 = (t348+t312);
float t350 = (2*t349);
float t351 = (1-t350);
float t352 = (t324*t351);
float t353 = (t347+t352);
float t354 = (t308*t311);
float t355 = (t326*t328);
float t356 = (t354+t355);
float t357 = (2*t356);
float t358 = (t337*t357);
float t359 = (t353+t358);
float t360 = (t338+t339);
float t361 = (2*t360);
float t362 = (t278*t361);
float t363 = (0+t362);
float t364 = (t354-t355);
float t365 = (2*t364);
float t366 = (t324*t365);
float t367 = (t363+t366);
float t368 = (t348+t309);
float t369 = (2*t368);
float t370 = (1-t369);
float t371 = (t337*t370);
float t372 = (t367+t371);
vec4 t373 = vec4(t343,t359,t372,0);
float t374 = (t320+t322);
float t375 = (2*t374);
float t376 = (t375*t315);
float t377 = (0+t376);
float t378 = (t319*t319);
float t379 = (t378+t275);
float t380 = (2*t379);
float t381 = (1-t380);
float t382 = (t381*t331);
float t383 = (t377+t382);
float t384 = (t271*t274);
float t385 = (t319*t321);
float t386 = (t384-t385);
float t387 = (2*t386);
float t388 = (t387*t341);
float t389 = (t383+t388);
float t390 = (t375*t345);
float t391 = (0+t390);
float t392 = (t381*t351);
float t393 = (t391+t392);
float t394 = (t387*t357);
float t395 = (t393+t394);
float t396 = (t375*t361);
float t397 = (0+t396);
float t398 = (t381*t365);
float t399 = (t397+t398);
float t400 = (t387*t370);
float t401 = (t399+t400);
vec4 t402 = vec4(t389,t395,t401,0);
float t403 = (t334-t335);
float t404 = (2*t403);
float t405 = (t404*t315);
float t406 = (0+t405);
float t407 = (t384+t385);
float t408 = (2*t407);
float t409 = (t408*t331);
float t410 = (t406+t409);
float t411 = (t378+t272);
float t412 = (2*t411);
float t413 = (1-t412);
float t414 = (t413*t341);
float t415 = (t410+t414);
float t416 = (t404*t345);
float t417 = (0+t416);
float t418 = (t408*t351);
float t419 = (t417+t418);
float t420 = (t413*t357);
float t421 = (t419+t420);
float t422 = (t404*t361);
float t423 = (0+t422);
float t424 = (t408*t365);
float t425 = (t423+t424);
float t426 = (t413*t370);
float t427 = (t425+t426);
vec4 t428 = vec4(t415,t421,t427,0);
vec4 t429 = vec4(0,0,0,1);
mat4x4 t430 = mat4x4(t373,t402,t428,t429);
vec4 t431 = (t257*t430);
float t432 = (t431[0]*t431[0]);
float t433 = (t431[2]*t431[2]);
float t434 = (t432+t433);
float t435 = sqrt(t434);
float t436 = atan(t435,t431[1]);
float t437 = (3.1415927/2);
float t438 = (t436-t437);
float t439 = (t256-t438);
float t440 = abs(t439);
float t441 = (t440/2);
float t442 = sin(t441);
float t443 = (t442*t442);
float t444 = cos(t438);
float t445 = cos(t256);
float t446 = (t444*t445);
float t447 = atan(t222,t238);
float t448 = (t447+3.1415927);
float t449 = (3.1415927*2);
float t450 = mod(t448,t449);
float t451 = (t450-3.1415927);
float t452 = atan(t431[0],t431[2]);
float t453 = (t452+3.1415927);
float t454 = (3.1415927*2);
float t455 = mod(t453,t454);
float t456 = (t455-3.1415927);
float t457 = (t451-t456);
float t458 = abs(t457);
float t459 = (t458/2);
float t460 = sin(t459);
float t461 = (t460*t460);
float t462 = (t446*t461);
float t463 = (t443+t462);
float t464 = sqrt(t463);
float t465 = asin(t464);
float t466 = (2*t465);
float t467 = (3.1415927-t466);
float t468 = (t467/3.1415927);
float t469 = smoothstep(float(0.48),float(0.59),t468);
float t470 = (float(0.0)*t469);
float t471 = (float(1.0)+t470);
float t472 = (1-t155);
float t473 = (t471*t472);
float t474 = (t156+t473);
float t475 = (3.1415927/2);
float t476 = (t8-t475);
float t477 = (3.1415927/2);
float t478 = (t254-t477);
float t479 = (t476-t478);
float t480 = abs(t479);
float t481 = (t480/2);
float t482 = sin(t481);
float t483 = (t482*t482);
float t484 = cos(t478);
float t485 = cos(t476);
float t486 = (t484*t485);
float t487 = (t118+3.1415927);
float t488 = (3.1415927*2);
float t489 = mod(t487,t488);
float t490 = (t489-3.1415927);
float t491 = (t447+3.1415927);
float t492 = (3.1415927*2);
float t493 = mod(t491,t492);
float t494 = (t493-3.1415927);
float t495 = (t490-t494);
float t496 = abs(t495);
float t497 = (t496/2);
float t498 = sin(t497);
float t499 = (t498*t498);
float t500 = (t486*t499);
float t501 = (t483+t500);
float t502 = sqrt(t501);
float t503 = asin(t502);
float t504 = (2*t503);
float t505 = (t222*t222);
float t506 = (t253*t253);
float t507 = (t505+t506);
float t508 = (t238*t238);
float t509 = (t507+t508);
float t510 = sqrt(t509);
float t511 = (t510*float(1.4959787e8));
float t512 = (2*t511);
float t513 = (1392684/t512);
float t514 = asin(t513);
float t515 = (2*t514);
float t516 = (t515*4);
float t517 = (t504/t516);
float t518 = smoothstep(float(0.95),1,t517);
float t519 = (1-t518);
float t520 = (float(0.0)*t469);
float t521 = (t519+t520);
float t522 = (1-t521);
float t523 = (t522*t155);
float t524 = (t521+t523);
float t525 = (t474*t524);
float t526 = (3.1415927/2);
float t527 = (t8-t526);
float t528 = (t12/2);
float t529 = sin(t528);
float t530 = sin(t12);
float t531 = (1*t530);
float t532 = cos(0);
float t533 = (t531*t532);
float t534 = (t533*0);
float t535 = sin(t12);
float t536 = (1*t535);
float t537 = sin(0);
float t538 = (t536*t537);
float t539 = (t538*0);
float t540 = (t534-t539);
float t541 = cos(t12);
float t542 = (1*t541);
float t543 = (t542*0);
float t544 = (t533*1);
float t545 = (t543-t544);
float t546 = (t545*t545);
float t547 = (t540*t540);
float t548 = (t546+t547);
float t549 = (t538*1);
float t550 = (t542*0);
float t551 = (t549-t550);
float t552 = (t551*t551);
float t553 = (t548+t552);
float t554 = sqrt(t553);
float t555 = (t540/t554);
float t556 = (t529*t555);
float t557 = (t556*t556);
float t558 = (t551/t554);
float t559 = (t529*t558);
float t560 = (t559*t559);
float t561 = (t557+t560);
float t562 = (2*t561);
float t563 = (1-t562);
float t564 = (float(686.971)*840);
float t565 = (u4.u0/t564);
float t566 = (t565*3.1415927);
float t567 = (t566*2);
float t568 = sin(t567);
float t569 = (t568*float(1.5));
float t570 = (u4.u0/t193);
float t571 = (t570*3.1415927);
float t572 = (t571*2);
float t573 = sin(t572);
float t574 = (t573*1);
float t575 = (t569-t574);
float t576 = (t563*t575);
float t577 = (t545/t554);
float t578 = (t529*t577);
float t579 = (t578*t556);
float t580 = cos(t528);
float t581 = (t559*t580);
float t582 = (t579-t581);
float t583 = (2*t582);
float t584 = (t583*0);
float t585 = (t576+t584);
float t586 = (t578*t559);
float t587 = (t556*t580);
float t588 = (t586+t587);
float t589 = (2*t588);
float t590 = (u4.u0/t564);
float t591 = (t590*3.1415927);
float t592 = (t591*2);
float t593 = cos(t592);
float t594 = (t593*float(1.5));
float t595 = (u4.u0/t193);
float t596 = (t595*3.1415927);
float t597 = (t596*2);
float t598 = cos(t597);
float t599 = (t598*1);
float t600 = (t594-t599);
float t601 = (t589*t600);
float t602 = (t585+t601);
float t603 = (t602*t602);
float t604 = (t586-t587);
float t605 = (2*t604);
float t606 = (t605*t575);
float t607 = (t556*t559);
float t608 = (t578*t580);
float t609 = (t607+t608);
float t610 = (2*t609);
float t611 = (t610*0);
float t612 = (t606+t611);
float t613 = (t578*t578);
float t614 = (t613+t557);
float t615 = (2*t614);
float t616 = (1-t615);
float t617 = (t616*t600);
float t618 = (t612+t617);
float t619 = (t618*t618);
float t620 = (t603+t619);
float t621 = sqrt(t620);
float t622 = (t579+t581);
float t623 = (2*t622);
float t624 = (t623*t575);
float t625 = (t613+t560);
float t626 = (2*t625);
float t627 = (1-t626);
float t628 = (t627*0);
float t629 = (t624+t628);
float t630 = (t607-t608);
float t631 = (2*t630);
float t632 = (t631*t600);
float t633 = (t629+t632);
float t634 = atan(t621,t633);
float t635 = (3.1415927/2);
float t636 = (t634-t635);
float t637 = (t527-t636);
float t638 = abs(t637);
float t639 = (t638/2);
float t640 = sin(t639);
float t641 = (t640*t640);
float t642 = cos(t636);
float t643 = cos(t527);
float t644 = (t642*t643);
float t645 = (t118+3.1415927);
float t646 = (3.1415927*2);
float t647 = mod(t645,t646);
float t648 = (t647-3.1415927);
float t649 = atan(t602,t618);
float t650 = (t649+3.1415927);
float t651 = (3.1415927*2);
float t652 = mod(t650,t651);
float t653 = (t652-3.1415927);
float t654 = (t648-t653);
float t655 = abs(t654);
float t656 = (t655/2);
float t657 = sin(t656);
float t658 = (t657*t657);
float t659 = (t644*t658);
float t660 = (t641+t659);
float t661 = sqrt(t660);
float t662 = asin(t661);
float t663 = (2*t662);
float t664 = (t602*t602);
float t665 = (t633*t633);
float t666 = (t664+t665);
float t667 = (t618*t618);
float t668 = (t666+t667);
float t669 = sqrt(t668);
float t670 = (t669*float(1.4959787e8));
float t671 = (2*t670);
float t672 = (6780/t671);
float t673 = asin(t672);
float t674 = (2*t673);
float t675 = (t674*4);
float t676 = (t663/t675);
float t677 = step(1,t676);
float t678 = (1-t677);
float t679 = (float(1.0)*t678);
float t680 = (1-t524);
float t681 = (t679*t680);
float t682 = (t525+t681);
float t683 = (1-t679);
float t684 = (t683*t524);
float t685 = (t679+t684);
float t686 = (t682*t685);
float t687 = (3.1415927/2);
float t688 = (t8-t687);
float t689 = (t12/2);
float t690 = sin(t689);
float t691 = sin(t12);
float t692 = (1*t691);
float t693 = cos(0);
float t694 = (t692*t693);
float t695 = (t694*0);
float t696 = sin(t12);
float t697 = (1*t696);
float t698 = sin(0);
float t699 = (t697*t698);
float t700 = (t699*0);
float t701 = (t695-t700);
float t702 = cos(t12);
float t703 = (1*t702);
float t704 = (t703*0);
float t705 = (t694*1);
float t706 = (t704-t705);
float t707 = (t706*t706);
float t708 = (t701*t701);
float t709 = (t707+t708);
float t710 = (t699*1);
float t711 = (t703*0);
float t712 = (t710-t711);
float t713 = (t712*t712);
float t714 = (t709+t713);
float t715 = sqrt(t714);
float t716 = (t701/t715);
float t717 = (t690*t716);
float t718 = (t717*t717);
float t719 = (t712/t715);
float t720 = (t690*t719);
float t721 = (t720*t720);
float t722 = (t718+t721);
float t723 = (2*t722);
float t724 = (1-t723);
float t725 = (float(224.7)*840);
float t726 = (u4.u0/t725);
float t727 = (t726*3.1415927);
float t728 = (t727*2);
float t729 = sin(t728);
float t730 = (t729*float(0.7205));
float t731 = (u4.u0/t193);
float t732 = (t731*3.1415927);
float t733 = (t732*2);
float t734 = sin(t733);
float t735 = (t734*1);
float t736 = (t730-t735);
float t737 = (t724*t736);
float t738 = (t706/t715);
float t739 = (t690*t738);
float t740 = (t739*t717);
float t741 = cos(t689);
float t742 = (t720*t741);
float t743 = (t740-t742);
float t744 = (2*t743);
float t745 = (t744*0);
float t746 = (t737+t745);
float t747 = (t739*t720);
float t748 = (t717*t741);
float t749 = (t747+t748);
float t750 = (2*t749);
float t751 = (u4.u0/t725);
float t752 = (t751*3.1415927);
float t753 = (t752*2);
float t754 = cos(t753);
float t755 = (t754*float(0.7205));
float t756 = (u4.u0/t193);
float t757 = (t756*3.1415927);
float t758 = (t757*2);
float t759 = cos(t758);
float t760 = (t759*1);
float t761 = (t755-t760);
float t762 = (t750*t761);
float t763 = (t746+t762);
float t764 = (t763*t763);
float t765 = (t747-t748);
float t766 = (2*t765);
float t767 = (t766*t736);
float t768 = (t717*t720);
float t769 = (t739*t741);
float t770 = (t768+t769);
float t771 = (2*t770);
float t772 = (t771*0);
float t773 = (t767+t772);
float t774 = (t739*t739);
float t775 = (t774+t718);
float t776 = (2*t775);
float t777 = (1-t776);
float t778 = (t777*t761);
float t779 = (t773+t778);
float t780 = (t779*t779);
float t781 = (t764+t780);
float t782 = sqrt(t781);
float t783 = (t740+t742);
float t784 = (2*t783);
float t785 = (t784*t736);
float t786 = (t774+t721);
float t787 = (2*t786);
float t788 = (1-t787);
float t789 = (t788*0);
float t790 = (t785+t789);
float t791 = (t768-t769);
float t792 = (2*t791);
float t793 = (t792*t761);
float t794 = (t790+t793);
float t795 = atan(t782,t794);
float t796 = (3.1415927/2);
float t797 = (t795-t796);
float t798 = (t688-t797);
float t799 = abs(t798);
float t800 = (t799/2);
float t801 = sin(t800);
float t802 = (t801*t801);
float t803 = cos(t797);
float t804 = cos(t688);
float t805 = (t803*t804);
float t806 = (t118+3.1415927);
float t807 = (3.1415927*2);
float t808 = mod(t806,t807);
float t809 = (t808-3.1415927);
float t810 = atan(t763,t779);
float t811 = (t810+3.1415927);
float t812 = (3.1415927*2);
float t813 = mod(t811,t812);
float t814 = (t813-3.1415927);
float t815 = (t809-t814);
float t816 = abs(t815);
float t817 = (t816/2);
float t818 = sin(t817);
float t819 = (t818*t818);
float t820 = (t805*t819);
float t821 = (t802+t820);
float t822 = sqrt(t821);
float t823 = asin(t822);
float t824 = (2*t823);
float t825 = (t763*t763);
float t826 = (t794*t794);
float t827 = (t825+t826);
float t828 = (t779*t779);
float t829 = (t827+t828);
float t830 = sqrt(t829);
float t831 = (t830*float(1.4959787e8));
float t832 = (2*t831);
float t833 = (float(12103.6)/t832);
float t834 = asin(t833);
float t835 = (2*t834);
float t836 = (t835*4);
float t837 = (t824/t836);
float t838 = step(1,t837);
float t839 = (1-t838);
float t840 = (float(1.0)*t839);
float t841 = (1-t685);
float t842 = (t840*t841);
float t843 = (t686+t842);
float t844 = (1-t840);
float t845 = (t844*t685);
float t846 = (t840+t845);
float t847 = (t843*t846);
float t848 = (3.1415927/2);
float t849 = (t8-t848);
float t850 = (t12/2);
float t851 = sin(t850);
float t852 = sin(t12);
float t853 = (1*t852);
float t854 = cos(0);
float t855 = (t853*t854);
float t856 = (t855*0);
float t857 = sin(t12);
float t858 = (1*t857);
float t859 = sin(0);
float t860 = (t858*t859);
float t861 = (t860*0);
float t862 = (t856-t861);
float t863 = cos(t12);
float t864 = (1*t863);
float t865 = (t864*0);
float t866 = (t855*1);
float t867 = (t865-t866);
float t868 = (t867*t867);
float t869 = (t862*t862);
float t870 = (t868+t869);
float t871 = (t860*1);
float t872 = (t864*0);
float t873 = (t871-t872);
float t874 = (t873*t873);
float t875 = (t870+t874);
float t876 = sqrt(t875);
float t877 = (t862/t876);
float t878 = (t851*t877);
float t879 = (t878*t878);
float t880 = (t873/t876);
float t881 = (t851*t880);
float t882 = (t881*t881);
float t883 = (t879+t882);
float t884 = (2*t883);
float t885 = (1-t884);
float t886 = (float(4332.59)*840);
float t887 = (u4.u0/t886);
float t888 = (t887*3.1415927);
float t889 = (t888*2);
float t890 = sin(t889);
float t891 = (t890*float(5.2));
float t892 = (u4.u0/t193);
float t893 = (t892*3.1415927);
float t894 = (t893*2);
float t895 = sin(t894);
float t896 = (t895*1);
float t897 = (t891-t896);
float t898 = (t885*t897);
float t899 = (t867/t876);
float t900 = (t851*t899);
float t901 = (t900*t878);
float t902 = cos(t850);
float t903 = (t881*t902);
float t904 = (t901-t903);
float t905 = (2*t904);
float t906 = (t905*0);
float t907 = (t898+t906);
float t908 = (t900*t881);
float t909 = (t878*t902);
float t910 = (t908+t909);
float t911 = (2*t910);
float t912 = (u4.u0/t886);
float t913 = (t912*3.1415927);
float t914 = (t913*2);
float t915 = cos(t914);
float t916 = (t915*float(5.2));
float t917 = (u4.u0/t193);
float t918 = (t917*3.1415927);
float t919 = (t918*2);
float t920 = cos(t919);
float t921 = (t920*1);
float t922 = (t916-t921);
float t923 = (t911*t922);
float t924 = (t907+t923);
float t925 = (t924*t924);
float t926 = (t908-t909);
float t927 = (2*t926);
float t928 = (t927*t897);
float t929 = (t878*t881);
float t930 = (t900*t902);
float t931 = (t929+t930);
float t932 = (2*t931);
float t933 = (t932*0);
float t934 = (t928+t933);
float t935 = (t900*t900);
float t936 = (t935+t879);
float t937 = (2*t936);
float t938 = (1-t937);
float t939 = (t938*t922);
float t940 = (t934+t939);
float t941 = (t940*t940);
float t942 = (t925+t941);
float t943 = sqrt(t942);
float t944 = (t901+t903);
float t945 = (2*t944);
float t946 = (t945*t897);
float t947 = (t935+t882);
float t948 = (2*t947);
float t949 = (1-t948);
float t950 = (t949*0);
float t951 = (t946+t950);
float t952 = (t929-t930);
float t953 = (2*t952);
float t954 = (t953*t922);
float t955 = (t951+t954);
float t956 = atan(t943,t955);
float t957 = (3.1415927/2);
float t958 = (t956-t957);
float t959 = (t849-t958);
float t960 = abs(t959);
float t961 = (t960/2);
float t962 = sin(t961);
float t963 = (t962*t962);
float t964 = cos(t958);
float t965 = cos(t849);
float t966 = (t964*t965);
float t967 = (t118+3.1415927);
float t968 = (3.1415927*2);
float t969 = mod(t967,t968);
float t970 = (t969-3.1415927);
float t971 = atan(t924,t940);
float t972 = (t971+3.1415927);
float t973 = (3.1415927*2);
float t974 = mod(t972,t973);
float t975 = (t974-3.1415927);
float t976 = (t970-t975);
float t977 = abs(t976);
float t978 = (t977/2);
float t979 = sin(t978);
float t980 = (t979*t979);
float t981 = (t966*t980);
float t982 = (t963+t981);
float t983 = sqrt(t982);
float t984 = asin(t983);
float t985 = (2*t984);
float t986 = (t924*t924);
float t987 = (t955*t955);
float t988 = (t986+t987);
float t989 = (t940*t940);
float t990 = (t988+t989);
float t991 = sqrt(t990);
float t992 = (t991*float(1.4959787e8));
float t993 = (2*t992);
float t994 = (140000/t993);
float t995 = asin(t994);
float t996 = (2*t995);
float t997 = (t996*4);
float t998 = (t985/t997);
float t999 = step(1,t998);
float t1000 = (1-t999);
float t1001 = step(float(0.98),t998);
float t1002 = cos(t956);
float t1003 = (1*t1002);
float t1004 = (t1003*0);
float t1005 = sin(t956);
float t1006 = (1*t1005);
float t1007 = cos(t971);
float t1008 = (t1006*t1007);
float t1009 = (t1008*1);
float t1010 = (t1004-t1009);
float t1011 = sin(t8);
float t1012 = (1*t1011);
float t1013 = sin(t118);
float t1014 = (t1012*t1013);
float t1015 = (t1010*t1014);
float t1016 = (t1008*0);
float t1017 = sin(t956);
float t1018 = (1*t1017);
float t1019 = sin(t971);
float t1020 = (t1018*t1019);
float t1021 = (t1020*0);
float t1022 = (t1016-t1021);
float t1023 = cos(t8);
float t1024 = (1*t1023);
float t1025 = (t1022*t1024);
float t1026 = (t1015+t1025);
float t1027 = (t1020*1);
float t1028 = (t1003*0);
float t1029 = (t1027-t1028);
float t1030 = sin(t8);
float t1031 = (1*t1030);
float t1032 = cos(t118);
float t1033 = (t1031*t1032);
float t1034 = (t1029*t1033);
float t1035 = (t1026+t1034);
float t1036 = (t1022*t1008);
float t1037 = (t1029*t1003);
float t1038 = (t1036-t1037);
float t1039 = (t1038*t1014);
float t1040 = (t1029*t1020);
float t1041 = (t1010*t1008);
float t1042 = (t1040-t1041);
float t1043 = (t1042*t1024);
float t1044 = (t1039+t1043);
float t1045 = (t1010*t1003);
float t1046 = (t1022*t1020);
float t1047 = (t1045-t1046);
float t1048 = (t1047*t1033);
float t1049 = (t1044+t1048);
float t1050 = atan(t1035,t1049);
float t1051 = (t1050+3.1415927);
float t1052 = (t1051/3.1415927);
float t1053 = (t1052*2);
float t1054 = (t1053*12);
float t1055 = fract(t1054);
float t1056 = step(float(0.75),t1055);
float t1057 = step(float(0.5),t998);
float t1058 = (t1056*t1057);
float t1059 = (t1001+t1058);
bool t1060 = (1<=t1059);
float t1061;
if(t1060){
t1061 = 1;
} else {
t1061 = t1059;
}
float t1062 = (float(0.6)*t1061);
float t1063 = (float(1.0)*t1061);
float t1064 = (t1062*t1063);
float t1065 = (1-t1063);
float t1066 = (float(6.0e-2)*t1065);
float t1067 = (t1064+t1066);
float t1068 = (t998*3.1415927);
float t1069 = cos(t1068);
float t1070 = (t1069/2);
float t1071 = (t1070+float(0.5));
float t1072 = (t1071+float(0.5));
float t1073 = (t1067*t1072);
float t1074 = (1-float(1.0));
float t1075 = (t1074*t1063);
float t1076 = (float(1.0)+t1075);
float t1077 = (t1076*t1072);
float t1078 = (t1073*t1077);
float t1079 = (1-t1077);
float t1080 = (0*t1079);
float t1081 = (t1078+t1080);
float t1082 = (t1000*t1081);
float t1083 = (1-t846);
float t1084 = (t1082*t1083);
float t1085 = (t847+t1084);
float t1086 = (1-1);
float t1087 = (t1086*t1077);
float t1088 = (1+t1087);
float t1089 = (t1000*t1088);
float t1090 = (1-t1089);
float t1091 = (t1090*t846);
float t1092 = (t1089+t1091);
float t1093 = (t1085*t1092);
float t1094 = (3.1415927/2);
float t1095 = (t8-t1094);
float t1096 = (t12/2);
float t1097 = sin(t1096);
float t1098 = sin(t12);
float t1099 = (1*t1098);
float t1100 = cos(0);
float t1101 = (t1099*t1100);
float t1102 = (t1101*0);
float t1103 = sin(t12);
float t1104 = (1*t1103);
float t1105 = sin(0);
float t1106 = (t1104*t1105);
float t1107 = (t1106*0);
float t1108 = (t1102-t1107);
float t1109 = cos(t12);
float t1110 = (1*t1109);
float t1111 = (t1110*0);
float t1112 = (t1101*1);
float t1113 = (t1111-t1112);
float t1114 = (t1113*t1113);
float t1115 = (t1108*t1108);
float t1116 = (t1114+t1115);
float t1117 = (t1106*1);
float t1118 = (t1110*0);
float t1119 = (t1117-t1118);
float t1120 = (t1119*t1119);
float t1121 = (t1116+t1120);
float t1122 = sqrt(t1121);
float t1123 = (t1108/t1122);
float t1124 = (t1097*t1123);
float t1125 = (t1124*t1124);
float t1126 = (t1119/t1122);
float t1127 = (t1097*t1126);
float t1128 = (t1127*t1127);
float t1129 = (t1125+t1128);
float t1130 = (2*t1129);
float t1131 = (1-t1130);
float t1132 = (float(10759.22)*840);
float t1133 = (u4.u0/t1132);
float t1134 = (t1133*3.1415927);
float t1135 = (t1134*2);
float t1136 = sin(t1135);
float t1137 = (t1136*float(9.5));
float t1138 = (u4.u0/t193);
float t1139 = (t1138*3.1415927);
float t1140 = (t1139*2);
float t1141 = sin(t1140);
float t1142 = (t1141*1);
float t1143 = (t1137-t1142);
float t1144 = (t1131*t1143);
float t1145 = (t1113/t1122);
float t1146 = (t1097*t1145);
float t1147 = (t1146*t1124);
float t1148 = cos(t1096);
float t1149 = (t1127*t1148);
float t1150 = (t1147-t1149);
float t1151 = (2*t1150);
float t1152 = (t1151*0);
float t1153 = (t1144+t1152);
float t1154 = (t1146*t1127);
float t1155 = (t1124*t1148);
float t1156 = (t1154+t1155);
float t1157 = (2*t1156);
float t1158 = (u4.u0/t1132);
float t1159 = (t1158*3.1415927);
float t1160 = (t1159*2);
float t1161 = cos(t1160);
float t1162 = (t1161*float(9.5));
float t1163 = (u4.u0/t193);
float t1164 = (t1163*3.1415927);
float t1165 = (t1164*2);
float t1166 = cos(t1165);
float t1167 = (t1166*1);
float t1168 = (t1162-t1167);
float t1169 = (t1157*t1168);
float t1170 = (t1153+t1169);
float t1171 = (t1170*t1170);
float t1172 = (t1154-t1155);
float t1173 = (2*t1172);
float t1174 = (t1173*t1143);
float t1175 = (t1124*t1127);
float t1176 = (t1146*t1148);
float t1177 = (t1175+t1176);
float t1178 = (2*t1177);
float t1179 = (t1178*0);
float t1180 = (t1174+t1179);
float t1181 = (t1146*t1146);
float t1182 = (t1181+t1125);
float t1183 = (2*t1182);
float t1184 = (1-t1183);
float t1185 = (t1184*t1168);
float t1186 = (t1180+t1185);
float t1187 = (t1186*t1186);
float t1188 = (t1171+t1187);
float t1189 = sqrt(t1188);
float t1190 = (t1147+t1149);
float t1191 = (2*t1190);
float t1192 = (t1191*t1143);
float t1193 = (t1181+t1128);
float t1194 = (2*t1193);
float t1195 = (1-t1194);
float t1196 = (t1195*0);
float t1197 = (t1192+t1196);
float t1198 = (t1175-t1176);
float t1199 = (2*t1198);
float t1200 = (t1199*t1168);
float t1201 = (t1197+t1200);
float t1202 = atan(t1189,t1201);
float t1203 = (3.1415927/2);
float t1204 = (t1202-t1203);
float t1205 = (t1095-t1204);
float t1206 = abs(t1205);
float t1207 = (t1206/2);
float t1208 = sin(t1207);
float t1209 = (t1208*t1208);
float t1210 = cos(t1204);
float t1211 = cos(t1095);
float t1212 = (t1210*t1211);
float t1213 = (t118+3.1415927);
float t1214 = (3.1415927*2);
float t1215 = mod(t1213,t1214);
float t1216 = (t1215-3.1415927);
float t1217 = atan(t1170,t1186);
float t1218 = (t1217+3.1415927);
float t1219 = (3.1415927*2);
float t1220 = mod(t1218,t1219);
float t1221 = (t1220-3.1415927);
float t1222 = (t1216-t1221);
float t1223 = abs(t1222);
float t1224 = (t1223/2);
float t1225 = sin(t1224);
float t1226 = (t1225*t1225);
float t1227 = (t1212*t1226);
float t1228 = (t1209+t1227);
float t1229 = sqrt(t1228);
float t1230 = asin(t1229);
float t1231 = (2*t1230);
float t1232 = (t1170*t1170);
float t1233 = (t1201*t1201);
float t1234 = (t1232+t1233);
float t1235 = (t1186*t1186);
float t1236 = (t1234+t1235);
float t1237 = sqrt(t1236);
float t1238 = (t1237*float(1.4959787e8));
float t1239 = (2*t1238);
float t1240 = (118000/t1239);
float t1241 = asin(t1240);
float t1242 = (2*t1241);
float t1243 = (t1242*4);
float t1244 = (t1231/t1243);
float t1245 = step(1,t1244);
float t1246 = (1-t1245);
float t1247 = (float(0.9)*t1246);
float t1248 = (1-t1092);
float t1249 = (t1247*t1248);
float t1250 = (t1093+t1249);
float t1251 = (float(1.0)*t1246);
float t1252 = (1-t1251);
float t1253 = (t1252*t1092);
float t1254 = (t1251+t1253);
float t1255 = (t1250*t1254);
float t1256 = smoothstep(float(0.45),float(0.55),t468);
float t1257 = (float(0.3)*t1256);
float t1258 = (1-t1256);
float t1259 = (float(0.5)*t1258);
float t1260 = (t1257+t1259);
float t1261 = (3.1415927/2);
float t1262 = (t8-t1261);
float t1263 = (3.1415927/2);
float t1264 = (t436-t1263);
float t1265 = (t1262-t1264);
float t1266 = abs(t1265);
float t1267 = (t1266/2);
float t1268 = sin(t1267);
float t1269 = (t1268*t1268);
float t1270 = cos(t1264);
float t1271 = cos(t1262);
float t1272 = (t1270*t1271);
float t1273 = (t118+3.1415927);
float t1274 = (3.1415927*2);
float t1275 = mod(t1273,t1274);
float t1276 = (t1275-3.1415927);
float t1277 = (t452+3.1415927);
float t1278 = (3.1415927*2);
float t1279 = mod(t1277,t1278);
float t1280 = (t1279-3.1415927);
float t1281 = (t1276-t1280);
float t1282 = abs(t1281);
float t1283 = (t1282/2);
float t1284 = sin(t1283);
float t1285 = (t1284*t1284);
float t1286 = (t1272*t1285);
float t1287 = (t1269+t1286);
float t1288 = sqrt(t1287);
float t1289 = asin(t1288);
float t1290 = (2*t1289);
float t1291 = (3.1415927-t1290);
float t1292 = (t1291/3.1415927);
float t1293 = (t1292-float(0.5));
float t1294 = (-2);
float t1295 = (t1293*t1294);
float t1296 = (1-t1295);
float t1297 = (float(0.8)*t1296);
float t1298 = smoothstep(float(0.4),float(0.6),t468);
float t1299 = (t1298*3.1415927);
float t1300 = sin(t1299);
float t1301 = (t1297*t1300);
float t1302 = (3.1415927/2);
float t1303 = (t8-t1302);
float t1304 = (3.1415927/2);
float t1305 = (t254-t1304);
float t1306 = (t1303-t1305);
float t1307 = abs(t1306);
float t1308 = (t1307/2);
float t1309 = sin(t1308);
float t1310 = (t1309*t1309);
float t1311 = cos(t1305);
float t1312 = cos(t1303);
float t1313 = (t1311*t1312);
float t1314 = (t118+3.1415927);
float t1315 = (3.1415927*2);
float t1316 = mod(t1314,t1315);
float t1317 = (t1316-3.1415927);
float t1318 = (t447+3.1415927);
float t1319 = (3.1415927*2);
float t1320 = mod(t1318,t1319);
float t1321 = (t1320-3.1415927);
float t1322 = (t1317-t1321);
float t1323 = abs(t1322);
float t1324 = (t1323/2);
float t1325 = sin(t1324);
float t1326 = (t1325*t1325);
float t1327 = (t1313*t1326);
float t1328 = (t1310+t1327);
float t1329 = sqrt(t1328);
float t1330 = asin(t1329);
float t1331 = (2*t1330);
float t1332 = (3.1415927-t1331);
float t1333 = (t1332/3.1415927);
float t1334 = smoothstep(float(0.5),float(0.7),t1333);
float t1335 = (t1301*t1334);
float t1336 = (t1260+t1335);
float t1337 = (u8.u0*t1336);
float t1338 = (t1333/2);
float t1339 = (t1338+float(0.5));
float t1340 = smoothstep(float(0.3),float(0.6),t468);
float t1341 = (t1339*t1340);
float t1342 = (u8.u0*t1341);
float t1343 = (t1337*t1342);
float t1344 = (3.1415927/36);
float t1345 = (t8/t1344);
float t1346 = floor(t1345);
float t1347 = (t1346/36);
float t1348 = (t1346/36);
float t1349 = (t1348*float(842.378));
float t1350 = fract(t1349);
float t1351 = (t1350+float(45.32));
float t1352 = (t1351+u6.u0);
float t1353 = (t1350*t1352);
float t1354 = (t1346/36);
float t1355 = (t1354*3.1415927);
float t1356 = sin(t1355);
float t1357 = (36*t1356);
float t1358 = floor(t1357);
float t1359 = (t1358+1);
float t1360 = (3.1415927/t1359);
float t1361 = (t118/t1360);
float t1362 = floor(t1361);
float t1363 = (t1362/t1359);
float t1364 = (t1363*float(1734.048));
float t1365 = fract(t1364);
float t1366 = (t1365+float(45.32));
float t1367 = (t1366+u6.u0);
float t1368 = (t1365*t1367);
float t1369 = (t1353+t1368);
float t1370 = (t1350+t1369);
float t1371 = (t1365+t1369);
float t1372 = (t1370*t1371);
float t1373 = fract(t1372);
float t1374 = (t1373*5);
float t1375 = (t1347+t1374);
float t1376 = fract(t1375);
float t1377 = (t1376*12000);
float t1378 = (t1377/1000);
bool t1379 = (1<=t1378);
float t1380;
if(t1379){
t1380 = 1;
} else {
t1380 = t1378;
}
float t1381 = (t1377-6000);
float t1382 = (t1381/8000);
bool t1383 = (0>=t1382);
float t1384;
if(t1383){
t1384 = 0;
} else {
t1384 = t1382;
}
float t1385 = (t1380-t1384);
float t1386 = (t1373*173);
float t1387 = fract(t1386);
float t1388 = step(float(0.66),t1387);
float t1389 = (t1388*3);
float t1390 = (3+t1389);
float t1391 = (3.1415927/t1390);
float t1392 = cos(t1391);
float t1393 = (1-t1392);
float t1394 = (t1346*t1344);
float t1395 = (t1346/36);
float t1396 = (t1395*float(842.378));
float t1397 = fract(t1396);
float t1398 = (t1397+float(45.32));
float t1399 = (t1398+u6.u0);
float t1400 = (t1397*t1399);
float t1401 = (t1362/t1359);
float t1402 = (t1401*float(1734.048));
float t1403 = fract(t1402);
float t1404 = (t1403+float(45.32));
float t1405 = (t1404+u6.u0);
float t1406 = (t1403*t1405);
float t1407 = (t1400+t1406);
float t1408 = (t1397+t1407);
float t1409 = (t1403+t1407);
float t1410 = (t1408*t1409);
float t1411 = fract(t1410);
float t1412 = (t1411*float(2852.02));
float t1413 = fract(t1412);
float t1414 = (t1413-float(0.5));
float t1415 = (t1414*t1344);
float t1416 = (t1415*float(0.75));
float t1417 = (t1394+t1416);
float t1418 = cos(t1417);
float t1419 = (1*t1418);
float t1420 = (t1419*0);
float t1421 = sin(t1417);
float t1422 = (1*t1421);
float t1423 = (3.1415927/t1359);
float t1424 = (t1362*t1423);
float t1425 = (t1411*float(97372.83));
float t1426 = fract(t1425);
float t1427 = (t1426-float(0.5));
float t1428 = (3.1415927/t1359);
float t1429 = (t1427*t1428);
float t1430 = (t1429*float(0.75));
float t1431 = (t1424+t1430);
float t1432 = (t1431+3.1415927);
float t1433 = (3.1415927*2);
float t1434 = mod(t1432,t1433);
float t1435 = (t1434-3.1415927);
float t1436 = cos(t1435);
float t1437 = (t1422*t1436);
float t1438 = (t1437*1);
float t1439 = (t1420-t1438);
float t1440 = sin(t8);
float t1441 = (1*t1440);
float t1442 = sin(t118);
float t1443 = (t1441*t1442);
float t1444 = (t1439*t1443);
float t1445 = (t1437*0);
float t1446 = sin(t1417);
float t1447 = (1*t1446);
float t1448 = sin(t1435);
float t1449 = (t1447*t1448);
float t1450 = (t1449*0);
float t1451 = (t1445-t1450);
float t1452 = cos(t8);
float t1453 = (1*t1452);
float t1454 = (t1451*t1453);
float t1455 = (t1444+t1454);
float t1456 = (t1449*1);
float t1457 = (t1419*0);
float t1458 = (t1456-t1457);
float t1459 = sin(t8);
float t1460 = (1*t1459);
float t1461 = cos(t118);
float t1462 = (t1460*t1461);
float t1463 = (t1458*t1462);
float t1464 = (t1455+t1463);
float t1465 = (t1451*t1437);
float t1466 = (t1458*t1419);
float t1467 = (t1465-t1466);
float t1468 = (t1467*t1443);
float t1469 = (t1458*t1449);
float t1470 = (t1439*t1437);
float t1471 = (t1469-t1470);
float t1472 = (t1471*t1453);
float t1473 = (t1468+t1472);
float t1474 = (t1439*t1419);
float t1475 = (t1451*t1449);
float t1476 = (t1474-t1475);
float t1477 = (t1476*t1462);
float t1478 = (t1473+t1477);
float t1479 = atan(t1464,t1478);
float t1480 = (t1479+3.1415927);
float t1481 = (t1387*3.1415927);
float t1482 = (t1480+t1481);
float t1483 = (3.1415927*2);
float t1484 = (t1482/t1483);
float t1485 = fract(t1484);
float t1486 = (t1485*t1390);
float t1487 = fract(t1486);
float t1488 = (t1487*2);
float t1489 = (t1488-1);
float t1490 = abs(t1489);
float t1491 = (t1490*t1490);
float t1492 = (t1393*t1491);
float t1493 = (t1392+t1492);
float t1494 = (t1373*float(8.0e-3));
float t1495 = (float(1.0e-3)+t1494);
float t1496 = step(float(0.66),t1387);
float t1497 = (t1496*float(3.0e-3));
float t1498 = (t1495-t1497);
float t1499 = (t1498*float(0.8));
float t1500 = (t1493*t1499);
float t1501 = (3.1415927/2);
float t1502 = (t1417-t1501);
float t1503 = (3.1415927/2);
float t1504 = (t8-t1503);
float t1505 = (t1502-t1504);
float t1506 = abs(t1505);
float t1507 = (t1506/2);
float t1508 = sin(t1507);
float t1509 = (t1508*t1508);
float t1510 = cos(t1504);
float t1511 = cos(t1502);
float t1512 = (t1510*t1511);
float t1513 = (t1435+3.1415927);
float t1514 = (3.1415927*2);
float t1515 = mod(t1513,t1514);
float t1516 = (t1515-3.1415927);
float t1517 = (t118+3.1415927);
float t1518 = (3.1415927*2);
float t1519 = mod(t1517,t1518);
float t1520 = (t1519-3.1415927);
float t1521 = (t1516-t1520);
float t1522 = abs(t1521);
float t1523 = (t1522/2);
float t1524 = sin(t1523);
float t1525 = (t1524*t1524);
float t1526 = (t1512*t1525);
float t1527 = (t1509+t1526);
float t1528 = sqrt(t1527);
float t1529 = asin(t1528);
float t1530 = (2*t1529);
float t1531 = step(t1500,t1530);
float t1532 = (1-t1531);
float t1533 = (t1385*t1532);
float t1534 = (3.1415927/2);
float t1535 = (t8-t1534);
float t1536 = (3.1415927/2);
float t1537 = (t1417-t1536);
float t1538 = (t1535-t1537);
float t1539 = abs(t1538);
float t1540 = (t1539/2);
float t1541 = sin(t1540);
float t1542 = (t1541*t1541);
float t1543 = cos(t1537);
float t1544 = cos(t1535);
float t1545 = (t1543*t1544);
float t1546 = (t118+3.1415927);
float t1547 = (3.1415927*2);
float t1548 = mod(t1546,t1547);
float t1549 = (t1548-3.1415927);
float t1550 = (t1435+3.1415927);
float t1551 = (3.1415927*2);
float t1552 = mod(t1550,t1551);
float t1553 = (t1552-3.1415927);
float t1554 = (t1549-t1553);
float t1555 = abs(t1554);
float t1556 = (t1555/2);
float t1557 = sin(t1556);
float t1558 = (t1557*t1557);
float t1559 = (t1545*t1558);
float t1560 = (t1542+t1559);
float t1561 = sqrt(t1560);
float t1562 = asin(t1561);
float t1563 = (2*t1562);
float t1564 = (1/t1563);
float t1565 = (t1564*t1499);
float t1566 = (t1565*float(1.25e-2));
float t1567 = (u4.u0*t1373);
float t1568 = cos(t1567);
float t1569 = (t1568+1);
float t1570 = (t1569/2);
float t1571 = (t1566*t1570);
float t1572 = (t1571*t1385);
float t1573 = (t1533+t1572);
float t1574 = (0+t1573);
float t1575 = (t1346/36);
float t1576 = (t1346/36);
float t1577 = (t1576*float(842.378));
float t1578 = fract(t1577);
float t1579 = (t1578+float(45.32));
float t1580 = (t1579+u6.u0);
float t1581 = (t1578*t1580);
float t1582 = (t1362+1);
float t1583 = (t1582/t1359);
float t1584 = (t1583*float(1734.048));
float t1585 = fract(t1584);
float t1586 = (t1585+float(45.32));
float t1587 = (t1586+u6.u0);
float t1588 = (t1585*t1587);
float t1589 = (t1581+t1588);
float t1590 = (t1578+t1589);
float t1591 = (t1585+t1589);
float t1592 = (t1590*t1591);
float t1593 = fract(t1592);
float t1594 = (t1593*5);
float t1595 = (t1575+t1594);
float t1596 = fract(t1595);
float t1597 = (t1596*12000);
float t1598 = (t1597/1000);
bool t1599 = (1<=t1598);
float t1600;
if(t1599){
t1600 = 1;
} else {
t1600 = t1598;
}
float t1601 = (t1597-6000);
float t1602 = (t1601/8000);
bool t1603 = (0>=t1602);
float t1604;
if(t1603){
t1604 = 0;
} else {
t1604 = t1602;
}
float t1605 = (t1600-t1604);
float t1606 = (t1593*173);
float t1607 = fract(t1606);
float t1608 = step(float(0.66),t1607);
float t1609 = (t1608*3);
float t1610 = (3+t1609);
float t1611 = (3.1415927/t1610);
float t1612 = cos(t1611);
float t1613 = (1-t1612);
float t1614 = (t1346*t1344);
float t1615 = (t1346/36);
float t1616 = (t1615*float(842.378));
float t1617 = fract(t1616);
float t1618 = (t1617+float(45.32));
float t1619 = (t1618+u6.u0);
float t1620 = (t1617*t1619);
float t1621 = (t1582/t1359);
float t1622 = (t1621*float(1734.048));
float t1623 = fract(t1622);
float t1624 = (t1623+float(45.32));
float t1625 = (t1624+u6.u0);
float t1626 = (t1623*t1625);
float t1627 = (t1620+t1626);
float t1628 = (t1617+t1627);
float t1629 = (t1623+t1627);
float t1630 = (t1628*t1629);
float t1631 = fract(t1630);
float t1632 = (t1631*float(2852.02));
float t1633 = fract(t1632);
float t1634 = (t1633-float(0.5));
float t1635 = (t1634*t1344);
float t1636 = (t1635*float(0.75));
float t1637 = (t1614+t1636);
float t1638 = cos(t1637);
float t1639 = (1*t1638);
float t1640 = (t1639*0);
float t1641 = sin(t1637);
float t1642 = (1*t1641);
float t1643 = (3.1415927/t1359);
float t1644 = (t1582*t1643);
float t1645 = (t1631*float(97372.83));
float t1646 = fract(t1645);
float t1647 = (t1646-float(0.5));
float t1648 = (3.1415927/t1359);
float t1649 = (t1647*t1648);
float t1650 = (t1649*float(0.75));
float t1651 = (t1644+t1650);
float t1652 = (t1651+3.1415927);
float t1653 = mod(t1652,t1433);
float t1654 = (t1653-3.1415927);
float t1655 = cos(t1654);
float t1656 = (t1642*t1655);
float t1657 = (t1656*1);
float t1658 = (t1640-t1657);
float t1659 = sin(t8);
float t1660 = (1*t1659);
float t1661 = sin(t118);
float t1662 = (t1660*t1661);
float t1663 = (t1658*t1662);
float t1664 = (t1656*0);
float t1665 = sin(t1637);
float t1666 = (1*t1665);
float t1667 = sin(t1654);
float t1668 = (t1666*t1667);
float t1669 = (t1668*0);
float t1670 = (t1664-t1669);
float t1671 = cos(t8);
float t1672 = (1*t1671);
float t1673 = (t1670*t1672);
float t1674 = (t1663+t1673);
float t1675 = (t1668*1);
float t1676 = (t1639*0);
float t1677 = (t1675-t1676);
float t1678 = sin(t8);
float t1679 = (1*t1678);
float t1680 = cos(t118);
float t1681 = (t1679*t1680);
float t1682 = (t1677*t1681);
float t1683 = (t1674+t1682);
float t1684 = (t1670*t1656);
float t1685 = (t1677*t1639);
float t1686 = (t1684-t1685);
float t1687 = (t1686*t1662);
float t1688 = (t1677*t1668);
float t1689 = (t1658*t1656);
float t1690 = (t1688-t1689);
float t1691 = (t1690*t1672);
float t1692 = (t1687+t1691);
float t1693 = (t1658*t1639);
float t1694 = (t1670*t1668);
float t1695 = (t1693-t1694);
float t1696 = (t1695*t1681);
float t1697 = (t1692+t1696);
float t1698 = atan(t1683,t1697);
float t1699 = (t1698+3.1415927);
float t1700 = (t1607*3.1415927);
float t1701 = (t1699+t1700);
float t1702 = (t1701/t1483);
float t1703 = fract(t1702);
float t1704 = (t1703*t1610);
float t1705 = fract(t1704);
float t1706 = (t1705*2);
float t1707 = (t1706-1);
float t1708 = abs(t1707);
float t1709 = (t1708*t1708);
float t1710 = (t1613*t1709);
float t1711 = (t1612+t1710);
float t1712 = (t1593*float(8.0e-3));
float t1713 = (float(1.0e-3)+t1712);
float t1714 = step(float(0.66),t1607);
float t1715 = (t1714*float(3.0e-3));
float t1716 = (t1713-t1715);
float t1717 = (t1716*float(0.8));
float t1718 = (t1711*t1717);
float t1719 = (3.1415927/2);
float t1720 = (t1637-t1719);
float t1721 = (3.1415927/2);
float t1722 = (t8-t1721);
float t1723 = (t1720-t1722);
float t1724 = abs(t1723);
float t1725 = (t1724/2);
float t1726 = sin(t1725);
float t1727 = (t1726*t1726);
float t1728 = cos(t1722);
float t1729 = cos(t1720);
float t1730 = (t1728*t1729);
float t1731 = (t1654+3.1415927);
float t1732 = (3.1415927*2);
float t1733 = mod(t1731,t1732);
float t1734 = (t1733-3.1415927);
float t1735 = (t118+3.1415927);
float t1736 = (3.1415927*2);
float t1737 = mod(t1735,t1736);
float t1738 = (t1737-3.1415927);
float t1739 = (t1734-t1738);
float t1740 = abs(t1739);
float t1741 = (t1740/2);
float t1742 = sin(t1741);
float t1743 = (t1742*t1742);
float t1744 = (t1730*t1743);
float t1745 = (t1727+t1744);
float t1746 = sqrt(t1745);
float t1747 = asin(t1746);
float t1748 = (2*t1747);
float t1749 = step(t1718,t1748);
float t1750 = (1-t1749);
float t1751 = (t1605*t1750);
float t1752 = (3.1415927/2);
float t1753 = (t8-t1752);
float t1754 = (3.1415927/2);
float t1755 = (t1637-t1754);
float t1756 = (t1753-t1755);
float t1757 = abs(t1756);
float t1758 = (t1757/2);
float t1759 = sin(t1758);
float t1760 = (t1759*t1759);
float t1761 = cos(t1755);
float t1762 = cos(t1753);
float t1763 = (t1761*t1762);
float t1764 = (t118+3.1415927);
float t1765 = (3.1415927*2);
float t1766 = mod(t1764,t1765);
float t1767 = (t1766-3.1415927);
float t1768 = (t1654+3.1415927);
float t1769 = (3.1415927*2);
float t1770 = mod(t1768,t1769);
float t1771 = (t1770-3.1415927);
float t1772 = (t1767-t1771);
float t1773 = abs(t1772);
float t1774 = (t1773/2);
float t1775 = sin(t1774);
float t1776 = (t1775*t1775);
float t1777 = (t1763*t1776);
float t1778 = (t1760+t1777);
float t1779 = sqrt(t1778);
float t1780 = asin(t1779);
float t1781 = (2*t1780);
float t1782 = (1/t1781);
float t1783 = (t1782*t1717);
float t1784 = (t1783*float(1.25e-2));
float t1785 = (u4.u0*t1593);
float t1786 = cos(t1785);
float t1787 = (t1786+1);
float t1788 = (t1787/2);
float t1789 = (t1784*t1788);
float t1790 = (t1789*t1605);
float t1791 = (t1751+t1790);
float t1792 = (t1574+t1791);
float t1793 = (t1346/36);
float t1794 = (t1346/36);
float t1795 = (t1794*float(842.378));
float t1796 = fract(t1795);
float t1797 = (t1796+float(45.32));
float t1798 = (t1797+u6.u0);
float t1799 = (t1796*t1798);
float t1800 = (t1362+2);
float t1801 = (t1800/t1359);
float t1802 = (t1801*float(1734.048));
float t1803 = fract(t1802);
float t1804 = (t1803+float(45.32));
float t1805 = (t1804+u6.u0);
float t1806 = (t1803*t1805);
float t1807 = (t1799+t1806);
float t1808 = (t1796+t1807);
float t1809 = (t1803+t1807);
float t1810 = (t1808*t1809);
float t1811 = fract(t1810);
float t1812 = (t1811*5);
float t1813 = (t1793+t1812);
float t1814 = fract(t1813);
float t1815 = (t1814*12000);
float t1816 = (t1815/1000);
bool t1817 = (1<=t1816);
float t1818;
if(t1817){
t1818 = 1;
} else {
t1818 = t1816;
}
float t1819 = (t1815-6000);
float t1820 = (t1819/8000);
bool t1821 = (0>=t1820);
float t1822;
if(t1821){
t1822 = 0;
} else {
t1822 = t1820;
}
float t1823 = (t1818-t1822);
float t1824 = (t1811*173);
float t1825 = fract(t1824);
float t1826 = step(float(0.66),t1825);
float t1827 = (t1826*3);
float t1828 = (3+t1827);
float t1829 = (3.1415927/t1828);
float t1830 = cos(t1829);
float t1831 = (1-t1830);
float t1832 = (t1346*t1344);
float t1833 = (t1346/36);
float t1834 = (t1833*float(842.378));
float t1835 = fract(t1834);
float t1836 = (t1835+float(45.32));
float t1837 = (t1836+u6.u0);
float t1838 = (t1835*t1837);
float t1839 = (t1800/t1359);
float t1840 = (t1839*float(1734.048));
float t1841 = fract(t1840);
float t1842 = (t1841+float(45.32));
float t1843 = (t1842+u6.u0);
float t1844 = (t1841*t1843);
float t1845 = (t1838+t1844);
float t1846 = (t1835+t1845);
float t1847 = (t1841+t1845);
float t1848 = (t1846*t1847);
float t1849 = fract(t1848);
float t1850 = (t1849*float(2852.02));
float t1851 = fract(t1850);
float t1852 = (t1851-float(0.5));
float t1853 = (t1852*t1344);
float t1854 = (t1853*float(0.75));
float t1855 = (t1832+t1854);
float t1856 = cos(t1855);
float t1857 = (1*t1856);
float t1858 = (t1857*0);
float t1859 = sin(t1855);
float t1860 = (1*t1859);
float t1861 = (3.1415927/t1359);
float t1862 = (t1800*t1861);
float t1863 = (t1849*float(97372.83));
float t1864 = fract(t1863);
float t1865 = (t1864-float(0.5));
float t1866 = (3.1415927/t1359);
float t1867 = (t1865*t1866);
float t1868 = (t1867*float(0.75));
float t1869 = (t1862+t1868);
float t1870 = (t1869+3.1415927);
float t1871 = mod(t1870,t1433);
float t1872 = (t1871-3.1415927);
float t1873 = cos(t1872);
float t1874 = (t1860*t1873);
float t1875 = (t1874*1);
float t1876 = (t1858-t1875);
float t1877 = sin(t8);
float t1878 = (1*t1877);
float t1879 = sin(t118);
float t1880 = (t1878*t1879);
float t1881 = (t1876*t1880);
float t1882 = (t1874*0);
float t1883 = sin(t1855);
float t1884 = (1*t1883);
float t1885 = sin(t1872);
float t1886 = (t1884*t1885);
float t1887 = (t1886*0);
float t1888 = (t1882-t1887);
float t1889 = cos(t8);
float t1890 = (1*t1889);
float t1891 = (t1888*t1890);
float t1892 = (t1881+t1891);
float t1893 = (t1886*1);
float t1894 = (t1857*0);
float t1895 = (t1893-t1894);
float t1896 = sin(t8);
float t1897 = (1*t1896);
float t1898 = cos(t118);
float t1899 = (t1897*t1898);
float t1900 = (t1895*t1899);
float t1901 = (t1892+t1900);
float t1902 = (t1888*t1874);
float t1903 = (t1895*t1857);
float t1904 = (t1902-t1903);
float t1905 = (t1904*t1880);
float t1906 = (t1895*t1886);
float t1907 = (t1876*t1874);
float t1908 = (t1906-t1907);
float t1909 = (t1908*t1890);
float t1910 = (t1905+t1909);
float t1911 = (t1876*t1857);
float t1912 = (t1888*t1886);
float t1913 = (t1911-t1912);
float t1914 = (t1913*t1899);
float t1915 = (t1910+t1914);
float t1916 = atan(t1901,t1915);
float t1917 = (t1916+3.1415927);
float t1918 = (t1825*3.1415927);
float t1919 = (t1917+t1918);
float t1920 = (t1919/t1483);
float t1921 = fract(t1920);
float t1922 = (t1921*t1828);
float t1923 = fract(t1922);
float t1924 = (t1923*2);
float t1925 = (t1924-1);
float t1926 = abs(t1925);
float t1927 = (t1926*t1926);
float t1928 = (t1831*t1927);
float t1929 = (t1830+t1928);
float t1930 = (t1811*float(8.0e-3));
float t1931 = (float(1.0e-3)+t1930);
float t1932 = step(float(0.66),t1825);
float t1933 = (t1932*float(3.0e-3));
float t1934 = (t1931-t1933);
float t1935 = (t1934*float(0.8));
float t1936 = (t1929*t1935);
float t1937 = (3.1415927/2);
float t1938 = (t1855-t1937);
float t1939 = (3.1415927/2);
float t1940 = (t8-t1939);
float t1941 = (t1938-t1940);
float t1942 = abs(t1941);
float t1943 = (t1942/2);
float t1944 = sin(t1943);
float t1945 = (t1944*t1944);
float t1946 = cos(t1940);
float t1947 = cos(t1938);
float t1948 = (t1946*t1947);
float t1949 = (t1872+3.1415927);
float t1950 = (3.1415927*2);
float t1951 = mod(t1949,t1950);
float t1952 = (t1951-3.1415927);
float t1953 = (t118+3.1415927);
float t1954 = (3.1415927*2);
float t1955 = mod(t1953,t1954);
float t1956 = (t1955-3.1415927);
float t1957 = (t1952-t1956);
float t1958 = abs(t1957);
float t1959 = (t1958/2);
float t1960 = sin(t1959);
float t1961 = (t1960*t1960);
float t1962 = (t1948*t1961);
float t1963 = (t1945+t1962);
float t1964 = sqrt(t1963);
float t1965 = asin(t1964);
float t1966 = (2*t1965);
float t1967 = step(t1936,t1966);
float t1968 = (1-t1967);
float t1969 = (t1823*t1968);
float t1970 = (3.1415927/2);
float t1971 = (t8-t1970);
float t1972 = (3.1415927/2);
float t1973 = (t1855-t1972);
float t1974 = (t1971-t1973);
float t1975 = abs(t1974);
float t1976 = (t1975/2);
float t1977 = sin(t1976);
float t1978 = (t1977*t1977);
float t1979 = cos(t1973);
float t1980 = cos(t1971);
float t1981 = (t1979*t1980);
float t1982 = (t118+3.1415927);
float t1983 = (3.1415927*2);
float t1984 = mod(t1982,t1983);
float t1985 = (t1984-3.1415927);
float t1986 = (t1872+3.1415927);
float t1987 = (3.1415927*2);
float t1988 = mod(t1986,t1987);
float t1989 = (t1988-3.1415927);
float t1990 = (t1985-t1989);
float t1991 = abs(t1990);
float t1992 = (t1991/2);
float t1993 = sin(t1992);
float t1994 = (t1993*t1993);
float t1995 = (t1981*t1994);
float t1996 = (t1978+t1995);
float t1997 = sqrt(t1996);
float t1998 = asin(t1997);
float t1999 = (2*t1998);
float t2000 = (1/t1999);
float t2001 = (t2000*t1935);
float t2002 = (t2001*float(1.25e-2));
float t2003 = (u4.u0*t1811);
float t2004 = cos(t2003);
float t2005 = (t2004+1);
float t2006 = (t2005/2);
float t2007 = (t2002*t2006);
float t2008 = (t2007*t1823);
float t2009 = (t1969+t2008);
float t2010 = (t1792+t2009);
float t2011 = (t1346+1);
float t2012 = (t2011/36);
float t2013 = (t2011/36);
float t2014 = (t2013*float(842.378));
float t2015 = fract(t2014);
float t2016 = (t2015+float(45.32));
float t2017 = (t2016+u6.u0);
float t2018 = (t2015*t2017);
float t2019 = (t2011/36);
float t2020 = (t2019*3.1415927);
float t2021 = sin(t2020);
float t2022 = (36*t2021);
float t2023 = floor(t2022);
float t2024 = (t2023+1);
float t2025 = (3.1415927/t2024);
float t2026 = (t118/t2025);
float t2027 = floor(t2026);
float t2028 = (t2027/t2024);
float t2029 = (t2028*float(1734.048));
float t2030 = fract(t2029);
float t2031 = (t2030+float(45.32));
float t2032 = (t2031+u6.u0);
float t2033 = (t2030*t2032);
float t2034 = (t2018+t2033);
float t2035 = (t2015+t2034);
float t2036 = (t2030+t2034);
float t2037 = (t2035*t2036);
float t2038 = fract(t2037);
float t2039 = (t2038*5);
float t2040 = (t2012+t2039);
float t2041 = fract(t2040);
float t2042 = (t2041*12000);
float t2043 = (t2042/1000);
bool t2044 = (1<=t2043);
float t2045;
if(t2044){
t2045 = 1;
} else {
t2045 = t2043;
}
float t2046 = (t2042-6000);
float t2047 = (t2046/8000);
bool t2048 = (0>=t2047);
float t2049;
if(t2048){
t2049 = 0;
} else {
t2049 = t2047;
}
float t2050 = (t2045-t2049);
float t2051 = (t2038*173);
float t2052 = fract(t2051);
float t2053 = step(float(0.66),t2052);
float t2054 = (t2053*3);
float t2055 = (3+t2054);
float t2056 = (3.1415927/t2055);
float t2057 = cos(t2056);
float t2058 = (1-t2057);
float t2059 = (t2011*t1344);
float t2060 = (t2011/36);
float t2061 = (t2060*float(842.378));
float t2062 = fract(t2061);
float t2063 = (t2062+float(45.32));
float t2064 = (t2063+u6.u0);
float t2065 = (t2062*t2064);
float t2066 = (t2027/t2024);
float t2067 = (t2066*float(1734.048));
float t2068 = fract(t2067);
float t2069 = (t2068+float(45.32));
float t2070 = (t2069+u6.u0);
float t2071 = (t2068*t2070);
float t2072 = (t2065+t2071);
float t2073 = (t2062+t2072);
float t2074 = (t2068+t2072);
float t2075 = (t2073*t2074);
float t2076 = fract(t2075);
float t2077 = (t2076*float(2852.02));
float t2078 = fract(t2077);
float t2079 = (t2078-float(0.5));
float t2080 = (t2079*t1344);
float t2081 = (t2080*float(0.75));
float t2082 = (t2059+t2081);
float t2083 = cos(t2082);
float t2084 = (1*t2083);
float t2085 = (t2084*0);
float t2086 = sin(t2082);
float t2087 = (1*t2086);
float t2088 = (3.1415927/t2024);
float t2089 = (t2027*t2088);
float t2090 = (t2076*float(97372.83));
float t2091 = fract(t2090);
float t2092 = (t2091-float(0.5));
float t2093 = (3.1415927/t2024);
float t2094 = (t2092*t2093);
float t2095 = (t2094*float(0.75));
float t2096 = (t2089+t2095);
float t2097 = (t2096+3.1415927);
float t2098 = mod(t2097,t1433);
float t2099 = (t2098-3.1415927);
float t2100 = cos(t2099);
float t2101 = (t2087*t2100);
float t2102 = (t2101*1);
float t2103 = (t2085-t2102);
float t2104 = sin(t8);
float t2105 = (1*t2104);
float t2106 = sin(t118);
float t2107 = (t2105*t2106);
float t2108 = (t2103*t2107);
float t2109 = (t2101*0);
float t2110 = sin(t2082);
float t2111 = (1*t2110);
float t2112 = sin(t2099);
float t2113 = (t2111*t2112);
float t2114 = (t2113*0);
float t2115 = (t2109-t2114);
float t2116 = cos(t8);
float t2117 = (1*t2116);
float t2118 = (t2115*t2117);
float t2119 = (t2108+t2118);
float t2120 = (t2113*1);
float t2121 = (t2084*0);
float t2122 = (t2120-t2121);
float t2123 = sin(t8);
float t2124 = (1*t2123);
float t2125 = cos(t118);
float t2126 = (t2124*t2125);
float t2127 = (t2122*t2126);
float t2128 = (t2119+t2127);
float t2129 = (t2115*t2101);
float t2130 = (t2122*t2084);
float t2131 = (t2129-t2130);
float t2132 = (t2131*t2107);
float t2133 = (t2122*t2113);
float t2134 = (t2103*t2101);
float t2135 = (t2133-t2134);
float t2136 = (t2135*t2117);
float t2137 = (t2132+t2136);
float t2138 = (t2103*t2084);
float t2139 = (t2115*t2113);
float t2140 = (t2138-t2139);
float t2141 = (t2140*t2126);
float t2142 = (t2137+t2141);
float t2143 = atan(t2128,t2142);
float t2144 = (t2143+3.1415927);
float t2145 = (t2052*3.1415927);
float t2146 = (t2144+t2145);
float t2147 = (t2146/t1483);
float t2148 = fract(t2147);
float t2149 = (t2148*t2055);
float t2150 = fract(t2149);
float t2151 = (t2150*2);
float t2152 = (t2151-1);
float t2153 = abs(t2152);
float t2154 = (t2153*t2153);
float t2155 = (t2058*t2154);
float t2156 = (t2057+t2155);
float t2157 = (t2038*float(8.0e-3));
float t2158 = (float(1.0e-3)+t2157);
float t2159 = step(float(0.66),t2052);
float t2160 = (t2159*float(3.0e-3));
float t2161 = (t2158-t2160);
float t2162 = (t2161*float(0.8));
float t2163 = (t2156*t2162);
float t2164 = (3.1415927/2);
float t2165 = (t2082-t2164);
float t2166 = (3.1415927/2);
float t2167 = (t8-t2166);
float t2168 = (t2165-t2167);
float t2169 = abs(t2168);
float t2170 = (t2169/2);
float t2171 = sin(t2170);
float t2172 = (t2171*t2171);
float t2173 = cos(t2167);
float t2174 = cos(t2165);
float t2175 = (t2173*t2174);
float t2176 = (t2099+3.1415927);
float t2177 = (3.1415927*2);
float t2178 = mod(t2176,t2177);
float t2179 = (t2178-3.1415927);
float t2180 = (t118+3.1415927);
float t2181 = (3.1415927*2);
float t2182 = mod(t2180,t2181);
float t2183 = (t2182-3.1415927);
float t2184 = (t2179-t2183);
float t2185 = abs(t2184);
float t2186 = (t2185/2);
float t2187 = sin(t2186);
float t2188 = (t2187*t2187);
float t2189 = (t2175*t2188);
float t2190 = (t2172+t2189);
float t2191 = sqrt(t2190);
float t2192 = asin(t2191);
float t2193 = (2*t2192);
float t2194 = step(t2163,t2193);
float t2195 = (1-t2194);
float t2196 = (t2050*t2195);
float t2197 = (3.1415927/2);
float t2198 = (t8-t2197);
float t2199 = (3.1415927/2);
float t2200 = (t2082-t2199);
float t2201 = (t2198-t2200);
float t2202 = abs(t2201);
float t2203 = (t2202/2);
float t2204 = sin(t2203);
float t2205 = (t2204*t2204);
float t2206 = cos(t2200);
float t2207 = cos(t2198);
float t2208 = (t2206*t2207);
float t2209 = (t118+3.1415927);
float t2210 = (3.1415927*2);
float t2211 = mod(t2209,t2210);
float t2212 = (t2211-3.1415927);
float t2213 = (t2099+3.1415927);
float t2214 = (3.1415927*2);
float t2215 = mod(t2213,t2214);
float t2216 = (t2215-3.1415927);
float t2217 = (t2212-t2216);
float t2218 = abs(t2217);
float t2219 = (t2218/2);
float t2220 = sin(t2219);
float t2221 = (t2220*t2220);
float t2222 = (t2208*t2221);
float t2223 = (t2205+t2222);
float t2224 = sqrt(t2223);
float t2225 = asin(t2224);
float t2226 = (2*t2225);
float t2227 = (1/t2226);
float t2228 = (t2227*t2162);
float t2229 = (t2228*float(1.25e-2));
float t2230 = (u4.u0*t2038);
float t2231 = cos(t2230);
float t2232 = (t2231+1);
float t2233 = (t2232/2);
float t2234 = (t2229*t2233);
float t2235 = (t2234*t2050);
float t2236 = (t2196+t2235);
float t2237 = (t2010+t2236);
float t2238 = (t1346*t1344);
float t2239 = (t1346/36);
float t2240 = (t2239*float(842.378));
float t2241 = fract(t2240);
float t2242 = (t2241+float(45.32));
float t2243 = (t2242+u6.u0);
float t2244 = (t2241*t2243);
float t2245 = (t1582/t1359);
float t2246 = (t2245*float(1734.048));
float t2247 = fract(t2246);
float t2248 = (t2247+float(45.32));
float t2249 = (t2248+u6.u0);
float t2250 = (t2247*t2249);
float t2251 = (t2244+t2250);
float t2252 = (t2241+t2251);
float t2253 = (t2247+t2251);
float t2254 = (t2252*t2253);
float t2255 = fract(t2254);
float t2256 = (t2255*float(2852.02));
float t2257 = fract(t2256);
float t2258 = (t2257-float(0.5));
float t2259 = (t2258*t1344);
float t2260 = (t2259*float(0.75));
float t2261 = (t2238+t2260);
float t2262 = (3.1415927/2);
float t2263 = (t2261-t2262);
float t2264 = (t1346*t1344);
float t2265 = (t1346/36);
float t2266 = (t2265*float(842.378));
float t2267 = fract(t2266);
float t2268 = (t2267+float(45.32));
float t2269 = (t2268+u6.u0);
float t2270 = (t2267*t2269);
float t2271 = (t1362/t1359);
float t2272 = (t2271*float(1734.048));
float t2273 = fract(t2272);
float t2274 = (t2273+float(45.32));
float t2275 = (t2274+u6.u0);
float t2276 = (t2273*t2275);
float t2277 = (t2270+t2276);
float t2278 = (t2267+t2277);
float t2279 = (t2273+t2277);
float t2280 = (t2278*t2279);
float t2281 = fract(t2280);
float t2282 = (t2281*float(2852.02));
float t2283 = fract(t2282);
float t2284 = (t2283-float(0.5));
float t2285 = (t2284*t1344);
float t2286 = (t2285*float(0.75));
float t2287 = (t2264+t2286);
float t2288 = (3.1415927/2);
float t2289 = (t2287-t2288);
float t2290 = (t2263-t2289);
float t2291 = abs(t2290);
float t2292 = (t2291/2);
float t2293 = sin(t2292);
float t2294 = (t2293*t2293);
float t2295 = cos(t2289);
float t2296 = cos(t2263);
float t2297 = (t2295*t2296);
float t2298 = (3.1415927/t1359);
float t2299 = (t1582*t2298);
float t2300 = (t2255*float(97372.83));
float t2301 = fract(t2300);
float t2302 = (t2301-float(0.5));
float t2303 = (3.1415927/t1359);
float t2304 = (t2302*t2303);
float t2305 = (t2304*float(0.75));
float t2306 = (t2299+t2305);
float t2307 = (t2306+3.1415927);
float t2308 = mod(t2307,t1433);
float t2309 = (t2308-3.1415927);
float t2310 = (t2309+3.1415927);
float t2311 = (3.1415927*2);
float t2312 = mod(t2310,t2311);
float t2313 = (t2312-3.1415927);
float t2314 = (3.1415927/t1359);
float t2315 = (t1362*t2314);
float t2316 = (t2281*float(97372.83));
float t2317 = fract(t2316);
float t2318 = (t2317-float(0.5));
float t2319 = (3.1415927/t1359);
float t2320 = (t2318*t2319);
float t2321 = (t2320*float(0.75));
float t2322 = (t2315+t2321);
float t2323 = (t2322+3.1415927);
float t2324 = mod(t2323,t1433);
float t2325 = (t2324-3.1415927);
float t2326 = (t2325+3.1415927);
float t2327 = (3.1415927*2);
float t2328 = mod(t2326,t2327);
float t2329 = (t2328-3.1415927);
float t2330 = (t2313-t2329);
float t2331 = abs(t2330);
float t2332 = (t2331/2);
float t2333 = sin(t2332);
float t2334 = (t2333*t2333);
float t2335 = (t2297*t2334);
float t2336 = (t2294+t2335);
float t2337 = sqrt(t2336);
float t2338 = asin(t2337);
float t2339 = (2*t2338);
float t2340 = (3.1415927/2);
float t2341 = (t8-t2340);
float t2342 = (3.1415927/2);
float t2343 = (t2287-t2342);
float t2344 = (t2341-t2343);
float t2345 = abs(t2344);
float t2346 = (t2345/2);
float t2347 = sin(t2346);
float t2348 = (t2347*t2347);
float t2349 = cos(t2343);
float t2350 = cos(t2341);
float t2351 = (t2349*t2350);
float t2352 = (t118+3.1415927);
float t2353 = (3.1415927*2);
float t2354 = mod(t2352,t2353);
float t2355 = (t2354-3.1415927);
float t2356 = (t2325+3.1415927);
float t2357 = (3.1415927*2);
float t2358 = mod(t2356,t2357);
float t2359 = (t2358-3.1415927);
float t2360 = (t2355-t2359);
float t2361 = abs(t2360);
float t2362 = (t2361/2);
float t2363 = sin(t2362);
float t2364 = (t2363*t2363);
float t2365 = (t2351*t2364);
float t2366 = (t2348+t2365);
float t2367 = sqrt(t2366);
float t2368 = asin(t2367);
float t2369 = (2*t2368);
float t2370 = (t2339-t2369);
float t2371 = (3.1415927/2);
float t2372 = (t8-t2371);
float t2373 = (3.1415927/2);
float t2374 = (t2261-t2373);
float t2375 = (t2372-t2374);
float t2376 = abs(t2375);
float t2377 = (t2376/2);
float t2378 = sin(t2377);
float t2379 = (t2378*t2378);
float t2380 = cos(t2374);
float t2381 = cos(t2372);
float t2382 = (t2380*t2381);
float t2383 = (t118+3.1415927);
float t2384 = (3.1415927*2);
float t2385 = mod(t2383,t2384);
float t2386 = (t2385-3.1415927);
float t2387 = (t2309+3.1415927);
float t2388 = (3.1415927*2);
float t2389 = mod(t2387,t2388);
float t2390 = (t2389-3.1415927);
float t2391 = (t2386-t2390);
float t2392 = abs(t2391);
float t2393 = (t2392/2);
float t2394 = sin(t2393);
float t2395 = (t2394*t2394);
float t2396 = (t2382*t2395);
float t2397 = (t2379+t2396);
float t2398 = sqrt(t2397);
float t2399 = asin(t2398);
float t2400 = (2*t2399);
float t2401 = (t2370-t2400);
float t2402 = abs(t2401);
bool t2403 = (float(1.0e-4)>t2402);
float t2404;
if(t2403){
float t2405 = cos(t2287);
float t2406 = (1*t2405);
float t2407 = sin(t2261);
float t2408 = (1*t2407);
float t2409 = cos(t2309);
float t2410 = (t2408*t2409);
float t2411 = (t2406*t2410);
float t2412 = sin(t2287);
float t2413 = (1*t2412);
float t2414 = cos(t2325);
float t2415 = (t2413*t2414);
float t2416 = cos(t2261);
float t2417 = (1*t2416);
float t2418 = (t2415*t2417);
float t2419 = (t2411-t2418);
float t2420 = sin(t8);
float t2421 = (1*t2420);
float t2422 = sin(t118);
float t2423 = (t2421*t2422);
float t2424 = (t2419*t2423);
float t2425 = sin(t2261);
float t2426 = (1*t2425);
float t2427 = sin(t2309);
float t2428 = (t2426*t2427);
float t2429 = (t2415*t2428);
float t2430 = sin(t2287);
float t2431 = (1*t2430);
float t2432 = sin(t2325);
float t2433 = (t2431*t2432);
float t2434 = (t2433*t2410);
float t2435 = (t2429-t2434);
float t2436 = cos(t8);
float t2437 = (1*t2436);
float t2438 = (t2435*t2437);
float t2439 = (t2424+t2438);
float t2440 = (t2433*t2417);
float t2441 = (t2406*t2428);
float t2442 = (t2440-t2441);
float t2443 = sin(t8);
float t2444 = (1*t2443);
float t2445 = cos(t118);
float t2446 = (t2444*t2445);
float t2447 = (t2442*t2446);
float t2448 = (t2439+t2447);
float t2449 = abs(t2448);
t2404 = t2449;
} else {
float t2450 = (3.1415927/2);
float t2451 = (t8-t2450);
float t2452 = (3.1415927/2);
float t2453 = (t2261-t2452);
float t2454 = (t2451-t2453);
float t2455 = abs(t2454);
float t2456 = (t2455/2);
float t2457 = sin(t2456);
float t2458 = (t2457*t2457);
float t2459 = cos(t2453);
float t2460 = cos(t2451);
float t2461 = (t2459*t2460);
float t2462 = (t118+3.1415927);
float t2463 = (3.1415927*2);
float t2464 = mod(t2462,t2463);
float t2465 = (t2464-3.1415927);
float t2466 = (t2309+3.1415927);
float t2467 = (3.1415927*2);
float t2468 = mod(t2466,t2467);
float t2469 = (t2468-3.1415927);
float t2470 = (t2465-t2469);
float t2471 = abs(t2470);
float t2472 = (t2471/2);
float t2473 = sin(t2472);
float t2474 = (t2473*t2473);
float t2475 = (t2461*t2474);
float t2476 = (t2458+t2475);
float t2477 = sqrt(t2476);
float t2478 = asin(t2477);
float t2479 = (2*t2478);
float t2480 = abs(t2479);
float t2481 = (3.1415927/2);
float t2482 = (t8-t2481);
float t2483 = (3.1415927/2);
float t2484 = (t2287-t2483);
float t2485 = (t2482-t2484);
float t2486 = abs(t2485);
float t2487 = (t2486/2);
float t2488 = sin(t2487);
float t2489 = (t2488*t2488);
float t2490 = cos(t2484);
float t2491 = cos(t2482);
float t2492 = (t2490*t2491);
float t2493 = (t118+3.1415927);
float t2494 = (3.1415927*2);
float t2495 = mod(t2493,t2494);
float t2496 = (t2495-3.1415927);
float t2497 = (t2325+3.1415927);
float t2498 = (3.1415927*2);
float t2499 = mod(t2497,t2498);
float t2500 = (t2499-3.1415927);
float t2501 = (t2496-t2500);
float t2502 = abs(t2501);
float t2503 = (t2502/2);
float t2504 = sin(t2503);
float t2505 = (t2504*t2504);
float t2506 = (t2492*t2505);
float t2507 = (t2489+t2506);
float t2508 = sqrt(t2507);
float t2509 = asin(t2508);
float t2510 = (2*t2509);
float t2511 = abs(t2510);
bool t2512 = (t2480>=t2511);
float t2513;
if(t2512){
t2513 = t2480;
} else {
t2513 = t2511;
}
t2404 = t2513;
}
float t2514 = abs(t2404);
float t2515 = step(float(2.0e-4),t2514);
float t2516 = (1-t2515);
float t2517 = (t1346*t1582);
float t2518 = (t2517*float(842.378));
float t2519 = fract(t2518);
float t2520 = (t2519+float(45.32));
float t2521 = (t2520+u6.u0);
float t2522 = (t2519*t2521);
float t2523 = (t1362*t1346);
float t2524 = (t2523*float(1734.048));
float t2525 = fract(t2524);
float t2526 = (t2525+float(45.32));
float t2527 = (t2526+u6.u0);
float t2528 = (t2525*t2527);
float t2529 = (t2522+t2528);
float t2530 = (t2519+t2529);
float t2531 = (t2525+t2529);
float t2532 = (t2530*t2531);
float t2533 = fract(t2532);
float t2534 = step(float(0.2),t2533);
float t2535 = (t2516*t2534);
float t2536 = (3.1415927/2);
float t2537 = (t2261-t2536);
float t2538 = (3.1415927/2);
float t2539 = (t2287-t2538);
float t2540 = (t2537-t2539);
float t2541 = abs(t2540);
float t2542 = (t2541/2);
float t2543 = sin(t2542);
float t2544 = (t2543*t2543);
float t2545 = cos(t2539);
float t2546 = cos(t2537);
float t2547 = (t2545*t2546);
float t2548 = (t2309+3.1415927);
float t2549 = (3.1415927*2);
float t2550 = mod(t2548,t2549);
float t2551 = (t2550-3.1415927);
float t2552 = (t2325+3.1415927);
float t2553 = (3.1415927*2);
float t2554 = mod(t2552,t2553);
float t2555 = (t2554-3.1415927);
float t2556 = (t2551-t2555);
float t2557 = abs(t2556);
float t2558 = (t2557/2);
float t2559 = sin(t2558);
float t2560 = (t2559*t2559);
float t2561 = (t2547*t2560);
float t2562 = (t2544+t2561);
float t2563 = sqrt(t2562);
float t2564 = asin(t2563);
float t2565 = (2*t2564);
float t2566 = (t2565/t1344);
float t2567 = (1-t2566);
float t2568 = (t1346/36);
float t2569 = (t2568*float(842.378));
float t2570 = fract(t2569);
float t2571 = (t2570+float(45.32));
float t2572 = (t2571+u6.u0);
float t2573 = (t2570*t2572);
float t2574 = (t1362/t1359);
float t2575 = (t2574*float(1734.048));
float t2576 = fract(t2575);
float t2577 = (t2576+float(45.32));
float t2578 = (t2577+u6.u0);
float t2579 = (t2576*t2578);
float t2580 = (t2573+t2579);
float t2581 = (t2570+t2580);
float t2582 = (t2576+t2580);
float t2583 = (t2581*t2582);
float t2584 = fract(t2583);
float t2585 = (t2584*float(8.0e-3));
float t2586 = (float(1.0e-3)+t2585);
float t2587 = (t2584*173);
float t2588 = fract(t2587);
float t2589 = step(float(0.66),t2588);
float t2590 = (t2589*float(3.0e-3));
float t2591 = (t2586-t2590);
float t2592 = (t2591*float(0.8));
float t2593 = (t1346/36);
float t2594 = (t2593*float(842.378));
float t2595 = fract(t2594);
float t2596 = (t2595+float(45.32));
float t2597 = (t2596+u6.u0);
float t2598 = (t2595*t2597);
float t2599 = (t1582/t1359);
float t2600 = (t2599*float(1734.048));
float t2601 = fract(t2600);
float t2602 = (t2601+float(45.32));
float t2603 = (t2602+u6.u0);
float t2604 = (t2601*t2603);
float t2605 = (t2598+t2604);
float t2606 = (t2595+t2605);
float t2607 = (t2601+t2605);
float t2608 = (t2606*t2607);
float t2609 = fract(t2608);
float t2610 = (t2609*float(8.0e-3));
float t2611 = (float(1.0e-3)+t2610);
float t2612 = (t2609*173);
float t2613 = fract(t2612);
float t2614 = step(float(0.66),t2613);
float t2615 = (t2614*float(3.0e-3));
float t2616 = (t2611-t2615);
float t2617 = (t2616*float(0.8));
float t2618 = (t2592-t2617);
float t2619 = abs(t2618);
float t2620 = (t2619-float(1.0e-3));
float t2621 = (t2620/float(8.0e-3));
float t2622 = (1-t2621);
float t2623 = (t2622*t2622);
float t2624 = (t2567*t2623);
float t2625 = (t2535*t2624);
float t2626 = (u4.u0*t2533);
float t2627 = (t2626*3);
float t2628 = sin(t2627);
float t2629 = (t2628+1);
float t2630 = (t2629/2);
float t2631 = (t2630*float(0.66));
float t2632 = (t2631+float(0.33));
float t2633 = (t2625*t2632);
float t2634 = (float(0.2)*t2633);
bool t2635 = (0>=t2634);
float t2636;
if(t2635){
t2636 = 0;
} else {
t2636 = t2634;
}
float t2637 = (t2636*1);
float t2638 = (t2237+t2637);
float t2639 = (t2011*t1344);
float t2640 = (t2011/36);
float t2641 = (t2640*float(842.378));
float t2642 = fract(t2641);
float t2643 = (t2642+float(45.32));
float t2644 = (t2643+u6.u0);
float t2645 = (t2642*t2644);
float t2646 = (t2027/t2024);
float t2647 = (t2646*float(1734.048));
float t2648 = fract(t2647);
float t2649 = (t2648+float(45.32));
float t2650 = (t2649+u6.u0);
float t2651 = (t2648*t2650);
float t2652 = (t2645+t2651);
float t2653 = (t2642+t2652);
float t2654 = (t2648+t2652);
float t2655 = (t2653*t2654);
float t2656 = fract(t2655);
float t2657 = (t2656*float(2852.02));
float t2658 = fract(t2657);
float t2659 = (t2658-float(0.5));
float t2660 = (t2659*t1344);
float t2661 = (t2660*float(0.75));
float t2662 = (t2639+t2661);
float t2663 = (3.1415927/2);
float t2664 = (t2662-t2663);
float t2665 = (t1346*t1344);
float t2666 = (t1346/36);
float t2667 = (t2666*float(842.378));
float t2668 = fract(t2667);
float t2669 = (t2668+float(45.32));
float t2670 = (t2669+u6.u0);
float t2671 = (t2668*t2670);
float t2672 = (t1362/t1359);
float t2673 = (t2672*float(1734.048));
float t2674 = fract(t2673);
float t2675 = (t2674+float(45.32));
float t2676 = (t2675+u6.u0);
float t2677 = (t2674*t2676);
float t2678 = (t2671+t2677);
float t2679 = (t2668+t2678);
float t2680 = (t2674+t2678);
float t2681 = (t2679*t2680);
float t2682 = fract(t2681);
float t2683 = (t2682*float(2852.02));
float t2684 = fract(t2683);
float t2685 = (t2684-float(0.5));
float t2686 = (t2685*t1344);
float t2687 = (t2686*float(0.75));
float t2688 = (t2665+t2687);
float t2689 = (3.1415927/2);
float t2690 = (t2688-t2689);
float t2691 = (t2664-t2690);
float t2692 = abs(t2691);
float t2693 = (t2692/2);
float t2694 = sin(t2693);
float t2695 = (t2694*t2694);
float t2696 = cos(t2690);
float t2697 = cos(t2664);
float t2698 = (t2696*t2697);
float t2699 = (3.1415927/t2024);
float t2700 = (t2027*t2699);
float t2701 = (t2656*float(97372.83));
float t2702 = fract(t2701);
float t2703 = (t2702-float(0.5));
float t2704 = (3.1415927/t2024);
float t2705 = (t2703*t2704);
float t2706 = (t2705*float(0.75));
float t2707 = (t2700+t2706);
float t2708 = (t2707+3.1415927);
float t2709 = mod(t2708,t1433);
float t2710 = (t2709-3.1415927);
float t2711 = (t2710+3.1415927);
float t2712 = (3.1415927*2);
float t2713 = mod(t2711,t2712);
float t2714 = (t2713-3.1415927);
float t2715 = (3.1415927/t1359);
float t2716 = (t1362*t2715);
float t2717 = (t2682*float(97372.83));
float t2718 = fract(t2717);
float t2719 = (t2718-float(0.5));
float t2720 = (3.1415927/t1359);
float t2721 = (t2719*t2720);
float t2722 = (t2721*float(0.75));
float t2723 = (t2716+t2722);
float t2724 = (t2723+3.1415927);
float t2725 = mod(t2724,t1433);
float t2726 = (t2725-3.1415927);
float t2727 = (t2726+3.1415927);
float t2728 = (3.1415927*2);
float t2729 = mod(t2727,t2728);
float t2730 = (t2729-3.1415927);
float t2731 = (t2714-t2730);
float t2732 = abs(t2731);
float t2733 = (t2732/2);
float t2734 = sin(t2733);
float t2735 = (t2734*t2734);
float t2736 = (t2698*t2735);
float t2737 = (t2695+t2736);
float t2738 = sqrt(t2737);
float t2739 = asin(t2738);
float t2740 = (2*t2739);
float t2741 = (3.1415927/2);
float t2742 = (t8-t2741);
float t2743 = (3.1415927/2);
float t2744 = (t2688-t2743);
float t2745 = (t2742-t2744);
float t2746 = abs(t2745);
float t2747 = (t2746/2);
float t2748 = sin(t2747);
float t2749 = (t2748*t2748);
float t2750 = cos(t2744);
float t2751 = cos(t2742);
float t2752 = (t2750*t2751);
float t2753 = (t118+3.1415927);
float t2754 = (3.1415927*2);
float t2755 = mod(t2753,t2754);
float t2756 = (t2755-3.1415927);
float t2757 = (t2726+3.1415927);
float t2758 = (3.1415927*2);
float t2759 = mod(t2757,t2758);
float t2760 = (t2759-3.1415927);
float t2761 = (t2756-t2760);
float t2762 = abs(t2761);
float t2763 = (t2762/2);
float t2764 = sin(t2763);
float t2765 = (t2764*t2764);
float t2766 = (t2752*t2765);
float t2767 = (t2749+t2766);
float t2768 = sqrt(t2767);
float t2769 = asin(t2768);
float t2770 = (2*t2769);
float t2771 = (t2740-t2770);
float t2772 = (3.1415927/2);
float t2773 = (t8-t2772);
float t2774 = (3.1415927/2);
float t2775 = (t2662-t2774);
float t2776 = (t2773-t2775);
float t2777 = abs(t2776);
float t2778 = (t2777/2);
float t2779 = sin(t2778);
float t2780 = (t2779*t2779);
float t2781 = cos(t2775);
float t2782 = cos(t2773);
float t2783 = (t2781*t2782);
float t2784 = (t118+3.1415927);
float t2785 = (3.1415927*2);
float t2786 = mod(t2784,t2785);
float t2787 = (t2786-3.1415927);
float t2788 = (t2710+3.1415927);
float t2789 = (3.1415927*2);
float t2790 = mod(t2788,t2789);
float t2791 = (t2790-3.1415927);
float t2792 = (t2787-t2791);
float t2793 = abs(t2792);
float t2794 = (t2793/2);
float t2795 = sin(t2794);
float t2796 = (t2795*t2795);
float t2797 = (t2783*t2796);
float t2798 = (t2780+t2797);
float t2799 = sqrt(t2798);
float t2800 = asin(t2799);
float t2801 = (2*t2800);
float t2802 = (t2771-t2801);
float t2803 = abs(t2802);
bool t2804 = (float(1.0e-4)>t2803);
float t2805;
if(t2804){
float t2806 = cos(t2688);
float t2807 = (1*t2806);
float t2808 = sin(t2662);
float t2809 = (1*t2808);
float t2810 = cos(t2710);
float t2811 = (t2809*t2810);
float t2812 = (t2807*t2811);
float t2813 = sin(t2688);
float t2814 = (1*t2813);
float t2815 = cos(t2726);
float t2816 = (t2814*t2815);
float t2817 = cos(t2662);
float t2818 = (1*t2817);
float t2819 = (t2816*t2818);
float t2820 = (t2812-t2819);
float t2821 = sin(t8);
float t2822 = (1*t2821);
float t2823 = sin(t118);
float t2824 = (t2822*t2823);
float t2825 = (t2820*t2824);
float t2826 = sin(t2662);
float t2827 = (1*t2826);
float t2828 = sin(t2710);
float t2829 = (t2827*t2828);
float t2830 = (t2816*t2829);
float t2831 = sin(t2688);
float t2832 = (1*t2831);
float t2833 = sin(t2726);
float t2834 = (t2832*t2833);
float t2835 = (t2834*t2811);
float t2836 = (t2830-t2835);
float t2837 = cos(t8);
float t2838 = (1*t2837);
float t2839 = (t2836*t2838);
float t2840 = (t2825+t2839);
float t2841 = (t2834*t2818);
float t2842 = (t2807*t2829);
float t2843 = (t2841-t2842);
float t2844 = sin(t8);
float t2845 = (1*t2844);
float t2846 = cos(t118);
float t2847 = (t2845*t2846);
float t2848 = (t2843*t2847);
float t2849 = (t2840+t2848);
float t2850 = abs(t2849);
t2805 = t2850;
} else {
float t2851 = (3.1415927/2);
float t2852 = (t8-t2851);
float t2853 = (3.1415927/2);
float t2854 = (t2662-t2853);
float t2855 = (t2852-t2854);
float t2856 = abs(t2855);
float t2857 = (t2856/2);
float t2858 = sin(t2857);
float t2859 = (t2858*t2858);
float t2860 = cos(t2854);
float t2861 = cos(t2852);
float t2862 = (t2860*t2861);
float t2863 = (t118+3.1415927);
float t2864 = (3.1415927*2);
float t2865 = mod(t2863,t2864);
float t2866 = (t2865-3.1415927);
float t2867 = (t2710+3.1415927);
float t2868 = (3.1415927*2);
float t2869 = mod(t2867,t2868);
float t2870 = (t2869-3.1415927);
float t2871 = (t2866-t2870);
float t2872 = abs(t2871);
float t2873 = (t2872/2);
float t2874 = sin(t2873);
float t2875 = (t2874*t2874);
float t2876 = (t2862*t2875);
float t2877 = (t2859+t2876);
float t2878 = sqrt(t2877);
float t2879 = asin(t2878);
float t2880 = (2*t2879);
float t2881 = abs(t2880);
float t2882 = (3.1415927/2);
float t2883 = (t8-t2882);
float t2884 = (3.1415927/2);
float t2885 = (t2688-t2884);
float t2886 = (t2883-t2885);
float t2887 = abs(t2886);
float t2888 = (t2887/2);
float t2889 = sin(t2888);
float t2890 = (t2889*t2889);
float t2891 = cos(t2885);
float t2892 = cos(t2883);
float t2893 = (t2891*t2892);
float t2894 = (t118+3.1415927);
float t2895 = (3.1415927*2);
float t2896 = mod(t2894,t2895);
float t2897 = (t2896-3.1415927);
float t2898 = (t2726+3.1415927);
float t2899 = (3.1415927*2);
float t2900 = mod(t2898,t2899);
float t2901 = (t2900-3.1415927);
float t2902 = (t2897-t2901);
float t2903 = abs(t2902);
float t2904 = (t2903/2);
float t2905 = sin(t2904);
float t2906 = (t2905*t2905);
float t2907 = (t2893*t2906);
float t2908 = (t2890+t2907);
float t2909 = sqrt(t2908);
float t2910 = asin(t2909);
float t2911 = (2*t2910);
float t2912 = abs(t2911);
bool t2913 = (t2881>=t2912);
float t2914;
if(t2913){
t2914 = t2881;
} else {
t2914 = t2912;
}
t2805 = t2914;
}
float t2915 = abs(t2805);
float t2916 = step(float(2.0e-4),t2915);
float t2917 = (1-t2916);
float t2918 = (t1346*t2027);
float t2919 = (t2918*float(842.378));
float t2920 = fract(t2919);
float t2921 = (t2920+float(45.32));
float t2922 = (t2921+u6.u0);
float t2923 = (t2920*t2922);
float t2924 = (t1362*t2011);
float t2925 = (t2924*float(1734.048));
float t2926 = fract(t2925);
float t2927 = (t2926+float(45.32));
float t2928 = (t2927+u6.u0);
float t2929 = (t2926*t2928);
float t2930 = (t2923+t2929);
float t2931 = (t2920+t2930);
float t2932 = (t2926+t2930);
float t2933 = (t2931*t2932);
float t2934 = fract(t2933);
float t2935 = step(float(0.2),t2934);
float t2936 = (t2917*t2935);
float t2937 = (3.1415927/2);
float t2938 = (t2662-t2937);
float t2939 = (3.1415927/2);
float t2940 = (t2688-t2939);
float t2941 = (t2938-t2940);
float t2942 = abs(t2941);
float t2943 = (t2942/2);
float t2944 = sin(t2943);
float t2945 = (t2944*t2944);
float t2946 = cos(t2940);
float t2947 = cos(t2938);
float t2948 = (t2946*t2947);
float t2949 = (t2710+3.1415927);
float t2950 = (3.1415927*2);
float t2951 = mod(t2949,t2950);
float t2952 = (t2951-3.1415927);
float t2953 = (t2726+3.1415927);
float t2954 = (3.1415927*2);
float t2955 = mod(t2953,t2954);
float t2956 = (t2955-3.1415927);
float t2957 = (t2952-t2956);
float t2958 = abs(t2957);
float t2959 = (t2958/2);
float t2960 = sin(t2959);
float t2961 = (t2960*t2960);
float t2962 = (t2948*t2961);
float t2963 = (t2945+t2962);
float t2964 = sqrt(t2963);
float t2965 = asin(t2964);
float t2966 = (2*t2965);
float t2967 = (t2966/t1344);
float t2968 = (1-t2967);
float t2969 = (t1346/36);
float t2970 = (t2969*float(842.378));
float t2971 = fract(t2970);
float t2972 = (t2971+float(45.32));
float t2973 = (t2972+u6.u0);
float t2974 = (t2971*t2973);
float t2975 = (t1362/t1359);
float t2976 = (t2975*float(1734.048));
float t2977 = fract(t2976);
float t2978 = (t2977+float(45.32));
float t2979 = (t2978+u6.u0);
float t2980 = (t2977*t2979);
float t2981 = (t2974+t2980);
float t2982 = (t2971+t2981);
float t2983 = (t2977+t2981);
float t2984 = (t2982*t2983);
float t2985 = fract(t2984);
float t2986 = (t2985*float(8.0e-3));
float t2987 = (float(1.0e-3)+t2986);
float t2988 = (t2985*173);
float t2989 = fract(t2988);
float t2990 = step(float(0.66),t2989);
float t2991 = (t2990*float(3.0e-3));
float t2992 = (t2987-t2991);
float t2993 = (t2992*float(0.8));
float t2994 = (t2011/36);
float t2995 = (t2994*float(842.378));
float t2996 = fract(t2995);
float t2997 = (t2996+float(45.32));
float t2998 = (t2997+u6.u0);
float t2999 = (t2996*t2998);
float t3000 = (t2027/t2024);
float t3001 = (t3000*float(1734.048));
float t3002 = fract(t3001);
float t3003 = (t3002+float(45.32));
float t3004 = (t3003+u6.u0);
float t3005 = (t3002*t3004);
float t3006 = (t2999+t3005);
float t3007 = (t2996+t3006);
float t3008 = (t3002+t3006);
float t3009 = (t3007*t3008);
float t3010 = fract(t3009);
float t3011 = (t3010*float(8.0e-3));
float t3012 = (float(1.0e-3)+t3011);
float t3013 = (t3010*173);
float t3014 = fract(t3013);
float t3015 = step(float(0.66),t3014);
float t3016 = (t3015*float(3.0e-3));
float t3017 = (t3012-t3016);
float t3018 = (t3017*float(0.8));
float t3019 = (t2993-t3018);
float t3020 = abs(t3019);
float t3021 = (t3020-float(1.0e-3));
float t3022 = (t3021/float(8.0e-3));
float t3023 = (1-t3022);
float t3024 = (t3023*t3023);
float t3025 = (t2968*t3024);
float t3026 = (t2936*t3025);
float t3027 = (u4.u0*t2934);
float t3028 = (t3027*3);
float t3029 = sin(t3028);
float t3030 = (t3029+1);
float t3031 = (t3030/2);
float t3032 = (t3031*float(0.66));
float t3033 = (t3032+float(0.33));
float t3034 = (t3026*t3033);
float t3035 = (float(0.2)*t3034);
bool t3036 = (0>=t3035);
float t3037;
if(t3036){
t3037 = 0;
} else {
t3037 = t3035;
}
float t3038 = (t3037*1);
float t3039 = (t2638+t3038);
float t3040 = (t2011*t1344);
float t3041 = (t2011/36);
float t3042 = (t3041*float(842.378));
float t3043 = fract(t3042);
float t3044 = (t3043+float(45.32));
float t3045 = (t3044+u6.u0);
float t3046 = (t3043*t3045);
float t3047 = (t2027+1);
float t3048 = (t3047/t2024);
float t3049 = (t3048*float(1734.048));
float t3050 = fract(t3049);
float t3051 = (t3050+float(45.32));
float t3052 = (t3051+u6.u0);
float t3053 = (t3050*t3052);
float t3054 = (t3046+t3053);
float t3055 = (t3043+t3054);
float t3056 = (t3050+t3054);
float t3057 = (t3055*t3056);
float t3058 = fract(t3057);
float t3059 = (t3058*float(2852.02));
float t3060 = fract(t3059);
float t3061 = (t3060-float(0.5));
float t3062 = (t3061*t1344);
float t3063 = (t3062*float(0.75));
float t3064 = (t3040+t3063);
float t3065 = (3.1415927/2);
float t3066 = (t3064-t3065);
float t3067 = (t2011*t1344);
float t3068 = (t2011/36);
float t3069 = (t3068*float(842.378));
float t3070 = fract(t3069);
float t3071 = (t3070+float(45.32));
float t3072 = (t3071+u6.u0);
float t3073 = (t3070*t3072);
float t3074 = (t2027/t2024);
float t3075 = (t3074*float(1734.048));
float t3076 = fract(t3075);
float t3077 = (t3076+float(45.32));
float t3078 = (t3077+u6.u0);
float t3079 = (t3076*t3078);
float t3080 = (t3073+t3079);
float t3081 = (t3070+t3080);
float t3082 = (t3076+t3080);
float t3083 = (t3081*t3082);
float t3084 = fract(t3083);
float t3085 = (t3084*float(2852.02));
float t3086 = fract(t3085);
float t3087 = (t3086-float(0.5));
float t3088 = (t3087*t1344);
float t3089 = (t3088*float(0.75));
float t3090 = (t3067+t3089);
float t3091 = (3.1415927/2);
float t3092 = (t3090-t3091);
float t3093 = (t3066-t3092);
float t3094 = abs(t3093);
float t3095 = (t3094/2);
float t3096 = sin(t3095);
float t3097 = (t3096*t3096);
float t3098 = cos(t3092);
float t3099 = cos(t3066);
float t3100 = (t3098*t3099);
float t3101 = (3.1415927/t2024);
float t3102 = (t3047*t3101);
float t3103 = (t3058*float(97372.83));
float t3104 = fract(t3103);
float t3105 = (t3104-float(0.5));
float t3106 = (3.1415927/t2024);
float t3107 = (t3105*t3106);
float t3108 = (t3107*float(0.75));
float t3109 = (t3102+t3108);
float t3110 = (t3109+3.1415927);
float t3111 = mod(t3110,t1433);
float t3112 = (t3111-3.1415927);
float t3113 = (t3112+3.1415927);
float t3114 = (3.1415927*2);
float t3115 = mod(t3113,t3114);
float t3116 = (t3115-3.1415927);
float t3117 = (3.1415927/t2024);
float t3118 = (t2027*t3117);
float t3119 = (t3084*float(97372.83));
float t3120 = fract(t3119);
float t3121 = (t3120-float(0.5));
float t3122 = (3.1415927/t2024);
float t3123 = (t3121*t3122);
float t3124 = (t3123*float(0.75));
float t3125 = (t3118+t3124);
float t3126 = (t3125+3.1415927);
float t3127 = mod(t3126,t1433);
float t3128 = (t3127-3.1415927);
float t3129 = (t3128+3.1415927);
float t3130 = (3.1415927*2);
float t3131 = mod(t3129,t3130);
float t3132 = (t3131-3.1415927);
float t3133 = (t3116-t3132);
float t3134 = abs(t3133);
float t3135 = (t3134/2);
float t3136 = sin(t3135);
float t3137 = (t3136*t3136);
float t3138 = (t3100*t3137);
float t3139 = (t3097+t3138);
float t3140 = sqrt(t3139);
float t3141 = asin(t3140);
float t3142 = (2*t3141);
float t3143 = (3.1415927/2);
float t3144 = (t8-t3143);
float t3145 = (3.1415927/2);
float t3146 = (t3090-t3145);
float t3147 = (t3144-t3146);
float t3148 = abs(t3147);
float t3149 = (t3148/2);
float t3150 = sin(t3149);
float t3151 = (t3150*t3150);
float t3152 = cos(t3146);
float t3153 = cos(t3144);
float t3154 = (t3152*t3153);
float t3155 = (t118+3.1415927);
float t3156 = (3.1415927*2);
float t3157 = mod(t3155,t3156);
float t3158 = (t3157-3.1415927);
float t3159 = (t3128+3.1415927);
float t3160 = (3.1415927*2);
float t3161 = mod(t3159,t3160);
float t3162 = (t3161-3.1415927);
float t3163 = (t3158-t3162);
float t3164 = abs(t3163);
float t3165 = (t3164/2);
float t3166 = sin(t3165);
float t3167 = (t3166*t3166);
float t3168 = (t3154*t3167);
float t3169 = (t3151+t3168);
float t3170 = sqrt(t3169);
float t3171 = asin(t3170);
float t3172 = (2*t3171);
float t3173 = (t3142-t3172);
float t3174 = (3.1415927/2);
float t3175 = (t8-t3174);
float t3176 = (3.1415927/2);
float t3177 = (t3064-t3176);
float t3178 = (t3175-t3177);
float t3179 = abs(t3178);
float t3180 = (t3179/2);
float t3181 = sin(t3180);
float t3182 = (t3181*t3181);
float t3183 = cos(t3177);
float t3184 = cos(t3175);
float t3185 = (t3183*t3184);
float t3186 = (t118+3.1415927);
float t3187 = (3.1415927*2);
float t3188 = mod(t3186,t3187);
float t3189 = (t3188-3.1415927);
float t3190 = (t3112+3.1415927);
float t3191 = (3.1415927*2);
float t3192 = mod(t3190,t3191);
float t3193 = (t3192-3.1415927);
float t3194 = (t3189-t3193);
float t3195 = abs(t3194);
float t3196 = (t3195/2);
float t3197 = sin(t3196);
float t3198 = (t3197*t3197);
float t3199 = (t3185*t3198);
float t3200 = (t3182+t3199);
float t3201 = sqrt(t3200);
float t3202 = asin(t3201);
float t3203 = (2*t3202);
float t3204 = (t3173-t3203);
float t3205 = abs(t3204);
bool t3206 = (float(1.0e-4)>t3205);
float t3207;
if(t3206){
float t3208 = cos(t3090);
float t3209 = (1*t3208);
float t3210 = sin(t3064);
float t3211 = (1*t3210);
float t3212 = cos(t3112);
float t3213 = (t3211*t3212);
float t3214 = (t3209*t3213);
float t3215 = sin(t3090);
float t3216 = (1*t3215);
float t3217 = cos(t3128);
float t3218 = (t3216*t3217);
float t3219 = cos(t3064);
float t3220 = (1*t3219);
float t3221 = (t3218*t3220);
float t3222 = (t3214-t3221);
float t3223 = sin(t8);
float t3224 = (1*t3223);
float t3225 = sin(t118);
float t3226 = (t3224*t3225);
float t3227 = (t3222*t3226);
float t3228 = sin(t3064);
float t3229 = (1*t3228);
float t3230 = sin(t3112);
float t3231 = (t3229*t3230);
float t3232 = (t3218*t3231);
float t3233 = sin(t3090);
float t3234 = (1*t3233);
float t3235 = sin(t3128);
float t3236 = (t3234*t3235);
float t3237 = (t3236*t3213);
float t3238 = (t3232-t3237);
float t3239 = cos(t8);
float t3240 = (1*t3239);
float t3241 = (t3238*t3240);
float t3242 = (t3227+t3241);
float t3243 = (t3236*t3220);
float t3244 = (t3209*t3231);
float t3245 = (t3243-t3244);
float t3246 = sin(t8);
float t3247 = (1*t3246);
float t3248 = cos(t118);
float t3249 = (t3247*t3248);
float t3250 = (t3245*t3249);
float t3251 = (t3242+t3250);
float t3252 = abs(t3251);
t3207 = t3252;
} else {
float t3253 = (3.1415927/2);
float t3254 = (t8-t3253);
float t3255 = (3.1415927/2);
float t3256 = (t3064-t3255);
float t3257 = (t3254-t3256);
float t3258 = abs(t3257);
float t3259 = (t3258/2);
float t3260 = sin(t3259);
float t3261 = (t3260*t3260);
float t3262 = cos(t3256);
float t3263 = cos(t3254);
float t3264 = (t3262*t3263);
float t3265 = (t118+3.1415927);
float t3266 = (3.1415927*2);
float t3267 = mod(t3265,t3266);
float t3268 = (t3267-3.1415927);
float t3269 = (t3112+3.1415927);
float t3270 = (3.1415927*2);
float t3271 = mod(t3269,t3270);
float t3272 = (t3271-3.1415927);
float t3273 = (t3268-t3272);
float t3274 = abs(t3273);
float t3275 = (t3274/2);
float t3276 = sin(t3275);
float t3277 = (t3276*t3276);
float t3278 = (t3264*t3277);
float t3279 = (t3261+t3278);
float t3280 = sqrt(t3279);
float t3281 = asin(t3280);
float t3282 = (2*t3281);
float t3283 = abs(t3282);
float t3284 = (3.1415927/2);
float t3285 = (t8-t3284);
float t3286 = (3.1415927/2);
float t3287 = (t3090-t3286);
float t3288 = (t3285-t3287);
float t3289 = abs(t3288);
float t3290 = (t3289/2);
float t3291 = sin(t3290);
float t3292 = (t3291*t3291);
float t3293 = cos(t3287);
float t3294 = cos(t3285);
float t3295 = (t3293*t3294);
float t3296 = (t118+3.1415927);
float t3297 = (3.1415927*2);
float t3298 = mod(t3296,t3297);
float t3299 = (t3298-3.1415927);
float t3300 = (t3128+3.1415927);
float t3301 = (3.1415927*2);
float t3302 = mod(t3300,t3301);
float t3303 = (t3302-3.1415927);
float t3304 = (t3299-t3303);
float t3305 = abs(t3304);
float t3306 = (t3305/2);
float t3307 = sin(t3306);
float t3308 = (t3307*t3307);
float t3309 = (t3295*t3308);
float t3310 = (t3292+t3309);
float t3311 = sqrt(t3310);
float t3312 = asin(t3311);
float t3313 = (2*t3312);
float t3314 = abs(t3313);
bool t3315 = (t3283>=t3314);
float t3316;
if(t3315){
t3316 = t3283;
} else {
t3316 = t3314;
}
t3207 = t3316;
}
float t3317 = abs(t3207);
float t3318 = step(float(2.0e-4),t3317);
float t3319 = (1-t3318);
float t3320 = (t2011*t3047);
float t3321 = (t3320*float(842.378));
float t3322 = fract(t3321);
float t3323 = (t3322+float(45.32));
float t3324 = (t3323+u6.u0);
float t3325 = (t3322*t3324);
float t3326 = (t2027*t2011);
float t3327 = (t3326*float(1734.048));
float t3328 = fract(t3327);
float t3329 = (t3328+float(45.32));
float t3330 = (t3329+u6.u0);
float t3331 = (t3328*t3330);
float t3332 = (t3325+t3331);
float t3333 = (t3322+t3332);
float t3334 = (t3328+t3332);
float t3335 = (t3333*t3334);
float t3336 = fract(t3335);
float t3337 = step(float(0.2),t3336);
float t3338 = (t3319*t3337);
float t3339 = (3.1415927/2);
float t3340 = (t3064-t3339);
float t3341 = (3.1415927/2);
float t3342 = (t3090-t3341);
float t3343 = (t3340-t3342);
float t3344 = abs(t3343);
float t3345 = (t3344/2);
float t3346 = sin(t3345);
float t3347 = (t3346*t3346);
float t3348 = cos(t3342);
float t3349 = cos(t3340);
float t3350 = (t3348*t3349);
float t3351 = (t3112+3.1415927);
float t3352 = (3.1415927*2);
float t3353 = mod(t3351,t3352);
float t3354 = (t3353-3.1415927);
float t3355 = (t3128+3.1415927);
float t3356 = (3.1415927*2);
float t3357 = mod(t3355,t3356);
float t3358 = (t3357-3.1415927);
float t3359 = (t3354-t3358);
float t3360 = abs(t3359);
float t3361 = (t3360/2);
float t3362 = sin(t3361);
float t3363 = (t3362*t3362);
float t3364 = (t3350*t3363);
float t3365 = (t3347+t3364);
float t3366 = sqrt(t3365);
float t3367 = asin(t3366);
float t3368 = (2*t3367);
float t3369 = (t3368/t1344);
float t3370 = (1-t3369);
float t3371 = (t2011/36);
float t3372 = (t3371*float(842.378));
float t3373 = fract(t3372);
float t3374 = (t3373+float(45.32));
float t3375 = (t3374+u6.u0);
float t3376 = (t3373*t3375);
float t3377 = (t2027/t2024);
float t3378 = (t3377*float(1734.048));
float t3379 = fract(t3378);
float t3380 = (t3379+float(45.32));
float t3381 = (t3380+u6.u0);
float t3382 = (t3379*t3381);
float t3383 = (t3376+t3382);
float t3384 = (t3373+t3383);
float t3385 = (t3379+t3383);
float t3386 = (t3384*t3385);
float t3387 = fract(t3386);
float t3388 = (t3387*float(8.0e-3));
float t3389 = (float(1.0e-3)+t3388);
float t3390 = (t3387*173);
float t3391 = fract(t3390);
float t3392 = step(float(0.66),t3391);
float t3393 = (t3392*float(3.0e-3));
float t3394 = (t3389-t3393);
float t3395 = (t3394*float(0.8));
float t3396 = (t2011/36);
float t3397 = (t3396*float(842.378));
float t3398 = fract(t3397);
float t3399 = (t3398+float(45.32));
float t3400 = (t3399+u6.u0);
float t3401 = (t3398*t3400);
float t3402 = (t3047/t2024);
float t3403 = (t3402*float(1734.048));
float t3404 = fract(t3403);
float t3405 = (t3404+float(45.32));
float t3406 = (t3405+u6.u0);
float t3407 = (t3404*t3406);
float t3408 = (t3401+t3407);
float t3409 = (t3398+t3408);
float t3410 = (t3404+t3408);
float t3411 = (t3409*t3410);
float t3412 = fract(t3411);
float t3413 = (t3412*float(8.0e-3));
float t3414 = (float(1.0e-3)+t3413);
float t3415 = (t3412*173);
float t3416 = fract(t3415);
float t3417 = step(float(0.66),t3416);
float t3418 = (t3417*float(3.0e-3));
float t3419 = (t3414-t3418);
float t3420 = (t3419*float(0.8));
float t3421 = (t3395-t3420);
float t3422 = abs(t3421);
float t3423 = (t3422-float(1.0e-3));
float t3424 = (t3423/float(8.0e-3));
float t3425 = (1-t3424);
float t3426 = (t3425*t3425);
float t3427 = (t3370*t3426);
float t3428 = (t3338*t3427);
float t3429 = (u4.u0*t3336);
float t3430 = (t3429*3);
float t3431 = sin(t3430);
float t3432 = (t3431+1);
float t3433 = (t3432/2);
float t3434 = (t3433*float(0.66));
float t3435 = (t3434+float(0.33));
float t3436 = (t3428*t3435);
float t3437 = (float(0.2)*t3436);
bool t3438 = (0>=t3437);
float t3439;
if(t3438){
t3439 = 0;
} else {
t3439 = t3437;
}
float t3440 = (t3439*1);
float t3441 = (t3039+t3440);
float t3442 = (t2011*t1344);
float t3443 = (t2011/36);
float t3444 = (t3443*float(842.378));
float t3445 = fract(t3444);
float t3446 = (t3445+float(45.32));
float t3447 = (t3446+u6.u0);
float t3448 = (t3445*t3447);
float t3449 = (t3047/t2024);
float t3450 = (t3449*float(1734.048));
float t3451 = fract(t3450);
float t3452 = (t3451+float(45.32));
float t3453 = (t3452+u6.u0);
float t3454 = (t3451*t3453);
float t3455 = (t3448+t3454);
float t3456 = (t3445+t3455);
float t3457 = (t3451+t3455);
float t3458 = (t3456*t3457);
float t3459 = fract(t3458);
float t3460 = (t3459*float(2852.02));
float t3461 = fract(t3460);
float t3462 = (t3461-float(0.5));
float t3463 = (t3462*t1344);
float t3464 = (t3463*float(0.75));
float t3465 = (t3442+t3464);
float t3466 = (3.1415927/2);
float t3467 = (t3465-t3466);
float t3468 = (t1346*t1344);
float t3469 = (t1346/36);
float t3470 = (t3469*float(842.378));
float t3471 = fract(t3470);
float t3472 = (t3471+float(45.32));
float t3473 = (t3472+u6.u0);
float t3474 = (t3471*t3473);
float t3475 = (t1582/t1359);
float t3476 = (t3475*float(1734.048));
float t3477 = fract(t3476);
float t3478 = (t3477+float(45.32));
float t3479 = (t3478+u6.u0);
float t3480 = (t3477*t3479);
float t3481 = (t3474+t3480);
float t3482 = (t3471+t3481);
float t3483 = (t3477+t3481);
float t3484 = (t3482*t3483);
float t3485 = fract(t3484);
float t3486 = (t3485*float(2852.02));
float t3487 = fract(t3486);
float t3488 = (t3487-float(0.5));
float t3489 = (t3488*t1344);
float t3490 = (t3489*float(0.75));
float t3491 = (t3468+t3490);
float t3492 = (3.1415927/2);
float t3493 = (t3491-t3492);
float t3494 = (t3467-t3493);
float t3495 = abs(t3494);
float t3496 = (t3495/2);
float t3497 = sin(t3496);
float t3498 = (t3497*t3497);
float t3499 = cos(t3493);
float t3500 = cos(t3467);
float t3501 = (t3499*t3500);
float t3502 = (3.1415927/t2024);
float t3503 = (t3047*t3502);
float t3504 = (t3459*float(97372.83));
float t3505 = fract(t3504);
float t3506 = (t3505-float(0.5));
float t3507 = (3.1415927/t2024);
float t3508 = (t3506*t3507);
float t3509 = (t3508*float(0.75));
float t3510 = (t3503+t3509);
float t3511 = (t3510+3.1415927);
float t3512 = mod(t3511,t1433);
float t3513 = (t3512-3.1415927);
float t3514 = (t3513+3.1415927);
float t3515 = (3.1415927*2);
float t3516 = mod(t3514,t3515);
float t3517 = (t3516-3.1415927);
float t3518 = (3.1415927/t1359);
float t3519 = (t1582*t3518);
float t3520 = (t3485*float(97372.83));
float t3521 = fract(t3520);
float t3522 = (t3521-float(0.5));
float t3523 = (3.1415927/t1359);
float t3524 = (t3522*t3523);
float t3525 = (t3524*float(0.75));
float t3526 = (t3519+t3525);
float t3527 = (t3526+3.1415927);
float t3528 = mod(t3527,t1433);
float t3529 = (t3528-3.1415927);
float t3530 = (t3529+3.1415927);
float t3531 = (3.1415927*2);
float t3532 = mod(t3530,t3531);
float t3533 = (t3532-3.1415927);
float t3534 = (t3517-t3533);
float t3535 = abs(t3534);
float t3536 = (t3535/2);
float t3537 = sin(t3536);
float t3538 = (t3537*t3537);
float t3539 = (t3501*t3538);
float t3540 = (t3498+t3539);
float t3541 = sqrt(t3540);
float t3542 = asin(t3541);
float t3543 = (2*t3542);
float t3544 = (3.1415927/2);
float t3545 = (t8-t3544);
float t3546 = (3.1415927/2);
float t3547 = (t3491-t3546);
float t3548 = (t3545-t3547);
float t3549 = abs(t3548);
float t3550 = (t3549/2);
float t3551 = sin(t3550);
float t3552 = (t3551*t3551);
float t3553 = cos(t3547);
float t3554 = cos(t3545);
float t3555 = (t3553*t3554);
float t3556 = (t118+3.1415927);
float t3557 = (3.1415927*2);
float t3558 = mod(t3556,t3557);
float t3559 = (t3558-3.1415927);
float t3560 = (t3529+3.1415927);
float t3561 = (3.1415927*2);
float t3562 = mod(t3560,t3561);
float t3563 = (t3562-3.1415927);
float t3564 = (t3559-t3563);
float t3565 = abs(t3564);
float t3566 = (t3565/2);
float t3567 = sin(t3566);
float t3568 = (t3567*t3567);
float t3569 = (t3555*t3568);
float t3570 = (t3552+t3569);
float t3571 = sqrt(t3570);
float t3572 = asin(t3571);
float t3573 = (2*t3572);
float t3574 = (t3543-t3573);
float t3575 = (3.1415927/2);
float t3576 = (t8-t3575);
float t3577 = (3.1415927/2);
float t3578 = (t3465-t3577);
float t3579 = (t3576-t3578);
float t3580 = abs(t3579);
float t3581 = (t3580/2);
float t3582 = sin(t3581);
float t3583 = (t3582*t3582);
float t3584 = cos(t3578);
float t3585 = cos(t3576);
float t3586 = (t3584*t3585);
float t3587 = (t118+3.1415927);
float t3588 = (3.1415927*2);
float t3589 = mod(t3587,t3588);
float t3590 = (t3589-3.1415927);
float t3591 = (t3513+3.1415927);
float t3592 = (3.1415927*2);
float t3593 = mod(t3591,t3592);
float t3594 = (t3593-3.1415927);
float t3595 = (t3590-t3594);
float t3596 = abs(t3595);
float t3597 = (t3596/2);
float t3598 = sin(t3597);
float t3599 = (t3598*t3598);
float t3600 = (t3586*t3599);
float t3601 = (t3583+t3600);
float t3602 = sqrt(t3601);
float t3603 = asin(t3602);
float t3604 = (2*t3603);
float t3605 = (t3574-t3604);
float t3606 = abs(t3605);
bool t3607 = (float(1.0e-4)>t3606);
float t3608;
if(t3607){
float t3609 = cos(t3491);
float t3610 = (1*t3609);
float t3611 = sin(t3465);
float t3612 = (1*t3611);
float t3613 = cos(t3513);
float t3614 = (t3612*t3613);
float t3615 = (t3610*t3614);
float t3616 = sin(t3491);
float t3617 = (1*t3616);
float t3618 = cos(t3529);
float t3619 = (t3617*t3618);
float t3620 = cos(t3465);
float t3621 = (1*t3620);
float t3622 = (t3619*t3621);
float t3623 = (t3615-t3622);
float t3624 = sin(t8);
float t3625 = (1*t3624);
float t3626 = sin(t118);
float t3627 = (t3625*t3626);
float t3628 = (t3623*t3627);
float t3629 = sin(t3465);
float t3630 = (1*t3629);
float t3631 = sin(t3513);
float t3632 = (t3630*t3631);
float t3633 = (t3619*t3632);
float t3634 = sin(t3491);
float t3635 = (1*t3634);
float t3636 = sin(t3529);
float t3637 = (t3635*t3636);
float t3638 = (t3637*t3614);
float t3639 = (t3633-t3638);
float t3640 = cos(t8);
float t3641 = (1*t3640);
float t3642 = (t3639*t3641);
float t3643 = (t3628+t3642);
float t3644 = (t3637*t3621);
float t3645 = (t3610*t3632);
float t3646 = (t3644-t3645);
float t3647 = sin(t8);
float t3648 = (1*t3647);
float t3649 = cos(t118);
float t3650 = (t3648*t3649);
float t3651 = (t3646*t3650);
float t3652 = (t3643+t3651);
float t3653 = abs(t3652);
t3608 = t3653;
} else {
float t3654 = (3.1415927/2);
float t3655 = (t8-t3654);
float t3656 = (3.1415927/2);
float t3657 = (t3465-t3656);
float t3658 = (t3655-t3657);
float t3659 = abs(t3658);
float t3660 = (t3659/2);
float t3661 = sin(t3660);
float t3662 = (t3661*t3661);
float t3663 = cos(t3657);
float t3664 = cos(t3655);
float t3665 = (t3663*t3664);
float t3666 = (t118+3.1415927);
float t3667 = (3.1415927*2);
float t3668 = mod(t3666,t3667);
float t3669 = (t3668-3.1415927);
float t3670 = (t3513+3.1415927);
float t3671 = (3.1415927*2);
float t3672 = mod(t3670,t3671);
float t3673 = (t3672-3.1415927);
float t3674 = (t3669-t3673);
float t3675 = abs(t3674);
float t3676 = (t3675/2);
float t3677 = sin(t3676);
float t3678 = (t3677*t3677);
float t3679 = (t3665*t3678);
float t3680 = (t3662+t3679);
float t3681 = sqrt(t3680);
float t3682 = asin(t3681);
float t3683 = (2*t3682);
float t3684 = abs(t3683);
float t3685 = (3.1415927/2);
float t3686 = (t8-t3685);
float t3687 = (3.1415927/2);
float t3688 = (t3491-t3687);
float t3689 = (t3686-t3688);
float t3690 = abs(t3689);
float t3691 = (t3690/2);
float t3692 = sin(t3691);
float t3693 = (t3692*t3692);
float t3694 = cos(t3688);
float t3695 = cos(t3686);
float t3696 = (t3694*t3695);
float t3697 = (t118+3.1415927);
float t3698 = (3.1415927*2);
float t3699 = mod(t3697,t3698);
float t3700 = (t3699-3.1415927);
float t3701 = (t3529+3.1415927);
float t3702 = (3.1415927*2);
float t3703 = mod(t3701,t3702);
float t3704 = (t3703-3.1415927);
float t3705 = (t3700-t3704);
float t3706 = abs(t3705);
float t3707 = (t3706/2);
float t3708 = sin(t3707);
float t3709 = (t3708*t3708);
float t3710 = (t3696*t3709);
float t3711 = (t3693+t3710);
float t3712 = sqrt(t3711);
float t3713 = asin(t3712);
float t3714 = (2*t3713);
float t3715 = abs(t3714);
bool t3716 = (t3684>=t3715);
float t3717;
if(t3716){
t3717 = t3684;
} else {
t3717 = t3715;
}
t3608 = t3717;
}
float t3718 = abs(t3608);
float t3719 = step(float(2.0e-4),t3718);
float t3720 = (1-t3719);
float t3721 = (t1346*t3047);
float t3722 = (t3721*float(842.378));
float t3723 = fract(t3722);
float t3724 = (t3723+float(45.32));
float t3725 = (t3724+u6.u0);
float t3726 = (t3723*t3725);
float t3727 = (t1582*t2011);
float t3728 = (t3727*float(1734.048));
float t3729 = fract(t3728);
float t3730 = (t3729+float(45.32));
float t3731 = (t3730+u6.u0);
float t3732 = (t3729*t3731);
float t3733 = (t3726+t3732);
float t3734 = (t3723+t3733);
float t3735 = (t3729+t3733);
float t3736 = (t3734*t3735);
float t3737 = fract(t3736);
float t3738 = step(float(0.2),t3737);
float t3739 = (t3720*t3738);
float t3740 = (3.1415927/2);
float t3741 = (t3465-t3740);
float t3742 = (3.1415927/2);
float t3743 = (t3491-t3742);
float t3744 = (t3741-t3743);
float t3745 = abs(t3744);
float t3746 = (t3745/2);
float t3747 = sin(t3746);
float t3748 = (t3747*t3747);
float t3749 = cos(t3743);
float t3750 = cos(t3741);
float t3751 = (t3749*t3750);
float t3752 = (t3513+3.1415927);
float t3753 = (3.1415927*2);
float t3754 = mod(t3752,t3753);
float t3755 = (t3754-3.1415927);
float t3756 = (t3529+3.1415927);
float t3757 = (3.1415927*2);
float t3758 = mod(t3756,t3757);
float t3759 = (t3758-3.1415927);
float t3760 = (t3755-t3759);
float t3761 = abs(t3760);
float t3762 = (t3761/2);
float t3763 = sin(t3762);
float t3764 = (t3763*t3763);
float t3765 = (t3751*t3764);
float t3766 = (t3748+t3765);
float t3767 = sqrt(t3766);
float t3768 = asin(t3767);
float t3769 = (2*t3768);
float t3770 = (t3769/t1344);
float t3771 = (1-t3770);
float t3772 = (t1346/36);
float t3773 = (t3772*float(842.378));
float t3774 = fract(t3773);
float t3775 = (t3774+float(45.32));
float t3776 = (t3775+u6.u0);
float t3777 = (t3774*t3776);
float t3778 = (t1582/t1359);
float t3779 = (t3778*float(1734.048));
float t3780 = fract(t3779);
float t3781 = (t3780+float(45.32));
float t3782 = (t3781+u6.u0);
float t3783 = (t3780*t3782);
float t3784 = (t3777+t3783);
float t3785 = (t3774+t3784);
float t3786 = (t3780+t3784);
float t3787 = (t3785*t3786);
float t3788 = fract(t3787);
float t3789 = (t3788*float(8.0e-3));
float t3790 = (float(1.0e-3)+t3789);
float t3791 = (t3788*173);
float t3792 = fract(t3791);
float t3793 = step(float(0.66),t3792);
float t3794 = (t3793*float(3.0e-3));
float t3795 = (t3790-t3794);
float t3796 = (t3795*float(0.8));
float t3797 = (t2011/36);
float t3798 = (t3797*float(842.378));
float t3799 = fract(t3798);
float t3800 = (t3799+float(45.32));
float t3801 = (t3800+u6.u0);
float t3802 = (t3799*t3801);
float t3803 = (t3047/t2024);
float t3804 = (t3803*float(1734.048));
float t3805 = fract(t3804);
float t3806 = (t3805+float(45.32));
float t3807 = (t3806+u6.u0);
float t3808 = (t3805*t3807);
float t3809 = (t3802+t3808);
float t3810 = (t3799+t3809);
float t3811 = (t3805+t3809);
float t3812 = (t3810*t3811);
float t3813 = fract(t3812);
float t3814 = (t3813*float(8.0e-3));
float t3815 = (float(1.0e-3)+t3814);
float t3816 = (t3813*173);
float t3817 = fract(t3816);
float t3818 = step(float(0.66),t3817);
float t3819 = (t3818*float(3.0e-3));
float t3820 = (t3815-t3819);
float t3821 = (t3820*float(0.8));
float t3822 = (t3796-t3821);
float t3823 = abs(t3822);
float t3824 = (t3823-float(1.0e-3));
float t3825 = (t3824/float(8.0e-3));
float t3826 = (1-t3825);
float t3827 = (t3826*t3826);
float t3828 = (t3771*t3827);
float t3829 = (t3739*t3828);
float t3830 = (u4.u0*t3737);
float t3831 = (t3830*3);
float t3832 = sin(t3831);
float t3833 = (t3832+1);
float t3834 = (t3833/2);
float t3835 = (t3834*float(0.66));
float t3836 = (t3835+float(0.33));
float t3837 = (t3829*t3836);
float t3838 = (float(0.2)*t3837);
bool t3839 = (0>=t3838);
float t3840;
if(t3839){
t3840 = 0;
} else {
t3840 = t3838;
}
float t3841 = (t3840*1);
float t3842 = (t3441+t3841);
float t3843 = (t2011*t1344);
float t3844 = (t2011/36);
float t3845 = (t3844*float(842.378));
float t3846 = fract(t3845);
float t3847 = (t3846+float(45.32));
float t3848 = (t3847+u6.u0);
float t3849 = (t3846*t3848);
float t3850 = (t3047/t2024);
float t3851 = (t3850*float(1734.048));
float t3852 = fract(t3851);
float t3853 = (t3852+float(45.32));
float t3854 = (t3853+u6.u0);
float t3855 = (t3852*t3854);
float t3856 = (t3849+t3855);
float t3857 = (t3846+t3856);
float t3858 = (t3852+t3856);
float t3859 = (t3857*t3858);
float t3860 = fract(t3859);
float t3861 = (t3860*float(2852.02));
float t3862 = fract(t3861);
float t3863 = (t3862-float(0.5));
float t3864 = (t3863*t1344);
float t3865 = (t3864*float(0.75));
float t3866 = (t3843+t3865);
float t3867 = (3.1415927/2);
float t3868 = (t3866-t3867);
float t3869 = (t1346*t1344);
float t3870 = (t1346/36);
float t3871 = (t3870*float(842.378));
float t3872 = fract(t3871);
float t3873 = (t3872+float(45.32));
float t3874 = (t3873+u6.u0);
float t3875 = (t3872*t3874);
float t3876 = (t1362/t1359);
float t3877 = (t3876*float(1734.048));
float t3878 = fract(t3877);
float t3879 = (t3878+float(45.32));
float t3880 = (t3879+u6.u0);
float t3881 = (t3878*t3880);
float t3882 = (t3875+t3881);
float t3883 = (t3872+t3882);
float t3884 = (t3878+t3882);
float t3885 = (t3883*t3884);
float t3886 = fract(t3885);
float t3887 = (t3886*float(2852.02));
float t3888 = fract(t3887);
float t3889 = (t3888-float(0.5));
float t3890 = (t3889*t1344);
float t3891 = (t3890*float(0.75));
float t3892 = (t3869+t3891);
float t3893 = (3.1415927/2);
float t3894 = (t3892-t3893);
float t3895 = (t3868-t3894);
float t3896 = abs(t3895);
float t3897 = (t3896/2);
float t3898 = sin(t3897);
float t3899 = (t3898*t3898);
float t3900 = cos(t3894);
float t3901 = cos(t3868);
float t3902 = (t3900*t3901);
float t3903 = (3.1415927/t2024);
float t3904 = (t3047*t3903);
float t3905 = (t3860*float(97372.83));
float t3906 = fract(t3905);
float t3907 = (t3906-float(0.5));
float t3908 = (3.1415927/t2024);
float t3909 = (t3907*t3908);
float t3910 = (t3909*float(0.75));
float t3911 = (t3904+t3910);
float t3912 = (t3911+3.1415927);
float t3913 = mod(t3912,t1433);
float t3914 = (t3913-3.1415927);
float t3915 = (t3914+3.1415927);
float t3916 = (3.1415927*2);
float t3917 = mod(t3915,t3916);
float t3918 = (t3917-3.1415927);
float t3919 = (3.1415927/t1359);
float t3920 = (t1362*t3919);
float t3921 = (t3886*float(97372.83));
float t3922 = fract(t3921);
float t3923 = (t3922-float(0.5));
float t3924 = (3.1415927/t1359);
float t3925 = (t3923*t3924);
float t3926 = (t3925*float(0.75));
float t3927 = (t3920+t3926);
float t3928 = (t3927+3.1415927);
float t3929 = mod(t3928,t1433);
float t3930 = (t3929-3.1415927);
float t3931 = (t3930+3.1415927);
float t3932 = (3.1415927*2);
float t3933 = mod(t3931,t3932);
float t3934 = (t3933-3.1415927);
float t3935 = (t3918-t3934);
float t3936 = abs(t3935);
float t3937 = (t3936/2);
float t3938 = sin(t3937);
float t3939 = (t3938*t3938);
float t3940 = (t3902*t3939);
float t3941 = (t3899+t3940);
float t3942 = sqrt(t3941);
float t3943 = asin(t3942);
float t3944 = (2*t3943);
float t3945 = (3.1415927/2);
float t3946 = (t8-t3945);
float t3947 = (3.1415927/2);
float t3948 = (t3892-t3947);
float t3949 = (t3946-t3948);
float t3950 = abs(t3949);
float t3951 = (t3950/2);
float t3952 = sin(t3951);
float t3953 = (t3952*t3952);
float t3954 = cos(t3948);
float t3955 = cos(t3946);
float t3956 = (t3954*t3955);
float t3957 = (t118+3.1415927);
float t3958 = (3.1415927*2);
float t3959 = mod(t3957,t3958);
float t3960 = (t3959-3.1415927);
float t3961 = (t3930+3.1415927);
float t3962 = (3.1415927*2);
float t3963 = mod(t3961,t3962);
float t3964 = (t3963-3.1415927);
float t3965 = (t3960-t3964);
float t3966 = abs(t3965);
float t3967 = (t3966/2);
float t3968 = sin(t3967);
float t3969 = (t3968*t3968);
float t3970 = (t3956*t3969);
float t3971 = (t3953+t3970);
float t3972 = sqrt(t3971);
float t3973 = asin(t3972);
float t3974 = (2*t3973);
float t3975 = (t3944-t3974);
float t3976 = (3.1415927/2);
float t3977 = (t8-t3976);
float t3978 = (3.1415927/2);
float t3979 = (t3866-t3978);
float t3980 = (t3977-t3979);
float t3981 = abs(t3980);
float t3982 = (t3981/2);
float t3983 = sin(t3982);
float t3984 = (t3983*t3983);
float t3985 = cos(t3979);
float t3986 = cos(t3977);
float t3987 = (t3985*t3986);
float t3988 = (t118+3.1415927);
float t3989 = (3.1415927*2);
float t3990 = mod(t3988,t3989);
float t3991 = (t3990-3.1415927);
float t3992 = (t3914+3.1415927);
float t3993 = (3.1415927*2);
float t3994 = mod(t3992,t3993);
float t3995 = (t3994-3.1415927);
float t3996 = (t3991-t3995);
float t3997 = abs(t3996);
float t3998 = (t3997/2);
float t3999 = sin(t3998);
float t4000 = (t3999*t3999);
float t4001 = (t3987*t4000);
float t4002 = (t3984+t4001);
float t4003 = sqrt(t4002);
float t4004 = asin(t4003);
float t4005 = (2*t4004);
float t4006 = (t3975-t4005);
float t4007 = abs(t4006);
bool t4008 = (float(1.0e-4)>t4007);
float t4009;
if(t4008){
float t4010 = cos(t3892);
float t4011 = (1*t4010);
float t4012 = sin(t3866);
float t4013 = (1*t4012);
float t4014 = cos(t3914);
float t4015 = (t4013*t4014);
float t4016 = (t4011*t4015);
float t4017 = sin(t3892);
float t4018 = (1*t4017);
float t4019 = cos(t3930);
float t4020 = (t4018*t4019);
float t4021 = cos(t3866);
float t4022 = (1*t4021);
float t4023 = (t4020*t4022);
float t4024 = (t4016-t4023);
float t4025 = sin(t8);
float t4026 = (1*t4025);
float t4027 = sin(t118);
float t4028 = (t4026*t4027);
float t4029 = (t4024*t4028);
float t4030 = sin(t3866);
float t4031 = (1*t4030);
float t4032 = sin(t3914);
float t4033 = (t4031*t4032);
float t4034 = (t4020*t4033);
float t4035 = sin(t3892);
float t4036 = (1*t4035);
float t4037 = sin(t3930);
float t4038 = (t4036*t4037);
float t4039 = (t4038*t4015);
float t4040 = (t4034-t4039);
float t4041 = cos(t8);
float t4042 = (1*t4041);
float t4043 = (t4040*t4042);
float t4044 = (t4029+t4043);
float t4045 = (t4038*t4022);
float t4046 = (t4011*t4033);
float t4047 = (t4045-t4046);
float t4048 = sin(t8);
float t4049 = (1*t4048);
float t4050 = cos(t118);
float t4051 = (t4049*t4050);
float t4052 = (t4047*t4051);
float t4053 = (t4044+t4052);
float t4054 = abs(t4053);
t4009 = t4054;
} else {
float t4055 = (3.1415927/2);
float t4056 = (t8-t4055);
float t4057 = (3.1415927/2);
float t4058 = (t3866-t4057);
float t4059 = (t4056-t4058);
float t4060 = abs(t4059);
float t4061 = (t4060/2);
float t4062 = sin(t4061);
float t4063 = (t4062*t4062);
float t4064 = cos(t4058);
float t4065 = cos(t4056);
float t4066 = (t4064*t4065);
float t4067 = (t118+3.1415927);
float t4068 = (3.1415927*2);
float t4069 = mod(t4067,t4068);
float t4070 = (t4069-3.1415927);
float t4071 = (t3914+3.1415927);
float t4072 = (3.1415927*2);
float t4073 = mod(t4071,t4072);
float t4074 = (t4073-3.1415927);
float t4075 = (t4070-t4074);
float t4076 = abs(t4075);
float t4077 = (t4076/2);
float t4078 = sin(t4077);
float t4079 = (t4078*t4078);
float t4080 = (t4066*t4079);
float t4081 = (t4063+t4080);
float t4082 = sqrt(t4081);
float t4083 = asin(t4082);
float t4084 = (2*t4083);
float t4085 = abs(t4084);
float t4086 = (3.1415927/2);
float t4087 = (t8-t4086);
float t4088 = (3.1415927/2);
float t4089 = (t3892-t4088);
float t4090 = (t4087-t4089);
float t4091 = abs(t4090);
float t4092 = (t4091/2);
float t4093 = sin(t4092);
float t4094 = (t4093*t4093);
float t4095 = cos(t4089);
float t4096 = cos(t4087);
float t4097 = (t4095*t4096);
float t4098 = (t118+3.1415927);
float t4099 = (3.1415927*2);
float t4100 = mod(t4098,t4099);
float t4101 = (t4100-3.1415927);
float t4102 = (t3930+3.1415927);
float t4103 = (3.1415927*2);
float t4104 = mod(t4102,t4103);
float t4105 = (t4104-3.1415927);
float t4106 = (t4101-t4105);
float t4107 = abs(t4106);
float t4108 = (t4107/2);
float t4109 = sin(t4108);
float t4110 = (t4109*t4109);
float t4111 = (t4097*t4110);
float t4112 = (t4094+t4111);
float t4113 = sqrt(t4112);
float t4114 = asin(t4113);
float t4115 = (2*t4114);
float t4116 = abs(t4115);
bool t4117 = (t4085>=t4116);
float t4118;
if(t4117){
t4118 = t4085;
} else {
t4118 = t4116;
}
t4009 = t4118;
}
float t4119 = abs(t4009);
float t4120 = step(float(2.0e-4),t4119);
float t4121 = (1-t4120);
float t4122 = (t1346*t3047);
float t4123 = (t4122*float(842.378));
float t4124 = fract(t4123);
float t4125 = (t4124+float(45.32));
float t4126 = (t4125+u6.u0);
float t4127 = (t4124*t4126);
float t4128 = (t1362*t2011);
float t4129 = (t4128*float(1734.048));
float t4130 = fract(t4129);
float t4131 = (t4130+float(45.32));
float t4132 = (t4131+u6.u0);
float t4133 = (t4130*t4132);
float t4134 = (t4127+t4133);
float t4135 = (t4124+t4134);
float t4136 = (t4130+t4134);
float t4137 = (t4135*t4136);
float t4138 = fract(t4137);
float t4139 = step(float(0.2),t4138);
float t4140 = (t4121*t4139);
float t4141 = (3.1415927/2);
float t4142 = (t3866-t4141);
float t4143 = (3.1415927/2);
float t4144 = (t3892-t4143);
float t4145 = (t4142-t4144);
float t4146 = abs(t4145);
float t4147 = (t4146/2);
float t4148 = sin(t4147);
float t4149 = (t4148*t4148);
float t4150 = cos(t4144);
float t4151 = cos(t4142);
float t4152 = (t4150*t4151);
float t4153 = (t3914+3.1415927);
float t4154 = (3.1415927*2);
float t4155 = mod(t4153,t4154);
float t4156 = (t4155-3.1415927);
float t4157 = (t3930+3.1415927);
float t4158 = (3.1415927*2);
float t4159 = mod(t4157,t4158);
float t4160 = (t4159-3.1415927);
float t4161 = (t4156-t4160);
float t4162 = abs(t4161);
float t4163 = (t4162/2);
float t4164 = sin(t4163);
float t4165 = (t4164*t4164);
float t4166 = (t4152*t4165);
float t4167 = (t4149+t4166);
float t4168 = sqrt(t4167);
float t4169 = asin(t4168);
float t4170 = (2*t4169);
float t4171 = (t4170/t1344);
float t4172 = (1-t4171);
float t4173 = (t1346/36);
float t4174 = (t4173*float(842.378));
float t4175 = fract(t4174);
float t4176 = (t4175+float(45.32));
float t4177 = (t4176+u6.u0);
float t4178 = (t4175*t4177);
float t4179 = (t1362/t1359);
float t4180 = (t4179*float(1734.048));
float t4181 = fract(t4180);
float t4182 = (t4181+float(45.32));
float t4183 = (t4182+u6.u0);
float t4184 = (t4181*t4183);
float t4185 = (t4178+t4184);
float t4186 = (t4175+t4185);
float t4187 = (t4181+t4185);
float t4188 = (t4186*t4187);
float t4189 = fract(t4188);
float t4190 = (t4189*float(8.0e-3));
float t4191 = (float(1.0e-3)+t4190);
float t4192 = (t4189*173);
float t4193 = fract(t4192);
float t4194 = step(float(0.66),t4193);
float t4195 = (t4194*float(3.0e-3));
float t4196 = (t4191-t4195);
float t4197 = (t4196*float(0.8));
float t4198 = (t2011/36);
float t4199 = (t4198*float(842.378));
float t4200 = fract(t4199);
float t4201 = (t4200+float(45.32));
float t4202 = (t4201+u6.u0);
float t4203 = (t4200*t4202);
float t4204 = (t3047/t2024);
float t4205 = (t4204*float(1734.048));
float t4206 = fract(t4205);
float t4207 = (t4206+float(45.32));
float t4208 = (t4207+u6.u0);
float t4209 = (t4206*t4208);
float t4210 = (t4203+t4209);
float t4211 = (t4200+t4210);
float t4212 = (t4206+t4210);
float t4213 = (t4211*t4212);
float t4214 = fract(t4213);
float t4215 = (t4214*float(8.0e-3));
float t4216 = (float(1.0e-3)+t4215);
float t4217 = (t4214*173);
float t4218 = fract(t4217);
float t4219 = step(float(0.66),t4218);
float t4220 = (t4219*float(3.0e-3));
float t4221 = (t4216-t4220);
float t4222 = (t4221*float(0.8));
float t4223 = (t4197-t4222);
float t4224 = abs(t4223);
float t4225 = (t4224-float(1.0e-3));
float t4226 = (t4225/float(8.0e-3));
float t4227 = (1-t4226);
float t4228 = (t4227*t4227);
float t4229 = (t4172*t4228);
float t4230 = (t4140*t4229);
float t4231 = (u4.u0*t4138);
float t4232 = (t4231*3);
float t4233 = sin(t4232);
float t4234 = (t4233+1);
float t4235 = (t4234/2);
float t4236 = (t4235*float(0.66));
float t4237 = (t4236+float(0.33));
float t4238 = (t4230*t4237);
float t4239 = (float(0.2)*t4238);
bool t4240 = (0>=t4239);
float t4241;
if(t4240){
t4241 = 0;
} else {
t4241 = t4239;
}
float t4242 = (t4241*1);
float t4243 = (t3842+t4242);
float t4244 = (t1346*t1344);
float t4245 = (t1346/36);
float t4246 = (t4245*float(842.378));
float t4247 = fract(t4246);
float t4248 = (t4247+float(45.32));
float t4249 = (t4248+u6.u0);
float t4250 = (t4247*t4249);
float t4251 = (t1800/t1359);
float t4252 = (t4251*float(1734.048));
float t4253 = fract(t4252);
float t4254 = (t4253+float(45.32));
float t4255 = (t4254+u6.u0);
float t4256 = (t4253*t4255);
float t4257 = (t4250+t4256);
float t4258 = (t4247+t4257);
float t4259 = (t4253+t4257);
float t4260 = (t4258*t4259);
float t4261 = fract(t4260);
float t4262 = (t4261*float(2852.02));
float t4263 = fract(t4262);
float t4264 = (t4263-float(0.5));
float t4265 = (t4264*t1344);
float t4266 = (t4265*float(0.75));
float t4267 = (t4244+t4266);
float t4268 = (3.1415927/2);
float t4269 = (t4267-t4268);
float t4270 = (t1346*t1344);
float t4271 = (t1346/36);
float t4272 = (t4271*float(842.378));
float t4273 = fract(t4272);
float t4274 = (t4273+float(45.32));
float t4275 = (t4274+u6.u0);
float t4276 = (t4273*t4275);
float t4277 = (t1582/t1359);
float t4278 = (t4277*float(1734.048));
float t4279 = fract(t4278);
float t4280 = (t4279+float(45.32));
float t4281 = (t4280+u6.u0);
float t4282 = (t4279*t4281);
float t4283 = (t4276+t4282);
float t4284 = (t4273+t4283);
float t4285 = (t4279+t4283);
float t4286 = (t4284*t4285);
float t4287 = fract(t4286);
float t4288 = (t4287*float(2852.02));
float t4289 = fract(t4288);
float t4290 = (t4289-float(0.5));
float t4291 = (t4290*t1344);
float t4292 = (t4291*float(0.75));
float t4293 = (t4270+t4292);
float t4294 = (3.1415927/2);
float t4295 = (t4293-t4294);
float t4296 = (t4269-t4295);
float t4297 = abs(t4296);
float t4298 = (t4297/2);
float t4299 = sin(t4298);
float t4300 = (t4299*t4299);
float t4301 = cos(t4295);
float t4302 = cos(t4269);
float t4303 = (t4301*t4302);
float t4304 = (3.1415927/t1359);
float t4305 = (t1800*t4304);
float t4306 = (t4261*float(97372.83));
float t4307 = fract(t4306);
float t4308 = (t4307-float(0.5));
float t4309 = (3.1415927/t1359);
float t4310 = (t4308*t4309);
float t4311 = (t4310*float(0.75));
float t4312 = (t4305+t4311);
float t4313 = (t4312+3.1415927);
float t4314 = mod(t4313,t1433);
float t4315 = (t4314-3.1415927);
float t4316 = (t4315+3.1415927);
float t4317 = (3.1415927*2);
float t4318 = mod(t4316,t4317);
float t4319 = (t4318-3.1415927);
float t4320 = (3.1415927/t1359);
float t4321 = (t1582*t4320);
float t4322 = (t4287*float(97372.83));
float t4323 = fract(t4322);
float t4324 = (t4323-float(0.5));
float t4325 = (3.1415927/t1359);
float t4326 = (t4324*t4325);
float t4327 = (t4326*float(0.75));
float t4328 = (t4321+t4327);
float t4329 = (t4328+3.1415927);
float t4330 = mod(t4329,t1433);
float t4331 = (t4330-3.1415927);
float t4332 = (t4331+3.1415927);
float t4333 = (3.1415927*2);
float t4334 = mod(t4332,t4333);
float t4335 = (t4334-3.1415927);
float t4336 = (t4319-t4335);
float t4337 = abs(t4336);
float t4338 = (t4337/2);
float t4339 = sin(t4338);
float t4340 = (t4339*t4339);
float t4341 = (t4303*t4340);
float t4342 = (t4300+t4341);
float t4343 = sqrt(t4342);
float t4344 = asin(t4343);
float t4345 = (2*t4344);
float t4346 = (3.1415927/2);
float t4347 = (t8-t4346);
float t4348 = (3.1415927/2);
float t4349 = (t4293-t4348);
float t4350 = (t4347-t4349);
float t4351 = abs(t4350);
float t4352 = (t4351/2);
float t4353 = sin(t4352);
float t4354 = (t4353*t4353);
float t4355 = cos(t4349);
float t4356 = cos(t4347);
float t4357 = (t4355*t4356);
float t4358 = (t118+3.1415927);
float t4359 = (3.1415927*2);
float t4360 = mod(t4358,t4359);
float t4361 = (t4360-3.1415927);
float t4362 = (t4331+3.1415927);
float t4363 = (3.1415927*2);
float t4364 = mod(t4362,t4363);
float t4365 = (t4364-3.1415927);
float t4366 = (t4361-t4365);
float t4367 = abs(t4366);
float t4368 = (t4367/2);
float t4369 = sin(t4368);
float t4370 = (t4369*t4369);
float t4371 = (t4357*t4370);
float t4372 = (t4354+t4371);
float t4373 = sqrt(t4372);
float t4374 = asin(t4373);
float t4375 = (2*t4374);
float t4376 = (t4345-t4375);
float t4377 = (3.1415927/2);
float t4378 = (t8-t4377);
float t4379 = (3.1415927/2);
float t4380 = (t4267-t4379);
float t4381 = (t4378-t4380);
float t4382 = abs(t4381);
float t4383 = (t4382/2);
float t4384 = sin(t4383);
float t4385 = (t4384*t4384);
float t4386 = cos(t4380);
float t4387 = cos(t4378);
float t4388 = (t4386*t4387);
float t4389 = (t118+3.1415927);
float t4390 = (3.1415927*2);
float t4391 = mod(t4389,t4390);
float t4392 = (t4391-3.1415927);
float t4393 = (t4315+3.1415927);
float t4394 = (3.1415927*2);
float t4395 = mod(t4393,t4394);
float t4396 = (t4395-3.1415927);
float t4397 = (t4392-t4396);
float t4398 = abs(t4397);
float t4399 = (t4398/2);
float t4400 = sin(t4399);
float t4401 = (t4400*t4400);
float t4402 = (t4388*t4401);
float t4403 = (t4385+t4402);
float t4404 = sqrt(t4403);
float t4405 = asin(t4404);
float t4406 = (2*t4405);
float t4407 = (t4376-t4406);
float t4408 = abs(t4407);
bool t4409 = (float(1.0e-4)>t4408);
float t4410;
if(t4409){
float t4411 = cos(t4293);
float t4412 = (1*t4411);
float t4413 = sin(t4267);
float t4414 = (1*t4413);
float t4415 = cos(t4315);
float t4416 = (t4414*t4415);
float t4417 = (t4412*t4416);
float t4418 = sin(t4293);
float t4419 = (1*t4418);
float t4420 = cos(t4331);
float t4421 = (t4419*t4420);
float t4422 = cos(t4267);
float t4423 = (1*t4422);
float t4424 = (t4421*t4423);
float t4425 = (t4417-t4424);
float t4426 = sin(t8);
float t4427 = (1*t4426);
float t4428 = sin(t118);
float t4429 = (t4427*t4428);
float t4430 = (t4425*t4429);
float t4431 = sin(t4267);
float t4432 = (1*t4431);
float t4433 = sin(t4315);
float t4434 = (t4432*t4433);
float t4435 = (t4421*t4434);
float t4436 = sin(t4293);
float t4437 = (1*t4436);
float t4438 = sin(t4331);
float t4439 = (t4437*t4438);
float t4440 = (t4439*t4416);
float t4441 = (t4435-t4440);
float t4442 = cos(t8);
float t4443 = (1*t4442);
float t4444 = (t4441*t4443);
float t4445 = (t4430+t4444);
float t4446 = (t4439*t4423);
float t4447 = (t4412*t4434);
float t4448 = (t4446-t4447);
float t4449 = sin(t8);
float t4450 = (1*t4449);
float t4451 = cos(t118);
float t4452 = (t4450*t4451);
float t4453 = (t4448*t4452);
float t4454 = (t4445+t4453);
float t4455 = abs(t4454);
t4410 = t4455;
} else {
float t4456 = (3.1415927/2);
float t4457 = (t8-t4456);
float t4458 = (3.1415927/2);
float t4459 = (t4267-t4458);
float t4460 = (t4457-t4459);
float t4461 = abs(t4460);
float t4462 = (t4461/2);
float t4463 = sin(t4462);
float t4464 = (t4463*t4463);
float t4465 = cos(t4459);
float t4466 = cos(t4457);
float t4467 = (t4465*t4466);
float t4468 = (t118+3.1415927);
float t4469 = (3.1415927*2);
float t4470 = mod(t4468,t4469);
float t4471 = (t4470-3.1415927);
float t4472 = (t4315+3.1415927);
float t4473 = (3.1415927*2);
float t4474 = mod(t4472,t4473);
float t4475 = (t4474-3.1415927);
float t4476 = (t4471-t4475);
float t4477 = abs(t4476);
float t4478 = (t4477/2);
float t4479 = sin(t4478);
float t4480 = (t4479*t4479);
float t4481 = (t4467*t4480);
float t4482 = (t4464+t4481);
float t4483 = sqrt(t4482);
float t4484 = asin(t4483);
float t4485 = (2*t4484);
float t4486 = abs(t4485);
float t4487 = (3.1415927/2);
float t4488 = (t8-t4487);
float t4489 = (3.1415927/2);
float t4490 = (t4293-t4489);
float t4491 = (t4488-t4490);
float t4492 = abs(t4491);
float t4493 = (t4492/2);
float t4494 = sin(t4493);
float t4495 = (t4494*t4494);
float t4496 = cos(t4490);
float t4497 = cos(t4488);
float t4498 = (t4496*t4497);
float t4499 = (t118+3.1415927);
float t4500 = (3.1415927*2);
float t4501 = mod(t4499,t4500);
float t4502 = (t4501-3.1415927);
float t4503 = (t4331+3.1415927);
float t4504 = (3.1415927*2);
float t4505 = mod(t4503,t4504);
float t4506 = (t4505-3.1415927);
float t4507 = (t4502-t4506);
float t4508 = abs(t4507);
float t4509 = (t4508/2);
float t4510 = sin(t4509);
float t4511 = (t4510*t4510);
float t4512 = (t4498*t4511);
float t4513 = (t4495+t4512);
float t4514 = sqrt(t4513);
float t4515 = asin(t4514);
float t4516 = (2*t4515);
float t4517 = abs(t4516);
bool t4518 = (t4486>=t4517);
float t4519;
if(t4518){
t4519 = t4486;
} else {
t4519 = t4517;
}
t4410 = t4519;
}
float t4520 = abs(t4410);
float t4521 = step(float(2.0e-4),t4520);
float t4522 = (1-t4521);
float t4523 = (t1346*t1800);
float t4524 = (t4523*float(842.378));
float t4525 = fract(t4524);
float t4526 = (t4525+float(45.32));
float t4527 = (t4526+u6.u0);
float t4528 = (t4525*t4527);
float t4529 = (t1582*t1346);
float t4530 = (t4529*float(1734.048));
float t4531 = fract(t4530);
float t4532 = (t4531+float(45.32));
float t4533 = (t4532+u6.u0);
float t4534 = (t4531*t4533);
float t4535 = (t4528+t4534);
float t4536 = (t4525+t4535);
float t4537 = (t4531+t4535);
float t4538 = (t4536*t4537);
float t4539 = fract(t4538);
float t4540 = step(float(0.2),t4539);
float t4541 = (t4522*t4540);
float t4542 = (3.1415927/2);
float t4543 = (t4267-t4542);
float t4544 = (3.1415927/2);
float t4545 = (t4293-t4544);
float t4546 = (t4543-t4545);
float t4547 = abs(t4546);
float t4548 = (t4547/2);
float t4549 = sin(t4548);
float t4550 = (t4549*t4549);
float t4551 = cos(t4545);
float t4552 = cos(t4543);
float t4553 = (t4551*t4552);
float t4554 = (t4315+3.1415927);
float t4555 = (3.1415927*2);
float t4556 = mod(t4554,t4555);
float t4557 = (t4556-3.1415927);
float t4558 = (t4331+3.1415927);
float t4559 = (3.1415927*2);
float t4560 = mod(t4558,t4559);
float t4561 = (t4560-3.1415927);
float t4562 = (t4557-t4561);
float t4563 = abs(t4562);
float t4564 = (t4563/2);
float t4565 = sin(t4564);
float t4566 = (t4565*t4565);
float t4567 = (t4553*t4566);
float t4568 = (t4550+t4567);
float t4569 = sqrt(t4568);
float t4570 = asin(t4569);
float t4571 = (2*t4570);
float t4572 = (t4571/t1344);
float t4573 = (1-t4572);
float t4574 = (t1346/36);
float t4575 = (t4574*float(842.378));
float t4576 = fract(t4575);
float t4577 = (t4576+float(45.32));
float t4578 = (t4577+u6.u0);
float t4579 = (t4576*t4578);
float t4580 = (t1582/t1359);
float t4581 = (t4580*float(1734.048));
float t4582 = fract(t4581);
float t4583 = (t4582+float(45.32));
float t4584 = (t4583+u6.u0);
float t4585 = (t4582*t4584);
float t4586 = (t4579+t4585);
float t4587 = (t4576+t4586);
float t4588 = (t4582+t4586);
float t4589 = (t4587*t4588);
float t4590 = fract(t4589);
float t4591 = (t4590*float(8.0e-3));
float t4592 = (float(1.0e-3)+t4591);
float t4593 = (t4590*173);
float t4594 = fract(t4593);
float t4595 = step(float(0.66),t4594);
float t4596 = (t4595*float(3.0e-3));
float t4597 = (t4592-t4596);
float t4598 = (t4597*float(0.8));
float t4599 = (t1346/36);
float t4600 = (t4599*float(842.378));
float t4601 = fract(t4600);
float t4602 = (t4601+float(45.32));
float t4603 = (t4602+u6.u0);
float t4604 = (t4601*t4603);
float t4605 = (t1800/t1359);
float t4606 = (t4605*float(1734.048));
float t4607 = fract(t4606);
float t4608 = (t4607+float(45.32));
float t4609 = (t4608+u6.u0);
float t4610 = (t4607*t4609);
float t4611 = (t4604+t4610);
float t4612 = (t4601+t4611);
float t4613 = (t4607+t4611);
float t4614 = (t4612*t4613);
float t4615 = fract(t4614);
float t4616 = (t4615*float(8.0e-3));
float t4617 = (float(1.0e-3)+t4616);
float t4618 = (t4615*173);
float t4619 = fract(t4618);
float t4620 = step(float(0.66),t4619);
float t4621 = (t4620*float(3.0e-3));
float t4622 = (t4617-t4621);
float t4623 = (t4622*float(0.8));
float t4624 = (t4598-t4623);
float t4625 = abs(t4624);
float t4626 = (t4625-float(1.0e-3));
float t4627 = (t4626/float(8.0e-3));
float t4628 = (1-t4627);
float t4629 = (t4628*t4628);
float t4630 = (t4573*t4629);
float t4631 = (t4541*t4630);
float t4632 = (u4.u0*t4539);
float t4633 = (t4632*3);
float t4634 = sin(t4633);
float t4635 = (t4634+1);
float t4636 = (t4635/2);
float t4637 = (t4636*float(0.66));
float t4638 = (t4637+float(0.33));
float t4639 = (t4631*t4638);
float t4640 = (float(0.2)*t4639);
bool t4641 = (0>=t4640);
float t4642;
if(t4641){
t4642 = 0;
} else {
t4642 = t4640;
}
float t4643 = (t4642*1);
float t4644 = (t4243+t4643);
float t4645 = (t1346*t1344);
float t4646 = (t1346/36);
float t4647 = (t4646*float(842.378));
float t4648 = fract(t4647);
float t4649 = (t4648+float(45.32));
float t4650 = (t4649+u6.u0);
float t4651 = (t4648*t4650);
float t4652 = (t1362+2);
float t4653 = (t4652/t2024);
float t4654 = (t4653*float(1734.048));
float t4655 = fract(t4654);
float t4656 = (t4655+float(45.32));
float t4657 = (t4656+u6.u0);
float t4658 = (t4655*t4657);
float t4659 = (t4651+t4658);
float t4660 = (t4648+t4659);
float t4661 = (t4655+t4659);
float t4662 = (t4660*t4661);
float t4663 = fract(t4662);
float t4664 = (t4663*float(2852.02));
float t4665 = fract(t4664);
float t4666 = (t4665-float(0.5));
float t4667 = (t4666*t1344);
float t4668 = (t4667*float(0.75));
float t4669 = (t4645+t4668);
float t4670 = (3.1415927/2);
float t4671 = (t4669-t4670);
float t4672 = (t2011*t1344);
float t4673 = (t2011/36);
float t4674 = (t4673*float(842.378));
float t4675 = fract(t4674);
float t4676 = (t4675+float(45.32));
float t4677 = (t4676+u6.u0);
float t4678 = (t4675*t4677);
float t4679 = (t3047/t2024);
float t4680 = (t4679*float(1734.048));
float t4681 = fract(t4680);
float t4682 = (t4681+float(45.32));
float t4683 = (t4682+u6.u0);
float t4684 = (t4681*t4683);
float t4685 = (t4678+t4684);
float t4686 = (t4675+t4685);
float t4687 = (t4681+t4685);
float t4688 = (t4686*t4687);
float t4689 = fract(t4688);
float t4690 = (t4689*float(2852.02));
float t4691 = fract(t4690);
float t4692 = (t4691-float(0.5));
float t4693 = (t4692*t1344);
float t4694 = (t4693*float(0.75));
float t4695 = (t4672+t4694);
float t4696 = (3.1415927/2);
float t4697 = (t4695-t4696);
float t4698 = (t4671-t4697);
float t4699 = abs(t4698);
float t4700 = (t4699/2);
float t4701 = sin(t4700);
float t4702 = (t4701*t4701);
float t4703 = cos(t4697);
float t4704 = cos(t4671);
float t4705 = (t4703*t4704);
float t4706 = (3.1415927/t2024);
float t4707 = (t4652*t4706);
float t4708 = (t4663*float(97372.83));
float t4709 = fract(t4708);
float t4710 = (t4709-float(0.5));
float t4711 = (3.1415927/t2024);
float t4712 = (t4710*t4711);
float t4713 = (t4712*float(0.75));
float t4714 = (t4707+t4713);
float t4715 = (t4714+3.1415927);
float t4716 = mod(t4715,t1433);
float t4717 = (t4716-3.1415927);
float t4718 = (t4717+3.1415927);
float t4719 = (3.1415927*2);
float t4720 = mod(t4718,t4719);
float t4721 = (t4720-3.1415927);
float t4722 = (3.1415927/t2024);
float t4723 = (t3047*t4722);
float t4724 = (t4689*float(97372.83));
float t4725 = fract(t4724);
float t4726 = (t4725-float(0.5));
float t4727 = (3.1415927/t2024);
float t4728 = (t4726*t4727);
float t4729 = (t4728*float(0.75));
float t4730 = (t4723+t4729);
float t4731 = (t4730+3.1415927);
float t4732 = mod(t4731,t1433);
float t4733 = (t4732-3.1415927);
float t4734 = (t4733+3.1415927);
float t4735 = (3.1415927*2);
float t4736 = mod(t4734,t4735);
float t4737 = (t4736-3.1415927);
float t4738 = (t4721-t4737);
float t4739 = abs(t4738);
float t4740 = (t4739/2);
float t4741 = sin(t4740);
float t4742 = (t4741*t4741);
float t4743 = (t4705*t4742);
float t4744 = (t4702+t4743);
float t4745 = sqrt(t4744);
float t4746 = asin(t4745);
float t4747 = (2*t4746);
float t4748 = (3.1415927/2);
float t4749 = (t8-t4748);
float t4750 = (3.1415927/2);
float t4751 = (t4695-t4750);
float t4752 = (t4749-t4751);
float t4753 = abs(t4752);
float t4754 = (t4753/2);
float t4755 = sin(t4754);
float t4756 = (t4755*t4755);
float t4757 = cos(t4751);
float t4758 = cos(t4749);
float t4759 = (t4757*t4758);
float t4760 = (t118+3.1415927);
float t4761 = (3.1415927*2);
float t4762 = mod(t4760,t4761);
float t4763 = (t4762-3.1415927);
float t4764 = (t4733+3.1415927);
float t4765 = (3.1415927*2);
float t4766 = mod(t4764,t4765);
float t4767 = (t4766-3.1415927);
float t4768 = (t4763-t4767);
float t4769 = abs(t4768);
float t4770 = (t4769/2);
float t4771 = sin(t4770);
float t4772 = (t4771*t4771);
float t4773 = (t4759*t4772);
float t4774 = (t4756+t4773);
float t4775 = sqrt(t4774);
float t4776 = asin(t4775);
float t4777 = (2*t4776);
float t4778 = (t4747-t4777);
float t4779 = (3.1415927/2);
float t4780 = (t8-t4779);
float t4781 = (3.1415927/2);
float t4782 = (t4669-t4781);
float t4783 = (t4780-t4782);
float t4784 = abs(t4783);
float t4785 = (t4784/2);
float t4786 = sin(t4785);
float t4787 = (t4786*t4786);
float t4788 = cos(t4782);
float t4789 = cos(t4780);
float t4790 = (t4788*t4789);
float t4791 = (t118+3.1415927);
float t4792 = (3.1415927*2);
float t4793 = mod(t4791,t4792);
float t4794 = (t4793-3.1415927);
float t4795 = (t4717+3.1415927);
float t4796 = (3.1415927*2);
float t4797 = mod(t4795,t4796);
float t4798 = (t4797-3.1415927);
float t4799 = (t4794-t4798);
float t4800 = abs(t4799);
float t4801 = (t4800/2);
float t4802 = sin(t4801);
float t4803 = (t4802*t4802);
float t4804 = (t4790*t4803);
float t4805 = (t4787+t4804);
float t4806 = sqrt(t4805);
float t4807 = asin(t4806);
float t4808 = (2*t4807);
float t4809 = (t4778-t4808);
float t4810 = abs(t4809);
bool t4811 = (float(1.0e-4)>t4810);
float t4812;
if(t4811){
float t4813 = cos(t4695);
float t4814 = (1*t4813);
float t4815 = sin(t4669);
float t4816 = (1*t4815);
float t4817 = cos(t4717);
float t4818 = (t4816*t4817);
float t4819 = (t4814*t4818);
float t4820 = sin(t4695);
float t4821 = (1*t4820);
float t4822 = cos(t4733);
float t4823 = (t4821*t4822);
float t4824 = cos(t4669);
float t4825 = (1*t4824);
float t4826 = (t4823*t4825);
float t4827 = (t4819-t4826);
float t4828 = sin(t8);
float t4829 = (1*t4828);
float t4830 = sin(t118);
float t4831 = (t4829*t4830);
float t4832 = (t4827*t4831);
float t4833 = sin(t4669);
float t4834 = (1*t4833);
float t4835 = sin(t4717);
float t4836 = (t4834*t4835);
float t4837 = (t4823*t4836);
float t4838 = sin(t4695);
float t4839 = (1*t4838);
float t4840 = sin(t4733);
float t4841 = (t4839*t4840);
float t4842 = (t4841*t4818);
float t4843 = (t4837-t4842);
float t4844 = cos(t8);
float t4845 = (1*t4844);
float t4846 = (t4843*t4845);
float t4847 = (t4832+t4846);
float t4848 = (t4841*t4825);
float t4849 = (t4814*t4836);
float t4850 = (t4848-t4849);
float t4851 = sin(t8);
float t4852 = (1*t4851);
float t4853 = cos(t118);
float t4854 = (t4852*t4853);
float t4855 = (t4850*t4854);
float t4856 = (t4847+t4855);
float t4857 = abs(t4856);
t4812 = t4857;
} else {
float t4858 = (3.1415927/2);
float t4859 = (t8-t4858);
float t4860 = (3.1415927/2);
float t4861 = (t4669-t4860);
float t4862 = (t4859-t4861);
float t4863 = abs(t4862);
float t4864 = (t4863/2);
float t4865 = sin(t4864);
float t4866 = (t4865*t4865);
float t4867 = cos(t4861);
float t4868 = cos(t4859);
float t4869 = (t4867*t4868);
float t4870 = (t118+3.1415927);
float t4871 = (3.1415927*2);
float t4872 = mod(t4870,t4871);
float t4873 = (t4872-3.1415927);
float t4874 = (t4717+3.1415927);
float t4875 = (3.1415927*2);
float t4876 = mod(t4874,t4875);
float t4877 = (t4876-3.1415927);
float t4878 = (t4873-t4877);
float t4879 = abs(t4878);
float t4880 = (t4879/2);
float t4881 = sin(t4880);
float t4882 = (t4881*t4881);
float t4883 = (t4869*t4882);
float t4884 = (t4866+t4883);
float t4885 = sqrt(t4884);
float t4886 = asin(t4885);
float t4887 = (2*t4886);
float t4888 = abs(t4887);
float t4889 = (3.1415927/2);
float t4890 = (t8-t4889);
float t4891 = (3.1415927/2);
float t4892 = (t4695-t4891);
float t4893 = (t4890-t4892);
float t4894 = abs(t4893);
float t4895 = (t4894/2);
float t4896 = sin(t4895);
float t4897 = (t4896*t4896);
float t4898 = cos(t4892);
float t4899 = cos(t4890);
float t4900 = (t4898*t4899);
float t4901 = (t118+3.1415927);
float t4902 = (3.1415927*2);
float t4903 = mod(t4901,t4902);
float t4904 = (t4903-3.1415927);
float t4905 = (t4733+3.1415927);
float t4906 = (3.1415927*2);
float t4907 = mod(t4905,t4906);
float t4908 = (t4907-3.1415927);
float t4909 = (t4904-t4908);
float t4910 = abs(t4909);
float t4911 = (t4910/2);
float t4912 = sin(t4911);
float t4913 = (t4912*t4912);
float t4914 = (t4900*t4913);
float t4915 = (t4897+t4914);
float t4916 = sqrt(t4915);
float t4917 = asin(t4916);
float t4918 = (2*t4917);
float t4919 = abs(t4918);
bool t4920 = (t4888>=t4919);
float t4921;
if(t4920){
t4921 = t4888;
} else {
t4921 = t4919;
}
t4812 = t4921;
}
float t4922 = abs(t4812);
float t4923 = step(float(2.0e-4),t4922);
float t4924 = (1-t4923);
float t4925 = (t2011*t4652);
float t4926 = (t4925*float(842.378));
float t4927 = fract(t4926);
float t4928 = (t4927+float(45.32));
float t4929 = (t4928+u6.u0);
float t4930 = (t4927*t4929);
float t4931 = (t3047*t1346);
float t4932 = (t4931*float(1734.048));
float t4933 = fract(t4932);
float t4934 = (t4933+float(45.32));
float t4935 = (t4934+u6.u0);
float t4936 = (t4933*t4935);
float t4937 = (t4930+t4936);
float t4938 = (t4927+t4937);
float t4939 = (t4933+t4937);
float t4940 = (t4938*t4939);
float t4941 = fract(t4940);
float t4942 = step(float(0.2),t4941);
float t4943 = (t4924*t4942);
float t4944 = (3.1415927/2);
float t4945 = (t4669-t4944);
float t4946 = (3.1415927/2);
float t4947 = (t4695-t4946);
float t4948 = (t4945-t4947);
float t4949 = abs(t4948);
float t4950 = (t4949/2);
float t4951 = sin(t4950);
float t4952 = (t4951*t4951);
float t4953 = cos(t4947);
float t4954 = cos(t4945);
float t4955 = (t4953*t4954);
float t4956 = (t4717+3.1415927);
float t4957 = (3.1415927*2);
float t4958 = mod(t4956,t4957);
float t4959 = (t4958-3.1415927);
float t4960 = (t4733+3.1415927);
float t4961 = (3.1415927*2);
float t4962 = mod(t4960,t4961);
float t4963 = (t4962-3.1415927);
float t4964 = (t4959-t4963);
float t4965 = abs(t4964);
float t4966 = (t4965/2);
float t4967 = sin(t4966);
float t4968 = (t4967*t4967);
float t4969 = (t4955*t4968);
float t4970 = (t4952+t4969);
float t4971 = sqrt(t4970);
float t4972 = asin(t4971);
float t4973 = (2*t4972);
float t4974 = (t4973/t1344);
float t4975 = (1-t4974);
float t4976 = (t2011/36);
float t4977 = (t4976*float(842.378));
float t4978 = fract(t4977);
float t4979 = (t4978+float(45.32));
float t4980 = (t4979+u6.u0);
float t4981 = (t4978*t4980);
float t4982 = (t3047/t2024);
float t4983 = (t4982*float(1734.048));
float t4984 = fract(t4983);
float t4985 = (t4984+float(45.32));
float t4986 = (t4985+u6.u0);
float t4987 = (t4984*t4986);
float t4988 = (t4981+t4987);
float t4989 = (t4978+t4988);
float t4990 = (t4984+t4988);
float t4991 = (t4989*t4990);
float t4992 = fract(t4991);
float t4993 = (t4992*float(8.0e-3));
float t4994 = (float(1.0e-3)+t4993);
float t4995 = (t4992*173);
float t4996 = fract(t4995);
float t4997 = step(float(0.66),t4996);
float t4998 = (t4997*float(3.0e-3));
float t4999 = (t4994-t4998);
float t5000 = (t4999*float(0.8));
float t5001 = (t1346/36);
float t5002 = (t5001*float(842.378));
float t5003 = fract(t5002);
float t5004 = (t5003+float(45.32));
float t5005 = (t5004+u6.u0);
float t5006 = (t5003*t5005);
float t5007 = (t4652/t2024);
float t5008 = (t5007*float(1734.048));
float t5009 = fract(t5008);
float t5010 = (t5009+float(45.32));
float t5011 = (t5010+u6.u0);
float t5012 = (t5009*t5011);
float t5013 = (t5006+t5012);
float t5014 = (t5003+t5013);
float t5015 = (t5009+t5013);
float t5016 = (t5014*t5015);
float t5017 = fract(t5016);
float t5018 = (t5017*float(8.0e-3));
float t5019 = (float(1.0e-3)+t5018);
float t5020 = (t5017*173);
float t5021 = fract(t5020);
float t5022 = step(float(0.66),t5021);
float t5023 = (t5022*float(3.0e-3));
float t5024 = (t5019-t5023);
float t5025 = (t5024*float(0.8));
float t5026 = (t5000-t5025);
float t5027 = abs(t5026);
float t5028 = (t5027-float(1.0e-3));
float t5029 = (t5028/float(8.0e-3));
float t5030 = (1-t5029);
float t5031 = (t5030*t5030);
float t5032 = (t4975*t5031);
float t5033 = (t4943*t5032);
float t5034 = (u4.u0*t4941);
float t5035 = (t5034*3);
float t5036 = sin(t5035);
float t5037 = (t5036+1);
float t5038 = (t5037/2);
float t5039 = (t5038*float(0.66));
float t5040 = (t5039+float(0.33));
float t5041 = (t5033*t5040);
float t5042 = (float(0.2)*t5041);
bool t5043 = (0>=t5042);
float t5044;
if(t5043){
t5044 = 0;
} else {
t5044 = t5042;
}
float t5045 = (t5044*1);
float t5046 = (t4644+t5045);
float t5047 = (t1346*t1344);
float t5048 = (t1346/36);
float t5049 = (t5048*float(842.378));
float t5050 = fract(t5049);
float t5051 = (t5050+float(45.32));
float t5052 = (t5051+u6.u0);
float t5053 = (t5050*t5052);
float t5054 = (t4652/t2024);
float t5055 = (t5054*float(1734.048));
float t5056 = fract(t5055);
float t5057 = (t5056+float(45.32));
float t5058 = (t5057+u6.u0);
float t5059 = (t5056*t5058);
float t5060 = (t5053+t5059);
float t5061 = (t5050+t5060);
float t5062 = (t5056+t5060);
float t5063 = (t5061*t5062);
float t5064 = fract(t5063);
float t5065 = (t5064*float(2852.02));
float t5066 = fract(t5065);
float t5067 = (t5066-float(0.5));
float t5068 = (t5067*t1344);
float t5069 = (t5068*float(0.75));
float t5070 = (t5047+t5069);
float t5071 = (3.1415927/2);
float t5072 = (t5070-t5071);
float t5073 = (t1346*t1344);
float t5074 = (t1346/36);
float t5075 = (t5074*float(842.378));
float t5076 = fract(t5075);
float t5077 = (t5076+float(45.32));
float t5078 = (t5077+u6.u0);
float t5079 = (t5076*t5078);
float t5080 = (t1800/t1359);
float t5081 = (t5080*float(1734.048));
float t5082 = fract(t5081);
float t5083 = (t5082+float(45.32));
float t5084 = (t5083+u6.u0);
float t5085 = (t5082*t5084);
float t5086 = (t5079+t5085);
float t5087 = (t5076+t5086);
float t5088 = (t5082+t5086);
float t5089 = (t5087*t5088);
float t5090 = fract(t5089);
float t5091 = (t5090*float(2852.02));
float t5092 = fract(t5091);
float t5093 = (t5092-float(0.5));
float t5094 = (t5093*t1344);
float t5095 = (t5094*float(0.75));
float t5096 = (t5073+t5095);
float t5097 = (3.1415927/2);
float t5098 = (t5096-t5097);
float t5099 = (t5072-t5098);
float t5100 = abs(t5099);
float t5101 = (t5100/2);
float t5102 = sin(t5101);
float t5103 = (t5102*t5102);
float t5104 = cos(t5098);
float t5105 = cos(t5072);
float t5106 = (t5104*t5105);
float t5107 = (3.1415927/t2024);
float t5108 = (t4652*t5107);
float t5109 = (t5064*float(97372.83));
float t5110 = fract(t5109);
float t5111 = (t5110-float(0.5));
float t5112 = (3.1415927/t2024);
float t5113 = (t5111*t5112);
float t5114 = (t5113*float(0.75));
float t5115 = (t5108+t5114);
float t5116 = (t5115+3.1415927);
float t5117 = mod(t5116,t1433);
float t5118 = (t5117-3.1415927);
float t5119 = (t5118+3.1415927);
float t5120 = (3.1415927*2);
float t5121 = mod(t5119,t5120);
float t5122 = (t5121-3.1415927);
float t5123 = (3.1415927/t1359);
float t5124 = (t1800*t5123);
float t5125 = (t5090*float(97372.83));
float t5126 = fract(t5125);
float t5127 = (t5126-float(0.5));
float t5128 = (3.1415927/t1359);
float t5129 = (t5127*t5128);
float t5130 = (t5129*float(0.75));
float t5131 = (t5124+t5130);
float t5132 = (t5131+3.1415927);
float t5133 = mod(t5132,t1433);
float t5134 = (t5133-3.1415927);
float t5135 = (t5134+3.1415927);
float t5136 = (3.1415927*2);
float t5137 = mod(t5135,t5136);
float t5138 = (t5137-3.1415927);
float t5139 = (t5122-t5138);
float t5140 = abs(t5139);
float t5141 = (t5140/2);
float t5142 = sin(t5141);
float t5143 = (t5142*t5142);
float t5144 = (t5106*t5143);
float t5145 = (t5103+t5144);
float t5146 = sqrt(t5145);
float t5147 = asin(t5146);
float t5148 = (2*t5147);
float t5149 = (3.1415927/2);
float t5150 = (t8-t5149);
float t5151 = (3.1415927/2);
float t5152 = (t5096-t5151);
float t5153 = (t5150-t5152);
float t5154 = abs(t5153);
float t5155 = (t5154/2);
float t5156 = sin(t5155);
float t5157 = (t5156*t5156);
float t5158 = cos(t5152);
float t5159 = cos(t5150);
float t5160 = (t5158*t5159);
float t5161 = (t118+3.1415927);
float t5162 = (3.1415927*2);
float t5163 = mod(t5161,t5162);
float t5164 = (t5163-3.1415927);
float t5165 = (t5134+3.1415927);
float t5166 = (3.1415927*2);
float t5167 = mod(t5165,t5166);
float t5168 = (t5167-3.1415927);
float t5169 = (t5164-t5168);
float t5170 = abs(t5169);
float t5171 = (t5170/2);
float t5172 = sin(t5171);
float t5173 = (t5172*t5172);
float t5174 = (t5160*t5173);
float t5175 = (t5157+t5174);
float t5176 = sqrt(t5175);
float t5177 = asin(t5176);
float t5178 = (2*t5177);
float t5179 = (t5148-t5178);
float t5180 = (3.1415927/2);
float t5181 = (t8-t5180);
float t5182 = (3.1415927/2);
float t5183 = (t5070-t5182);
float t5184 = (t5181-t5183);
float t5185 = abs(t5184);
float t5186 = (t5185/2);
float t5187 = sin(t5186);
float t5188 = (t5187*t5187);
float t5189 = cos(t5183);
float t5190 = cos(t5181);
float t5191 = (t5189*t5190);
float t5192 = (t118+3.1415927);
float t5193 = (3.1415927*2);
float t5194 = mod(t5192,t5193);
float t5195 = (t5194-3.1415927);
float t5196 = (t5118+3.1415927);
float t5197 = (3.1415927*2);
float t5198 = mod(t5196,t5197);
float t5199 = (t5198-3.1415927);
float t5200 = (t5195-t5199);
float t5201 = abs(t5200);
float t5202 = (t5201/2);
float t5203 = sin(t5202);
float t5204 = (t5203*t5203);
float t5205 = (t5191*t5204);
float t5206 = (t5188+t5205);
float t5207 = sqrt(t5206);
float t5208 = asin(t5207);
float t5209 = (2*t5208);
float t5210 = (t5179-t5209);
float t5211 = abs(t5210);
bool t5212 = (float(1.0e-4)>t5211);
float t5213;
if(t5212){
float t5214 = cos(t5096);
float t5215 = (1*t5214);
float t5216 = sin(t5070);
float t5217 = (1*t5216);
float t5218 = cos(t5118);
float t5219 = (t5217*t5218);
float t5220 = (t5215*t5219);
float t5221 = sin(t5096);
float t5222 = (1*t5221);
float t5223 = cos(t5134);
float t5224 = (t5222*t5223);
float t5225 = cos(t5070);
float t5226 = (1*t5225);
float t5227 = (t5224*t5226);
float t5228 = (t5220-t5227);
float t5229 = sin(t8);
float t5230 = (1*t5229);
float t5231 = sin(t118);
float t5232 = (t5230*t5231);
float t5233 = (t5228*t5232);
float t5234 = sin(t5070);
float t5235 = (1*t5234);
float t5236 = sin(t5118);
float t5237 = (t5235*t5236);
float t5238 = (t5224*t5237);
float t5239 = sin(t5096);
float t5240 = (1*t5239);
float t5241 = sin(t5134);
float t5242 = (t5240*t5241);
float t5243 = (t5242*t5219);
float t5244 = (t5238-t5243);
float t5245 = cos(t8);
float t5246 = (1*t5245);
float t5247 = (t5244*t5246);
float t5248 = (t5233+t5247);
float t5249 = (t5242*t5226);
float t5250 = (t5215*t5237);
float t5251 = (t5249-t5250);
float t5252 = sin(t8);
float t5253 = (1*t5252);
float t5254 = cos(t118);
float t5255 = (t5253*t5254);
float t5256 = (t5251*t5255);
float t5257 = (t5248+t5256);
float t5258 = abs(t5257);
t5213 = t5258;
} else {
float t5259 = (3.1415927/2);
float t5260 = (t8-t5259);
float t5261 = (3.1415927/2);
float t5262 = (t5070-t5261);
float t5263 = (t5260-t5262);
float t5264 = abs(t5263);
float t5265 = (t5264/2);
float t5266 = sin(t5265);
float t5267 = (t5266*t5266);
float t5268 = cos(t5262);
float t5269 = cos(t5260);
float t5270 = (t5268*t5269);
float t5271 = (t118+3.1415927);
float t5272 = (3.1415927*2);
float t5273 = mod(t5271,t5272);
float t5274 = (t5273-3.1415927);
float t5275 = (t5118+3.1415927);
float t5276 = (3.1415927*2);
float t5277 = mod(t5275,t5276);
float t5278 = (t5277-3.1415927);
float t5279 = (t5274-t5278);
float t5280 = abs(t5279);
float t5281 = (t5280/2);
float t5282 = sin(t5281);
float t5283 = (t5282*t5282);
float t5284 = (t5270*t5283);
float t5285 = (t5267+t5284);
float t5286 = sqrt(t5285);
float t5287 = asin(t5286);
float t5288 = (2*t5287);
float t5289 = abs(t5288);
float t5290 = (3.1415927/2);
float t5291 = (t8-t5290);
float t5292 = (3.1415927/2);
float t5293 = (t5096-t5292);
float t5294 = (t5291-t5293);
float t5295 = abs(t5294);
float t5296 = (t5295/2);
float t5297 = sin(t5296);
float t5298 = (t5297*t5297);
float t5299 = cos(t5293);
float t5300 = cos(t5291);
float t5301 = (t5299*t5300);
float t5302 = (t118+3.1415927);
float t5303 = (3.1415927*2);
float t5304 = mod(t5302,t5303);
float t5305 = (t5304-3.1415927);
float t5306 = (t5134+3.1415927);
float t5307 = (3.1415927*2);
float t5308 = mod(t5306,t5307);
float t5309 = (t5308-3.1415927);
float t5310 = (t5305-t5309);
float t5311 = abs(t5310);
float t5312 = (t5311/2);
float t5313 = sin(t5312);
float t5314 = (t5313*t5313);
float t5315 = (t5301*t5314);
float t5316 = (t5298+t5315);
float t5317 = sqrt(t5316);
float t5318 = asin(t5317);
float t5319 = (2*t5318);
float t5320 = abs(t5319);
bool t5321 = (t5289>=t5320);
float t5322;
if(t5321){
t5322 = t5289;
} else {
t5322 = t5320;
}
t5213 = t5322;
}
float t5323 = abs(t5213);
float t5324 = step(float(2.0e-4),t5323);
float t5325 = (1-t5324);
float t5326 = (t1346*t4652);
float t5327 = (t5326*float(842.378));
float t5328 = fract(t5327);
float t5329 = (t5328+float(45.32));
float t5330 = (t5329+u6.u0);
float t5331 = (t5328*t5330);
float t5332 = (t1800*t1346);
float t5333 = (t5332*float(1734.048));
float t5334 = fract(t5333);
float t5335 = (t5334+float(45.32));
float t5336 = (t5335+u6.u0);
float t5337 = (t5334*t5336);
float t5338 = (t5331+t5337);
float t5339 = (t5328+t5338);
float t5340 = (t5334+t5338);
float t5341 = (t5339*t5340);
float t5342 = fract(t5341);
float t5343 = step(float(0.2),t5342);
float t5344 = (t5325*t5343);
float t5345 = (3.1415927/2);
float t5346 = (t5070-t5345);
float t5347 = (3.1415927/2);
float t5348 = (t5096-t5347);
float t5349 = (t5346-t5348);
float t5350 = abs(t5349);
float t5351 = (t5350/2);
float t5352 = sin(t5351);
float t5353 = (t5352*t5352);
float t5354 = cos(t5348);
float t5355 = cos(t5346);
float t5356 = (t5354*t5355);
float t5357 = (t5118+3.1415927);
float t5358 = (3.1415927*2);
float t5359 = mod(t5357,t5358);
float t5360 = (t5359-3.1415927);
float t5361 = (t5134+3.1415927);
float t5362 = (3.1415927*2);
float t5363 = mod(t5361,t5362);
float t5364 = (t5363-3.1415927);
float t5365 = (t5360-t5364);
float t5366 = abs(t5365);
float t5367 = (t5366/2);
float t5368 = sin(t5367);
float t5369 = (t5368*t5368);
float t5370 = (t5356*t5369);
float t5371 = (t5353+t5370);
float t5372 = sqrt(t5371);
float t5373 = asin(t5372);
float t5374 = (2*t5373);
float t5375 = (t5374/t1344);
float t5376 = (1-t5375);
float t5377 = (t1346/36);
float t5378 = (t5377*float(842.378));
float t5379 = fract(t5378);
float t5380 = (t5379+float(45.32));
float t5381 = (t5380+u6.u0);
float t5382 = (t5379*t5381);
float t5383 = (t1800/t1359);
float t5384 = (t5383*float(1734.048));
float t5385 = fract(t5384);
float t5386 = (t5385+float(45.32));
float t5387 = (t5386+u6.u0);
float t5388 = (t5385*t5387);
float t5389 = (t5382+t5388);
float t5390 = (t5379+t5389);
float t5391 = (t5385+t5389);
float t5392 = (t5390*t5391);
float t5393 = fract(t5392);
float t5394 = (t5393*float(8.0e-3));
float t5395 = (float(1.0e-3)+t5394);
float t5396 = (t5393*173);
float t5397 = fract(t5396);
float t5398 = step(float(0.66),t5397);
float t5399 = (t5398*float(3.0e-3));
float t5400 = (t5395-t5399);
float t5401 = (t5400*float(0.8));
float t5402 = (t1346/36);
float t5403 = (t5402*float(842.378));
float t5404 = fract(t5403);
float t5405 = (t5404+float(45.32));
float t5406 = (t5405+u6.u0);
float t5407 = (t5404*t5406);
float t5408 = (t4652/t2024);
float t5409 = (t5408*float(1734.048));
float t5410 = fract(t5409);
float t5411 = (t5410+float(45.32));
float t5412 = (t5411+u6.u0);
float t5413 = (t5410*t5412);
float t5414 = (t5407+t5413);
float t5415 = (t5404+t5414);
float t5416 = (t5410+t5414);
float t5417 = (t5415*t5416);
float t5418 = fract(t5417);
float t5419 = (t5418*float(8.0e-3));
float t5420 = (float(1.0e-3)+t5419);
float t5421 = (t5418*173);
float t5422 = fract(t5421);
float t5423 = step(float(0.66),t5422);
float t5424 = (t5423*float(3.0e-3));
float t5425 = (t5420-t5424);
float t5426 = (t5425*float(0.8));
float t5427 = (t5401-t5426);
float t5428 = abs(t5427);
float t5429 = (t5428-float(1.0e-3));
float t5430 = (t5429/float(8.0e-3));
float t5431 = (1-t5430);
float t5432 = (t5431*t5431);
float t5433 = (t5376*t5432);
float t5434 = (t5344*t5433);
float t5435 = (u4.u0*t5342);
float t5436 = (t5435*3);
float t5437 = sin(t5436);
float t5438 = (t5437+1);
float t5439 = (t5438/2);
float t5440 = (t5439*float(0.66));
float t5441 = (t5440+float(0.33));
float t5442 = (t5434*t5441);
float t5443 = (float(0.2)*t5442);
bool t5444 = (0>=t5443);
float t5445;
if(t5444){
t5445 = 0;
} else {
t5445 = t5443;
}
float t5446 = (t5445*1);
float t5447 = (t5046+t5446);
float t5448 = (3.1415927/85);
float t5449 = (t8/t5448);
float t5450 = floor(t5449);
float t5451 = (t5450/85);
float t5452 = (t5450/85);
float t5453 = (t5452*float(842.378));
float t5454 = fract(t5453);
float t5455 = (t5454+float(45.32));
float t5456 = (t5455+u6.u0);
float t5457 = (t5454*t5456);
float t5458 = (t5450/85);
float t5459 = (t5458*3.1415927);
float t5460 = sin(t5459);
float t5461 = (85*t5460);
float t5462 = floor(t5461);
float t5463 = (t5462+1);
float t5464 = (3.1415927/t5463);
float t5465 = (t118/t5464);
float t5466 = floor(t5465);
float t5467 = (t5466/t5463);
float t5468 = (t5467*float(1734.048));
float t5469 = fract(t5468);
float t5470 = (t5469+float(45.32));
float t5471 = (t5470+u6.u0);
float t5472 = (t5469*t5471);
float t5473 = (t5457+t5472);
float t5474 = (t5454+t5473);
float t5475 = (t5469+t5473);
float t5476 = (t5474*t5475);
float t5477 = fract(t5476);
float t5478 = (t5477*5);
float t5479 = (t5451+t5478);
float t5480 = fract(t5479);
float t5481 = (t5480*12000);
float t5482 = (t5481/1000);
bool t5483 = (1<=t5482);
float t5484;
if(t5483){
t5484 = 1;
} else {
t5484 = t5482;
}
float t5485 = (t5481-6000);
float t5486 = (t5485/8000);
bool t5487 = (0>=t5486);
float t5488;
if(t5487){
t5488 = 0;
} else {
t5488 = t5486;
}
float t5489 = (t5484-t5488);
float t5490 = (t5477*173);
float t5491 = fract(t5490);
float t5492 = step(float(0.66),t5491);
float t5493 = (t5492*3);
float t5494 = (3+t5493);
float t5495 = (3.1415927/t5494);
float t5496 = cos(t5495);
float t5497 = (1-t5496);
float t5498 = (t5450*t5448);
float t5499 = (t5450/85);
float t5500 = (t5499*float(842.378));
float t5501 = fract(t5500);
float t5502 = (t5501+float(45.32));
float t5503 = (t5502+u6.u0);
float t5504 = (t5501*t5503);
float t5505 = (t5466/t5463);
float t5506 = (t5505*float(1734.048));
float t5507 = fract(t5506);
float t5508 = (t5507+float(45.32));
float t5509 = (t5508+u6.u0);
float t5510 = (t5507*t5509);
float t5511 = (t5504+t5510);
float t5512 = (t5501+t5511);
float t5513 = (t5507+t5511);
float t5514 = (t5512*t5513);
float t5515 = fract(t5514);
float t5516 = (t5515*float(2852.02));
float t5517 = fract(t5516);
float t5518 = (t5517-float(0.5));
float t5519 = (t5518*t5448);
float t5520 = (t5519*float(0.75));
float t5521 = (t5498+t5520);
float t5522 = cos(t5521);
float t5523 = (1*t5522);
float t5524 = (t5523*0);
float t5525 = sin(t5521);
float t5526 = (1*t5525);
float t5527 = (3.1415927/t5463);
float t5528 = (t5466*t5527);
float t5529 = (t5515*float(97372.83));
float t5530 = fract(t5529);
float t5531 = (t5530-float(0.5));
float t5532 = (3.1415927/t5463);
float t5533 = (t5531*t5532);
float t5534 = (t5533*float(0.75));
float t5535 = (t5528+t5534);
float t5536 = (t5535+3.1415927);
float t5537 = mod(t5536,t1433);
float t5538 = (t5537-3.1415927);
float t5539 = cos(t5538);
float t5540 = (t5526*t5539);
float t5541 = (t5540*1);
float t5542 = (t5524-t5541);
float t5543 = sin(t8);
float t5544 = (1*t5543);
float t5545 = sin(t118);
float t5546 = (t5544*t5545);
float t5547 = (t5542*t5546);
float t5548 = (t5540*0);
float t5549 = sin(t5521);
float t5550 = (1*t5549);
float t5551 = sin(t5538);
float t5552 = (t5550*t5551);
float t5553 = (t5552*0);
float t5554 = (t5548-t5553);
float t5555 = cos(t8);
float t5556 = (1*t5555);
float t5557 = (t5554*t5556);
float t5558 = (t5547+t5557);
float t5559 = (t5552*1);
float t5560 = (t5523*0);
float t5561 = (t5559-t5560);
float t5562 = sin(t8);
float t5563 = (1*t5562);
float t5564 = cos(t118);
float t5565 = (t5563*t5564);
float t5566 = (t5561*t5565);
float t5567 = (t5558+t5566);
float t5568 = (t5554*t5540);
float t5569 = (t5561*t5523);
float t5570 = (t5568-t5569);
float t5571 = (t5570*t5546);
float t5572 = (t5561*t5552);
float t5573 = (t5542*t5540);
float t5574 = (t5572-t5573);
float t5575 = (t5574*t5556);
float t5576 = (t5571+t5575);
float t5577 = (t5542*t5523);
float t5578 = (t5554*t5552);
float t5579 = (t5577-t5578);
float t5580 = (t5579*t5565);
float t5581 = (t5576+t5580);
float t5582 = atan(t5567,t5581);
float t5583 = (t5582+3.1415927);
float t5584 = (t5491*3.1415927);
float t5585 = (t5583+t5584);
float t5586 = (t5585/t1483);
float t5587 = fract(t5586);
float t5588 = (t5587*t5494);
float t5589 = fract(t5588);
float t5590 = (t5589*2);
float t5591 = (t5590-1);
float t5592 = abs(t5591);
float t5593 = (t5592*t5592);
float t5594 = (t5497*t5593);
float t5595 = (t5496+t5594);
float t5596 = (t5477*float(8.0e-3));
float t5597 = (float(1.0e-3)+t5596);
float t5598 = step(float(0.66),t5491);
float t5599 = (t5598*float(3.0e-3));
float t5600 = (t5597-t5599);
float t5601 = (t5600*float(0.45));
float t5602 = (t5595*t5601);
float t5603 = (3.1415927/2);
float t5604 = (t5521-t5603);
float t5605 = (3.1415927/2);
float t5606 = (t8-t5605);
float t5607 = (t5604-t5606);
float t5608 = abs(t5607);
float t5609 = (t5608/2);
float t5610 = sin(t5609);
float t5611 = (t5610*t5610);
float t5612 = cos(t5606);
float t5613 = cos(t5604);
float t5614 = (t5612*t5613);
float t5615 = (t5538+3.1415927);
float t5616 = (3.1415927*2);
float t5617 = mod(t5615,t5616);
float t5618 = (t5617-3.1415927);
float t5619 = (t118+3.1415927);
float t5620 = (3.1415927*2);
float t5621 = mod(t5619,t5620);
float t5622 = (t5621-3.1415927);
float t5623 = (t5618-t5622);
float t5624 = abs(t5623);
float t5625 = (t5624/2);
float t5626 = sin(t5625);
float t5627 = (t5626*t5626);
float t5628 = (t5614*t5627);
float t5629 = (t5611+t5628);
float t5630 = sqrt(t5629);
float t5631 = asin(t5630);
float t5632 = (2*t5631);
float t5633 = step(t5602,t5632);
float t5634 = (1-t5633);
float t5635 = (t5489*t5634);
float t5636 = (3.1415927/2);
float t5637 = (t8-t5636);
float t5638 = (3.1415927/2);
float t5639 = (t5521-t5638);
float t5640 = (t5637-t5639);
float t5641 = abs(t5640);
float t5642 = (t5641/2);
float t5643 = sin(t5642);
float t5644 = (t5643*t5643);
float t5645 = cos(t5639);
float t5646 = cos(t5637);
float t5647 = (t5645*t5646);
float t5648 = (t118+3.1415927);
float t5649 = (3.1415927*2);
float t5650 = mod(t5648,t5649);
float t5651 = (t5650-3.1415927);
float t5652 = (t5538+3.1415927);
float t5653 = (3.1415927*2);
float t5654 = mod(t5652,t5653);
float t5655 = (t5654-3.1415927);
float t5656 = (t5651-t5655);
float t5657 = abs(t5656);
float t5658 = (t5657/2);
float t5659 = sin(t5658);
float t5660 = (t5659*t5659);
float t5661 = (t5647*t5660);
float t5662 = (t5644+t5661);
float t5663 = sqrt(t5662);
float t5664 = asin(t5663);
float t5665 = (2*t5664);
float t5666 = (1/t5665);
float t5667 = (t5666*t5601);
float t5668 = (t5667*float(1.25e-2));
float t5669 = (u4.u0*t5477);
float t5670 = cos(t5669);
float t5671 = (t5670+1);
float t5672 = (t5671/2);
float t5673 = (t5668*t5672);
float t5674 = (t5673*t5489);
float t5675 = (t5635+t5674);
float t5676 = (0+t5675);
float t5677 = (t5450/85);
float t5678 = (t5450/85);
float t5679 = (t5678*float(842.378));
float t5680 = fract(t5679);
float t5681 = (t5680+float(45.32));
float t5682 = (t5681+u6.u0);
float t5683 = (t5680*t5682);
float t5684 = (t5466+1);
float t5685 = (t5684/t5463);
float t5686 = (t5685*float(1734.048));
float t5687 = fract(t5686);
float t5688 = (t5687+float(45.32));
float t5689 = (t5688+u6.u0);
float t5690 = (t5687*t5689);
float t5691 = (t5683+t5690);
float t5692 = (t5680+t5691);
float t5693 = (t5687+t5691);
float t5694 = (t5692*t5693);
float t5695 = fract(t5694);
float t5696 = (t5695*5);
float t5697 = (t5677+t5696);
float t5698 = fract(t5697);
float t5699 = (t5698*12000);
float t5700 = (t5699/1000);
bool t5701 = (1<=t5700);
float t5702;
if(t5701){
t5702 = 1;
} else {
t5702 = t5700;
}
float t5703 = (t5699-6000);
float t5704 = (t5703/8000);
bool t5705 = (0>=t5704);
float t5706;
if(t5705){
t5706 = 0;
} else {
t5706 = t5704;
}
float t5707 = (t5702-t5706);
float t5708 = (t5695*173);
float t5709 = fract(t5708);
float t5710 = step(float(0.66),t5709);
float t5711 = (t5710*3);
float t5712 = (3+t5711);
float t5713 = (3.1415927/t5712);
float t5714 = cos(t5713);
float t5715 = (1-t5714);
float t5716 = (t5450*t5448);
float t5717 = (t5450/85);
float t5718 = (t5717*float(842.378));
float t5719 = fract(t5718);
float t5720 = (t5719+float(45.32));
float t5721 = (t5720+u6.u0);
float t5722 = (t5719*t5721);
float t5723 = (t5684/t5463);
float t5724 = (t5723*float(1734.048));
float t5725 = fract(t5724);
float t5726 = (t5725+float(45.32));
float t5727 = (t5726+u6.u0);
float t5728 = (t5725*t5727);
float t5729 = (t5722+t5728);
float t5730 = (t5719+t5729);
float t5731 = (t5725+t5729);
float t5732 = (t5730*t5731);
float t5733 = fract(t5732);
float t5734 = (t5733*float(2852.02));
float t5735 = fract(t5734);
float t5736 = (t5735-float(0.5));
float t5737 = (t5736*t5448);
float t5738 = (t5737*float(0.75));
float t5739 = (t5716+t5738);
float t5740 = cos(t5739);
float t5741 = (1*t5740);
float t5742 = (t5741*0);
float t5743 = sin(t5739);
float t5744 = (1*t5743);
float t5745 = (3.1415927/t5463);
float t5746 = (t5684*t5745);
float t5747 = (t5733*float(97372.83));
float t5748 = fract(t5747);
float t5749 = (t5748-float(0.5));
float t5750 = (3.1415927/t5463);
float t5751 = (t5749*t5750);
float t5752 = (t5751*float(0.75));
float t5753 = (t5746+t5752);
float t5754 = (t5753+3.1415927);
float t5755 = mod(t5754,t1433);
float t5756 = (t5755-3.1415927);
float t5757 = cos(t5756);
float t5758 = (t5744*t5757);
float t5759 = (t5758*1);
float t5760 = (t5742-t5759);
float t5761 = sin(t8);
float t5762 = (1*t5761);
float t5763 = sin(t118);
float t5764 = (t5762*t5763);
float t5765 = (t5760*t5764);
float t5766 = (t5758*0);
float t5767 = sin(t5739);
float t5768 = (1*t5767);
float t5769 = sin(t5756);
float t5770 = (t5768*t5769);
float t5771 = (t5770*0);
float t5772 = (t5766-t5771);
float t5773 = cos(t8);
float t5774 = (1*t5773);
float t5775 = (t5772*t5774);
float t5776 = (t5765+t5775);
float t5777 = (t5770*1);
float t5778 = (t5741*0);
float t5779 = (t5777-t5778);
float t5780 = sin(t8);
float t5781 = (1*t5780);
float t5782 = cos(t118);
float t5783 = (t5781*t5782);
float t5784 = (t5779*t5783);
float t5785 = (t5776+t5784);
float t5786 = (t5772*t5758);
float t5787 = (t5779*t5741);
float t5788 = (t5786-t5787);
float t5789 = (t5788*t5764);
float t5790 = (t5779*t5770);
float t5791 = (t5760*t5758);
float t5792 = (t5790-t5791);
float t5793 = (t5792*t5774);
float t5794 = (t5789+t5793);
float t5795 = (t5760*t5741);
float t5796 = (t5772*t5770);
float t5797 = (t5795-t5796);
float t5798 = (t5797*t5783);
float t5799 = (t5794+t5798);
float t5800 = atan(t5785,t5799);
float t5801 = (t5800+3.1415927);
float t5802 = (t5709*3.1415927);
float t5803 = (t5801+t5802);
float t5804 = (t5803/t1483);
float t5805 = fract(t5804);
float t5806 = (t5805*t5712);
float t5807 = fract(t5806);
float t5808 = (t5807*2);
float t5809 = (t5808-1);
float t5810 = abs(t5809);
float t5811 = (t5810*t5810);
float t5812 = (t5715*t5811);
float t5813 = (t5714+t5812);
float t5814 = (t5695*float(8.0e-3));
float t5815 = (float(1.0e-3)+t5814);
float t5816 = step(float(0.66),t5709);
float t5817 = (t5816*float(3.0e-3));
float t5818 = (t5815-t5817);
float t5819 = (t5818*float(0.45));
float t5820 = (t5813*t5819);
float t5821 = (3.1415927/2);
float t5822 = (t5739-t5821);
float t5823 = (3.1415927/2);
float t5824 = (t8-t5823);
float t5825 = (t5822-t5824);
float t5826 = abs(t5825);
float t5827 = (t5826/2);
float t5828 = sin(t5827);
float t5829 = (t5828*t5828);
float t5830 = cos(t5824);
float t5831 = cos(t5822);
float t5832 = (t5830*t5831);
float t5833 = (t5756+3.1415927);
float t5834 = (3.1415927*2);
float t5835 = mod(t5833,t5834);
float t5836 = (t5835-3.1415927);
float t5837 = (t118+3.1415927);
float t5838 = (3.1415927*2);
float t5839 = mod(t5837,t5838);
float t5840 = (t5839-3.1415927);
float t5841 = (t5836-t5840);
float t5842 = abs(t5841);
float t5843 = (t5842/2);
float t5844 = sin(t5843);
float t5845 = (t5844*t5844);
float t5846 = (t5832*t5845);
float t5847 = (t5829+t5846);
float t5848 = sqrt(t5847);
float t5849 = asin(t5848);
float t5850 = (2*t5849);
float t5851 = step(t5820,t5850);
float t5852 = (1-t5851);
float t5853 = (t5707*t5852);
float t5854 = (3.1415927/2);
float t5855 = (t8-t5854);
float t5856 = (3.1415927/2);
float t5857 = (t5739-t5856);
float t5858 = (t5855-t5857);
float t5859 = abs(t5858);
float t5860 = (t5859/2);
float t5861 = sin(t5860);
float t5862 = (t5861*t5861);
float t5863 = cos(t5857);
float t5864 = cos(t5855);
float t5865 = (t5863*t5864);
float t5866 = (t118+3.1415927);
float t5867 = (3.1415927*2);
float t5868 = mod(t5866,t5867);
float t5869 = (t5868-3.1415927);
float t5870 = (t5756+3.1415927);
float t5871 = (3.1415927*2);
float t5872 = mod(t5870,t5871);
float t5873 = (t5872-3.1415927);
float t5874 = (t5869-t5873);
float t5875 = abs(t5874);
float t5876 = (t5875/2);
float t5877 = sin(t5876);
float t5878 = (t5877*t5877);
float t5879 = (t5865*t5878);
float t5880 = (t5862+t5879);
float t5881 = sqrt(t5880);
float t5882 = asin(t5881);
float t5883 = (2*t5882);
float t5884 = (1/t5883);
float t5885 = (t5884*t5819);
float t5886 = (t5885*float(1.25e-2));
float t5887 = (u4.u0*t5695);
float t5888 = cos(t5887);
float t5889 = (t5888+1);
float t5890 = (t5889/2);
float t5891 = (t5886*t5890);
float t5892 = (t5891*t5707);
float t5893 = (t5853+t5892);
float t5894 = (t5676+t5893);
float t5895 = (t5450/85);
float t5896 = (t5450/85);
float t5897 = (t5896*float(842.378));
float t5898 = fract(t5897);
float t5899 = (t5898+float(45.32));
float t5900 = (t5899+u6.u0);
float t5901 = (t5898*t5900);
float t5902 = (t5466+2);
float t5903 = (t5902/t5463);
float t5904 = (t5903*float(1734.048));
float t5905 = fract(t5904);
float t5906 = (t5905+float(45.32));
float t5907 = (t5906+u6.u0);
float t5908 = (t5905*t5907);
float t5909 = (t5901+t5908);
float t5910 = (t5898+t5909);
float t5911 = (t5905+t5909);
float t5912 = (t5910*t5911);
float t5913 = fract(t5912);
float t5914 = (t5913*5);
float t5915 = (t5895+t5914);
float t5916 = fract(t5915);
float t5917 = (t5916*12000);
float t5918 = (t5917/1000);
bool t5919 = (1<=t5918);
float t5920;
if(t5919){
t5920 = 1;
} else {
t5920 = t5918;
}
float t5921 = (t5917-6000);
float t5922 = (t5921/8000);
bool t5923 = (0>=t5922);
float t5924;
if(t5923){
t5924 = 0;
} else {
t5924 = t5922;
}
float t5925 = (t5920-t5924);
float t5926 = (t5913*173);
float t5927 = fract(t5926);
float t5928 = step(float(0.66),t5927);
float t5929 = (t5928*3);
float t5930 = (3+t5929);
float t5931 = (3.1415927/t5930);
float t5932 = cos(t5931);
float t5933 = (1-t5932);
float t5934 = (t5450*t5448);
float t5935 = (t5450/85);
float t5936 = (t5935*float(842.378));
float t5937 = fract(t5936);
float t5938 = (t5937+float(45.32));
float t5939 = (t5938+u6.u0);
float t5940 = (t5937*t5939);
float t5941 = (t5902/t5463);
float t5942 = (t5941*float(1734.048));
float t5943 = fract(t5942);
float t5944 = (t5943+float(45.32));
float t5945 = (t5944+u6.u0);
float t5946 = (t5943*t5945);
float t5947 = (t5940+t5946);
float t5948 = (t5937+t5947);
float t5949 = (t5943+t5947);
float t5950 = (t5948*t5949);
float t5951 = fract(t5950);
float t5952 = (t5951*float(2852.02));
float t5953 = fract(t5952);
float t5954 = (t5953-float(0.5));
float t5955 = (t5954*t5448);
float t5956 = (t5955*float(0.75));
float t5957 = (t5934+t5956);
float t5958 = cos(t5957);
float t5959 = (1*t5958);
float t5960 = (t5959*0);
float t5961 = sin(t5957);
float t5962 = (1*t5961);
float t5963 = (3.1415927/t5463);
float t5964 = (t5902*t5963);
float t5965 = (t5951*float(97372.83));
float t5966 = fract(t5965);
float t5967 = (t5966-float(0.5));
float t5968 = (3.1415927/t5463);
float t5969 = (t5967*t5968);
float t5970 = (t5969*float(0.75));
float t5971 = (t5964+t5970);
float t5972 = (t5971+3.1415927);
float t5973 = mod(t5972,t1433);
float t5974 = (t5973-3.1415927);
float t5975 = cos(t5974);
float t5976 = (t5962*t5975);
float t5977 = (t5976*1);
float t5978 = (t5960-t5977);
float t5979 = sin(t8);
float t5980 = (1*t5979);
float t5981 = sin(t118);
float t5982 = (t5980*t5981);
float t5983 = (t5978*t5982);
float t5984 = (t5976*0);
float t5985 = sin(t5957);
float t5986 = (1*t5985);
float t5987 = sin(t5974);
float t5988 = (t5986*t5987);
float t5989 = (t5988*0);
float t5990 = (t5984-t5989);
float t5991 = cos(t8);
float t5992 = (1*t5991);
float t5993 = (t5990*t5992);
float t5994 = (t5983+t5993);
float t5995 = (t5988*1);
float t5996 = (t5959*0);
float t5997 = (t5995-t5996);
float t5998 = sin(t8);
float t5999 = (1*t5998);
float t6000 = cos(t118);
float t6001 = (t5999*t6000);
float t6002 = (t5997*t6001);
float t6003 = (t5994+t6002);
float t6004 = (t5990*t5976);
float t6005 = (t5997*t5959);
float t6006 = (t6004-t6005);
float t6007 = (t6006*t5982);
float t6008 = (t5997*t5988);
float t6009 = (t5978*t5976);
float t6010 = (t6008-t6009);
float t6011 = (t6010*t5992);
float t6012 = (t6007+t6011);
float t6013 = (t5978*t5959);
float t6014 = (t5990*t5988);
float t6015 = (t6013-t6014);
float t6016 = (t6015*t6001);
float t6017 = (t6012+t6016);
float t6018 = atan(t6003,t6017);
float t6019 = (t6018+3.1415927);
float t6020 = (t5927*3.1415927);
float t6021 = (t6019+t6020);
float t6022 = (t6021/t1483);
float t6023 = fract(t6022);
float t6024 = (t6023*t5930);
float t6025 = fract(t6024);
float t6026 = (t6025*2);
float t6027 = (t6026-1);
float t6028 = abs(t6027);
float t6029 = (t6028*t6028);
float t6030 = (t5933*t6029);
float t6031 = (t5932+t6030);
float t6032 = (t5913*float(8.0e-3));
float t6033 = (float(1.0e-3)+t6032);
float t6034 = step(float(0.66),t5927);
float t6035 = (t6034*float(3.0e-3));
float t6036 = (t6033-t6035);
float t6037 = (t6036*float(0.45));
float t6038 = (t6031*t6037);
float t6039 = (3.1415927/2);
float t6040 = (t5957-t6039);
float t6041 = (3.1415927/2);
float t6042 = (t8-t6041);
float t6043 = (t6040-t6042);
float t6044 = abs(t6043);
float t6045 = (t6044/2);
float t6046 = sin(t6045);
float t6047 = (t6046*t6046);
float t6048 = cos(t6042);
float t6049 = cos(t6040);
float t6050 = (t6048*t6049);
float t6051 = (t5974+3.1415927);
float t6052 = (3.1415927*2);
float t6053 = mod(t6051,t6052);
float t6054 = (t6053-3.1415927);
float t6055 = (t118+3.1415927);
float t6056 = (3.1415927*2);
float t6057 = mod(t6055,t6056);
float t6058 = (t6057-3.1415927);
float t6059 = (t6054-t6058);
float t6060 = abs(t6059);
float t6061 = (t6060/2);
float t6062 = sin(t6061);
float t6063 = (t6062*t6062);
float t6064 = (t6050*t6063);
float t6065 = (t6047+t6064);
float t6066 = sqrt(t6065);
float t6067 = asin(t6066);
float t6068 = (2*t6067);
float t6069 = step(t6038,t6068);
float t6070 = (1-t6069);
float t6071 = (t5925*t6070);
float t6072 = (3.1415927/2);
float t6073 = (t8-t6072);
float t6074 = (3.1415927/2);
float t6075 = (t5957-t6074);
float t6076 = (t6073-t6075);
float t6077 = abs(t6076);
float t6078 = (t6077/2);
float t6079 = sin(t6078);
float t6080 = (t6079*t6079);
float t6081 = cos(t6075);
float t6082 = cos(t6073);
float t6083 = (t6081*t6082);
float t6084 = (t118+3.1415927);
float t6085 = (3.1415927*2);
float t6086 = mod(t6084,t6085);
float t6087 = (t6086-3.1415927);
float t6088 = (t5974+3.1415927);
float t6089 = (3.1415927*2);
float t6090 = mod(t6088,t6089);
float t6091 = (t6090-3.1415927);
float t6092 = (t6087-t6091);
float t6093 = abs(t6092);
float t6094 = (t6093/2);
float t6095 = sin(t6094);
float t6096 = (t6095*t6095);
float t6097 = (t6083*t6096);
float t6098 = (t6080+t6097);
float t6099 = sqrt(t6098);
float t6100 = asin(t6099);
float t6101 = (2*t6100);
float t6102 = (1/t6101);
float t6103 = (t6102*t6037);
float t6104 = (t6103*float(1.25e-2));
float t6105 = (u4.u0*t5913);
float t6106 = cos(t6105);
float t6107 = (t6106+1);
float t6108 = (t6107/2);
float t6109 = (t6104*t6108);
float t6110 = (t6109*t5925);
float t6111 = (t6071+t6110);
float t6112 = (t5894+t6111);
float t6113 = (t5450+1);
float t6114 = (t6113/85);
float t6115 = (t6113/85);
float t6116 = (t6115*float(842.378));
float t6117 = fract(t6116);
float t6118 = (t6117+float(45.32));
float t6119 = (t6118+u6.u0);
float t6120 = (t6117*t6119);
float t6121 = (t6113/85);
float t6122 = (t6121*3.1415927);
float t6123 = sin(t6122);
float t6124 = (85*t6123);
float t6125 = floor(t6124);
float t6126 = (t6125+1);
float t6127 = (3.1415927/t6126);
float t6128 = (t118/t6127);
float t6129 = floor(t6128);
float t6130 = (t6129/t6126);
float t6131 = (t6130*float(1734.048));
float t6132 = fract(t6131);
float t6133 = (t6132+float(45.32));
float t6134 = (t6133+u6.u0);
float t6135 = (t6132*t6134);
float t6136 = (t6120+t6135);
float t6137 = (t6117+t6136);
float t6138 = (t6132+t6136);
float t6139 = (t6137*t6138);
float t6140 = fract(t6139);
float t6141 = (t6140*5);
float t6142 = (t6114+t6141);
float t6143 = fract(t6142);
float t6144 = (t6143*12000);
float t6145 = (t6144/1000);
bool t6146 = (1<=t6145);
float t6147;
if(t6146){
t6147 = 1;
} else {
t6147 = t6145;
}
float t6148 = (t6144-6000);
float t6149 = (t6148/8000);
bool t6150 = (0>=t6149);
float t6151;
if(t6150){
t6151 = 0;
} else {
t6151 = t6149;
}
float t6152 = (t6147-t6151);
float t6153 = (t6140*173);
float t6154 = fract(t6153);
float t6155 = step(float(0.66),t6154);
float t6156 = (t6155*3);
float t6157 = (3+t6156);
float t6158 = (3.1415927/t6157);
float t6159 = cos(t6158);
float t6160 = (1-t6159);
float t6161 = (t6113*t5448);
float t6162 = (t6113/85);
float t6163 = (t6162*float(842.378));
float t6164 = fract(t6163);
float t6165 = (t6164+float(45.32));
float t6166 = (t6165+u6.u0);
float t6167 = (t6164*t6166);
float t6168 = (t6129/t6126);
float t6169 = (t6168*float(1734.048));
float t6170 = fract(t6169);
float t6171 = (t6170+float(45.32));
float t6172 = (t6171+u6.u0);
float t6173 = (t6170*t6172);
float t6174 = (t6167+t6173);
float t6175 = (t6164+t6174);
float t6176 = (t6170+t6174);
float t6177 = (t6175*t6176);
float t6178 = fract(t6177);
float t6179 = (t6178*float(2852.02));
float t6180 = fract(t6179);
float t6181 = (t6180-float(0.5));
float t6182 = (t6181*t5448);
float t6183 = (t6182*float(0.75));
float t6184 = (t6161+t6183);
float t6185 = cos(t6184);
float t6186 = (1*t6185);
float t6187 = (t6186*0);
float t6188 = sin(t6184);
float t6189 = (1*t6188);
float t6190 = (3.1415927/t6126);
float t6191 = (t6129*t6190);
float t6192 = (t6178*float(97372.83));
float t6193 = fract(t6192);
float t6194 = (t6193-float(0.5));
float t6195 = (3.1415927/t6126);
float t6196 = (t6194*t6195);
float t6197 = (t6196*float(0.75));
float t6198 = (t6191+t6197);
float t6199 = (t6198+3.1415927);
float t6200 = mod(t6199,t1433);
float t6201 = (t6200-3.1415927);
float t6202 = cos(t6201);
float t6203 = (t6189*t6202);
float t6204 = (t6203*1);
float t6205 = (t6187-t6204);
float t6206 = sin(t8);
float t6207 = (1*t6206);
float t6208 = sin(t118);
float t6209 = (t6207*t6208);
float t6210 = (t6205*t6209);
float t6211 = (t6203*0);
float t6212 = sin(t6184);
float t6213 = (1*t6212);
float t6214 = sin(t6201);
float t6215 = (t6213*t6214);
float t6216 = (t6215*0);
float t6217 = (t6211-t6216);
float t6218 = cos(t8);
float t6219 = (1*t6218);
float t6220 = (t6217*t6219);
float t6221 = (t6210+t6220);
float t6222 = (t6215*1);
float t6223 = (t6186*0);
float t6224 = (t6222-t6223);
float t6225 = sin(t8);
float t6226 = (1*t6225);
float t6227 = cos(t118);
float t6228 = (t6226*t6227);
float t6229 = (t6224*t6228);
float t6230 = (t6221+t6229);
float t6231 = (t6217*t6203);
float t6232 = (t6224*t6186);
float t6233 = (t6231-t6232);
float t6234 = (t6233*t6209);
float t6235 = (t6224*t6215);
float t6236 = (t6205*t6203);
float t6237 = (t6235-t6236);
float t6238 = (t6237*t6219);
float t6239 = (t6234+t6238);
float t6240 = (t6205*t6186);
float t6241 = (t6217*t6215);
float t6242 = (t6240-t6241);
float t6243 = (t6242*t6228);
float t6244 = (t6239+t6243);
float t6245 = atan(t6230,t6244);
float t6246 = (t6245+3.1415927);
float t6247 = (t6154*3.1415927);
float t6248 = (t6246+t6247);
float t6249 = (t6248/t1483);
float t6250 = fract(t6249);
float t6251 = (t6250*t6157);
float t6252 = fract(t6251);
float t6253 = (t6252*2);
float t6254 = (t6253-1);
float t6255 = abs(t6254);
float t6256 = (t6255*t6255);
float t6257 = (t6160*t6256);
float t6258 = (t6159+t6257);
float t6259 = (t6140*float(8.0e-3));
float t6260 = (float(1.0e-3)+t6259);
float t6261 = step(float(0.66),t6154);
float t6262 = (t6261*float(3.0e-3));
float t6263 = (t6260-t6262);
float t6264 = (t6263*float(0.45));
float t6265 = (t6258*t6264);
float t6266 = (3.1415927/2);
float t6267 = (t6184-t6266);
float t6268 = (3.1415927/2);
float t6269 = (t8-t6268);
float t6270 = (t6267-t6269);
float t6271 = abs(t6270);
float t6272 = (t6271/2);
float t6273 = sin(t6272);
float t6274 = (t6273*t6273);
float t6275 = cos(t6269);
float t6276 = cos(t6267);
float t6277 = (t6275*t6276);
float t6278 = (t6201+3.1415927);
float t6279 = (3.1415927*2);
float t6280 = mod(t6278,t6279);
float t6281 = (t6280-3.1415927);
float t6282 = (t118+3.1415927);
float t6283 = (3.1415927*2);
float t6284 = mod(t6282,t6283);
float t6285 = (t6284-3.1415927);
float t6286 = (t6281-t6285);
float t6287 = abs(t6286);
float t6288 = (t6287/2);
float t6289 = sin(t6288);
float t6290 = (t6289*t6289);
float t6291 = (t6277*t6290);
float t6292 = (t6274+t6291);
float t6293 = sqrt(t6292);
float t6294 = asin(t6293);
float t6295 = (2*t6294);
float t6296 = step(t6265,t6295);
float t6297 = (1-t6296);
float t6298 = (t6152*t6297);
float t6299 = (3.1415927/2);
float t6300 = (t8-t6299);
float t6301 = (3.1415927/2);
float t6302 = (t6184-t6301);
float t6303 = (t6300-t6302);
float t6304 = abs(t6303);
float t6305 = (t6304/2);
float t6306 = sin(t6305);
float t6307 = (t6306*t6306);
float t6308 = cos(t6302);
float t6309 = cos(t6300);
float t6310 = (t6308*t6309);
float t6311 = (t118+3.1415927);
float t6312 = (3.1415927*2);
float t6313 = mod(t6311,t6312);
float t6314 = (t6313-3.1415927);
float t6315 = (t6201+3.1415927);
float t6316 = (3.1415927*2);
float t6317 = mod(t6315,t6316);
float t6318 = (t6317-3.1415927);
float t6319 = (t6314-t6318);
float t6320 = abs(t6319);
float t6321 = (t6320/2);
float t6322 = sin(t6321);
float t6323 = (t6322*t6322);
float t6324 = (t6310*t6323);
float t6325 = (t6307+t6324);
float t6326 = sqrt(t6325);
float t6327 = asin(t6326);
float t6328 = (2*t6327);
float t6329 = (1/t6328);
float t6330 = (t6329*t6264);
float t6331 = (t6330*float(1.25e-2));
float t6332 = (u4.u0*t6140);
float t6333 = cos(t6332);
float t6334 = (t6333+1);
float t6335 = (t6334/2);
float t6336 = (t6331*t6335);
float t6337 = (t6336*t6152);
float t6338 = (t6298+t6337);
float t6339 = (t6112+t6338);
float t6340 = (t5450*t5448);
float t6341 = (t5450/85);
float t6342 = (t6341*float(842.378));
float t6343 = fract(t6342);
float t6344 = (t6343+float(45.32));
float t6345 = (t6344+u6.u0);
float t6346 = (t6343*t6345);
float t6347 = (t5684/t5463);
float t6348 = (t6347*float(1734.048));
float t6349 = fract(t6348);
float t6350 = (t6349+float(45.32));
float t6351 = (t6350+u6.u0);
float t6352 = (t6349*t6351);
float t6353 = (t6346+t6352);
float t6354 = (t6343+t6353);
float t6355 = (t6349+t6353);
float t6356 = (t6354*t6355);
float t6357 = fract(t6356);
float t6358 = (t6357*float(2852.02));
float t6359 = fract(t6358);
float t6360 = (t6359-float(0.5));
float t6361 = (t6360*t5448);
float t6362 = (t6361*float(0.75));
float t6363 = (t6340+t6362);
float t6364 = (3.1415927/2);
float t6365 = (t6363-t6364);
float t6366 = (t5450*t5448);
float t6367 = (t5450/85);
float t6368 = (t6367*float(842.378));
float t6369 = fract(t6368);
float t6370 = (t6369+float(45.32));
float t6371 = (t6370+u6.u0);
float t6372 = (t6369*t6371);
float t6373 = (t5466/t5463);
float t6374 = (t6373*float(1734.048));
float t6375 = fract(t6374);
float t6376 = (t6375+float(45.32));
float t6377 = (t6376+u6.u0);
float t6378 = (t6375*t6377);
float t6379 = (t6372+t6378);
float t6380 = (t6369+t6379);
float t6381 = (t6375+t6379);
float t6382 = (t6380*t6381);
float t6383 = fract(t6382);
float t6384 = (t6383*float(2852.02));
float t6385 = fract(t6384);
float t6386 = (t6385-float(0.5));
float t6387 = (t6386*t5448);
float t6388 = (t6387*float(0.75));
float t6389 = (t6366+t6388);
float t6390 = (3.1415927/2);
float t6391 = (t6389-t6390);
float t6392 = (t6365-t6391);
float t6393 = abs(t6392);
float t6394 = (t6393/2);
float t6395 = sin(t6394);
float t6396 = (t6395*t6395);
float t6397 = cos(t6391);
float t6398 = cos(t6365);
float t6399 = (t6397*t6398);
float t6400 = (3.1415927/t5463);
float t6401 = (t5684*t6400);
float t6402 = (t6357*float(97372.83));
float t6403 = fract(t6402);
float t6404 = (t6403-float(0.5));
float t6405 = (3.1415927/t5463);
float t6406 = (t6404*t6405);
float t6407 = (t6406*float(0.75));
float t6408 = (t6401+t6407);
float t6409 = (t6408+3.1415927);
float t6410 = mod(t6409,t1433);
float t6411 = (t6410-3.1415927);
float t6412 = (t6411+3.1415927);
float t6413 = (3.1415927*2);
float t6414 = mod(t6412,t6413);
float t6415 = (t6414-3.1415927);
float t6416 = (3.1415927/t5463);
float t6417 = (t5466*t6416);
float t6418 = (t6383*float(97372.83));
float t6419 = fract(t6418);
float t6420 = (t6419-float(0.5));
float t6421 = (3.1415927/t5463);
float t6422 = (t6420*t6421);
float t6423 = (t6422*float(0.75));
float t6424 = (t6417+t6423);
float t6425 = (t6424+3.1415927);
float t6426 = mod(t6425,t1433);
float t6427 = (t6426-3.1415927);
float t6428 = (t6427+3.1415927);
float t6429 = (3.1415927*2);
float t6430 = mod(t6428,t6429);
float t6431 = (t6430-3.1415927);
float t6432 = (t6415-t6431);
float t6433 = abs(t6432);
float t6434 = (t6433/2);
float t6435 = sin(t6434);
float t6436 = (t6435*t6435);
float t6437 = (t6399*t6436);
float t6438 = (t6396+t6437);
float t6439 = sqrt(t6438);
float t6440 = asin(t6439);
float t6441 = (2*t6440);
float t6442 = (3.1415927/2);
float t6443 = (t8-t6442);
float t6444 = (3.1415927/2);
float t6445 = (t6389-t6444);
float t6446 = (t6443-t6445);
float t6447 = abs(t6446);
float t6448 = (t6447/2);
float t6449 = sin(t6448);
float t6450 = (t6449*t6449);
float t6451 = cos(t6445);
float t6452 = cos(t6443);
float t6453 = (t6451*t6452);
float t6454 = (t118+3.1415927);
float t6455 = (3.1415927*2);
float t6456 = mod(t6454,t6455);
float t6457 = (t6456-3.1415927);
float t6458 = (t6427+3.1415927);
float t6459 = (3.1415927*2);
float t6460 = mod(t6458,t6459);
float t6461 = (t6460-3.1415927);
float t6462 = (t6457-t6461);
float t6463 = abs(t6462);
float t6464 = (t6463/2);
float t6465 = sin(t6464);
float t6466 = (t6465*t6465);
float t6467 = (t6453*t6466);
float t6468 = (t6450+t6467);
float t6469 = sqrt(t6468);
float t6470 = asin(t6469);
float t6471 = (2*t6470);
float t6472 = (t6441-t6471);
float t6473 = (3.1415927/2);
float t6474 = (t8-t6473);
float t6475 = (3.1415927/2);
float t6476 = (t6363-t6475);
float t6477 = (t6474-t6476);
float t6478 = abs(t6477);
float t6479 = (t6478/2);
float t6480 = sin(t6479);
float t6481 = (t6480*t6480);
float t6482 = cos(t6476);
float t6483 = cos(t6474);
float t6484 = (t6482*t6483);
float t6485 = (t118+3.1415927);
float t6486 = (3.1415927*2);
float t6487 = mod(t6485,t6486);
float t6488 = (t6487-3.1415927);
float t6489 = (t6411+3.1415927);
float t6490 = (3.1415927*2);
float t6491 = mod(t6489,t6490);
float t6492 = (t6491-3.1415927);
float t6493 = (t6488-t6492);
float t6494 = abs(t6493);
float t6495 = (t6494/2);
float t6496 = sin(t6495);
float t6497 = (t6496*t6496);
float t6498 = (t6484*t6497);
float t6499 = (t6481+t6498);
float t6500 = sqrt(t6499);
float t6501 = asin(t6500);
float t6502 = (2*t6501);
float t6503 = (t6472-t6502);
float t6504 = abs(t6503);
bool t6505 = (float(1.0e-4)>t6504);
float t6506;
if(t6505){
float t6507 = cos(t6389);
float t6508 = (1*t6507);
float t6509 = sin(t6363);
float t6510 = (1*t6509);
float t6511 = cos(t6411);
float t6512 = (t6510*t6511);
float t6513 = (t6508*t6512);
float t6514 = sin(t6389);
float t6515 = (1*t6514);
float t6516 = cos(t6427);
float t6517 = (t6515*t6516);
float t6518 = cos(t6363);
float t6519 = (1*t6518);
float t6520 = (t6517*t6519);
float t6521 = (t6513-t6520);
float t6522 = sin(t8);
float t6523 = (1*t6522);
float t6524 = sin(t118);
float t6525 = (t6523*t6524);
float t6526 = (t6521*t6525);
float t6527 = sin(t6363);
float t6528 = (1*t6527);
float t6529 = sin(t6411);
float t6530 = (t6528*t6529);
float t6531 = (t6517*t6530);
float t6532 = sin(t6389);
float t6533 = (1*t6532);
float t6534 = sin(t6427);
float t6535 = (t6533*t6534);
float t6536 = (t6535*t6512);
float t6537 = (t6531-t6536);
float t6538 = cos(t8);
float t6539 = (1*t6538);
float t6540 = (t6537*t6539);
float t6541 = (t6526+t6540);
float t6542 = (t6535*t6519);
float t6543 = (t6508*t6530);
float t6544 = (t6542-t6543);
float t6545 = sin(t8);
float t6546 = (1*t6545);
float t6547 = cos(t118);
float t6548 = (t6546*t6547);
float t6549 = (t6544*t6548);
float t6550 = (t6541+t6549);
float t6551 = abs(t6550);
t6506 = t6551;
} else {
float t6552 = (3.1415927/2);
float t6553 = (t8-t6552);
float t6554 = (3.1415927/2);
float t6555 = (t6363-t6554);
float t6556 = (t6553-t6555);
float t6557 = abs(t6556);
float t6558 = (t6557/2);
float t6559 = sin(t6558);
float t6560 = (t6559*t6559);
float t6561 = cos(t6555);
float t6562 = cos(t6553);
float t6563 = (t6561*t6562);
float t6564 = (t118+3.1415927);
float t6565 = (3.1415927*2);
float t6566 = mod(t6564,t6565);
float t6567 = (t6566-3.1415927);
float t6568 = (t6411+3.1415927);
float t6569 = (3.1415927*2);
float t6570 = mod(t6568,t6569);
float t6571 = (t6570-3.1415927);
float t6572 = (t6567-t6571);
float t6573 = abs(t6572);
float t6574 = (t6573/2);
float t6575 = sin(t6574);
float t6576 = (t6575*t6575);
float t6577 = (t6563*t6576);
float t6578 = (t6560+t6577);
float t6579 = sqrt(t6578);
float t6580 = asin(t6579);
float t6581 = (2*t6580);
float t6582 = abs(t6581);
float t6583 = (3.1415927/2);
float t6584 = (t8-t6583);
float t6585 = (3.1415927/2);
float t6586 = (t6389-t6585);
float t6587 = (t6584-t6586);
float t6588 = abs(t6587);
float t6589 = (t6588/2);
float t6590 = sin(t6589);
float t6591 = (t6590*t6590);
float t6592 = cos(t6586);
float t6593 = cos(t6584);
float t6594 = (t6592*t6593);
float t6595 = (t118+3.1415927);
float t6596 = (3.1415927*2);
float t6597 = mod(t6595,t6596);
float t6598 = (t6597-3.1415927);
float t6599 = (t6427+3.1415927);
float t6600 = (3.1415927*2);
float t6601 = mod(t6599,t6600);
float t6602 = (t6601-3.1415927);
float t6603 = (t6598-t6602);
float t6604 = abs(t6603);
float t6605 = (t6604/2);
float t6606 = sin(t6605);
float t6607 = (t6606*t6606);
float t6608 = (t6594*t6607);
float t6609 = (t6591+t6608);
float t6610 = sqrt(t6609);
float t6611 = asin(t6610);
float t6612 = (2*t6611);
float t6613 = abs(t6612);
bool t6614 = (t6582>=t6613);
float t6615;
if(t6614){
t6615 = t6582;
} else {
t6615 = t6613;
}
t6506 = t6615;
}
float t6616 = abs(t6506);
float t6617 = step(float(2.0e-4),t6616);
float t6618 = (1-t6617);
float t6619 = (t5450*t5684);
float t6620 = (t6619*float(842.378));
float t6621 = fract(t6620);
float t6622 = (t6621+float(45.32));
float t6623 = (t6622+u6.u0);
float t6624 = (t6621*t6623);
float t6625 = (t5466*t5450);
float t6626 = (t6625*float(1734.048));
float t6627 = fract(t6626);
float t6628 = (t6627+float(45.32));
float t6629 = (t6628+u6.u0);
float t6630 = (t6627*t6629);
float t6631 = (t6624+t6630);
float t6632 = (t6621+t6631);
float t6633 = (t6627+t6631);
float t6634 = (t6632*t6633);
float t6635 = fract(t6634);
float t6636 = step(float(0.2),t6635);
float t6637 = (t6618*t6636);
float t6638 = (3.1415927/2);
float t6639 = (t6363-t6638);
float t6640 = (3.1415927/2);
float t6641 = (t6389-t6640);
float t6642 = (t6639-t6641);
float t6643 = abs(t6642);
float t6644 = (t6643/2);
float t6645 = sin(t6644);
float t6646 = (t6645*t6645);
float t6647 = cos(t6641);
float t6648 = cos(t6639);
float t6649 = (t6647*t6648);
float t6650 = (t6411+3.1415927);
float t6651 = (3.1415927*2);
float t6652 = mod(t6650,t6651);
float t6653 = (t6652-3.1415927);
float t6654 = (t6427+3.1415927);
float t6655 = (3.1415927*2);
float t6656 = mod(t6654,t6655);
float t6657 = (t6656-3.1415927);
float t6658 = (t6653-t6657);
float t6659 = abs(t6658);
float t6660 = (t6659/2);
float t6661 = sin(t6660);
float t6662 = (t6661*t6661);
float t6663 = (t6649*t6662);
float t6664 = (t6646+t6663);
float t6665 = sqrt(t6664);
float t6666 = asin(t6665);
float t6667 = (2*t6666);
float t6668 = (t6667/t5448);
float t6669 = (1-t6668);
float t6670 = (t5450/85);
float t6671 = (t6670*float(842.378));
float t6672 = fract(t6671);
float t6673 = (t6672+float(45.32));
float t6674 = (t6673+u6.u0);
float t6675 = (t6672*t6674);
float t6676 = (t5466/t5463);
float t6677 = (t6676*float(1734.048));
float t6678 = fract(t6677);
float t6679 = (t6678+float(45.32));
float t6680 = (t6679+u6.u0);
float t6681 = (t6678*t6680);
float t6682 = (t6675+t6681);
float t6683 = (t6672+t6682);
float t6684 = (t6678+t6682);
float t6685 = (t6683*t6684);
float t6686 = fract(t6685);
float t6687 = (t6686*float(8.0e-3));
float t6688 = (float(1.0e-3)+t6687);
float t6689 = (t6686*173);
float t6690 = fract(t6689);
float t6691 = step(float(0.66),t6690);
float t6692 = (t6691*float(3.0e-3));
float t6693 = (t6688-t6692);
float t6694 = (t6693*float(0.45));
float t6695 = (t5450/85);
float t6696 = (t6695*float(842.378));
float t6697 = fract(t6696);
float t6698 = (t6697+float(45.32));
float t6699 = (t6698+u6.u0);
float t6700 = (t6697*t6699);
float t6701 = (t5684/t5463);
float t6702 = (t6701*float(1734.048));
float t6703 = fract(t6702);
float t6704 = (t6703+float(45.32));
float t6705 = (t6704+u6.u0);
float t6706 = (t6703*t6705);
float t6707 = (t6700+t6706);
float t6708 = (t6697+t6707);
float t6709 = (t6703+t6707);
float t6710 = (t6708*t6709);
float t6711 = fract(t6710);
float t6712 = (t6711*float(8.0e-3));
float t6713 = (float(1.0e-3)+t6712);
float t6714 = (t6711*173);
float t6715 = fract(t6714);
float t6716 = step(float(0.66),t6715);
float t6717 = (t6716*float(3.0e-3));
float t6718 = (t6713-t6717);
float t6719 = (t6718*float(0.45));
float t6720 = (t6694-t6719);
float t6721 = abs(t6720);
float t6722 = (t6721-float(1.0e-3));
float t6723 = (t6722/float(8.0e-3));
float t6724 = (1-t6723);
float t6725 = (t6724*t6724);
float t6726 = (t6669*t6725);
float t6727 = (t6637*t6726);
float t6728 = (u4.u0*t6635);
float t6729 = (t6728*3);
float t6730 = sin(t6729);
float t6731 = (t6730+1);
float t6732 = (t6731/2);
float t6733 = (t6732*float(0.66));
float t6734 = (t6733+float(0.33));
float t6735 = (t6727*t6734);
float t6736 = (float(0.2)*t6735);
bool t6737 = (0>=t6736);
float t6738;
if(t6737){
t6738 = 0;
} else {
t6738 = t6736;
}
float t6739 = (t6738*0);
float t6740 = (t6339+t6739);
float t6741 = (t6113*t5448);
float t6742 = (t6113/85);
float t6743 = (t6742*float(842.378));
float t6744 = fract(t6743);
float t6745 = (t6744+float(45.32));
float t6746 = (t6745+u6.u0);
float t6747 = (t6744*t6746);
float t6748 = (t6129/t6126);
float t6749 = (t6748*float(1734.048));
float t6750 = fract(t6749);
float t6751 = (t6750+float(45.32));
float t6752 = (t6751+u6.u0);
float t6753 = (t6750*t6752);
float t6754 = (t6747+t6753);
float t6755 = (t6744+t6754);
float t6756 = (t6750+t6754);
float t6757 = (t6755*t6756);
float t6758 = fract(t6757);
float t6759 = (t6758*float(2852.02));
float t6760 = fract(t6759);
float t6761 = (t6760-float(0.5));
float t6762 = (t6761*t5448);
float t6763 = (t6762*float(0.75));
float t6764 = (t6741+t6763);
float t6765 = (3.1415927/2);
float t6766 = (t6764-t6765);
float t6767 = (t5450*t5448);
float t6768 = (t5450/85);
float t6769 = (t6768*float(842.378));
float t6770 = fract(t6769);
float t6771 = (t6770+float(45.32));
float t6772 = (t6771+u6.u0);
float t6773 = (t6770*t6772);
float t6774 = (t5466/t5463);
float t6775 = (t6774*float(1734.048));
float t6776 = fract(t6775);
float t6777 = (t6776+float(45.32));
float t6778 = (t6777+u6.u0);
float t6779 = (t6776*t6778);
float t6780 = (t6773+t6779);
float t6781 = (t6770+t6780);
float t6782 = (t6776+t6780);
float t6783 = (t6781*t6782);
float t6784 = fract(t6783);
float t6785 = (t6784*float(2852.02));
float t6786 = fract(t6785);
float t6787 = (t6786-float(0.5));
float t6788 = (t6787*t5448);
float t6789 = (t6788*float(0.75));
float t6790 = (t6767+t6789);
float t6791 = (3.1415927/2);
float t6792 = (t6790-t6791);
float t6793 = (t6766-t6792);
float t6794 = abs(t6793);
float t6795 = (t6794/2);
float t6796 = sin(t6795);
float t6797 = (t6796*t6796);
float t6798 = cos(t6792);
float t6799 = cos(t6766);
float t6800 = (t6798*t6799);
float t6801 = (3.1415927/t6126);
float t6802 = (t6129*t6801);
float t6803 = (t6758*float(97372.83));
float t6804 = fract(t6803);
float t6805 = (t6804-float(0.5));
float t6806 = (3.1415927/t6126);
float t6807 = (t6805*t6806);
float t6808 = (t6807*float(0.75));
float t6809 = (t6802+t6808);
float t6810 = (t6809+3.1415927);
float t6811 = mod(t6810,t1433);
float t6812 = (t6811-3.1415927);
float t6813 = (t6812+3.1415927);
float t6814 = (3.1415927*2);
float t6815 = mod(t6813,t6814);
float t6816 = (t6815-3.1415927);
float t6817 = (3.1415927/t5463);
float t6818 = (t5466*t6817);
float t6819 = (t6784*float(97372.83));
float t6820 = fract(t6819);
float t6821 = (t6820-float(0.5));
float t6822 = (3.1415927/t5463);
float t6823 = (t6821*t6822);
float t6824 = (t6823*float(0.75));
float t6825 = (t6818+t6824);
float t6826 = (t6825+3.1415927);
float t6827 = mod(t6826,t1433);
float t6828 = (t6827-3.1415927);
float t6829 = (t6828+3.1415927);
float t6830 = (3.1415927*2);
float t6831 = mod(t6829,t6830);
float t6832 = (t6831-3.1415927);
float t6833 = (t6816-t6832);
float t6834 = abs(t6833);
float t6835 = (t6834/2);
float t6836 = sin(t6835);
float t6837 = (t6836*t6836);
float t6838 = (t6800*t6837);
float t6839 = (t6797+t6838);
float t6840 = sqrt(t6839);
float t6841 = asin(t6840);
float t6842 = (2*t6841);
float t6843 = (3.1415927/2);
float t6844 = (t8-t6843);
float t6845 = (3.1415927/2);
float t6846 = (t6790-t6845);
float t6847 = (t6844-t6846);
float t6848 = abs(t6847);
float t6849 = (t6848/2);
float t6850 = sin(t6849);
float t6851 = (t6850*t6850);
float t6852 = cos(t6846);
float t6853 = cos(t6844);
float t6854 = (t6852*t6853);
float t6855 = (t118+3.1415927);
float t6856 = (3.1415927*2);
float t6857 = mod(t6855,t6856);
float t6858 = (t6857-3.1415927);
float t6859 = (t6828+3.1415927);
float t6860 = (3.1415927*2);
float t6861 = mod(t6859,t6860);
float t6862 = (t6861-3.1415927);
float t6863 = (t6858-t6862);
float t6864 = abs(t6863);
float t6865 = (t6864/2);
float t6866 = sin(t6865);
float t6867 = (t6866*t6866);
float t6868 = (t6854*t6867);
float t6869 = (t6851+t6868);
float t6870 = sqrt(t6869);
float t6871 = asin(t6870);
float t6872 = (2*t6871);
float t6873 = (t6842-t6872);
float t6874 = (3.1415927/2);
float t6875 = (t8-t6874);
float t6876 = (3.1415927/2);
float t6877 = (t6764-t6876);
float t6878 = (t6875-t6877);
float t6879 = abs(t6878);
float t6880 = (t6879/2);
float t6881 = sin(t6880);
float t6882 = (t6881*t6881);
float t6883 = cos(t6877);
float t6884 = cos(t6875);
float t6885 = (t6883*t6884);
float t6886 = (t118+3.1415927);
float t6887 = (3.1415927*2);
float t6888 = mod(t6886,t6887);
float t6889 = (t6888-3.1415927);
float t6890 = (t6812+3.1415927);
float t6891 = (3.1415927*2);
float t6892 = mod(t6890,t6891);
float t6893 = (t6892-3.1415927);
float t6894 = (t6889-t6893);
float t6895 = abs(t6894);
float t6896 = (t6895/2);
float t6897 = sin(t6896);
float t6898 = (t6897*t6897);
float t6899 = (t6885*t6898);
float t6900 = (t6882+t6899);
float t6901 = sqrt(t6900);
float t6902 = asin(t6901);
float t6903 = (2*t6902);
float t6904 = (t6873-t6903);
float t6905 = abs(t6904);
bool t6906 = (float(1.0e-4)>t6905);
float t6907;
if(t6906){
float t6908 = cos(t6790);
float t6909 = (1*t6908);
float t6910 = sin(t6764);
float t6911 = (1*t6910);
float t6912 = cos(t6812);
float t6913 = (t6911*t6912);
float t6914 = (t6909*t6913);
float t6915 = sin(t6790);
float t6916 = (1*t6915);
float t6917 = cos(t6828);
float t6918 = (t6916*t6917);
float t6919 = cos(t6764);
float t6920 = (1*t6919);
float t6921 = (t6918*t6920);
float t6922 = (t6914-t6921);
float t6923 = sin(t8);
float t6924 = (1*t6923);
float t6925 = sin(t118);
float t6926 = (t6924*t6925);
float t6927 = (t6922*t6926);
float t6928 = sin(t6764);
float t6929 = (1*t6928);
float t6930 = sin(t6812);
float t6931 = (t6929*t6930);
float t6932 = (t6918*t6931);
float t6933 = sin(t6790);
float t6934 = (1*t6933);
float t6935 = sin(t6828);
float t6936 = (t6934*t6935);
float t6937 = (t6936*t6913);
float t6938 = (t6932-t6937);
float t6939 = cos(t8);
float t6940 = (1*t6939);
float t6941 = (t6938*t6940);
float t6942 = (t6927+t6941);
float t6943 = (t6936*t6920);
float t6944 = (t6909*t6931);
float t6945 = (t6943-t6944);
float t6946 = sin(t8);
float t6947 = (1*t6946);
float t6948 = cos(t118);
float t6949 = (t6947*t6948);
float t6950 = (t6945*t6949);
float t6951 = (t6942+t6950);
float t6952 = abs(t6951);
t6907 = t6952;
} else {
float t6953 = (3.1415927/2);
float t6954 = (t8-t6953);
float t6955 = (3.1415927/2);
float t6956 = (t6764-t6955);
float t6957 = (t6954-t6956);
float t6958 = abs(t6957);
float t6959 = (t6958/2);
float t6960 = sin(t6959);
float t6961 = (t6960*t6960);
float t6962 = cos(t6956);
float t6963 = cos(t6954);
float t6964 = (t6962*t6963);
float t6965 = (t118+3.1415927);
float t6966 = (3.1415927*2);
float t6967 = mod(t6965,t6966);
float t6968 = (t6967-3.1415927);
float t6969 = (t6812+3.1415927);
float t6970 = (3.1415927*2);
float t6971 = mod(t6969,t6970);
float t6972 = (t6971-3.1415927);
float t6973 = (t6968-t6972);
float t6974 = abs(t6973);
float t6975 = (t6974/2);
float t6976 = sin(t6975);
float t6977 = (t6976*t6976);
float t6978 = (t6964*t6977);
float t6979 = (t6961+t6978);
float t6980 = sqrt(t6979);
float t6981 = asin(t6980);
float t6982 = (2*t6981);
float t6983 = abs(t6982);
float t6984 = (3.1415927/2);
float t6985 = (t8-t6984);
float t6986 = (3.1415927/2);
float t6987 = (t6790-t6986);
float t6988 = (t6985-t6987);
float t6989 = abs(t6988);
float t6990 = (t6989/2);
float t6991 = sin(t6990);
float t6992 = (t6991*t6991);
float t6993 = cos(t6987);
float t6994 = cos(t6985);
float t6995 = (t6993*t6994);
float t6996 = (t118+3.1415927);
float t6997 = (3.1415927*2);
float t6998 = mod(t6996,t6997);
float t6999 = (t6998-3.1415927);
float t7000 = (t6828+3.1415927);
float t7001 = (3.1415927*2);
float t7002 = mod(t7000,t7001);
float t7003 = (t7002-3.1415927);
float t7004 = (t6999-t7003);
float t7005 = abs(t7004);
float t7006 = (t7005/2);
float t7007 = sin(t7006);
float t7008 = (t7007*t7007);
float t7009 = (t6995*t7008);
float t7010 = (t6992+t7009);
float t7011 = sqrt(t7010);
float t7012 = asin(t7011);
float t7013 = (2*t7012);
float t7014 = abs(t7013);
bool t7015 = (t6983>=t7014);
float t7016;
if(t7015){
t7016 = t6983;
} else {
t7016 = t7014;
}
t6907 = t7016;
}
float t7017 = abs(t6907);
float t7018 = step(float(2.0e-4),t7017);
float t7019 = (1-t7018);
float t7020 = (t5450*t6129);
float t7021 = (t7020*float(842.378));
float t7022 = fract(t7021);
float t7023 = (t7022+float(45.32));
float t7024 = (t7023+u6.u0);
float t7025 = (t7022*t7024);
float t7026 = (t5466*t6113);
float t7027 = (t7026*float(1734.048));
float t7028 = fract(t7027);
float t7029 = (t7028+float(45.32));
float t7030 = (t7029+u6.u0);
float t7031 = (t7028*t7030);
float t7032 = (t7025+t7031);
float t7033 = (t7022+t7032);
float t7034 = (t7028+t7032);
float t7035 = (t7033*t7034);
float t7036 = fract(t7035);
float t7037 = step(float(0.2),t7036);
float t7038 = (t7019*t7037);
float t7039 = (3.1415927/2);
float t7040 = (t6764-t7039);
float t7041 = (3.1415927/2);
float t7042 = (t6790-t7041);
float t7043 = (t7040-t7042);
float t7044 = abs(t7043);
float t7045 = (t7044/2);
float t7046 = sin(t7045);
float t7047 = (t7046*t7046);
float t7048 = cos(t7042);
float t7049 = cos(t7040);
float t7050 = (t7048*t7049);
float t7051 = (t6812+3.1415927);
float t7052 = (3.1415927*2);
float t7053 = mod(t7051,t7052);
float t7054 = (t7053-3.1415927);
float t7055 = (t6828+3.1415927);
float t7056 = (3.1415927*2);
float t7057 = mod(t7055,t7056);
float t7058 = (t7057-3.1415927);
float t7059 = (t7054-t7058);
float t7060 = abs(t7059);
float t7061 = (t7060/2);
float t7062 = sin(t7061);
float t7063 = (t7062*t7062);
float t7064 = (t7050*t7063);
float t7065 = (t7047+t7064);
float t7066 = sqrt(t7065);
float t7067 = asin(t7066);
float t7068 = (2*t7067);
float t7069 = (t7068/t5448);
float t7070 = (1-t7069);
float t7071 = (t5450/85);
float t7072 = (t7071*float(842.378));
float t7073 = fract(t7072);
float t7074 = (t7073+float(45.32));
float t7075 = (t7074+u6.u0);
float t7076 = (t7073*t7075);
float t7077 = (t5466/t5463);
float t7078 = (t7077*float(1734.048));
float t7079 = fract(t7078);
float t7080 = (t7079+float(45.32));
float t7081 = (t7080+u6.u0);
float t7082 = (t7079*t7081);
float t7083 = (t7076+t7082);
float t7084 = (t7073+t7083);
float t7085 = (t7079+t7083);
float t7086 = (t7084*t7085);
float t7087 = fract(t7086);
float t7088 = (t7087*float(8.0e-3));
float t7089 = (float(1.0e-3)+t7088);
float t7090 = (t7087*173);
float t7091 = fract(t7090);
float t7092 = step(float(0.66),t7091);
float t7093 = (t7092*float(3.0e-3));
float t7094 = (t7089-t7093);
float t7095 = (t7094*float(0.45));
float t7096 = (t6113/85);
float t7097 = (t7096*float(842.378));
float t7098 = fract(t7097);
float t7099 = (t7098+float(45.32));
float t7100 = (t7099+u6.u0);
float t7101 = (t7098*t7100);
float t7102 = (t6129/t6126);
float t7103 = (t7102*float(1734.048));
float t7104 = fract(t7103);
float t7105 = (t7104+float(45.32));
float t7106 = (t7105+u6.u0);
float t7107 = (t7104*t7106);
float t7108 = (t7101+t7107);
float t7109 = (t7098+t7108);
float t7110 = (t7104+t7108);
float t7111 = (t7109*t7110);
float t7112 = fract(t7111);
float t7113 = (t7112*float(8.0e-3));
float t7114 = (float(1.0e-3)+t7113);
float t7115 = (t7112*173);
float t7116 = fract(t7115);
float t7117 = step(float(0.66),t7116);
float t7118 = (t7117*float(3.0e-3));
float t7119 = (t7114-t7118);
float t7120 = (t7119*float(0.45));
float t7121 = (t7095-t7120);
float t7122 = abs(t7121);
float t7123 = (t7122-float(1.0e-3));
float t7124 = (t7123/float(8.0e-3));
float t7125 = (1-t7124);
float t7126 = (t7125*t7125);
float t7127 = (t7070*t7126);
float t7128 = (t7038*t7127);
float t7129 = (u4.u0*t7036);
float t7130 = (t7129*3);
float t7131 = sin(t7130);
float t7132 = (t7131+1);
float t7133 = (t7132/2);
float t7134 = (t7133*float(0.66));
float t7135 = (t7134+float(0.33));
float t7136 = (t7128*t7135);
float t7137 = (float(0.2)*t7136);
bool t7138 = (0>=t7137);
float t7139;
if(t7138){
t7139 = 0;
} else {
t7139 = t7137;
}
float t7140 = (t7139*0);
float t7141 = (t6740+t7140);
float t7142 = (t6113*t5448);
float t7143 = (t6113/85);
float t7144 = (t7143*float(842.378));
float t7145 = fract(t7144);
float t7146 = (t7145+float(45.32));
float t7147 = (t7146+u6.u0);
float t7148 = (t7145*t7147);
float t7149 = (t6129+1);
float t7150 = (t7149/t6126);
float t7151 = (t7150*float(1734.048));
float t7152 = fract(t7151);
float t7153 = (t7152+float(45.32));
float t7154 = (t7153+u6.u0);
float t7155 = (t7152*t7154);
float t7156 = (t7148+t7155);
float t7157 = (t7145+t7156);
float t7158 = (t7152+t7156);
float t7159 = (t7157*t7158);
float t7160 = fract(t7159);
float t7161 = (t7160*float(2852.02));
float t7162 = fract(t7161);
float t7163 = (t7162-float(0.5));
float t7164 = (t7163*t5448);
float t7165 = (t7164*float(0.75));
float t7166 = (t7142+t7165);
float t7167 = (3.1415927/2);
float t7168 = (t7166-t7167);
float t7169 = (t6113*t5448);
float t7170 = (t6113/85);
float t7171 = (t7170*float(842.378));
float t7172 = fract(t7171);
float t7173 = (t7172+float(45.32));
float t7174 = (t7173+u6.u0);
float t7175 = (t7172*t7174);
float t7176 = (t6129/t6126);
float t7177 = (t7176*float(1734.048));
float t7178 = fract(t7177);
float t7179 = (t7178+float(45.32));
float t7180 = (t7179+u6.u0);
float t7181 = (t7178*t7180);
float t7182 = (t7175+t7181);
float t7183 = (t7172+t7182);
float t7184 = (t7178+t7182);
float t7185 = (t7183*t7184);
float t7186 = fract(t7185);
float t7187 = (t7186*float(2852.02));
float t7188 = fract(t7187);
float t7189 = (t7188-float(0.5));
float t7190 = (t7189*t5448);
float t7191 = (t7190*float(0.75));
float t7192 = (t7169+t7191);
float t7193 = (3.1415927/2);
float t7194 = (t7192-t7193);
float t7195 = (t7168-t7194);
float t7196 = abs(t7195);
float t7197 = (t7196/2);
float t7198 = sin(t7197);
float t7199 = (t7198*t7198);
float t7200 = cos(t7194);
float t7201 = cos(t7168);
float t7202 = (t7200*t7201);
float t7203 = (3.1415927/t6126);
float t7204 = (t7149*t7203);
float t7205 = (t7160*float(97372.83));
float t7206 = fract(t7205);
float t7207 = (t7206-float(0.5));
float t7208 = (3.1415927/t6126);
float t7209 = (t7207*t7208);
float t7210 = (t7209*float(0.75));
float t7211 = (t7204+t7210);
float t7212 = (t7211+3.1415927);
float t7213 = mod(t7212,t1433);
float t7214 = (t7213-3.1415927);
float t7215 = (t7214+3.1415927);
float t7216 = (3.1415927*2);
float t7217 = mod(t7215,t7216);
float t7218 = (t7217-3.1415927);
float t7219 = (3.1415927/t6126);
float t7220 = (t6129*t7219);
float t7221 = (t7186*float(97372.83));
float t7222 = fract(t7221);
float t7223 = (t7222-float(0.5));
float t7224 = (3.1415927/t6126);
float t7225 = (t7223*t7224);
float t7226 = (t7225*float(0.75));
float t7227 = (t7220+t7226);
float t7228 = (t7227+3.1415927);
float t7229 = mod(t7228,t1433);
float t7230 = (t7229-3.1415927);
float t7231 = (t7230+3.1415927);
float t7232 = (3.1415927*2);
float t7233 = mod(t7231,t7232);
float t7234 = (t7233-3.1415927);
float t7235 = (t7218-t7234);
float t7236 = abs(t7235);
float t7237 = (t7236/2);
float t7238 = sin(t7237);
float t7239 = (t7238*t7238);
float t7240 = (t7202*t7239);
float t7241 = (t7199+t7240);
float t7242 = sqrt(t7241);
float t7243 = asin(t7242);
float t7244 = (2*t7243);
float t7245 = (3.1415927/2);
float t7246 = (t8-t7245);
float t7247 = (3.1415927/2);
float t7248 = (t7192-t7247);
float t7249 = (t7246-t7248);
float t7250 = abs(t7249);
float t7251 = (t7250/2);
float t7252 = sin(t7251);
float t7253 = (t7252*t7252);
float t7254 = cos(t7248);
float t7255 = cos(t7246);
float t7256 = (t7254*t7255);
float t7257 = (t118+3.1415927);
float t7258 = (3.1415927*2);
float t7259 = mod(t7257,t7258);
float t7260 = (t7259-3.1415927);
float t7261 = (t7230+3.1415927);
float t7262 = (3.1415927*2);
float t7263 = mod(t7261,t7262);
float t7264 = (t7263-3.1415927);
float t7265 = (t7260-t7264);
float t7266 = abs(t7265);
float t7267 = (t7266/2);
float t7268 = sin(t7267);
float t7269 = (t7268*t7268);
float t7270 = (t7256*t7269);
float t7271 = (t7253+t7270);
float t7272 = sqrt(t7271);
float t7273 = asin(t7272);
float t7274 = (2*t7273);
float t7275 = (t7244-t7274);
float t7276 = (3.1415927/2);
float t7277 = (t8-t7276);
float t7278 = (3.1415927/2);
float t7279 = (t7166-t7278);
float t7280 = (t7277-t7279);
float t7281 = abs(t7280);
float t7282 = (t7281/2);
float t7283 = sin(t7282);
float t7284 = (t7283*t7283);
float t7285 = cos(t7279);
float t7286 = cos(t7277);
float t7287 = (t7285*t7286);
float t7288 = (t118+3.1415927);
float t7289 = (3.1415927*2);
float t7290 = mod(t7288,t7289);
float t7291 = (t7290-3.1415927);
float t7292 = (t7214+3.1415927);
float t7293 = (3.1415927*2);
float t7294 = mod(t7292,t7293);
float t7295 = (t7294-3.1415927);
float t7296 = (t7291-t7295);
float t7297 = abs(t7296);
float t7298 = (t7297/2);
float t7299 = sin(t7298);
float t7300 = (t7299*t7299);
float t7301 = (t7287*t7300);
float t7302 = (t7284+t7301);
float t7303 = sqrt(t7302);
float t7304 = asin(t7303);
float t7305 = (2*t7304);
float t7306 = (t7275-t7305);
float t7307 = abs(t7306);
bool t7308 = (float(1.0e-4)>t7307);
float t7309;
if(t7308){
float t7310 = cos(t7192);
float t7311 = (1*t7310);
float t7312 = sin(t7166);
float t7313 = (1*t7312);
float t7314 = cos(t7214);
float t7315 = (t7313*t7314);
float t7316 = (t7311*t7315);
float t7317 = sin(t7192);
float t7318 = (1*t7317);
float t7319 = cos(t7230);
float t7320 = (t7318*t7319);
float t7321 = cos(t7166);
float t7322 = (1*t7321);
float t7323 = (t7320*t7322);
float t7324 = (t7316-t7323);
float t7325 = sin(t8);
float t7326 = (1*t7325);
float t7327 = sin(t118);
float t7328 = (t7326*t7327);
float t7329 = (t7324*t7328);
float t7330 = sin(t7166);
float t7331 = (1*t7330);
float t7332 = sin(t7214);
float t7333 = (t7331*t7332);
float t7334 = (t7320*t7333);
float t7335 = sin(t7192);
float t7336 = (1*t7335);
float t7337 = sin(t7230);
float t7338 = (t7336*t7337);
float t7339 = (t7338*t7315);
float t7340 = (t7334-t7339);
float t7341 = cos(t8);
float t7342 = (1*t7341);
float t7343 = (t7340*t7342);
float t7344 = (t7329+t7343);
float t7345 = (t7338*t7322);
float t7346 = (t7311*t7333);
float t7347 = (t7345-t7346);
float t7348 = sin(t8);
float t7349 = (1*t7348);
float t7350 = cos(t118);
float t7351 = (t7349*t7350);
float t7352 = (t7347*t7351);
float t7353 = (t7344+t7352);
float t7354 = abs(t7353);
t7309 = t7354;
} else {
float t7355 = (3.1415927/2);
float t7356 = (t8-t7355);
float t7357 = (3.1415927/2);
float t7358 = (t7166-t7357);
float t7359 = (t7356-t7358);
float t7360 = abs(t7359);
float t7361 = (t7360/2);
float t7362 = sin(t7361);
float t7363 = (t7362*t7362);
float t7364 = cos(t7358);
float t7365 = cos(t7356);
float t7366 = (t7364*t7365);
float t7367 = (t118+3.1415927);
float t7368 = (3.1415927*2);
float t7369 = mod(t7367,t7368);
float t7370 = (t7369-3.1415927);
float t7371 = (t7214+3.1415927);
float t7372 = (3.1415927*2);
float t7373 = mod(t7371,t7372);
float t7374 = (t7373-3.1415927);
float t7375 = (t7370-t7374);
float t7376 = abs(t7375);
float t7377 = (t7376/2);
float t7378 = sin(t7377);
float t7379 = (t7378*t7378);
float t7380 = (t7366*t7379);
float t7381 = (t7363+t7380);
float t7382 = sqrt(t7381);
float t7383 = asin(t7382);
float t7384 = (2*t7383);
float t7385 = abs(t7384);
float t7386 = (3.1415927/2);
float t7387 = (t8-t7386);
float t7388 = (3.1415927/2);
float t7389 = (t7192-t7388);
float t7390 = (t7387-t7389);
float t7391 = abs(t7390);
float t7392 = (t7391/2);
float t7393 = sin(t7392);
float t7394 = (t7393*t7393);
float t7395 = cos(t7389);
float t7396 = cos(t7387);
float t7397 = (t7395*t7396);
float t7398 = (t118+3.1415927);
float t7399 = (3.1415927*2);
float t7400 = mod(t7398,t7399);
float t7401 = (t7400-3.1415927);
float t7402 = (t7230+3.1415927);
float t7403 = (3.1415927*2);
float t7404 = mod(t7402,t7403);
float t7405 = (t7404-3.1415927);
float t7406 = (t7401-t7405);
float t7407 = abs(t7406);
float t7408 = (t7407/2);
float t7409 = sin(t7408);
float t7410 = (t7409*t7409);
float t7411 = (t7397*t7410);
float t7412 = (t7394+t7411);
float t7413 = sqrt(t7412);
float t7414 = asin(t7413);
float t7415 = (2*t7414);
float t7416 = abs(t7415);
bool t7417 = (t7385>=t7416);
float t7418;
if(t7417){
t7418 = t7385;
} else {
t7418 = t7416;
}
t7309 = t7418;
}
float t7419 = abs(t7309);
float t7420 = step(float(2.0e-4),t7419);
float t7421 = (1-t7420);
float t7422 = (t6113*t7149);
float t7423 = (t7422*float(842.378));
float t7424 = fract(t7423);
float t7425 = (t7424+float(45.32));
float t7426 = (t7425+u6.u0);
float t7427 = (t7424*t7426);
float t7428 = (t6129*t6113);
float t7429 = (t7428*float(1734.048));
float t7430 = fract(t7429);
float t7431 = (t7430+float(45.32));
float t7432 = (t7431+u6.u0);
float t7433 = (t7430*t7432);
float t7434 = (t7427+t7433);
float t7435 = (t7424+t7434);
float t7436 = (t7430+t7434);
float t7437 = (t7435*t7436);
float t7438 = fract(t7437);
float t7439 = step(float(0.2),t7438);
float t7440 = (t7421*t7439);
float t7441 = (3.1415927/2);
float t7442 = (t7166-t7441);
float t7443 = (3.1415927/2);
float t7444 = (t7192-t7443);
float t7445 = (t7442-t7444);
float t7446 = abs(t7445);
float t7447 = (t7446/2);
float t7448 = sin(t7447);
float t7449 = (t7448*t7448);
float t7450 = cos(t7444);
float t7451 = cos(t7442);
float t7452 = (t7450*t7451);
float t7453 = (t7214+3.1415927);
float t7454 = (3.1415927*2);
float t7455 = mod(t7453,t7454);
float t7456 = (t7455-3.1415927);
float t7457 = (t7230+3.1415927);
float t7458 = (3.1415927*2);
float t7459 = mod(t7457,t7458);
float t7460 = (t7459-3.1415927);
float t7461 = (t7456-t7460);
float t7462 = abs(t7461);
float t7463 = (t7462/2);
float t7464 = sin(t7463);
float t7465 = (t7464*t7464);
float t7466 = (t7452*t7465);
float t7467 = (t7449+t7466);
float t7468 = sqrt(t7467);
float t7469 = asin(t7468);
float t7470 = (2*t7469);
float t7471 = (t7470/t5448);
float t7472 = (1-t7471);
float t7473 = (t6113/85);
float t7474 = (t7473*float(842.378));
float t7475 = fract(t7474);
float t7476 = (t7475+float(45.32));
float t7477 = (t7476+u6.u0);
float t7478 = (t7475*t7477);
float t7479 = (t6129/t6126);
float t7480 = (t7479*float(1734.048));
float t7481 = fract(t7480);
float t7482 = (t7481+float(45.32));
float t7483 = (t7482+u6.u0);
float t7484 = (t7481*t7483);
float t7485 = (t7478+t7484);
float t7486 = (t7475+t7485);
float t7487 = (t7481+t7485);
float t7488 = (t7486*t7487);
float t7489 = fract(t7488);
float t7490 = (t7489*float(8.0e-3));
float t7491 = (float(1.0e-3)+t7490);
float t7492 = (t7489*173);
float t7493 = fract(t7492);
float t7494 = step(float(0.66),t7493);
float t7495 = (t7494*float(3.0e-3));
float t7496 = (t7491-t7495);
float t7497 = (t7496*float(0.45));
float t7498 = (t6113/85);
float t7499 = (t7498*float(842.378));
float t7500 = fract(t7499);
float t7501 = (t7500+float(45.32));
float t7502 = (t7501+u6.u0);
float t7503 = (t7500*t7502);
float t7504 = (t7149/t6126);
float t7505 = (t7504*float(1734.048));
float t7506 = fract(t7505);
float t7507 = (t7506+float(45.32));
float t7508 = (t7507+u6.u0);
float t7509 = (t7506*t7508);
float t7510 = (t7503+t7509);
float t7511 = (t7500+t7510);
float t7512 = (t7506+t7510);
float t7513 = (t7511*t7512);
float t7514 = fract(t7513);
float t7515 = (t7514*float(8.0e-3));
float t7516 = (float(1.0e-3)+t7515);
float t7517 = (t7514*173);
float t7518 = fract(t7517);
float t7519 = step(float(0.66),t7518);
float t7520 = (t7519*float(3.0e-3));
float t7521 = (t7516-t7520);
float t7522 = (t7521*float(0.45));
float t7523 = (t7497-t7522);
float t7524 = abs(t7523);
float t7525 = (t7524-float(1.0e-3));
float t7526 = (t7525/float(8.0e-3));
float t7527 = (1-t7526);
float t7528 = (t7527*t7527);
float t7529 = (t7472*t7528);
float t7530 = (t7440*t7529);
float t7531 = (u4.u0*t7438);
float t7532 = (t7531*3);
float t7533 = sin(t7532);
float t7534 = (t7533+1);
float t7535 = (t7534/2);
float t7536 = (t7535*float(0.66));
float t7537 = (t7536+float(0.33));
float t7538 = (t7530*t7537);
float t7539 = (float(0.2)*t7538);
bool t7540 = (0>=t7539);
float t7541;
if(t7540){
t7541 = 0;
} else {
t7541 = t7539;
}
float t7542 = (t7541*0);
float t7543 = (t7141+t7542);
float t7544 = (t6113*t5448);
float t7545 = (t6113/85);
float t7546 = (t7545*float(842.378));
float t7547 = fract(t7546);
float t7548 = (t7547+float(45.32));
float t7549 = (t7548+u6.u0);
float t7550 = (t7547*t7549);
float t7551 = (t7149/t6126);
float t7552 = (t7551*float(1734.048));
float t7553 = fract(t7552);
float t7554 = (t7553+float(45.32));
float t7555 = (t7554+u6.u0);
float t7556 = (t7553*t7555);
float t7557 = (t7550+t7556);
float t7558 = (t7547+t7557);
float t7559 = (t7553+t7557);
float t7560 = (t7558*t7559);
float t7561 = fract(t7560);
float t7562 = (t7561*float(2852.02));
float t7563 = fract(t7562);
float t7564 = (t7563-float(0.5));
float t7565 = (t7564*t5448);
float t7566 = (t7565*float(0.75));
float t7567 = (t7544+t7566);
float t7568 = (3.1415927/2);
float t7569 = (t7567-t7568);
float t7570 = (t5450*t5448);
float t7571 = (t5450/85);
float t7572 = (t7571*float(842.378));
float t7573 = fract(t7572);
float t7574 = (t7573+float(45.32));
float t7575 = (t7574+u6.u0);
float t7576 = (t7573*t7575);
float t7577 = (t5684/t5463);
float t7578 = (t7577*float(1734.048));
float t7579 = fract(t7578);
float t7580 = (t7579+float(45.32));
float t7581 = (t7580+u6.u0);
float t7582 = (t7579*t7581);
float t7583 = (t7576+t7582);
float t7584 = (t7573+t7583);
float t7585 = (t7579+t7583);
float t7586 = (t7584*t7585);
float t7587 = fract(t7586);
float t7588 = (t7587*float(2852.02));
float t7589 = fract(t7588);
float t7590 = (t7589-float(0.5));
float t7591 = (t7590*t5448);
float t7592 = (t7591*float(0.75));
float t7593 = (t7570+t7592);
float t7594 = (3.1415927/2);
float t7595 = (t7593-t7594);
float t7596 = (t7569-t7595);
float t7597 = abs(t7596);
float t7598 = (t7597/2);
float t7599 = sin(t7598);
float t7600 = (t7599*t7599);
float t7601 = cos(t7595);
float t7602 = cos(t7569);
float t7603 = (t7601*t7602);
float t7604 = (3.1415927/t6126);
float t7605 = (t7149*t7604);
float t7606 = (t7561*float(97372.83));
float t7607 = fract(t7606);
float t7608 = (t7607-float(0.5));
float t7609 = (3.1415927/t6126);
float t7610 = (t7608*t7609);
float t7611 = (t7610*float(0.75));
float t7612 = (t7605+t7611);
float t7613 = (t7612+3.1415927);
float t7614 = mod(t7613,t1433);
float t7615 = (t7614-3.1415927);
float t7616 = (t7615+3.1415927);
float t7617 = (3.1415927*2);
float t7618 = mod(t7616,t7617);
float t7619 = (t7618-3.1415927);
float t7620 = (3.1415927/t5463);
float t7621 = (t5684*t7620);
float t7622 = (t7587*float(97372.83));
float t7623 = fract(t7622);
float t7624 = (t7623-float(0.5));
float t7625 = (3.1415927/t5463);
float t7626 = (t7624*t7625);
float t7627 = (t7626*float(0.75));
float t7628 = (t7621+t7627);
float t7629 = (t7628+3.1415927);
float t7630 = mod(t7629,t1433);
float t7631 = (t7630-3.1415927);
float t7632 = (t7631+3.1415927);
float t7633 = (3.1415927*2);
float t7634 = mod(t7632,t7633);
float t7635 = (t7634-3.1415927);
float t7636 = (t7619-t7635);
float t7637 = abs(t7636);
float t7638 = (t7637/2);
float t7639 = sin(t7638);
float t7640 = (t7639*t7639);
float t7641 = (t7603*t7640);
float t7642 = (t7600+t7641);
float t7643 = sqrt(t7642);
float t7644 = asin(t7643);
float t7645 = (2*t7644);
float t7646 = (3.1415927/2);
float t7647 = (t8-t7646);
float t7648 = (3.1415927/2);
float t7649 = (t7593-t7648);
float t7650 = (t7647-t7649);
float t7651 = abs(t7650);
float t7652 = (t7651/2);
float t7653 = sin(t7652);
float t7654 = (t7653*t7653);
float t7655 = cos(t7649);
float t7656 = cos(t7647);
float t7657 = (t7655*t7656);
float t7658 = (t118+3.1415927);
float t7659 = (3.1415927*2);
float t7660 = mod(t7658,t7659);
float t7661 = (t7660-3.1415927);
float t7662 = (t7631+3.1415927);
float t7663 = (3.1415927*2);
float t7664 = mod(t7662,t7663);
float t7665 = (t7664-3.1415927);
float t7666 = (t7661-t7665);
float t7667 = abs(t7666);
float t7668 = (t7667/2);
float t7669 = sin(t7668);
float t7670 = (t7669*t7669);
float t7671 = (t7657*t7670);
float t7672 = (t7654+t7671);
float t7673 = sqrt(t7672);
float t7674 = asin(t7673);
float t7675 = (2*t7674);
float t7676 = (t7645-t7675);
float t7677 = (3.1415927/2);
float t7678 = (t8-t7677);
float t7679 = (3.1415927/2);
float t7680 = (t7567-t7679);
float t7681 = (t7678-t7680);
float t7682 = abs(t7681);
float t7683 = (t7682/2);
float t7684 = sin(t7683);
float t7685 = (t7684*t7684);
float t7686 = cos(t7680);
float t7687 = cos(t7678);
float t7688 = (t7686*t7687);
float t7689 = (t118+3.1415927);
float t7690 = (3.1415927*2);
float t7691 = mod(t7689,t7690);
float t7692 = (t7691-3.1415927);
float t7693 = (t7615+3.1415927);
float t7694 = (3.1415927*2);
float t7695 = mod(t7693,t7694);
float t7696 = (t7695-3.1415927);
float t7697 = (t7692-t7696);
float t7698 = abs(t7697);
float t7699 = (t7698/2);
float t7700 = sin(t7699);
float t7701 = (t7700*t7700);
float t7702 = (t7688*t7701);
float t7703 = (t7685+t7702);
float t7704 = sqrt(t7703);
float t7705 = asin(t7704);
float t7706 = (2*t7705);
float t7707 = (t7676-t7706);
float t7708 = abs(t7707);
bool t7709 = (float(1.0e-4)>t7708);
float t7710;
if(t7709){
float t7711 = cos(t7593);
float t7712 = (1*t7711);
float t7713 = sin(t7567);
float t7714 = (1*t7713);
float t7715 = cos(t7615);
float t7716 = (t7714*t7715);
float t7717 = (t7712*t7716);
float t7718 = sin(t7593);
float t7719 = (1*t7718);
float t7720 = cos(t7631);
float t7721 = (t7719*t7720);
float t7722 = cos(t7567);
float t7723 = (1*t7722);
float t7724 = (t7721*t7723);
float t7725 = (t7717-t7724);
float t7726 = sin(t8);
float t7727 = (1*t7726);
float t7728 = sin(t118);
float t7729 = (t7727*t7728);
float t7730 = (t7725*t7729);
float t7731 = sin(t7567);
float t7732 = (1*t7731);
float t7733 = sin(t7615);
float t7734 = (t7732*t7733);
float t7735 = (t7721*t7734);
float t7736 = sin(t7593);
float t7737 = (1*t7736);
float t7738 = sin(t7631);
float t7739 = (t7737*t7738);
float t7740 = (t7739*t7716);
float t7741 = (t7735-t7740);
float t7742 = cos(t8);
float t7743 = (1*t7742);
float t7744 = (t7741*t7743);
float t7745 = (t7730+t7744);
float t7746 = (t7739*t7723);
float t7747 = (t7712*t7734);
float t7748 = (t7746-t7747);
float t7749 = sin(t8);
float t7750 = (1*t7749);
float t7751 = cos(t118);
float t7752 = (t7750*t7751);
float t7753 = (t7748*t7752);
float t7754 = (t7745+t7753);
float t7755 = abs(t7754);
t7710 = t7755;
} else {
float t7756 = (3.1415927/2);
float t7757 = (t8-t7756);
float t7758 = (3.1415927/2);
float t7759 = (t7567-t7758);
float t7760 = (t7757-t7759);
float t7761 = abs(t7760);
float t7762 = (t7761/2);
float t7763 = sin(t7762);
float t7764 = (t7763*t7763);
float t7765 = cos(t7759);
float t7766 = cos(t7757);
float t7767 = (t7765*t7766);
float t7768 = (t118+3.1415927);
float t7769 = (3.1415927*2);
float t7770 = mod(t7768,t7769);
float t7771 = (t7770-3.1415927);
float t7772 = (t7615+3.1415927);
float t7773 = (3.1415927*2);
float t7774 = mod(t7772,t7773);
float t7775 = (t7774-3.1415927);
float t7776 = (t7771-t7775);
float t7777 = abs(t7776);
float t7778 = (t7777/2);
float t7779 = sin(t7778);
float t7780 = (t7779*t7779);
float t7781 = (t7767*t7780);
float t7782 = (t7764+t7781);
float t7783 = sqrt(t7782);
float t7784 = asin(t7783);
float t7785 = (2*t7784);
float t7786 = abs(t7785);
float t7787 = (3.1415927/2);
float t7788 = (t8-t7787);
float t7789 = (3.1415927/2);
float t7790 = (t7593-t7789);
float t7791 = (t7788-t7790);
float t7792 = abs(t7791);
float t7793 = (t7792/2);
float t7794 = sin(t7793);
float t7795 = (t7794*t7794);
float t7796 = cos(t7790);
float t7797 = cos(t7788);
float t7798 = (t7796*t7797);
float t7799 = (t118+3.1415927);
float t7800 = (3.1415927*2);
float t7801 = mod(t7799,t7800);
float t7802 = (t7801-3.1415927);
float t7803 = (t7631+3.1415927);
float t7804 = (3.1415927*2);
float t7805 = mod(t7803,t7804);
float t7806 = (t7805-3.1415927);
float t7807 = (t7802-t7806);
float t7808 = abs(t7807);
float t7809 = (t7808/2);
float t7810 = sin(t7809);
float t7811 = (t7810*t7810);
float t7812 = (t7798*t7811);
float t7813 = (t7795+t7812);
float t7814 = sqrt(t7813);
float t7815 = asin(t7814);
float t7816 = (2*t7815);
float t7817 = abs(t7816);
bool t7818 = (t7786>=t7817);
float t7819;
if(t7818){
t7819 = t7786;
} else {
t7819 = t7817;
}
t7710 = t7819;
}
float t7820 = abs(t7710);
float t7821 = step(float(2.0e-4),t7820);
float t7822 = (1-t7821);
float t7823 = (t5450*t7149);
float t7824 = (t7823*float(842.378));
float t7825 = fract(t7824);
float t7826 = (t7825+float(45.32));
float t7827 = (t7826+u6.u0);
float t7828 = (t7825*t7827);
float t7829 = (t5684*t6113);
float t7830 = (t7829*float(1734.048));
float t7831 = fract(t7830);
float t7832 = (t7831+float(45.32));
float t7833 = (t7832+u6.u0);
float t7834 = (t7831*t7833);
float t7835 = (t7828+t7834);
float t7836 = (t7825+t7835);
float t7837 = (t7831+t7835);
float t7838 = (t7836*t7837);
float t7839 = fract(t7838);
float t7840 = step(float(0.2),t7839);
float t7841 = (t7822*t7840);
float t7842 = (3.1415927/2);
float t7843 = (t7567-t7842);
float t7844 = (3.1415927/2);
float t7845 = (t7593-t7844);
float t7846 = (t7843-t7845);
float t7847 = abs(t7846);
float t7848 = (t7847/2);
float t7849 = sin(t7848);
float t7850 = (t7849*t7849);
float t7851 = cos(t7845);
float t7852 = cos(t7843);
float t7853 = (t7851*t7852);
float t7854 = (t7615+3.1415927);
float t7855 = (3.1415927*2);
float t7856 = mod(t7854,t7855);
float t7857 = (t7856-3.1415927);
float t7858 = (t7631+3.1415927);
float t7859 = (3.1415927*2);
float t7860 = mod(t7858,t7859);
float t7861 = (t7860-3.1415927);
float t7862 = (t7857-t7861);
float t7863 = abs(t7862);
float t7864 = (t7863/2);
float t7865 = sin(t7864);
float t7866 = (t7865*t7865);
float t7867 = (t7853*t7866);
float t7868 = (t7850+t7867);
float t7869 = sqrt(t7868);
float t7870 = asin(t7869);
float t7871 = (2*t7870);
float t7872 = (t7871/t5448);
float t7873 = (1-t7872);
float t7874 = (t5450/85);
float t7875 = (t7874*float(842.378));
float t7876 = fract(t7875);
float t7877 = (t7876+float(45.32));
float t7878 = (t7877+u6.u0);
float t7879 = (t7876*t7878);
float t7880 = (t5684/t5463);
float t7881 = (t7880*float(1734.048));
float t7882 = fract(t7881);
float t7883 = (t7882+float(45.32));
float t7884 = (t7883+u6.u0);
float t7885 = (t7882*t7884);
float t7886 = (t7879+t7885);
float t7887 = (t7876+t7886);
float t7888 = (t7882+t7886);
float t7889 = (t7887*t7888);
float t7890 = fract(t7889);
float t7891 = (t7890*float(8.0e-3));
float t7892 = (float(1.0e-3)+t7891);
float t7893 = (t7890*173);
float t7894 = fract(t7893);
float t7895 = step(float(0.66),t7894);
float t7896 = (t7895*float(3.0e-3));
float t7897 = (t7892-t7896);
float t7898 = (t7897*float(0.45));
float t7899 = (t6113/85);
float t7900 = (t7899*float(842.378));
float t7901 = fract(t7900);
float t7902 = (t7901+float(45.32));
float t7903 = (t7902+u6.u0);
float t7904 = (t7901*t7903);
float t7905 = (t7149/t6126);
float t7906 = (t7905*float(1734.048));
float t7907 = fract(t7906);
float t7908 = (t7907+float(45.32));
float t7909 = (t7908+u6.u0);
float t7910 = (t7907*t7909);
float t7911 = (t7904+t7910);
float t7912 = (t7901+t7911);
float t7913 = (t7907+t7911);
float t7914 = (t7912*t7913);
float t7915 = fract(t7914);
float t7916 = (t7915*float(8.0e-3));
float t7917 = (float(1.0e-3)+t7916);
float t7918 = (t7915*173);
float t7919 = fract(t7918);
float t7920 = step(float(0.66),t7919);
float t7921 = (t7920*float(3.0e-3));
float t7922 = (t7917-t7921);
float t7923 = (t7922*float(0.45));
float t7924 = (t7898-t7923);
float t7925 = abs(t7924);
float t7926 = (t7925-float(1.0e-3));
float t7927 = (t7926/float(8.0e-3));
float t7928 = (1-t7927);
float t7929 = (t7928*t7928);
float t7930 = (t7873*t7929);
float t7931 = (t7841*t7930);
float t7932 = (u4.u0*t7839);
float t7933 = (t7932*3);
float t7934 = sin(t7933);
float t7935 = (t7934+1);
float t7936 = (t7935/2);
float t7937 = (t7936*float(0.66));
float t7938 = (t7937+float(0.33));
float t7939 = (t7931*t7938);
float t7940 = (float(0.2)*t7939);
bool t7941 = (0>=t7940);
float t7942;
if(t7941){
t7942 = 0;
} else {
t7942 = t7940;
}
float t7943 = (t7942*0);
float t7944 = (t7543+t7943);
float t7945 = (t6113*t5448);
float t7946 = (t6113/85);
float t7947 = (t7946*float(842.378));
float t7948 = fract(t7947);
float t7949 = (t7948+float(45.32));
float t7950 = (t7949+u6.u0);
float t7951 = (t7948*t7950);
float t7952 = (t7149/t6126);
float t7953 = (t7952*float(1734.048));
float t7954 = fract(t7953);
float t7955 = (t7954+float(45.32));
float t7956 = (t7955+u6.u0);
float t7957 = (t7954*t7956);
float t7958 = (t7951+t7957);
float t7959 = (t7948+t7958);
float t7960 = (t7954+t7958);
float t7961 = (t7959*t7960);
float t7962 = fract(t7961);
float t7963 = (t7962*float(2852.02));
float t7964 = fract(t7963);
float t7965 = (t7964-float(0.5));
float t7966 = (t7965*t5448);
float t7967 = (t7966*float(0.75));
float t7968 = (t7945+t7967);
float t7969 = (3.1415927/2);
float t7970 = (t7968-t7969);
float t7971 = (t5450*t5448);
float t7972 = (t5450/85);
float t7973 = (t7972*float(842.378));
float t7974 = fract(t7973);
float t7975 = (t7974+float(45.32));
float t7976 = (t7975+u6.u0);
float t7977 = (t7974*t7976);
float t7978 = (t5466/t5463);
float t7979 = (t7978*float(1734.048));
float t7980 = fract(t7979);
float t7981 = (t7980+float(45.32));
float t7982 = (t7981+u6.u0);
float t7983 = (t7980*t7982);
float t7984 = (t7977+t7983);
float t7985 = (t7974+t7984);
float t7986 = (t7980+t7984);
float t7987 = (t7985*t7986);
float t7988 = fract(t7987);
float t7989 = (t7988*float(2852.02));
float t7990 = fract(t7989);
float t7991 = (t7990-float(0.5));
float t7992 = (t7991*t5448);
float t7993 = (t7992*float(0.75));
float t7994 = (t7971+t7993);
float t7995 = (3.1415927/2);
float t7996 = (t7994-t7995);
float t7997 = (t7970-t7996);
float t7998 = abs(t7997);
float t7999 = (t7998/2);
float t8000 = sin(t7999);
float t8001 = (t8000*t8000);
float t8002 = cos(t7996);
float t8003 = cos(t7970);
float t8004 = (t8002*t8003);
float t8005 = (3.1415927/t6126);
float t8006 = (t7149*t8005);
float t8007 = (t7962*float(97372.83));
float t8008 = fract(t8007);
float t8009 = (t8008-float(0.5));
float t8010 = (3.1415927/t6126);
float t8011 = (t8009*t8010);
float t8012 = (t8011*float(0.75));
float t8013 = (t8006+t8012);
float t8014 = (t8013+3.1415927);
float t8015 = mod(t8014,t1433);
float t8016 = (t8015-3.1415927);
float t8017 = (t8016+3.1415927);
float t8018 = (3.1415927*2);
float t8019 = mod(t8017,t8018);
float t8020 = (t8019-3.1415927);
float t8021 = (3.1415927/t5463);
float t8022 = (t5466*t8021);
float t8023 = (t7988*float(97372.83));
float t8024 = fract(t8023);
float t8025 = (t8024-float(0.5));
float t8026 = (3.1415927/t5463);
float t8027 = (t8025*t8026);
float t8028 = (t8027*float(0.75));
float t8029 = (t8022+t8028);
float t8030 = (t8029+3.1415927);
float t8031 = mod(t8030,t1433);
float t8032 = (t8031-3.1415927);
float t8033 = (t8032+3.1415927);
float t8034 = (3.1415927*2);
float t8035 = mod(t8033,t8034);
float t8036 = (t8035-3.1415927);
float t8037 = (t8020-t8036);
float t8038 = abs(t8037);
float t8039 = (t8038/2);
float t8040 = sin(t8039);
float t8041 = (t8040*t8040);
float t8042 = (t8004*t8041);
float t8043 = (t8001+t8042);
float t8044 = sqrt(t8043);
float t8045 = asin(t8044);
float t8046 = (2*t8045);
float t8047 = (3.1415927/2);
float t8048 = (t8-t8047);
float t8049 = (3.1415927/2);
float t8050 = (t7994-t8049);
float t8051 = (t8048-t8050);
float t8052 = abs(t8051);
float t8053 = (t8052/2);
float t8054 = sin(t8053);
float t8055 = (t8054*t8054);
float t8056 = cos(t8050);
float t8057 = cos(t8048);
float t8058 = (t8056*t8057);
float t8059 = (t118+3.1415927);
float t8060 = (3.1415927*2);
float t8061 = mod(t8059,t8060);
float t8062 = (t8061-3.1415927);
float t8063 = (t8032+3.1415927);
float t8064 = (3.1415927*2);
float t8065 = mod(t8063,t8064);
float t8066 = (t8065-3.1415927);
float t8067 = (t8062-t8066);
float t8068 = abs(t8067);
float t8069 = (t8068/2);
float t8070 = sin(t8069);
float t8071 = (t8070*t8070);
float t8072 = (t8058*t8071);
float t8073 = (t8055+t8072);
float t8074 = sqrt(t8073);
float t8075 = asin(t8074);
float t8076 = (2*t8075);
float t8077 = (t8046-t8076);
float t8078 = (3.1415927/2);
float t8079 = (t8-t8078);
float t8080 = (3.1415927/2);
float t8081 = (t7968-t8080);
float t8082 = (t8079-t8081);
float t8083 = abs(t8082);
float t8084 = (t8083/2);
float t8085 = sin(t8084);
float t8086 = (t8085*t8085);
float t8087 = cos(t8081);
float t8088 = cos(t8079);
float t8089 = (t8087*t8088);
float t8090 = (t118+3.1415927);
float t8091 = (3.1415927*2);
float t8092 = mod(t8090,t8091);
float t8093 = (t8092-3.1415927);
float t8094 = (t8016+3.1415927);
float t8095 = (3.1415927*2);
float t8096 = mod(t8094,t8095);
float t8097 = (t8096-3.1415927);
float t8098 = (t8093-t8097);
float t8099 = abs(t8098);
float t8100 = (t8099/2);
float t8101 = sin(t8100);
float t8102 = (t8101*t8101);
float t8103 = (t8089*t8102);
float t8104 = (t8086+t8103);
float t8105 = sqrt(t8104);
float t8106 = asin(t8105);
float t8107 = (2*t8106);
float t8108 = (t8077-t8107);
float t8109 = abs(t8108);
bool t8110 = (float(1.0e-4)>t8109);
float t8111;
if(t8110){
float t8112 = cos(t7994);
float t8113 = (1*t8112);
float t8114 = sin(t7968);
float t8115 = (1*t8114);
float t8116 = cos(t8016);
float t8117 = (t8115*t8116);
float t8118 = (t8113*t8117);
float t8119 = sin(t7994);
float t8120 = (1*t8119);
float t8121 = cos(t8032);
float t8122 = (t8120*t8121);
float t8123 = cos(t7968);
float t8124 = (1*t8123);
float t8125 = (t8122*t8124);
float t8126 = (t8118-t8125);
float t8127 = sin(t8);
float t8128 = (1*t8127);
float t8129 = sin(t118);
float t8130 = (t8128*t8129);
float t8131 = (t8126*t8130);
float t8132 = sin(t7968);
float t8133 = (1*t8132);
float t8134 = sin(t8016);
float t8135 = (t8133*t8134);
float t8136 = (t8122*t8135);
float t8137 = sin(t7994);
float t8138 = (1*t8137);
float t8139 = sin(t8032);
float t8140 = (t8138*t8139);
float t8141 = (t8140*t8117);
float t8142 = (t8136-t8141);
float t8143 = cos(t8);
float t8144 = (1*t8143);
float t8145 = (t8142*t8144);
float t8146 = (t8131+t8145);
float t8147 = (t8140*t8124);
float t8148 = (t8113*t8135);
float t8149 = (t8147-t8148);
float t8150 = sin(t8);
float t8151 = (1*t8150);
float t8152 = cos(t118);
float t8153 = (t8151*t8152);
float t8154 = (t8149*t8153);
float t8155 = (t8146+t8154);
float t8156 = abs(t8155);
t8111 = t8156;
} else {
float t8157 = (3.1415927/2);
float t8158 = (t8-t8157);
float t8159 = (3.1415927/2);
float t8160 = (t7968-t8159);
float t8161 = (t8158-t8160);
float t8162 = abs(t8161);
float t8163 = (t8162/2);
float t8164 = sin(t8163);
float t8165 = (t8164*t8164);
float t8166 = cos(t8160);
float t8167 = cos(t8158);
float t8168 = (t8166*t8167);
float t8169 = (t118+3.1415927);
float t8170 = (3.1415927*2);
float t8171 = mod(t8169,t8170);
float t8172 = (t8171-3.1415927);
float t8173 = (t8016+3.1415927);
float t8174 = (3.1415927*2);
float t8175 = mod(t8173,t8174);
float t8176 = (t8175-3.1415927);
float t8177 = (t8172-t8176);
float t8178 = abs(t8177);
float t8179 = (t8178/2);
float t8180 = sin(t8179);
float t8181 = (t8180*t8180);
float t8182 = (t8168*t8181);
float t8183 = (t8165+t8182);
float t8184 = sqrt(t8183);
float t8185 = asin(t8184);
float t8186 = (2*t8185);
float t8187 = abs(t8186);
float t8188 = (3.1415927/2);
float t8189 = (t8-t8188);
float t8190 = (3.1415927/2);
float t8191 = (t7994-t8190);
float t8192 = (t8189-t8191);
float t8193 = abs(t8192);
float t8194 = (t8193/2);
float t8195 = sin(t8194);
float t8196 = (t8195*t8195);
float t8197 = cos(t8191);
float t8198 = cos(t8189);
float t8199 = (t8197*t8198);
float t8200 = (t118+3.1415927);
float t8201 = (3.1415927*2);
float t8202 = mod(t8200,t8201);
float t8203 = (t8202-3.1415927);
float t8204 = (t8032+3.1415927);
float t8205 = (3.1415927*2);
float t8206 = mod(t8204,t8205);
float t8207 = (t8206-3.1415927);
float t8208 = (t8203-t8207);
float t8209 = abs(t8208);
float t8210 = (t8209/2);
float t8211 = sin(t8210);
float t8212 = (t8211*t8211);
float t8213 = (t8199*t8212);
float t8214 = (t8196+t8213);
float t8215 = sqrt(t8214);
float t8216 = asin(t8215);
float t8217 = (2*t8216);
float t8218 = abs(t8217);
bool t8219 = (t8187>=t8218);
float t8220;
if(t8219){
t8220 = t8187;
} else {
t8220 = t8218;
}
t8111 = t8220;
}
float t8221 = abs(t8111);
float t8222 = step(float(2.0e-4),t8221);
float t8223 = (1-t8222);
float t8224 = (t5450*t7149);
float t8225 = (t8224*float(842.378));
float t8226 = fract(t8225);
float t8227 = (t8226+float(45.32));
float t8228 = (t8227+u6.u0);
float t8229 = (t8226*t8228);
float t8230 = (t5466*t6113);
float t8231 = (t8230*float(1734.048));
float t8232 = fract(t8231);
float t8233 = (t8232+float(45.32));
float t8234 = (t8233+u6.u0);
float t8235 = (t8232*t8234);
float t8236 = (t8229+t8235);
float t8237 = (t8226+t8236);
float t8238 = (t8232+t8236);
float t8239 = (t8237*t8238);
float t8240 = fract(t8239);
float t8241 = step(float(0.2),t8240);
float t8242 = (t8223*t8241);
float t8243 = (3.1415927/2);
float t8244 = (t7968-t8243);
float t8245 = (3.1415927/2);
float t8246 = (t7994-t8245);
float t8247 = (t8244-t8246);
float t8248 = abs(t8247);
float t8249 = (t8248/2);
float t8250 = sin(t8249);
float t8251 = (t8250*t8250);
float t8252 = cos(t8246);
float t8253 = cos(t8244);
float t8254 = (t8252*t8253);
float t8255 = (t8016+3.1415927);
float t8256 = (3.1415927*2);
float t8257 = mod(t8255,t8256);
float t8258 = (t8257-3.1415927);
float t8259 = (t8032+3.1415927);
float t8260 = (3.1415927*2);
float t8261 = mod(t8259,t8260);
float t8262 = (t8261-3.1415927);
float t8263 = (t8258-t8262);
float t8264 = abs(t8263);
float t8265 = (t8264/2);
float t8266 = sin(t8265);
float t8267 = (t8266*t8266);
float t8268 = (t8254*t8267);
float t8269 = (t8251+t8268);
float t8270 = sqrt(t8269);
float t8271 = asin(t8270);
float t8272 = (2*t8271);
float t8273 = (t8272/t5448);
float t8274 = (1-t8273);
float t8275 = (t5450/85);
float t8276 = (t8275*float(842.378));
float t8277 = fract(t8276);
float t8278 = (t8277+float(45.32));
float t8279 = (t8278+u6.u0);
float t8280 = (t8277*t8279);
float t8281 = (t5466/t5463);
float t8282 = (t8281*float(1734.048));
float t8283 = fract(t8282);
float t8284 = (t8283+float(45.32));
float t8285 = (t8284+u6.u0);
float t8286 = (t8283*t8285);
float t8287 = (t8280+t8286);
float t8288 = (t8277+t8287);
float t8289 = (t8283+t8287);
float t8290 = (t8288*t8289);
float t8291 = fract(t8290);
float t8292 = (t8291*float(8.0e-3));
float t8293 = (float(1.0e-3)+t8292);
float t8294 = (t8291*173);
float t8295 = fract(t8294);
float t8296 = step(float(0.66),t8295);
float t8297 = (t8296*float(3.0e-3));
float t8298 = (t8293-t8297);
float t8299 = (t8298*float(0.45));
float t8300 = (t6113/85);
float t8301 = (t8300*float(842.378));
float t8302 = fract(t8301);
float t8303 = (t8302+float(45.32));
float t8304 = (t8303+u6.u0);
float t8305 = (t8302*t8304);
float t8306 = (t7149/t6126);
float t8307 = (t8306*float(1734.048));
float t8308 = fract(t8307);
float t8309 = (t8308+float(45.32));
float t8310 = (t8309+u6.u0);
float t8311 = (t8308*t8310);
float t8312 = (t8305+t8311);
float t8313 = (t8302+t8312);
float t8314 = (t8308+t8312);
float t8315 = (t8313*t8314);
float t8316 = fract(t8315);
float t8317 = (t8316*float(8.0e-3));
float t8318 = (float(1.0e-3)+t8317);
float t8319 = (t8316*173);
float t8320 = fract(t8319);
float t8321 = step(float(0.66),t8320);
float t8322 = (t8321*float(3.0e-3));
float t8323 = (t8318-t8322);
float t8324 = (t8323*float(0.45));
float t8325 = (t8299-t8324);
float t8326 = abs(t8325);
float t8327 = (t8326-float(1.0e-3));
float t8328 = (t8327/float(8.0e-3));
float t8329 = (1-t8328);
float t8330 = (t8329*t8329);
float t8331 = (t8274*t8330);
float t8332 = (t8242*t8331);
float t8333 = (u4.u0*t8240);
float t8334 = (t8333*3);
float t8335 = sin(t8334);
float t8336 = (t8335+1);
float t8337 = (t8336/2);
float t8338 = (t8337*float(0.66));
float t8339 = (t8338+float(0.33));
float t8340 = (t8332*t8339);
float t8341 = (float(0.2)*t8340);
bool t8342 = (0>=t8341);
float t8343;
if(t8342){
t8343 = 0;
} else {
t8343 = t8341;
}
float t8344 = (t8343*0);
float t8345 = (t7944+t8344);
float t8346 = (t5450*t5448);
float t8347 = (t5450/85);
float t8348 = (t8347*float(842.378));
float t8349 = fract(t8348);
float t8350 = (t8349+float(45.32));
float t8351 = (t8350+u6.u0);
float t8352 = (t8349*t8351);
float t8353 = (t5902/t5463);
float t8354 = (t8353*float(1734.048));
float t8355 = fract(t8354);
float t8356 = (t8355+float(45.32));
float t8357 = (t8356+u6.u0);
float t8358 = (t8355*t8357);
float t8359 = (t8352+t8358);
float t8360 = (t8349+t8359);
float t8361 = (t8355+t8359);
float t8362 = (t8360*t8361);
float t8363 = fract(t8362);
float t8364 = (t8363*float(2852.02));
float t8365 = fract(t8364);
float t8366 = (t8365-float(0.5));
float t8367 = (t8366*t5448);
float t8368 = (t8367*float(0.75));
float t8369 = (t8346+t8368);
float t8370 = (3.1415927/2);
float t8371 = (t8369-t8370);
float t8372 = (t5450*t5448);
float t8373 = (t5450/85);
float t8374 = (t8373*float(842.378));
float t8375 = fract(t8374);
float t8376 = (t8375+float(45.32));
float t8377 = (t8376+u6.u0);
float t8378 = (t8375*t8377);
float t8379 = (t5684/t5463);
float t8380 = (t8379*float(1734.048));
float t8381 = fract(t8380);
float t8382 = (t8381+float(45.32));
float t8383 = (t8382+u6.u0);
float t8384 = (t8381*t8383);
float t8385 = (t8378+t8384);
float t8386 = (t8375+t8385);
float t8387 = (t8381+t8385);
float t8388 = (t8386*t8387);
float t8389 = fract(t8388);
float t8390 = (t8389*float(2852.02));
float t8391 = fract(t8390);
float t8392 = (t8391-float(0.5));
float t8393 = (t8392*t5448);
float t8394 = (t8393*float(0.75));
float t8395 = (t8372+t8394);
float t8396 = (3.1415927/2);
float t8397 = (t8395-t8396);
float t8398 = (t8371-t8397);
float t8399 = abs(t8398);
float t8400 = (t8399/2);
float t8401 = sin(t8400);
float t8402 = (t8401*t8401);
float t8403 = cos(t8397);
float t8404 = cos(t8371);
float t8405 = (t8403*t8404);
float t8406 = (3.1415927/t5463);
float t8407 = (t5902*t8406);
float t8408 = (t8363*float(97372.83));
float t8409 = fract(t8408);
float t8410 = (t8409-float(0.5));
float t8411 = (3.1415927/t5463);
float t8412 = (t8410*t8411);
float t8413 = (t8412*float(0.75));
float t8414 = (t8407+t8413);
float t8415 = (t8414+3.1415927);
float t8416 = mod(t8415,t1433);
float t8417 = (t8416-3.1415927);
float t8418 = (t8417+3.1415927);
float t8419 = (3.1415927*2);
float t8420 = mod(t8418,t8419);
float t8421 = (t8420-3.1415927);
float t8422 = (3.1415927/t5463);
float t8423 = (t5684*t8422);
float t8424 = (t8389*float(97372.83));
float t8425 = fract(t8424);
float t8426 = (t8425-float(0.5));
float t8427 = (3.1415927/t5463);
float t8428 = (t8426*t8427);
float t8429 = (t8428*float(0.75));
float t8430 = (t8423+t8429);
float t8431 = (t8430+3.1415927);
float t8432 = mod(t8431,t1433);
float t8433 = (t8432-3.1415927);
float t8434 = (t8433+3.1415927);
float t8435 = (3.1415927*2);
float t8436 = mod(t8434,t8435);
float t8437 = (t8436-3.1415927);
float t8438 = (t8421-t8437);
float t8439 = abs(t8438);
float t8440 = (t8439/2);
float t8441 = sin(t8440);
float t8442 = (t8441*t8441);
float t8443 = (t8405*t8442);
float t8444 = (t8402+t8443);
float t8445 = sqrt(t8444);
float t8446 = asin(t8445);
float t8447 = (2*t8446);
float t8448 = (3.1415927/2);
float t8449 = (t8-t8448);
float t8450 = (3.1415927/2);
float t8451 = (t8395-t8450);
float t8452 = (t8449-t8451);
float t8453 = abs(t8452);
float t8454 = (t8453/2);
float t8455 = sin(t8454);
float t8456 = (t8455*t8455);
float t8457 = cos(t8451);
float t8458 = cos(t8449);
float t8459 = (t8457*t8458);
float t8460 = (t118+3.1415927);
float t8461 = (3.1415927*2);
float t8462 = mod(t8460,t8461);
float t8463 = (t8462-3.1415927);
float t8464 = (t8433+3.1415927);
float t8465 = (3.1415927*2);
float t8466 = mod(t8464,t8465);
float t8467 = (t8466-3.1415927);
float t8468 = (t8463-t8467);
float t8469 = abs(t8468);
float t8470 = (t8469/2);
float t8471 = sin(t8470);
float t8472 = (t8471*t8471);
float t8473 = (t8459*t8472);
float t8474 = (t8456+t8473);
float t8475 = sqrt(t8474);
float t8476 = asin(t8475);
float t8477 = (2*t8476);
float t8478 = (t8447-t8477);
float t8479 = (3.1415927/2);
float t8480 = (t8-t8479);
float t8481 = (3.1415927/2);
float t8482 = (t8369-t8481);
float t8483 = (t8480-t8482);
float t8484 = abs(t8483);
float t8485 = (t8484/2);
float t8486 = sin(t8485);
float t8487 = (t8486*t8486);
float t8488 = cos(t8482);
float t8489 = cos(t8480);
float t8490 = (t8488*t8489);
float t8491 = (t118+3.1415927);
float t8492 = (3.1415927*2);
float t8493 = mod(t8491,t8492);
float t8494 = (t8493-3.1415927);
float t8495 = (t8417+3.1415927);
float t8496 = (3.1415927*2);
float t8497 = mod(t8495,t8496);
float t8498 = (t8497-3.1415927);
float t8499 = (t8494-t8498);
float t8500 = abs(t8499);
float t8501 = (t8500/2);
float t8502 = sin(t8501);
float t8503 = (t8502*t8502);
float t8504 = (t8490*t8503);
float t8505 = (t8487+t8504);
float t8506 = sqrt(t8505);
float t8507 = asin(t8506);
float t8508 = (2*t8507);
float t8509 = (t8478-t8508);
float t8510 = abs(t8509);
bool t8511 = (float(1.0e-4)>t8510);
float t8512;
if(t8511){
float t8513 = cos(t8395);
float t8514 = (1*t8513);
float t8515 = sin(t8369);
float t8516 = (1*t8515);
float t8517 = cos(t8417);
float t8518 = (t8516*t8517);
float t8519 = (t8514*t8518);
float t8520 = sin(t8395);
float t8521 = (1*t8520);
float t8522 = cos(t8433);
float t8523 = (t8521*t8522);
float t8524 = cos(t8369);
float t8525 = (1*t8524);
float t8526 = (t8523*t8525);
float t8527 = (t8519-t8526);
float t8528 = sin(t8);
float t8529 = (1*t8528);
float t8530 = sin(t118);
float t8531 = (t8529*t8530);
float t8532 = (t8527*t8531);
float t8533 = sin(t8369);
float t8534 = (1*t8533);
float t8535 = sin(t8417);
float t8536 = (t8534*t8535);
float t8537 = (t8523*t8536);
float t8538 = sin(t8395);
float t8539 = (1*t8538);
float t8540 = sin(t8433);
float t8541 = (t8539*t8540);
float t8542 = (t8541*t8518);
float t8543 = (t8537-t8542);
float t8544 = cos(t8);
float t8545 = (1*t8544);
float t8546 = (t8543*t8545);
float t8547 = (t8532+t8546);
float t8548 = (t8541*t8525);
float t8549 = (t8514*t8536);
float t8550 = (t8548-t8549);
float t8551 = sin(t8);
float t8552 = (1*t8551);
float t8553 = cos(t118);
float t8554 = (t8552*t8553);
float t8555 = (t8550*t8554);
float t8556 = (t8547+t8555);
float t8557 = abs(t8556);
t8512 = t8557;
} else {
float t8558 = (3.1415927/2);
float t8559 = (t8-t8558);
float t8560 = (3.1415927/2);
float t8561 = (t8369-t8560);
float t8562 = (t8559-t8561);
float t8563 = abs(t8562);
float t8564 = (t8563/2);
float t8565 = sin(t8564);
float t8566 = (t8565*t8565);
float t8567 = cos(t8561);
float t8568 = cos(t8559);
float t8569 = (t8567*t8568);
float t8570 = (t118+3.1415927);
float t8571 = (3.1415927*2);
float t8572 = mod(t8570,t8571);
float t8573 = (t8572-3.1415927);
float t8574 = (t8417+3.1415927);
float t8575 = (3.1415927*2);
float t8576 = mod(t8574,t8575);
float t8577 = (t8576-3.1415927);
float t8578 = (t8573-t8577);
float t8579 = abs(t8578);
float t8580 = (t8579/2);
float t8581 = sin(t8580);
float t8582 = (t8581*t8581);
float t8583 = (t8569*t8582);
float t8584 = (t8566+t8583);
float t8585 = sqrt(t8584);
float t8586 = asin(t8585);
float t8587 = (2*t8586);
float t8588 = abs(t8587);
float t8589 = (3.1415927/2);
float t8590 = (t8-t8589);
float t8591 = (3.1415927/2);
float t8592 = (t8395-t8591);
float t8593 = (t8590-t8592);
float t8594 = abs(t8593);
float t8595 = (t8594/2);
float t8596 = sin(t8595);
float t8597 = (t8596*t8596);
float t8598 = cos(t8592);
float t8599 = cos(t8590);
float t8600 = (t8598*t8599);
float t8601 = (t118+3.1415927);
float t8602 = (3.1415927*2);
float t8603 = mod(t8601,t8602);
float t8604 = (t8603-3.1415927);
float t8605 = (t8433+3.1415927);
float t8606 = (3.1415927*2);
float t8607 = mod(t8605,t8606);
float t8608 = (t8607-3.1415927);
float t8609 = (t8604-t8608);
float t8610 = abs(t8609);
float t8611 = (t8610/2);
float t8612 = sin(t8611);
float t8613 = (t8612*t8612);
float t8614 = (t8600*t8613);
float t8615 = (t8597+t8614);
float t8616 = sqrt(t8615);
float t8617 = asin(t8616);
float t8618 = (2*t8617);
float t8619 = abs(t8618);
bool t8620 = (t8588>=t8619);
float t8621;
if(t8620){
t8621 = t8588;
} else {
t8621 = t8619;
}
t8512 = t8621;
}
float t8622 = abs(t8512);
float t8623 = step(float(2.0e-4),t8622);
float t8624 = (1-t8623);
float t8625 = (t5450*t5902);
float t8626 = (t8625*float(842.378));
float t8627 = fract(t8626);
float t8628 = (t8627+float(45.32));
float t8629 = (t8628+u6.u0);
float t8630 = (t8627*t8629);
float t8631 = (t5684*t5450);
float t8632 = (t8631*float(1734.048));
float t8633 = fract(t8632);
float t8634 = (t8633+float(45.32));
float t8635 = (t8634+u6.u0);
float t8636 = (t8633*t8635);
float t8637 = (t8630+t8636);
float t8638 = (t8627+t8637);
float t8639 = (t8633+t8637);
float t8640 = (t8638*t8639);
float t8641 = fract(t8640);
float t8642 = step(float(0.2),t8641);
float t8643 = (t8624*t8642);
float t8644 = (3.1415927/2);
float t8645 = (t8369-t8644);
float t8646 = (3.1415927/2);
float t8647 = (t8395-t8646);
float t8648 = (t8645-t8647);
float t8649 = abs(t8648);
float t8650 = (t8649/2);
float t8651 = sin(t8650);
float t8652 = (t8651*t8651);
float t8653 = cos(t8647);
float t8654 = cos(t8645);
float t8655 = (t8653*t8654);
float t8656 = (t8417+3.1415927);
float t8657 = (3.1415927*2);
float t8658 = mod(t8656,t8657);
float t8659 = (t8658-3.1415927);
float t8660 = (t8433+3.1415927);
float t8661 = (3.1415927*2);
float t8662 = mod(t8660,t8661);
float t8663 = (t8662-3.1415927);
float t8664 = (t8659-t8663);
float t8665 = abs(t8664);
float t8666 = (t8665/2);
float t8667 = sin(t8666);
float t8668 = (t8667*t8667);
float t8669 = (t8655*t8668);
float t8670 = (t8652+t8669);
float t8671 = sqrt(t8670);
float t8672 = asin(t8671);
float t8673 = (2*t8672);
float t8674 = (t8673/t5448);
float t8675 = (1-t8674);
float t8676 = (t5450/85);
float t8677 = (t8676*float(842.378));
float t8678 = fract(t8677);
float t8679 = (t8678+float(45.32));
float t8680 = (t8679+u6.u0);
float t8681 = (t8678*t8680);
float t8682 = (t5684/t5463);
float t8683 = (t8682*float(1734.048));
float t8684 = fract(t8683);
float t8685 = (t8684+float(45.32));
float t8686 = (t8685+u6.u0);
float t8687 = (t8684*t8686);
float t8688 = (t8681+t8687);
float t8689 = (t8678+t8688);
float t8690 = (t8684+t8688);
float t8691 = (t8689*t8690);
float t8692 = fract(t8691);
float t8693 = (t8692*float(8.0e-3));
float t8694 = (float(1.0e-3)+t8693);
float t8695 = (t8692*173);
float t8696 = fract(t8695);
float t8697 = step(float(0.66),t8696);
float t8698 = (t8697*float(3.0e-3));
float t8699 = (t8694-t8698);
float t8700 = (t8699*float(0.45));
float t8701 = (t5450/85);
float t8702 = (t8701*float(842.378));
float t8703 = fract(t8702);
float t8704 = (t8703+float(45.32));
float t8705 = (t8704+u6.u0);
float t8706 = (t8703*t8705);
float t8707 = (t5902/t5463);
float t8708 = (t8707*float(1734.048));
float t8709 = fract(t8708);
float t8710 = (t8709+float(45.32));
float t8711 = (t8710+u6.u0);
float t8712 = (t8709*t8711);
float t8713 = (t8706+t8712);
float t8714 = (t8703+t8713);
float t8715 = (t8709+t8713);
float t8716 = (t8714*t8715);
float t8717 = fract(t8716);
float t8718 = (t8717*float(8.0e-3));
float t8719 = (float(1.0e-3)+t8718);
float t8720 = (t8717*173);
float t8721 = fract(t8720);
float t8722 = step(float(0.66),t8721);
float t8723 = (t8722*float(3.0e-3));
float t8724 = (t8719-t8723);
float t8725 = (t8724*float(0.45));
float t8726 = (t8700-t8725);
float t8727 = abs(t8726);
float t8728 = (t8727-float(1.0e-3));
float t8729 = (t8728/float(8.0e-3));
float t8730 = (1-t8729);
float t8731 = (t8730*t8730);
float t8732 = (t8675*t8731);
float t8733 = (t8643*t8732);
float t8734 = (u4.u0*t8641);
float t8735 = (t8734*3);
float t8736 = sin(t8735);
float t8737 = (t8736+1);
float t8738 = (t8737/2);
float t8739 = (t8738*float(0.66));
float t8740 = (t8739+float(0.33));
float t8741 = (t8733*t8740);
float t8742 = (float(0.2)*t8741);
bool t8743 = (0>=t8742);
float t8744;
if(t8743){
t8744 = 0;
} else {
t8744 = t8742;
}
float t8745 = (t8744*0);
float t8746 = (t8345+t8745);
float t8747 = (t5450*t5448);
float t8748 = (t5450/85);
float t8749 = (t8748*float(842.378));
float t8750 = fract(t8749);
float t8751 = (t8750+float(45.32));
float t8752 = (t8751+u6.u0);
float t8753 = (t8750*t8752);
float t8754 = (t5466+2);
float t8755 = (t8754/t6126);
float t8756 = (t8755*float(1734.048));
float t8757 = fract(t8756);
float t8758 = (t8757+float(45.32));
float t8759 = (t8758+u6.u0);
float t8760 = (t8757*t8759);
float t8761 = (t8753+t8760);
float t8762 = (t8750+t8761);
float t8763 = (t8757+t8761);
float t8764 = (t8762*t8763);
float t8765 = fract(t8764);
float t8766 = (t8765*float(2852.02));
float t8767 = fract(t8766);
float t8768 = (t8767-float(0.5));
float t8769 = (t8768*t5448);
float t8770 = (t8769*float(0.75));
float t8771 = (t8747+t8770);
float t8772 = (3.1415927/2);
float t8773 = (t8771-t8772);
float t8774 = (t6113*t5448);
float t8775 = (t6113/85);
float t8776 = (t8775*float(842.378));
float t8777 = fract(t8776);
float t8778 = (t8777+float(45.32));
float t8779 = (t8778+u6.u0);
float t8780 = (t8777*t8779);
float t8781 = (t7149/t6126);
float t8782 = (t8781*float(1734.048));
float t8783 = fract(t8782);
float t8784 = (t8783+float(45.32));
float t8785 = (t8784+u6.u0);
float t8786 = (t8783*t8785);
float t8787 = (t8780+t8786);
float t8788 = (t8777+t8787);
float t8789 = (t8783+t8787);
float t8790 = (t8788*t8789);
float t8791 = fract(t8790);
float t8792 = (t8791*float(2852.02));
float t8793 = fract(t8792);
float t8794 = (t8793-float(0.5));
float t8795 = (t8794*t5448);
float t8796 = (t8795*float(0.75));
float t8797 = (t8774+t8796);
float t8798 = (3.1415927/2);
float t8799 = (t8797-t8798);
float t8800 = (t8773-t8799);
float t8801 = abs(t8800);
float t8802 = (t8801/2);
float t8803 = sin(t8802);
float t8804 = (t8803*t8803);
float t8805 = cos(t8799);
float t8806 = cos(t8773);
float t8807 = (t8805*t8806);
float t8808 = (3.1415927/t6126);
float t8809 = (t8754*t8808);
float t8810 = (t8765*float(97372.83));
float t8811 = fract(t8810);
float t8812 = (t8811-float(0.5));
float t8813 = (3.1415927/t6126);
float t8814 = (t8812*t8813);
float t8815 = (t8814*float(0.75));
float t8816 = (t8809+t8815);
float t8817 = (t8816+3.1415927);
float t8818 = mod(t8817,t1433);
float t8819 = (t8818-3.1415927);
float t8820 = (t8819+3.1415927);
float t8821 = (3.1415927*2);
float t8822 = mod(t8820,t8821);
float t8823 = (t8822-3.1415927);
float t8824 = (3.1415927/t6126);
float t8825 = (t7149*t8824);
float t8826 = (t8791*float(97372.83));
float t8827 = fract(t8826);
float t8828 = (t8827-float(0.5));
float t8829 = (3.1415927/t6126);
float t8830 = (t8828*t8829);
float t8831 = (t8830*float(0.75));
float t8832 = (t8825+t8831);
float t8833 = (t8832+3.1415927);
float t8834 = mod(t8833,t1433);
float t8835 = (t8834-3.1415927);
float t8836 = (t8835+3.1415927);
float t8837 = (3.1415927*2);
float t8838 = mod(t8836,t8837);
float t8839 = (t8838-3.1415927);
float t8840 = (t8823-t8839);
float t8841 = abs(t8840);
float t8842 = (t8841/2);
float t8843 = sin(t8842);
float t8844 = (t8843*t8843);
float t8845 = (t8807*t8844);
float t8846 = (t8804+t8845);
float t8847 = sqrt(t8846);
float t8848 = asin(t8847);
float t8849 = (2*t8848);
float t8850 = (3.1415927/2);
float t8851 = (t8-t8850);
float t8852 = (3.1415927/2);
float t8853 = (t8797-t8852);
float t8854 = (t8851-t8853);
float t8855 = abs(t8854);
float t8856 = (t8855/2);
float t8857 = sin(t8856);
float t8858 = (t8857*t8857);
float t8859 = cos(t8853);
float t8860 = cos(t8851);
float t8861 = (t8859*t8860);
float t8862 = (t118+3.1415927);
float t8863 = (3.1415927*2);
float t8864 = mod(t8862,t8863);
float t8865 = (t8864-3.1415927);
float t8866 = (t8835+3.1415927);
float t8867 = (3.1415927*2);
float t8868 = mod(t8866,t8867);
float t8869 = (t8868-3.1415927);
float t8870 = (t8865-t8869);
float t8871 = abs(t8870);
float t8872 = (t8871/2);
float t8873 = sin(t8872);
float t8874 = (t8873*t8873);
float t8875 = (t8861*t8874);
float t8876 = (t8858+t8875);
float t8877 = sqrt(t8876);
float t8878 = asin(t8877);
float t8879 = (2*t8878);
float t8880 = (t8849-t8879);
float t8881 = (3.1415927/2);
float t8882 = (t8-t8881);
float t8883 = (3.1415927/2);
float t8884 = (t8771-t8883);
float t8885 = (t8882-t8884);
float t8886 = abs(t8885);
float t8887 = (t8886/2);
float t8888 = sin(t8887);
float t8889 = (t8888*t8888);
float t8890 = cos(t8884);
float t8891 = cos(t8882);
float t8892 = (t8890*t8891);
float t8893 = (t118+3.1415927);
float t8894 = (3.1415927*2);
float t8895 = mod(t8893,t8894);
float t8896 = (t8895-3.1415927);
float t8897 = (t8819+3.1415927);
float t8898 = (3.1415927*2);
float t8899 = mod(t8897,t8898);
float t8900 = (t8899-3.1415927);
float t8901 = (t8896-t8900);
float t8902 = abs(t8901);
float t8903 = (t8902/2);
float t8904 = sin(t8903);
float t8905 = (t8904*t8904);
float t8906 = (t8892*t8905);
float t8907 = (t8889+t8906);
float t8908 = sqrt(t8907);
float t8909 = asin(t8908);
float t8910 = (2*t8909);
float t8911 = (t8880-t8910);
float t8912 = abs(t8911);
bool t8913 = (float(1.0e-4)>t8912);
float t8914;
if(t8913){
float t8915 = cos(t8797);
float t8916 = (1*t8915);
float t8917 = sin(t8771);
float t8918 = (1*t8917);
float t8919 = cos(t8819);
float t8920 = (t8918*t8919);
float t8921 = (t8916*t8920);
float t8922 = sin(t8797);
float t8923 = (1*t8922);
float t8924 = cos(t8835);
float t8925 = (t8923*t8924);
float t8926 = cos(t8771);
float t8927 = (1*t8926);
float t8928 = (t8925*t8927);
float t8929 = (t8921-t8928);
float t8930 = sin(t8);
float t8931 = (1*t8930);
float t8932 = sin(t118);
float t8933 = (t8931*t8932);
float t8934 = (t8929*t8933);
float t8935 = sin(t8771);
float t8936 = (1*t8935);
float t8937 = sin(t8819);
float t8938 = (t8936*t8937);
float t8939 = (t8925*t8938);
float t8940 = sin(t8797);
float t8941 = (1*t8940);
float t8942 = sin(t8835);
float t8943 = (t8941*t8942);
float t8944 = (t8943*t8920);
float t8945 = (t8939-t8944);
float t8946 = cos(t8);
float t8947 = (1*t8946);
float t8948 = (t8945*t8947);
float t8949 = (t8934+t8948);
float t8950 = (t8943*t8927);
float t8951 = (t8916*t8938);
float t8952 = (t8950-t8951);
float t8953 = sin(t8);
float t8954 = (1*t8953);
float t8955 = cos(t118);
float t8956 = (t8954*t8955);
float t8957 = (t8952*t8956);
float t8958 = (t8949+t8957);
float t8959 = abs(t8958);
t8914 = t8959;
} else {
float t8960 = (3.1415927/2);
float t8961 = (t8-t8960);
float t8962 = (3.1415927/2);
float t8963 = (t8771-t8962);
float t8964 = (t8961-t8963);
float t8965 = abs(t8964);
float t8966 = (t8965/2);
float t8967 = sin(t8966);
float t8968 = (t8967*t8967);
float t8969 = cos(t8963);
float t8970 = cos(t8961);
float t8971 = (t8969*t8970);
float t8972 = (t118+3.1415927);
float t8973 = (3.1415927*2);
float t8974 = mod(t8972,t8973);
float t8975 = (t8974-3.1415927);
float t8976 = (t8819+3.1415927);
float t8977 = (3.1415927*2);
float t8978 = mod(t8976,t8977);
float t8979 = (t8978-3.1415927);
float t8980 = (t8975-t8979);
float t8981 = abs(t8980);
float t8982 = (t8981/2);
float t8983 = sin(t8982);
float t8984 = (t8983*t8983);
float t8985 = (t8971*t8984);
float t8986 = (t8968+t8985);
float t8987 = sqrt(t8986);
float t8988 = asin(t8987);
float t8989 = (2*t8988);
float t8990 = abs(t8989);
float t8991 = (3.1415927/2);
float t8992 = (t8-t8991);
float t8993 = (3.1415927/2);
float t8994 = (t8797-t8993);
float t8995 = (t8992-t8994);
float t8996 = abs(t8995);
float t8997 = (t8996/2);
float t8998 = sin(t8997);
float t8999 = (t8998*t8998);
float t9000 = cos(t8994);
float t9001 = cos(t8992);
float t9002 = (t9000*t9001);
float t9003 = (t118+3.1415927);
float t9004 = (3.1415927*2);
float t9005 = mod(t9003,t9004);
float t9006 = (t9005-3.1415927);
float t9007 = (t8835+3.1415927);
float t9008 = (3.1415927*2);
float t9009 = mod(t9007,t9008);
float t9010 = (t9009-3.1415927);
float t9011 = (t9006-t9010);
float t9012 = abs(t9011);
float t9013 = (t9012/2);
float t9014 = sin(t9013);
float t9015 = (t9014*t9014);
float t9016 = (t9002*t9015);
float t9017 = (t8999+t9016);
float t9018 = sqrt(t9017);
float t9019 = asin(t9018);
float t9020 = (2*t9019);
float t9021 = abs(t9020);
bool t9022 = (t8990>=t9021);
float t9023;
if(t9022){
t9023 = t8990;
} else {
t9023 = t9021;
}
t8914 = t9023;
}
float t9024 = abs(t8914);
float t9025 = step(float(2.0e-4),t9024);
float t9026 = (1-t9025);
float t9027 = (t6113*t8754);
float t9028 = (t9027*float(842.378));
float t9029 = fract(t9028);
float t9030 = (t9029+float(45.32));
float t9031 = (t9030+u6.u0);
float t9032 = (t9029*t9031);
float t9033 = (t7149*t5450);
float t9034 = (t9033*float(1734.048));
float t9035 = fract(t9034);
float t9036 = (t9035+float(45.32));
float t9037 = (t9036+u6.u0);
float t9038 = (t9035*t9037);
float t9039 = (t9032+t9038);
float t9040 = (t9029+t9039);
float t9041 = (t9035+t9039);
float t9042 = (t9040*t9041);
float t9043 = fract(t9042);
float t9044 = step(float(0.2),t9043);
float t9045 = (t9026*t9044);
float t9046 = (3.1415927/2);
float t9047 = (t8771-t9046);
float t9048 = (3.1415927/2);
float t9049 = (t8797-t9048);
float t9050 = (t9047-t9049);
float t9051 = abs(t9050);
float t9052 = (t9051/2);
float t9053 = sin(t9052);
float t9054 = (t9053*t9053);
float t9055 = cos(t9049);
float t9056 = cos(t9047);
float t9057 = (t9055*t9056);
float t9058 = (t8819+3.1415927);
float t9059 = (3.1415927*2);
float t9060 = mod(t9058,t9059);
float t9061 = (t9060-3.1415927);
float t9062 = (t8835+3.1415927);
float t9063 = (3.1415927*2);
float t9064 = mod(t9062,t9063);
float t9065 = (t9064-3.1415927);
float t9066 = (t9061-t9065);
float t9067 = abs(t9066);
float t9068 = (t9067/2);
float t9069 = sin(t9068);
float t9070 = (t9069*t9069);
float t9071 = (t9057*t9070);
float t9072 = (t9054+t9071);
float t9073 = sqrt(t9072);
float t9074 = asin(t9073);
float t9075 = (2*t9074);
float t9076 = (t9075/t5448);
float t9077 = (1-t9076);
float t9078 = (t6113/85);
float t9079 = (t9078*float(842.378));
float t9080 = fract(t9079);
float t9081 = (t9080+float(45.32));
float t9082 = (t9081+u6.u0);
float t9083 = (t9080*t9082);
float t9084 = (t7149/t6126);
float t9085 = (t9084*float(1734.048));
float t9086 = fract(t9085);
float t9087 = (t9086+float(45.32));
float t9088 = (t9087+u6.u0);
float t9089 = (t9086*t9088);
float t9090 = (t9083+t9089);
float t9091 = (t9080+t9090);
float t9092 = (t9086+t9090);
float t9093 = (t9091*t9092);
float t9094 = fract(t9093);
float t9095 = (t9094*float(8.0e-3));
float t9096 = (float(1.0e-3)+t9095);
float t9097 = (t9094*173);
float t9098 = fract(t9097);
float t9099 = step(float(0.66),t9098);
float t9100 = (t9099*float(3.0e-3));
float t9101 = (t9096-t9100);
float t9102 = (t9101*float(0.45));
float t9103 = (t5450/85);
float t9104 = (t9103*float(842.378));
float t9105 = fract(t9104);
float t9106 = (t9105+float(45.32));
float t9107 = (t9106+u6.u0);
float t9108 = (t9105*t9107);
float t9109 = (t8754/t6126);
float t9110 = (t9109*float(1734.048));
float t9111 = fract(t9110);
float t9112 = (t9111+float(45.32));
float t9113 = (t9112+u6.u0);
float t9114 = (t9111*t9113);
float t9115 = (t9108+t9114);
float t9116 = (t9105+t9115);
float t9117 = (t9111+t9115);
float t9118 = (t9116*t9117);
float t9119 = fract(t9118);
float t9120 = (t9119*float(8.0e-3));
float t9121 = (float(1.0e-3)+t9120);
float t9122 = (t9119*173);
float t9123 = fract(t9122);
float t9124 = step(float(0.66),t9123);
float t9125 = (t9124*float(3.0e-3));
float t9126 = (t9121-t9125);
float t9127 = (t9126*float(0.45));
float t9128 = (t9102-t9127);
float t9129 = abs(t9128);
float t9130 = (t9129-float(1.0e-3));
float t9131 = (t9130/float(8.0e-3));
float t9132 = (1-t9131);
float t9133 = (t9132*t9132);
float t9134 = (t9077*t9133);
float t9135 = (t9045*t9134);
float t9136 = (u4.u0*t9043);
float t9137 = (t9136*3);
float t9138 = sin(t9137);
float t9139 = (t9138+1);
float t9140 = (t9139/2);
float t9141 = (t9140*float(0.66));
float t9142 = (t9141+float(0.33));
float t9143 = (t9135*t9142);
float t9144 = (float(0.2)*t9143);
bool t9145 = (0>=t9144);
float t9146;
if(t9145){
t9146 = 0;
} else {
t9146 = t9144;
}
float t9147 = (t9146*0);
float t9148 = (t8746+t9147);
float t9149 = (t5450*t5448);
float t9150 = (t5450/85);
float t9151 = (t9150*float(842.378));
float t9152 = fract(t9151);
float t9153 = (t9152+float(45.32));
float t9154 = (t9153+u6.u0);
float t9155 = (t9152*t9154);
float t9156 = (t8754/t6126);
float t9157 = (t9156*float(1734.048));
float t9158 = fract(t9157);
float t9159 = (t9158+float(45.32));
float t9160 = (t9159+u6.u0);
float t9161 = (t9158*t9160);
float t9162 = (t9155+t9161);
float t9163 = (t9152+t9162);
float t9164 = (t9158+t9162);
float t9165 = (t9163*t9164);
float t9166 = fract(t9165);
float t9167 = (t9166*float(2852.02));
float t9168 = fract(t9167);
float t9169 = (t9168-float(0.5));
float t9170 = (t9169*t5448);
float t9171 = (t9170*float(0.75));
float t9172 = (t9149+t9171);
float t9173 = (3.1415927/2);
float t9174 = (t9172-t9173);
float t9175 = (t5450*t5448);
float t9176 = (t5450/85);
float t9177 = (t9176*float(842.378));
float t9178 = fract(t9177);
float t9179 = (t9178+float(45.32));
float t9180 = (t9179+u6.u0);
float t9181 = (t9178*t9180);
float t9182 = (t5902/t5463);
float t9183 = (t9182*float(1734.048));
float t9184 = fract(t9183);
float t9185 = (t9184+float(45.32));
float t9186 = (t9185+u6.u0);
float t9187 = (t9184*t9186);
float t9188 = (t9181+t9187);
float t9189 = (t9178+t9188);
float t9190 = (t9184+t9188);
float t9191 = (t9189*t9190);
float t9192 = fract(t9191);
float t9193 = (t9192*float(2852.02));
float t9194 = fract(t9193);
float t9195 = (t9194-float(0.5));
float t9196 = (t9195*t5448);
float t9197 = (t9196*float(0.75));
float t9198 = (t9175+t9197);
float t9199 = (3.1415927/2);
float t9200 = (t9198-t9199);
float t9201 = (t9174-t9200);
float t9202 = abs(t9201);
float t9203 = (t9202/2);
float t9204 = sin(t9203);
float t9205 = (t9204*t9204);
float t9206 = cos(t9200);
float t9207 = cos(t9174);
float t9208 = (t9206*t9207);
float t9209 = (3.1415927/t6126);
float t9210 = (t8754*t9209);
float t9211 = (t9166*float(97372.83));
float t9212 = fract(t9211);
float t9213 = (t9212-float(0.5));
float t9214 = (3.1415927/t6126);
float t9215 = (t9213*t9214);
float t9216 = (t9215*float(0.75));
float t9217 = (t9210+t9216);
float t9218 = (t9217+3.1415927);
float t9219 = mod(t9218,t1433);
float t9220 = (t9219-3.1415927);
float t9221 = (t9220+3.1415927);
float t9222 = (3.1415927*2);
float t9223 = mod(t9221,t9222);
float t9224 = (t9223-3.1415927);
float t9225 = (3.1415927/t5463);
float t9226 = (t5902*t9225);
float t9227 = (t9192*float(97372.83));
float t9228 = fract(t9227);
float t9229 = (t9228-float(0.5));
float t9230 = (3.1415927/t5463);
float t9231 = (t9229*t9230);
float t9232 = (t9231*float(0.75));
float t9233 = (t9226+t9232);
float t9234 = (t9233+3.1415927);
float t9235 = mod(t9234,t1433);
float t9236 = (t9235-3.1415927);
float t9237 = (t9236+3.1415927);
float t9238 = (3.1415927*2);
float t9239 = mod(t9237,t9238);
float t9240 = (t9239-3.1415927);
float t9241 = (t9224-t9240);
float t9242 = abs(t9241);
float t9243 = (t9242/2);
float t9244 = sin(t9243);
float t9245 = (t9244*t9244);
float t9246 = (t9208*t9245);
float t9247 = (t9205+t9246);
float t9248 = sqrt(t9247);
float t9249 = asin(t9248);
float t9250 = (2*t9249);
float t9251 = (3.1415927/2);
float t9252 = (t8-t9251);
float t9253 = (3.1415927/2);
float t9254 = (t9198-t9253);
float t9255 = (t9252-t9254);
float t9256 = abs(t9255);
float t9257 = (t9256/2);
float t9258 = sin(t9257);
float t9259 = (t9258*t9258);
float t9260 = cos(t9254);
float t9261 = cos(t9252);
float t9262 = (t9260*t9261);
float t9263 = (t118+3.1415927);
float t9264 = (3.1415927*2);
float t9265 = mod(t9263,t9264);
float t9266 = (t9265-3.1415927);
float t9267 = (t9236+3.1415927);
float t9268 = (3.1415927*2);
float t9269 = mod(t9267,t9268);
float t9270 = (t9269-3.1415927);
float t9271 = (t9266-t9270);
float t9272 = abs(t9271);
float t9273 = (t9272/2);
float t9274 = sin(t9273);
float t9275 = (t9274*t9274);
float t9276 = (t9262*t9275);
float t9277 = (t9259+t9276);
float t9278 = sqrt(t9277);
float t9279 = asin(t9278);
float t9280 = (2*t9279);
float t9281 = (t9250-t9280);
float t9282 = (3.1415927/2);
float t9283 = (t8-t9282);
float t9284 = (3.1415927/2);
float t9285 = (t9172-t9284);
float t9286 = (t9283-t9285);
float t9287 = abs(t9286);
float t9288 = (t9287/2);
float t9289 = sin(t9288);
float t9290 = (t9289*t9289);
float t9291 = cos(t9285);
float t9292 = cos(t9283);
float t9293 = (t9291*t9292);
float t9294 = (t118+3.1415927);
float t9295 = (3.1415927*2);
float t9296 = mod(t9294,t9295);
float t9297 = (t9296-3.1415927);
float t9298 = (t9220+3.1415927);
float t9299 = (3.1415927*2);
float t9300 = mod(t9298,t9299);
float t9301 = (t9300-3.1415927);
float t9302 = (t9297-t9301);
float t9303 = abs(t9302);
float t9304 = (t9303/2);
float t9305 = sin(t9304);
float t9306 = (t9305*t9305);
float t9307 = (t9293*t9306);
float t9308 = (t9290+t9307);
float t9309 = sqrt(t9308);
float t9310 = asin(t9309);
float t9311 = (2*t9310);
float t9312 = (t9281-t9311);
float t9313 = abs(t9312);
bool t9314 = (float(1.0e-4)>t9313);
float t9315;
if(t9314){
float t9316 = cos(t9198);
float t9317 = (1*t9316);
float t9318 = sin(t9172);
float t9319 = (1*t9318);
float t9320 = cos(t9220);
float t9321 = (t9319*t9320);
float t9322 = (t9317*t9321);
float t9323 = sin(t9198);
float t9324 = (1*t9323);
float t9325 = cos(t9236);
float t9326 = (t9324*t9325);
float t9327 = cos(t9172);
float t9328 = (1*t9327);
float t9329 = (t9326*t9328);
float t9330 = (t9322-t9329);
float t9331 = sin(t8);
float t9332 = (1*t9331);
float t9333 = sin(t118);
float t9334 = (t9332*t9333);
float t9335 = (t9330*t9334);
float t9336 = sin(t9172);
float t9337 = (1*t9336);
float t9338 = sin(t9220);
float t9339 = (t9337*t9338);
float t9340 = (t9326*t9339);
float t9341 = sin(t9198);
float t9342 = (1*t9341);
float t9343 = sin(t9236);
float t9344 = (t9342*t9343);
float t9345 = (t9344*t9321);
float t9346 = (t9340-t9345);
float t9347 = cos(t8);
float t9348 = (1*t9347);
float t9349 = (t9346*t9348);
float t9350 = (t9335+t9349);
float t9351 = (t9344*t9328);
float t9352 = (t9317*t9339);
float t9353 = (t9351-t9352);
float t9354 = sin(t8);
float t9355 = (1*t9354);
float t9356 = cos(t118);
float t9357 = (t9355*t9356);
float t9358 = (t9353*t9357);
float t9359 = (t9350+t9358);
float t9360 = abs(t9359);
t9315 = t9360;
} else {
float t9361 = (3.1415927/2);
float t9362 = (t8-t9361);
float t9363 = (3.1415927/2);
float t9364 = (t9172-t9363);
float t9365 = (t9362-t9364);
float t9366 = abs(t9365);
float t9367 = (t9366/2);
float t9368 = sin(t9367);
float t9369 = (t9368*t9368);
float t9370 = cos(t9364);
float t9371 = cos(t9362);
float t9372 = (t9370*t9371);
float t9373 = (t118+3.1415927);
float t9374 = (3.1415927*2);
float t9375 = mod(t9373,t9374);
float t9376 = (t9375-3.1415927);
float t9377 = (t9220+3.1415927);
float t9378 = (3.1415927*2);
float t9379 = mod(t9377,t9378);
float t9380 = (t9379-3.1415927);
float t9381 = (t9376-t9380);
float t9382 = abs(t9381);
float t9383 = (t9382/2);
float t9384 = sin(t9383);
float t9385 = (t9384*t9384);
float t9386 = (t9372*t9385);
float t9387 = (t9369+t9386);
float t9388 = sqrt(t9387);
float t9389 = asin(t9388);
float t9390 = (2*t9389);
float t9391 = abs(t9390);
float t9392 = (3.1415927/2);
float t9393 = (t8-t9392);
float t9394 = (3.1415927/2);
float t9395 = (t9198-t9394);
float t9396 = (t9393-t9395);
float t9397 = abs(t9396);
float t9398 = (t9397/2);
float t9399 = sin(t9398);
float t9400 = (t9399*t9399);
float t9401 = cos(t9395);
float t9402 = cos(t9393);
float t9403 = (t9401*t9402);
float t9404 = (t118+3.1415927);
float t9405 = (3.1415927*2);
float t9406 = mod(t9404,t9405);
float t9407 = (t9406-3.1415927);
float t9408 = (t9236+3.1415927);
float t9409 = (3.1415927*2);
float t9410 = mod(t9408,t9409);
float t9411 = (t9410-3.1415927);
float t9412 = (t9407-t9411);
float t9413 = abs(t9412);
float t9414 = (t9413/2);
float t9415 = sin(t9414);
float t9416 = (t9415*t9415);
float t9417 = (t9403*t9416);
float t9418 = (t9400+t9417);
float t9419 = sqrt(t9418);
float t9420 = asin(t9419);
float t9421 = (2*t9420);
float t9422 = abs(t9421);
bool t9423 = (t9391>=t9422);
float t9424;
if(t9423){
t9424 = t9391;
} else {
t9424 = t9422;
}
t9315 = t9424;
}
float t9425 = abs(t9315);
float t9426 = step(float(2.0e-4),t9425);
float t9427 = (1-t9426);
float t9428 = (t5450*t8754);
float t9429 = (t9428*float(842.378));
float t9430 = fract(t9429);
float t9431 = (t9430+float(45.32));
float t9432 = (t9431+u6.u0);
float t9433 = (t9430*t9432);
float t9434 = (t5902*t5450);
float t9435 = (t9434*float(1734.048));
float t9436 = fract(t9435);
float t9437 = (t9436+float(45.32));
float t9438 = (t9437+u6.u0);
float t9439 = (t9436*t9438);
float t9440 = (t9433+t9439);
float t9441 = (t9430+t9440);
float t9442 = (t9436+t9440);
float t9443 = (t9441*t9442);
float t9444 = fract(t9443);
float t9445 = step(float(0.2),t9444);
float t9446 = (t9427*t9445);
float t9447 = (3.1415927/2);
float t9448 = (t9172-t9447);
float t9449 = (3.1415927/2);
float t9450 = (t9198-t9449);
float t9451 = (t9448-t9450);
float t9452 = abs(t9451);
float t9453 = (t9452/2);
float t9454 = sin(t9453);
float t9455 = (t9454*t9454);
float t9456 = cos(t9450);
float t9457 = cos(t9448);
float t9458 = (t9456*t9457);
float t9459 = (t9220+3.1415927);
float t9460 = (3.1415927*2);
float t9461 = mod(t9459,t9460);
float t9462 = (t9461-3.1415927);
float t9463 = (t9236+3.1415927);
float t9464 = (3.1415927*2);
float t9465 = mod(t9463,t9464);
float t9466 = (t9465-3.1415927);
float t9467 = (t9462-t9466);
float t9468 = abs(t9467);
float t9469 = (t9468/2);
float t9470 = sin(t9469);
float t9471 = (t9470*t9470);
float t9472 = (t9458*t9471);
float t9473 = (t9455+t9472);
float t9474 = sqrt(t9473);
float t9475 = asin(t9474);
float t9476 = (2*t9475);
float t9477 = (t9476/t5448);
float t9478 = (1-t9477);
float t9479 = (t5450/85);
float t9480 = (t9479*float(842.378));
float t9481 = fract(t9480);
float t9482 = (t9481+float(45.32));
float t9483 = (t9482+u6.u0);
float t9484 = (t9481*t9483);
float t9485 = (t5902/t5463);
float t9486 = (t9485*float(1734.048));
float t9487 = fract(t9486);
float t9488 = (t9487+float(45.32));
float t9489 = (t9488+u6.u0);
float t9490 = (t9487*t9489);
float t9491 = (t9484+t9490);
float t9492 = (t9481+t9491);
float t9493 = (t9487+t9491);
float t9494 = (t9492*t9493);
float t9495 = fract(t9494);
float t9496 = (t9495*float(8.0e-3));
float t9497 = (float(1.0e-3)+t9496);
float t9498 = (t9495*173);
float t9499 = fract(t9498);
float t9500 = step(float(0.66),t9499);
float t9501 = (t9500*float(3.0e-3));
float t9502 = (t9497-t9501);
float t9503 = (t9502*float(0.45));
float t9504 = (t5450/85);
float t9505 = (t9504*float(842.378));
float t9506 = fract(t9505);
float t9507 = (t9506+float(45.32));
float t9508 = (t9507+u6.u0);
float t9509 = (t9506*t9508);
float t9510 = (t8754/t6126);
float t9511 = (t9510*float(1734.048));
float t9512 = fract(t9511);
float t9513 = (t9512+float(45.32));
float t9514 = (t9513+u6.u0);
float t9515 = (t9512*t9514);
float t9516 = (t9509+t9515);
float t9517 = (t9506+t9516);
float t9518 = (t9512+t9516);
float t9519 = (t9517*t9518);
float t9520 = fract(t9519);
float t9521 = (t9520*float(8.0e-3));
float t9522 = (float(1.0e-3)+t9521);
float t9523 = (t9520*173);
float t9524 = fract(t9523);
float t9525 = step(float(0.66),t9524);
float t9526 = (t9525*float(3.0e-3));
float t9527 = (t9522-t9526);
float t9528 = (t9527*float(0.45));
float t9529 = (t9503-t9528);
float t9530 = abs(t9529);
float t9531 = (t9530-float(1.0e-3));
float t9532 = (t9531/float(8.0e-3));
float t9533 = (1-t9532);
float t9534 = (t9533*t9533);
float t9535 = (t9478*t9534);
float t9536 = (t9446*t9535);
float t9537 = (u4.u0*t9444);
float t9538 = (t9537*3);
float t9539 = sin(t9538);
float t9540 = (t9539+1);
float t9541 = (t9540/2);
float t9542 = (t9541*float(0.66));
float t9543 = (t9542+float(0.33));
float t9544 = (t9536*t9543);
float t9545 = (float(0.2)*t9544);
bool t9546 = (0>=t9545);
float t9547;
if(t9546){
t9547 = 0;
} else {
t9547 = t9545;
}
float t9548 = (t9547*0);
float t9549 = (t9148+t9548);
float t9550 = (t9549*float(0.33));
float t9551 = (t5447+t9550);
float t9552 = cos(float(1.46));
float t9553 = (1*t9552);
float t9554 = sin(float(1.15));
float t9555 = (1*t9554);
float t9556 = (-float(0.24));
float t9557 = cos(t9556);
float t9558 = (t9555*t9557);
float t9559 = (t9553*t9558);
float t9560 = sin(float(1.46));
float t9561 = (1*t9560);
float t9562 = (float(0.93)*float(842.378));
float t9563 = fract(t9562);
float t9564 = (t9563+float(45.32));
float t9565 = (t9564+u6.u0);
float t9566 = (t9563*t9565);
float t9567 = (float(1.245)*float(1734.048));
float t9568 = fract(t9567);
float t9569 = (t9568+float(45.32));
float t9570 = (t9569+u6.u0);
float t9571 = (t9568*t9570);
float t9572 = (t9566+t9571);
float t9573 = (t9563+t9572);
float t9574 = (t9568+t9572);
float t9575 = (t9573*t9574);
float t9576 = fract(t9575);
float t9577 = (t9576*3.1415927);
float t9578 = cos(t9577);
float t9579 = (t9561*t9578);
float t9580 = cos(float(1.15));
float t9581 = (1*t9580);
float t9582 = (t9579*t9581);
float t9583 = (t9559-t9582);
float t9584 = sin(t8);
float t9585 = (1*t9584);
float t9586 = sin(t118);
float t9587 = (t9585*t9586);
float t9588 = (t9583*t9587);
float t9589 = sin(float(1.15));
float t9590 = (1*t9589);
float t9591 = sin(t9556);
float t9592 = (t9590*t9591);
float t9593 = (t9579*t9592);
float t9594 = sin(float(1.46));
float t9595 = (1*t9594);
float t9596 = sin(t9577);
float t9597 = (t9595*t9596);
float t9598 = (t9597*t9558);
float t9599 = (t9593-t9598);
float t9600 = cos(t8);
float t9601 = (1*t9600);
float t9602 = (t9599*t9601);
float t9603 = (t9588+t9602);
float t9604 = (t9597*t9581);
float t9605 = (t9553*t9592);
float t9606 = (t9604-t9605);
float t9607 = sin(t8);
float t9608 = (1*t9607);
float t9609 = cos(t118);
float t9610 = (t9608*t9609);
float t9611 = (t9606*t9610);
float t9612 = (t9603+t9611);
float t9613 = abs(t9612);
float t9614 = (t8/3.1415927);
float t9615 = fract(t9614);
float t9616 = (t9615*16);
float t9617 = floor(t9616);
float t9618 = (t9617*float(842.378));
float t9619 = fract(t9618);
float t9620 = (t9619+float(45.32));
float t9621 = (t9620+u6.u0);
float t9622 = (t9619*t9621);
float t9623 = (t118/3.1415927);
float t9624 = fract(t9623);
float t9625 = (t9624*16);
float t9626 = floor(t9625);
float t9627 = (t9626*float(1734.048));
float t9628 = fract(t9627);
float t9629 = (t9628+float(45.32));
float t9630 = (t9629+u6.u0);
float t9631 = (t9628*t9630);
float t9632 = (t9622+t9631);
float t9633 = (t9619+t9632);
float t9634 = (t9628+t9632);
float t9635 = (t9633*t9634);
float t9636 = fract(t9635);
float t9637 = fract(t9616);
float t9638 = (t9637*3.1415927);
float t9639 = cos(t9638);
float t9640 = (t9639/2);
float t9641 = (t9640+float(0.5));
float t9642 = (1-t9641);
float t9643 = (1-t9642);
float t9644 = (t9636*t9643);
float t9645 = (t9617+1);
float t9646 = mod(t9645,16);
float t9647 = (t9646*float(842.378));
float t9648 = fract(t9647);
float t9649 = (t9648+float(45.32));
float t9650 = (t9649+u6.u0);
float t9651 = (t9648*t9650);
float t9652 = (t9626*float(1734.048));
float t9653 = fract(t9652);
float t9654 = (t9653+float(45.32));
float t9655 = (t9654+u6.u0);
float t9656 = (t9653*t9655);
float t9657 = (t9651+t9656);
float t9658 = (t9648+t9657);
float t9659 = (t9653+t9657);
float t9660 = (t9658*t9659);
float t9661 = fract(t9660);
float t9662 = (t9661*t9642);
float t9663 = (t9644+t9662);
float t9664 = fract(t9625);
float t9665 = (t9664*3.1415927);
float t9666 = cos(t9665);
float t9667 = (t9666/2);
float t9668 = (t9667+float(0.5));
float t9669 = (1-t9668);
float t9670 = (1-t9669);
float t9671 = (t9663*t9670);
float t9672 = (t9617*float(842.378));
float t9673 = fract(t9672);
float t9674 = (t9673+float(45.32));
float t9675 = (t9674+u6.u0);
float t9676 = (t9673*t9675);
float t9677 = (t9626+1);
float t9678 = mod(t9677,16);
float t9679 = (t9678*float(1734.048));
float t9680 = fract(t9679);
float t9681 = (t9680+float(45.32));
float t9682 = (t9681+u6.u0);
float t9683 = (t9680*t9682);
float t9684 = (t9676+t9683);
float t9685 = (t9673+t9684);
float t9686 = (t9680+t9684);
float t9687 = (t9685*t9686);
float t9688 = fract(t9687);
float t9689 = (t9688*t9643);
float t9690 = (t9646*float(842.378));
float t9691 = fract(t9690);
float t9692 = (t9691+float(45.32));
float t9693 = (t9692+u6.u0);
float t9694 = (t9691*t9693);
float t9695 = (t9678*float(1734.048));
float t9696 = fract(t9695);
float t9697 = (t9696+float(45.32));
float t9698 = (t9697+u6.u0);
float t9699 = (t9696*t9698);
float t9700 = (t9694+t9699);
float t9701 = (t9691+t9700);
float t9702 = (t9696+t9700);
float t9703 = (t9701*t9702);
float t9704 = fract(t9703);
float t9705 = (t9704*t9642);
float t9706 = (t9689+t9705);
float t9707 = (t9706*t9669);
float t9708 = (t9671+t9707);
float t9709 = (t9708*float(0.5));
float t9710 = (t9615*32);
float t9711 = floor(t9710);
float t9712 = (t9711*float(842.378));
float t9713 = fract(t9712);
float t9714 = (t9713+float(45.32));
float t9715 = (t9714+u6.u0);
float t9716 = (t9713*t9715);
float t9717 = (t9624*32);
float t9718 = floor(t9717);
float t9719 = (t9718*float(1734.048));
float t9720 = fract(t9719);
float t9721 = (t9720+float(45.32));
float t9722 = (t9721+u6.u0);
float t9723 = (t9720*t9722);
float t9724 = (t9716+t9723);
float t9725 = (t9713+t9724);
float t9726 = (t9720+t9724);
float t9727 = (t9725*t9726);
float t9728 = fract(t9727);
float t9729 = fract(t9710);
float t9730 = (t9729*3.1415927);
float t9731 = cos(t9730);
float t9732 = (t9731/2);
float t9733 = (t9732+float(0.5));
float t9734 = (1-t9733);
float t9735 = (1-t9734);
float t9736 = (t9728*t9735);
float t9737 = (t9711+1);
float t9738 = mod(t9737,32);
float t9739 = (t9738*float(842.378));
float t9740 = fract(t9739);
float t9741 = (t9740+float(45.32));
float t9742 = (t9741+u6.u0);
float t9743 = (t9740*t9742);
float t9744 = (t9718*float(1734.048));
float t9745 = fract(t9744);
float t9746 = (t9745+float(45.32));
float t9747 = (t9746+u6.u0);
float t9748 = (t9745*t9747);
float t9749 = (t9743+t9748);
float t9750 = (t9740+t9749);
float t9751 = (t9745+t9749);
float t9752 = (t9750*t9751);
float t9753 = fract(t9752);
float t9754 = (t9753*t9734);
float t9755 = (t9736+t9754);
float t9756 = fract(t9717);
float t9757 = (t9756*3.1415927);
float t9758 = cos(t9757);
float t9759 = (t9758/2);
float t9760 = (t9759+float(0.5));
float t9761 = (1-t9760);
float t9762 = (1-t9761);
float t9763 = (t9755*t9762);
float t9764 = (t9711*float(842.378));
float t9765 = fract(t9764);
float t9766 = (t9765+float(45.32));
float t9767 = (t9766+u6.u0);
float t9768 = (t9765*t9767);
float t9769 = (t9718+1);
float t9770 = mod(t9769,32);
float t9771 = (t9770*float(1734.048));
float t9772 = fract(t9771);
float t9773 = (t9772+float(45.32));
float t9774 = (t9773+u6.u0);
float t9775 = (t9772*t9774);
float t9776 = (t9768+t9775);
float t9777 = (t9765+t9776);
float t9778 = (t9772+t9776);
float t9779 = (t9777*t9778);
float t9780 = fract(t9779);
float t9781 = (t9780*t9735);
float t9782 = (t9738*float(842.378));
float t9783 = fract(t9782);
float t9784 = (t9783+float(45.32));
float t9785 = (t9784+u6.u0);
float t9786 = (t9783*t9785);
float t9787 = (t9770*float(1734.048));
float t9788 = fract(t9787);
float t9789 = (t9788+float(45.32));
float t9790 = (t9789+u6.u0);
float t9791 = (t9788*t9790);
float t9792 = (t9786+t9791);
float t9793 = (t9783+t9792);
float t9794 = (t9788+t9792);
float t9795 = (t9793*t9794);
float t9796 = fract(t9795);
float t9797 = (t9796*t9734);
float t9798 = (t9781+t9797);
float t9799 = (t9798*t9761);
float t9800 = (t9763+t9799);
float t9801 = (t9800*float(0.25));
float t9802 = (t9709+t9801);
float t9803 = (t9615*64);
float t9804 = floor(t9803);
float t9805 = (t9804*float(842.378));
float t9806 = fract(t9805);
float t9807 = (t9806+float(45.32));
float t9808 = (t9807+u6.u0);
float t9809 = (t9806*t9808);
float t9810 = (t9624*64);
float t9811 = floor(t9810);
float t9812 = (t9811*float(1734.048));
float t9813 = fract(t9812);
float t9814 = (t9813+float(45.32));
float t9815 = (t9814+u6.u0);
float t9816 = (t9813*t9815);
float t9817 = (t9809+t9816);
float t9818 = (t9806+t9817);
float t9819 = (t9813+t9817);
float t9820 = (t9818*t9819);
float t9821 = fract(t9820);
float t9822 = fract(t9803);
float t9823 = (t9822*3.1415927);
float t9824 = cos(t9823);
float t9825 = (t9824/2);
float t9826 = (t9825+float(0.5));
float t9827 = (1-t9826);
float t9828 = (1-t9827);
float t9829 = (t9821*t9828);
float t9830 = (t9804+1);
float t9831 = mod(t9830,64);
float t9832 = (t9831*float(842.378));
float t9833 = fract(t9832);
float t9834 = (t9833+float(45.32));
float t9835 = (t9834+u6.u0);
float t9836 = (t9833*t9835);
float t9837 = (t9811*float(1734.048));
float t9838 = fract(t9837);
float t9839 = (t9838+float(45.32));
float t9840 = (t9839+u6.u0);
float t9841 = (t9838*t9840);
float t9842 = (t9836+t9841);
float t9843 = (t9833+t9842);
float t9844 = (t9838+t9842);
float t9845 = (t9843*t9844);
float t9846 = fract(t9845);
float t9847 = (t9846*t9827);
float t9848 = (t9829+t9847);
float t9849 = fract(t9810);
float t9850 = (t9849*3.1415927);
float t9851 = cos(t9850);
float t9852 = (t9851/2);
float t9853 = (t9852+float(0.5));
float t9854 = (1-t9853);
float t9855 = (1-t9854);
float t9856 = (t9848*t9855);
float t9857 = (t9804*float(842.378));
float t9858 = fract(t9857);
float t9859 = (t9858+float(45.32));
float t9860 = (t9859+u6.u0);
float t9861 = (t9858*t9860);
float t9862 = (t9811+1);
float t9863 = mod(t9862,64);
float t9864 = (t9863*float(1734.048));
float t9865 = fract(t9864);
float t9866 = (t9865+float(45.32));
float t9867 = (t9866+u6.u0);
float t9868 = (t9865*t9867);
float t9869 = (t9861+t9868);
float t9870 = (t9858+t9869);
float t9871 = (t9865+t9869);
float t9872 = (t9870*t9871);
float t9873 = fract(t9872);
float t9874 = (t9873*t9828);
float t9875 = (t9831*float(842.378));
float t9876 = fract(t9875);
float t9877 = (t9876+float(45.32));
float t9878 = (t9877+u6.u0);
float t9879 = (t9876*t9878);
float t9880 = (t9863*float(1734.048));
float t9881 = fract(t9880);
float t9882 = (t9881+float(45.32));
float t9883 = (t9882+u6.u0);
float t9884 = (t9881*t9883);
float t9885 = (t9879+t9884);
float t9886 = (t9876+t9885);
float t9887 = (t9881+t9885);
float t9888 = (t9886*t9887);
float t9889 = fract(t9888);
float t9890 = (t9889*t9827);
float t9891 = (t9874+t9890);
float t9892 = (t9891*t9854);
float t9893 = (t9856+t9892);
float t9894 = (t9893*float(0.125));
float t9895 = (t9802+t9894);
float t9896 = (t9615*128);
float t9897 = floor(t9896);
float t9898 = (t9897*float(842.378));
float t9899 = fract(t9898);
float t9900 = (t9899+float(45.32));
float t9901 = (t9900+u6.u0);
float t9902 = (t9899*t9901);
float t9903 = (t9624*128);
float t9904 = floor(t9903);
float t9905 = (t9904*float(1734.048));
float t9906 = fract(t9905);
float t9907 = (t9906+float(45.32));
float t9908 = (t9907+u6.u0);
float t9909 = (t9906*t9908);
float t9910 = (t9902+t9909);
float t9911 = (t9899+t9910);
float t9912 = (t9906+t9910);
float t9913 = (t9911*t9912);
float t9914 = fract(t9913);
float t9915 = fract(t9896);
float t9916 = (t9915*3.1415927);
float t9917 = cos(t9916);
float t9918 = (t9917/2);
float t9919 = (t9918+float(0.5));
float t9920 = (1-t9919);
float t9921 = (1-t9920);
float t9922 = (t9914*t9921);
float t9923 = (t9897+1);
float t9924 = mod(t9923,128);
float t9925 = (t9924*float(842.378));
float t9926 = fract(t9925);
float t9927 = (t9926+float(45.32));
float t9928 = (t9927+u6.u0);
float t9929 = (t9926*t9928);
float t9930 = (t9904*float(1734.048));
float t9931 = fract(t9930);
float t9932 = (t9931+float(45.32));
float t9933 = (t9932+u6.u0);
float t9934 = (t9931*t9933);
float t9935 = (t9929+t9934);
float t9936 = (t9926+t9935);
float t9937 = (t9931+t9935);
float t9938 = (t9936*t9937);
float t9939 = fract(t9938);
float t9940 = (t9939*t9920);
float t9941 = (t9922+t9940);
float t9942 = fract(t9903);
float t9943 = (t9942*3.1415927);
float t9944 = cos(t9943);
float t9945 = (t9944/2);
float t9946 = (t9945+float(0.5));
float t9947 = (1-t9946);
float t9948 = (1-t9947);
float t9949 = (t9941*t9948);
float t9950 = (t9897*float(842.378));
float t9951 = fract(t9950);
float t9952 = (t9951+float(45.32));
float t9953 = (t9952+u6.u0);
float t9954 = (t9951*t9953);
float t9955 = (t9904+1);
float t9956 = mod(t9955,128);
float t9957 = (t9956*float(1734.048));
float t9958 = fract(t9957);
float t9959 = (t9958+float(45.32));
float t9960 = (t9959+u6.u0);
float t9961 = (t9958*t9960);
float t9962 = (t9954+t9961);
float t9963 = (t9951+t9962);
float t9964 = (t9958+t9962);
float t9965 = (t9963*t9964);
float t9966 = fract(t9965);
float t9967 = (t9966*t9921);
float t9968 = (t9924*float(842.378));
float t9969 = fract(t9968);
float t9970 = (t9969+float(45.32));
float t9971 = (t9970+u6.u0);
float t9972 = (t9969*t9971);
float t9973 = (t9956*float(1734.048));
float t9974 = fract(t9973);
float t9975 = (t9974+float(45.32));
float t9976 = (t9975+u6.u0);
float t9977 = (t9974*t9976);
float t9978 = (t9972+t9977);
float t9979 = (t9969+t9978);
float t9980 = (t9974+t9978);
float t9981 = (t9979*t9980);
float t9982 = fract(t9981);
float t9983 = (t9982*t9920);
float t9984 = (t9967+t9983);
float t9985 = (t9984*t9947);
float t9986 = (t9949+t9985);
float t9987 = (t9986*float(6.25e-2));
float t9988 = (t9895+t9987);
float t9989 = (t9988*float(0.25));
float t9990 = (t9989-float(0.125));
float t9991 = (t9613+t9990);
float t9992 = smoothstep(float(0.0),float(0.32),t9991);
float t9993 = (1-t9992);
float t9994 = (t9993*float(1.1));
float t9995 = fract(t9994);
float t9996 = (t9995*t9995);
float t9997 = (t9996*float(5.0e-2));
float t9998 = (3.1415927/245);
float t9999 = (t8/t9998);
float t10000 = floor(t9999);
float t10001 = (t10000/245);
float t10002 = (t10000/245);
float t10003 = (t10002*float(842.378));
float t10004 = fract(t10003);
float t10005 = (t10004+float(45.32));
float t10006 = (t10005+u6.u0);
float t10007 = (t10004*t10006);
float t10008 = (t10000/245);
float t10009 = (t10008*3.1415927);
float t10010 = sin(t10009);
float t10011 = (245*t10010);
float t10012 = floor(t10011);
float t10013 = (t10012+1);
float t10014 = (3.1415927/t10013);
float t10015 = (t118/t10014);
float t10016 = floor(t10015);
float t10017 = (t10016/t10013);
float t10018 = (t10017*float(1734.048));
float t10019 = fract(t10018);
float t10020 = (t10019+float(45.32));
float t10021 = (t10020+u6.u0);
float t10022 = (t10019*t10021);
float t10023 = (t10007+t10022);
float t10024 = (t10004+t10023);
float t10025 = (t10019+t10023);
float t10026 = (t10024*t10025);
float t10027 = fract(t10026);
float t10028 = (t10027*5);
float t10029 = (t10001+t10028);
float t10030 = fract(t10029);
float t10031 = (t10030*12000);
float t10032 = (t10031/1000);
bool t10033 = (1<=t10032);
float t10034;
if(t10033){
t10034 = 1;
} else {
t10034 = t10032;
}
float t10035 = (t10031-6000);
float t10036 = (t10035/8000);
bool t10037 = (0>=t10036);
float t10038;
if(t10037){
t10038 = 0;
} else {
t10038 = t10036;
}
float t10039 = (t10034-t10038);
float t10040 = (t10027*173);
float t10041 = fract(t10040);
float t10042 = step(float(0.66),t10041);
float t10043 = (t10042*3);
float t10044 = (3+t10043);
float t10045 = (3.1415927/t10044);
float t10046 = cos(t10045);
float t10047 = (1-t10046);
float t10048 = (t10000*t9998);
float t10049 = (t10000/245);
float t10050 = (t10049*float(842.378));
float t10051 = fract(t10050);
float t10052 = (t10051+float(45.32));
float t10053 = (t10052+u6.u0);
float t10054 = (t10051*t10053);
float t10055 = (t10016/t10013);
float t10056 = (t10055*float(1734.048));
float t10057 = fract(t10056);
float t10058 = (t10057+float(45.32));
float t10059 = (t10058+u6.u0);
float t10060 = (t10057*t10059);
float t10061 = (t10054+t10060);
float t10062 = (t10051+t10061);
float t10063 = (t10057+t10061);
float t10064 = (t10062*t10063);
float t10065 = fract(t10064);
float t10066 = (t10065*float(2852.02));
float t10067 = fract(t10066);
float t10068 = (t10067-float(0.5));
float t10069 = (t10068*t9998);
float t10070 = (t10069*float(0.75));
float t10071 = (t10048+t10070);
float t10072 = cos(t10071);
float t10073 = (1*t10072);
float t10074 = (t10073*0);
float t10075 = sin(t10071);
float t10076 = (1*t10075);
float t10077 = (3.1415927/t10013);
float t10078 = (t10016*t10077);
float t10079 = (t10065*float(97372.83));
float t10080 = fract(t10079);
float t10081 = (t10080-float(0.5));
float t10082 = (3.1415927/t10013);
float t10083 = (t10081*t10082);
float t10084 = (t10083*float(0.75));
float t10085 = (t10078+t10084);
float t10086 = (t10085+3.1415927);
float t10087 = mod(t10086,t1433);
float t10088 = (t10087-3.1415927);
float t10089 = cos(t10088);
float t10090 = (t10076*t10089);
float t10091 = (t10090*1);
float t10092 = (t10074-t10091);
float t10093 = sin(t8);
float t10094 = (1*t10093);
float t10095 = sin(t118);
float t10096 = (t10094*t10095);
float t10097 = (t10092*t10096);
float t10098 = (t10090*0);
float t10099 = sin(t10071);
float t10100 = (1*t10099);
float t10101 = sin(t10088);
float t10102 = (t10100*t10101);
float t10103 = (t10102*0);
float t10104 = (t10098-t10103);
float t10105 = cos(t8);
float t10106 = (1*t10105);
float t10107 = (t10104*t10106);
float t10108 = (t10097+t10107);
float t10109 = (t10102*1);
float t10110 = (t10073*0);
float t10111 = (t10109-t10110);
float t10112 = sin(t8);
float t10113 = (1*t10112);
float t10114 = cos(t118);
float t10115 = (t10113*t10114);
float t10116 = (t10111*t10115);
float t10117 = (t10108+t10116);
float t10118 = (t10104*t10090);
float t10119 = (t10111*t10073);
float t10120 = (t10118-t10119);
float t10121 = (t10120*t10096);
float t10122 = (t10111*t10102);
float t10123 = (t10092*t10090);
float t10124 = (t10122-t10123);
float t10125 = (t10124*t10106);
float t10126 = (t10121+t10125);
float t10127 = (t10092*t10073);
float t10128 = (t10104*t10102);
float t10129 = (t10127-t10128);
float t10130 = (t10129*t10115);
float t10131 = (t10126+t10130);
float t10132 = atan(t10117,t10131);
float t10133 = (t10132+3.1415927);
float t10134 = (t10041*3.1415927);
float t10135 = (t10133+t10134);
float t10136 = (t10135/t1483);
float t10137 = fract(t10136);
float t10138 = (t10137*t10044);
float t10139 = fract(t10138);
float t10140 = (t10139*2);
float t10141 = (t10140-1);
float t10142 = abs(t10141);
float t10143 = (t10142*t10142);
float t10144 = (t10047*t10143);
float t10145 = (t10046+t10144);
float t10146 = (t10027*float(8.0e-3));
float t10147 = (float(1.0e-3)+t10146);
float t10148 = step(float(0.66),t10041);
float t10149 = (t10148*float(3.0e-3));
float t10150 = (t10147-t10149);
float t10151 = (t10150*float(0.4));
float t10152 = (t10145*t10151);
float t10153 = (3.1415927/2);
float t10154 = (t10071-t10153);
float t10155 = (3.1415927/2);
float t10156 = (t8-t10155);
float t10157 = (t10154-t10156);
float t10158 = abs(t10157);
float t10159 = (t10158/2);
float t10160 = sin(t10159);
float t10161 = (t10160*t10160);
float t10162 = cos(t10156);
float t10163 = cos(t10154);
float t10164 = (t10162*t10163);
float t10165 = (t10088+3.1415927);
float t10166 = (3.1415927*2);
float t10167 = mod(t10165,t10166);
float t10168 = (t10167-3.1415927);
float t10169 = (t118+3.1415927);
float t10170 = (3.1415927*2);
float t10171 = mod(t10169,t10170);
float t10172 = (t10171-3.1415927);
float t10173 = (t10168-t10172);
float t10174 = abs(t10173);
float t10175 = (t10174/2);
float t10176 = sin(t10175);
float t10177 = (t10176*t10176);
float t10178 = (t10164*t10177);
float t10179 = (t10161+t10178);
float t10180 = sqrt(t10179);
float t10181 = asin(t10180);
float t10182 = (2*t10181);
float t10183 = step(t10152,t10182);
float t10184 = (1-t10183);
float t10185 = (t10039*t10184);
float t10186 = (3.1415927/2);
float t10187 = (t8-t10186);
float t10188 = (3.1415927/2);
float t10189 = (t10071-t10188);
float t10190 = (t10187-t10189);
float t10191 = abs(t10190);
float t10192 = (t10191/2);
float t10193 = sin(t10192);
float t10194 = (t10193*t10193);
float t10195 = cos(t10189);
float t10196 = cos(t10187);
float t10197 = (t10195*t10196);
float t10198 = (t118+3.1415927);
float t10199 = (3.1415927*2);
float t10200 = mod(t10198,t10199);
float t10201 = (t10200-3.1415927);
float t10202 = (t10088+3.1415927);
float t10203 = (3.1415927*2);
float t10204 = mod(t10202,t10203);
float t10205 = (t10204-3.1415927);
float t10206 = (t10201-t10205);
float t10207 = abs(t10206);
float t10208 = (t10207/2);
float t10209 = sin(t10208);
float t10210 = (t10209*t10209);
float t10211 = (t10197*t10210);
float t10212 = (t10194+t10211);
float t10213 = sqrt(t10212);
float t10214 = asin(t10213);
float t10215 = (2*t10214);
float t10216 = (1/t10215);
float t10217 = (t10216*t10151);
float t10218 = (t10217*float(1.25e-2));
float t10219 = (u4.u0*t10027);
float t10220 = cos(t10219);
float t10221 = (t10220+1);
float t10222 = (t10221/2);
float t10223 = (t10218*t10222);
float t10224 = (t10223*t10039);
float t10225 = (t10185+t10224);
float t10226 = (0+t10225);
float t10227 = (t10000/245);
float t10228 = (t10000/245);
float t10229 = (t10228*float(842.378));
float t10230 = fract(t10229);
float t10231 = (t10230+float(45.32));
float t10232 = (t10231+u6.u0);
float t10233 = (t10230*t10232);
float t10234 = (t10016+1);
float t10235 = (t10234/t10013);
float t10236 = (t10235*float(1734.048));
float t10237 = fract(t10236);
float t10238 = (t10237+float(45.32));
float t10239 = (t10238+u6.u0);
float t10240 = (t10237*t10239);
float t10241 = (t10233+t10240);
float t10242 = (t10230+t10241);
float t10243 = (t10237+t10241);
float t10244 = (t10242*t10243);
float t10245 = fract(t10244);
float t10246 = (t10245*5);
float t10247 = (t10227+t10246);
float t10248 = fract(t10247);
float t10249 = (t10248*12000);
float t10250 = (t10249/1000);
bool t10251 = (1<=t10250);
float t10252;
if(t10251){
t10252 = 1;
} else {
t10252 = t10250;
}
float t10253 = (t10249-6000);
float t10254 = (t10253/8000);
bool t10255 = (0>=t10254);
float t10256;
if(t10255){
t10256 = 0;
} else {
t10256 = t10254;
}
float t10257 = (t10252-t10256);
float t10258 = (t10245*173);
float t10259 = fract(t10258);
float t10260 = step(float(0.66),t10259);
float t10261 = (t10260*3);
float t10262 = (3+t10261);
float t10263 = (3.1415927/t10262);
float t10264 = cos(t10263);
float t10265 = (1-t10264);
float t10266 = (t10000*t9998);
float t10267 = (t10000/245);
float t10268 = (t10267*float(842.378));
float t10269 = fract(t10268);
float t10270 = (t10269+float(45.32));
float t10271 = (t10270+u6.u0);
float t10272 = (t10269*t10271);
float t10273 = (t10234/t10013);
float t10274 = (t10273*float(1734.048));
float t10275 = fract(t10274);
float t10276 = (t10275+float(45.32));
float t10277 = (t10276+u6.u0);
float t10278 = (t10275*t10277);
float t10279 = (t10272+t10278);
float t10280 = (t10269+t10279);
float t10281 = (t10275+t10279);
float t10282 = (t10280*t10281);
float t10283 = fract(t10282);
float t10284 = (t10283*float(2852.02));
float t10285 = fract(t10284);
float t10286 = (t10285-float(0.5));
float t10287 = (t10286*t9998);
float t10288 = (t10287*float(0.75));
float t10289 = (t10266+t10288);
float t10290 = cos(t10289);
float t10291 = (1*t10290);
float t10292 = (t10291*0);
float t10293 = sin(t10289);
float t10294 = (1*t10293);
float t10295 = (3.1415927/t10013);
float t10296 = (t10234*t10295);
float t10297 = (t10283*float(97372.83));
float t10298 = fract(t10297);
float t10299 = (t10298-float(0.5));
float t10300 = (3.1415927/t10013);
float t10301 = (t10299*t10300);
float t10302 = (t10301*float(0.75));
float t10303 = (t10296+t10302);
float t10304 = (t10303+3.1415927);
float t10305 = mod(t10304,t1433);
float t10306 = (t10305-3.1415927);
float t10307 = cos(t10306);
float t10308 = (t10294*t10307);
float t10309 = (t10308*1);
float t10310 = (t10292-t10309);
float t10311 = sin(t8);
float t10312 = (1*t10311);
float t10313 = sin(t118);
float t10314 = (t10312*t10313);
float t10315 = (t10310*t10314);
float t10316 = (t10308*0);
float t10317 = sin(t10289);
float t10318 = (1*t10317);
float t10319 = sin(t10306);
float t10320 = (t10318*t10319);
float t10321 = (t10320*0);
float t10322 = (t10316-t10321);
float t10323 = cos(t8);
float t10324 = (1*t10323);
float t10325 = (t10322*t10324);
float t10326 = (t10315+t10325);
float t10327 = (t10320*1);
float t10328 = (t10291*0);
float t10329 = (t10327-t10328);
float t10330 = sin(t8);
float t10331 = (1*t10330);
float t10332 = cos(t118);
float t10333 = (t10331*t10332);
float t10334 = (t10329*t10333);
float t10335 = (t10326+t10334);
float t10336 = (t10322*t10308);
float t10337 = (t10329*t10291);
float t10338 = (t10336-t10337);
float t10339 = (t10338*t10314);
float t10340 = (t10329*t10320);
float t10341 = (t10310*t10308);
float t10342 = (t10340-t10341);
float t10343 = (t10342*t10324);
float t10344 = (t10339+t10343);
float t10345 = (t10310*t10291);
float t10346 = (t10322*t10320);
float t10347 = (t10345-t10346);
float t10348 = (t10347*t10333);
float t10349 = (t10344+t10348);
float t10350 = atan(t10335,t10349);
float t10351 = (t10350+3.1415927);
float t10352 = (t10259*3.1415927);
float t10353 = (t10351+t10352);
float t10354 = (t10353/t1483);
float t10355 = fract(t10354);
float t10356 = (t10355*t10262);
float t10357 = fract(t10356);
float t10358 = (t10357*2);
float t10359 = (t10358-1);
float t10360 = abs(t10359);
float t10361 = (t10360*t10360);
float t10362 = (t10265*t10361);
float t10363 = (t10264+t10362);
float t10364 = (t10245*float(8.0e-3));
float t10365 = (float(1.0e-3)+t10364);
float t10366 = step(float(0.66),t10259);
float t10367 = (t10366*float(3.0e-3));
float t10368 = (t10365-t10367);
float t10369 = (t10368*float(0.4));
float t10370 = (t10363*t10369);
float t10371 = (3.1415927/2);
float t10372 = (t10289-t10371);
float t10373 = (3.1415927/2);
float t10374 = (t8-t10373);
float t10375 = (t10372-t10374);
float t10376 = abs(t10375);
float t10377 = (t10376/2);
float t10378 = sin(t10377);
float t10379 = (t10378*t10378);
float t10380 = cos(t10374);
float t10381 = cos(t10372);
float t10382 = (t10380*t10381);
float t10383 = (t10306+3.1415927);
float t10384 = (3.1415927*2);
float t10385 = mod(t10383,t10384);
float t10386 = (t10385-3.1415927);
float t10387 = (t118+3.1415927);
float t10388 = (3.1415927*2);
float t10389 = mod(t10387,t10388);
float t10390 = (t10389-3.1415927);
float t10391 = (t10386-t10390);
float t10392 = abs(t10391);
float t10393 = (t10392/2);
float t10394 = sin(t10393);
float t10395 = (t10394*t10394);
float t10396 = (t10382*t10395);
float t10397 = (t10379+t10396);
float t10398 = sqrt(t10397);
float t10399 = asin(t10398);
float t10400 = (2*t10399);
float t10401 = step(t10370,t10400);
float t10402 = (1-t10401);
float t10403 = (t10257*t10402);
float t10404 = (3.1415927/2);
float t10405 = (t8-t10404);
float t10406 = (3.1415927/2);
float t10407 = (t10289-t10406);
float t10408 = (t10405-t10407);
float t10409 = abs(t10408);
float t10410 = (t10409/2);
float t10411 = sin(t10410);
float t10412 = (t10411*t10411);
float t10413 = cos(t10407);
float t10414 = cos(t10405);
float t10415 = (t10413*t10414);
float t10416 = (t118+3.1415927);
float t10417 = (3.1415927*2);
float t10418 = mod(t10416,t10417);
float t10419 = (t10418-3.1415927);
float t10420 = (t10306+3.1415927);
float t10421 = (3.1415927*2);
float t10422 = mod(t10420,t10421);
float t10423 = (t10422-3.1415927);
float t10424 = (t10419-t10423);
float t10425 = abs(t10424);
float t10426 = (t10425/2);
float t10427 = sin(t10426);
float t10428 = (t10427*t10427);
float t10429 = (t10415*t10428);
float t10430 = (t10412+t10429);
float t10431 = sqrt(t10430);
float t10432 = asin(t10431);
float t10433 = (2*t10432);
float t10434 = (1/t10433);
float t10435 = (t10434*t10369);
float t10436 = (t10435*float(1.25e-2));
float t10437 = (u4.u0*t10245);
float t10438 = cos(t10437);
float t10439 = (t10438+1);
float t10440 = (t10439/2);
float t10441 = (t10436*t10440);
float t10442 = (t10441*t10257);
float t10443 = (t10403+t10442);
float t10444 = (t10226+t10443);
float t10445 = (t10000/245);
float t10446 = (t10000/245);
float t10447 = (t10446*float(842.378));
float t10448 = fract(t10447);
float t10449 = (t10448+float(45.32));
float t10450 = (t10449+u6.u0);
float t10451 = (t10448*t10450);
float t10452 = (t10016+2);
float t10453 = (t10452/t10013);
float t10454 = (t10453*float(1734.048));
float t10455 = fract(t10454);
float t10456 = (t10455+float(45.32));
float t10457 = (t10456+u6.u0);
float t10458 = (t10455*t10457);
float t10459 = (t10451+t10458);
float t10460 = (t10448+t10459);
float t10461 = (t10455+t10459);
float t10462 = (t10460*t10461);
float t10463 = fract(t10462);
float t10464 = (t10463*5);
float t10465 = (t10445+t10464);
float t10466 = fract(t10465);
float t10467 = (t10466*12000);
float t10468 = (t10467/1000);
bool t10469 = (1<=t10468);
float t10470;
if(t10469){
t10470 = 1;
} else {
t10470 = t10468;
}
float t10471 = (t10467-6000);
float t10472 = (t10471/8000);
bool t10473 = (0>=t10472);
float t10474;
if(t10473){
t10474 = 0;
} else {
t10474 = t10472;
}
float t10475 = (t10470-t10474);
float t10476 = (t10463*173);
float t10477 = fract(t10476);
float t10478 = step(float(0.66),t10477);
float t10479 = (t10478*3);
float t10480 = (3+t10479);
float t10481 = (3.1415927/t10480);
float t10482 = cos(t10481);
float t10483 = (1-t10482);
float t10484 = (t10000*t9998);
float t10485 = (t10000/245);
float t10486 = (t10485*float(842.378));
float t10487 = fract(t10486);
float t10488 = (t10487+float(45.32));
float t10489 = (t10488+u6.u0);
float t10490 = (t10487*t10489);
float t10491 = (t10452/t10013);
float t10492 = (t10491*float(1734.048));
float t10493 = fract(t10492);
float t10494 = (t10493+float(45.32));
float t10495 = (t10494+u6.u0);
float t10496 = (t10493*t10495);
float t10497 = (t10490+t10496);
float t10498 = (t10487+t10497);
float t10499 = (t10493+t10497);
float t10500 = (t10498*t10499);
float t10501 = fract(t10500);
float t10502 = (t10501*float(2852.02));
float t10503 = fract(t10502);
float t10504 = (t10503-float(0.5));
float t10505 = (t10504*t9998);
float t10506 = (t10505*float(0.75));
float t10507 = (t10484+t10506);
float t10508 = cos(t10507);
float t10509 = (1*t10508);
float t10510 = (t10509*0);
float t10511 = sin(t10507);
float t10512 = (1*t10511);
float t10513 = (3.1415927/t10013);
float t10514 = (t10452*t10513);
float t10515 = (t10501*float(97372.83));
float t10516 = fract(t10515);
float t10517 = (t10516-float(0.5));
float t10518 = (3.1415927/t10013);
float t10519 = (t10517*t10518);
float t10520 = (t10519*float(0.75));
float t10521 = (t10514+t10520);
float t10522 = (t10521+3.1415927);
float t10523 = mod(t10522,t1433);
float t10524 = (t10523-3.1415927);
float t10525 = cos(t10524);
float t10526 = (t10512*t10525);
float t10527 = (t10526*1);
float t10528 = (t10510-t10527);
float t10529 = sin(t8);
float t10530 = (1*t10529);
float t10531 = sin(t118);
float t10532 = (t10530*t10531);
float t10533 = (t10528*t10532);
float t10534 = (t10526*0);
float t10535 = sin(t10507);
float t10536 = (1*t10535);
float t10537 = sin(t10524);
float t10538 = (t10536*t10537);
float t10539 = (t10538*0);
float t10540 = (t10534-t10539);
float t10541 = cos(t8);
float t10542 = (1*t10541);
float t10543 = (t10540*t10542);
float t10544 = (t10533+t10543);
float t10545 = (t10538*1);
float t10546 = (t10509*0);
float t10547 = (t10545-t10546);
float t10548 = sin(t8);
float t10549 = (1*t10548);
float t10550 = cos(t118);
float t10551 = (t10549*t10550);
float t10552 = (t10547*t10551);
float t10553 = (t10544+t10552);
float t10554 = (t10540*t10526);
float t10555 = (t10547*t10509);
float t10556 = (t10554-t10555);
float t10557 = (t10556*t10532);
float t10558 = (t10547*t10538);
float t10559 = (t10528*t10526);
float t10560 = (t10558-t10559);
float t10561 = (t10560*t10542);
float t10562 = (t10557+t10561);
float t10563 = (t10528*t10509);
float t10564 = (t10540*t10538);
float t10565 = (t10563-t10564);
float t10566 = (t10565*t10551);
float t10567 = (t10562+t10566);
float t10568 = atan(t10553,t10567);
float t10569 = (t10568+3.1415927);
float t10570 = (t10477*3.1415927);
float t10571 = (t10569+t10570);
float t10572 = (t10571/t1483);
float t10573 = fract(t10572);
float t10574 = (t10573*t10480);
float t10575 = fract(t10574);
float t10576 = (t10575*2);
float t10577 = (t10576-1);
float t10578 = abs(t10577);
float t10579 = (t10578*t10578);
float t10580 = (t10483*t10579);
float t10581 = (t10482+t10580);
float t10582 = (t10463*float(8.0e-3));
float t10583 = (float(1.0e-3)+t10582);
float t10584 = step(float(0.66),t10477);
float t10585 = (t10584*float(3.0e-3));
float t10586 = (t10583-t10585);
float t10587 = (t10586*float(0.4));
float t10588 = (t10581*t10587);
float t10589 = (3.1415927/2);
float t10590 = (t10507-t10589);
float t10591 = (3.1415927/2);
float t10592 = (t8-t10591);
float t10593 = (t10590-t10592);
float t10594 = abs(t10593);
float t10595 = (t10594/2);
float t10596 = sin(t10595);
float t10597 = (t10596*t10596);
float t10598 = cos(t10592);
float t10599 = cos(t10590);
float t10600 = (t10598*t10599);
float t10601 = (t10524+3.1415927);
float t10602 = (3.1415927*2);
float t10603 = mod(t10601,t10602);
float t10604 = (t10603-3.1415927);
float t10605 = (t118+3.1415927);
float t10606 = (3.1415927*2);
float t10607 = mod(t10605,t10606);
float t10608 = (t10607-3.1415927);
float t10609 = (t10604-t10608);
float t10610 = abs(t10609);
float t10611 = (t10610/2);
float t10612 = sin(t10611);
float t10613 = (t10612*t10612);
float t10614 = (t10600*t10613);
float t10615 = (t10597+t10614);
float t10616 = sqrt(t10615);
float t10617 = asin(t10616);
float t10618 = (2*t10617);
float t10619 = step(t10588,t10618);
float t10620 = (1-t10619);
float t10621 = (t10475*t10620);
float t10622 = (3.1415927/2);
float t10623 = (t8-t10622);
float t10624 = (3.1415927/2);
float t10625 = (t10507-t10624);
float t10626 = (t10623-t10625);
float t10627 = abs(t10626);
float t10628 = (t10627/2);
float t10629 = sin(t10628);
float t10630 = (t10629*t10629);
float t10631 = cos(t10625);
float t10632 = cos(t10623);
float t10633 = (t10631*t10632);
float t10634 = (t118+3.1415927);
float t10635 = (3.1415927*2);
float t10636 = mod(t10634,t10635);
float t10637 = (t10636-3.1415927);
float t10638 = (t10524+3.1415927);
float t10639 = (3.1415927*2);
float t10640 = mod(t10638,t10639);
float t10641 = (t10640-3.1415927);
float t10642 = (t10637-t10641);
float t10643 = abs(t10642);
float t10644 = (t10643/2);
float t10645 = sin(t10644);
float t10646 = (t10645*t10645);
float t10647 = (t10633*t10646);
float t10648 = (t10630+t10647);
float t10649 = sqrt(t10648);
float t10650 = asin(t10649);
float t10651 = (2*t10650);
float t10652 = (1/t10651);
float t10653 = (t10652*t10587);
float t10654 = (t10653*float(1.25e-2));
float t10655 = (u4.u0*t10463);
float t10656 = cos(t10655);
float t10657 = (t10656+1);
float t10658 = (t10657/2);
float t10659 = (t10654*t10658);
float t10660 = (t10659*t10475);
float t10661 = (t10621+t10660);
float t10662 = (t10444+t10661);
float t10663 = (t10000+1);
float t10664 = (t10663/245);
float t10665 = (t10663/245);
float t10666 = (t10665*float(842.378));
float t10667 = fract(t10666);
float t10668 = (t10667+float(45.32));
float t10669 = (t10668+u6.u0);
float t10670 = (t10667*t10669);
float t10671 = (t10663/245);
float t10672 = (t10671*3.1415927);
float t10673 = sin(t10672);
float t10674 = (245*t10673);
float t10675 = floor(t10674);
float t10676 = (t10675+1);
float t10677 = (3.1415927/t10676);
float t10678 = (t118/t10677);
float t10679 = floor(t10678);
float t10680 = (t10679/t10676);
float t10681 = (t10680*float(1734.048));
float t10682 = fract(t10681);
float t10683 = (t10682+float(45.32));
float t10684 = (t10683+u6.u0);
float t10685 = (t10682*t10684);
float t10686 = (t10670+t10685);
float t10687 = (t10667+t10686);
float t10688 = (t10682+t10686);
float t10689 = (t10687*t10688);
float t10690 = fract(t10689);
float t10691 = (t10690*5);
float t10692 = (t10664+t10691);
float t10693 = fract(t10692);
float t10694 = (t10693*12000);
float t10695 = (t10694/1000);
bool t10696 = (1<=t10695);
float t10697;
if(t10696){
t10697 = 1;
} else {
t10697 = t10695;
}
float t10698 = (t10694-6000);
float t10699 = (t10698/8000);
bool t10700 = (0>=t10699);
float t10701;
if(t10700){
t10701 = 0;
} else {
t10701 = t10699;
}
float t10702 = (t10697-t10701);
float t10703 = (t10690*173);
float t10704 = fract(t10703);
float t10705 = step(float(0.66),t10704);
float t10706 = (t10705*3);
float t10707 = (3+t10706);
float t10708 = (3.1415927/t10707);
float t10709 = cos(t10708);
float t10710 = (1-t10709);
float t10711 = (t10663*t9998);
float t10712 = (t10663/245);
float t10713 = (t10712*float(842.378));
float t10714 = fract(t10713);
float t10715 = (t10714+float(45.32));
float t10716 = (t10715+u6.u0);
float t10717 = (t10714*t10716);
float t10718 = (t10679/t10676);
float t10719 = (t10718*float(1734.048));
float t10720 = fract(t10719);
float t10721 = (t10720+float(45.32));
float t10722 = (t10721+u6.u0);
float t10723 = (t10720*t10722);
float t10724 = (t10717+t10723);
float t10725 = (t10714+t10724);
float t10726 = (t10720+t10724);
float t10727 = (t10725*t10726);
float t10728 = fract(t10727);
float t10729 = (t10728*float(2852.02));
float t10730 = fract(t10729);
float t10731 = (t10730-float(0.5));
float t10732 = (t10731*t9998);
float t10733 = (t10732*float(0.75));
float t10734 = (t10711+t10733);
float t10735 = cos(t10734);
float t10736 = (1*t10735);
float t10737 = (t10736*0);
float t10738 = sin(t10734);
float t10739 = (1*t10738);
float t10740 = (3.1415927/t10676);
float t10741 = (t10679*t10740);
float t10742 = (t10728*float(97372.83));
float t10743 = fract(t10742);
float t10744 = (t10743-float(0.5));
float t10745 = (3.1415927/t10676);
float t10746 = (t10744*t10745);
float t10747 = (t10746*float(0.75));
float t10748 = (t10741+t10747);
float t10749 = (t10748+3.1415927);
float t10750 = mod(t10749,t1433);
float t10751 = (t10750-3.1415927);
float t10752 = cos(t10751);
float t10753 = (t10739*t10752);
float t10754 = (t10753*1);
float t10755 = (t10737-t10754);
float t10756 = sin(t8);
float t10757 = (1*t10756);
float t10758 = sin(t118);
float t10759 = (t10757*t10758);
float t10760 = (t10755*t10759);
float t10761 = (t10753*0);
float t10762 = sin(t10734);
float t10763 = (1*t10762);
float t10764 = sin(t10751);
float t10765 = (t10763*t10764);
float t10766 = (t10765*0);
float t10767 = (t10761-t10766);
float t10768 = cos(t8);
float t10769 = (1*t10768);
float t10770 = (t10767*t10769);
float t10771 = (t10760+t10770);
float t10772 = (t10765*1);
float t10773 = (t10736*0);
float t10774 = (t10772-t10773);
float t10775 = sin(t8);
float t10776 = (1*t10775);
float t10777 = cos(t118);
float t10778 = (t10776*t10777);
float t10779 = (t10774*t10778);
float t10780 = (t10771+t10779);
float t10781 = (t10767*t10753);
float t10782 = (t10774*t10736);
float t10783 = (t10781-t10782);
float t10784 = (t10783*t10759);
float t10785 = (t10774*t10765);
float t10786 = (t10755*t10753);
float t10787 = (t10785-t10786);
float t10788 = (t10787*t10769);
float t10789 = (t10784+t10788);
float t10790 = (t10755*t10736);
float t10791 = (t10767*t10765);
float t10792 = (t10790-t10791);
float t10793 = (t10792*t10778);
float t10794 = (t10789+t10793);
float t10795 = atan(t10780,t10794);
float t10796 = (t10795+3.1415927);
float t10797 = (t10704*3.1415927);
float t10798 = (t10796+t10797);
float t10799 = (t10798/t1483);
float t10800 = fract(t10799);
float t10801 = (t10800*t10707);
float t10802 = fract(t10801);
float t10803 = (t10802*2);
float t10804 = (t10803-1);
float t10805 = abs(t10804);
float t10806 = (t10805*t10805);
float t10807 = (t10710*t10806);
float t10808 = (t10709+t10807);
float t10809 = (t10690*float(8.0e-3));
float t10810 = (float(1.0e-3)+t10809);
float t10811 = step(float(0.66),t10704);
float t10812 = (t10811*float(3.0e-3));
float t10813 = (t10810-t10812);
float t10814 = (t10813*float(0.4));
float t10815 = (t10808*t10814);
float t10816 = (3.1415927/2);
float t10817 = (t10734-t10816);
float t10818 = (3.1415927/2);
float t10819 = (t8-t10818);
float t10820 = (t10817-t10819);
float t10821 = abs(t10820);
float t10822 = (t10821/2);
float t10823 = sin(t10822);
float t10824 = (t10823*t10823);
float t10825 = cos(t10819);
float t10826 = cos(t10817);
float t10827 = (t10825*t10826);
float t10828 = (t10751+3.1415927);
float t10829 = (3.1415927*2);
float t10830 = mod(t10828,t10829);
float t10831 = (t10830-3.1415927);
float t10832 = (t118+3.1415927);
float t10833 = (3.1415927*2);
float t10834 = mod(t10832,t10833);
float t10835 = (t10834-3.1415927);
float t10836 = (t10831-t10835);
float t10837 = abs(t10836);
float t10838 = (t10837/2);
float t10839 = sin(t10838);
float t10840 = (t10839*t10839);
float t10841 = (t10827*t10840);
float t10842 = (t10824+t10841);
float t10843 = sqrt(t10842);
float t10844 = asin(t10843);
float t10845 = (2*t10844);
float t10846 = step(t10815,t10845);
float t10847 = (1-t10846);
float t10848 = (t10702*t10847);
float t10849 = (3.1415927/2);
float t10850 = (t8-t10849);
float t10851 = (3.1415927/2);
float t10852 = (t10734-t10851);
float t10853 = (t10850-t10852);
float t10854 = abs(t10853);
float t10855 = (t10854/2);
float t10856 = sin(t10855);
float t10857 = (t10856*t10856);
float t10858 = cos(t10852);
float t10859 = cos(t10850);
float t10860 = (t10858*t10859);
float t10861 = (t118+3.1415927);
float t10862 = (3.1415927*2);
float t10863 = mod(t10861,t10862);
float t10864 = (t10863-3.1415927);
float t10865 = (t10751+3.1415927);
float t10866 = (3.1415927*2);
float t10867 = mod(t10865,t10866);
float t10868 = (t10867-3.1415927);
float t10869 = (t10864-t10868);
float t10870 = abs(t10869);
float t10871 = (t10870/2);
float t10872 = sin(t10871);
float t10873 = (t10872*t10872);
float t10874 = (t10860*t10873);
float t10875 = (t10857+t10874);
float t10876 = sqrt(t10875);
float t10877 = asin(t10876);
float t10878 = (2*t10877);
float t10879 = (1/t10878);
float t10880 = (t10879*t10814);
float t10881 = (t10880*float(1.25e-2));
float t10882 = (u4.u0*t10690);
float t10883 = cos(t10882);
float t10884 = (t10883+1);
float t10885 = (t10884/2);
float t10886 = (t10881*t10885);
float t10887 = (t10886*t10702);
float t10888 = (t10848+t10887);
float t10889 = (t10662+t10888);
float t10890 = (t10000*t9998);
float t10891 = (t10000/245);
float t10892 = (t10891*float(842.378));
float t10893 = fract(t10892);
float t10894 = (t10893+float(45.32));
float t10895 = (t10894+u6.u0);
float t10896 = (t10893*t10895);
float t10897 = (t10234/t10013);
float t10898 = (t10897*float(1734.048));
float t10899 = fract(t10898);
float t10900 = (t10899+float(45.32));
float t10901 = (t10900+u6.u0);
float t10902 = (t10899*t10901);
float t10903 = (t10896+t10902);
float t10904 = (t10893+t10903);
float t10905 = (t10899+t10903);
float t10906 = (t10904*t10905);
float t10907 = fract(t10906);
float t10908 = (t10907*float(2852.02));
float t10909 = fract(t10908);
float t10910 = (t10909-float(0.5));
float t10911 = (t10910*t9998);
float t10912 = (t10911*float(0.75));
float t10913 = (t10890+t10912);
float t10914 = (3.1415927/2);
float t10915 = (t10913-t10914);
float t10916 = (t10000*t9998);
float t10917 = (t10000/245);
float t10918 = (t10917*float(842.378));
float t10919 = fract(t10918);
float t10920 = (t10919+float(45.32));
float t10921 = (t10920+u6.u0);
float t10922 = (t10919*t10921);
float t10923 = (t10016/t10013);
float t10924 = (t10923*float(1734.048));
float t10925 = fract(t10924);
float t10926 = (t10925+float(45.32));
float t10927 = (t10926+u6.u0);
float t10928 = (t10925*t10927);
float t10929 = (t10922+t10928);
float t10930 = (t10919+t10929);
float t10931 = (t10925+t10929);
float t10932 = (t10930*t10931);
float t10933 = fract(t10932);
float t10934 = (t10933*float(2852.02));
float t10935 = fract(t10934);
float t10936 = (t10935-float(0.5));
float t10937 = (t10936*t9998);
float t10938 = (t10937*float(0.75));
float t10939 = (t10916+t10938);
float t10940 = (3.1415927/2);
float t10941 = (t10939-t10940);
float t10942 = (t10915-t10941);
float t10943 = abs(t10942);
float t10944 = (t10943/2);
float t10945 = sin(t10944);
float t10946 = (t10945*t10945);
float t10947 = cos(t10941);
float t10948 = cos(t10915);
float t10949 = (t10947*t10948);
float t10950 = (3.1415927/t10013);
float t10951 = (t10234*t10950);
float t10952 = (t10907*float(97372.83));
float t10953 = fract(t10952);
float t10954 = (t10953-float(0.5));
float t10955 = (3.1415927/t10013);
float t10956 = (t10954*t10955);
float t10957 = (t10956*float(0.75));
float t10958 = (t10951+t10957);
float t10959 = (t10958+3.1415927);
float t10960 = mod(t10959,t1433);
float t10961 = (t10960-3.1415927);
float t10962 = (t10961+3.1415927);
float t10963 = (3.1415927*2);
float t10964 = mod(t10962,t10963);
float t10965 = (t10964-3.1415927);
float t10966 = (3.1415927/t10013);
float t10967 = (t10016*t10966);
float t10968 = (t10933*float(97372.83));
float t10969 = fract(t10968);
float t10970 = (t10969-float(0.5));
float t10971 = (3.1415927/t10013);
float t10972 = (t10970*t10971);
float t10973 = (t10972*float(0.75));
float t10974 = (t10967+t10973);
float t10975 = (t10974+3.1415927);
float t10976 = mod(t10975,t1433);
float t10977 = (t10976-3.1415927);
float t10978 = (t10977+3.1415927);
float t10979 = (3.1415927*2);
float t10980 = mod(t10978,t10979);
float t10981 = (t10980-3.1415927);
float t10982 = (t10965-t10981);
float t10983 = abs(t10982);
float t10984 = (t10983/2);
float t10985 = sin(t10984);
float t10986 = (t10985*t10985);
float t10987 = (t10949*t10986);
float t10988 = (t10946+t10987);
float t10989 = sqrt(t10988);
float t10990 = asin(t10989);
float t10991 = (2*t10990);
float t10992 = (3.1415927/2);
float t10993 = (t8-t10992);
float t10994 = (3.1415927/2);
float t10995 = (t10939-t10994);
float t10996 = (t10993-t10995);
float t10997 = abs(t10996);
float t10998 = (t10997/2);
float t10999 = sin(t10998);
float t11000 = (t10999*t10999);
float t11001 = cos(t10995);
float t11002 = cos(t10993);
float t11003 = (t11001*t11002);
float t11004 = (t118+3.1415927);
float t11005 = (3.1415927*2);
float t11006 = mod(t11004,t11005);
float t11007 = (t11006-3.1415927);
float t11008 = (t10977+3.1415927);
float t11009 = (3.1415927*2);
float t11010 = mod(t11008,t11009);
float t11011 = (t11010-3.1415927);
float t11012 = (t11007-t11011);
float t11013 = abs(t11012);
float t11014 = (t11013/2);
float t11015 = sin(t11014);
float t11016 = (t11015*t11015);
float t11017 = (t11003*t11016);
float t11018 = (t11000+t11017);
float t11019 = sqrt(t11018);
float t11020 = asin(t11019);
float t11021 = (2*t11020);
float t11022 = (t10991-t11021);
float t11023 = (3.1415927/2);
float t11024 = (t8-t11023);
float t11025 = (3.1415927/2);
float t11026 = (t10913-t11025);
float t11027 = (t11024-t11026);
float t11028 = abs(t11027);
float t11029 = (t11028/2);
float t11030 = sin(t11029);
float t11031 = (t11030*t11030);
float t11032 = cos(t11026);
float t11033 = cos(t11024);
float t11034 = (t11032*t11033);
float t11035 = (t118+3.1415927);
float t11036 = (3.1415927*2);
float t11037 = mod(t11035,t11036);
float t11038 = (t11037-3.1415927);
float t11039 = (t10961+3.1415927);
float t11040 = (3.1415927*2);
float t11041 = mod(t11039,t11040);
float t11042 = (t11041-3.1415927);
float t11043 = (t11038-t11042);
float t11044 = abs(t11043);
float t11045 = (t11044/2);
float t11046 = sin(t11045);
float t11047 = (t11046*t11046);
float t11048 = (t11034*t11047);
float t11049 = (t11031+t11048);
float t11050 = sqrt(t11049);
float t11051 = asin(t11050);
float t11052 = (2*t11051);
float t11053 = (t11022-t11052);
float t11054 = abs(t11053);
bool t11055 = (float(1.0e-4)>t11054);
float t11056;
if(t11055){
float t11057 = cos(t10939);
float t11058 = (1*t11057);
float t11059 = sin(t10913);
float t11060 = (1*t11059);
float t11061 = cos(t10961);
float t11062 = (t11060*t11061);
float t11063 = (t11058*t11062);
float t11064 = sin(t10939);
float t11065 = (1*t11064);
float t11066 = cos(t10977);
float t11067 = (t11065*t11066);
float t11068 = cos(t10913);
float t11069 = (1*t11068);
float t11070 = (t11067*t11069);
float t11071 = (t11063-t11070);
float t11072 = sin(t8);
float t11073 = (1*t11072);
float t11074 = sin(t118);
float t11075 = (t11073*t11074);
float t11076 = (t11071*t11075);
float t11077 = sin(t10913);
float t11078 = (1*t11077);
float t11079 = sin(t10961);
float t11080 = (t11078*t11079);
float t11081 = (t11067*t11080);
float t11082 = sin(t10939);
float t11083 = (1*t11082);
float t11084 = sin(t10977);
float t11085 = (t11083*t11084);
float t11086 = (t11085*t11062);
float t11087 = (t11081-t11086);
float t11088 = cos(t8);
float t11089 = (1*t11088);
float t11090 = (t11087*t11089);
float t11091 = (t11076+t11090);
float t11092 = (t11085*t11069);
float t11093 = (t11058*t11080);
float t11094 = (t11092-t11093);
float t11095 = sin(t8);
float t11096 = (1*t11095);
float t11097 = cos(t118);
float t11098 = (t11096*t11097);
float t11099 = (t11094*t11098);
float t11100 = (t11091+t11099);
float t11101 = abs(t11100);
t11056 = t11101;
} else {
float t11102 = (3.1415927/2);
float t11103 = (t8-t11102);
float t11104 = (3.1415927/2);
float t11105 = (t10913-t11104);
float t11106 = (t11103-t11105);
float t11107 = abs(t11106);
float t11108 = (t11107/2);
float t11109 = sin(t11108);
float t11110 = (t11109*t11109);
float t11111 = cos(t11105);
float t11112 = cos(t11103);
float t11113 = (t11111*t11112);
float t11114 = (t118+3.1415927);
float t11115 = (3.1415927*2);
float t11116 = mod(t11114,t11115);
float t11117 = (t11116-3.1415927);
float t11118 = (t10961+3.1415927);
float t11119 = (3.1415927*2);
float t11120 = mod(t11118,t11119);
float t11121 = (t11120-3.1415927);
float t11122 = (t11117-t11121);
float t11123 = abs(t11122);
float t11124 = (t11123/2);
float t11125 = sin(t11124);
float t11126 = (t11125*t11125);
float t11127 = (t11113*t11126);
float t11128 = (t11110+t11127);
float t11129 = sqrt(t11128);
float t11130 = asin(t11129);
float t11131 = (2*t11130);
float t11132 = abs(t11131);
float t11133 = (3.1415927/2);
float t11134 = (t8-t11133);
float t11135 = (3.1415927/2);
float t11136 = (t10939-t11135);
float t11137 = (t11134-t11136);
float t11138 = abs(t11137);
float t11139 = (t11138/2);
float t11140 = sin(t11139);
float t11141 = (t11140*t11140);
float t11142 = cos(t11136);
float t11143 = cos(t11134);
float t11144 = (t11142*t11143);
float t11145 = (t118+3.1415927);
float t11146 = (3.1415927*2);
float t11147 = mod(t11145,t11146);
float t11148 = (t11147-3.1415927);
float t11149 = (t10977+3.1415927);
float t11150 = (3.1415927*2);
float t11151 = mod(t11149,t11150);
float t11152 = (t11151-3.1415927);
float t11153 = (t11148-t11152);
float t11154 = abs(t11153);
float t11155 = (t11154/2);
float t11156 = sin(t11155);
float t11157 = (t11156*t11156);
float t11158 = (t11144*t11157);
float t11159 = (t11141+t11158);
float t11160 = sqrt(t11159);
float t11161 = asin(t11160);
float t11162 = (2*t11161);
float t11163 = abs(t11162);
bool t11164 = (t11132>=t11163);
float t11165;
if(t11164){
t11165 = t11132;
} else {
t11165 = t11163;
}
t11056 = t11165;
}
float t11166 = abs(t11056);
float t11167 = step(float(2.0e-4),t11166);
float t11168 = (1-t11167);
float t11169 = (t10000*t10234);
float t11170 = (t11169*float(842.378));
float t11171 = fract(t11170);
float t11172 = (t11171+float(45.32));
float t11173 = (t11172+u6.u0);
float t11174 = (t11171*t11173);
float t11175 = (t10016*t10000);
float t11176 = (t11175*float(1734.048));
float t11177 = fract(t11176);
float t11178 = (t11177+float(45.32));
float t11179 = (t11178+u6.u0);
float t11180 = (t11177*t11179);
float t11181 = (t11174+t11180);
float t11182 = (t11171+t11181);
float t11183 = (t11177+t11181);
float t11184 = (t11182*t11183);
float t11185 = fract(t11184);
float t11186 = step(float(0.2),t11185);
float t11187 = (t11168*t11186);
float t11188 = (3.1415927/2);
float t11189 = (t10913-t11188);
float t11190 = (3.1415927/2);
float t11191 = (t10939-t11190);
float t11192 = (t11189-t11191);
float t11193 = abs(t11192);
float t11194 = (t11193/2);
float t11195 = sin(t11194);
float t11196 = (t11195*t11195);
float t11197 = cos(t11191);
float t11198 = cos(t11189);
float t11199 = (t11197*t11198);
float t11200 = (t10961+3.1415927);
float t11201 = (3.1415927*2);
float t11202 = mod(t11200,t11201);
float t11203 = (t11202-3.1415927);
float t11204 = (t10977+3.1415927);
float t11205 = (3.1415927*2);
float t11206 = mod(t11204,t11205);
float t11207 = (t11206-3.1415927);
float t11208 = (t11203-t11207);
float t11209 = abs(t11208);
float t11210 = (t11209/2);
float t11211 = sin(t11210);
float t11212 = (t11211*t11211);
float t11213 = (t11199*t11212);
float t11214 = (t11196+t11213);
float t11215 = sqrt(t11214);
float t11216 = asin(t11215);
float t11217 = (2*t11216);
float t11218 = (t11217/t9998);
float t11219 = (1-t11218);
float t11220 = (t10000/245);
float t11221 = (t11220*float(842.378));
float t11222 = fract(t11221);
float t11223 = (t11222+float(45.32));
float t11224 = (t11223+u6.u0);
float t11225 = (t11222*t11224);
float t11226 = (t10016/t10013);
float t11227 = (t11226*float(1734.048));
float t11228 = fract(t11227);
float t11229 = (t11228+float(45.32));
float t11230 = (t11229+u6.u0);
float t11231 = (t11228*t11230);
float t11232 = (t11225+t11231);
float t11233 = (t11222+t11232);
float t11234 = (t11228+t11232);
float t11235 = (t11233*t11234);
float t11236 = fract(t11235);
float t11237 = (t11236*float(8.0e-3));
float t11238 = (float(1.0e-3)+t11237);
float t11239 = (t11236*173);
float t11240 = fract(t11239);
float t11241 = step(float(0.66),t11240);
float t11242 = (t11241*float(3.0e-3));
float t11243 = (t11238-t11242);
float t11244 = (t11243*float(0.4));
float t11245 = (t10000/245);
float t11246 = (t11245*float(842.378));
float t11247 = fract(t11246);
float t11248 = (t11247+float(45.32));
float t11249 = (t11248+u6.u0);
float t11250 = (t11247*t11249);
float t11251 = (t10234/t10013);
float t11252 = (t11251*float(1734.048));
float t11253 = fract(t11252);
float t11254 = (t11253+float(45.32));
float t11255 = (t11254+u6.u0);
float t11256 = (t11253*t11255);
float t11257 = (t11250+t11256);
float t11258 = (t11247+t11257);
float t11259 = (t11253+t11257);
float t11260 = (t11258*t11259);
float t11261 = fract(t11260);
float t11262 = (t11261*float(8.0e-3));
float t11263 = (float(1.0e-3)+t11262);
float t11264 = (t11261*173);
float t11265 = fract(t11264);
float t11266 = step(float(0.66),t11265);
float t11267 = (t11266*float(3.0e-3));
float t11268 = (t11263-t11267);
float t11269 = (t11268*float(0.4));
float t11270 = (t11244-t11269);
float t11271 = abs(t11270);
float t11272 = (t11271-float(1.0e-3));
float t11273 = (t11272/float(8.0e-3));
float t11274 = (1-t11273);
float t11275 = (t11274*t11274);
float t11276 = (t11219*t11275);
float t11277 = (t11187*t11276);
float t11278 = (u4.u0*t11185);
float t11279 = (t11278*3);
float t11280 = sin(t11279);
float t11281 = (t11280+1);
float t11282 = (t11281/2);
float t11283 = (t11282*float(0.66));
float t11284 = (t11283+float(0.33));
float t11285 = (t11277*t11284);
float t11286 = (float(0.2)*t11285);
bool t11287 = (0>=t11286);
float t11288;
if(t11287){
t11288 = 0;
} else {
t11288 = t11286;
}
float t11289 = (t11288*0);
float t11290 = (t10889+t11289);
float t11291 = (t10663*t9998);
float t11292 = (t10663/245);
float t11293 = (t11292*float(842.378));
float t11294 = fract(t11293);
float t11295 = (t11294+float(45.32));
float t11296 = (t11295+u6.u0);
float t11297 = (t11294*t11296);
float t11298 = (t10679/t10676);
float t11299 = (t11298*float(1734.048));
float t11300 = fract(t11299);
float t11301 = (t11300+float(45.32));
float t11302 = (t11301+u6.u0);
float t11303 = (t11300*t11302);
float t11304 = (t11297+t11303);
float t11305 = (t11294+t11304);
float t11306 = (t11300+t11304);
float t11307 = (t11305*t11306);
float t11308 = fract(t11307);
float t11309 = (t11308*float(2852.02));
float t11310 = fract(t11309);
float t11311 = (t11310-float(0.5));
float t11312 = (t11311*t9998);
float t11313 = (t11312*float(0.75));
float t11314 = (t11291+t11313);
float t11315 = (3.1415927/2);
float t11316 = (t11314-t11315);
float t11317 = (t10000*t9998);
float t11318 = (t10000/245);
float t11319 = (t11318*float(842.378));
float t11320 = fract(t11319);
float t11321 = (t11320+float(45.32));
float t11322 = (t11321+u6.u0);
float t11323 = (t11320*t11322);
float t11324 = (t10016/t10013);
float t11325 = (t11324*float(1734.048));
float t11326 = fract(t11325);
float t11327 = (t11326+float(45.32));
float t11328 = (t11327+u6.u0);
float t11329 = (t11326*t11328);
float t11330 = (t11323+t11329);
float t11331 = (t11320+t11330);
float t11332 = (t11326+t11330);
float t11333 = (t11331*t11332);
float t11334 = fract(t11333);
float t11335 = (t11334*float(2852.02));
float t11336 = fract(t11335);
float t11337 = (t11336-float(0.5));
float t11338 = (t11337*t9998);
float t11339 = (t11338*float(0.75));
float t11340 = (t11317+t11339);
float t11341 = (3.1415927/2);
float t11342 = (t11340-t11341);
float t11343 = (t11316-t11342);
float t11344 = abs(t11343);
float t11345 = (t11344/2);
float t11346 = sin(t11345);
float t11347 = (t11346*t11346);
float t11348 = cos(t11342);
float t11349 = cos(t11316);
float t11350 = (t11348*t11349);
float t11351 = (3.1415927/t10676);
float t11352 = (t10679*t11351);
float t11353 = (t11308*float(97372.83));
float t11354 = fract(t11353);
float t11355 = (t11354-float(0.5));
float t11356 = (3.1415927/t10676);
float t11357 = (t11355*t11356);
float t11358 = (t11357*float(0.75));
float t11359 = (t11352+t11358);
float t11360 = (t11359+3.1415927);
float t11361 = mod(t11360,t1433);
float t11362 = (t11361-3.1415927);
float t11363 = (t11362+3.1415927);
float t11364 = (3.1415927*2);
float t11365 = mod(t11363,t11364);
float t11366 = (t11365-3.1415927);
float t11367 = (3.1415927/t10013);
float t11368 = (t10016*t11367);
float t11369 = (t11334*float(97372.83));
float t11370 = fract(t11369);
float t11371 = (t11370-float(0.5));
float t11372 = (3.1415927/t10013);
float t11373 = (t11371*t11372);
float t11374 = (t11373*float(0.75));
float t11375 = (t11368+t11374);
float t11376 = (t11375+3.1415927);
float t11377 = mod(t11376,t1433);
float t11378 = (t11377-3.1415927);
float t11379 = (t11378+3.1415927);
float t11380 = (3.1415927*2);
float t11381 = mod(t11379,t11380);
float t11382 = (t11381-3.1415927);
float t11383 = (t11366-t11382);
float t11384 = abs(t11383);
float t11385 = (t11384/2);
float t11386 = sin(t11385);
float t11387 = (t11386*t11386);
float t11388 = (t11350*t11387);
float t11389 = (t11347+t11388);
float t11390 = sqrt(t11389);
float t11391 = asin(t11390);
float t11392 = (2*t11391);
float t11393 = (3.1415927/2);
float t11394 = (t8-t11393);
float t11395 = (3.1415927/2);
float t11396 = (t11340-t11395);
float t11397 = (t11394-t11396);
float t11398 = abs(t11397);
float t11399 = (t11398/2);
float t11400 = sin(t11399);
float t11401 = (t11400*t11400);
float t11402 = cos(t11396);
float t11403 = cos(t11394);
float t11404 = (t11402*t11403);
float t11405 = (t118+3.1415927);
float t11406 = (3.1415927*2);
float t11407 = mod(t11405,t11406);
float t11408 = (t11407-3.1415927);
float t11409 = (t11378+3.1415927);
float t11410 = (3.1415927*2);
float t11411 = mod(t11409,t11410);
float t11412 = (t11411-3.1415927);
float t11413 = (t11408-t11412);
float t11414 = abs(t11413);
float t11415 = (t11414/2);
float t11416 = sin(t11415);
float t11417 = (t11416*t11416);
float t11418 = (t11404*t11417);
float t11419 = (t11401+t11418);
float t11420 = sqrt(t11419);
float t11421 = asin(t11420);
float t11422 = (2*t11421);
float t11423 = (t11392-t11422);
float t11424 = (3.1415927/2);
float t11425 = (t8-t11424);
float t11426 = (3.1415927/2);
float t11427 = (t11314-t11426);
float t11428 = (t11425-t11427);
float t11429 = abs(t11428);
float t11430 = (t11429/2);
float t11431 = sin(t11430);
float t11432 = (t11431*t11431);
float t11433 = cos(t11427);
float t11434 = cos(t11425);
float t11435 = (t11433*t11434);
float t11436 = (t118+3.1415927);
float t11437 = (3.1415927*2);
float t11438 = mod(t11436,t11437);
float t11439 = (t11438-3.1415927);
float t11440 = (t11362+3.1415927);
float t11441 = (3.1415927*2);
float t11442 = mod(t11440,t11441);
float t11443 = (t11442-3.1415927);
float t11444 = (t11439-t11443);
float t11445 = abs(t11444);
float t11446 = (t11445/2);
float t11447 = sin(t11446);
float t11448 = (t11447*t11447);
float t11449 = (t11435*t11448);
float t11450 = (t11432+t11449);
float t11451 = sqrt(t11450);
float t11452 = asin(t11451);
float t11453 = (2*t11452);
float t11454 = (t11423-t11453);
float t11455 = abs(t11454);
bool t11456 = (float(1.0e-4)>t11455);
float t11457;
if(t11456){
float t11458 = cos(t11340);
float t11459 = (1*t11458);
float t11460 = sin(t11314);
float t11461 = (1*t11460);
float t11462 = cos(t11362);
float t11463 = (t11461*t11462);
float t11464 = (t11459*t11463);
float t11465 = sin(t11340);
float t11466 = (1*t11465);
float t11467 = cos(t11378);
float t11468 = (t11466*t11467);
float t11469 = cos(t11314);
float t11470 = (1*t11469);
float t11471 = (t11468*t11470);
float t11472 = (t11464-t11471);
float t11473 = sin(t8);
float t11474 = (1*t11473);
float t11475 = sin(t118);
float t11476 = (t11474*t11475);
float t11477 = (t11472*t11476);
float t11478 = sin(t11314);
float t11479 = (1*t11478);
float t11480 = sin(t11362);
float t11481 = (t11479*t11480);
float t11482 = (t11468*t11481);
float t11483 = sin(t11340);
float t11484 = (1*t11483);
float t11485 = sin(t11378);
float t11486 = (t11484*t11485);
float t11487 = (t11486*t11463);
float t11488 = (t11482-t11487);
float t11489 = cos(t8);
float t11490 = (1*t11489);
float t11491 = (t11488*t11490);
float t11492 = (t11477+t11491);
float t11493 = (t11486*t11470);
float t11494 = (t11459*t11481);
float t11495 = (t11493-t11494);
float t11496 = sin(t8);
float t11497 = (1*t11496);
float t11498 = cos(t118);
float t11499 = (t11497*t11498);
float t11500 = (t11495*t11499);
float t11501 = (t11492+t11500);
float t11502 = abs(t11501);
t11457 = t11502;
} else {
float t11503 = (3.1415927/2);
float t11504 = (t8-t11503);
float t11505 = (3.1415927/2);
float t11506 = (t11314-t11505);
float t11507 = (t11504-t11506);
float t11508 = abs(t11507);
float t11509 = (t11508/2);
float t11510 = sin(t11509);
float t11511 = (t11510*t11510);
float t11512 = cos(t11506);
float t11513 = cos(t11504);
float t11514 = (t11512*t11513);
float t11515 = (t118+3.1415927);
float t11516 = (3.1415927*2);
float t11517 = mod(t11515,t11516);
float t11518 = (t11517-3.1415927);
float t11519 = (t11362+3.1415927);
float t11520 = (3.1415927*2);
float t11521 = mod(t11519,t11520);
float t11522 = (t11521-3.1415927);
float t11523 = (t11518-t11522);
float t11524 = abs(t11523);
float t11525 = (t11524/2);
float t11526 = sin(t11525);
float t11527 = (t11526*t11526);
float t11528 = (t11514*t11527);
float t11529 = (t11511+t11528);
float t11530 = sqrt(t11529);
float t11531 = asin(t11530);
float t11532 = (2*t11531);
float t11533 = abs(t11532);
float t11534 = (3.1415927/2);
float t11535 = (t8-t11534);
float t11536 = (3.1415927/2);
float t11537 = (t11340-t11536);
float t11538 = (t11535-t11537);
float t11539 = abs(t11538);
float t11540 = (t11539/2);
float t11541 = sin(t11540);
float t11542 = (t11541*t11541);
float t11543 = cos(t11537);
float t11544 = cos(t11535);
float t11545 = (t11543*t11544);
float t11546 = (t118+3.1415927);
float t11547 = (3.1415927*2);
float t11548 = mod(t11546,t11547);
float t11549 = (t11548-3.1415927);
float t11550 = (t11378+3.1415927);
float t11551 = (3.1415927*2);
float t11552 = mod(t11550,t11551);
float t11553 = (t11552-3.1415927);
float t11554 = (t11549-t11553);
float t11555 = abs(t11554);
float t11556 = (t11555/2);
float t11557 = sin(t11556);
float t11558 = (t11557*t11557);
float t11559 = (t11545*t11558);
float t11560 = (t11542+t11559);
float t11561 = sqrt(t11560);
float t11562 = asin(t11561);
float t11563 = (2*t11562);
float t11564 = abs(t11563);
bool t11565 = (t11533>=t11564);
float t11566;
if(t11565){
t11566 = t11533;
} else {
t11566 = t11564;
}
t11457 = t11566;
}
float t11567 = abs(t11457);
float t11568 = step(float(2.0e-4),t11567);
float t11569 = (1-t11568);
float t11570 = (t10000*t10679);
float t11571 = (t11570*float(842.378));
float t11572 = fract(t11571);
float t11573 = (t11572+float(45.32));
float t11574 = (t11573+u6.u0);
float t11575 = (t11572*t11574);
float t11576 = (t10016*t10663);
float t11577 = (t11576*float(1734.048));
float t11578 = fract(t11577);
float t11579 = (t11578+float(45.32));
float t11580 = (t11579+u6.u0);
float t11581 = (t11578*t11580);
float t11582 = (t11575+t11581);
float t11583 = (t11572+t11582);
float t11584 = (t11578+t11582);
float t11585 = (t11583*t11584);
float t11586 = fract(t11585);
float t11587 = step(float(0.2),t11586);
float t11588 = (t11569*t11587);
float t11589 = (3.1415927/2);
float t11590 = (t11314-t11589);
float t11591 = (3.1415927/2);
float t11592 = (t11340-t11591);
float t11593 = (t11590-t11592);
float t11594 = abs(t11593);
float t11595 = (t11594/2);
float t11596 = sin(t11595);
float t11597 = (t11596*t11596);
float t11598 = cos(t11592);
float t11599 = cos(t11590);
float t11600 = (t11598*t11599);
float t11601 = (t11362+3.1415927);
float t11602 = (3.1415927*2);
float t11603 = mod(t11601,t11602);
float t11604 = (t11603-3.1415927);
float t11605 = (t11378+3.1415927);
float t11606 = (3.1415927*2);
float t11607 = mod(t11605,t11606);
float t11608 = (t11607-3.1415927);
float t11609 = (t11604-t11608);
float t11610 = abs(t11609);
float t11611 = (t11610/2);
float t11612 = sin(t11611);
float t11613 = (t11612*t11612);
float t11614 = (t11600*t11613);
float t11615 = (t11597+t11614);
float t11616 = sqrt(t11615);
float t11617 = asin(t11616);
float t11618 = (2*t11617);
float t11619 = (t11618/t9998);
float t11620 = (1-t11619);
float t11621 = (t10000/245);
float t11622 = (t11621*float(842.378));
float t11623 = fract(t11622);
float t11624 = (t11623+float(45.32));
float t11625 = (t11624+u6.u0);
float t11626 = (t11623*t11625);
float t11627 = (t10016/t10013);
float t11628 = (t11627*float(1734.048));
float t11629 = fract(t11628);
float t11630 = (t11629+float(45.32));
float t11631 = (t11630+u6.u0);
float t11632 = (t11629*t11631);
float t11633 = (t11626+t11632);
float t11634 = (t11623+t11633);
float t11635 = (t11629+t11633);
float t11636 = (t11634*t11635);
float t11637 = fract(t11636);
float t11638 = (t11637*float(8.0e-3));
float t11639 = (float(1.0e-3)+t11638);
float t11640 = (t11637*173);
float t11641 = fract(t11640);
float t11642 = step(float(0.66),t11641);
float t11643 = (t11642*float(3.0e-3));
float t11644 = (t11639-t11643);
float t11645 = (t11644*float(0.4));
float t11646 = (t10663/245);
float t11647 = (t11646*float(842.378));
float t11648 = fract(t11647);
float t11649 = (t11648+float(45.32));
float t11650 = (t11649+u6.u0);
float t11651 = (t11648*t11650);
float t11652 = (t10679/t10676);
float t11653 = (t11652*float(1734.048));
float t11654 = fract(t11653);
float t11655 = (t11654+float(45.32));
float t11656 = (t11655+u6.u0);
float t11657 = (t11654*t11656);
float t11658 = (t11651+t11657);
float t11659 = (t11648+t11658);
float t11660 = (t11654+t11658);
float t11661 = (t11659*t11660);
float t11662 = fract(t11661);
float t11663 = (t11662*float(8.0e-3));
float t11664 = (float(1.0e-3)+t11663);
float t11665 = (t11662*173);
float t11666 = fract(t11665);
float t11667 = step(float(0.66),t11666);
float t11668 = (t11667*float(3.0e-3));
float t11669 = (t11664-t11668);
float t11670 = (t11669*float(0.4));
float t11671 = (t11645-t11670);
float t11672 = abs(t11671);
float t11673 = (t11672-float(1.0e-3));
float t11674 = (t11673/float(8.0e-3));
float t11675 = (1-t11674);
float t11676 = (t11675*t11675);
float t11677 = (t11620*t11676);
float t11678 = (t11588*t11677);
float t11679 = (u4.u0*t11586);
float t11680 = (t11679*3);
float t11681 = sin(t11680);
float t11682 = (t11681+1);
float t11683 = (t11682/2);
float t11684 = (t11683*float(0.66));
float t11685 = (t11684+float(0.33));
float t11686 = (t11678*t11685);
float t11687 = (float(0.2)*t11686);
bool t11688 = (0>=t11687);
float t11689;
if(t11688){
t11689 = 0;
} else {
t11689 = t11687;
}
float t11690 = (t11689*0);
float t11691 = (t11290+t11690);
float t11692 = (t10663*t9998);
float t11693 = (t10663/245);
float t11694 = (t11693*float(842.378));
float t11695 = fract(t11694);
float t11696 = (t11695+float(45.32));
float t11697 = (t11696+u6.u0);
float t11698 = (t11695*t11697);
float t11699 = (t10679+1);
float t11700 = (t11699/t10676);
float t11701 = (t11700*float(1734.048));
float t11702 = fract(t11701);
float t11703 = (t11702+float(45.32));
float t11704 = (t11703+u6.u0);
float t11705 = (t11702*t11704);
float t11706 = (t11698+t11705);
float t11707 = (t11695+t11706);
float t11708 = (t11702+t11706);
float t11709 = (t11707*t11708);
float t11710 = fract(t11709);
float t11711 = (t11710*float(2852.02));
float t11712 = fract(t11711);
float t11713 = (t11712-float(0.5));
float t11714 = (t11713*t9998);
float t11715 = (t11714*float(0.75));
float t11716 = (t11692+t11715);
float t11717 = (3.1415927/2);
float t11718 = (t11716-t11717);
float t11719 = (t10663*t9998);
float t11720 = (t10663/245);
float t11721 = (t11720*float(842.378));
float t11722 = fract(t11721);
float t11723 = (t11722+float(45.32));
float t11724 = (t11723+u6.u0);
float t11725 = (t11722*t11724);
float t11726 = (t10679/t10676);
float t11727 = (t11726*float(1734.048));
float t11728 = fract(t11727);
float t11729 = (t11728+float(45.32));
float t11730 = (t11729+u6.u0);
float t11731 = (t11728*t11730);
float t11732 = (t11725+t11731);
float t11733 = (t11722+t11732);
float t11734 = (t11728+t11732);
float t11735 = (t11733*t11734);
float t11736 = fract(t11735);
float t11737 = (t11736*float(2852.02));
float t11738 = fract(t11737);
float t11739 = (t11738-float(0.5));
float t11740 = (t11739*t9998);
float t11741 = (t11740*float(0.75));
float t11742 = (t11719+t11741);
float t11743 = (3.1415927/2);
float t11744 = (t11742-t11743);
float t11745 = (t11718-t11744);
float t11746 = abs(t11745);
float t11747 = (t11746/2);
float t11748 = sin(t11747);
float t11749 = (t11748*t11748);
float t11750 = cos(t11744);
float t11751 = cos(t11718);
float t11752 = (t11750*t11751);
float t11753 = (3.1415927/t10676);
float t11754 = (t11699*t11753);
float t11755 = (t11710*float(97372.83));
float t11756 = fract(t11755);
float t11757 = (t11756-float(0.5));
float t11758 = (3.1415927/t10676);
float t11759 = (t11757*t11758);
float t11760 = (t11759*float(0.75));
float t11761 = (t11754+t11760);
float t11762 = (t11761+3.1415927);
float t11763 = mod(t11762,t1433);
float t11764 = (t11763-3.1415927);
float t11765 = (t11764+3.1415927);
float t11766 = (3.1415927*2);
float t11767 = mod(t11765,t11766);
float t11768 = (t11767-3.1415927);
float t11769 = (3.1415927/t10676);
float t11770 = (t10679*t11769);
float t11771 = (t11736*float(97372.83));
float t11772 = fract(t11771);
float t11773 = (t11772-float(0.5));
float t11774 = (3.1415927/t10676);
float t11775 = (t11773*t11774);
float t11776 = (t11775*float(0.75));
float t11777 = (t11770+t11776);
float t11778 = (t11777+3.1415927);
float t11779 = mod(t11778,t1433);
float t11780 = (t11779-3.1415927);
float t11781 = (t11780+3.1415927);
float t11782 = (3.1415927*2);
float t11783 = mod(t11781,t11782);
float t11784 = (t11783-3.1415927);
float t11785 = (t11768-t11784);
float t11786 = abs(t11785);
float t11787 = (t11786/2);
float t11788 = sin(t11787);
float t11789 = (t11788*t11788);
float t11790 = (t11752*t11789);
float t11791 = (t11749+t11790);
float t11792 = sqrt(t11791);
float t11793 = asin(t11792);
float t11794 = (2*t11793);
float t11795 = (3.1415927/2);
float t11796 = (t8-t11795);
float t11797 = (3.1415927/2);
float t11798 = (t11742-t11797);
float t11799 = (t11796-t11798);
float t11800 = abs(t11799);
float t11801 = (t11800/2);
float t11802 = sin(t11801);
float t11803 = (t11802*t11802);
float t11804 = cos(t11798);
float t11805 = cos(t11796);
float t11806 = (t11804*t11805);
float t11807 = (t118+3.1415927);
float t11808 = (3.1415927*2);
float t11809 = mod(t11807,t11808);
float t11810 = (t11809-3.1415927);
float t11811 = (t11780+3.1415927);
float t11812 = (3.1415927*2);
float t11813 = mod(t11811,t11812);
float t11814 = (t11813-3.1415927);
float t11815 = (t11810-t11814);
float t11816 = abs(t11815);
float t11817 = (t11816/2);
float t11818 = sin(t11817);
float t11819 = (t11818*t11818);
float t11820 = (t11806*t11819);
float t11821 = (t11803+t11820);
float t11822 = sqrt(t11821);
float t11823 = asin(t11822);
float t11824 = (2*t11823);
float t11825 = (t11794-t11824);
float t11826 = (3.1415927/2);
float t11827 = (t8-t11826);
float t11828 = (3.1415927/2);
float t11829 = (t11716-t11828);
float t11830 = (t11827-t11829);
float t11831 = abs(t11830);
float t11832 = (t11831/2);
float t11833 = sin(t11832);
float t11834 = (t11833*t11833);
float t11835 = cos(t11829);
float t11836 = cos(t11827);
float t11837 = (t11835*t11836);
float t11838 = (t118+3.1415927);
float t11839 = (3.1415927*2);
float t11840 = mod(t11838,t11839);
float t11841 = (t11840-3.1415927);
float t11842 = (t11764+3.1415927);
float t11843 = (3.1415927*2);
float t11844 = mod(t11842,t11843);
float t11845 = (t11844-3.1415927);
float t11846 = (t11841-t11845);
float t11847 = abs(t11846);
float t11848 = (t11847/2);
float t11849 = sin(t11848);
float t11850 = (t11849*t11849);
float t11851 = (t11837*t11850);
float t11852 = (t11834+t11851);
float t11853 = sqrt(t11852);
float t11854 = asin(t11853);
float t11855 = (2*t11854);
float t11856 = (t11825-t11855);
float t11857 = abs(t11856);
bool t11858 = (float(1.0e-4)>t11857);
float t11859;
if(t11858){
float t11860 = cos(t11742);
float t11861 = (1*t11860);
float t11862 = sin(t11716);
float t11863 = (1*t11862);
float t11864 = cos(t11764);
float t11865 = (t11863*t11864);
float t11866 = (t11861*t11865);
float t11867 = sin(t11742);
float t11868 = (1*t11867);
float t11869 = cos(t11780);
float t11870 = (t11868*t11869);
float t11871 = cos(t11716);
float t11872 = (1*t11871);
float t11873 = (t11870*t11872);
float t11874 = (t11866-t11873);
float t11875 = sin(t8);
float t11876 = (1*t11875);
float t11877 = sin(t118);
float t11878 = (t11876*t11877);
float t11879 = (t11874*t11878);
float t11880 = sin(t11716);
float t11881 = (1*t11880);
float t11882 = sin(t11764);
float t11883 = (t11881*t11882);
float t11884 = (t11870*t11883);
float t11885 = sin(t11742);
float t11886 = (1*t11885);
float t11887 = sin(t11780);
float t11888 = (t11886*t11887);
float t11889 = (t11888*t11865);
float t11890 = (t11884-t11889);
float t11891 = cos(t8);
float t11892 = (1*t11891);
float t11893 = (t11890*t11892);
float t11894 = (t11879+t11893);
float t11895 = (t11888*t11872);
float t11896 = (t11861*t11883);
float t11897 = (t11895-t11896);
float t11898 = sin(t8);
float t11899 = (1*t11898);
float t11900 = cos(t118);
float t11901 = (t11899*t11900);
float t11902 = (t11897*t11901);
float t11903 = (t11894+t11902);
float t11904 = abs(t11903);
t11859 = t11904;
} else {
float t11905 = (3.1415927/2);
float t11906 = (t8-t11905);
float t11907 = (3.1415927/2);
float t11908 = (t11716-t11907);
float t11909 = (t11906-t11908);
float t11910 = abs(t11909);
float t11911 = (t11910/2);
float t11912 = sin(t11911);
float t11913 = (t11912*t11912);
float t11914 = cos(t11908);
float t11915 = cos(t11906);
float t11916 = (t11914*t11915);
float t11917 = (t118+3.1415927);
float t11918 = (3.1415927*2);
float t11919 = mod(t11917,t11918);
float t11920 = (t11919-3.1415927);
float t11921 = (t11764+3.1415927);
float t11922 = (3.1415927*2);
float t11923 = mod(t11921,t11922);
float t11924 = (t11923-3.1415927);
float t11925 = (t11920-t11924);
float t11926 = abs(t11925);
float t11927 = (t11926/2);
float t11928 = sin(t11927);
float t11929 = (t11928*t11928);
float t11930 = (t11916*t11929);
float t11931 = (t11913+t11930);
float t11932 = sqrt(t11931);
float t11933 = asin(t11932);
float t11934 = (2*t11933);
float t11935 = abs(t11934);
float t11936 = (3.1415927/2);
float t11937 = (t8-t11936);
float t11938 = (3.1415927/2);
float t11939 = (t11742-t11938);
float t11940 = (t11937-t11939);
float t11941 = abs(t11940);
float t11942 = (t11941/2);
float t11943 = sin(t11942);
float t11944 = (t11943*t11943);
float t11945 = cos(t11939);
float t11946 = cos(t11937);
float t11947 = (t11945*t11946);
float t11948 = (t118+3.1415927);
float t11949 = (3.1415927*2);
float t11950 = mod(t11948,t11949);
float t11951 = (t11950-3.1415927);
float t11952 = (t11780+3.1415927);
float t11953 = (3.1415927*2);
float t11954 = mod(t11952,t11953);
float t11955 = (t11954-3.1415927);
float t11956 = (t11951-t11955);
float t11957 = abs(t11956);
float t11958 = (t11957/2);
float t11959 = sin(t11958);
float t11960 = (t11959*t11959);
float t11961 = (t11947*t11960);
float t11962 = (t11944+t11961);
float t11963 = sqrt(t11962);
float t11964 = asin(t11963);
float t11965 = (2*t11964);
float t11966 = abs(t11965);
bool t11967 = (t11935>=t11966);
float t11968;
if(t11967){
t11968 = t11935;
} else {
t11968 = t11966;
}
t11859 = t11968;
}
float t11969 = abs(t11859);
float t11970 = step(float(2.0e-4),t11969);
float t11971 = (1-t11970);
float t11972 = (t10663*t11699);
float t11973 = (t11972*float(842.378));
float t11974 = fract(t11973);
float t11975 = (t11974+float(45.32));
float t11976 = (t11975+u6.u0);
float t11977 = (t11974*t11976);
float t11978 = (t10679*t10663);
float t11979 = (t11978*float(1734.048));
float t11980 = fract(t11979);
float t11981 = (t11980+float(45.32));
float t11982 = (t11981+u6.u0);
float t11983 = (t11980*t11982);
float t11984 = (t11977+t11983);
float t11985 = (t11974+t11984);
float t11986 = (t11980+t11984);
float t11987 = (t11985*t11986);
float t11988 = fract(t11987);
float t11989 = step(float(0.2),t11988);
float t11990 = (t11971*t11989);
float t11991 = (3.1415927/2);
float t11992 = (t11716-t11991);
float t11993 = (3.1415927/2);
float t11994 = (t11742-t11993);
float t11995 = (t11992-t11994);
float t11996 = abs(t11995);
float t11997 = (t11996/2);
float t11998 = sin(t11997);
float t11999 = (t11998*t11998);
float t12000 = cos(t11994);
float t12001 = cos(t11992);
float t12002 = (t12000*t12001);
float t12003 = (t11764+3.1415927);
float t12004 = (3.1415927*2);
float t12005 = mod(t12003,t12004);
float t12006 = (t12005-3.1415927);
float t12007 = (t11780+3.1415927);
float t12008 = (3.1415927*2);
float t12009 = mod(t12007,t12008);
float t12010 = (t12009-3.1415927);
float t12011 = (t12006-t12010);
float t12012 = abs(t12011);
float t12013 = (t12012/2);
float t12014 = sin(t12013);
float t12015 = (t12014*t12014);
float t12016 = (t12002*t12015);
float t12017 = (t11999+t12016);
float t12018 = sqrt(t12017);
float t12019 = asin(t12018);
float t12020 = (2*t12019);
float t12021 = (t12020/t9998);
float t12022 = (1-t12021);
float t12023 = (t10663/245);
float t12024 = (t12023*float(842.378));
float t12025 = fract(t12024);
float t12026 = (t12025+float(45.32));
float t12027 = (t12026+u6.u0);
float t12028 = (t12025*t12027);
float t12029 = (t10679/t10676);
float t12030 = (t12029*float(1734.048));
float t12031 = fract(t12030);
float t12032 = (t12031+float(45.32));
float t12033 = (t12032+u6.u0);
float t12034 = (t12031*t12033);
float t12035 = (t12028+t12034);
float t12036 = (t12025+t12035);
float t12037 = (t12031+t12035);
float t12038 = (t12036*t12037);
float t12039 = fract(t12038);
float t12040 = (t12039*float(8.0e-3));
float t12041 = (float(1.0e-3)+t12040);
float t12042 = (t12039*173);
float t12043 = fract(t12042);
float t12044 = step(float(0.66),t12043);
float t12045 = (t12044*float(3.0e-3));
float t12046 = (t12041-t12045);
float t12047 = (t12046*float(0.4));
float t12048 = (t10663/245);
float t12049 = (t12048*float(842.378));
float t12050 = fract(t12049);
float t12051 = (t12050+float(45.32));
float t12052 = (t12051+u6.u0);
float t12053 = (t12050*t12052);
float t12054 = (t11699/t10676);
float t12055 = (t12054*float(1734.048));
float t12056 = fract(t12055);
float t12057 = (t12056+float(45.32));
float t12058 = (t12057+u6.u0);
float t12059 = (t12056*t12058);
float t12060 = (t12053+t12059);
float t12061 = (t12050+t12060);
float t12062 = (t12056+t12060);
float t12063 = (t12061*t12062);
float t12064 = fract(t12063);
float t12065 = (t12064*float(8.0e-3));
float t12066 = (float(1.0e-3)+t12065);
float t12067 = (t12064*173);
float t12068 = fract(t12067);
float t12069 = step(float(0.66),t12068);
float t12070 = (t12069*float(3.0e-3));
float t12071 = (t12066-t12070);
float t12072 = (t12071*float(0.4));
float t12073 = (t12047-t12072);
float t12074 = abs(t12073);
float t12075 = (t12074-float(1.0e-3));
float t12076 = (t12075/float(8.0e-3));
float t12077 = (1-t12076);
float t12078 = (t12077*t12077);
float t12079 = (t12022*t12078);
float t12080 = (t11990*t12079);
float t12081 = (u4.u0*t11988);
float t12082 = (t12081*3);
float t12083 = sin(t12082);
float t12084 = (t12083+1);
float t12085 = (t12084/2);
float t12086 = (t12085*float(0.66));
float t12087 = (t12086+float(0.33));
float t12088 = (t12080*t12087);
float t12089 = (float(0.2)*t12088);
bool t12090 = (0>=t12089);
float t12091;
if(t12090){
t12091 = 0;
} else {
t12091 = t12089;
}
float t12092 = (t12091*0);
float t12093 = (t11691+t12092);
float t12094 = (t10663*t9998);
float t12095 = (t10663/245);
float t12096 = (t12095*float(842.378));
float t12097 = fract(t12096);
float t12098 = (t12097+float(45.32));
float t12099 = (t12098+u6.u0);
float t12100 = (t12097*t12099);
float t12101 = (t11699/t10676);
float t12102 = (t12101*float(1734.048));
float t12103 = fract(t12102);
float t12104 = (t12103+float(45.32));
float t12105 = (t12104+u6.u0);
float t12106 = (t12103*t12105);
float t12107 = (t12100+t12106);
float t12108 = (t12097+t12107);
float t12109 = (t12103+t12107);
float t12110 = (t12108*t12109);
float t12111 = fract(t12110);
float t12112 = (t12111*float(2852.02));
float t12113 = fract(t12112);
float t12114 = (t12113-float(0.5));
float t12115 = (t12114*t9998);
float t12116 = (t12115*float(0.75));
float t12117 = (t12094+t12116);
float t12118 = (3.1415927/2);
float t12119 = (t12117-t12118);
float t12120 = (t10000*t9998);
float t12121 = (t10000/245);
float t12122 = (t12121*float(842.378));
float t12123 = fract(t12122);
float t12124 = (t12123+float(45.32));
float t12125 = (t12124+u6.u0);
float t12126 = (t12123*t12125);
float t12127 = (t10234/t10013);
float t12128 = (t12127*float(1734.048));
float t12129 = fract(t12128);
float t12130 = (t12129+float(45.32));
float t12131 = (t12130+u6.u0);
float t12132 = (t12129*t12131);
float t12133 = (t12126+t12132);
float t12134 = (t12123+t12133);
float t12135 = (t12129+t12133);
float t12136 = (t12134*t12135);
float t12137 = fract(t12136);
float t12138 = (t12137*float(2852.02));
float t12139 = fract(t12138);
float t12140 = (t12139-float(0.5));
float t12141 = (t12140*t9998);
float t12142 = (t12141*float(0.75));
float t12143 = (t12120+t12142);
float t12144 = (3.1415927/2);
float t12145 = (t12143-t12144);
float t12146 = (t12119-t12145);
float t12147 = abs(t12146);
float t12148 = (t12147/2);
float t12149 = sin(t12148);
float t12150 = (t12149*t12149);
float t12151 = cos(t12145);
float t12152 = cos(t12119);
float t12153 = (t12151*t12152);
float t12154 = (3.1415927/t10676);
float t12155 = (t11699*t12154);
float t12156 = (t12111*float(97372.83));
float t12157 = fract(t12156);
float t12158 = (t12157-float(0.5));
float t12159 = (3.1415927/t10676);
float t12160 = (t12158*t12159);
float t12161 = (t12160*float(0.75));
float t12162 = (t12155+t12161);
float t12163 = (t12162+3.1415927);
float t12164 = mod(t12163,t1433);
float t12165 = (t12164-3.1415927);
float t12166 = (t12165+3.1415927);
float t12167 = (3.1415927*2);
float t12168 = mod(t12166,t12167);
float t12169 = (t12168-3.1415927);
float t12170 = (3.1415927/t10013);
float t12171 = (t10234*t12170);
float t12172 = (t12137*float(97372.83));
float t12173 = fract(t12172);
float t12174 = (t12173-float(0.5));
float t12175 = (3.1415927/t10013);
float t12176 = (t12174*t12175);
float t12177 = (t12176*float(0.75));
float t12178 = (t12171+t12177);
float t12179 = (t12178+3.1415927);
float t12180 = mod(t12179,t1433);
float t12181 = (t12180-3.1415927);
float t12182 = (t12181+3.1415927);
float t12183 = (3.1415927*2);
float t12184 = mod(t12182,t12183);
float t12185 = (t12184-3.1415927);
float t12186 = (t12169-t12185);
float t12187 = abs(t12186);
float t12188 = (t12187/2);
float t12189 = sin(t12188);
float t12190 = (t12189*t12189);
float t12191 = (t12153*t12190);
float t12192 = (t12150+t12191);
float t12193 = sqrt(t12192);
float t12194 = asin(t12193);
float t12195 = (2*t12194);
float t12196 = (3.1415927/2);
float t12197 = (t8-t12196);
float t12198 = (3.1415927/2);
float t12199 = (t12143-t12198);
float t12200 = (t12197-t12199);
float t12201 = abs(t12200);
float t12202 = (t12201/2);
float t12203 = sin(t12202);
float t12204 = (t12203*t12203);
float t12205 = cos(t12199);
float t12206 = cos(t12197);
float t12207 = (t12205*t12206);
float t12208 = (t118+3.1415927);
float t12209 = (3.1415927*2);
float t12210 = mod(t12208,t12209);
float t12211 = (t12210-3.1415927);
float t12212 = (t12181+3.1415927);
float t12213 = (3.1415927*2);
float t12214 = mod(t12212,t12213);
float t12215 = (t12214-3.1415927);
float t12216 = (t12211-t12215);
float t12217 = abs(t12216);
float t12218 = (t12217/2);
float t12219 = sin(t12218);
float t12220 = (t12219*t12219);
float t12221 = (t12207*t12220);
float t12222 = (t12204+t12221);
float t12223 = sqrt(t12222);
float t12224 = asin(t12223);
float t12225 = (2*t12224);
float t12226 = (t12195-t12225);
float t12227 = (3.1415927/2);
float t12228 = (t8-t12227);
float t12229 = (3.1415927/2);
float t12230 = (t12117-t12229);
float t12231 = (t12228-t12230);
float t12232 = abs(t12231);
float t12233 = (t12232/2);
float t12234 = sin(t12233);
float t12235 = (t12234*t12234);
float t12236 = cos(t12230);
float t12237 = cos(t12228);
float t12238 = (t12236*t12237);
float t12239 = (t118+3.1415927);
float t12240 = (3.1415927*2);
float t12241 = mod(t12239,t12240);
float t12242 = (t12241-3.1415927);
float t12243 = (t12165+3.1415927);
float t12244 = (3.1415927*2);
float t12245 = mod(t12243,t12244);
float t12246 = (t12245-3.1415927);
float t12247 = (t12242-t12246);
float t12248 = abs(t12247);
float t12249 = (t12248/2);
float t12250 = sin(t12249);
float t12251 = (t12250*t12250);
float t12252 = (t12238*t12251);
float t12253 = (t12235+t12252);
float t12254 = sqrt(t12253);
float t12255 = asin(t12254);
float t12256 = (2*t12255);
float t12257 = (t12226-t12256);
float t12258 = abs(t12257);
bool t12259 = (float(1.0e-4)>t12258);
float t12260;
if(t12259){
float t12261 = cos(t12143);
float t12262 = (1*t12261);
float t12263 = sin(t12117);
float t12264 = (1*t12263);
float t12265 = cos(t12165);
float t12266 = (t12264*t12265);
float t12267 = (t12262*t12266);
float t12268 = sin(t12143);
float t12269 = (1*t12268);
float t12270 = cos(t12181);
float t12271 = (t12269*t12270);
float t12272 = cos(t12117);
float t12273 = (1*t12272);
float t12274 = (t12271*t12273);
float t12275 = (t12267-t12274);
float t12276 = sin(t8);
float t12277 = (1*t12276);
float t12278 = sin(t118);
float t12279 = (t12277*t12278);
float t12280 = (t12275*t12279);
float t12281 = sin(t12117);
float t12282 = (1*t12281);
float t12283 = sin(t12165);
float t12284 = (t12282*t12283);
float t12285 = (t12271*t12284);
float t12286 = sin(t12143);
float t12287 = (1*t12286);
float t12288 = sin(t12181);
float t12289 = (t12287*t12288);
float t12290 = (t12289*t12266);
float t12291 = (t12285-t12290);
float t12292 = cos(t8);
float t12293 = (1*t12292);
float t12294 = (t12291*t12293);
float t12295 = (t12280+t12294);
float t12296 = (t12289*t12273);
float t12297 = (t12262*t12284);
float t12298 = (t12296-t12297);
float t12299 = sin(t8);
float t12300 = (1*t12299);
float t12301 = cos(t118);
float t12302 = (t12300*t12301);
float t12303 = (t12298*t12302);
float t12304 = (t12295+t12303);
float t12305 = abs(t12304);
t12260 = t12305;
} else {
float t12306 = (3.1415927/2);
float t12307 = (t8-t12306);
float t12308 = (3.1415927/2);
float t12309 = (t12117-t12308);
float t12310 = (t12307-t12309);
float t12311 = abs(t12310);
float t12312 = (t12311/2);
float t12313 = sin(t12312);
float t12314 = (t12313*t12313);
float t12315 = cos(t12309);
float t12316 = cos(t12307);
float t12317 = (t12315*t12316);
float t12318 = (t118+3.1415927);
float t12319 = (3.1415927*2);
float t12320 = mod(t12318,t12319);
float t12321 = (t12320-3.1415927);
float t12322 = (t12165+3.1415927);
float t12323 = (3.1415927*2);
float t12324 = mod(t12322,t12323);
float t12325 = (t12324-3.1415927);
float t12326 = (t12321-t12325);
float t12327 = abs(t12326);
float t12328 = (t12327/2);
float t12329 = sin(t12328);
float t12330 = (t12329*t12329);
float t12331 = (t12317*t12330);
float t12332 = (t12314+t12331);
float t12333 = sqrt(t12332);
float t12334 = asin(t12333);
float t12335 = (2*t12334);
float t12336 = abs(t12335);
float t12337 = (3.1415927/2);
float t12338 = (t8-t12337);
float t12339 = (3.1415927/2);
float t12340 = (t12143-t12339);
float t12341 = (t12338-t12340);
float t12342 = abs(t12341);
float t12343 = (t12342/2);
float t12344 = sin(t12343);
float t12345 = (t12344*t12344);
float t12346 = cos(t12340);
float t12347 = cos(t12338);
float t12348 = (t12346*t12347);
float t12349 = (t118+3.1415927);
float t12350 = (3.1415927*2);
float t12351 = mod(t12349,t12350);
float t12352 = (t12351-3.1415927);
float t12353 = (t12181+3.1415927);
float t12354 = (3.1415927*2);
float t12355 = mod(t12353,t12354);
float t12356 = (t12355-3.1415927);
float t12357 = (t12352-t12356);
float t12358 = abs(t12357);
float t12359 = (t12358/2);
float t12360 = sin(t12359);
float t12361 = (t12360*t12360);
float t12362 = (t12348*t12361);
float t12363 = (t12345+t12362);
float t12364 = sqrt(t12363);
float t12365 = asin(t12364);
float t12366 = (2*t12365);
float t12367 = abs(t12366);
bool t12368 = (t12336>=t12367);
float t12369;
if(t12368){
t12369 = t12336;
} else {
t12369 = t12367;
}
t12260 = t12369;
}
float t12370 = abs(t12260);
float t12371 = step(float(2.0e-4),t12370);
float t12372 = (1-t12371);
float t12373 = (t10000*t11699);
float t12374 = (t12373*float(842.378));
float t12375 = fract(t12374);
float t12376 = (t12375+float(45.32));
float t12377 = (t12376+u6.u0);
float t12378 = (t12375*t12377);
float t12379 = (t10234*t10663);
float t12380 = (t12379*float(1734.048));
float t12381 = fract(t12380);
float t12382 = (t12381+float(45.32));
float t12383 = (t12382+u6.u0);
float t12384 = (t12381*t12383);
float t12385 = (t12378+t12384);
float t12386 = (t12375+t12385);
float t12387 = (t12381+t12385);
float t12388 = (t12386*t12387);
float t12389 = fract(t12388);
float t12390 = step(float(0.2),t12389);
float t12391 = (t12372*t12390);
float t12392 = (3.1415927/2);
float t12393 = (t12117-t12392);
float t12394 = (3.1415927/2);
float t12395 = (t12143-t12394);
float t12396 = (t12393-t12395);
float t12397 = abs(t12396);
float t12398 = (t12397/2);
float t12399 = sin(t12398);
float t12400 = (t12399*t12399);
float t12401 = cos(t12395);
float t12402 = cos(t12393);
float t12403 = (t12401*t12402);
float t12404 = (t12165+3.1415927);
float t12405 = (3.1415927*2);
float t12406 = mod(t12404,t12405);
float t12407 = (t12406-3.1415927);
float t12408 = (t12181+3.1415927);
float t12409 = (3.1415927*2);
float t12410 = mod(t12408,t12409);
float t12411 = (t12410-3.1415927);
float t12412 = (t12407-t12411);
float t12413 = abs(t12412);
float t12414 = (t12413/2);
float t12415 = sin(t12414);
float t12416 = (t12415*t12415);
float t12417 = (t12403*t12416);
float t12418 = (t12400+t12417);
float t12419 = sqrt(t12418);
float t12420 = asin(t12419);
float t12421 = (2*t12420);
float t12422 = (t12421/t9998);
float t12423 = (1-t12422);
float t12424 = (t10000/245);
float t12425 = (t12424*float(842.378));
float t12426 = fract(t12425);
float t12427 = (t12426+float(45.32));
float t12428 = (t12427+u6.u0);
float t12429 = (t12426*t12428);
float t12430 = (t10234/t10013);
float t12431 = (t12430*float(1734.048));
float t12432 = fract(t12431);
float t12433 = (t12432+float(45.32));
float t12434 = (t12433+u6.u0);
float t12435 = (t12432*t12434);
float t12436 = (t12429+t12435);
float t12437 = (t12426+t12436);
float t12438 = (t12432+t12436);
float t12439 = (t12437*t12438);
float t12440 = fract(t12439);
float t12441 = (t12440*float(8.0e-3));
float t12442 = (float(1.0e-3)+t12441);
float t12443 = (t12440*173);
float t12444 = fract(t12443);
float t12445 = step(float(0.66),t12444);
float t12446 = (t12445*float(3.0e-3));
float t12447 = (t12442-t12446);
float t12448 = (t12447*float(0.4));
float t12449 = (t10663/245);
float t12450 = (t12449*float(842.378));
float t12451 = fract(t12450);
float t12452 = (t12451+float(45.32));
float t12453 = (t12452+u6.u0);
float t12454 = (t12451*t12453);
float t12455 = (t11699/t10676);
float t12456 = (t12455*float(1734.048));
float t12457 = fract(t12456);
float t12458 = (t12457+float(45.32));
float t12459 = (t12458+u6.u0);
float t12460 = (t12457*t12459);
float t12461 = (t12454+t12460);
float t12462 = (t12451+t12461);
float t12463 = (t12457+t12461);
float t12464 = (t12462*t12463);
float t12465 = fract(t12464);
float t12466 = (t12465*float(8.0e-3));
float t12467 = (float(1.0e-3)+t12466);
float t12468 = (t12465*173);
float t12469 = fract(t12468);
float t12470 = step(float(0.66),t12469);
float t12471 = (t12470*float(3.0e-3));
float t12472 = (t12467-t12471);
float t12473 = (t12472*float(0.4));
float t12474 = (t12448-t12473);
float t12475 = abs(t12474);
float t12476 = (t12475-float(1.0e-3));
float t12477 = (t12476/float(8.0e-3));
float t12478 = (1-t12477);
float t12479 = (t12478*t12478);
float t12480 = (t12423*t12479);
float t12481 = (t12391*t12480);
float t12482 = (u4.u0*t12389);
float t12483 = (t12482*3);
float t12484 = sin(t12483);
float t12485 = (t12484+1);
float t12486 = (t12485/2);
float t12487 = (t12486*float(0.66));
float t12488 = (t12487+float(0.33));
float t12489 = (t12481*t12488);
float t12490 = (float(0.2)*t12489);
bool t12491 = (0>=t12490);
float t12492;
if(t12491){
t12492 = 0;
} else {
t12492 = t12490;
}
float t12493 = (t12492*0);
float t12494 = (t12093+t12493);
float t12495 = (t10663*t9998);
float t12496 = (t10663/245);
float t12497 = (t12496*float(842.378));
float t12498 = fract(t12497);
float t12499 = (t12498+float(45.32));
float t12500 = (t12499+u6.u0);
float t12501 = (t12498*t12500);
float t12502 = (t11699/t10676);
float t12503 = (t12502*float(1734.048));
float t12504 = fract(t12503);
float t12505 = (t12504+float(45.32));
float t12506 = (t12505+u6.u0);
float t12507 = (t12504*t12506);
float t12508 = (t12501+t12507);
float t12509 = (t12498+t12508);
float t12510 = (t12504+t12508);
float t12511 = (t12509*t12510);
float t12512 = fract(t12511);
float t12513 = (t12512*float(2852.02));
float t12514 = fract(t12513);
float t12515 = (t12514-float(0.5));
float t12516 = (t12515*t9998);
float t12517 = (t12516*float(0.75));
float t12518 = (t12495+t12517);
float t12519 = (3.1415927/2);
float t12520 = (t12518-t12519);
float t12521 = (t10000*t9998);
float t12522 = (t10000/245);
float t12523 = (t12522*float(842.378));
float t12524 = fract(t12523);
float t12525 = (t12524+float(45.32));
float t12526 = (t12525+u6.u0);
float t12527 = (t12524*t12526);
float t12528 = (t10016/t10013);
float t12529 = (t12528*float(1734.048));
float t12530 = fract(t12529);
float t12531 = (t12530+float(45.32));
float t12532 = (t12531+u6.u0);
float t12533 = (t12530*t12532);
float t12534 = (t12527+t12533);
float t12535 = (t12524+t12534);
float t12536 = (t12530+t12534);
float t12537 = (t12535*t12536);
float t12538 = fract(t12537);
float t12539 = (t12538*float(2852.02));
float t12540 = fract(t12539);
float t12541 = (t12540-float(0.5));
float t12542 = (t12541*t9998);
float t12543 = (t12542*float(0.75));
float t12544 = (t12521+t12543);
float t12545 = (3.1415927/2);
float t12546 = (t12544-t12545);
float t12547 = (t12520-t12546);
float t12548 = abs(t12547);
float t12549 = (t12548/2);
float t12550 = sin(t12549);
float t12551 = (t12550*t12550);
float t12552 = cos(t12546);
float t12553 = cos(t12520);
float t12554 = (t12552*t12553);
float t12555 = (3.1415927/t10676);
float t12556 = (t11699*t12555);
float t12557 = (t12512*float(97372.83));
float t12558 = fract(t12557);
float t12559 = (t12558-float(0.5));
float t12560 = (3.1415927/t10676);
float t12561 = (t12559*t12560);
float t12562 = (t12561*float(0.75));
float t12563 = (t12556+t12562);
float t12564 = (t12563+3.1415927);
float t12565 = mod(t12564,t1433);
float t12566 = (t12565-3.1415927);
float t12567 = (t12566+3.1415927);
float t12568 = (3.1415927*2);
float t12569 = mod(t12567,t12568);
float t12570 = (t12569-3.1415927);
float t12571 = (3.1415927/t10013);
float t12572 = (t10016*t12571);
float t12573 = (t12538*float(97372.83));
float t12574 = fract(t12573);
float t12575 = (t12574-float(0.5));
float t12576 = (3.1415927/t10013);
float t12577 = (t12575*t12576);
float t12578 = (t12577*float(0.75));
float t12579 = (t12572+t12578);
float t12580 = (t12579+3.1415927);
float t12581 = mod(t12580,t1433);
float t12582 = (t12581-3.1415927);
float t12583 = (t12582+3.1415927);
float t12584 = (3.1415927*2);
float t12585 = mod(t12583,t12584);
float t12586 = (t12585-3.1415927);
float t12587 = (t12570-t12586);
float t12588 = abs(t12587);
float t12589 = (t12588/2);
float t12590 = sin(t12589);
float t12591 = (t12590*t12590);
float t12592 = (t12554*t12591);
float t12593 = (t12551+t12592);
float t12594 = sqrt(t12593);
float t12595 = asin(t12594);
float t12596 = (2*t12595);
float t12597 = (3.1415927/2);
float t12598 = (t8-t12597);
float t12599 = (3.1415927/2);
float t12600 = (t12544-t12599);
float t12601 = (t12598-t12600);
float t12602 = abs(t12601);
float t12603 = (t12602/2);
float t12604 = sin(t12603);
float t12605 = (t12604*t12604);
float t12606 = cos(t12600);
float t12607 = cos(t12598);
float t12608 = (t12606*t12607);
float t12609 = (t118+3.1415927);
float t12610 = (3.1415927*2);
float t12611 = mod(t12609,t12610);
float t12612 = (t12611-3.1415927);
float t12613 = (t12582+3.1415927);
float t12614 = (3.1415927*2);
float t12615 = mod(t12613,t12614);
float t12616 = (t12615-3.1415927);
float t12617 = (t12612-t12616);
float t12618 = abs(t12617);
float t12619 = (t12618/2);
float t12620 = sin(t12619);
float t12621 = (t12620*t12620);
float t12622 = (t12608*t12621);
float t12623 = (t12605+t12622);
float t12624 = sqrt(t12623);
float t12625 = asin(t12624);
float t12626 = (2*t12625);
float t12627 = (t12596-t12626);
float t12628 = (3.1415927/2);
float t12629 = (t8-t12628);
float t12630 = (3.1415927/2);
float t12631 = (t12518-t12630);
float t12632 = (t12629-t12631);
float t12633 = abs(t12632);
float t12634 = (t12633/2);
float t12635 = sin(t12634);
float t12636 = (t12635*t12635);
float t12637 = cos(t12631);
float t12638 = cos(t12629);
float t12639 = (t12637*t12638);
float t12640 = (t118+3.1415927);
float t12641 = (3.1415927*2);
float t12642 = mod(t12640,t12641);
float t12643 = (t12642-3.1415927);
float t12644 = (t12566+3.1415927);
float t12645 = (3.1415927*2);
float t12646 = mod(t12644,t12645);
float t12647 = (t12646-3.1415927);
float t12648 = (t12643-t12647);
float t12649 = abs(t12648);
float t12650 = (t12649/2);
float t12651 = sin(t12650);
float t12652 = (t12651*t12651);
float t12653 = (t12639*t12652);
float t12654 = (t12636+t12653);
float t12655 = sqrt(t12654);
float t12656 = asin(t12655);
float t12657 = (2*t12656);
float t12658 = (t12627-t12657);
float t12659 = abs(t12658);
bool t12660 = (float(1.0e-4)>t12659);
float t12661;
if(t12660){
float t12662 = cos(t12544);
float t12663 = (1*t12662);
float t12664 = sin(t12518);
float t12665 = (1*t12664);
float t12666 = cos(t12566);
float t12667 = (t12665*t12666);
float t12668 = (t12663*t12667);
float t12669 = sin(t12544);
float t12670 = (1*t12669);
float t12671 = cos(t12582);
float t12672 = (t12670*t12671);
float t12673 = cos(t12518);
float t12674 = (1*t12673);
float t12675 = (t12672*t12674);
float t12676 = (t12668-t12675);
float t12677 = sin(t8);
float t12678 = (1*t12677);
float t12679 = sin(t118);
float t12680 = (t12678*t12679);
float t12681 = (t12676*t12680);
float t12682 = sin(t12518);
float t12683 = (1*t12682);
float t12684 = sin(t12566);
float t12685 = (t12683*t12684);
float t12686 = (t12672*t12685);
float t12687 = sin(t12544);
float t12688 = (1*t12687);
float t12689 = sin(t12582);
float t12690 = (t12688*t12689);
float t12691 = (t12690*t12667);
float t12692 = (t12686-t12691);
float t12693 = cos(t8);
float t12694 = (1*t12693);
float t12695 = (t12692*t12694);
float t12696 = (t12681+t12695);
float t12697 = (t12690*t12674);
float t12698 = (t12663*t12685);
float t12699 = (t12697-t12698);
float t12700 = sin(t8);
float t12701 = (1*t12700);
float t12702 = cos(t118);
float t12703 = (t12701*t12702);
float t12704 = (t12699*t12703);
float t12705 = (t12696+t12704);
float t12706 = abs(t12705);
t12661 = t12706;
} else {
float t12707 = (3.1415927/2);
float t12708 = (t8-t12707);
float t12709 = (3.1415927/2);
float t12710 = (t12518-t12709);
float t12711 = (t12708-t12710);
float t12712 = abs(t12711);
float t12713 = (t12712/2);
float t12714 = sin(t12713);
float t12715 = (t12714*t12714);
float t12716 = cos(t12710);
float t12717 = cos(t12708);
float t12718 = (t12716*t12717);
float t12719 = (t118+3.1415927);
float t12720 = (3.1415927*2);
float t12721 = mod(t12719,t12720);
float t12722 = (t12721-3.1415927);
float t12723 = (t12566+3.1415927);
float t12724 = (3.1415927*2);
float t12725 = mod(t12723,t12724);
float t12726 = (t12725-3.1415927);
float t12727 = (t12722-t12726);
float t12728 = abs(t12727);
float t12729 = (t12728/2);
float t12730 = sin(t12729);
float t12731 = (t12730*t12730);
float t12732 = (t12718*t12731);
float t12733 = (t12715+t12732);
float t12734 = sqrt(t12733);
float t12735 = asin(t12734);
float t12736 = (2*t12735);
float t12737 = abs(t12736);
float t12738 = (3.1415927/2);
float t12739 = (t8-t12738);
float t12740 = (3.1415927/2);
float t12741 = (t12544-t12740);
float t12742 = (t12739-t12741);
float t12743 = abs(t12742);
float t12744 = (t12743/2);
float t12745 = sin(t12744);
float t12746 = (t12745*t12745);
float t12747 = cos(t12741);
float t12748 = cos(t12739);
float t12749 = (t12747*t12748);
float t12750 = (t118+3.1415927);
float t12751 = (3.1415927*2);
float t12752 = mod(t12750,t12751);
float t12753 = (t12752-3.1415927);
float t12754 = (t12582+3.1415927);
float t12755 = (3.1415927*2);
float t12756 = mod(t12754,t12755);
float t12757 = (t12756-3.1415927);
float t12758 = (t12753-t12757);
float t12759 = abs(t12758);
float t12760 = (t12759/2);
float t12761 = sin(t12760);
float t12762 = (t12761*t12761);
float t12763 = (t12749*t12762);
float t12764 = (t12746+t12763);
float t12765 = sqrt(t12764);
float t12766 = asin(t12765);
float t12767 = (2*t12766);
float t12768 = abs(t12767);
bool t12769 = (t12737>=t12768);
float t12770;
if(t12769){
t12770 = t12737;
} else {
t12770 = t12768;
}
t12661 = t12770;
}
float t12771 = abs(t12661);
float t12772 = step(float(2.0e-4),t12771);
float t12773 = (1-t12772);
float t12774 = (t10000*t11699);
float t12775 = (t12774*float(842.378));
float t12776 = fract(t12775);
float t12777 = (t12776+float(45.32));
float t12778 = (t12777+u6.u0);
float t12779 = (t12776*t12778);
float t12780 = (t10016*t10663);
float t12781 = (t12780*float(1734.048));
float t12782 = fract(t12781);
float t12783 = (t12782+float(45.32));
float t12784 = (t12783+u6.u0);
float t12785 = (t12782*t12784);
float t12786 = (t12779+t12785);
float t12787 = (t12776+t12786);
float t12788 = (t12782+t12786);
float t12789 = (t12787*t12788);
float t12790 = fract(t12789);
float t12791 = step(float(0.2),t12790);
float t12792 = (t12773*t12791);
float t12793 = (3.1415927/2);
float t12794 = (t12518-t12793);
float t12795 = (3.1415927/2);
float t12796 = (t12544-t12795);
float t12797 = (t12794-t12796);
float t12798 = abs(t12797);
float t12799 = (t12798/2);
float t12800 = sin(t12799);
float t12801 = (t12800*t12800);
float t12802 = cos(t12796);
float t12803 = cos(t12794);
float t12804 = (t12802*t12803);
float t12805 = (t12566+3.1415927);
float t12806 = (3.1415927*2);
float t12807 = mod(t12805,t12806);
float t12808 = (t12807-3.1415927);
float t12809 = (t12582+3.1415927);
float t12810 = (3.1415927*2);
float t12811 = mod(t12809,t12810);
float t12812 = (t12811-3.1415927);
float t12813 = (t12808-t12812);
float t12814 = abs(t12813);
float t12815 = (t12814/2);
float t12816 = sin(t12815);
float t12817 = (t12816*t12816);
float t12818 = (t12804*t12817);
float t12819 = (t12801+t12818);
float t12820 = sqrt(t12819);
float t12821 = asin(t12820);
float t12822 = (2*t12821);
float t12823 = (t12822/t9998);
float t12824 = (1-t12823);
float t12825 = (t10000/245);
float t12826 = (t12825*float(842.378));
float t12827 = fract(t12826);
float t12828 = (t12827+float(45.32));
float t12829 = (t12828+u6.u0);
float t12830 = (t12827*t12829);
float t12831 = (t10016/t10013);
float t12832 = (t12831*float(1734.048));
float t12833 = fract(t12832);
float t12834 = (t12833+float(45.32));
float t12835 = (t12834+u6.u0);
float t12836 = (t12833*t12835);
float t12837 = (t12830+t12836);
float t12838 = (t12827+t12837);
float t12839 = (t12833+t12837);
float t12840 = (t12838*t12839);
float t12841 = fract(t12840);
float t12842 = (t12841*float(8.0e-3));
float t12843 = (float(1.0e-3)+t12842);
float t12844 = (t12841*173);
float t12845 = fract(t12844);
float t12846 = step(float(0.66),t12845);
float t12847 = (t12846*float(3.0e-3));
float t12848 = (t12843-t12847);
float t12849 = (t12848*float(0.4));
float t12850 = (t10663/245);
float t12851 = (t12850*float(842.378));
float t12852 = fract(t12851);
float t12853 = (t12852+float(45.32));
float t12854 = (t12853+u6.u0);
float t12855 = (t12852*t12854);
float t12856 = (t11699/t10676);
float t12857 = (t12856*float(1734.048));
float t12858 = fract(t12857);
float t12859 = (t12858+float(45.32));
float t12860 = (t12859+u6.u0);
float t12861 = (t12858*t12860);
float t12862 = (t12855+t12861);
float t12863 = (t12852+t12862);
float t12864 = (t12858+t12862);
float t12865 = (t12863*t12864);
float t12866 = fract(t12865);
float t12867 = (t12866*float(8.0e-3));
float t12868 = (float(1.0e-3)+t12867);
float t12869 = (t12866*173);
float t12870 = fract(t12869);
float t12871 = step(float(0.66),t12870);
float t12872 = (t12871*float(3.0e-3));
float t12873 = (t12868-t12872);
float t12874 = (t12873*float(0.4));
float t12875 = (t12849-t12874);
float t12876 = abs(t12875);
float t12877 = (t12876-float(1.0e-3));
float t12878 = (t12877/float(8.0e-3));
float t12879 = (1-t12878);
float t12880 = (t12879*t12879);
float t12881 = (t12824*t12880);
float t12882 = (t12792*t12881);
float t12883 = (u4.u0*t12790);
float t12884 = (t12883*3);
float t12885 = sin(t12884);
float t12886 = (t12885+1);
float t12887 = (t12886/2);
float t12888 = (t12887*float(0.66));
float t12889 = (t12888+float(0.33));
float t12890 = (t12882*t12889);
float t12891 = (float(0.2)*t12890);
bool t12892 = (0>=t12891);
float t12893;
if(t12892){
t12893 = 0;
} else {
t12893 = t12891;
}
float t12894 = (t12893*0);
float t12895 = (t12494+t12894);
float t12896 = (t10000*t9998);
float t12897 = (t10000/245);
float t12898 = (t12897*float(842.378));
float t12899 = fract(t12898);
float t12900 = (t12899+float(45.32));
float t12901 = (t12900+u6.u0);
float t12902 = (t12899*t12901);
float t12903 = (t10452/t10013);
float t12904 = (t12903*float(1734.048));
float t12905 = fract(t12904);
float t12906 = (t12905+float(45.32));
float t12907 = (t12906+u6.u0);
float t12908 = (t12905*t12907);
float t12909 = (t12902+t12908);
float t12910 = (t12899+t12909);
float t12911 = (t12905+t12909);
float t12912 = (t12910*t12911);
float t12913 = fract(t12912);
float t12914 = (t12913*float(2852.02));
float t12915 = fract(t12914);
float t12916 = (t12915-float(0.5));
float t12917 = (t12916*t9998);
float t12918 = (t12917*float(0.75));
float t12919 = (t12896+t12918);
float t12920 = (3.1415927/2);
float t12921 = (t12919-t12920);
float t12922 = (t10000*t9998);
float t12923 = (t10000/245);
float t12924 = (t12923*float(842.378));
float t12925 = fract(t12924);
float t12926 = (t12925+float(45.32));
float t12927 = (t12926+u6.u0);
float t12928 = (t12925*t12927);
float t12929 = (t10234/t10013);
float t12930 = (t12929*float(1734.048));
float t12931 = fract(t12930);
float t12932 = (t12931+float(45.32));
float t12933 = (t12932+u6.u0);
float t12934 = (t12931*t12933);
float t12935 = (t12928+t12934);
float t12936 = (t12925+t12935);
float t12937 = (t12931+t12935);
float t12938 = (t12936*t12937);
float t12939 = fract(t12938);
float t12940 = (t12939*float(2852.02));
float t12941 = fract(t12940);
float t12942 = (t12941-float(0.5));
float t12943 = (t12942*t9998);
float t12944 = (t12943*float(0.75));
float t12945 = (t12922+t12944);
float t12946 = (3.1415927/2);
float t12947 = (t12945-t12946);
float t12948 = (t12921-t12947);
float t12949 = abs(t12948);
float t12950 = (t12949/2);
float t12951 = sin(t12950);
float t12952 = (t12951*t12951);
float t12953 = cos(t12947);
float t12954 = cos(t12921);
float t12955 = (t12953*t12954);
float t12956 = (3.1415927/t10013);
float t12957 = (t10452*t12956);
float t12958 = (t12913*float(97372.83));
float t12959 = fract(t12958);
float t12960 = (t12959-float(0.5));
float t12961 = (3.1415927/t10013);
float t12962 = (t12960*t12961);
float t12963 = (t12962*float(0.75));
float t12964 = (t12957+t12963);
float t12965 = (t12964+3.1415927);
float t12966 = mod(t12965,t1433);
float t12967 = (t12966-3.1415927);
float t12968 = (t12967+3.1415927);
float t12969 = (3.1415927*2);
float t12970 = mod(t12968,t12969);
float t12971 = (t12970-3.1415927);
float t12972 = (3.1415927/t10013);
float t12973 = (t10234*t12972);
float t12974 = (t12939*float(97372.83));
float t12975 = fract(t12974);
float t12976 = (t12975-float(0.5));
float t12977 = (3.1415927/t10013);
float t12978 = (t12976*t12977);
float t12979 = (t12978*float(0.75));
float t12980 = (t12973+t12979);
float t12981 = (t12980+3.1415927);
float t12982 = mod(t12981,t1433);
float t12983 = (t12982-3.1415927);
float t12984 = (t12983+3.1415927);
float t12985 = (3.1415927*2);
float t12986 = mod(t12984,t12985);
float t12987 = (t12986-3.1415927);
float t12988 = (t12971-t12987);
float t12989 = abs(t12988);
float t12990 = (t12989/2);
float t12991 = sin(t12990);
float t12992 = (t12991*t12991);
float t12993 = (t12955*t12992);
float t12994 = (t12952+t12993);
float t12995 = sqrt(t12994);
float t12996 = asin(t12995);
float t12997 = (2*t12996);
float t12998 = (3.1415927/2);
float t12999 = (t8-t12998);
float t13000 = (3.1415927/2);
float t13001 = (t12945-t13000);
float t13002 = (t12999-t13001);
float t13003 = abs(t13002);
float t13004 = (t13003/2);
float t13005 = sin(t13004);
float t13006 = (t13005*t13005);
float t13007 = cos(t13001);
float t13008 = cos(t12999);
float t13009 = (t13007*t13008);
float t13010 = (t118+3.1415927);
float t13011 = (3.1415927*2);
float t13012 = mod(t13010,t13011);
float t13013 = (t13012-3.1415927);
float t13014 = (t12983+3.1415927);
float t13015 = (3.1415927*2);
float t13016 = mod(t13014,t13015);
float t13017 = (t13016-3.1415927);
float t13018 = (t13013-t13017);
float t13019 = abs(t13018);
float t13020 = (t13019/2);
float t13021 = sin(t13020);
float t13022 = (t13021*t13021);
float t13023 = (t13009*t13022);
float t13024 = (t13006+t13023);
float t13025 = sqrt(t13024);
float t13026 = asin(t13025);
float t13027 = (2*t13026);
float t13028 = (t12997-t13027);
float t13029 = (3.1415927/2);
float t13030 = (t8-t13029);
float t13031 = (3.1415927/2);
float t13032 = (t12919-t13031);
float t13033 = (t13030-t13032);
float t13034 = abs(t13033);
float t13035 = (t13034/2);
float t13036 = sin(t13035);
float t13037 = (t13036*t13036);
float t13038 = cos(t13032);
float t13039 = cos(t13030);
float t13040 = (t13038*t13039);
float t13041 = (t118+3.1415927);
float t13042 = (3.1415927*2);
float t13043 = mod(t13041,t13042);
float t13044 = (t13043-3.1415927);
float t13045 = (t12967+3.1415927);
float t13046 = (3.1415927*2);
float t13047 = mod(t13045,t13046);
float t13048 = (t13047-3.1415927);
float t13049 = (t13044-t13048);
float t13050 = abs(t13049);
float t13051 = (t13050/2);
float t13052 = sin(t13051);
float t13053 = (t13052*t13052);
float t13054 = (t13040*t13053);
float t13055 = (t13037+t13054);
float t13056 = sqrt(t13055);
float t13057 = asin(t13056);
float t13058 = (2*t13057);
float t13059 = (t13028-t13058);
float t13060 = abs(t13059);
bool t13061 = (float(1.0e-4)>t13060);
float t13062;
if(t13061){
float t13063 = cos(t12945);
float t13064 = (1*t13063);
float t13065 = sin(t12919);
float t13066 = (1*t13065);
float t13067 = cos(t12967);
float t13068 = (t13066*t13067);
float t13069 = (t13064*t13068);
float t13070 = sin(t12945);
float t13071 = (1*t13070);
float t13072 = cos(t12983);
float t13073 = (t13071*t13072);
float t13074 = cos(t12919);
float t13075 = (1*t13074);
float t13076 = (t13073*t13075);
float t13077 = (t13069-t13076);
float t13078 = sin(t8);
float t13079 = (1*t13078);
float t13080 = sin(t118);
float t13081 = (t13079*t13080);
float t13082 = (t13077*t13081);
float t13083 = sin(t12919);
float t13084 = (1*t13083);
float t13085 = sin(t12967);
float t13086 = (t13084*t13085);
float t13087 = (t13073*t13086);
float t13088 = sin(t12945);
float t13089 = (1*t13088);
float t13090 = sin(t12983);
float t13091 = (t13089*t13090);
float t13092 = (t13091*t13068);
float t13093 = (t13087-t13092);
float t13094 = cos(t8);
float t13095 = (1*t13094);
float t13096 = (t13093*t13095);
float t13097 = (t13082+t13096);
float t13098 = (t13091*t13075);
float t13099 = (t13064*t13086);
float t13100 = (t13098-t13099);
float t13101 = sin(t8);
float t13102 = (1*t13101);
float t13103 = cos(t118);
float t13104 = (t13102*t13103);
float t13105 = (t13100*t13104);
float t13106 = (t13097+t13105);
float t13107 = abs(t13106);
t13062 = t13107;
} else {
float t13108 = (3.1415927/2);
float t13109 = (t8-t13108);
float t13110 = (3.1415927/2);
float t13111 = (t12919-t13110);
float t13112 = (t13109-t13111);
float t13113 = abs(t13112);
float t13114 = (t13113/2);
float t13115 = sin(t13114);
float t13116 = (t13115*t13115);
float t13117 = cos(t13111);
float t13118 = cos(t13109);
float t13119 = (t13117*t13118);
float t13120 = (t118+3.1415927);
float t13121 = (3.1415927*2);
float t13122 = mod(t13120,t13121);
float t13123 = (t13122-3.1415927);
float t13124 = (t12967+3.1415927);
float t13125 = (3.1415927*2);
float t13126 = mod(t13124,t13125);
float t13127 = (t13126-3.1415927);
float t13128 = (t13123-t13127);
float t13129 = abs(t13128);
float t13130 = (t13129/2);
float t13131 = sin(t13130);
float t13132 = (t13131*t13131);
float t13133 = (t13119*t13132);
float t13134 = (t13116+t13133);
float t13135 = sqrt(t13134);
float t13136 = asin(t13135);
float t13137 = (2*t13136);
float t13138 = abs(t13137);
float t13139 = (3.1415927/2);
float t13140 = (t8-t13139);
float t13141 = (3.1415927/2);
float t13142 = (t12945-t13141);
float t13143 = (t13140-t13142);
float t13144 = abs(t13143);
float t13145 = (t13144/2);
float t13146 = sin(t13145);
float t13147 = (t13146*t13146);
float t13148 = cos(t13142);
float t13149 = cos(t13140);
float t13150 = (t13148*t13149);
float t13151 = (t118+3.1415927);
float t13152 = (3.1415927*2);
float t13153 = mod(t13151,t13152);
float t13154 = (t13153-3.1415927);
float t13155 = (t12983+3.1415927);
float t13156 = (3.1415927*2);
float t13157 = mod(t13155,t13156);
float t13158 = (t13157-3.1415927);
float t13159 = (t13154-t13158);
float t13160 = abs(t13159);
float t13161 = (t13160/2);
float t13162 = sin(t13161);
float t13163 = (t13162*t13162);
float t13164 = (t13150*t13163);
float t13165 = (t13147+t13164);
float t13166 = sqrt(t13165);
float t13167 = asin(t13166);
float t13168 = (2*t13167);
float t13169 = abs(t13168);
bool t13170 = (t13138>=t13169);
float t13171;
if(t13170){
t13171 = t13138;
} else {
t13171 = t13169;
}
t13062 = t13171;
}
float t13172 = abs(t13062);
float t13173 = step(float(2.0e-4),t13172);
float t13174 = (1-t13173);
float t13175 = (t10000*t10452);
float t13176 = (t13175*float(842.378));
float t13177 = fract(t13176);
float t13178 = (t13177+float(45.32));
float t13179 = (t13178+u6.u0);
float t13180 = (t13177*t13179);
float t13181 = (t10234*t10000);
float t13182 = (t13181*float(1734.048));
float t13183 = fract(t13182);
float t13184 = (t13183+float(45.32));
float t13185 = (t13184+u6.u0);
float t13186 = (t13183*t13185);
float t13187 = (t13180+t13186);
float t13188 = (t13177+t13187);
float t13189 = (t13183+t13187);
float t13190 = (t13188*t13189);
float t13191 = fract(t13190);
float t13192 = step(float(0.2),t13191);
float t13193 = (t13174*t13192);
float t13194 = (3.1415927/2);
float t13195 = (t12919-t13194);
float t13196 = (3.1415927/2);
float t13197 = (t12945-t13196);
float t13198 = (t13195-t13197);
float t13199 = abs(t13198);
float t13200 = (t13199/2);
float t13201 = sin(t13200);
float t13202 = (t13201*t13201);
float t13203 = cos(t13197);
float t13204 = cos(t13195);
float t13205 = (t13203*t13204);
float t13206 = (t12967+3.1415927);
float t13207 = (3.1415927*2);
float t13208 = mod(t13206,t13207);
float t13209 = (t13208-3.1415927);
float t13210 = (t12983+3.1415927);
float t13211 = (3.1415927*2);
float t13212 = mod(t13210,t13211);
float t13213 = (t13212-3.1415927);
float t13214 = (t13209-t13213);
float t13215 = abs(t13214);
float t13216 = (t13215/2);
float t13217 = sin(t13216);
float t13218 = (t13217*t13217);
float t13219 = (t13205*t13218);
float t13220 = (t13202+t13219);
float t13221 = sqrt(t13220);
float t13222 = asin(t13221);
float t13223 = (2*t13222);
float t13224 = (t13223/t9998);
float t13225 = (1-t13224);
float t13226 = (t10000/245);
float t13227 = (t13226*float(842.378));
float t13228 = fract(t13227);
float t13229 = (t13228+float(45.32));
float t13230 = (t13229+u6.u0);
float t13231 = (t13228*t13230);
float t13232 = (t10234/t10013);
float t13233 = (t13232*float(1734.048));
float t13234 = fract(t13233);
float t13235 = (t13234+float(45.32));
float t13236 = (t13235+u6.u0);
float t13237 = (t13234*t13236);
float t13238 = (t13231+t13237);
float t13239 = (t13228+t13238);
float t13240 = (t13234+t13238);
float t13241 = (t13239*t13240);
float t13242 = fract(t13241);
float t13243 = (t13242*float(8.0e-3));
float t13244 = (float(1.0e-3)+t13243);
float t13245 = (t13242*173);
float t13246 = fract(t13245);
float t13247 = step(float(0.66),t13246);
float t13248 = (t13247*float(3.0e-3));
float t13249 = (t13244-t13248);
float t13250 = (t13249*float(0.4));
float t13251 = (t10000/245);
float t13252 = (t13251*float(842.378));
float t13253 = fract(t13252);
float t13254 = (t13253+float(45.32));
float t13255 = (t13254+u6.u0);
float t13256 = (t13253*t13255);
float t13257 = (t10452/t10013);
float t13258 = (t13257*float(1734.048));
float t13259 = fract(t13258);
float t13260 = (t13259+float(45.32));
float t13261 = (t13260+u6.u0);
float t13262 = (t13259*t13261);
float t13263 = (t13256+t13262);
float t13264 = (t13253+t13263);
float t13265 = (t13259+t13263);
float t13266 = (t13264*t13265);
float t13267 = fract(t13266);
float t13268 = (t13267*float(8.0e-3));
float t13269 = (float(1.0e-3)+t13268);
float t13270 = (t13267*173);
float t13271 = fract(t13270);
float t13272 = step(float(0.66),t13271);
float t13273 = (t13272*float(3.0e-3));
float t13274 = (t13269-t13273);
float t13275 = (t13274*float(0.4));
float t13276 = (t13250-t13275);
float t13277 = abs(t13276);
float t13278 = (t13277-float(1.0e-3));
float t13279 = (t13278/float(8.0e-3));
float t13280 = (1-t13279);
float t13281 = (t13280*t13280);
float t13282 = (t13225*t13281);
float t13283 = (t13193*t13282);
float t13284 = (u4.u0*t13191);
float t13285 = (t13284*3);
float t13286 = sin(t13285);
float t13287 = (t13286+1);
float t13288 = (t13287/2);
float t13289 = (t13288*float(0.66));
float t13290 = (t13289+float(0.33));
float t13291 = (t13283*t13290);
float t13292 = (float(0.2)*t13291);
bool t13293 = (0>=t13292);
float t13294;
if(t13293){
t13294 = 0;
} else {
t13294 = t13292;
}
float t13295 = (t13294*0);
float t13296 = (t12895+t13295);
float t13297 = (t10000*t9998);
float t13298 = (t10000/245);
float t13299 = (t13298*float(842.378));
float t13300 = fract(t13299);
float t13301 = (t13300+float(45.32));
float t13302 = (t13301+u6.u0);
float t13303 = (t13300*t13302);
float t13304 = (t10016+2);
float t13305 = (t13304/t10676);
float t13306 = (t13305*float(1734.048));
float t13307 = fract(t13306);
float t13308 = (t13307+float(45.32));
float t13309 = (t13308+u6.u0);
float t13310 = (t13307*t13309);
float t13311 = (t13303+t13310);
float t13312 = (t13300+t13311);
float t13313 = (t13307+t13311);
float t13314 = (t13312*t13313);
float t13315 = fract(t13314);
float t13316 = (t13315*float(2852.02));
float t13317 = fract(t13316);
float t13318 = (t13317-float(0.5));
float t13319 = (t13318*t9998);
float t13320 = (t13319*float(0.75));
float t13321 = (t13297+t13320);
float t13322 = (3.1415927/2);
float t13323 = (t13321-t13322);
float t13324 = (t10663*t9998);
float t13325 = (t10663/245);
float t13326 = (t13325*float(842.378));
float t13327 = fract(t13326);
float t13328 = (t13327+float(45.32));
float t13329 = (t13328+u6.u0);
float t13330 = (t13327*t13329);
float t13331 = (t11699/t10676);
float t13332 = (t13331*float(1734.048));
float t13333 = fract(t13332);
float t13334 = (t13333+float(45.32));
float t13335 = (t13334+u6.u0);
float t13336 = (t13333*t13335);
float t13337 = (t13330+t13336);
float t13338 = (t13327+t13337);
float t13339 = (t13333+t13337);
float t13340 = (t13338*t13339);
float t13341 = fract(t13340);
float t13342 = (t13341*float(2852.02));
float t13343 = fract(t13342);
float t13344 = (t13343-float(0.5));
float t13345 = (t13344*t9998);
float t13346 = (t13345*float(0.75));
float t13347 = (t13324+t13346);
float t13348 = (3.1415927/2);
float t13349 = (t13347-t13348);
float t13350 = (t13323-t13349);
float t13351 = abs(t13350);
float t13352 = (t13351/2);
float t13353 = sin(t13352);
float t13354 = (t13353*t13353);
float t13355 = cos(t13349);
float t13356 = cos(t13323);
float t13357 = (t13355*t13356);
float t13358 = (3.1415927/t10676);
float t13359 = (t13304*t13358);
float t13360 = (t13315*float(97372.83));
float t13361 = fract(t13360);
float t13362 = (t13361-float(0.5));
float t13363 = (3.1415927/t10676);
float t13364 = (t13362*t13363);
float t13365 = (t13364*float(0.75));
float t13366 = (t13359+t13365);
float t13367 = (t13366+3.1415927);
float t13368 = mod(t13367,t1433);
float t13369 = (t13368-3.1415927);
float t13370 = (t13369+3.1415927);
float t13371 = (3.1415927*2);
float t13372 = mod(t13370,t13371);
float t13373 = (t13372-3.1415927);
float t13374 = (3.1415927/t10676);
float t13375 = (t11699*t13374);
float t13376 = (t13341*float(97372.83));
float t13377 = fract(t13376);
float t13378 = (t13377-float(0.5));
float t13379 = (3.1415927/t10676);
float t13380 = (t13378*t13379);
float t13381 = (t13380*float(0.75));
float t13382 = (t13375+t13381);
float t13383 = (t13382+3.1415927);
float t13384 = mod(t13383,t1433);
float t13385 = (t13384-3.1415927);
float t13386 = (t13385+3.1415927);
float t13387 = (3.1415927*2);
float t13388 = mod(t13386,t13387);
float t13389 = (t13388-3.1415927);
float t13390 = (t13373-t13389);
float t13391 = abs(t13390);
float t13392 = (t13391/2);
float t13393 = sin(t13392);
float t13394 = (t13393*t13393);
float t13395 = (t13357*t13394);
float t13396 = (t13354+t13395);
float t13397 = sqrt(t13396);
float t13398 = asin(t13397);
float t13399 = (2*t13398);
float t13400 = (3.1415927/2);
float t13401 = (t8-t13400);
float t13402 = (3.1415927/2);
float t13403 = (t13347-t13402);
float t13404 = (t13401-t13403);
float t13405 = abs(t13404);
float t13406 = (t13405/2);
float t13407 = sin(t13406);
float t13408 = (t13407*t13407);
float t13409 = cos(t13403);
float t13410 = cos(t13401);
float t13411 = (t13409*t13410);
float t13412 = (t118+3.1415927);
float t13413 = (3.1415927*2);
float t13414 = mod(t13412,t13413);
float t13415 = (t13414-3.1415927);
float t13416 = (t13385+3.1415927);
float t13417 = (3.1415927*2);
float t13418 = mod(t13416,t13417);
float t13419 = (t13418-3.1415927);
float t13420 = (t13415-t13419);
float t13421 = abs(t13420);
float t13422 = (t13421/2);
float t13423 = sin(t13422);
float t13424 = (t13423*t13423);
float t13425 = (t13411*t13424);
float t13426 = (t13408+t13425);
float t13427 = sqrt(t13426);
float t13428 = asin(t13427);
float t13429 = (2*t13428);
float t13430 = (t13399-t13429);
float t13431 = (3.1415927/2);
float t13432 = (t8-t13431);
float t13433 = (3.1415927/2);
float t13434 = (t13321-t13433);
float t13435 = (t13432-t13434);
float t13436 = abs(t13435);
float t13437 = (t13436/2);
float t13438 = sin(t13437);
float t13439 = (t13438*t13438);
float t13440 = cos(t13434);
float t13441 = cos(t13432);
float t13442 = (t13440*t13441);
float t13443 = (t118+3.1415927);
float t13444 = (3.1415927*2);
float t13445 = mod(t13443,t13444);
float t13446 = (t13445-3.1415927);
float t13447 = (t13369+3.1415927);
float t13448 = (3.1415927*2);
float t13449 = mod(t13447,t13448);
float t13450 = (t13449-3.1415927);
float t13451 = (t13446-t13450);
float t13452 = abs(t13451);
float t13453 = (t13452/2);
float t13454 = sin(t13453);
float t13455 = (t13454*t13454);
float t13456 = (t13442*t13455);
float t13457 = (t13439+t13456);
float t13458 = sqrt(t13457);
float t13459 = asin(t13458);
float t13460 = (2*t13459);
float t13461 = (t13430-t13460);
float t13462 = abs(t13461);
bool t13463 = (float(1.0e-4)>t13462);
float t13464;
if(t13463){
float t13465 = cos(t13347);
float t13466 = (1*t13465);
float t13467 = sin(t13321);
float t13468 = (1*t13467);
float t13469 = cos(t13369);
float t13470 = (t13468*t13469);
float t13471 = (t13466*t13470);
float t13472 = sin(t13347);
float t13473 = (1*t13472);
float t13474 = cos(t13385);
float t13475 = (t13473*t13474);
float t13476 = cos(t13321);
float t13477 = (1*t13476);
float t13478 = (t13475*t13477);
float t13479 = (t13471-t13478);
float t13480 = sin(t8);
float t13481 = (1*t13480);
float t13482 = sin(t118);
float t13483 = (t13481*t13482);
float t13484 = (t13479*t13483);
float t13485 = sin(t13321);
float t13486 = (1*t13485);
float t13487 = sin(t13369);
float t13488 = (t13486*t13487);
float t13489 = (t13475*t13488);
float t13490 = sin(t13347);
float t13491 = (1*t13490);
float t13492 = sin(t13385);
float t13493 = (t13491*t13492);
float t13494 = (t13493*t13470);
float t13495 = (t13489-t13494);
float t13496 = cos(t8);
float t13497 = (1*t13496);
float t13498 = (t13495*t13497);
float t13499 = (t13484+t13498);
float t13500 = (t13493*t13477);
float t13501 = (t13466*t13488);
float t13502 = (t13500-t13501);
float t13503 = sin(t8);
float t13504 = (1*t13503);
float t13505 = cos(t118);
float t13506 = (t13504*t13505);
float t13507 = (t13502*t13506);
float t13508 = (t13499+t13507);
float t13509 = abs(t13508);
t13464 = t13509;
} else {
float t13510 = (3.1415927/2);
float t13511 = (t8-t13510);
float t13512 = (3.1415927/2);
float t13513 = (t13321-t13512);
float t13514 = (t13511-t13513);
float t13515 = abs(t13514);
float t13516 = (t13515/2);
float t13517 = sin(t13516);
float t13518 = (t13517*t13517);
float t13519 = cos(t13513);
float t13520 = cos(t13511);
float t13521 = (t13519*t13520);
float t13522 = (t118+3.1415927);
float t13523 = (3.1415927*2);
float t13524 = mod(t13522,t13523);
float t13525 = (t13524-3.1415927);
float t13526 = (t13369+3.1415927);
float t13527 = (3.1415927*2);
float t13528 = mod(t13526,t13527);
float t13529 = (t13528-3.1415927);
float t13530 = (t13525-t13529);
float t13531 = abs(t13530);
float t13532 = (t13531/2);
float t13533 = sin(t13532);
float t13534 = (t13533*t13533);
float t13535 = (t13521*t13534);
float t13536 = (t13518+t13535);
float t13537 = sqrt(t13536);
float t13538 = asin(t13537);
float t13539 = (2*t13538);
float t13540 = abs(t13539);
float t13541 = (3.1415927/2);
float t13542 = (t8-t13541);
float t13543 = (3.1415927/2);
float t13544 = (t13347-t13543);
float t13545 = (t13542-t13544);
float t13546 = abs(t13545);
float t13547 = (t13546/2);
float t13548 = sin(t13547);
float t13549 = (t13548*t13548);
float t13550 = cos(t13544);
float t13551 = cos(t13542);
float t13552 = (t13550*t13551);
float t13553 = (t118+3.1415927);
float t13554 = (3.1415927*2);
float t13555 = mod(t13553,t13554);
float t13556 = (t13555-3.1415927);
float t13557 = (t13385+3.1415927);
float t13558 = (3.1415927*2);
float t13559 = mod(t13557,t13558);
float t13560 = (t13559-3.1415927);
float t13561 = (t13556-t13560);
float t13562 = abs(t13561);
float t13563 = (t13562/2);
float t13564 = sin(t13563);
float t13565 = (t13564*t13564);
float t13566 = (t13552*t13565);
float t13567 = (t13549+t13566);
float t13568 = sqrt(t13567);
float t13569 = asin(t13568);
float t13570 = (2*t13569);
float t13571 = abs(t13570);
bool t13572 = (t13540>=t13571);
float t13573;
if(t13572){
t13573 = t13540;
} else {
t13573 = t13571;
}
t13464 = t13573;
}
float t13574 = abs(t13464);
float t13575 = step(float(2.0e-4),t13574);
float t13576 = (1-t13575);
float t13577 = (t10663*t13304);
float t13578 = (t13577*float(842.378));
float t13579 = fract(t13578);
float t13580 = (t13579+float(45.32));
float t13581 = (t13580+u6.u0);
float t13582 = (t13579*t13581);
float t13583 = (t11699*t10000);
float t13584 = (t13583*float(1734.048));
float t13585 = fract(t13584);
float t13586 = (t13585+float(45.32));
float t13587 = (t13586+u6.u0);
float t13588 = (t13585*t13587);
float t13589 = (t13582+t13588);
float t13590 = (t13579+t13589);
float t13591 = (t13585+t13589);
float t13592 = (t13590*t13591);
float t13593 = fract(t13592);
float t13594 = step(float(0.2),t13593);
float t13595 = (t13576*t13594);
float t13596 = (3.1415927/2);
float t13597 = (t13321-t13596);
float t13598 = (3.1415927/2);
float t13599 = (t13347-t13598);
float t13600 = (t13597-t13599);
float t13601 = abs(t13600);
float t13602 = (t13601/2);
float t13603 = sin(t13602);
float t13604 = (t13603*t13603);
float t13605 = cos(t13599);
float t13606 = cos(t13597);
float t13607 = (t13605*t13606);
float t13608 = (t13369+3.1415927);
float t13609 = (3.1415927*2);
float t13610 = mod(t13608,t13609);
float t13611 = (t13610-3.1415927);
float t13612 = (t13385+3.1415927);
float t13613 = (3.1415927*2);
float t13614 = mod(t13612,t13613);
float t13615 = (t13614-3.1415927);
float t13616 = (t13611-t13615);
float t13617 = abs(t13616);
float t13618 = (t13617/2);
float t13619 = sin(t13618);
float t13620 = (t13619*t13619);
float t13621 = (t13607*t13620);
float t13622 = (t13604+t13621);
float t13623 = sqrt(t13622);
float t13624 = asin(t13623);
float t13625 = (2*t13624);
float t13626 = (t13625/t9998);
float t13627 = (1-t13626);
float t13628 = (t10663/245);
float t13629 = (t13628*float(842.378));
float t13630 = fract(t13629);
float t13631 = (t13630+float(45.32));
float t13632 = (t13631+u6.u0);
float t13633 = (t13630*t13632);
float t13634 = (t11699/t10676);
float t13635 = (t13634*float(1734.048));
float t13636 = fract(t13635);
float t13637 = (t13636+float(45.32));
float t13638 = (t13637+u6.u0);
float t13639 = (t13636*t13638);
float t13640 = (t13633+t13639);
float t13641 = (t13630+t13640);
float t13642 = (t13636+t13640);
float t13643 = (t13641*t13642);
float t13644 = fract(t13643);
float t13645 = (t13644*float(8.0e-3));
float t13646 = (float(1.0e-3)+t13645);
float t13647 = (t13644*173);
float t13648 = fract(t13647);
float t13649 = step(float(0.66),t13648);
float t13650 = (t13649*float(3.0e-3));
float t13651 = (t13646-t13650);
float t13652 = (t13651*float(0.4));
float t13653 = (t10000/245);
float t13654 = (t13653*float(842.378));
float t13655 = fract(t13654);
float t13656 = (t13655+float(45.32));
float t13657 = (t13656+u6.u0);
float t13658 = (t13655*t13657);
float t13659 = (t13304/t10676);
float t13660 = (t13659*float(1734.048));
float t13661 = fract(t13660);
float t13662 = (t13661+float(45.32));
float t13663 = (t13662+u6.u0);
float t13664 = (t13661*t13663);
float t13665 = (t13658+t13664);
float t13666 = (t13655+t13665);
float t13667 = (t13661+t13665);
float t13668 = (t13666*t13667);
float t13669 = fract(t13668);
float t13670 = (t13669*float(8.0e-3));
float t13671 = (float(1.0e-3)+t13670);
float t13672 = (t13669*173);
float t13673 = fract(t13672);
float t13674 = step(float(0.66),t13673);
float t13675 = (t13674*float(3.0e-3));
float t13676 = (t13671-t13675);
float t13677 = (t13676*float(0.4));
float t13678 = (t13652-t13677);
float t13679 = abs(t13678);
float t13680 = (t13679-float(1.0e-3));
float t13681 = (t13680/float(8.0e-3));
float t13682 = (1-t13681);
float t13683 = (t13682*t13682);
float t13684 = (t13627*t13683);
float t13685 = (t13595*t13684);
float t13686 = (u4.u0*t13593);
float t13687 = (t13686*3);
float t13688 = sin(t13687);
float t13689 = (t13688+1);
float t13690 = (t13689/2);
float t13691 = (t13690*float(0.66));
float t13692 = (t13691+float(0.33));
float t13693 = (t13685*t13692);
float t13694 = (float(0.2)*t13693);
bool t13695 = (0>=t13694);
float t13696;
if(t13695){
t13696 = 0;
} else {
t13696 = t13694;
}
float t13697 = (t13696*0);
float t13698 = (t13296+t13697);
float t13699 = (t10000*t9998);
float t13700 = (t10000/245);
float t13701 = (t13700*float(842.378));
float t13702 = fract(t13701);
float t13703 = (t13702+float(45.32));
float t13704 = (t13703+u6.u0);
float t13705 = (t13702*t13704);
float t13706 = (t13304/t10676);
float t13707 = (t13706*float(1734.048));
float t13708 = fract(t13707);
float t13709 = (t13708+float(45.32));
float t13710 = (t13709+u6.u0);
float t13711 = (t13708*t13710);
float t13712 = (t13705+t13711);
float t13713 = (t13702+t13712);
float t13714 = (t13708+t13712);
float t13715 = (t13713*t13714);
float t13716 = fract(t13715);
float t13717 = (t13716*float(2852.02));
float t13718 = fract(t13717);
float t13719 = (t13718-float(0.5));
float t13720 = (t13719*t9998);
float t13721 = (t13720*float(0.75));
float t13722 = (t13699+t13721);
float t13723 = (3.1415927/2);
float t13724 = (t13722-t13723);
float t13725 = (t10000*t9998);
float t13726 = (t10000/245);
float t13727 = (t13726*float(842.378));
float t13728 = fract(t13727);
float t13729 = (t13728+float(45.32));
float t13730 = (t13729+u6.u0);
float t13731 = (t13728*t13730);
float t13732 = (t10452/t10013);
float t13733 = (t13732*float(1734.048));
float t13734 = fract(t13733);
float t13735 = (t13734+float(45.32));
float t13736 = (t13735+u6.u0);
float t13737 = (t13734*t13736);
float t13738 = (t13731+t13737);
float t13739 = (t13728+t13738);
float t13740 = (t13734+t13738);
float t13741 = (t13739*t13740);
float t13742 = fract(t13741);
float t13743 = (t13742*float(2852.02));
float t13744 = fract(t13743);
float t13745 = (t13744-float(0.5));
float t13746 = (t13745*t9998);
float t13747 = (t13746*float(0.75));
float t13748 = (t13725+t13747);
float t13749 = (3.1415927/2);
float t13750 = (t13748-t13749);
float t13751 = (t13724-t13750);
float t13752 = abs(t13751);
float t13753 = (t13752/2);
float t13754 = sin(t13753);
float t13755 = (t13754*t13754);
float t13756 = cos(t13750);
float t13757 = cos(t13724);
float t13758 = (t13756*t13757);
float t13759 = (3.1415927/t10676);
float t13760 = (t13304*t13759);
float t13761 = (t13716*float(97372.83));
float t13762 = fract(t13761);
float t13763 = (t13762-float(0.5));
float t13764 = (3.1415927/t10676);
float t13765 = (t13763*t13764);
float t13766 = (t13765*float(0.75));
float t13767 = (t13760+t13766);
float t13768 = (t13767+3.1415927);
float t13769 = mod(t13768,t1433);
float t13770 = (t13769-3.1415927);
float t13771 = (t13770+3.1415927);
float t13772 = (3.1415927*2);
float t13773 = mod(t13771,t13772);
float t13774 = (t13773-3.1415927);
float t13775 = (3.1415927/t10013);
float t13776 = (t10452*t13775);
float t13777 = (t13742*float(97372.83));
float t13778 = fract(t13777);
float t13779 = (t13778-float(0.5));
float t13780 = (3.1415927/t10013);
float t13781 = (t13779*t13780);
float t13782 = (t13781*float(0.75));
float t13783 = (t13776+t13782);
float t13784 = (t13783+3.1415927);
float t13785 = mod(t13784,t1433);
float t13786 = (t13785-3.1415927);
float t13787 = (t13786+3.1415927);
float t13788 = (3.1415927*2);
float t13789 = mod(t13787,t13788);
float t13790 = (t13789-3.1415927);
float t13791 = (t13774-t13790);
float t13792 = abs(t13791);
float t13793 = (t13792/2);
float t13794 = sin(t13793);
float t13795 = (t13794*t13794);
float t13796 = (t13758*t13795);
float t13797 = (t13755+t13796);
float t13798 = sqrt(t13797);
float t13799 = asin(t13798);
float t13800 = (2*t13799);
float t13801 = (3.1415927/2);
float t13802 = (t8-t13801);
float t13803 = (3.1415927/2);
float t13804 = (t13748-t13803);
float t13805 = (t13802-t13804);
float t13806 = abs(t13805);
float t13807 = (t13806/2);
float t13808 = sin(t13807);
float t13809 = (t13808*t13808);
float t13810 = cos(t13804);
float t13811 = cos(t13802);
float t13812 = (t13810*t13811);
float t13813 = (t118+3.1415927);
float t13814 = (3.1415927*2);
float t13815 = mod(t13813,t13814);
float t13816 = (t13815-3.1415927);
float t13817 = (t13786+3.1415927);
float t13818 = (3.1415927*2);
float t13819 = mod(t13817,t13818);
float t13820 = (t13819-3.1415927);
float t13821 = (t13816-t13820);
float t13822 = abs(t13821);
float t13823 = (t13822/2);
float t13824 = sin(t13823);
float t13825 = (t13824*t13824);
float t13826 = (t13812*t13825);
float t13827 = (t13809+t13826);
float t13828 = sqrt(t13827);
float t13829 = asin(t13828);
float t13830 = (2*t13829);
float t13831 = (t13800-t13830);
float t13832 = (3.1415927/2);
float t13833 = (t8-t13832);
float t13834 = (3.1415927/2);
float t13835 = (t13722-t13834);
float t13836 = (t13833-t13835);
float t13837 = abs(t13836);
float t13838 = (t13837/2);
float t13839 = sin(t13838);
float t13840 = (t13839*t13839);
float t13841 = cos(t13835);
float t13842 = cos(t13833);
float t13843 = (t13841*t13842);
float t13844 = (t118+3.1415927);
float t13845 = (3.1415927*2);
float t13846 = mod(t13844,t13845);
float t13847 = (t13846-3.1415927);
float t13848 = (t13770+3.1415927);
float t13849 = (3.1415927*2);
float t13850 = mod(t13848,t13849);
float t13851 = (t13850-3.1415927);
float t13852 = (t13847-t13851);
float t13853 = abs(t13852);
float t13854 = (t13853/2);
float t13855 = sin(t13854);
float t13856 = (t13855*t13855);
float t13857 = (t13843*t13856);
float t13858 = (t13840+t13857);
float t13859 = sqrt(t13858);
float t13860 = asin(t13859);
float t13861 = (2*t13860);
float t13862 = (t13831-t13861);
float t13863 = abs(t13862);
bool t13864 = (float(1.0e-4)>t13863);
float t13865;
if(t13864){
float t13866 = cos(t13748);
float t13867 = (1*t13866);
float t13868 = sin(t13722);
float t13869 = (1*t13868);
float t13870 = cos(t13770);
float t13871 = (t13869*t13870);
float t13872 = (t13867*t13871);
float t13873 = sin(t13748);
float t13874 = (1*t13873);
float t13875 = cos(t13786);
float t13876 = (t13874*t13875);
float t13877 = cos(t13722);
float t13878 = (1*t13877);
float t13879 = (t13876*t13878);
float t13880 = (t13872-t13879);
float t13881 = sin(t8);
float t13882 = (1*t13881);
float t13883 = sin(t118);
float t13884 = (t13882*t13883);
float t13885 = (t13880*t13884);
float t13886 = sin(t13722);
float t13887 = (1*t13886);
float t13888 = sin(t13770);
float t13889 = (t13887*t13888);
float t13890 = (t13876*t13889);
float t13891 = sin(t13748);
float t13892 = (1*t13891);
float t13893 = sin(t13786);
float t13894 = (t13892*t13893);
float t13895 = (t13894*t13871);
float t13896 = (t13890-t13895);
float t13897 = cos(t8);
float t13898 = (1*t13897);
float t13899 = (t13896*t13898);
float t13900 = (t13885+t13899);
float t13901 = (t13894*t13878);
float t13902 = (t13867*t13889);
float t13903 = (t13901-t13902);
float t13904 = sin(t8);
float t13905 = (1*t13904);
float t13906 = cos(t118);
float t13907 = (t13905*t13906);
float t13908 = (t13903*t13907);
float t13909 = (t13900+t13908);
float t13910 = abs(t13909);
t13865 = t13910;
} else {
float t13911 = (3.1415927/2);
float t13912 = (t8-t13911);
float t13913 = (3.1415927/2);
float t13914 = (t13722-t13913);
float t13915 = (t13912-t13914);
float t13916 = abs(t13915);
float t13917 = (t13916/2);
float t13918 = sin(t13917);
float t13919 = (t13918*t13918);
float t13920 = cos(t13914);
float t13921 = cos(t13912);
float t13922 = (t13920*t13921);
float t13923 = (t118+3.1415927);
float t13924 = (3.1415927*2);
float t13925 = mod(t13923,t13924);
float t13926 = (t13925-3.1415927);
float t13927 = (t13770+3.1415927);
float t13928 = (3.1415927*2);
float t13929 = mod(t13927,t13928);
float t13930 = (t13929-3.1415927);
float t13931 = (t13926-t13930);
float t13932 = abs(t13931);
float t13933 = (t13932/2);
float t13934 = sin(t13933);
float t13935 = (t13934*t13934);
float t13936 = (t13922*t13935);
float t13937 = (t13919+t13936);
float t13938 = sqrt(t13937);
float t13939 = asin(t13938);
float t13940 = (2*t13939);
float t13941 = abs(t13940);
float t13942 = (3.1415927/2);
float t13943 = (t8-t13942);
float t13944 = (3.1415927/2);
float t13945 = (t13748-t13944);
float t13946 = (t13943-t13945);
float t13947 = abs(t13946);
float t13948 = (t13947/2);
float t13949 = sin(t13948);
float t13950 = (t13949*t13949);
float t13951 = cos(t13945);
float t13952 = cos(t13943);
float t13953 = (t13951*t13952);
float t13954 = (t118+3.1415927);
float t13955 = (3.1415927*2);
float t13956 = mod(t13954,t13955);
float t13957 = (t13956-3.1415927);
float t13958 = (t13786+3.1415927);
float t13959 = (3.1415927*2);
float t13960 = mod(t13958,t13959);
float t13961 = (t13960-3.1415927);
float t13962 = (t13957-t13961);
float t13963 = abs(t13962);
float t13964 = (t13963/2);
float t13965 = sin(t13964);
float t13966 = (t13965*t13965);
float t13967 = (t13953*t13966);
float t13968 = (t13950+t13967);
float t13969 = sqrt(t13968);
float t13970 = asin(t13969);
float t13971 = (2*t13970);
float t13972 = abs(t13971);
bool t13973 = (t13941>=t13972);
float t13974;
if(t13973){
t13974 = t13941;
} else {
t13974 = t13972;
}
t13865 = t13974;
}
float t13975 = abs(t13865);
float t13976 = step(float(2.0e-4),t13975);
float t13977 = (1-t13976);
float t13978 = (t10000*t13304);
float t13979 = (t13978*float(842.378));
float t13980 = fract(t13979);
float t13981 = (t13980+float(45.32));
float t13982 = (t13981+u6.u0);
float t13983 = (t13980*t13982);
float t13984 = (t10452*t10000);
float t13985 = (t13984*float(1734.048));
float t13986 = fract(t13985);
float t13987 = (t13986+float(45.32));
float t13988 = (t13987+u6.u0);
float t13989 = (t13986*t13988);
float t13990 = (t13983+t13989);
float t13991 = (t13980+t13990);
float t13992 = (t13986+t13990);
float t13993 = (t13991*t13992);
float t13994 = fract(t13993);
float t13995 = step(float(0.2),t13994);
float t13996 = (t13977*t13995);
float t13997 = (3.1415927/2);
float t13998 = (t13722-t13997);
float t13999 = (3.1415927/2);
float t14000 = (t13748-t13999);
float t14001 = (t13998-t14000);
float t14002 = abs(t14001);
float t14003 = (t14002/2);
float t14004 = sin(t14003);
float t14005 = (t14004*t14004);
float t14006 = cos(t14000);
float t14007 = cos(t13998);
float t14008 = (t14006*t14007);
float t14009 = (t13770+3.1415927);
float t14010 = (3.1415927*2);
float t14011 = mod(t14009,t14010);
float t14012 = (t14011-3.1415927);
float t14013 = (t13786+3.1415927);
float t14014 = (3.1415927*2);
float t14015 = mod(t14013,t14014);
float t14016 = (t14015-3.1415927);
float t14017 = (t14012-t14016);
float t14018 = abs(t14017);
float t14019 = (t14018/2);
float t14020 = sin(t14019);
float t14021 = (t14020*t14020);
float t14022 = (t14008*t14021);
float t14023 = (t14005+t14022);
float t14024 = sqrt(t14023);
float t14025 = asin(t14024);
float t14026 = (2*t14025);
float t14027 = (t14026/t9998);
float t14028 = (1-t14027);
float t14029 = (t10000/245);
float t14030 = (t14029*float(842.378));
float t14031 = fract(t14030);
float t14032 = (t14031+float(45.32));
float t14033 = (t14032+u6.u0);
float t14034 = (t14031*t14033);
float t14035 = (t10452/t10013);
float t14036 = (t14035*float(1734.048));
float t14037 = fract(t14036);
float t14038 = (t14037+float(45.32));
float t14039 = (t14038+u6.u0);
float t14040 = (t14037*t14039);
float t14041 = (t14034+t14040);
float t14042 = (t14031+t14041);
float t14043 = (t14037+t14041);
float t14044 = (t14042*t14043);
float t14045 = fract(t14044);
float t14046 = (t14045*float(8.0e-3));
float t14047 = (float(1.0e-3)+t14046);
float t14048 = (t14045*173);
float t14049 = fract(t14048);
float t14050 = step(float(0.66),t14049);
float t14051 = (t14050*float(3.0e-3));
float t14052 = (t14047-t14051);
float t14053 = (t14052*float(0.4));
float t14054 = (t10000/245);
float t14055 = (t14054*float(842.378));
float t14056 = fract(t14055);
float t14057 = (t14056+float(45.32));
float t14058 = (t14057+u6.u0);
float t14059 = (t14056*t14058);
float t14060 = (t13304/t10676);
float t14061 = (t14060*float(1734.048));
float t14062 = fract(t14061);
float t14063 = (t14062+float(45.32));
float t14064 = (t14063+u6.u0);
float t14065 = (t14062*t14064);
float t14066 = (t14059+t14065);
float t14067 = (t14056+t14066);
float t14068 = (t14062+t14066);
float t14069 = (t14067*t14068);
float t14070 = fract(t14069);
float t14071 = (t14070*float(8.0e-3));
float t14072 = (float(1.0e-3)+t14071);
float t14073 = (t14070*173);
float t14074 = fract(t14073);
float t14075 = step(float(0.66),t14074);
float t14076 = (t14075*float(3.0e-3));
float t14077 = (t14072-t14076);
float t14078 = (t14077*float(0.4));
float t14079 = (t14053-t14078);
float t14080 = abs(t14079);
float t14081 = (t14080-float(1.0e-3));
float t14082 = (t14081/float(8.0e-3));
float t14083 = (1-t14082);
float t14084 = (t14083*t14083);
float t14085 = (t14028*t14084);
float t14086 = (t13996*t14085);
float t14087 = (u4.u0*t13994);
float t14088 = (t14087*3);
float t14089 = sin(t14088);
float t14090 = (t14089+1);
float t14091 = (t14090/2);
float t14092 = (t14091*float(0.66));
float t14093 = (t14092+float(0.33));
float t14094 = (t14086*t14093);
float t14095 = (float(0.2)*t14094);
bool t14096 = (0>=t14095);
float t14097;
if(t14096){
t14097 = 0;
} else {
t14097 = t14095;
}
float t14098 = (t14097*0);
float t14099 = (t13698+t14098);
float t14100 = (t9993*t9993);
float t14101 = (t14099*t14100);
bool t14102 = (t9997>=t14101);
float t14103;
if(t14102){
t14103 = t9997;
} else {
t14103 = t14101;
}
float t14104 = (t9551+t14103);
float t14105 = smoothstep(float(0.35),float(0.55),t468);
float t14106 = (u8.u0*t14105);
float t14107 = (1-t14106);
float t14108 = smoothstep(float(0.45),float(0.65),t468);
float t14109 = (t1334*t14108);
float t14110 = (u8.u0*t14109);
float t14111 = (1-t14110);
float t14112 = (3.1415927/2);
float t14113 = (t8-t14112);
float t14114 = (3.1415927/2);
float t14115 = (t107-t14114);
float t14116 = (t14113-t14115);
float t14117 = abs(t14116);
float t14118 = (t14117/2);
float t14119 = sin(t14118);
float t14120 = (t14119*t14119);
float t14121 = cos(t14115);
float t14122 = cos(t14113);
float t14123 = (t14121*t14122);
float t14124 = (t118+3.1415927);
float t14125 = (3.1415927*2);
float t14126 = mod(t14124,t14125);
float t14127 = (t14126-3.1415927);
float t14128 = (t123+3.1415927);
float t14129 = (3.1415927*2);
float t14130 = mod(t14128,t14129);
float t14131 = (t14130-3.1415927);
float t14132 = (t14127-t14131);
float t14133 = abs(t14132);
float t14134 = (t14133/2);
float t14135 = sin(t14134);
float t14136 = (t14135*t14135);
float t14137 = (t14123*t14136);
float t14138 = (t14120+t14137);
float t14139 = sqrt(t14138);
float t14140 = asin(t14139);
float t14141 = (2*t14140);
float t14142 = (3.1415927-t14141);
float t14143 = (t14142/3.1415927);
float t14144 = smoothstep(float(0.8),float(1.0),t14143);
float t14145 = (u8.u0*t14144);
float t14146 = (1-t14145);
bool t14147 = (t14111<=t14146);
float t14148;
if(t14147){
t14148 = t14111;
} else {
t14148 = t14146;
}
bool t14149 = (t14107<=t14148);
float t14150;
if(t14149){
t14150 = t14107;
} else {
t14150 = t14148;
}
float t14151 = (t14104*t14150);
float t14152 = (1-t1342);
float t14153 = (t14151*t14152);
float t14154 = (t1343+t14153);
float t14155 = (1-t1254);
float t14156 = (t14154*t14155);
float t14157 = (t1255+t14156);
float t14158 = (t3*t155);
float t14159 = (float(1.0)*t469);
float t14160 = (float(0.0)+t14159);
float t14161 = (t14160*t472);
float t14162 = (t14158+t14161);
float t14163 = (t14162*t524);
float t14164 = (float(0.2)*t678);
float t14165 = (t14164*t680);
float t14166 = (t14163+t14165);
float t14167 = (t14166*t685);
float t14168 = (float(0.7)*t839);
float t14169 = (t14168*t841);
float t14170 = (t14167+t14169);
float t14171 = (t14170*t846);
float t14172 = (float(0.1)*t1061);
float t14173 = (t14172*t1063);
float t14174 = (float(1.0e-2)*t1065);
float t14175 = (t14173+t14174);
float t14176 = (t14175*t1072);
float t14177 = (t14176*t1077);
float t14178 = (0*t1079);
float t14179 = (t14177+t14178);
float t14180 = (t1000*t14179);
float t14181 = (t14180*t1083);
float t14182 = (t14171+t14181);
float t14183 = (t14182*t1092);
float t14184 = (float(1.0)*t1246);
float t14185 = (t14184*t1248);
float t14186 = (t14183+t14185);
float t14187 = (t14186*t1254);
float t14188 = (float(0.7)*t1256);
float t14189 = (float(0.1)*t1258);
float t14190 = (t14188+t14189);
float t14191 = (float(0.2)*t1296);
float t14192 = (t14191*t1300);
float t14193 = (t14192*t1334);
float t14194 = (t14190+t14193);
float t14195 = (u8.u0*t14194);
float t14196 = (t14195*t1342);
float t14197 = (t1377/4000);
bool t14198 = (1<=t14197);
float t14199;
if(t14198){
t14199 = 1;
} else {
t14199 = t14197;
}
float t14200 = (t1377-7000);
float t14201 = (t14200/9333);
bool t14202 = (0>=t14201);
float t14203;
if(t14202){
t14203 = 0;
} else {
t14203 = t14201;
}
float t14204 = (t14199-t14203);
float t14205 = (t14204*t1532);
float t14206 = (t1571*t14204);
float t14207 = (t14205+t14206);
float t14208 = (0+t14207);
float t14209 = (t1597/4000);
bool t14210 = (1<=t14209);
float t14211;
if(t14210){
t14211 = 1;
} else {
t14211 = t14209;
}
float t14212 = (t1597-7000);
float t14213 = (t14212/9333);
bool t14214 = (0>=t14213);
float t14215;
if(t14214){
t14215 = 0;
} else {
t14215 = t14213;
}
float t14216 = (t14211-t14215);
float t14217 = (t14216*t1750);
float t14218 = (t1789*t14216);
float t14219 = (t14217+t14218);
float t14220 = (t14208+t14219);
float t14221 = (t1815/4000);
bool t14222 = (1<=t14221);
float t14223;
if(t14222){
t14223 = 1;
} else {
t14223 = t14221;
}
float t14224 = (t1815-7000);
float t14225 = (t14224/9333);
bool t14226 = (0>=t14225);
float t14227;
if(t14226){
t14227 = 0;
} else {
t14227 = t14225;
}
float t14228 = (t14223-t14227);
float t14229 = (t14228*t1968);
float t14230 = (t2007*t14228);
float t14231 = (t14229+t14230);
float t14232 = (t14220+t14231);
float t14233 = (t2042/4000);
bool t14234 = (1<=t14233);
float t14235;
if(t14234){
t14235 = 1;
} else {
t14235 = t14233;
}
float t14236 = (t2042-7000);
float t14237 = (t14236/9333);
bool t14238 = (0>=t14237);
float t14239;
if(t14238){
t14239 = 0;
} else {
t14239 = t14237;
}
float t14240 = (t14235-t14239);
float t14241 = (t14240*t2195);
float t14242 = (t2234*t14240);
float t14243 = (t14241+t14242);
float t14244 = (t14232+t14243);
float t14245 = (float(0.3)*t2633);
bool t14246 = (0>=t14245);
float t14247;
if(t14246){
t14247 = 0;
} else {
t14247 = t14245;
}
float t14248 = (t14247*1);
float t14249 = (t14244+t14248);
float t14250 = (float(0.3)*t3034);
bool t14251 = (0>=t14250);
float t14252;
if(t14251){
t14252 = 0;
} else {
t14252 = t14250;
}
float t14253 = (t14252*1);
float t14254 = (t14249+t14253);
float t14255 = (float(0.3)*t3436);
bool t14256 = (0>=t14255);
float t14257;
if(t14256){
t14257 = 0;
} else {
t14257 = t14255;
}
float t14258 = (t14257*1);
float t14259 = (t14254+t14258);
float t14260 = (float(0.3)*t3837);
bool t14261 = (0>=t14260);
float t14262;
if(t14261){
t14262 = 0;
} else {
t14262 = t14260;
}
float t14263 = (t14262*1);
float t14264 = (t14259+t14263);
float t14265 = (float(0.3)*t4238);
bool t14266 = (0>=t14265);
float t14267;
if(t14266){
t14267 = 0;
} else {
t14267 = t14265;
}
float t14268 = (t14267*1);
float t14269 = (t14264+t14268);
float t14270 = (float(0.3)*t4639);
bool t14271 = (0>=t14270);
float t14272;
if(t14271){
t14272 = 0;
} else {
t14272 = t14270;
}
float t14273 = (t14272*1);
float t14274 = (t14269+t14273);
float t14275 = (float(0.3)*t5041);
bool t14276 = (0>=t14275);
float t14277;
if(t14276){
t14277 = 0;
} else {
t14277 = t14275;
}
float t14278 = (t14277*1);
float t14279 = (t14274+t14278);
float t14280 = (float(0.3)*t5442);
bool t14281 = (0>=t14280);
float t14282;
if(t14281){
t14282 = 0;
} else {
t14282 = t14280;
}
float t14283 = (t14282*1);
float t14284 = (t14279+t14283);
float t14285 = (t5481/4000);
bool t14286 = (1<=t14285);
float t14287;
if(t14286){
t14287 = 1;
} else {
t14287 = t14285;
}
float t14288 = (t5481-7000);
float t14289 = (t14288/9333);
bool t14290 = (0>=t14289);
float t14291;
if(t14290){
t14291 = 0;
} else {
t14291 = t14289;
}
float t14292 = (t14287-t14291);
float t14293 = (t14292*t5634);
float t14294 = (t5673*t14292);
float t14295 = (t14293+t14294);
float t14296 = (0+t14295);
float t14297 = (t5699/4000);
bool t14298 = (1<=t14297);
float t14299;
if(t14298){
t14299 = 1;
} else {
t14299 = t14297;
}
float t14300 = (t5699-7000);
float t14301 = (t14300/9333);
bool t14302 = (0>=t14301);
float t14303;
if(t14302){
t14303 = 0;
} else {
t14303 = t14301;
}
float t14304 = (t14299-t14303);
float t14305 = (t14304*t5852);
float t14306 = (t5891*t14304);
float t14307 = (t14305+t14306);
float t14308 = (t14296+t14307);
float t14309 = (t5917/4000);
bool t14310 = (1<=t14309);
float t14311;
if(t14310){
t14311 = 1;
} else {
t14311 = t14309;
}
float t14312 = (t5917-7000);
float t14313 = (t14312/9333);
bool t14314 = (0>=t14313);
float t14315;
if(t14314){
t14315 = 0;
} else {
t14315 = t14313;
}
float t14316 = (t14311-t14315);
float t14317 = (t14316*t6070);
float t14318 = (t6109*t14316);
float t14319 = (t14317+t14318);
float t14320 = (t14308+t14319);
float t14321 = (t6144/4000);
bool t14322 = (1<=t14321);
float t14323;
if(t14322){
t14323 = 1;
} else {
t14323 = t14321;
}
float t14324 = (t6144-7000);
float t14325 = (t14324/9333);
bool t14326 = (0>=t14325);
float t14327;
if(t14326){
t14327 = 0;
} else {
t14327 = t14325;
}
float t14328 = (t14323-t14327);
float t14329 = (t14328*t6297);
float t14330 = (t6336*t14328);
float t14331 = (t14329+t14330);
float t14332 = (t14320+t14331);
float t14333 = (float(0.3)*t6735);
bool t14334 = (0>=t14333);
float t14335;
if(t14334){
t14335 = 0;
} else {
t14335 = t14333;
}
float t14336 = (t14335*0);
float t14337 = (t14332+t14336);
float t14338 = (float(0.3)*t7136);
bool t14339 = (0>=t14338);
float t14340;
if(t14339){
t14340 = 0;
} else {
t14340 = t14338;
}
float t14341 = (t14340*0);
float t14342 = (t14337+t14341);
float t14343 = (float(0.3)*t7538);
bool t14344 = (0>=t14343);
float t14345;
if(t14344){
t14345 = 0;
} else {
t14345 = t14343;
}
float t14346 = (t14345*0);
float t14347 = (t14342+t14346);
float t14348 = (float(0.3)*t7939);
bool t14349 = (0>=t14348);
float t14350;
if(t14349){
t14350 = 0;
} else {
t14350 = t14348;
}
float t14351 = (t14350*0);
float t14352 = (t14347+t14351);
float t14353 = (float(0.3)*t8340);
bool t14354 = (0>=t14353);
float t14355;
if(t14354){
t14355 = 0;
} else {
t14355 = t14353;
}
float t14356 = (t14355*0);
float t14357 = (t14352+t14356);
float t14358 = (float(0.3)*t8741);
bool t14359 = (0>=t14358);
float t14360;
if(t14359){
t14360 = 0;
} else {
t14360 = t14358;
}
float t14361 = (t14360*0);
float t14362 = (t14357+t14361);
float t14363 = (float(0.3)*t9143);
bool t14364 = (0>=t14363);
float t14365;
if(t14364){
t14365 = 0;
} else {
t14365 = t14363;
}
float t14366 = (t14365*0);
float t14367 = (t14362+t14366);
float t14368 = (float(0.3)*t9544);
bool t14369 = (0>=t14368);
float t14370;
if(t14369){
t14370 = 0;
} else {
t14370 = t14368;
}
float t14371 = (t14370*0);
float t14372 = (t14367+t14371);
float t14373 = (t14372*float(0.33));
float t14374 = (t14284+t14373);
float t14375 = (t10031/4000);
bool t14376 = (1<=t14375);
float t14377;
if(t14376){
t14377 = 1;
} else {
t14377 = t14375;
}
float t14378 = (t10031-7000);
float t14379 = (t14378/9333);
bool t14380 = (0>=t14379);
float t14381;
if(t14380){
t14381 = 0;
} else {
t14381 = t14379;
}
float t14382 = (t14377-t14381);
float t14383 = (t14382*t10184);
float t14384 = (t10223*t14382);
float t14385 = (t14383+t14384);
float t14386 = (0+t14385);
float t14387 = (t10249/4000);
bool t14388 = (1<=t14387);
float t14389;
if(t14388){
t14389 = 1;
} else {
t14389 = t14387;
}
float t14390 = (t10249-7000);
float t14391 = (t14390/9333);
bool t14392 = (0>=t14391);
float t14393;
if(t14392){
t14393 = 0;
} else {
t14393 = t14391;
}
float t14394 = (t14389-t14393);
float t14395 = (t14394*t10402);
float t14396 = (t10441*t14394);
float t14397 = (t14395+t14396);
float t14398 = (t14386+t14397);
float t14399 = (t10467/4000);
bool t14400 = (1<=t14399);
float t14401;
if(t14400){
t14401 = 1;
} else {
t14401 = t14399;
}
float t14402 = (t10467-7000);
float t14403 = (t14402/9333);
bool t14404 = (0>=t14403);
float t14405;
if(t14404){
t14405 = 0;
} else {
t14405 = t14403;
}
float t14406 = (t14401-t14405);
float t14407 = (t14406*t10620);
float t14408 = (t10659*t14406);
float t14409 = (t14407+t14408);
float t14410 = (t14398+t14409);
float t14411 = (t10694/4000);
bool t14412 = (1<=t14411);
float t14413;
if(t14412){
t14413 = 1;
} else {
t14413 = t14411;
}
float t14414 = (t10694-7000);
float t14415 = (t14414/9333);
bool t14416 = (0>=t14415);
float t14417;
if(t14416){
t14417 = 0;
} else {
t14417 = t14415;
}
float t14418 = (t14413-t14417);
float t14419 = (t14418*t10847);
float t14420 = (t10886*t14418);
float t14421 = (t14419+t14420);
float t14422 = (t14410+t14421);
float t14423 = (float(0.3)*t11285);
bool t14424 = (0>=t14423);
float t14425;
if(t14424){
t14425 = 0;
} else {
t14425 = t14423;
}
float t14426 = (t14425*0);
float t14427 = (t14422+t14426);
float t14428 = (float(0.3)*t11686);
bool t14429 = (0>=t14428);
float t14430;
if(t14429){
t14430 = 0;
} else {
t14430 = t14428;
}
float t14431 = (t14430*0);
float t14432 = (t14427+t14431);
float t14433 = (float(0.3)*t12088);
bool t14434 = (0>=t14433);
float t14435;
if(t14434){
t14435 = 0;
} else {
t14435 = t14433;
}
float t14436 = (t14435*0);
float t14437 = (t14432+t14436);
float t14438 = (float(0.3)*t12489);
bool t14439 = (0>=t14438);
float t14440;
if(t14439){
t14440 = 0;
} else {
t14440 = t14438;
}
float t14441 = (t14440*0);
float t14442 = (t14437+t14441);
float t14443 = (float(0.3)*t12890);
bool t14444 = (0>=t14443);
float t14445;
if(t14444){
t14445 = 0;
} else {
t14445 = t14443;
}
float t14446 = (t14445*0);
float t14447 = (t14442+t14446);
float t14448 = (float(0.3)*t13291);
bool t14449 = (0>=t14448);
float t14450;
if(t14449){
t14450 = 0;
} else {
t14450 = t14448;
}
float t14451 = (t14450*0);
float t14452 = (t14447+t14451);
float t14453 = (float(0.3)*t13693);
bool t14454 = (0>=t14453);
float t14455;
if(t14454){
t14455 = 0;
} else {
t14455 = t14453;
}
float t14456 = (t14455*0);
float t14457 = (t14452+t14456);
float t14458 = (float(0.3)*t14094);
bool t14459 = (0>=t14458);
float t14460;
if(t14459){
t14460 = 0;
} else {
t14460 = t14458;
}
float t14461 = (t14460*0);
float t14462 = (t14457+t14461);
float t14463 = (t14462*t14100);
bool t14464 = (t9997>=t14463);
float t14465;
if(t14464){
t14465 = t9997;
} else {
t14465 = t14463;
}
float t14466 = (t14374+t14465);
float t14467 = (t14466*t14150);
float t14468 = (t14467*t14152);
float t14469 = (t14196+t14468);
float t14470 = (t14469*t14155);
float t14471 = (t14187+t14470);
float t14472 = (float(0.72)*t1);
float t14473 = (t0+t14472);
float t14474 = (t14473*t155);
float t14475 = (float(0.8)*t469);
float t14476 = (float(0.0)+t14475);
float t14477 = (t14476*t472);
float t14478 = (t14474+t14477);
float t14479 = (t14478*t524);
float t14480 = (float(0.0)*t678);
float t14481 = (t14480*t680);
float t14482 = (t14479+t14481);
float t14483 = (t14482*t685);
float t14484 = (float(0.2)*t839);
float t14485 = (t14484*t841);
float t14486 = (t14483+t14485);
float t14487 = (t14486*t846);
float t14488 = (t1062*t1063);
float t14489 = (float(6.0e-2)*t1065);
float t14490 = (t14488+t14489);
float t14491 = (t14490*t1072);
float t14492 = (t14491*t1077);
float t14493 = (0*t1079);
float t14494 = (t14492+t14493);
float t14495 = (t1000*t14494);
float t14496 = (t14495*t1083);
float t14497 = (t14487+t14496);
float t14498 = (t14497*t1092);
float t14499 = (float(0.7)*t1246);
float t14500 = (t14499*t1248);
float t14501 = (t14498+t14500);
float t14502 = (t14501*t1254);
float t14503 = (float(1.0)*t1256);
float t14504 = (float(0.6)*t1258);
float t14505 = (t14503+t14504);
float t14506 = (-float(0.4));
float t14507 = (t14506*t1296);
float t14508 = (t14507*t1300);
float t14509 = (t14508*t1334);
float t14510 = (t14505+t14509);
float t14511 = (u8.u0*t14510);
float t14512 = (t14511*t1342);
float t14513 = (t1377/8000);
bool t14514 = (1<=t14513);
float t14515;
if(t14514){
t14515 = 1;
} else {
t14515 = t14513;
}
float t14516 = (t14515*t1532);
float t14517 = (t1571*t14515);
float t14518 = (t14516+t14517);
float t14519 = (0+t14518);
float t14520 = (t1597/8000);
bool t14521 = (1<=t14520);
float t14522;
if(t14521){
t14522 = 1;
} else {
t14522 = t14520;
}
float t14523 = (t14522*t1750);
float t14524 = (t1789*t14522);
float t14525 = (t14523+t14524);
float t14526 = (t14519+t14525);
float t14527 = (t1815/8000);
bool t14528 = (1<=t14527);
float t14529;
if(t14528){
t14529 = 1;
} else {
t14529 = t14527;
}
float t14530 = (t14529*t1968);
float t14531 = (t2007*t14529);
float t14532 = (t14530+t14531);
float t14533 = (t14526+t14532);
float t14534 = (t2042/8000);
bool t14535 = (1<=t14534);
float t14536;
if(t14535){
t14536 = 1;
} else {
t14536 = t14534;
}
float t14537 = (t14536*t2195);
float t14538 = (t2234*t14536);
float t14539 = (t14537+t14538);
float t14540 = (t14533+t14539);
float t14541 = (float(0.7)*t2633);
bool t14542 = (0>=t14541);
float t14543;
if(t14542){
t14543 = 0;
} else {
t14543 = t14541;
}
float t14544 = (t14543*1);
float t14545 = (t14540+t14544);
float t14546 = (float(0.7)*t3034);
bool t14547 = (0>=t14546);
float t14548;
if(t14547){
t14548 = 0;
} else {
t14548 = t14546;
}
float t14549 = (t14548*1);
float t14550 = (t14545+t14549);
float t14551 = (float(0.7)*t3436);
bool t14552 = (0>=t14551);
float t14553;
if(t14552){
t14553 = 0;
} else {
t14553 = t14551;
}
float t14554 = (t14553*1);
float t14555 = (t14550+t14554);
float t14556 = (float(0.7)*t3837);
bool t14557 = (0>=t14556);
float t14558;
if(t14557){
t14558 = 0;
} else {
t14558 = t14556;
}
float t14559 = (t14558*1);
float t14560 = (t14555+t14559);
float t14561 = (float(0.7)*t4238);
bool t14562 = (0>=t14561);
float t14563;
if(t14562){
t14563 = 0;
} else {
t14563 = t14561;
}
float t14564 = (t14563*1);
float t14565 = (t14560+t14564);
float t14566 = (float(0.7)*t4639);
bool t14567 = (0>=t14566);
float t14568;
if(t14567){
t14568 = 0;
} else {
t14568 = t14566;
}
float t14569 = (t14568*1);
float t14570 = (t14565+t14569);
float t14571 = (float(0.7)*t5041);
bool t14572 = (0>=t14571);
float t14573;
if(t14572){
t14573 = 0;
} else {
t14573 = t14571;
}
float t14574 = (t14573*1);
float t14575 = (t14570+t14574);
float t14576 = (float(0.7)*t5442);
bool t14577 = (0>=t14576);
float t14578;
if(t14577){
t14578 = 0;
} else {
t14578 = t14576;
}
float t14579 = (t14578*1);
float t14580 = (t14575+t14579);
float t14581 = (t5481/8000);
bool t14582 = (1<=t14581);
float t14583;
if(t14582){
t14583 = 1;
} else {
t14583 = t14581;
}
float t14584 = (t14583*t5634);
float t14585 = (t5673*t14583);
float t14586 = (t14584+t14585);
float t14587 = (0+t14586);
float t14588 = (t5699/8000);
bool t14589 = (1<=t14588);
float t14590;
if(t14589){
t14590 = 1;
} else {
t14590 = t14588;
}
float t14591 = (t14590*t5852);
float t14592 = (t5891*t14590);
float t14593 = (t14591+t14592);
float t14594 = (t14587+t14593);
float t14595 = (t5917/8000);
bool t14596 = (1<=t14595);
float t14597;
if(t14596){
t14597 = 1;
} else {
t14597 = t14595;
}
float t14598 = (t14597*t6070);
float t14599 = (t6109*t14597);
float t14600 = (t14598+t14599);
float t14601 = (t14594+t14600);
float t14602 = (t6144/8000);
bool t14603 = (1<=t14602);
float t14604;
if(t14603){
t14604 = 1;
} else {
t14604 = t14602;
}
float t14605 = (t14604*t6297);
float t14606 = (t6336*t14604);
float t14607 = (t14605+t14606);
float t14608 = (t14601+t14607);
float t14609 = (float(0.7)*t6735);
bool t14610 = (0>=t14609);
float t14611;
if(t14610){
t14611 = 0;
} else {
t14611 = t14609;
}
float t14612 = (t14611*0);
float t14613 = (t14608+t14612);
float t14614 = (float(0.7)*t7136);
bool t14615 = (0>=t14614);
float t14616;
if(t14615){
t14616 = 0;
} else {
t14616 = t14614;
}
float t14617 = (t14616*0);
float t14618 = (t14613+t14617);
float t14619 = (float(0.7)*t7538);
bool t14620 = (0>=t14619);
float t14621;
if(t14620){
t14621 = 0;
} else {
t14621 = t14619;
}
float t14622 = (t14621*0);
float t14623 = (t14618+t14622);
float t14624 = (float(0.7)*t7939);
bool t14625 = (0>=t14624);
float t14626;
if(t14625){
t14626 = 0;
} else {
t14626 = t14624;
}
float t14627 = (t14626*0);
float t14628 = (t14623+t14627);
float t14629 = (float(0.7)*t8340);
bool t14630 = (0>=t14629);
float t14631;
if(t14630){
t14631 = 0;
} else {
t14631 = t14629;
}
float t14632 = (t14631*0);
float t14633 = (t14628+t14632);
float t14634 = (float(0.7)*t8741);
bool t14635 = (0>=t14634);
float t14636;
if(t14635){
t14636 = 0;
} else {
t14636 = t14634;
}
float t14637 = (t14636*0);
float t14638 = (t14633+t14637);
float t14639 = (float(0.7)*t9143);
bool t14640 = (0>=t14639);
float t14641;
if(t14640){
t14641 = 0;
} else {
t14641 = t14639;
}
float t14642 = (t14641*0);
float t14643 = (t14638+t14642);
float t14644 = (float(0.7)*t9544);
bool t14645 = (0>=t14644);
float t14646;
if(t14645){
t14646 = 0;
} else {
t14646 = t14644;
}
float t14647 = (t14646*0);
float t14648 = (t14643+t14647);
float t14649 = (t14648*float(0.33));
float t14650 = (t14580+t14649);
float t14651 = (t10031/8000);
bool t14652 = (1<=t14651);
float t14653;
if(t14652){
t14653 = 1;
} else {
t14653 = t14651;
}
float t14654 = (t14653*t10184);
float t14655 = (t10223*t14653);
float t14656 = (t14654+t14655);
float t14657 = (0+t14656);
float t14658 = (t10249/8000);
bool t14659 = (1<=t14658);
float t14660;
if(t14659){
t14660 = 1;
} else {
t14660 = t14658;
}
float t14661 = (t14660*t10402);
float t14662 = (t10441*t14660);
float t14663 = (t14661+t14662);
float t14664 = (t14657+t14663);
float t14665 = (t10467/8000);
bool t14666 = (1<=t14665);
float t14667;
if(t14666){
t14667 = 1;
} else {
t14667 = t14665;
}
float t14668 = (t14667*t10620);
float t14669 = (t10659*t14667);
float t14670 = (t14668+t14669);
float t14671 = (t14664+t14670);
float t14672 = (t10694/8000);
bool t14673 = (1<=t14672);
float t14674;
if(t14673){
t14674 = 1;
} else {
t14674 = t14672;
}
float t14675 = (t14674*t10847);
float t14676 = (t10886*t14674);
float t14677 = (t14675+t14676);
float t14678 = (t14671+t14677);
float t14679 = (float(0.7)*t11285);
bool t14680 = (0>=t14679);
float t14681;
if(t14680){
t14681 = 0;
} else {
t14681 = t14679;
}
float t14682 = (t14681*0);
float t14683 = (t14678+t14682);
float t14684 = (float(0.7)*t11686);
bool t14685 = (0>=t14684);
float t14686;
if(t14685){
t14686 = 0;
} else {
t14686 = t14684;
}
float t14687 = (t14686*0);
float t14688 = (t14683+t14687);
float t14689 = (float(0.7)*t12088);
bool t14690 = (0>=t14689);
float t14691;
if(t14690){
t14691 = 0;
} else {
t14691 = t14689;
}
float t14692 = (t14691*0);
float t14693 = (t14688+t14692);
float t14694 = (float(0.7)*t12489);
bool t14695 = (0>=t14694);
float t14696;
if(t14695){
t14696 = 0;
} else {
t14696 = t14694;
}
float t14697 = (t14696*0);
float t14698 = (t14693+t14697);
float t14699 = (float(0.7)*t12890);
bool t14700 = (0>=t14699);
float t14701;
if(t14700){
t14701 = 0;
} else {
t14701 = t14699;
}
float t14702 = (t14701*0);
float t14703 = (t14698+t14702);
float t14704 = (float(0.7)*t13291);
bool t14705 = (0>=t14704);
float t14706;
if(t14705){
t14706 = 0;
} else {
t14706 = t14704;
}
float t14707 = (t14706*0);
float t14708 = (t14703+t14707);
float t14709 = (float(0.7)*t13693);
bool t14710 = (0>=t14709);
float t14711;
if(t14710){
t14711 = 0;
} else {
t14711 = t14709;
}
float t14712 = (t14711*0);
float t14713 = (t14708+t14712);
float t14714 = (float(0.7)*t14094);
bool t14715 = (0>=t14714);
float t14716;
if(t14715){
t14716 = 0;
} else {
t14716 = t14714;
}
float t14717 = (t14716*0);
float t14718 = (t14713+t14717);
float t14719 = (t14718*t14100);
bool t14720 = (t9997>=t14719);
float t14721;
if(t14720){
t14721 = t9997;
} else {
t14721 = t14719;
}
float t14722 = (t14650+t14721);
float t14723 = (t14722*t14150);
float t14724 = (t14723*t14152);
float t14725 = (t14512+t14724);
float t14726 = (t14725*t14155);
float t14727 = (t14502+t14726);
float t14728 = (1*t14150);
float t14729 = (1-t14728);
float t14730 = (t14729*t1342);
float t14731 = (t14728+t14730);
float t14732 = (1-t14731);
float t14733 = (t14732*t1254);
float t14734 = (t14731+t14733);
out0 = vec4(t14157,t14471,t14727,t14734);
gl_FragDepth = gl_FragCoord[2];
}