falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1817 Commits
16 Branches
16GB
Tree: 8738b6ecd1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8738b6ecd1'
${ noResults }
Carla/source/modules/native-plugins/zamtube/ZamTubePlugin.cpp

1086 lines
64KB
Raw Blame History 

  1. /*

  2.  * ZamTube triode WDF distortion model

  3.  * Copyright (C) 2014  Damien Zammit <damien@zamaudio.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  *

  17.  * Tone Stacks from David Yeh's faust implementation.

  18.  *

  19.  */

  20. 

  21. #include "ZamTubePlugin.hpp"

  22. 

  23. START_NAMESPACE_DISTRHO

  24. 

  25. // -----------------------------------------------------------------------

  26. 

  27. ZamTubePlugin::ZamTubePlugin()

  28.     : Plugin(paramCount, 1, 0), // 1 program, 0 states

  29. 		Vi(0.0,10000.0), Ci(0.0000001,48000.0), Ck(0.00001,48000.0), Co(0.00000001,48000.0), Ro(1000000.0), Rg(20000.0), 

  30. 		Ri(1000000.0), Rk(1000.0), E(250.0,100000.0), 

  31. 		S0(&Ci,&Vi), I0(&S0), P0(&I0,&Ri), S1(&Rg,&P0), 

  32. 		I1(&S1), I3(&Ck,&Rk), S2(&Co,&Ro), I4(&S2), P2(&I4,&E) 

  33. {

  34.     // set default values

  35.     d_setProgram(0);

  36. }

  37. 

  38. // -----------------------------------------------------------------------

  39. // Init

  40. 

  41. void ZamTubePlugin::d_initParameter(uint32_t index, Parameter& parameter)

  42. {

  43.     switch (index)

  44.     {

  45.     case paramTubedrive:

  46.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  47.         parameter.name       = "Tube Drive";

  48.         parameter.symbol     = "tubedrive";

  49.         parameter.unit       = " ";

  50.         parameter.ranges.def = 0.0f;

  51.         parameter.ranges.min = -30.0f;

  52.         parameter.ranges.max = 30.0f;

  53.         break;

  54.     case paramBass:

  55.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  56.         parameter.name       = "Bass";

  57.         parameter.symbol     = "bass";

  58.         parameter.unit       = " ";

  59.         parameter.ranges.def = 0.5f;

  60.         parameter.ranges.min = 0.0f;

  61.         parameter.ranges.max = 1.0f;

  62.         break;

  63.     case paramMiddle:

  64.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  65.         parameter.name       = "Mids";

  66.         parameter.symbol     = "mids";

  67.         parameter.unit       = " ";

  68.         parameter.ranges.def = 0.5f;

  69.         parameter.ranges.min = 0.0f;

  70.         parameter.ranges.max = 1.0f;

  71.         break;

  72.     case paramTreble:

  73.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  74.         parameter.name       = "Treble";

  75.         parameter.symbol     = "treb";

  76.         parameter.unit       = " ";

  77.         parameter.ranges.def = 0.0f;

  78.         parameter.ranges.min = 0.0f;

  79.         parameter.ranges.max = 1.0f;

  80.         break;

  81.     case paramToneStack:

  82.         parameter.hints      = PARAMETER_IS_AUTOMABLE | PARAMETER_IS_INTEGER;

  83.         parameter.name       = "Tone Stack Model";

  84.         parameter.symbol     = "tonestack";

  85.         parameter.unit       = " ";

  86.         parameter.ranges.def = 0.0f;

  87.         parameter.ranges.min = 0.0f;

  88.         parameter.ranges.max = 24.0f;

  89.         break;

  90.     case paramGain:

  91.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  92.         parameter.name       = "Output level";

  93.         parameter.symbol     = "gain";

  94.         parameter.unit       = " ";

  95.         parameter.ranges.def = 0.0f;

  96.         parameter.ranges.min = -15.0f;

  97.         parameter.ranges.max = 15.0f;

  98.         break;

  99.     }

  100. }

  101. 

  102. void ZamTubePlugin::d_initProgramName(uint32_t index, d_string& programName)

  103. {

  104.     if (index != 0)

  105.         return;

  106. 

  107.     programName = "Default";

  108. }

  109. 

  110. // -----------------------------------------------------------------------

  111. // Internal data

  112. 

  113. float ZamTubePlugin::d_getParameterValue(uint32_t index) const

  114. {

  115.     switch (index)

  116.     {

  117.     case paramTubedrive:

  118.         return tubedrive;

  119.         break;

  120.     case paramBass:

  121.         return bass;

  122.         break;

  123.     case paramMiddle:

  124.         return middle;

  125.         break;

  126.     case paramTreble:

  127.         return treble;

  128.         break;

  129.     case paramToneStack:

  130.         return tonestack;

  131.         break;

  132.     case paramGain:

  133.         return mastergain;

  134.         break;

  135.     default:

  136.         return 0.0f;

  137.     }

  138. }

  139. 

  140. void ZamTubePlugin::d_setParameterValue(uint32_t index, float value)

  141. {

  142.     switch (index)

  143.     {

  144.     case paramTubedrive:

  145.         tubedrive = value;

  146.         break;

  147.     case paramBass:

  148.         bass = value;

  149.         break;

  150.     case paramMiddle:

  151.         middle = value;

  152.         break;

  153.     case paramTreble:

  154.         treble = value;

  155.         break;

  156.     case paramToneStack:

  157.         tonestack = value;

  158.         break;

  159.     case paramGain:

  160.         mastergain = value;

  161.         break;

  162.     }

  163. }

  164. 

  165. void ZamTubePlugin::d_setProgram(uint32_t index)

  166. {

  167.     if (index != 0)

  168.         return;

  169. 

  170.     /* Default parameter values */

  171.     tubedrive = 0.0f;

  172.     bass = 0.5f;

  173.     middle = 0.5f;

  174.     treble = 0.0f;

  175.     tonestack = 0.0f;

  176.     mastergain = 0.0f;

  177. 

  178.     /* Default variable values */

  179. 

  180.     /* reset filter values */

  181.     d_activate();

  182. }

  183. 

  184. // -----------------------------------------------------------------------

  185. // Process

  186. 

  187. void ZamTubePlugin::d_activate()

  188. {

  189. 

  190. 	T Fs = d_getSampleRate();

  191. 	

  192. 	// Passive components

  193. 	T ci = 0.0000001;	//100nF

  194. 	T ck = 0.00001;		//10uF

  195. 	T co = 0.00000001;	//10nF

  196. 	T ro = 1000000.0;	//1Mohm

  197. 	T rp = 100000.0;	//100kohm

  198. 	T rg = 20000.0;		//20kohm

  199. 	T ri = 1000000.0;	//1Mohm

  200. 	T rk = 1000.0;		//1kohm

  201. 	e = 250.0;		//250V

  202. 

  203. 	Vi = V(0.0,10000.0);	//1kohm internal resistance

  204. 	Ci = C(ci, Fs);

  205. 	Ck = C(ck, Fs);

  206. 	Co = C(co, Fs);

  207. 	Ro = R(ro);

  208. 	Rg = R(rg);

  209. 	Ri = R(ri);

  210. 	Rk = R(rk);

  211. 	E = V(e, rp);

  212. 

  213. 	//Official

  214. 	//->Gate

  215. 	S0 = ser(&Ci, &Vi);

  216. 	I0 = inv(&S0);

  217. 	P0 = par(&I0, &Ri);

  218. 	S1 = ser(&Rg, &P0);

  219. 	I1 = inv(&S1);

  220. 

  221. 	//->Cathode

  222. 	I3 = par(&Ck, &Rk);

  223. 

  224. 	//->Plate

  225. 	S2 = ser(&Co, &Ro);

  226. 	I4 = inv(&S2);

  227. 	P2 = par(&I4, &E);

  228. 

  229. 	// 12AX7 triode model RSD-1

  230. 	v.g1 = 2.242e-3;

  231. 	v.mu1 = 103.2;

  232. 	v.gamma1 = 1.26;

  233. 	v.c1 = 3.4;

  234. 	v.gg1 = 6.177e-4;

  235. 	v.e1 = 1.314;

  236. 	v.cg1 = 9.901;

  237. 	v.ig01 = 8.025e-8;

  238. 

  239. 	// 12AX7 triode model EHX-1

  240. 	v.g2 = 1.371e-3;

  241. 	v.mu2 = 86.9;

  242. 	v.gamma2 = 1.349;

  243. 	v.c2 = 4.56;

  244. 	v.gg2 = 3.263e-4;

  245. 	v.e2 = 1.156;

  246. 	v.cg2 = 11.99;

  247. 	v.ig02 = 3.917e-8;

  248. 

  249.         fSamplingFreq = Fs;

  250.         fConst0 = float(min(192000, max(1, fSamplingFreq)));

  251.         fConst1 = (2 * fConst0);

  252.         fConst2 = faustpower<2>(fConst1);

  253.         fConst3 = (3 * fConst1);

  254.         for (int i=0; i<4; i++) fRec0[i] = 0;

  255.         for (int i=0; i<4; i++) fRec1[i] = 0;

  256.         for (int i=0; i<4; i++) fRec2[i] = 0;

  257.         for (int i=0; i<4; i++) fRec3[i] = 0;

  258.         for (int i=0; i<4; i++) fRec4[i] = 0;

  259.         for (int i=0; i<4; i++) fRec5[i] = 0;

  260.         for (int i=0; i<4; i++) fRec6[i] = 0;

  261.         for (int i=0; i<4; i++) fRec7[i] = 0;

  262.         for (int i=0; i<4; i++) fRec8[i] = 0;

  263.         for (int i=0; i<4; i++) fRec9[i] = 0;

  264.         for (int i=0; i<4; i++) fRec10[i] = 0;

  265.         for (int i=0; i<4; i++) fRec11[i] = 0;

  266.         for (int i=0; i<4; i++) fRec12[i] = 0;

  267.         for (int i=0; i<4; i++) fRec13[i] = 0;

  268.         fConst4 = (1.0691560000000003e-08f * fConst1);

  269.         fConst5 = (3.2074680000000005e-08f * fConst1);

  270.         for (int i=0; i<4; i++) fRec14[i] = 0;

  271.         fConst6 = (0.044206800000000004f * fConst0);

  272.         for (int i=0; i<4; i++) fRec15[i] = 0;

  273.         for (int i=0; i<4; i++) fRec16[i] = 0;

  274.         for (int i=0; i<4; i++) fRec17[i] = 0;

  275.         for (int i=0; i<4; i++) fRec18[i] = 0;

  276.         for (int i=0; i<4; i++) fRec19[i] = 0;

  277.         for (int i=0; i<4; i++) fRec20[i] = 0;

  278.         for (int i=0; i<4; i++) fRec21[i] = 0;

  279.         for (int i=0; i<4; i++) fRec22[i] = 0;

  280.         for (int i=0; i<4; i++) fRec23[i] = 0;

  281.         for (int i=0; i<4; i++) fRec24[i] = 0;

  282. }

  283. 

  284. void ZamTubePlugin::d_run(const float** inputs, float** outputs, uint32_t frames)

  285. {

  286. 	T tubetone = 0.f;

  287. 	

  288. 	//12AX7 triode tube mod

  289. 	v.g = v.g1 + (v.g2-v.g1)*tubetone;

  290. 	v.mu = v.mu1 + (v.mu2-v.mu1)*tubetone;

  291. 	v.gamma = v.gamma1 + (v.gamma2-v.gamma1)*tubetone;

  292. 	v.c = v.c1 + (v.c2-v.c1)*tubetone;

  293. 	v.gg = v.gg1 + (v.gg2-v.gg1)*tubetone;

  294. 	v.e = v.e1 + (v.e2-v.e1)*tubetone;

  295. 	v.cg = v.cg1 + (v.cg2-v.cg1)*tubetone;

  296. 	v.ig0 = v.ig01 + (v.ig02-v.ig01)*tubetone;

  297. 

  298. 	float 	fSlow0 = middle;

  299. 	float 	fSlow1 = (1.3784375e-06f * fSlow0);

  300. 	float 	fSlow2 = expf((3.4f * (bass - 1)));

  301. 	float 	fSlow3 = (8.396625e-06f + ((7.405375e-05f * fSlow2) + (fSlow0 * (((1.3784375000000003e-05f * fSlow2) - 5.7371875e-06f) - fSlow1))));

  302. 	float 	fSlow4 = ((1.3062500000000001e-09f * fSlow2) - (1.30625e-10f * fSlow0));

  303. 	float 	fSlow5 = (4.468750000000001e-09f * fSlow2);

  304. 	float 	fSlow6 = (4.46875e-10f + (fSlow5 + (fSlow0 * (fSlow4 - 3.1625e-10f))));

  305. 	float 	fSlow7 = (fConst1 * fSlow6);

  306. 	float 	fSlow8 = (0.00055f * fSlow0);

  307. 	float 	fSlow9 = (0.0250625f * fSlow2);

  308. 	float 	fSlow10 = (fConst1 * (0.01842875f + (fSlow9 + fSlow8)));

  309. 	float 	fSlow11 = ((fSlow10 + (fConst2 * (fSlow7 - fSlow3))) - 1);

  310. 	float 	fSlow12 = (fConst3 * fSlow6);

  311. 	float 	fSlow13 = ((fConst2 * (fSlow3 + fSlow12)) - (3 + fSlow10));

  312. 	float 	fSlow14 = ((fSlow10 + (fConst2 * (fSlow3 - fSlow12))) - 3);

  313. 	float 	fSlow15 = (0 - (1 + (fSlow10 + (fConst2 * (fSlow3 + fSlow7)))));

  314. 	float 	fSlow16 = (1.0f / fSlow15);

  315. 	float 	fSlow17 = treble;

  316. 	float 	fSlow18 = ((fSlow0 * (1.30625e-10f + fSlow4)) + (fSlow17 * ((4.46875e-10f - (4.46875e-10f * fSlow0)) + fSlow5)));

  317. 	float 	fSlow19 = (fConst3 * fSlow18);

  318. 	float 	fSlow20 = (2.55375e-07f + (((9.912500000000003e-07f * fSlow17) + (fSlow0 * (1.4128125e-06f - fSlow1))) + (fSlow2 * (2.5537500000000007e-06f + (1.3784375000000003e-05f * fSlow0)))));

  319. 	float 	fSlow21 = (6.25e-05f * fSlow17);

  320. 	float 	fSlow22 = (fSlow8 + fSlow21);

  321. 	float 	fSlow23 = (0.0025062500000000002f + (fSlow9 + fSlow22));

  322. 	float 	fSlow24 = (fConst1 * fSlow23);

  323. 	float 	fSlow25 = (fSlow24 + (fConst2 * (fSlow20 - fSlow19)));

  324. 	float 	fSlow26 = (fConst1 * fSlow18);

  325. 	float 	fSlow27 = (fSlow24 + (fConst2 * (fSlow26 - fSlow20)));

  326. 	float 	fSlow28 = (fConst1 * (0 - fSlow23));

  327. 	float 	fSlow29 = (fSlow28 + (fConst2 * (fSlow20 + fSlow19)));

  328. 	float 	fSlow30 = (fSlow28 - (fConst2 * (fSlow20 + fSlow26)));

  329. 	float 	fSlow31 = tonestack;

  330. 	float 	fSlow32 = ((fSlow31 == 23) / fSlow15);

  331. 	float 	fSlow33 = (1.0607618000000002e-05f * fSlow0);

  332. 	float 	fSlow34 = (3.1187760000000004e-05f + ((0.00032604000000000004f * fSlow2) + (fSlow0 * (((0.00011284700000000001f * fSlow2) - 1.9801382e-05f) - fSlow33))));

  333. 	float 	fSlow35 = ((3.5814000000000013e-09f * fSlow2) - (3.3665160000000007e-10f * fSlow0));

  334. 	float 	fSlow36 = (8.100000000000003e-09f * fSlow2);

  335. 	float 	fSlow37 = (7.614000000000002e-10f + (fSlow36 + (fSlow0 * (fSlow35 - 4.247484000000001e-10f))));

  336. 	float 	fSlow38 = (fConst1 * fSlow37);

  337. 	float 	fSlow39 = (0.00188f * fSlow0);

  338. 	float 	fSlow40 = (0.060025f * fSlow2);

  339. 	float 	fSlow41 = (fConst1 * (0.027267350000000003f + (fSlow40 + fSlow39)));

  340. 	float 	fSlow42 = ((fSlow41 + (fConst2 * (fSlow38 - fSlow34))) - 1);

  341. 	float 	fSlow43 = (fConst3 * fSlow37);

  342. 	float 	fSlow44 = ((fConst2 * (fSlow34 + fSlow43)) - (3 + fSlow41));

  343. 	float 	fSlow45 = ((fSlow41 + (fConst2 * (fSlow34 - fSlow43))) - 3);

  344. 	float 	fSlow46 = (0 - (1 + (fSlow41 + (fConst2 * (fSlow34 + fSlow38)))));

  345. 	float 	fSlow47 = (1.0f / fSlow46);

  346. 	float 	fSlow48 = ((fSlow0 * (3.3665160000000007e-10f + fSlow35)) + (fSlow17 * ((7.614000000000002e-10f - (7.614000000000002e-10f * fSlow0)) + fSlow36)));

  347. 	float 	fSlow49 = (fConst3 * fSlow48);

  348. 	float 	fSlow50 = (1.9176000000000002e-07f + (((5.400000000000001e-07f * fSlow17) + (fSlow0 * (1.0654618000000002e-05f - fSlow33))) + (fSlow2 * (2.0400000000000004e-06f + (0.00011284700000000001f * fSlow0)))));

  349. 	float 	fSlow51 = (2.5e-05f * fSlow17);

  350. 	float 	fSlow52 = (0.005642350000000001f + (fSlow40 + (fSlow39 + fSlow51)));

  351. 	float 	fSlow53 = (fConst1 * fSlow52);

  352. 	float 	fSlow54 = (fSlow53 + (fConst2 * (fSlow50 - fSlow49)));

  353. 	float 	fSlow55 = (fConst1 * fSlow48);

  354. 	float 	fSlow56 = (fSlow53 + (fConst2 * (fSlow55 - fSlow50)));

  355. 	float 	fSlow57 = (fConst1 * (0 - fSlow52));

  356. 	float 	fSlow58 = (fSlow57 + (fConst2 * (fSlow50 + fSlow49)));

  357. 	float 	fSlow59 = (fSlow57 - (fConst2 * (fSlow50 + fSlow55)));

  358. 	float 	fSlow60 = ((fSlow31 == 24) / fSlow46);

  359. 	float 	fSlow61 = (4.7117500000000004e-07f * fSlow0);

  360. 	float 	fSlow62 = (0.00011998125000000002f * fSlow2);

  361. 	float 	fSlow63 = (5.718000000000001e-06f + (fSlow62 + (fSlow0 * (((1.1779375000000001e-05f * fSlow2) - 4.199450000000001e-06f) - fSlow61))));

  362. 	float 	fSlow64 = ((1.0281250000000001e-09f * fSlow2) - (4.1125e-11f * fSlow0));

  363. 	float 	fSlow65 = (7.343750000000001e-09f * fSlow2);

  364. 	float 	fSlow66 = (2.9375e-10f + (fSlow65 + (fSlow0 * (fSlow64 - 2.52625e-10f))));

  365. 	float 	fSlow67 = (fConst1 * fSlow66);

  366. 	float 	fSlow68 = (0.00047000000000000004f * fSlow0);

  367. 	float 	fSlow69 = (fConst1 * (0.015765f + (fSlow9 + fSlow68)));

  368. 	float 	fSlow70 = ((fSlow69 + (fConst2 * (fSlow67 - fSlow63))) - 1);

  369. 	float 	fSlow71 = (fConst3 * fSlow66);

  370. 	float 	fSlow72 = ((fConst2 * (fSlow63 + fSlow71)) - (3 + fSlow69));

  371. 	float 	fSlow73 = ((fSlow69 + (fConst2 * (fSlow63 - fSlow71))) - 3);

  372. 	float 	fSlow74 = (0 - (1 + (fSlow69 + (fConst2 * (fSlow63 + fSlow67)))));

  373. 	float 	fSlow75 = (1.0f / fSlow74);

  374. 	float 	fSlow76 = ((fSlow0 * (4.1125e-11f + fSlow64)) + (fSlow17 * ((2.9375e-10f - (2.9375e-10f * fSlow0)) + fSlow65)));

  375. 	float 	fSlow77 = (fConst3 * fSlow76);

  376. 	float 	fSlow78 = (9.187500000000001e-07f * fSlow17);

  377. 	float 	fSlow79 = (9.925e-08f + ((fSlow78 + (fSlow0 * (5.0055e-07f - fSlow61))) + (fSlow2 * (2.48125e-06f + (1.1779375000000001e-05f * fSlow0)))));

  378. 	float 	fSlow80 = (0.0010025f + (fSlow9 + (fSlow21 + fSlow68)));

  379. 	float 	fSlow81 = (fConst1 * fSlow80);

  380. 	float 	fSlow82 = (fSlow81 + (fConst2 * (fSlow79 - fSlow77)));

  381. 	float 	fSlow83 = (fConst1 * fSlow76);

  382. 	float 	fSlow84 = (fSlow81 + (fConst2 * (fSlow83 - fSlow79)));

  383. 	float 	fSlow85 = (fConst1 * (0 - fSlow80));

  384. 	float 	fSlow86 = (fSlow85 + (fConst2 * (fSlow79 + fSlow77)));

  385. 	float 	fSlow87 = (fSlow85 - (fConst2 * (fSlow79 + fSlow83)));

  386. 	float 	fSlow88 = ((fSlow31 == 22) / fSlow74);

  387. 	float 	fSlow89 = (3.059375000000001e-07f * fSlow0);

  388. 	float 	fSlow90 = (1.5468750000000003e-06f + ((1.2718750000000003e-05f * fSlow2) + (fSlow0 * (((3.0593750000000007e-06f * fSlow2) - 8.696875000000003e-07f) - fSlow89))));

  389. 	float 	fSlow91 = ((2.646875e-10f * fSlow2) - (2.6468750000000002e-11f * fSlow0));

  390. 	float 	fSlow92 = (7.5625e-10f * fSlow2);

  391. 	float 	fSlow93 = (7.562500000000001e-11f + (fSlow92 + (fSlow0 * (fSlow91 - 4.915625000000001e-11f))));

  392. 	float 	fSlow94 = (fConst1 * fSlow93);

  393. 	float 	fSlow95 = (0.005562500000000001f * fSlow2);

  394. 	float 	fSlow96 = (fConst1 * (0.005018750000000001f + (fSlow8 + fSlow95)));

  395. 	float 	fSlow97 = ((fSlow96 + (fConst2 * (fSlow94 - fSlow90))) - 1);

  396. 	float 	fSlow98 = (fConst3 * fSlow93);

  397. 	float 	fSlow99 = ((fConst2 * (fSlow90 + fSlow98)) - (3 + fSlow96));

  398. 	float 	fSlow100 = ((fSlow96 + (fConst2 * (fSlow90 - fSlow98))) - 3);

  399. 	float 	fSlow101 = (0 - (1 + (fSlow96 + (fConst2 * (fSlow90 + fSlow94)))));

  400. 	float 	fSlow102 = (1.0f / fSlow101);

  401. 	float 	fSlow103 = ((fSlow0 * (2.6468750000000002e-11f + fSlow91)) + (fSlow17 * ((7.562500000000001e-11f - (7.562500000000001e-11f * fSlow0)) + fSlow92)));

  402. 	float 	fSlow104 = (fConst3 * fSlow103);

  403. 	float 	fSlow105 = (6.1875e-08f + (((2.75e-07f * fSlow17) + (fSlow0 * (3.403125000000001e-07f - fSlow89))) + (fSlow2 * (6.1875e-07f + (3.0593750000000007e-06f * fSlow0)))));

  404. 	float 	fSlow106 = (0.00055625f + (fSlow22 + fSlow95));

  405. 	float 	fSlow107 = (fConst1 * fSlow106);

  406. 	float 	fSlow108 = (fSlow107 + (fConst2 * (fSlow105 - fSlow104)));

  407. 	float 	fSlow109 = (fConst1 * fSlow103);

  408. 	float 	fSlow110 = (fSlow107 + (fConst2 * (fSlow109 - fSlow105)));

  409. 	float 	fSlow111 = (fConst1 * (0 - fSlow106));

  410. 	float 	fSlow112 = (fSlow111 + (fConst2 * (fSlow105 + fSlow104)));

  411. 	float 	fSlow113 = (fSlow111 - (fConst2 * (fSlow105 + fSlow109)));

  412. 	float 	fSlow114 = ((fSlow31 == 21) / fSlow101);

  413. 	float 	fSlow115 = (2.2193400000000003e-07f * fSlow0);

  414. 	float 	fSlow116 = (2.7073879999999998e-06f + ((4.9553415999999996e-05f * fSlow2) + (fSlow0 * (((4.882548000000001e-06f * fSlow2) - 1.964318e-06f) - fSlow115))));

  415. 	float 	fSlow117 = ((3.4212992000000004e-10f * fSlow2) - (1.5551360000000004e-11f * fSlow0));

  416. 	float 	fSlow118 = (2.3521432000000003e-09f * fSlow2);

  417. 	float 	fSlow119 = (1.0691560000000001e-10f + (fSlow118 + (fSlow0 * (fSlow117 - 9.136424e-11f))));

  418. 	float 	fSlow120 = (fConst1 * fSlow119);

  419. 	float 	fSlow121 = (0.0103884f * fSlow2);

  420. 	float 	fSlow122 = (fConst1 * (0.009920600000000002f + (fSlow68 + fSlow121)));

  421. 	float 	fSlow123 = ((fSlow122 + (fConst2 * (fSlow120 - fSlow116))) - 1);

  422. 	float 	fSlow124 = (fConst3 * fSlow119);

  423. 	float 	fSlow125 = ((fConst2 * (fSlow116 + fSlow124)) - (3 + fSlow122));

  424. 	float 	fSlow126 = ((fSlow122 + (fConst2 * (fSlow116 - fSlow124))) - 3);

  425. 	float 	fSlow127 = (0 - (1 + (fSlow122 + (fConst2 * (fSlow116 + fSlow120)))));

  426. 	float 	fSlow128 = (1.0f / fSlow127);

  427. 	float 	fSlow129 = ((fSlow0 * (1.5551360000000004e-11f + fSlow117)) + (fSlow17 * ((1.0691560000000001e-10f - (1.0691560000000001e-10f * fSlow0)) + fSlow118)));

  428. 	float 	fSlow130 = (fConst3 * fSlow129);

  429. 	float 	fSlow131 = (4.3428e-08f + (((4.5496e-07f * fSlow17) + (fSlow0 * (2.4468200000000005e-07f - fSlow115))) + (fSlow2 * (9.55416e-07f + (4.882548000000001e-06f * fSlow0)))));

  430. 	float 	fSlow132 = (0.00047220000000000004f + (fSlow121 + (fSlow68 + (4.84e-05f * fSlow17))));

  431. 	float 	fSlow133 = (fConst1 * fSlow132);

  432. 	float 	fSlow134 = (fSlow133 + (fConst2 * (fSlow131 - fSlow130)));

  433. 	float 	fSlow135 = (fConst1 * fSlow129);

  434. 	float 	fSlow136 = (fSlow133 + (fConst2 * (fSlow135 - fSlow131)));

  435. 	float 	fSlow137 = (fConst1 * (0 - fSlow132));

  436. 	float 	fSlow138 = (fSlow137 + (fConst2 * (fSlow131 + fSlow130)));

  437. 	float 	fSlow139 = (fSlow137 - (fConst2 * (fSlow131 + fSlow135)));

  438. 	float 	fSlow140 = ((fSlow31 == 20) / fSlow127);

  439. 	float 	fSlow141 = (2.3926056000000006e-07f * fSlow0);

  440. 	float 	fSlow142 = (1.0875480000000001e-05f * fSlow2);

  441. 	float 	fSlow143 = (1.1144196800000003e-06f + ((3.659304000000001e-05f * fSlow2) + (fSlow0 * ((fSlow142 - 4.347578400000001e-07f) - fSlow141))));

  442. 	float 	fSlow144 = ((1.4413132800000006e-09f * fSlow2) - (3.1708892160000014e-11f * fSlow0));

  443. 	float 	fSlow145 = (3.403100800000001e-09f * fSlow2);

  444. 	float 	fSlow146 = (7.486821760000003e-11f + (fSlow145 + (fSlow0 * (fSlow144 - 4.315932544000001e-11f))));

  445. 	float 	fSlow147 = (fConst1 * fSlow146);

  446. 	float 	fSlow148 = (0.00048400000000000006f * fSlow0);

  447. 	float 	fSlow149 = (0.022470000000000004f * fSlow2);

  448. 	float 	fSlow150 = (fSlow149 + fSlow148);

  449. 	float 	fSlow151 = (fConst1 * (0.00358974f + fSlow150));

  450. 	float 	fSlow152 = ((fSlow151 + (fConst2 * (fSlow147 - fSlow143))) - 1);

  451. 	float 	fSlow153 = (fConst3 * fSlow146);

  452. 	float 	fSlow154 = ((fConst2 * (fSlow143 + fSlow153)) - (3 + fSlow151));

  453. 	float 	fSlow155 = ((fSlow151 + (fConst2 * (fSlow143 - fSlow153))) - 3);

  454. 	float 	fSlow156 = (0 - (1 + (fSlow151 + (fConst2 * (fSlow143 + fSlow147)))));

  455. 	float 	fSlow157 = (1.0f / fSlow156);

  456. 	float 	fSlow158 = ((fSlow0 * (3.1708892160000014e-11f + fSlow144)) + (fSlow17 * ((7.486821760000003e-11f - (7.486821760000003e-11f * fSlow0)) + fSlow145)));

  457. 	float 	fSlow159 = (fConst3 * fSlow158);

  458. 	float 	fSlow160 = (1.0875480000000001e-05f * fSlow0);

  459. 	float 	fSlow161 = (fSlow0 * (2.893061600000001e-07f - fSlow141));

  460. 	float 	fSlow162 = (8.098288000000002e-08f + (((3.0937280000000007e-07f * fSlow17) + fSlow161) + (fSlow2 * (3.6810400000000007e-06f + fSlow160))));

  461. 	float 	fSlow163 = (0.00049434f + (fSlow149 + (fSlow148 + (0.0001034f * fSlow17))));

  462. 	float 	fSlow164 = (fConst1 * fSlow163);

  463. 	float 	fSlow165 = (fSlow164 + (fConst2 * (fSlow162 - fSlow159)));

  464. 	float 	fSlow166 = (fConst1 * fSlow158);

  465. 	float 	fSlow167 = (fSlow164 + (fConst2 * (fSlow166 - fSlow162)));

  466. 	float 	fSlow168 = (fConst1 * (0 - fSlow163));

  467. 	float 	fSlow169 = (fSlow168 + (fConst2 * (fSlow162 + fSlow159)));

  468. 	float 	fSlow170 = (fSlow168 - (fConst2 * (fSlow162 + fSlow166)));

  469. 	float 	fSlow171 = ((fSlow31 == 19) / fSlow156);

  470. 	float 	fSlow172 = (7.790052600000002e-07f * fSlow0);

  471. 	float 	fSlow173 = (1.4106061200000003e-06f + ((3.7475640000000014e-05f * fSlow2) + (fSlow0 * (((2.3606220000000006e-05f * fSlow2) - 3.2220474e-07f) - fSlow172))));

  472. 	float 	fSlow174 = ((1.5406083e-09f * fSlow2) - (5.08400739e-11f * fSlow0));

  473. 	float 	fSlow175 = (1.9775250000000004e-09f * fSlow2);

  474. 	float 	fSlow176 = (6.5258325e-11f + (fSlow175 + (fSlow0 * (fSlow174 - 1.4418251099999996e-11f))));

  475. 	float 	fSlow177 = (fConst1 * fSlow176);

  476. 	float 	fSlow178 = (0.001551f * fSlow0);

  477. 	float 	fSlow179 = (0.015220000000000001f * fSlow2);

  478. 	float 	fSlow180 = (fConst1 * (0.0037192600000000003f + (fSlow179 + fSlow178)));

  479. 	float 	fSlow181 = ((fSlow180 + (fConst2 * (fSlow177 - fSlow173))) - 1);

  480. 	float 	fSlow182 = (fConst3 * fSlow176);

  481. 	float 	fSlow183 = ((fConst2 * (fSlow173 + fSlow182)) - (3 + fSlow180));

  482. 	float 	fSlow184 = ((fSlow180 + (fConst2 * (fSlow173 - fSlow182))) - 3);

  483. 	float 	fSlow185 = (0 - (1 + (fSlow180 + (fConst2 * (fSlow173 + fSlow177)))));

  484. 	float 	fSlow186 = (1.0f / fSlow185);

  485. 	float 	fSlow187 = ((fSlow0 * (5.08400739e-11f + fSlow174)) + (fSlow17 * ((6.5258325e-11f - (6.5258325e-11f * fSlow0)) + fSlow175)));

  486. 	float 	fSlow188 = (fConst3 * fSlow187);

  487. 	float 	fSlow189 = (5.018112e-08f + (((1.7391e-07f * fSlow17) + (fSlow0 * (8.643102600000002e-07f - fSlow172))) + (fSlow2 * (1.5206400000000001e-06f + (2.3606220000000006e-05f * fSlow0)))));

  488. 	float 	fSlow190 = (0.0005022600000000001f + (fSlow179 + (fSlow178 + (5.4999999999999995e-05f * fSlow17))));

  489. 	float 	fSlow191 = (fConst1 * fSlow190);

  490. 	float 	fSlow192 = (fSlow191 + (fConst2 * (fSlow189 - fSlow188)));

  491. 	float 	fSlow193 = (fConst1 * fSlow187);

  492. 	float 	fSlow194 = (fSlow191 + (fConst2 * (fSlow193 - fSlow189)));

  493. 	float 	fSlow195 = (fConst1 * (0 - fSlow190));

  494. 	float 	fSlow196 = (fSlow195 + (fConst2 * (fSlow189 + fSlow188)));

  495. 	float 	fSlow197 = (fSlow195 - (fConst2 * (fSlow189 + fSlow193)));

  496. 	float 	fSlow198 = ((fSlow31 == 18) / fSlow185);

  497. 	float 	fSlow199 = (4.7047000000000006e-07f * fSlow0);

  498. 	float 	fSlow200 = (5.107200000000001e-06f + ((0.00011849250000000002f * fSlow2) + (fSlow0 * (((1.1761750000000001e-05f * fSlow2) - 4.217780000000001e-06f) - fSlow199))));

  499. 	float 	fSlow201 = ((4.1125e-10f * fSlow2) - (1.645e-11f * fSlow0));

  500. 	float 	fSlow202 = (2.9375000000000002e-09f * fSlow2);

  501. 	float 	fSlow203 = (1.175e-10f + (fSlow202 + (fSlow0 * (fSlow201 - 1.0105e-10f))));

  502. 	float 	fSlow204 = (fConst1 * fSlow203);

  503. 	float 	fSlow205 = (0.025025000000000002f * fSlow2);

  504. 	float 	fSlow206 = (fConst1 * (0.015726f + (fSlow68 + fSlow205)));

  505. 	float 	fSlow207 = ((fSlow206 + (fConst2 * (fSlow204 - fSlow200))) - 1);

  506. 	float 	fSlow208 = (fConst3 * fSlow203);

  507. 	float 	fSlow209 = ((fConst2 * (fSlow200 + fSlow208)) - (3 + fSlow206));

  508. 	float 	fSlow210 = ((fSlow206 + (fConst2 * (fSlow200 - fSlow208))) - 3);

  509. 	float 	fSlow211 = (0 - (1 + (fSlow206 + (fConst2 * (fSlow200 + fSlow204)))));

  510. 	float 	fSlow212 = (1.0f / fSlow211);

  511. 	float 	fSlow213 = ((fSlow0 * (1.645e-11f + fSlow201)) + (fSlow17 * ((1.175e-10f - (1.175e-10f * fSlow0)) + fSlow202)));

  512. 	float 	fSlow214 = (fConst3 * fSlow213);

  513. 	float 	fSlow215 = (3.9700000000000005e-08f + (((3.675000000000001e-07f * fSlow17) + (fSlow0 * (4.8222e-07f - fSlow199))) + (fSlow2 * (9.925e-07f + (1.1761750000000001e-05f * fSlow0)))));

  514. 	float 	fSlow216 = (0.001001f + (fSlow205 + (fSlow51 + fSlow68)));

  515. 	float 	fSlow217 = (fConst1 * fSlow216);

  516. 	float 	fSlow218 = (fSlow217 + (fConst2 * (fSlow215 - fSlow214)));

  517. 	float 	fSlow219 = (fConst1 * fSlow213);

  518. 	float 	fSlow220 = (fSlow217 + (fConst2 * (fSlow219 - fSlow215)));

  519. 	float 	fSlow221 = (fConst1 * (0 - fSlow216));

  520. 	float 	fSlow222 = (fSlow221 + (fConst2 * (fSlow215 + fSlow214)));

  521. 	float 	fSlow223 = (fSlow221 - (fConst2 * (fSlow215 + fSlow219)));

  522. 	float 	fSlow224 = ((fSlow31 == 17) / fSlow211);

  523. 	float 	fSlow225 = (3.0896250000000005e-07f * fSlow0);

  524. 	float 	fSlow226 = (6.338090000000001e-07f + ((1.8734760000000003e-05f * fSlow2) + (fSlow0 * (((1.2358500000000002e-05f * fSlow2) - 1.361249999999999e-08f) - fSlow225))));

  525. 	float 	fSlow227 = ((1.6037340000000005e-09f * fSlow2) - (4.0093350000000015e-11f * fSlow0));

  526. 	float 	fSlow228 = (1.8198400000000004e-09f * fSlow2);

  527. 	float 	fSlow229 = (4.5496000000000015e-11f + (fSlow228 + (fSlow0 * (fSlow227 - 5.40265e-12f))));

  528. 	float 	fSlow230 = (fConst1 * fSlow229);

  529. 	float 	fSlow231 = (fConst1 * (0.00208725f + (fSlow8 + fSlow149)));

  530. 	float 	fSlow232 = ((fSlow231 + (fConst2 * (fSlow230 - fSlow226))) - 1);

  531. 	float 	fSlow233 = (fConst3 * fSlow229);

  532. 	float 	fSlow234 = ((fConst2 * (fSlow226 + fSlow233)) - (3 + fSlow231));

  533. 	float 	fSlow235 = ((fSlow231 + (fConst2 * (fSlow226 - fSlow233))) - 3);

  534. 	float 	fSlow236 = (0 - (1 + (fSlow231 + (fConst2 * (fSlow226 + fSlow230)))));

  535. 	float 	fSlow237 = (1.0f / fSlow236);

  536. 	float 	fSlow238 = ((fSlow0 * (4.0093350000000015e-11f + fSlow227)) + (fSlow17 * ((4.5496000000000015e-11f - (4.5496000000000015e-11f * fSlow0)) + fSlow228)));

  537. 	float 	fSlow239 = (fConst3 * fSlow238);

  538. 	float 	fSlow240 = (8.1169e-08f + (((1.6544000000000003e-07f * fSlow17) + (fSlow0 * (3.735875000000001e-07f - fSlow225))) + (fSlow2 * (3.24676e-06f + (1.2358500000000002e-05f * fSlow0)))));

  539. 	float 	fSlow241 = (0.00011750000000000001f * fSlow17);

  540. 	float 	fSlow242 = (0.0005617500000000001f + (fSlow149 + (fSlow8 + fSlow241)));

  541. 	float 	fSlow243 = (fConst1 * fSlow242);

  542. 	float 	fSlow244 = (fSlow243 + (fConst2 * (fSlow240 - fSlow239)));

  543. 	float 	fSlow245 = (fConst1 * fSlow238);

  544. 	float 	fSlow246 = (fSlow243 + (fConst2 * (fSlow245 - fSlow240)));

  545. 	float 	fSlow247 = (fConst1 * (0 - fSlow242));

  546. 	float 	fSlow248 = (fSlow247 + (fConst2 * (fSlow240 + fSlow239)));

  547. 	float 	fSlow249 = (fSlow247 - (fConst2 * (fSlow240 + fSlow245)));

  548. 	float 	fSlow250 = ((fSlow31 == 16) / fSlow236);

  549. 	float 	fSlow251 = (2.7256800000000006e-07f * fSlow0);

  550. 	float 	fSlow252 = (1.4234760000000002e-06f + ((2.851440000000001e-05f * fSlow2) + (fSlow0 * (((6.8142000000000025e-06f * fSlow2) - 7.876920000000001e-07f) - fSlow251))));

  551. 	float 	fSlow253 = ((4.724676000000001e-10f * fSlow2) - (1.8898704000000002e-11f * fSlow0));

  552. 	float 	fSlow254 = (1.6641900000000002e-09f * fSlow2);

  553. 	float 	fSlow255 = (6.656760000000001e-11f + (fSlow254 + (fSlow0 * (fSlow253 - 4.7668896000000004e-11f))));

  554. 	float 	fSlow256 = (fConst1 * fSlow255);

  555. 	float 	fSlow257 = (0.0008200000000000001f * fSlow0);

  556. 	float 	fSlow258 = (0.00831f * fSlow2);

  557. 	float 	fSlow259 = (fConst1 * (0.005107400000000001f + (fSlow258 + fSlow257)));

  558. 	float 	fSlow260 = ((fSlow259 + (fConst2 * (fSlow256 - fSlow252))) - 1);

  559. 	float 	fSlow261 = (fConst3 * fSlow255);

  560. 	float 	fSlow262 = ((fConst2 * (fSlow252 + fSlow261)) - (3 + fSlow259));

  561. 	float 	fSlow263 = ((fSlow259 + (fConst2 * (fSlow252 - fSlow261))) - 3);

  562. 	float 	fSlow264 = (0 - (1 + (fSlow259 + (fConst2 * (fSlow252 + fSlow256)))));

  563. 	float 	fSlow265 = (1.0f / fSlow264);

  564. 	float 	fSlow266 = ((fSlow0 * (1.8898704000000002e-11f + fSlow253)) + (fSlow17 * ((6.656760000000001e-11f - (6.656760000000001e-11f * fSlow0)) + fSlow254)));

  565. 	float 	fSlow267 = (fConst3 * fSlow266);

  566. 	float 	fSlow268 = (3.1116000000000005e-08f + (((2.829e-07f * fSlow17) + (fSlow0 * (3.2176800000000005e-07f - fSlow251))) + (fSlow2 * (7.779000000000002e-07f + (6.8142000000000025e-06f * fSlow0)))));

  567. 	float 	fSlow269 = (0.00033240000000000006f + (fSlow258 + (fSlow257 + (6e-05f * fSlow17))));

  568. 	float 	fSlow270 = (fConst1 * fSlow269);

  569. 	float 	fSlow271 = (fSlow270 + (fConst2 * (fSlow268 - fSlow267)));

  570. 	float 	fSlow272 = (fConst1 * fSlow266);

  571. 	float 	fSlow273 = (fSlow270 + (fConst2 * (fSlow272 - fSlow268)));

  572. 	float 	fSlow274 = (fConst1 * (0 - fSlow269));

  573. 	float 	fSlow275 = (fSlow274 + (fConst2 * (fSlow268 + fSlow267)));

  574. 	float 	fSlow276 = (fSlow274 - (fConst2 * (fSlow268 + fSlow272)));

  575. 	float 	fSlow277 = ((fSlow31 == 15) / fSlow264);

  576. 	float 	fSlow278 = (4.0108000000000004e-07f * fSlow0);

  577. 	float 	fSlow279 = (5.050300000000001e-06f + ((0.00010263250000000001f * fSlow2) + (fSlow0 * (((1.0027e-05f * fSlow2) - 3.5719200000000006e-06f) - fSlow278))));

  578. 	float 	fSlow280 = ((9.45e-10f * fSlow2) - (3.78e-11f * fSlow0));

  579. 	float 	fSlow281 = (6.75e-09f * fSlow2);

  580. 	float 	fSlow282 = (2.7e-10f + (fSlow281 + (fSlow0 * (fSlow280 - 2.3219999999999998e-10f))));

  581. 	float 	fSlow283 = (fConst1 * fSlow282);

  582. 	float 	fSlow284 = (0.0004f * fSlow0);

  583. 	float 	fSlow285 = (0.025067500000000003f * fSlow2);

  584. 	float 	fSlow286 = (fConst1 * (0.0150702f + (fSlow285 + fSlow284)));

  585. 	float 	fSlow287 = ((fSlow286 + (fConst2 * (fSlow283 - fSlow279))) - 1);

  586. 	float 	fSlow288 = (fConst3 * fSlow282);

  587. 	float 	fSlow289 = ((fConst2 * (fSlow279 + fSlow288)) - (3 + fSlow286));

  588. 	float 	fSlow290 = ((fSlow286 + (fConst2 * (fSlow279 - fSlow288))) - 3);

  589. 	float 	fSlow291 = (0 - (1 + (fSlow286 + (fConst2 * (fSlow279 + fSlow283)))));

  590. 	float 	fSlow292 = (1.0f / fSlow291);

  591. 	float 	fSlow293 = ((fSlow0 * (3.78e-11f + fSlow280)) + (fSlow17 * ((2.7e-10f - (2.7e-10f * fSlow0)) + fSlow281)));

  592. 	float 	fSlow294 = (fConst3 * fSlow293);

  593. 	float 	fSlow295 = (1.0530000000000001e-07f + (((9.45e-07f * fSlow17) + (fSlow0 * (4.2808000000000006e-07f - fSlow278))) + (fSlow2 * (2.6324999999999998e-06f + (1.0027e-05f * fSlow0)))));

  594. 	float 	fSlow296 = (6.75e-05f * fSlow17);

  595. 	float 	fSlow297 = (0.0010027f + (fSlow285 + (fSlow284 + fSlow296)));

  596. 	float 	fSlow298 = (fConst1 * fSlow297);

  597. 	float 	fSlow299 = (fSlow298 + (fConst2 * (fSlow295 - fSlow294)));

  598. 	float 	fSlow300 = (fConst1 * fSlow293);

  599. 	float 	fSlow301 = (fSlow298 + (fConst2 * (fSlow300 - fSlow295)));

  600. 	float 	fSlow302 = (fConst1 * (0 - fSlow297));

  601. 	float 	fSlow303 = (fSlow302 + (fConst2 * (fSlow295 + fSlow294)));

  602. 	float 	fSlow304 = (fSlow302 - (fConst2 * (fSlow295 + fSlow300)));

  603. 	float 	fSlow305 = ((fSlow31 == 14) / fSlow291);

  604. 	float 	fSlow306 = (1.95976e-07f * fSlow0);

  605. 	float 	fSlow307 = (9.060568000000001e-07f + ((8.801210000000002e-06f * fSlow2) + (fSlow0 * (((2.4497000000000004e-06f * fSlow2) - 4.3256399999999996e-07f) - fSlow306))));

  606. 	float 	fSlow308 = ((2.0778120000000008e-10f * fSlow2) - (1.6622496000000003e-11f * fSlow0));

  607. 	float 	fSlow309 = (5.553900000000002e-10f * fSlow2);

  608. 	float 	fSlow310 = (4.4431200000000016e-11f + (fSlow309 + (fSlow0 * (fSlow308 - 2.7808704000000013e-11f))));

  609. 	float 	fSlow311 = (fConst1 * fSlow310);

  610. 	float 	fSlow312 = (0.00044f * fSlow0);

  611. 	float 	fSlow313 = (0.0055675f * fSlow2);

  612. 	float 	fSlow314 = (fConst1 * (0.0035049f + (fSlow313 + fSlow312)));

  613. 	float 	fSlow315 = ((fSlow314 + (fConst2 * (fSlow311 - fSlow307))) - 1);

  614. 	float 	fSlow316 = (fConst3 * fSlow310);

  615. 	float 	fSlow317 = ((fConst2 * (fSlow307 + fSlow316)) - (3 + fSlow314));

  616. 	float 	fSlow318 = ((fSlow314 + (fConst2 * (fSlow307 - fSlow316))) - 3);

  617. 	float 	fSlow319 = (0 - (1 + (fSlow314 + (fConst2 * (fSlow307 + fSlow311)))));

  618. 	float 	fSlow320 = (1.0f / fSlow319);

  619. 	float 	fSlow321 = ((fSlow0 * (1.6622496000000003e-11f + fSlow308)) + (fSlow17 * ((4.4431200000000016e-11f - (4.4431200000000016e-11f * fSlow0)) + fSlow309)));

  620. 	float 	fSlow322 = (fConst3 * fSlow321);

  621. 	float 	fSlow323 = (4.585680000000001e-08f + (((2.0196000000000004e-07f * fSlow17) + (fSlow0 * (2.2567600000000002e-07f - fSlow306))) + (fSlow2 * (5.732100000000001e-07f + (2.4497000000000004e-06f * fSlow0)))));

  622. 	float 	fSlow324 = (0.00044540000000000004f + (fSlow313 + (fSlow296 + fSlow312)));

  623. 	float 	fSlow325 = (fConst1 * fSlow324);

  624. 	float 	fSlow326 = (fSlow325 + (fConst2 * (fSlow323 - fSlow322)));

  625. 	float 	fSlow327 = (fConst1 * fSlow321);

  626. 	float 	fSlow328 = (fSlow325 + (fConst2 * (fSlow327 - fSlow323)));

  627. 	float 	fSlow329 = (fConst1 * (0 - fSlow324));

  628. 	float 	fSlow330 = (fSlow329 + (fConst2 * (fSlow323 + fSlow322)));

  629. 	float 	fSlow331 = (fSlow329 - (fConst2 * (fSlow323 + fSlow327)));

  630. 	float 	fSlow332 = ((fSlow31 == 13) / fSlow319);

  631. 	float 	fSlow333 = (4.9434000000000004e-08f * fSlow0);

  632. 	float 	fSlow334 = (7.748796000000001e-07f + ((2.8889960000000004e-05f * fSlow2) + (fSlow0 * (((4.943400000000001e-06f * fSlow2) - 1.2634599999999999e-07f) - fSlow333))));

  633. 	float 	fSlow335 = ((1.2443156000000004e-09f * fSlow2) - (1.2443156000000002e-11f * fSlow0));

  634. 	float 	fSlow336 = (5.345780000000001e-09f * fSlow2);

  635. 	float 	fSlow337 = (5.345780000000001e-11f + (fSlow336 + (fSlow0 * (fSlow335 - 4.101464400000001e-11f))));

  636. 	float 	fSlow338 = (fConst1 * fSlow337);

  637. 	float 	fSlow339 = (0.00022f * fSlow0);

  638. 	float 	fSlow340 = (fConst1 * (0.0025277f + (fSlow149 + fSlow339)));

  639. 	float 	fSlow341 = ((fSlow340 + (fConst2 * (fSlow338 - fSlow334))) - 1);

  640. 	float 	fSlow342 = (fConst3 * fSlow337);

  641. 	float 	fSlow343 = ((fConst2 * (fSlow334 + fSlow342)) - (3 + fSlow340));

  642. 	float 	fSlow344 = ((fSlow340 + (fConst2 * (fSlow334 - fSlow342))) - 3);

  643. 	float 	fSlow345 = (0 - (1 + (fSlow340 + (fConst2 * (fSlow334 + fSlow338)))));

  644. 	float 	fSlow346 = (1.0f / fSlow345);

  645. 	float 	fSlow347 = ((fSlow0 * (1.2443156000000002e-11f + fSlow335)) + (fSlow17 * ((5.345780000000001e-11f - (5.345780000000001e-11f * fSlow0)) + fSlow336)));

  646. 	float 	fSlow348 = (fConst3 * fSlow347);

  647. 	float 	fSlow349 = (6.141960000000001e-08f + (((4.859800000000001e-07f * fSlow17) + (fSlow0 * (1.0113400000000001e-07f - fSlow333))) + (fSlow2 * (6.141960000000001e-06f + (4.943400000000001e-06f * fSlow0)))));

  648. 	float 	fSlow350 = (0.00022470000000000001f + (fSlow149 + (fSlow339 + (0.00023500000000000002f * fSlow17))));

  649. 	float 	fSlow351 = (fConst1 * fSlow350);

  650. 	float 	fSlow352 = (fSlow351 + (fConst2 * (fSlow349 - fSlow348)));

  651. 	float 	fSlow353 = (fConst1 * fSlow347);

  652. 	float 	fSlow354 = (fSlow351 + (fConst2 * (fSlow353 - fSlow349)));

  653. 	float 	fSlow355 = (fConst1 * (0 - fSlow350));

  654. 	float 	fSlow356 = (fSlow355 + (fConst2 * (fSlow349 + fSlow348)));

  655. 	float 	fSlow357 = (fSlow355 - (fConst2 * (fSlow349 + fSlow353)));

  656. 	float 	fSlow358 = ((fSlow31 == 12) / fSlow345);

  657. 	float 	fSlow359 = (2.5587500000000006e-07f * fSlow0);

  658. 	float 	fSlow360 = (7.717400000000001e-07f + ((2.2033600000000005e-05f * fSlow2) + (fSlow0 * (((1.0235000000000001e-05f * fSlow2) - 1.5537499999999997e-07f) - fSlow359))));

  659. 	float 	fSlow361 = ((1.3959000000000001e-09f * fSlow2) - (3.48975e-11f * fSlow0));

  660. 	float 	fSlow362 = (2.2090000000000005e-09f * fSlow2);

  661. 	float 	fSlow363 = (5.522500000000001e-11f + (fSlow362 + (fSlow0 * (fSlow361 - 2.0327500000000007e-11f))));

  662. 	float 	fSlow364 = (fConst1 * fSlow363);

  663. 	float 	fSlow365 = (0.0005f * fSlow0);

  664. 	float 	fSlow366 = (0.020470000000000002f * fSlow2);

  665. 	float 	fSlow367 = (fConst1 * (0.0025092499999999998f + (fSlow366 + fSlow365)));

  666. 	float 	fSlow368 = ((fSlow367 + (fConst2 * (fSlow364 - fSlow360))) - 1);

  667. 	float 	fSlow369 = (fConst3 * fSlow363);

  668. 	float 	fSlow370 = ((fConst2 * (fSlow360 + fSlow369)) - (3 + fSlow367));

  669. 	float 	fSlow371 = ((fSlow367 + (fConst2 * (fSlow360 - fSlow369))) - 3);

  670. 	float 	fSlow372 = (0 - (1 + (fSlow367 + (fConst2 * (fSlow360 + fSlow364)))));

  671. 	float 	fSlow373 = (1.0f / fSlow372);

  672. 	float 	fSlow374 = ((fSlow0 * (3.48975e-11f + fSlow361)) + (fSlow17 * ((5.522500000000001e-11f - (5.522500000000001e-11f * fSlow0)) + fSlow362)));

  673. 	float 	fSlow375 = (fConst3 * fSlow374);

  674. 	float 	fSlow376 = (8.084000000000001e-08f + (((2.2090000000000003e-07f * fSlow17) + (fSlow0 * (3.146250000000001e-07f - fSlow359))) + (fSlow2 * (3.2336000000000007e-06f + (1.0235000000000001e-05f * fSlow0)))));

  675. 	float 	fSlow377 = (0.00051175f + (fSlow366 + (fSlow241 + fSlow365)));

  676. 	float 	fSlow378 = (fConst1 * fSlow377);

  677. 	float 	fSlow379 = (fSlow378 + (fConst2 * (fSlow376 - fSlow375)));

  678. 	float 	fSlow380 = (fConst1 * fSlow374);

  679. 	float 	fSlow381 = (fSlow378 + (fConst2 * (fSlow380 - fSlow376)));

  680. 	float 	fSlow382 = (fConst1 * (0 - fSlow377));

  681. 	float 	fSlow383 = (fSlow382 + (fConst2 * (fSlow376 + fSlow375)));

  682. 	float 	fSlow384 = (fSlow382 - (fConst2 * (fSlow376 + fSlow380)));

  683. 	float 	fSlow385 = ((fSlow31 == 11) / fSlow372);

  684. 	float 	fSlow386 = (0.00022854915600000004f * fSlow0);

  685. 	float 	fSlow387 = (0.00010871476000000002f + ((0.00010719478000000002f * fSlow2) + (fSlow0 * ((0.00012621831200000002f + (0.00022854915600000004f * fSlow2)) - fSlow386))));

  686. 	float 	fSlow388 = ((3.421299200000001e-08f * fSlow2) - (3.421299200000001e-08f * fSlow0));

  687. 	float 	fSlow389 = (1.0f + (fSlow2 + (93531720.34763868f * (fSlow0 * (2.3521432000000005e-08f + fSlow388)))));

  688. 	float 	fSlow390 = (fConst4 * fSlow389);

  689. 	float 	fSlow391 = (fConst1 * (0.036906800000000003f + ((0.022103400000000002f * fSlow2) + (0.01034f * fSlow0))));

  690. 	float 	fSlow392 = ((fSlow391 + (fConst2 * (fSlow390 - fSlow387))) - 1);

  691. 	float 	fSlow393 = (fConst5 * fSlow389);

  692. 	float 	fSlow394 = ((fConst2 * (fSlow387 + fSlow393)) - (3 + fSlow391));

  693. 	float 	fSlow395 = ((fSlow391 + (fConst2 * (fSlow387 - fSlow393))) - 3);

  694. 	float 	fSlow396 = ((fConst2 * (0 - (fSlow387 + fSlow390))) - (1 + fSlow391));

  695. 	float 	fSlow397 = (1.0f / fSlow396);

  696. 	float 	fSlow398 = ((fSlow0 * (3.421299200000001e-08f + fSlow388)) + (fSlow17 * ((1.0691560000000003e-08f - (1.0691560000000003e-08f * fSlow0)) + (1.0691560000000003e-08f * fSlow2))));

  697. 	float 	fSlow399 = (fConst3 * fSlow398);

  698. 	float 	fSlow400 = (3.7947800000000004e-06f + (((1.5199800000000001e-06f * fSlow17) + (fSlow0 * (0.00022961831200000004f - fSlow386))) + (fSlow2 * (3.7947800000000004e-06f + fSlow386))));

  699. 	float 	fSlow401 = (1.0f + (fSlow2 + ((0.0046780133373146215f * fSlow17) + (0.4678013337314621f * fSlow0))));

  700. 	float 	fSlow402 = (fConst6 * fSlow401);

  701. 	float 	fSlow403 = (fSlow402 + (fConst2 * (fSlow400 - fSlow399)));

  702. 	float 	fSlow404 = (fConst1 * fSlow398);

  703. 	float 	fSlow405 = (fSlow402 + (fConst2 * (fSlow404 - fSlow400)));

  704. 	float 	fSlow406 = (fConst1 * (0 - (0.022103400000000002f * fSlow401)));

  705. 	float 	fSlow407 = (fSlow406 + (fConst2 * (fSlow400 + fSlow399)));

  706. 	float 	fSlow408 = (fSlow406 - (fConst2 * (fSlow400 + fSlow404)));

  707. 	float 	fSlow409 = ((fSlow31 == 10) / fSlow396);

  708. 	float 	fSlow410 = (4.851e-08f * fSlow0);

  709. 	float 	fSlow411 = (7.172000000000001e-07f + ((4.972000000000001e-05f * fSlow2) + (fSlow0 * (((4.8510000000000015e-06f * fSlow2) - 4.2449000000000006e-07f) - fSlow410))));

  710. 	float 	fSlow412 = ((2.6620000000000007e-10f * fSlow2) - (2.662e-12f * fSlow0));

  711. 	float 	fSlow413 = (2.4200000000000003e-09f * fSlow2);

  712. 	float 	fSlow414 = (2.4200000000000004e-11f + (fSlow413 + (fSlow0 * (fSlow412 - 2.1538000000000003e-11f))));

  713. 	float 	fSlow415 = (fConst1 * fSlow414);

  714. 	float 	fSlow416 = (0.022050000000000004f * fSlow2);

  715. 	float 	fSlow417 = (fConst1 * (0.0046705f + (fSlow339 + fSlow416)));

  716. 	float 	fSlow418 = ((fSlow417 + (fConst2 * (fSlow415 - fSlow411))) - 1);

  717. 	float 	fSlow419 = (fConst3 * fSlow414);

  718. 	float 	fSlow420 = ((fConst2 * (fSlow411 + fSlow419)) - (3 + fSlow417));

  719. 	float 	fSlow421 = ((fSlow417 + (fConst2 * (fSlow411 - fSlow419))) - 3);

  720. 	float 	fSlow422 = (0 - (1 + (fSlow417 + (fConst2 * (fSlow411 + fSlow415)))));

  721. 	float 	fSlow423 = (1.0f / fSlow422);

  722. 	float 	fSlow424 = ((fSlow0 * (2.662e-12f + fSlow412)) + (fSlow17 * ((2.4200000000000004e-11f - (2.4200000000000004e-11f * fSlow0)) + fSlow413)));

  723. 	float 	fSlow425 = (fConst3 * fSlow424);

  724. 	float 	fSlow426 = (1.32e-08f + (((2.2000000000000004e-07f * fSlow17) + (fSlow0 * (5.951000000000001e-08f - fSlow410))) + (fSlow2 * (1.32e-06f + (4.8510000000000015e-06f * fSlow0)))));

  725. 	float 	fSlow427 = (0.00022050000000000002f + (fSlow416 + (fSlow339 + (5e-05f * fSlow17))));

  726. 	float 	fSlow428 = (fConst1 * fSlow427);

  727. 	float 	fSlow429 = (fSlow428 + (fConst2 * (fSlow426 - fSlow425)));

  728. 	float 	fSlow430 = (fConst1 * fSlow424);

  729. 	float 	fSlow431 = (fSlow428 + (fConst2 * (fSlow430 - fSlow426)));

  730. 	float 	fSlow432 = (fConst1 * (0 - fSlow427));

  731. 	float 	fSlow433 = (fSlow432 + (fConst2 * (fSlow426 + fSlow425)));

  732. 	float 	fSlow434 = (fSlow432 - (fConst2 * (fSlow426 + fSlow430)));

  733. 	float 	fSlow435 = ((fSlow31 == 9) / fSlow422);

  734. 	float 	fSlow436 = (1.38796875e-06f * fSlow0);

  735. 	float 	fSlow437 = (3.5279375000000002e-06f + ((3.1989375e-05f * fSlow2) + (fSlow0 * (((1.38796875e-05f * fSlow2) - 1.6311937500000001e-06f) - fSlow436))));

  736. 	float 	fSlow438 = ((1.0561781250000004e-09f * fSlow2) - (1.0561781250000003e-10f * fSlow0));

  737. 	float 	fSlow439 = (1.9328750000000005e-09f * fSlow2);

  738. 	float 	fSlow440 = (1.9328750000000007e-10f + (fSlow439 + (fSlow0 * (fSlow438 - 8.766968750000004e-11f))));

  739. 	float 	fSlow441 = (fConst1 * fSlow440);

  740. 	float 	fSlow442 = (0.001175f * fSlow0);

  741. 	float 	fSlow443 = (0.011812500000000002f * fSlow2);

  742. 	float 	fSlow444 = (fConst1 * (0.0065077500000000005f + (fSlow443 + fSlow442)));

  743. 	float 	fSlow445 = ((fSlow444 + (fConst2 * (fSlow441 - fSlow437))) - 1);

  744. 	float 	fSlow446 = (fConst3 * fSlow440);

  745. 	float 	fSlow447 = ((fConst2 * (fSlow437 + fSlow446)) - (3 + fSlow444));

  746. 	float 	fSlow448 = ((fSlow444 + (fConst2 * (fSlow437 - fSlow446))) - 3);

  747. 	float 	fSlow449 = (0 - (1 + (fSlow444 + (fConst2 * (fSlow437 + fSlow441)))));

  748. 	float 	fSlow450 = (1.0f / fSlow449);

  749. 	float 	fSlow451 = ((fSlow0 * (1.0561781250000003e-10f + fSlow438)) + (fSlow17 * ((1.9328750000000007e-10f - (1.9328750000000007e-10f * fSlow0)) + fSlow439)));

  750. 	float 	fSlow452 = (fConst3 * fSlow451);

  751. 	float 	fSlow453 = (1.0633750000000002e-07f + (((3.2900000000000005e-07f * fSlow17) + (fSlow0 * (1.4614062500000001e-06f - fSlow436))) + (fSlow2 * (1.0633750000000002e-06f + (1.38796875e-05f * fSlow0)))));

  752. 	float 	fSlow454 = (fSlow21 + fSlow442);

  753. 	float 	fSlow455 = (0.00118125f + (fSlow443 + fSlow454));

  754. 	float 	fSlow456 = (fConst1 * fSlow455);

  755. 	float 	fSlow457 = (fSlow456 + (fConst2 * (fSlow453 - fSlow452)));

  756. 	float 	fSlow458 = (fConst1 * fSlow451);

  757. 	float 	fSlow459 = (fSlow456 + (fConst2 * (fSlow458 - fSlow453)));

  758. 	float 	fSlow460 = (fConst1 * (0 - fSlow455));

  759. 	float 	fSlow461 = (fSlow460 + (fConst2 * (fSlow453 + fSlow452)));

  760. 	float 	fSlow462 = (fSlow460 - (fConst2 * (fSlow453 + fSlow458)));

  761. 	float 	fSlow463 = ((fSlow31 == 8) / fSlow449);

  762. 	float 	fSlow464 = (3.0937500000000006e-07f * fSlow0);

  763. 	float 	fSlow465 = (1.2375000000000003e-05f * fSlow2);

  764. 	float 	fSlow466 = (6.677000000000001e-07f + ((1.9448000000000004e-05f * fSlow2) + (fSlow0 * ((fSlow465 - 2.1175000000000003e-08f) - fSlow464))));

  765. 	float 	fSlow467 = ((1.7121500000000001e-09f * fSlow2) - (4.2803750000000003e-11f * fSlow0));

  766. 	float 	fSlow468 = (1.9965000000000003e-09f * fSlow2);

  767. 	float 	fSlow469 = (4.991250000000001e-11f + (fSlow468 + (fSlow0 * (fSlow467 - 7.108750000000004e-12f))));

  768. 	float 	fSlow470 = (fConst1 * fSlow469);

  769. 	float 	fSlow471 = (0.022500000000000003f * fSlow2);

  770. 	float 	fSlow472 = (fSlow8 + fSlow471);

  771. 	float 	fSlow473 = (fConst1 * (0.0021395000000000003f + fSlow472));

  772. 	float 	fSlow474 = ((fSlow473 + (fConst2 * (fSlow470 - fSlow466))) - 1);

  773. 	float 	fSlow475 = (fConst3 * fSlow469);

  774. 	float 	fSlow476 = ((fConst2 * (fSlow466 + fSlow475)) - (3 + fSlow473));

  775. 	float 	fSlow477 = ((fSlow473 + (fConst2 * (fSlow466 - fSlow475))) - 3);

  776. 	float 	fSlow478 = (0 - (1 + (fSlow473 + (fConst2 * (fSlow466 + fSlow470)))));

  777. 	float 	fSlow479 = (1.0f / fSlow478);

  778. 	float 	fSlow480 = ((fSlow0 * (4.2803750000000003e-11f + fSlow467)) + (fSlow17 * ((4.991250000000001e-11f - (4.991250000000001e-11f * fSlow0)) + fSlow468)));

  779. 	float 	fSlow481 = (fConst3 * fSlow480);

  780. 	float 	fSlow482 = (1.2375000000000003e-05f * fSlow0);

  781. 	float 	fSlow483 = (fSlow0 * (3.781250000000001e-07f - fSlow464));

  782. 	float 	fSlow484 = (8.690000000000002e-08f + (((1.815e-07f * fSlow17) + fSlow483) + (fSlow2 * (3.4760000000000007e-06f + fSlow482))));

  783. 	float 	fSlow485 = (0.0005625000000000001f + (fSlow471 + (fSlow8 + (0.000125f * fSlow17))));

  784. 	float 	fSlow486 = (fConst1 * fSlow485);

  785. 	float 	fSlow487 = (fSlow486 + (fConst2 * (fSlow484 - fSlow481)));

  786. 	float 	fSlow488 = (fConst1 * fSlow480);

  787. 	float 	fSlow489 = (fSlow486 + (fConst2 * (fSlow488 - fSlow484)));

  788. 	float 	fSlow490 = (fConst1 * (0 - fSlow485));

  789. 	float 	fSlow491 = (fSlow490 + (fConst2 * (fSlow484 + fSlow481)));

  790. 	float 	fSlow492 = (fSlow490 - (fConst2 * (fSlow484 + fSlow488)));

  791. 	float 	fSlow493 = ((fSlow31 == 7) / fSlow478);

  792. 	float 	fSlow494 = (3.0621250000000006e-07f * fSlow0);

  793. 	float 	fSlow495 = (5.442360000000002e-07f + ((1.784904e-05f * fSlow2) + (fSlow0 * (((1.2248500000000003e-05f * fSlow2) - 5.596250000000005e-08f) - fSlow494))));

  794. 	float 	fSlow496 = ((9.245610000000004e-10f * fSlow2) - (2.3114025000000008e-11f * fSlow0));

  795. 	float 	fSlow497 = (1.0781100000000005e-09f * fSlow2);

  796. 	float 	fSlow498 = (2.695275000000001e-11f + (fSlow497 + (fSlow0 * (fSlow496 - 3.8387250000000005e-12f))));

  797. 	float 	fSlow499 = (fConst1 * fSlow498);

  798. 	float 	fSlow500 = (0.02227f * fSlow2);

  799. 	float 	fSlow501 = (fConst1 * (0.00207625f + (fSlow8 + fSlow500)));

  800. 	float 	fSlow502 = ((fSlow501 + (fConst2 * (fSlow499 - fSlow495))) - 1);

  801. 	float 	fSlow503 = (fConst3 * fSlow498);

  802. 	float 	fSlow504 = ((fConst2 * (fSlow495 + fSlow503)) - (3 + fSlow501));

  803. 	float 	fSlow505 = ((fSlow501 + (fConst2 * (fSlow495 - fSlow503))) - 3);

  804. 	float 	fSlow506 = (0 - (1 + (fSlow501 + (fConst2 * (fSlow495 + fSlow499)))));

  805. 	float 	fSlow507 = (1.0f / fSlow506);

  806. 	float 	fSlow508 = ((fSlow0 * (2.3114025000000008e-11f + fSlow496)) + (fSlow17 * ((2.695275000000001e-11f - (2.695275000000001e-11f * fSlow0)) + fSlow497)));

  807. 	float 	fSlow509 = (fConst3 * fSlow508);

  808. 	float 	fSlow510 = (4.6926e-08f + (((9.801000000000002e-08f * fSlow17) + (fSlow0 * (3.433375000000001e-07f - fSlow494))) + (fSlow2 * (1.8770400000000002e-06f + (1.2248500000000003e-05f * fSlow0)))));

  809. 	float 	fSlow511 = (0.0005567500000000001f + (fSlow500 + (fSlow8 + fSlow296)));

  810. 	float 	fSlow512 = (fConst1 * fSlow511);

  811. 	float 	fSlow513 = (fSlow512 + (fConst2 * (fSlow510 - fSlow509)));

  812. 	float 	fSlow514 = (fConst1 * fSlow508);

  813. 	float 	fSlow515 = (fSlow512 + (fConst2 * (fSlow514 - fSlow510)));

  814. 	float 	fSlow516 = (fConst1 * (0 - fSlow511));

  815. 	float 	fSlow517 = (fSlow516 + (fConst2 * (fSlow510 + fSlow509)));

  816. 	float 	fSlow518 = (fSlow516 - (fConst2 * (fSlow510 + fSlow514)));

  817. 	float 	fSlow519 = ((fSlow31 == 6) / fSlow506);

  818. 	float 	fSlow520 = (1.08515e-06f + ((3.108600000000001e-05f * fSlow2) + (fSlow0 * ((fSlow465 - 2.99475e-07f) - fSlow464))));

  819. 	float 	fSlow521 = ((1.8513000000000002e-09f * fSlow2) - (4.628250000000001e-11f * fSlow0));

  820. 	float 	fSlow522 = (3.3880000000000003e-09f * fSlow2);

  821. 	float 	fSlow523 = (8.470000000000002e-11f + (fSlow522 + (fSlow0 * (fSlow521 - 3.8417500000000006e-11f))));

  822. 	float 	fSlow524 = (fConst1 * fSlow523);

  823. 	float 	fSlow525 = (fConst1 * (fSlow472 + 0.0031515000000000002f));

  824. 	float 	fSlow526 = ((fSlow525 + (fConst2 * (fSlow524 - fSlow520))) - 1);

  825. 	float 	fSlow527 = (fConst3 * fSlow523);

  826. 	float 	fSlow528 = ((fConst2 * (fSlow520 + fSlow527)) - (3 + fSlow525));

  827. 	float 	fSlow529 = ((fSlow525 + (fConst2 * (fSlow520 - fSlow527))) - 3);

  828. 	float 	fSlow530 = (0 - (1 + (fSlow525 + (fConst2 * (fSlow520 + fSlow524)))));

  829. 	float 	fSlow531 = (1.0f / fSlow530);

  830. 	float 	fSlow532 = ((fSlow0 * (4.628250000000001e-11f + fSlow521)) + (fSlow17 * ((8.470000000000002e-11f - (8.470000000000002e-11f * fSlow0)) + fSlow522)));

  831. 	float 	fSlow533 = (fConst3 * fSlow532);

  832. 	float 	fSlow534 = (9.955000000000001e-08f + ((fSlow483 + (3.08e-07f * fSlow17)) + (fSlow2 * (fSlow482 + 3.982e-06f))));

  833. 	float 	fSlow535 = (fSlow486 + (fConst2 * (fSlow534 - fSlow533)));

  834. 	float 	fSlow536 = (fConst1 * fSlow532);

  835. 	float 	fSlow537 = (fSlow486 + (fConst2 * (fSlow536 - fSlow534)));

  836. 	float 	fSlow538 = (fSlow490 + (fConst2 * (fSlow534 + fSlow533)));

  837. 	float 	fSlow539 = (fSlow490 - (fConst2 * (fSlow534 + fSlow536)));

  838. 	float 	fSlow540 = ((fSlow31 == 5) / fSlow530);

  839. 	float 	fSlow541 = (5.665800800000001e-07f + ((1.892924e-05f * fSlow2) + (fSlow0 * ((fSlow142 - 6.207784000000001e-08f) - fSlow141))));

  840. 	float 	fSlow542 = ((1.2661536800000005e-09f * fSlow2) - (2.7855380960000008e-11f * fSlow0));

  841. 	float 	fSlow543 = (1.6515048000000004e-09f * fSlow2);

  842. 	float 	fSlow544 = (3.6333105600000014e-11f + (fSlow543 + (fSlow0 * (fSlow542 - 8.477724640000006e-12f))));

  843. 	float 	fSlow545 = (fConst1 * fSlow544);

  844. 	float 	fSlow546 = (fConst1 * (fSlow150 + 0.0020497400000000004f));

  845. 	float 	fSlow547 = ((fSlow546 + (fConst2 * (fSlow545 - fSlow541))) - 1);

  846. 	float 	fSlow548 = (fConst3 * fSlow544);

  847. 	float 	fSlow549 = ((fConst2 * (fSlow541 + fSlow548)) - (3 + fSlow546));

  848. 	float 	fSlow550 = ((fSlow546 + (fConst2 * (fSlow541 - fSlow548))) - 3);

  849. 	float 	fSlow551 = (0 - (1 + (fSlow546 + (fConst2 * (fSlow541 + fSlow545)))));

  850. 	float 	fSlow552 = (1.0f / fSlow551);

  851. 	float 	fSlow553 = ((fSlow0 * (2.7855380960000008e-11f + fSlow542)) + (fSlow17 * ((3.6333105600000014e-11f - (3.6333105600000014e-11f * fSlow0)) + fSlow543)));

  852. 	float 	fSlow554 = (fConst3 * fSlow553);

  853. 	float 	fSlow555 = (6.505928000000001e-08f + ((fSlow161 + (1.5013680000000003e-07f * fSlow17)) + (fSlow2 * (fSlow160 + 2.95724e-06f))));

  854. 	float 	fSlow556 = (fSlow164 + (fConst2 * (fSlow555 - fSlow554)));

  855. 	float 	fSlow557 = (fConst1 * fSlow553);

  856. 	float 	fSlow558 = (fSlow164 + (fConst2 * (fSlow557 - fSlow555)));

  857. 	float 	fSlow559 = (fSlow168 + (fConst2 * (fSlow555 + fSlow554)));

  858. 	float 	fSlow560 = (fSlow168 - (fConst2 * (fSlow555 + fSlow557)));

  859. 	float 	fSlow561 = ((fSlow31 == 4) / fSlow551);

  860. 	float 	fSlow562 = (1.0855872000000003e-07f * fSlow0);

  861. 	float 	fSlow563 = (3.222390000000001e-06f + (fSlow62 + (fSlow0 * (((5.6541000000000015e-06f * fSlow2) - 2.1333412800000006e-06f) - fSlow562))));

  862. 	float 	fSlow564 = (4.935e-10f * fSlow2);

  863. 	float 	fSlow565 = (fSlow564 - (9.4752e-12f * fSlow0));

  864. 	float 	fSlow566 = (1.41e-10f + (fSlow65 + (fSlow0 * (fSlow565 - 1.315248e-10f))));

  865. 	float 	fSlow567 = (fConst1 * fSlow566);

  866. 	float 	fSlow568 = (0.0002256f * fSlow0);

  867. 	float 	fSlow569 = (fConst1 * (0.015243699999999999f + (fSlow9 + fSlow568)));

  868. 	float 	fSlow570 = ((fSlow569 + (fConst2 * (fSlow567 - fSlow563))) - 1);

  869. 	float 	fSlow571 = (fConst3 * fSlow566);

  870. 	float 	fSlow572 = ((fConst2 * (fSlow563 + fSlow571)) - (3 + fSlow569));

  871. 	float 	fSlow573 = ((fSlow569 + (fConst2 * (fSlow563 - fSlow571))) - 3);

  872. 	float 	fSlow574 = (0 - (1 + (fSlow569 + (fConst2 * (fSlow563 + fSlow567)))));

  873. 	float 	fSlow575 = (1.0f / fSlow574);

  874. 	float 	fSlow576 = (1.41e-10f - (1.41e-10f * fSlow0));

  875. 	float 	fSlow577 = ((fSlow0 * (9.4752e-12f + fSlow565)) + (fSlow17 * (fSlow65 + fSlow576)));

  876. 	float 	fSlow578 = (fConst3 * fSlow577);

  877. 	float 	fSlow579 = (4.764000000000001e-08f + ((fSlow78 + (fSlow0 * (1.2265872000000003e-07f - fSlow562))) + (fSlow2 * (2.48125e-06f + (5.6541000000000015e-06f * fSlow0)))));

  878. 	float 	fSlow580 = (0.00048120000000000004f + (fSlow9 + (fSlow21 + fSlow568)));

  879. 	float 	fSlow581 = (fConst1 * fSlow580);

  880. 	float 	fSlow582 = (fSlow581 + (fConst2 * (fSlow579 - fSlow578)));

  881. 	float 	fSlow583 = (fConst1 * fSlow577);

  882. 	float 	fSlow584 = (fSlow581 + (fConst2 * (fSlow583 - fSlow579)));

  883. 	float 	fSlow585 = (fConst1 * (0 - fSlow580));

  884. 	float 	fSlow586 = (fSlow585 + (fConst2 * (fSlow579 + fSlow578)));

  885. 	float 	fSlow587 = (fSlow585 - (fConst2 * (fSlow579 + fSlow583)));

  886. 	float 	fSlow588 = ((fSlow31 == 3) / fSlow574);

  887. 	float 	fSlow589 = (4.7056400000000006e-07f * fSlow0);

  888. 	float 	fSlow590 = (5.188640000000001e-06f + ((0.00011869100000000002f * fSlow2) + (fSlow0 * (((1.1764100000000001e-05f * fSlow2) - 4.215336e-06f) - fSlow589))));

  889. 	float 	fSlow591 = (fSlow564 - (1.974e-11f * fSlow0));

  890. 	float 	fSlow592 = (3.525e-09f * fSlow2);

  891. 	float 	fSlow593 = (1.41e-10f + (fSlow592 + (fSlow0 * (fSlow591 - 1.2126e-10f))));

  892. 	float 	fSlow594 = (fConst1 * fSlow593);

  893. 	float 	fSlow595 = (0.02503f * fSlow2);

  894. 	float 	fSlow596 = (fConst1 * (0.0157312f + (fSlow68 + fSlow595)));

  895. 	float 	fSlow597 = ((fSlow596 + (fConst2 * (fSlow594 - fSlow590))) - 1);

  896. 	float 	fSlow598 = (fConst3 * fSlow593);

  897. 	float 	fSlow599 = ((fConst2 * (fSlow590 + fSlow598)) - (3 + fSlow596));

  898. 	float 	fSlow600 = ((fSlow596 + (fConst2 * (fSlow590 - fSlow598))) - 3);

  899. 	float 	fSlow601 = (0 - (1 + (fSlow596 + (fConst2 * (fSlow590 + fSlow594)))));

  900. 	float 	fSlow602 = (1.0f / fSlow601);

  901. 	float 	fSlow603 = ((fSlow0 * (1.974e-11f + fSlow591)) + (fSlow17 * (fSlow576 + fSlow592)));

  902. 	float 	fSlow604 = (fConst3 * fSlow603);

  903. 	float 	fSlow605 = (4.764000000000001e-08f + (((4.410000000000001e-07f * fSlow17) + (fSlow0 * (4.846640000000001e-07f - fSlow589))) + (fSlow2 * (1.1910000000000001e-06f + (1.1764100000000001e-05f * fSlow0)))));

  904. 	float 	fSlow606 = (0.0010012f + (fSlow595 + (fSlow68 + (3e-05f * fSlow17))));

  905. 	float 	fSlow607 = (fConst1 * fSlow606);

  906. 	float 	fSlow608 = (fSlow607 + (fConst2 * (fSlow605 - fSlow604)));

  907. 	float 	fSlow609 = (fConst1 * fSlow603);

  908. 	float 	fSlow610 = (fSlow607 + (fConst2 * (fSlow609 - fSlow605)));

  909. 	float 	fSlow611 = (fConst1 * (0 - fSlow606));

  910. 	float 	fSlow612 = (fSlow611 + (fConst2 * (fSlow605 + fSlow604)));

  911. 	float 	fSlow613 = (fSlow611 - (fConst2 * (fSlow605 + fSlow609)));

  912. 	float 	fSlow614 = ((fSlow31 == 2) / fSlow601);

  913. 	float 	fSlow615 = (2.9448437500000003e-06f * fSlow0);

  914. 	float 	fSlow616 = (1.2916875000000002e-05f + (fSlow62 + (fSlow0 * (((2.9448437500000007e-05f * fSlow2) - 8.731718750000001e-06f) - fSlow615))));

  915. 	float 	fSlow617 = ((2.5703125000000004e-09f * fSlow2) - (2.5703125000000003e-10f * fSlow0));

  916. 	float 	fSlow618 = (7.343750000000001e-10f + (fSlow65 + (fSlow0 * (fSlow617 - 4.773437500000001e-10f))));

  917. 	float 	fSlow619 = (fConst1 * fSlow618);

  918. 	float 	fSlow620 = (fConst1 * (0.01726875f + (fSlow9 + fSlow442)));

  919. 	float 	fSlow621 = ((fSlow620 + (fConst2 * (fSlow619 - fSlow616))) - 1);

  920. 	float 	fSlow622 = (fConst3 * fSlow618);

  921. 	float 	fSlow623 = ((fConst2 * (fSlow616 + fSlow622)) - (3 + fSlow620));

  922. 	float 	fSlow624 = ((fSlow620 + (fConst2 * (fSlow616 - fSlow622))) - 3);

  923. 	float 	fSlow625 = (0 - (1 + (fSlow620 + (fConst2 * (fSlow616 + fSlow619)))));

  924. 	float 	fSlow626 = (1.0f / fSlow625);

  925. 	float 	fSlow627 = ((fSlow0 * (2.5703125000000003e-10f + fSlow617)) + (fSlow17 * (fSlow65 + (7.343750000000001e-10f - (7.343750000000001e-10f * fSlow0)))));

  926. 	float 	fSlow628 = (fConst3 * fSlow627);

  927. 	float 	fSlow629 = (2.48125e-07f + ((fSlow78 + (fSlow0 * (3.0182812500000004e-06f - fSlow615))) + (fSlow2 * (2.48125e-06f + (2.9448437500000007e-05f * fSlow0)))));

  928. 	float 	fSlow630 = (0.0025062500000000002f + (fSlow9 + fSlow454));

  929. 	float 	fSlow631 = (fConst1 * fSlow630);

  930. 	float 	fSlow632 = (fSlow631 + (fConst2 * (fSlow629 - fSlow628)));

  931. 	float 	fSlow633 = (fConst1 * fSlow627);

  932. 	float 	fSlow634 = (fSlow631 + (fConst2 * (fSlow633 - fSlow629)));

  933. 	float 	fSlow635 = (fConst1 * (0 - fSlow630));

  934. 	float 	fSlow636 = (fSlow635 + (fConst2 * (fSlow629 + fSlow628)));

  935. 	float 	fSlow637 = (fSlow635 - (fConst2 * (fSlow629 + fSlow633)));

  936. 	float 	fSlow638 = ((fSlow31 == 1) / fSlow625);

  937. 	float 	fSlow639 = (2.5312500000000006e-07f * fSlow0);

  938. 	float 	fSlow640 = (7.4525e-07f + ((2.4210000000000004e-05f * fSlow2) + (fSlow0 * (((1.0125e-05f * fSlow2) - 2.75625e-07f) - fSlow639))));

  939. 	float 	fSlow641 = ((7.650000000000002e-10f * fSlow2) - (1.9125000000000002e-11f * fSlow0));

  940. 	float 	fSlow642 = (1.4000000000000001e-09f * fSlow2);

  941. 	float 	fSlow643 = (3.500000000000001e-11f + (fSlow642 + (fSlow0 * (fSlow641 - 1.5875000000000007e-11f))));

  942. 	float 	fSlow644 = (fConst1 * fSlow643);

  943. 	float 	fSlow645 = (0.02025f * fSlow2);

  944. 	float 	fSlow646 = (fConst1 * (0.0028087500000000005f + (fSlow365 + fSlow645)));

  945. 	float 	fSlow647 = ((fSlow646 + (fConst2 * (fSlow644 - fSlow640))) - 1);

  946. 	float 	fSlow648 = (fConst3 * fSlow643);

  947. 	float 	fSlow649 = ((fConst2 * (fSlow640 + fSlow648)) - (3 + fSlow646));

  948. 	float 	fSlow650 = ((fSlow646 + (fConst2 * (fSlow640 - fSlow648))) - 3);

  949. 	float 	fSlow651 = (0 - (1 + (fSlow646 + (fConst2 * (fSlow640 + fSlow644)))));

  950. 	float 	fSlow652 = (1.0f / fSlow651);

  951. 	float 	fSlow653 = ((fSlow0 * (1.9125000000000002e-11f + fSlow641)) + (fSlow17 * ((3.500000000000001e-11f - (3.500000000000001e-11f * fSlow0)) + fSlow642)));

  952. 	float 	fSlow654 = (fConst3 * fSlow653);

  953. 	float 	fSlow655 = (4.525e-08f + (((1.4e-07f * fSlow17) + (fSlow0 * (2.8437500000000003e-07f - fSlow639))) + (fSlow2 * (1.8100000000000002e-06f + (1.0125e-05f * fSlow0)))));

  954. 	float 	fSlow656 = (0.00050625f + (fSlow645 + (fSlow21 + fSlow365)));

  955. 	float 	fSlow657 = (fConst1 * fSlow656);

  956. 	float 	fSlow658 = (fSlow657 + (fConst2 * (fSlow655 - fSlow654)));

  957. 	float 	fSlow659 = (fConst1 * fSlow653);

  958. 	float 	fSlow660 = (fSlow657 + (fConst2 * (fSlow659 - fSlow655)));

  959. 	float 	fSlow661 = (fConst1 * (0 - fSlow656));

  960. 	float 	fSlow662 = (fSlow661 + (fConst2 * (fSlow655 + fSlow654)));

  961. 	float 	fSlow663 = (fSlow661 - (fConst2 * (fSlow655 + fSlow659)));

  962. 	float 	fSlow664 = ((fSlow31 == 0) / fSlow651);

  963. 

  964. 	float tubeout = 0.f;

  965. 	

  966. 	for (uint32_t i = 0; i < frames; ++i) {

  967. 

  968. 		//Step 1: read input sample as voltage for the source

  969. 		float in = sanitize_denormal(inputs[0][i]);

  970. 

  971. 		// protect against overflowing circuit

  972. 		in = fabs(in) < DANGER ? in : 0.f; 

  973. 

  974. 		Vi.e = in*from_dB(tubedrive);

  975. 

  976. 		//Step 2: propagate waves up to the triode and push values into triode element

  977. 		I1.waveUp();

  978. 		I3.waveUp();

  979. 		P2.waveUp();

  980. 		v.G.WD = sanitize_denormal(I1.WU);

  981. 		v.K.WD = sanitize_denormal(I3.WU); 

  982. 		v.P.WD = sanitize_denormal(P2.WU);

  983. 		v.vg = v.G.WD;

  984. 		v.vk = v.K.WD;

  985. 		v.vp = v.P.WD;

  986. 		v.G.PortRes = sanitize_denormal(I1.PortRes);

  987. 		v.K.PortRes = sanitize_denormal(I3.PortRes);

  988. 		v.P.PortRes = sanitize_denormal(P2.PortRes);

  989. 

  990. 		//Step 3: compute wave reflections inside the triode

  991. 		T vg0, vg1, vp0, vp1;

  992. 

  993. 		vg0 = -10.0;

  994. 		vg1 = 10.0;

  995. 		v.vg = sanitize_denormal(v.zeroffg(vg0,vg1,TOLERANCE));

  996. 		//v.vg = v.secantfg(&vg0,&vg1);

  997. 

  998. 		vp0 = e;

  999. 		vp1 = 0.0;

  1000. 		v.vp = sanitize_denormal(v.zeroffp(vp0,vp1,TOLERANCE));

  1001. 		//v.vp = v.secantfp(&vp0,&vp1);

  1002. 

  1003. 		v.vk = sanitize_denormal(v.ffk());

  1004. 

  1005. 		v.G.WU = sanitize_denormal(2.0*v.vg-v.G.WD);

  1006. 		v.K.WU = sanitize_denormal(2.0*v.vk-v.K.WD);

  1007. 		v.P.WU = sanitize_denormal(2.0*v.vp-v.P.WD);

  1008. 		

  1009. 		outputs[0][i] = in;

  1010. 		

  1011. 		tubeout = -Ro.Voltage()/e; //invert signal and rescale

  1012. 		tubeout = sanitize_denormal(tubeout);

  1013. 

  1014. 		P2.setWD(v.P.WU); 

  1015. 		I1.setWD(v.G.WU);

  1016. 		I3.setWD(v.K.WU);

  1017. 		

  1018. 		//Tone Stack sim

  1019. 		fRec0[0] = ((float)tubeout - (fSlow16 * (((fSlow14 * fRec0[2]) + (fSlow13 * fRec0[1])) + (fSlow11 * fRec0[3]))));

  1020. 		fRec1[0] = ((float)tubeout - (fSlow47 * (((fSlow45 * fRec1[2]) + (fSlow44 * fRec1[1])) + (fSlow42 * fRec1[3]))));

  1021. 		fRec2[0] = ((float)tubeout - (fSlow75 * (((fSlow73 * fRec2[2]) + (fSlow72 * fRec2[1])) + (fSlow70 * fRec2[3]))));

  1022. 		fRec3[0] = ((float)tubeout - (fSlow102 * (((fSlow100 * fRec3[2]) + (fSlow99 * fRec3[1])) + (fSlow97 * fRec3[3]))));

  1023. 		fRec4[0] = ((float)tubeout - (fSlow128 * (((fSlow126 * fRec4[2]) + (fSlow125 * fRec4[1])) + (fSlow123 * fRec4[3]))));

  1024. 		fRec5[0] = ((float)tubeout - (fSlow157 * (((fSlow155 * fRec5[2]) + (fSlow154 * fRec5[1])) + (fSlow152 * fRec5[3]))));

  1025. 		fRec6[0] = ((float)tubeout - (fSlow186 * (((fSlow184 * fRec6[2]) + (fSlow183 * fRec6[1])) + (fSlow181 * fRec6[3]))));

  1026. 		fRec7[0] = ((float)tubeout - (fSlow212 * (((fSlow210 * fRec7[2]) + (fSlow209 * fRec7[1])) + (fSlow207 * fRec7[3]))));

  1027. 		fRec8[0] = ((float)tubeout - (fSlow237 * (((fSlow235 * fRec8[2]) + (fSlow234 * fRec8[1])) + (fSlow232 * fRec8[3]))));

  1028. 		fRec9[0] = ((float)tubeout - (fSlow265 * (((fSlow263 * fRec9[2]) + (fSlow262 * fRec9[1])) + (fSlow260 * fRec9[3]))));

  1029. 		fRec10[0] = ((float)tubeout - (fSlow292 * (((fSlow290 * fRec10[2]) + (fSlow289 * fRec10[1])) + (fSlow287 * fRec10[3]))));

  1030. 		fRec11[0] = ((float)tubeout - (fSlow320 * (((fSlow318 * fRec11[2]) + (fSlow317 * fRec11[1])) + (fSlow315 * fRec11[3]))));

  1031. 		fRec12[0] = ((float)tubeout - (fSlow346 * (((fSlow344 * fRec12[2]) + (fSlow343 * fRec12[1])) + (fSlow341 * fRec12[3]))));

  1032. 		fRec13[0] = ((float)tubeout - (fSlow373 * (((fSlow371 * fRec13[2]) + (fSlow370 * fRec13[1])) + (fSlow368 * fRec13[3]))));

  1033. 		fRec14[0] = ((float)tubeout - (fSlow397 * (((fSlow395 * fRec14[2]) + (fSlow394 * fRec14[1])) + (fSlow392 * fRec14[3]))));

  1034. 		fRec15[0] = ((float)tubeout - (fSlow423 * (((fSlow421 * fRec15[2]) + (fSlow420 * fRec15[1])) + (fSlow418 * fRec15[3]))));

  1035. 		fRec16[0] = ((float)tubeout - (fSlow450 * (((fSlow448 * fRec16[2]) + (fSlow447 * fRec16[1])) + (fSlow445 * fRec16[3]))));

  1036. 		fRec17[0] = ((float)tubeout - (fSlow479 * (((fSlow477 * fRec17[2]) + (fSlow476 * fRec17[1])) + (fSlow474 * fRec17[3]))));

  1037. 		fRec18[0] = ((float)tubeout - (fSlow507 * (((fSlow505 * fRec18[2]) + (fSlow504 * fRec18[1])) + (fSlow502 * fRec18[3]))));

  1038. 		fRec19[0] = ((float)tubeout - (fSlow531 * (((fSlow529 * fRec19[2]) + (fSlow528 * fRec19[1])) + (fSlow526 * fRec19[3]))));

  1039. 		fRec20[0] = ((float)tubeout - (fSlow552 * (((fSlow550 * fRec20[2]) + (fSlow549 * fRec20[1])) + (fSlow547 * fRec20[3]))));

  1040. 		fRec21[0] = ((float)tubeout - (fSlow575 * (((fSlow573 * fRec21[2]) + (fSlow572 * fRec21[1])) + (fSlow570 * fRec21[3]))));

  1041. 		fRec22[0] = ((float)tubeout - (fSlow602 * (((fSlow600 * fRec22[2]) + (fSlow599 * fRec22[1])) + (fSlow597 * fRec22[3]))));

  1042. 		fRec23[0] = ((float)tubeout - (fSlow626 * (((fSlow624 * fRec23[2]) + (fSlow623 * fRec23[1])) + (fSlow621 * fRec23[3]))));

  1043. 		fRec24[0] = ((float)tubeout - (fSlow652 * (((fSlow650 * fRec24[2]) + (fSlow649 * fRec24[1])) + (fSlow647 * fRec24[3]))));

  1044. 		outputs[0][i] = (FAUSTFLOAT)((fSlow664 * ((fSlow663 * fRec24[0]) + ((fSlow662 * fRec24[1]) + ((fSlow660 * fRec24[3]) + (fSlow658 * fRec24[2]))))) + ((fSlow638 * ((fSlow637 * fRec23[0]) + ((fSlow636 * fRec23[1]) + ((fSlow634 * fRec23[3]) + (fSlow632 * fRec23[2]))))) + ((fSlow614 * ((fSlow613 * fRec22[0]) + ((fSlow612 * fRec22[1]) + ((fSlow610 * fRec22[3]) + (fSlow608 * fRec22[2]))))) + ((fSlow588 * ((fSlow587 * fRec21[0]) + ((fSlow586 * fRec21[1]) + ((fSlow584 * fRec21[3]) + (fSlow582 * fRec21[2]))))) + ((fSlow561 * ((fSlow560 * fRec20[0]) + ((fSlow559 * fRec20[1]) + ((fSlow558 * fRec20[3]) + (fSlow556 * fRec20[2]))))) + ((fSlow540 * ((fSlow539 * fRec19[0]) + ((fSlow538 * fRec19[1]) + ((fSlow537 * fRec19[3]) + (fSlow535 * fRec19[2]))))) + ((fSlow519 * ((fSlow518 * fRec18[0]) + ((fSlow517 * fRec18[1]) + ((fSlow515 * fRec18[3]) + (fSlow513 * fRec18[2]))))) + ((fSlow493 * ((fSlow492 * fRec17[0]) + ((fSlow491 * fRec17[1]) + ((fSlow489 * fRec17[3]) + (fSlow487 * fRec17[2]))))) + ((fSlow463 * ((fSlow462 * fRec16[0]) + ((fSlow461 * fRec16[1]) + ((fSlow459 * fRec16[3]) + (fSlow457 * fRec16[2]))))) + ((fSlow435 * ((fSlow434 * fRec15[0]) + ((fSlow433 * fRec15[1]) + ((fSlow431 * fRec15[3]) + (fSlow429 * fRec15[2]))))) + ((fSlow409 * ((fSlow408 * fRec14[0]) + ((fSlow407 * fRec14[1]) + ((fSlow405 * fRec14[3]) + (fSlow403 * fRec14[2]))))) + ((fSlow385 * ((fSlow384 * fRec13[0]) + ((fSlow383 * fRec13[1]) + ((fSlow381 * fRec13[3]) + (fSlow379 * fRec13[2]))))) + ((fSlow358 * ((fSlow357 * fRec12[0]) + ((fSlow356 * fRec12[1]) + ((fSlow354 * fRec12[3]) + (fSlow352 * fRec12[2]))))) + ((fSlow332 * ((fSlow331 * fRec11[0]) + ((fSlow330 * fRec11[1]) + ((fSlow328 * fRec11[3]) + (fSlow326 * fRec11[2]))))) + ((fSlow305 * ((fSlow304 * fRec10[0]) + ((fSlow303 * fRec10[1]) + ((fSlow301 * fRec10[3]) + (fSlow299 * fRec10[2]))))) + ((fSlow277 * ((fSlow276 * fRec9[0]) + ((fSlow275 * fRec9[1]) + ((fSlow273 * fRec9[3]) + (fSlow271 * fRec9[2]))))) + ((fSlow250 * ((fSlow249 * fRec8[0]) + ((fSlow248 * fRec8[1]) + ((fSlow246 * fRec8[3]) + (fSlow244 * fRec8[2]))))) + ((fSlow224 * ((fSlow223 * fRec7[0]) + ((fSlow222 * fRec7[1]) + ((fSlow220 * fRec7[3]) + (fSlow218 * fRec7[2]))))) + ((fSlow198 * ((fSlow197 * fRec6[0]) + ((fSlow196 * fRec6[1]) + ((fSlow194 * fRec6[3]) + (fSlow192 * fRec6[2]))))) + ((fSlow171 * ((fSlow170 * fRec5[0]) + ((fSlow169 * fRec5[1]) + ((fSlow167 * fRec5[3]) + (fSlow165 * fRec5[2]))))) + ((fSlow140 * ((fSlow139 * fRec4[0]) + ((fSlow138 * fRec4[1]) + ((fSlow136 * fRec4[3]) + (fSlow134 * fRec4[2]))))) + ((fSlow114 * ((fSlow113 * fRec3[0]) + ((fSlow112 * fRec3[1]) + ((fSlow110 * fRec3[3]) + (fSlow108 * fRec3[2]))))) + ((fSlow88 * ((fSlow87 * fRec2[0]) + ((fSlow86 * fRec2[1]) + ((fSlow84 * fRec2[3]) + (fSlow82 * fRec2[2]))))) + ((fSlow60 * ((fSlow59 * fRec1[0]) + ((fSlow58 * fRec1[1]) + ((fSlow56 * fRec1[3]) + (fSlow54 * fRec1[2]))))) + (fSlow32 * ((fSlow30 * fRec0[0]) + ((fSlow29 * fRec0[1]) + ((fSlow27 * fRec0[3]) + (fSlow25 * fRec0[2])))))))))))))))))))))))))))))* from_dB(mastergain);

  1045. 		outputs[0][i] = sanitize_denormal(outputs[0][i]);

  1046. 

  1047. 		// post processing

  1048. 		for (int i=3; i>0; i--) fRec24[i] = sanitize_denormal(fRec24[i-1]);

  1049. 		for (int i=3; i>0; i--) fRec23[i] = sanitize_denormal(fRec23[i-1]);

  1050. 		for (int i=3; i>0; i--) fRec22[i] = sanitize_denormal(fRec22[i-1]);

  1051. 		for (int i=3; i>0; i--) fRec21[i] = sanitize_denormal(fRec21[i-1]);

  1052. 		for (int i=3; i>0; i--) fRec20[i] = sanitize_denormal(fRec20[i-1]);

  1053. 		for (int i=3; i>0; i--) fRec19[i] = sanitize_denormal(fRec19[i-1]);

  1054. 		for (int i=3; i>0; i--) fRec18[i] = sanitize_denormal(fRec18[i-1]);

  1055. 		for (int i=3; i>0; i--) fRec17[i] = sanitize_denormal(fRec17[i-1]);

  1056. 		for (int i=3; i>0; i--) fRec16[i] = sanitize_denormal(fRec16[i-1]);

  1057. 		for (int i=3; i>0; i--) fRec15[i] = sanitize_denormal(fRec15[i-1]);

  1058. 		for (int i=3; i>0; i--) fRec14[i] = sanitize_denormal(fRec14[i-1]);

  1059. 		for (int i=3; i>0; i--) fRec13[i] = sanitize_denormal(fRec13[i-1]);

  1060. 		for (int i=3; i>0; i--) fRec12[i] = sanitize_denormal(fRec12[i-1]);

  1061. 		for (int i=3; i>0; i--) fRec11[i] = sanitize_denormal(fRec11[i-1]);

  1062. 		for (int i=3; i>0; i--) fRec10[i] = sanitize_denormal(fRec10[i-1]);

  1063. 		for (int i=3; i>0; i--) fRec9[i] = sanitize_denormal(fRec9[i-1]);

  1064. 		for (int i=3; i>0; i--) fRec8[i] = sanitize_denormal(fRec8[i-1]);

  1065. 		for (int i=3; i>0; i--) fRec7[i] = sanitize_denormal(fRec7[i-1]);

  1066. 		for (int i=3; i>0; i--) fRec6[i] = sanitize_denormal(fRec6[i-1]);

  1067. 		for (int i=3; i>0; i--) fRec5[i] = sanitize_denormal(fRec5[i-1]);

  1068. 		for (int i=3; i>0; i--) fRec4[i] = sanitize_denormal(fRec4[i-1]);

  1069. 		for (int i=3; i>0; i--) fRec3[i] = sanitize_denormal(fRec3[i-1]);

  1070. 		for (int i=3; i>0; i--) fRec2[i] = sanitize_denormal(fRec2[i-1]);

  1071. 		for (int i=3; i>0; i--) fRec1[i] = sanitize_denormal(fRec1[i-1]);

  1072. 		for (int i=3; i>0; i--) fRec0[i] = sanitize_denormal(fRec0[i-1]);

  1073. 	}

  1074. }

  1075. 

  1076. // -----------------------------------------------------------------------

  1077. 

  1078. Plugin* createPlugin()

  1079. {

  1080.     return new ZamTubePlugin();

  1081. }

  1082. 

  1083. // -----------------------------------------------------------------------

  1084. 

  1085. END_NAMESPACE_DISTRHO