random1 { global: ;1st Random Transformation File transform: #pixel = #pixel + p3 * fn2 ( p4 / #pixel * #pixel / #pixel - (acosh ( #pixel + #pixel / floor ( 4 * #pixel )))) default: title = "random1" } random2 { global: ;second Random Transformation File transform: #pixel = fn1 ( #pixel * #pixel - 0 / #pixel ^ fn3 ( p5 )/ (fn4 ( p6 ))) default: title = "random2" } random2a { global: ;second Random Transformation File transform: #pixel = fn1 ( #pixel * #pixel - p1 / #pixel ^ fn3 ( p5 )/ (fn4 ( p6 ))) default: title = "random2a" } random3 { global: ;My 3rd Randomly-Generated Transformation Formula transform: #pixel = 4 - #pixel * p4 / p1 + #pixel * p6 - p2 - (tanh ( 3 ^ (#pixel ^ p6 )- #screenpixel )+ fn2 ( p6 )- #angle )* (acosh ( 2 + 3 ^ p4 )+ #pixel ^ p2 )* #random * (acosh ( p2 )* p4 / #screenpixel )- fn3 ( #pixel + fn2 ( p6 )) default: title = "random3" } random3a { global: ;My 3ard Randomly-Generated Transformation Formula transform: #pixel = 4 - #pixel * p4 / p1 + #pixel * p6 - p2 - (tanh ( 3 ^ (#pixel ^ p6 )- #screenpixel )+ fn2 ( p6 )- #angle )* (acosh ( 2 + 3 ^ p4 )+ #pixel ^ p2 )* p5 * (acosh ( p2 )* p4 / #pixel )- fn3 ( #pixel + fn2 ( p6 )) default: title = "random3a" } random4 { global: ;My 4th Randomly-Generated Transformation Formula transform: #pixel = #pixel - fn1 ( 1 ^ cotanh ( #pixel - #pixel ^ p2 )^ #pixel ^ #pixel - p6 / fn2 ( 0 - #pixel - #pixel )) default: title = "random4" } random5 { global: ;My 5th Randomly-Generated Transformation Formula transform: #pixel = (#pixel - #pixel / #pixel * #pixel ^ #pixel ) default: title = "random5" } random5a { global: ;My 5th extra Randomly-Generated Transformation Formula transform: IF @flavor == 0 #pixel = fn1((p1 + #pixel) + (p2 / #pixel) / (p3 * #pixel) * (p4 - #pixel) - (p5 ^ #pixel) ^ #pixel ) ELSE IF @flavor == 1 #pixel = fn1(fn2(fn3(fn4((#pixel + p1) + (p2 * #pixel) - (p3 + #pixel) ^ (p4 * #pixel) / (p5 * #pixel) - #pixel )))) ELSE IF @flavor == 2 #pixel = (fn1(#pixel + p1) + fn2(p2 * #pixel) - fn3(p3 + #pixel) ^ fn4(p4 * #pixel) / (p5 * #pixel) - #pixel ) ELSE IF @flavor == 3 #pixel = (fn1(#pixel - p1) - fn2(#pixel - p2) * fn3(#pixel / p3) * fn4(#pixel ^ p4) / (p5 * #pixel) + #pixel ) ELSE IF @flavor == 4 #pixel = (fn1(#pixel ^ p1) * fn2(#pixel - p2) - fn3(#pixel ^ p3) + fn4(#pixel + p4) - (p5 - #pixel) / #pixel ) ELSE IF @flavor == 5 #pixel = (fn1(#pixel / p1) / fn2(#pixel + p2) ^ fn3(#pixel - p3) - fn4(#pixel / p4) * (p5 - #pixel) * #pixel ) ELSE IF @flavor == 6 #pixel = fn1(fn2(fn3(fn4(fn1(#pixel + p1) ^ fn2(#pixel + p2) - fn3(#pixel - p3) - fn4(#pixel ^ p4) / (p5 / #pixel) - (p6 + #pixel ))))) ELSE IF @flavor == 7 #pixel = fn1(fn2(fn3(fn4(fn1(#pixel / p1) - fn2(#pixel / p2) + fn3(#pixel ^ p3) - fn4(#pixel * p4) + (p5 - #pixel) ^ (p6 * #pixel ))))) ELSE IF @flavor == 8 #pixel = (fn1(p1 + #pixel) * fn2(#pixel - p2) - fn3(p3 + #pixel) + fn4(#pixel ^ p4) - fn1(p5 + #pixel) * fn2(#pixel - p6) ) ELSE IF @flavor == 9 #pixel = (fn1(p1 ^ #pixel) - fn2(#pixel / p2) / fn3(p3 / #pixel) - fn4(#pixel * p4) * fn1(p5 - #pixel) - fn2(#pixel ^ p6) ) ELSE IF @flavor == 10 #pixel = (fn1(p1 - #pixel) ^ fn2(#pixel - p2) + fn3(p3 ^ #pixel) * fn4(#pixel / p4) + fn1(p5 ^ #pixel) / fn2(#pixel + p6) ) ELSE IF @flavor == 11 #pixel = (fn1(p1 / #pixel) / fn2(#pixel ^ p2) * fn3(p3 - #pixel) + fn4(#pixel - p4) / fn1(p5 + #pixel) ^ fn2(#pixel / p6) ) ELSE IF @flavor == 12 #pixel = (fn1(p1 ^ #pixel) + fn2(#pixel - p2) - fn3(p3 ^ #pixel) / fn4(#pixel * p4) + fn1(p5 ^ #pixel) * fn2(#pixel - p6) ) ELSE IF @flavor == 13 #pixel = (fn1(p1 / #pixel) * fn2(#pixel + p2) ^ fn3(p3 - #pixel) * fn4(#pixel / p4) ^ fn1(p5 + #pixel) - fn2(#pixel * p6) ) ELSE IF @flavor == 14 #pixel = (fn1(p1 * #pixel) / fn2(#pixel * p2) / fn3(p3 * #pixel) ^ fn4(#pixel + p4) - fn1(p5 / #pixel) + fn2(#pixel ^ p6) ) ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF ENDIF default: title = "random5a" param flavor enum = "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15" default = 0 endparam } random6 { global: ;My 6th Randomly-Generated Transformation Formula transform: #pixel = (#pixel / #pixel + #pixel * #pixel ^ #pixel + #pixel - #pixel / #pixel * #pixel * #pixel ) default: title = "random6" } random7 { global: ;My 7th Randomly-Generated Transformation Formula transform: #pixel = (#pixel * tan ( (sinh ( #pixel - asinh ( #pixel + p6 )* p2 )/ (p4 )- (p4 )* ((fn1 ( p5 )+ #angle )/ ((fn2 ( p3 )^ ((ceil ( p4 )+ ((fn4 ( #pixel ))))))))))) default: title = "random7" } random8 { global: ;My Randomly-Generated Transformation Formula transform: #pixel = (#pixel + p2 + ((fn1 ( #pixel - #pixel / (fn4 ( 4 + (p1 )+ #screenpixel )/ (#pixel / #pixel - p3 )+ 1 ^ #pixel - #pixel ^ fn4 ( #pixel * fn3 ( 1 ))))))) default: title = "random8" } random9 { global: ;My 9th Randomly-Generated Transformation Formula transform: #pixel = ((fn2 ( p3 )^ (fn1 ( fn2 ( #pixel + fn3 ( p3 )+ (conj ( (tan ( p2 )+ (#angle ))))))))) default: title = "random9" } random10 { ;My 10th Super Randomly-Generated Transformation Formula global: Transform: if @ztweak1== true z =1/z endif if @ztweak2== true z =z ^ 2 + p1 endif if @ztweak3== true z =p1 *z * ( 1 - z ) ^ ( p2 - 1 ) endif if @ztweak4== true z =z ^ p1 + z ^ p2 * #pi + p3 * z endif if @ztweak5== true z =((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1)) endif if @ztweak6== true z =sqr( (z^2 + #pi - 1) / (2*z + #pi - 2) ) endif if @ztweak7== true z =(p2 )+ fn1 ( 2 - z ) endif if @ztweak8== true z =z = z + p1 * (trunc ( #screenpixel )) endif if @ztweak9== true z =(p3 )/ z endif if @ztweak10== true z =#e ^ z endif if @ztweak11== true z =z ^ #e endif if @ztweak12== true z =z ^ #pi endif if @ztweak13== true z =#pi ^ z endif if @ztweak14== true z =#pi / z endif if @ztweak15== true z =z / #pi endif if @ztweak16== true z =p5 * fn1(z) * (z ) endif if @ztweak17== true z =(p3 )/ (fn1 ( z )) endif if @ztweak18== true z =(z ^ p4 - e ^ z ) endif if @ztweak19== true z =(z ^ p6 )* #pi ^ 1 / z + (z*#pi/(z^#pi) ) endif if @ztweak20== true z =z * p2 + ((fn3 ( z ))) endif if @ztweak21== true z =z = z * z ^ 2 + p1 endif if @ztweak22== true z =( p3 )+ #e * (fn2 ( 2 + (4 ))) endif if @ztweak23== true z =(z + 2 * z ^ 2 + p1 ) endif if @ztweak24== true z =z + (fn2 ( 4 )) endif if @ztweak25== true z =((fn1 ( z*#pi/(z^#pi) ))) endif if @ztweak26== true z =4 / (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ) endif if @ztweak27== true z =2 ^ z endif if @ztweak28== true z =p5 ^ z / z - (z ) endif if @ztweak29== true z =z / fn3 ( 4 ^ p2 ) endif if @ztweak30== true z =((fn2 ( z ))) endif if @ztweak31== true z =z * p5 * fn4 ( 4 ^ z ^ e ) endif if @ztweak32== true z =(z * #screenpixel ) endif if @ztweak33== true z =z*#pi/(z^#pi) endif if @ztweak34== true z =(z * p6 ^ z ^ p1 + z ^ p2 * p3 + p4 * z )/ 3 endif if @ztweak35== true z =p6 + z ^ p1 + z ^ p2 * p3 + p4 * z - (3 * 1 ) endif if @ztweak36== true z =(z + z ) endif if @ztweak37== true z =(z + (fn4 ( #e ))) endif if @ztweak38== true z =( z + p6 )* #pi ^ z ^ e - (p6 ) endif if @ztweak39== true z =z ^ (z*#pi/(z^#pi) ) endif if @ztweak40== true z =(z * 4 ) endif if @ztweak41== true z =z + p2 - p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + 1 / z - flip ( z ) endif if @ztweak42== true z =(p2 - ((fn1 ( 3 ^ z )))) endif if @ztweak43== true z =(z * fn1(z) ) endif if @ztweak44== true z =z / p1 - #pi ^ z + (fn4 ( z )) endif if @ztweak45== true z =(z + p3 * #e )^ (fn4 ( #pi ^ z )) endif if @ztweak46== true z =(z / (exp ( z*#pi/(z^#pi) ))) endif if @ztweak47== true z =(z / (fn4 ( 1/z ))) endif if @ztweak48== true z =(z * 1 / (p5 )) endif if @ztweak49== true z =(p2 )/ #screenpixel + 1 / z + (2 / z ^ 2 + p1 ) endif if @ztweak50== true z =(z * p6 )* z ^ e / fn1 ( z^#pi/(z*#pi) ) endif IF @zfunc== 0 complex z = #pi ELSEIF @zfunc ==1 complex z = z ^ conj ( 4 / (p5 )* #screenpixel )/ #e * (fn1 ( 2 * (#e ))) ELSEIF @zfunc ==2 complex z = (z - p3 / #pi )* (1 ^ (z / (sqr ( e ^ z )))) ELSEIF @zfunc ==3 complex z = (z / log ( p6 )+ #pi * (p2 )/ (p3 )/ ((fn2 ( z ^ p2 )+ #random )/ (z^#pi/(z*#pi) ))) ELSEIF @zfunc ==4 complex z = (z ^ (fn1 ( z * z - (flip ( p5 )/ #pi ^ z )^ z - p3 )- z )+ (1 / z )) ELSEIF @zfunc ==5 complex z = p3 + #y * (fn1 ( z * p1 )/ (atanh ( 4 + (fn4 ( p4 ))))) ELSEIF @zfunc ==6 complex z = z / p4 / #pi - (fn3 ( 4 / (p3 )/ e ^ z )* (z ^ p1 )/ #y )* z ^ e ^ (fn4 ( 1 / (p4 )^ #screenpixel )/ z ^ z ^ ((fn2 ( z )))) ELSEIF @zfunc ==7 complex z = (z * p6 / #e )/ fn1 ( z / 4 + (p4 )- #y )+ z ^ e * (fn3 ( z * p6 )+ 1 + (p4 )/ z*#pi/(z^#pi) )+ fn4 ( 2 / (z )) ELSEIF @zfunc ==8 complex z = (z + fn2 ( z + p5 )/ z^#pi/(z*#pi) ^ ((ident ( 2 - z ^ fn1 ( 4 ^ (z )))))) ELSEIF @zfunc ==9 complex z = z ^ p6 / #y - #e - (cos ( z ^ p3 )/ (2 + (z * z - fn2 ( z )))) ELSEIF @zfunc ==10 complex z = p4 ^ z - (z ^ z - p6 )/ #pi ^ e ^ z * (fn4 ( z ^ p6 )^ z ^ #e )* (p1 )- #y ^ 1 / z * fn3 ( #x ) ELSEIF @zfunc ==11 complex z = (p3 - (z / fn3 ( p2 )* 2 + atan ( p4 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )- e ^ z )* (z ^ p1 + z ^ p2 * p3 + p4 * z ) ELSEIF @zfunc ==12 complex z = p2 / (flip ( 1 / (p5 )^ z ^ 2 + p1 )* 1 / z )* z * p1 ^ z ^ 2 + p1 - #e - (z ^ p6 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) / z^#pi/(z*#pi) - ((fn4 ( 4 ))) ELSEIF @zfunc ==13 complex z = (z + p2 )- z ^ p1 + z ^ p2 * p3 + p4 * z - #e - ((fn1 ( z / p5 )- ((fn4 ( 2 - z ))))) ELSEIF @zfunc ==14 complex z = (fn2 ( p2 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ (fn1 ( p6 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ z - fn3 ( flip ( 4 - z )) ELSEIF @zfunc ==15 complex z = ((fn3 ( z + p6 )^ #pi )/ e ^ z / (atan2 ( p3 )/ z ^ p1 + z ^ p2 * p3 + p4 * z )^ #pi ^ z / (z - p3 )* ((tanh ( 2 )))) ELSEIF @zfunc ==16 complex z = z * p3 / z ^ 2 + p1 - (z + p4 / #pi )^ #e / exp ( ident ( 4 + p4 )^ #screenpixel ^ (#pi )) ELSEIF @zfunc ==17 complex z = (p6 )/ (ident ( 4 + (z + p1 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )^ e ^ z )- 2 + z - fn4 ( 3 ^ ((fn2 ( 1 )))) ELSEIF @zfunc ==18 complex z = (p5 * (fn2 ( p1 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- (1 + (fn3 ( 1 * (fn3 ( z - p5 )+ #pi )/ #pi )/ 4 * (z^#pi/(z*#pi) )))) ELSEIF @zfunc ==19 complex z = (p6 )^ z ^ e ^ (fn3 ( z + z - p5 )* (fn1 ( z ^ p6 )- p6 )- z ^ p1 + z ^ p2 * p3 + p4 * z )- z^#pi/(z*#pi) * (fn1 ( p2 )) ELSEIF @zfunc ==20 complex z = (p4 )- 1 / z ^ p2 * z / p5 * (p4 )/ e ^ z / (z * p5 * #screenpixel ^ (fn4 ( z^#pi/(z*#pi) ))) ELSEIF @zfunc ==21 complex z = (p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) / z ^ z * ((fn2 ( z - p5 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )* #pi ^ z )^ p4 / p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + (p3 )- #pi / (p4 + #screenpixel * z ^ e )/ (4 * (#pi )) ELSEIF @zfunc ==22 complex z = (2 / z ^ p2 * z ^ 2 + p1 )^ (3 - z ^ (fn2 ( p5 )^ z ^ 2 + p1 )/ 1 / z / (conj ( p6 ))) ELSEIF @zfunc ==23 complex z = p3 + #screenpixel - e ^ z - (z * (fn4 ( z / p5 )* (fn4 ( z - p2 )/ z ^ e )* (fn2 ( p2 )- #screenpixel )* z*#pi/(z^#pi) )- fn4 ( 4 / (z ^ z ))) ELSEIF @zfunc ==24 complex z = ((fn2 ( p1 )^ z / p1 )^ z ^ p1 + z ^ p2 * p3 + p4 * z - (z / (fn4 ( 3 )))) ELSEIF @zfunc ==25 complex z = (p6 )+ #pi * e ^ z / ((fn4 ( 4 / (p2 )- #e )/ ((cotanh ( p6 )^ (fn3 ( p3 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ z ^ e )+ 2 ^ (4 )))) ELSEIF @zfunc ==26 complex z = p1 + #e - p3 / (p1 / #pi )^ (3 * (z * p2 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ (fn4 ( 4 )) ELSEIF @zfunc ==27 complex z = z ^ cotanh ( 2 / (z ^ 2 + p5 )/ #pi / ((log ( 1 )))) ELSEIF @zfunc ==28 complex z = (z - 4 ^ (z ^ 2 ^ (z / p2 )- (1 / z ))) ELSEIF @zfunc ==29 complex z = (round ( z - p5 )* fn3 ( z ^ p2 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ 1 / z + fn3 ( p5 ^ (1 / z ^ z )) ELSEIF @zfunc ==30 complex z = z / p2 + z^#pi/(z*#pi) ^ (z / p2 )^ z ^ 2 + p1 ^ z*#pi/(z^#pi) - (z * cos ( z ^ (fn1 ( z * p6 )+ (3 - (p1 ))))) ELSEIF @zfunc ==31 complex z = z - fn1 ( z * p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) * (1 / p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z / (trunc ( z * p3 )/ #e )* 3 / (p6 ) ELSEIF @zfunc ==32 complex z = (z / p5 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + z ^ e ^ (z ^ p6 )^ #e / (z / (fn3 ( (cotan ( 2 + (z / fn4 ( z ^ 2 + p1 ))))))) ELSEIF @zfunc ==33 complex z = p2 + z ^ e ^ (conj ( 2 / (p2 )/ (cabs ( z - z ^ (asinh ( p4 )- p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ #pi )/ (1 * (p3 ))))) ELSEIF @zfunc ==34 complex z = z - (fn4 ( z ^ p4 )+ z ^ e )/ (z / p4 )+ z ^ p1 + z ^ p2 * p3 + p4 * z - ((cotanh ( z + p2 )^ z )) ELSEIF @zfunc ==35 complex z = (z ^ 3 ^ (p6 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ z ^ z ^ z * p3 - (p3 * #screenpixel - z ^ p2 )^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + (#screenpixel ) ELSEIF @zfunc ==36 complex z = (p3 )+ z*#pi/(z^#pi) * (fn2 ( z - acosh ( 2 + z - 1 - (p3 )/ #e )+ (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ))) ELSEIF @zfunc ==37 complex z = (p2 - z ^ p1 + z ^ p2 * p3 + p4 * z )/ z*#pi/(z^#pi) + (fn4 ( z * p2 )/ e ^ z )+ p2 ^ #pi - (z / z ^ 2 + p1 ) ELSEIF @zfunc ==38 complex z = (p5 )/ ((fn2 ( z * p3 )^ ((fn1 ( z / p2 )- #pi )+ #e )^ (acosh ( 3 ^ (exp ( 1 )))))) ELSEIF @zfunc ==39 complex z = z ^ 3 - (z ^ z ^ (asinh ( p5 )+ #pi )+ fn3 ( p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z + z ) ELSEIF @zfunc ==40 complex z = 4 * (p3 * z ^ 2 + p1 )/ (z - p2 )* ((fn3 ( p5 )/ z ^ 2 + p1 )- fn1 ( 1 + ((fn3 ( #screenpixel ))))) ELSEIF @zfunc ==41 complex z = (z + p3 )* e ^ z * (fn1 ( 1 * (z / (fn4 ( z + p6 )- #screenpixel )^ #e )^ z * (fn1 ( 1 ^ z - (fn3 ( 3 ^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )))))) ELSEIF @zfunc ==42 complex z = z * (fn3 ( (fn3 ( tanh ( z ^ p3 )- z ^ p1 + z ^ p2 * p3 + p4 * z )+ (cotan ( p4 ))))) ELSEIF @zfunc ==43 complex z = (p1 )^ #e / (z ^ p4 + (2 / (z / p4 )+ z*#pi/(z^#pi) )^ fn3 ( z / fn1 ( 2 - 2 ))) ELSEIF @zfunc ==44 complex z = p6 + #pi ^ z / ((acosh ( 1 / z - p4 )- #pi )/ z*#pi/(z^#pi) )^ 3 * p4 - 1 / z + (z / p3 )^ z ^ e * p6 ELSEIF @zfunc ==45 complex z = (p6 ^ #pi ^ (z * p2 )+ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + #pi )- (fn2 ( z - p3 )/ #screenpixel )/ e ^ z / (z + p5 )- z ^ p1 + z ^ p2 * p3 + p4 * z / #e + (fn1 ( z * p4 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )* z ^ e * (3 / (p1 )) ELSEIF @zfunc ==46 complex z = (z / p3 )^ (fn4 ( p1 )/ (z - 1 + (z - p4 )/ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ z ^ e )/ p3 / (#pi ^ z ) ELSEIF @zfunc ==47 complex z = z * p3 + p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ^ (trunc ( z * p6 )/ z ^ 2 + p1 )+ (z - 1 ^ z + 2 - p3 ) ELSEIF @zfunc ==48 complex z = (z - p3 / ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- 1 - (4 + z ^ p1 )^ 1 / z ^ z - p2 / z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z ^ (z^#pi/(z*#pi) ) ELSEIF @zfunc ==49 complex z = (z * p4 )/ (z + z * (fn2 ( z / p1 )/ z - p5 )- z ^ z )+ ((fn2 ( z ^ e ))) ELSEIF @zfunc ==50 complex z = (z - fn4 ( fn1 ( 3 / p5 )- z ^ z )- (1 / ((fn2 ( p2 )- z*#pi/(z^#pi) )- ((fn3 ( z )))))) ELSEIF @zfunc ==51 complex z = 0 ENDIF IF @rfunc == 0 complex ra = #pi ELSEIF @rfunc ==1 complex ra = z ^ conj ( 4 / (p5 )* #screenpixel )/ #e * (fn1 ( 2 * (#e ))) ELSEIF @rfunc ==2 complex ra = (z - p3 / #pi )* (1 ^ (z / (sqr ( e ^ z )))) ELSEIF @rfunc ==3 complex ra = (z / log ( p6 )+ #pi * (p2 )/ (p3 )/ ((fn2 ( z ^ p2 )+ #random )/ (z^#pi/(z*#pi) ))) ELSEIF @rfunc ==4 complex ra = (z ^ (fn1 ( z * z - (flip ( p5 )/ #pi ^ z )^ z - p3 )- z )+ (1 / z )) ELSEIF @rfunc ==5 complex ra = p3 + #y * (fn1 ( z * p1 )/ (atanh ( 4 + (fn4 ( p4 ))))) ELSEIF @rfunc ==6 complex ra = z / p4 / #pi - (fn3 ( 4 / (p3 )/ e ^ z )* (z ^ p1 )/ #y )* z ^ e ^ (fn4 ( 1 / (p4 )^ #screenpixel )/ z ^ z ^ ((fn2 ( z )))) ELSEIF @rfunc ==7 complex ra = (z * p6 / #e )/ fn1 ( z / 4 + (p4 )- #y )+ z ^ e * (fn3 ( z * p6 )+ 1 + (p4 )/ z*#pi/(z^#pi) )+ fn4 ( 2 / (z )) ELSEIF @rfunc ==8 complex ra = (z + fn2 ( z + p5 )/ z^#pi/(z*#pi) ^ ((ident ( 2 - z ^ fn1 ( 4 ^ (z )))))) ELSEIF @rfunc ==9 complex ra = z ^ p6 / #y - #e - (cos ( z ^ p3 )/ (2 + (z * z - fn2 ( z )))) ELSEIF @rfunc ==10 complex ra = p4 ^ z - (z ^ z - p6 )/ #pi ^ e ^ z * (fn4 ( z ^ p6 )^ z ^ #e )* (p1 )- #y ^ 1 / z * fn3 ( #x ) ELSEIF @rfunc ==11 complex ra = (p3 - (z / fn3 ( p2 )* 2 + atan ( p4 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )- e ^ z )* (z ^ p1 + z ^ p2 * p3 + p4 * z ) ELSEIF @rfunc ==12 complex ra = p2 / (flip ( 1 / (p5 )^ z ^ 2 + p1 )* 1 / z )* z * p1 ^ z ^ 2 + p1 - #e - (z ^ p6 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) / z^#pi/(z*#pi) - ((fn4 ( 4 ))) ELSEIF @rfunc ==13 complex ra = (z + p2 )- z ^ p1 + z ^ p2 * p3 + p4 * z - #e - ((fn1 ( z / p5 )- ((fn4 ( 2 - z ))))) ELSEIF @rfunc ==14 complex ra = (fn2 ( p2 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ (fn1 ( p6 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ z - fn3 ( flip ( 4 - z )) ELSEIF @rfunc ==15 complex ra = ((fn3 ( z + p6 )^ #pi )/ e ^ z / (atan2 ( p3 )/ z ^ p1 + z ^ p2 * p3 + p4 * z )^ #pi ^ z / (z - p3 )* ((tanh ( 2 )))) ELSEIF @rfunc ==16 complex ra = z * p3 / z ^ 2 + p1 - (z + p4 / #pi )^ #e / exp ( ident ( 4 + p4 )^ #screenpixel ^ (#pi )) ELSEIF @rfunc ==17 complex ra = (p6 )/ (ident ( 4 + (z + p1 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )^ e ^ z )- 2 + z - fn4 ( 3 ^ ((fn2 ( 1 )))) ELSEIF @rfunc ==18 complex ra = (p5 * (fn2 ( p1 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- (1 + (fn3 ( 1 * (fn3 ( z - p5 )+ #pi )/ #pi )/ 4 * (z^#pi/(z*#pi) )))) ELSEIF @rfunc ==19 complex ra = (p6 )^ z ^ e ^ (fn3 ( z + z - p5 )* (fn1 ( z ^ p6 )- p6 )- z ^ p1 + z ^ p2 * p3 + p4 * z )- z^#pi/(z*#pi) * (fn1 ( p2 )) ELSEIF @rfunc ==20 complex ra = (p4 )- 1 / z ^ p2 * z / p5 * (p4 )/ e ^ z / (z * p5 * #screenpixel ^ (fn4 ( z^#pi/(z*#pi) ))) ELSEIF @rfunc ==21 complex ra = (p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) / z ^ z * ((fn2 ( z - p5 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )* #pi ^ z )^ p4 / p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + (p3 )- #pi / (p4 + #screenpixel * z ^ e )/ (4 * (#pi )) ELSEIF @rfunc ==22 complex ra = (2 / z ^ p2 * z ^ 2 + p1 )^ (3 - z ^ (fn2 ( p5 )^ z ^ 2 + p1 )/ 1 / z / (conj ( p6 ))) ELSEIF @rfunc ==23 complex ra = p3 + #screenpixel - e ^ z - (z * (fn4 ( z / p5 )* (fn4 ( z - p2 )/ z ^ e )* (fn2 ( p2 )- #screenpixel )* z*#pi/(z^#pi) )- fn4 ( 4 / (z ^ z ))) ELSEIF @rfunc ==24 complex ra = ((fn2 ( p1 )^ z / p1 )^ z ^ p1 + z ^ p2 * p3 + p4 * z - (z / (fn4 ( 3 )))) ELSEIF @rfunc ==25 complex ra = (p6 )+ #pi * e ^ z / ((fn4 ( 4 / (p2 )- #e )/ ((cotanh ( p6 )^ (fn3 ( p3 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ z ^ e )+ 2 ^ (4 )))) ELSEIF @rfunc ==26 complex ra = p1 + #e - p3 / (p1 / #pi )^ (3 * (z * p2 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ (fn4 ( 4 )) ELSEIF @rfunc ==27 complex ra = z ^ cotanh ( 2 / (z ^ 2 + p5 )/ #pi / ((log ( 1 )))) ELSEIF @rfunc ==28 complex ra = (z - 4 ^ (z ^ 2 ^ (z / p2 )- (1 / z ))) ELSEIF @rfunc ==29 complex ra = (round ( z - p5 )* fn3 ( z ^ p2 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ 1 / z + fn3 ( p5 ^ (1 / z ^ z )) ELSEIF @rfunc ==30 complex ra = z / p2 + z^#pi/(z*#pi) ^ (z / p2 )^ z ^ 2 + p1 ^ z*#pi/(z^#pi) - (z * cos ( z ^ (fn1 ( z * p6 )+ (3 - (p1 ))))) ELSEIF @rfunc ==31 complex ra = z - fn1 ( z * p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) * (1 / p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z / (trunc ( z * p3 )/ #e )* 3 / (p6 ) ELSEIF @rfunc ==32 complex ra = (z / p5 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + z ^ e ^ (z ^ p6 )^ #e / (z / (fn3 ( (cotan ( 2 + (z / fn4 ( z ^ 2 + p1 ))))))) ELSEIF @rfunc ==33 complex ra = p2 + z ^ e ^ (conj ( 2 / (p2 )/ (cabs ( z - z ^ (asinh ( p4 )- p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ #pi )/ (1 * (p3 ))))) ELSEIF @rfunc ==34 complex ra = z - (fn4 ( z ^ p4 )+ z ^ e )/ (z / p4 )+ z ^ p1 + z ^ p2 * p3 + p4 * z - ((cotanh ( z + p2 )^ z )) ELSEIF @rfunc ==35 complex ra = (z ^ 3 ^ (p6 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ z ^ z ^ z * p3 - (p3 * #screenpixel - z ^ p2 )^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + (#screenpixel ) ELSEIF @rfunc ==36 complex ra = (p3 )+ z*#pi/(z^#pi) * (fn2 ( z - acosh ( 2 + z - 1 - (p3 )/ #e )+ (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ))) ELSEIF @rfunc ==37 complex ra = (p2 - z ^ p1 + z ^ p2 * p3 + p4 * z )/ z*#pi/(z^#pi) + (fn4 ( z * p2 )/ e ^ z )+ p2 ^ #pi - (z / z ^ 2 + p1 ) ELSEIF @rfunc ==38 complex ra = (p5 )/ ((fn2 ( z * p3 )^ ((fn1 ( z / p2 )- #pi )+ #e )^ (acosh ( 3 ^ (exp ( 1 )))))) ELSEIF @rfunc ==39 complex ra = z ^ 3 - (z ^ z ^ (asinh ( p5 )+ #pi )+ fn3 ( p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z + z ) ELSEIF @rfunc ==40 complex ra = 4 * (p3 * z ^ 2 + p1 )/ (z - p2 )* ((fn3 ( p5 )/ z ^ 2 + p1 )- fn1 ( 1 + ((fn3 ( #screenpixel ))))) ELSEIF @rfunc ==41 complex ra = (z + p3 )* e ^ z * (fn1 ( 1 * (z / (fn4 ( z + p6 )- #screenpixel )^ #e )^ z * (fn1 ( 1 ^ z - (fn3 ( 3 ^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )))))) ELSEIF @rfunc ==42 complex ra = z * (fn3 ( (fn3 ( tanh ( z ^ p3 )- z ^ p1 + z ^ p2 * p3 + p4 * z )+ (cotan ( p4 ))))) ELSEIF @rfunc ==43 complex ra = (p1 )^ #e / (z ^ p4 + (2 / (z / p4 )+ z*#pi/(z^#pi) )^ fn3 ( z / fn1 ( 2 - 2 ))) ELSEIF @rfunc ==44 complex ra = p6 + #pi ^ z / ((acosh ( 1 / z - p4 )- #pi )/ z*#pi/(z^#pi) )^ 3 * p4 - 1 / z + (z / p3 )^ z ^ e * p6 ELSEIF @rfunc ==45 complex ra = (p6 ^ #pi ^ (z * p2 )+ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + #pi )- (fn2 ( z - p3 )/ #screenpixel )/ e ^ z / (z + p5 )- z ^ p1 + z ^ p2 * p3 + p4 * z / #e + (fn1 ( z * p4 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )* z ^ e * (3 / (p1 )) ELSEIF @rfunc ==46 complex ra = (z / p3 )^ (fn4 ( p1 )/ (z - 1 + (z - p4 )/ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ z ^ e )/ p3 / (#pi ^ z ) ELSEIF @rfunc ==47 complex ra = z * p3 + p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ^ (trunc ( z * p6 )/ z ^ 2 + p1 )+ (z - 1 ^ z + 2 - p3 ) ELSEIF @rfunc ==48 complex ra = (z - p3 / ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- 1 - (4 + z ^ p1 )^ 1 / z ^ z - p2 / z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z ^ (z^#pi/(z*#pi) ) ELSEIF @rfunc ==49 complex ra = (z * p4 )/ (z + z * (fn2 ( z / p1 )/ z - p5 )- z ^ z )+ ((fn2 ( z ^ e ))) ELSEIF @rfunc ==50 complex ra = (z - fn4 ( fn1 ( 3 / p5 )- z ^ z )- (1 / ((fn2 ( p2 )- z*#pi/(z^#pi) )- ((fn3 ( z )))))) ELSEIF @rfunc ==51 complex ra = 0 ENDIF IF @gfunc== 0 complex ga = #pi ELSEIF @gfunc ==1 complex ga = z ^ conj ( 4 / (p5 )* #screenpixel )/ #e * (fn1 ( 2 * (#e ))) ELSEIF @gfunc ==2 complex ga = (z - p3 / #pi )* (1 ^ (z / (sqr ( e ^ z )))) ELSEIF @gfunc ==3 complex ga = (z / log ( p6 )+ #pi * (p2 )/ (p3 )/ ((fn2 ( z ^ p2 )+ #random )/ (z^#pi/(z*#pi) ))) ELSEIF @gfunc ==4 complex ga = (z ^ (fn1 ( z * z - (flip ( p5 )/ #pi ^ z )^ z - p3 )- z )+ (1 / z )) ELSEIF @gfunc ==5 complex ga = p3 + #y * (fn1 ( z * p1 )/ (atanh ( 4 + (fn4 ( p4 ))))) ELSEIF @gfunc ==6 complex ga = z / p4 / #pi - (fn3 ( 4 / (p3 )/ e ^ z )* (z ^ p1 )/ #y )* z ^ e ^ (fn4 ( 1 / (p4 )^ #screenpixel )/ z ^ z ^ ((fn2 ( z )))) ELSEIF @gfunc ==7 complex ga = (z * p6 / #e )/ fn1 ( z / 4 + (p4 )- #y )+ z ^ e * (fn3 ( z * p6 )+ 1 + (p4 )/ z*#pi/(z^#pi) )+ fn4 ( 2 / (z )) ELSEIF @gfunc ==8 complex ga = (z + fn2 ( z + p5 )/ z^#pi/(z*#pi) ^ ((ident ( 2 - z ^ fn1 ( 4 ^ (z )))))) ELSEIF @gfunc ==9 complex ga = z ^ p6 / #y - #e - (cos ( z ^ p3 )/ (2 + (z * z - fn2 ( z )))) ELSEIF @gfunc ==10 complex ga = p4 ^ z - (z ^ z - p6 )/ #pi ^ e ^ z * (fn4 ( z ^ p6 )^ z ^ #e )* (p1 )- #y ^ 1 / z * fn3 ( #x ) ELSEIF @gfunc ==11 complex ga = (p3 - (z / fn3 ( p2 )* 2 + atan ( p4 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )- e ^ z )* (z ^ p1 + z ^ p2 * p3 + p4 * z ) ELSEIF @gfunc ==12 complex ga = p2 / (flip ( 1 / (p5 )^ z ^ 2 + p1 )* 1 / z )* z * p1 ^ z ^ 2 + p1 - #e - (z ^ p6 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) / z^#pi/(z*#pi) - ((fn4 ( 4 ))) ELSEIF @gfunc ==13 complex ga = (z + p2 )- z ^ p1 + z ^ p2 * p3 + p4 * z - #e - ((fn1 ( z / p5 )- ((fn4 ( 2 - z ))))) ELSEIF @gfunc ==14 complex ga = (fn2 ( p2 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ (fn1 ( p6 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ z - fn3 ( flip ( 4 - z )) ELSEIF @gfunc ==15 complex ga = ((fn3 ( z + p6 )^ #pi )/ e ^ z / (atan2 ( p3 )/ z ^ p1 + z ^ p2 * p3 + p4 * z )^ #pi ^ z / (z - p3 )* ((tanh ( 2 )))) ELSEIF @gfunc ==16 complex ga = z * p3 / z ^ 2 + p1 - (z + p4 / #pi )^ #e / exp ( ident ( 4 + p4 )^ #screenpixel ^ (#pi )) ELSEIF @gfunc ==17 complex ga = (p6 )/ (ident ( 4 + (z + p1 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )^ e ^ z )- 2 + z - fn4 ( 3 ^ ((fn2 ( 1 )))) ELSEIF @gfunc ==18 complex ga = (p5 * (fn2 ( p1 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- (1 + (fn3 ( 1 * (fn3 ( z - p5 )+ #pi )/ #pi )/ 4 * (z^#pi/(z*#pi) )))) ELSEIF @gfunc ==19 complex ga = (p6 )^ z ^ e ^ (fn3 ( z + z - p5 )* (fn1 ( z ^ p6 )- p6 )- z ^ p1 + z ^ p2 * p3 + p4 * z )- z^#pi/(z*#pi) * (fn1 ( p2 )) ELSEIF @gfunc ==20 complex ga = (p4 )- 1 / z ^ p2 * z / p5 * (p4 )/ e ^ z / (z * p5 * #screenpixel ^ (fn4 ( z^#pi/(z*#pi) ))) ELSEIF @gfunc ==21 complex ga = (p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) / z ^ z * ((fn2 ( z - p5 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )* #pi ^ z )^ p4 / p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + (p3 )- #pi / (p4 + #screenpixel * z ^ e )/ (4 * (#pi )) ELSEIF @gfunc ==22 complex ga = (2 / z ^ p2 * z ^ 2 + p1 )^ (3 - z ^ (fn2 ( p5 )^ z ^ 2 + p1 )/ 1 / z / (conj ( p6 ))) ELSEIF @gfunc ==23 complex ga = p3 + #screenpixel - e ^ z - (z * (fn4 ( z / p5 )* (fn4 ( z - p2 )/ z ^ e )* (fn2 ( p2 )- #screenpixel )* z*#pi/(z^#pi) )- fn4 ( 4 / (z ^ z ))) ELSEIF @gfunc ==24 complex ga = ((fn2 ( p1 )^ z / p1 )^ z ^ p1 + z ^ p2 * p3 + p4 * z - (z / (fn4 ( 3 )))) ELSEIF @gfunc ==25 complex ga = (p6 )+ #pi * e ^ z / ((fn4 ( 4 / (p2 )- #e )/ ((cotanh ( p6 )^ (fn3 ( p3 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ z ^ e )+ 2 ^ (4 )))) ELSEIF @gfunc ==26 complex ga = p1 + #e - p3 / (p1 / #pi )^ (3 * (z * p2 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ (fn4 ( 4 )) ELSEIF @gfunc ==27 complex ga = z ^ cotanh ( 2 / (z ^ 2 + p5 )/ #pi / ((log ( 1 )))) ELSEIF @gfunc ==28 complex ga = (z - 4 ^ (z ^ 2 ^ (z / p2 )- (1 / z ))) ELSEIF @gfunc ==29 complex ga = (round ( z - p5 )* fn3 ( z ^ p2 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ 1 / z + fn3 ( p5 ^ (1 / z ^ z )) ELSEIF @gfunc ==30 complex ga = z / p2 + z^#pi/(z*#pi) ^ (z / p2 )^ z ^ 2 + p1 ^ z*#pi/(z^#pi) - (z * cos ( z ^ (fn1 ( z * p6 )+ (3 - (p1 ))))) ELSEIF @gfunc ==31 complex ga = z - fn1 ( z * p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) * (1 / p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z / (trunc ( z * p3 )/ #e )* 3 / (p6 ) ELSEIF @gfunc ==32 complex ga = (z / p5 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + z ^ e ^ (z ^ p6 )^ #e / (z / (fn3 ( (cotan ( 2 + (z / fn4 ( z ^ 2 + p1 ))))))) ELSEIF @gfunc ==33 complex ga = p2 + z ^ e ^ (conj ( 2 / (p2 )/ (cabs ( z - z ^ (asinh ( p4 )- p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ #pi )/ (1 * (p3 ))))) ELSEIF @gfunc ==34 complex ga = z - (fn4 ( z ^ p4 )+ z ^ e )/ (z / p4 )+ z ^ p1 + z ^ p2 * p3 + p4 * z - ((cotanh ( z + p2 )^ z )) ELSEIF @gfunc ==35 complex ga = (z ^ 3 ^ (p6 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ z ^ z ^ z * p3 - (p3 * #screenpixel - z ^ p2 )^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + (#screenpixel ) ELSEIF @gfunc ==36 complex ga = (p3 )+ z*#pi/(z^#pi) * (fn2 ( z - acosh ( 2 + z - 1 - (p3 )/ #e )+ (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ))) ELSEIF @gfunc ==37 complex ga = (p2 - z ^ p1 + z ^ p2 * p3 + p4 * z )/ z*#pi/(z^#pi) + (fn4 ( z * p2 )/ e ^ z )+ p2 ^ #pi - (z / z ^ 2 + p1 ) ELSEIF @gfunc ==38 complex ga = (p5 )/ ((fn2 ( z * p3 )^ ((fn1 ( z / p2 )- #pi )+ #e )^ (acosh ( 3 ^ (exp ( 1 )))))) ELSEIF @gfunc ==39 complex ga = z ^ 3 - (z ^ z ^ (asinh ( p5 )+ #pi )+ fn3 ( p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z + z ) ELSEIF @gfunc ==40 complex ga = 4 * (p3 * z ^ 2 + p1 )/ (z - p2 )* ((fn3 ( p5 )/ z ^ 2 + p1 )- fn1 ( 1 + ((fn3 ( #screenpixel ))))) ELSEIF @gfunc ==41 complex ga = (z + p3 )* e ^ z * (fn1 ( 1 * (z / (fn4 ( z + p6 )- #screenpixel )^ #e )^ z * (fn1 ( 1 ^ z - (fn3 ( 3 ^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )))))) ELSEIF @gfunc ==42 complex ga = z * (fn3 ( (fn3 ( tanh ( z ^ p3 )- z ^ p1 + z ^ p2 * p3 + p4 * z )+ (cotan ( p4 ))))) ELSEIF @gfunc ==43 complex ga = (p1 )^ #e / (z ^ p4 + (2 / (z / p4 )+ z*#pi/(z^#pi) )^ fn3 ( z / fn1 ( 2 - 2 ))) ELSEIF @gfunc ==44 complex ga = p6 + #pi ^ z / ((acosh ( 1 / z - p4 )- #pi )/ z*#pi/(z^#pi) )^ 3 * p4 - 1 / z + (z / p3 )^ z ^ e * p6 ELSEIF @gfunc ==45 complex ga = (p6 ^ #pi ^ (z * p2 )+ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + #pi )- (fn2 ( z - p3 )/ #screenpixel )/ e ^ z / (z + p5 )- z ^ p1 + z ^ p2 * p3 + p4 * z / #e + (fn1 ( z * p4 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )* z ^ e * (3 / (p1 )) ELSEIF @gfunc ==46 complex ga = (z / p3 )^ (fn4 ( p1 )/ (z - 1 + (z - p4 )/ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ z ^ e )/ p3 / (#pi ^ z ) ELSEIF @gfunc ==47 complex ga = z * p3 + p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ^ (trunc ( z * p6 )/ z ^ 2 + p1 )+ (z - 1 ^ z + 2 - p3 ) ELSEIF @gfunc ==48 complex ga = (z - p3 / ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- 1 - (4 + z ^ p1 )^ 1 / z ^ z - p2 / z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z ^ (z^#pi/(z*#pi) ) ELSEIF @gfunc ==49 complex ga = (z * p4 )/ (z + z * (fn2 ( z / p1 )/ z - p5 )- z ^ z )+ ((fn2 ( z ^ e ))) ELSEIF @gfunc ==50 complex ga = (z - fn4 ( fn1 ( 3 / p5 )- z ^ z )- (1 / ((fn2 ( p2 )- z*#pi/(z^#pi) )- ((fn3 ( z )))))) ELSEIF @gfunc ==51 complex ga = 0 ENDIF IF @bfunc== 0 complex ba = #pi ELSEIF @bfunc ==1 complex ba = z ^ conj ( 4 / (p5 )* #screenpixel )/ #e * (fn1 ( 2 * (#e ))) ELSEIF @bfunc ==2 complex ba = (z - p3 / #pi )* (1 ^ (z / (sqr ( e ^ z )))) ELSEIF @bfunc ==3 complex ba = (z / log ( p6 )+ #pi * (p2 )/ (p3 )/ ((fn2 ( z ^ p2 )+ #random )/ (z^#pi/(z*#pi) ))) ELSEIF @bfunc ==4 complex ba = (z ^ (fn1 ( z * z - (flip ( p5 )/ #pi ^ z )^ z - p3 )- z )+ (1 / z )) ELSEIF @bfunc ==5 complex ba = p3 + #y * (fn1 ( z * p1 )/ (atanh ( 4 + (fn4 ( p4 ))))) ELSEIF @bfunc ==6 complex ba = z / p4 / #pi - (fn3 ( 4 / (p3 )/ e ^ z )* (z ^ p1 )/ #y )* z ^ e ^ (fn4 ( 1 / (p4 )^ #screenpixel )/ z ^ z ^ ((fn2 ( z )))) ELSEIF @bfunc ==7 complex ba = (z * p6 / #e )/ fn1 ( z / 4 + (p4 )- #y )+ z ^ e * (fn3 ( z * p6 )+ 1 + (p4 )/ z*#pi/(z^#pi) )+ fn4 ( 2 / (z )) ELSEIF @bfunc ==8 complex ba = (z + fn2 ( z + p5 )/ z^#pi/(z*#pi) ^ ((ident ( 2 - z ^ fn1 ( 4 ^ (z )))))) ELSEIF @bfunc ==9 complex ba = z ^ p6 / #y - #e - (cos ( z ^ p3 )/ (2 + (z * z - fn2 ( z )))) ELSEIF @bfunc ==10 complex ba = p4 ^ z - (z ^ z - p6 )/ #pi ^ e ^ z * (fn4 ( z ^ p6 )^ z ^ #e )* (p1 )- #y ^ 1 / z * fn3 ( #x ) ELSEIF @bfunc ==11 complex ba = (p3 - (z / fn3 ( p2 )* 2 + atan ( p4 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )- e ^ z )* (z ^ p1 + z ^ p2 * p3 + p4 * z ) ELSEIF @bfunc ==12 complex ba = p2 / (flip ( 1 / (p5 )^ z ^ 2 + p1 )* 1 / z )* z * p1 ^ z ^ 2 + p1 - #e - (z ^ p6 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) / z^#pi/(z*#pi) - ((fn4 ( 4 ))) ELSEIF @bfunc ==13 complex ba = (z + p2 )- z ^ p1 + z ^ p2 * p3 + p4 * z - #e - ((fn1 ( z / p5 )- ((fn4 ( 2 - z ))))) ELSEIF @bfunc ==14 complex ba = (fn2 ( p2 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ (fn1 ( p6 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ z - fn3 ( flip ( 4 - z )) ELSEIF @bfunc ==15 complex ba = ((fn3 ( z + p6 )^ #pi )/ e ^ z / (atan2 ( p3 )/ z ^ p1 + z ^ p2 * p3 + p4 * z )^ #pi ^ z / (z - p3 )* ((tanh ( 2 )))) ELSEIF @bfunc ==16 complex ba = z * p3 / z ^ 2 + p1 - (z + p4 / #pi )^ #e / exp ( ident ( 4 + p4 )^ #screenpixel ^ (#pi )) ELSEIF @bfunc ==17 complex ba = (p6 )/ (ident ( 4 + (z + p1 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )^ e ^ z )- 2 + z - fn4 ( 3 ^ ((fn2 ( 1 )))) ELSEIF @bfunc ==18 complex ba = (p5 * (fn2 ( p1 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- (1 + (fn3 ( 1 * (fn3 ( z - p5 )+ #pi )/ #pi )/ 4 * (z^#pi/(z*#pi) )))) ELSEIF @bfunc ==19 complex ba = (p6 )^ z ^ e ^ (fn3 ( z + z - p5 )* (fn1 ( z ^ p6 )- p6 )- z ^ p1 + z ^ p2 * p3 + p4 * z )- z^#pi/(z*#pi) * (fn1 ( p2 )) ELSEIF @bfunc ==20 complex ba = (p4 )- 1 / z ^ p2 * z / p5 * (p4 )/ e ^ z / (z * p5 * #screenpixel ^ (fn4 ( z^#pi/(z*#pi) ))) ELSEIF @bfunc ==21 complex ba = (p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) / z ^ z * ((fn2 ( z - p5 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )* #pi ^ z )^ p4 / p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + (p3 )- #pi / (p4 + #screenpixel * z ^ e )/ (4 * (#pi )) ELSEIF @bfunc ==22 complex ba = (2 / z ^ p2 * z ^ 2 + p1 )^ (3 - z ^ (fn2 ( p5 )^ z ^ 2 + p1 )/ 1 / z / (conj ( p6 ))) ELSEIF @bfunc ==23 complex ba = p3 + #screenpixel - e ^ z - (z * (fn4 ( z / p5 )* (fn4 ( z - p2 )/ z ^ e )* (fn2 ( p2 )- #screenpixel )* z*#pi/(z^#pi) )- fn4 ( 4 / (z ^ z ))) ELSEIF @bfunc ==24 complex ba = ((fn2 ( p1 )^ z / p1 )^ z ^ p1 + z ^ p2 * p3 + p4 * z - (z / (fn4 ( 3 )))) ELSEIF @bfunc ==25 complex ba = (p6 )+ #pi * e ^ z / ((fn4 ( 4 / (p2 )- #e )/ ((cotanh ( p6 )^ (fn3 ( p3 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ z ^ e )+ 2 ^ (4 )))) ELSEIF @bfunc ==26 complex ba = p1 + #e - p3 / (p1 / #pi )^ (3 * (z * p2 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ (fn4 ( 4 )) ELSEIF @bfunc ==27 complex ba = z ^ cotanh ( 2 / (z ^ 2 + p5 )/ #pi / ((log ( 1 )))) ELSEIF @bfunc ==28 complex ba = (z - 4 ^ (z ^ 2 ^ (z / p2 )- (1 / z ))) ELSEIF @bfunc ==29 complex ba = (round ( z - p5 )* fn3 ( z ^ p2 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ 1 / z + fn3 ( p5 ^ (1 / z ^ z )) ELSEIF @bfunc ==30 complex ba = z / p2 + z^#pi/(z*#pi) ^ (z / p2 )^ z ^ 2 + p1 ^ z*#pi/(z^#pi) - (z * cos ( z ^ (fn1 ( z * p6 )+ (3 - (p1 ))))) ELSEIF @bfunc ==31 complex ba = z - fn1 ( z * p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) * (1 / p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z / (trunc ( z * p3 )/ #e )* 3 / (p6 ) ELSEIF @bfunc ==32 complex ba = (z / p5 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + z ^ e ^ (z ^ p6 )^ #e / (z / (fn3 ( (cotan ( 2 + (z / fn4 ( z ^ 2 + p1 ))))))) ELSEIF @bfunc ==33 complex ba = p2 + z ^ e ^ (conj ( 2 / (p2 )/ (cabs ( z - z ^ (asinh ( p4 )- p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ #pi )/ (1 * (p3 ))))) ELSEIF @bfunc ==34 complex ba = z - (fn4 ( z ^ p4 )+ z ^ e )/ (z / p4 )+ z ^ p1 + z ^ p2 * p3 + p4 * z - ((cotanh ( z + p2 )^ z )) ELSEIF @bfunc ==35 complex ba = (z ^ 3 ^ (p6 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ z ^ z ^ z * p3 - (p3 * #screenpixel - z ^ p2 )^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + (#screenpixel ) ELSEIF @bfunc ==36 complex ba = (p3 )+ z*#pi/(z^#pi) * (fn2 ( z - acosh ( 2 + z - 1 - (p3 )/ #e )+ (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ))) ELSEIF @bfunc ==37 complex ba = (p2 - z ^ p1 + z ^ p2 * p3 + p4 * z )/ z*#pi/(z^#pi) + (fn4 ( z * p2 )/ e ^ z )+ p2 ^ #pi - (z / z ^ 2 + p1 ) ELSEIF @bfunc ==38 complex ba = (p5 )/ ((fn2 ( z * p3 )^ ((fn1 ( z / p2 )- #pi )+ #e )^ (acosh ( 3 ^ (exp ( 1 )))))) ELSEIF @bfunc ==39 complex ba = z ^ 3 - (z ^ z ^ (asinh ( p5 )+ #pi )+ fn3 ( p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z + z ) ELSEIF @bfunc ==40 complex ba = 4 * (p3 * z ^ 2 + p1 )/ (z - p2 )* ((fn3 ( p5 )/ z ^ 2 + p1 )- fn1 ( 1 + ((fn3 ( #screenpixel ))))) ELSEIF @bfunc ==41 complex ba = (z + p3 )* e ^ z * (fn1 ( 1 * (z / (fn4 ( z + p6 )- #screenpixel )^ #e )^ z * (fn1 ( 1 ^ z - (fn3 ( 3 ^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )))))) ELSEIF @bfunc ==42 complex ba = z * (fn3 ( (fn3 ( tanh ( z ^ p3 )- z ^ p1 + z ^ p2 * p3 + p4 * z )+ (cotan ( p4 ))))) ELSEIF @bfunc ==43 complex ba = (p1 )^ #e / (z ^ p4 + (2 / (z / p4 )+ z*#pi/(z^#pi) )^ fn3 ( z / fn1 ( 2 - 2 ))) ELSEIF @bfunc ==44 complex ba = p6 + #pi ^ z / ((acosh ( 1 / z - p4 )- #pi )/ z*#pi/(z^#pi) )^ 3 * p4 - 1 / z + (z / p3 )^ z ^ e * p6 ELSEIF @bfunc ==45 complex ba = (p6 ^ #pi ^ (z * p2 )+ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + #pi )- (fn2 ( z - p3 )/ #screenpixel )/ e ^ z / (z + p5 )- z ^ p1 + z ^ p2 * p3 + p4 * z / #e + (fn1 ( z * p4 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )* z ^ e * (3 / (p1 )) ELSEIF @bfunc ==46 complex ba = (z / p3 )^ (fn4 ( p1 )/ (z - 1 + (z - p4 )/ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ z ^ e )/ p3 / (#pi ^ z ) ELSEIF @bfunc ==47 complex ba = z * p3 + p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ^ (trunc ( z * p6 )/ z ^ 2 + p1 )+ (z - 1 ^ z + 2 - p3 ) ELSEIF @bfunc ==48 complex ba = (z - p3 / ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- 1 - (4 + z ^ p1 )^ 1 / z ^ z - p2 / z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z ^ (z^#pi/(z*#pi) ) ELSEIF @bfunc ==49 complex ba = (z * p4 )/ (z + z * (fn2 ( z / p1 )/ z - p5 )- z ^ z )+ ((fn2 ( z ^ e ))) ELSEIF @bfunc ==50 complex ba = (z - fn4 ( fn1 ( 3 / p5 )- z ^ z )- (1 / ((fn2 ( p2 )- z*#pi/(z^#pi) )- ((fn3 ( z )))))) ELSEIF @bfunc ==51 complex ba = 0 ENDIF IF @afunc== 0 complex aa = #pi ELSEIF @afunc ==1 complex aa = z ^ conj ( 4 / (p5 )* #screenpixel )/ #e * (fn1 ( 2 * (#e ))) ELSEIF @afunc ==2 complex aa = (z - p3 / #pi )* (1 ^ (z / (sqr ( e ^ z )))) ELSEIF @afunc ==3 complex aa = (z / log ( p6 )+ #pi * (p2 )/ (p3 )/ ((fn2 ( z ^ p2 )+ #random )/ (z^#pi/(z*#pi) ))) ELSEIF @afunc ==4 complex aa = (z ^ (fn1 ( z * z - (flip ( p5 )/ #pi ^ z )^ z - p3 )- z )+ (1 / z )) ELSEIF @afunc ==5 complex aa = p3 + #y * (fn1 ( z * p1 )/ (atanh ( 4 + (fn4 ( p4 ))))) ELSEIF @afunc ==6 complex aa = z / p4 / #pi - (fn3 ( 4 / (p3 )/ e ^ z )* (z ^ p1 )/ #y )* z ^ e ^ (fn4 ( 1 / (p4 )^ #screenpixel )/ z ^ z ^ ((fn2 ( z )))) ELSEIF @afunc ==7 complex aa = (z * p6 / #e )/ fn1 ( z / 4 + (p4 )- #y )+ z ^ e * (fn3 ( z * p6 )+ 1 + (p4 )/ z*#pi/(z^#pi) )+ fn4 ( 2 / (z )) ELSEIF @afunc ==8 complex aa = (z + fn2 ( z + p5 )/ z^#pi/(z*#pi) ^ ((ident ( 2 - z ^ fn1 ( 4 ^ (z )))))) ELSEIF @afunc ==9 complex aa = z ^ p6 / #y - #e - (cos ( z ^ p3 )/ (2 + (z * z - fn2 ( z )))) ELSEIF @afunc ==10 complex aa = p4 ^ z - (z ^ z - p6 )/ #pi ^ e ^ z * (fn4 ( z ^ p6 )^ z ^ #e )* (p1 )- #y ^ 1 / z * fn3 ( #x ) ELSEIF @afunc ==11 complex aa = (p3 - (z / fn3 ( p2 )* 2 + atan ( p4 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )- e ^ z )* (z ^ p1 + z ^ p2 * p3 + p4 * z ) ELSEIF @afunc ==12 complex aa = p2 / (flip ( 1 / (p5 )^ z ^ 2 + p1 )* 1 / z )* z * p1 ^ z ^ 2 + p1 - #e - (z ^ p6 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) / z^#pi/(z*#pi) - ((fn4 ( 4 ))) ELSEIF @afunc ==13 complex aa = (z + p2 )- z ^ p1 + z ^ p2 * p3 + p4 * z - #e - ((fn1 ( z / p5 )- ((fn4 ( 2 - z ))))) ELSEIF @afunc ==14 complex aa = (fn2 ( p2 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ (fn1 ( p6 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ z - fn3 ( flip ( 4 - z )) ELSEIF @afunc ==15 complex aa = ((fn3 ( z + p6 )^ #pi )/ e ^ z / (atan2 ( p3 )/ z ^ p1 + z ^ p2 * p3 + p4 * z )^ #pi ^ z / (z - p3 )* ((tanh ( 2 )))) ELSEIF @afunc ==16 complex aa = z * p3 / z ^ 2 + p1 - (z + p4 / #pi )^ #e / exp ( ident ( 4 + p4 )^ #screenpixel ^ (#pi )) ELSEIF @afunc ==17 complex aa = (p6 )/ (ident ( 4 + (z + p1 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )^ e ^ z )- 2 + z - fn4 ( 3 ^ ((fn2 ( 1 )))) ELSEIF @afunc ==18 complex aa = (p5 * (fn2 ( p1 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- (1 + (fn3 ( 1 * (fn3 ( z - p5 )+ #pi )/ #pi )/ 4 * (z^#pi/(z*#pi) )))) ELSEIF @afunc ==19 complex aa = (p6 )^ z ^ e ^ (fn3 ( z + z - p5 )* (fn1 ( z ^ p6 )- p6 )- z ^ p1 + z ^ p2 * p3 + p4 * z )- z^#pi/(z*#pi) * (fn1 ( p2 )) ELSEIF @afunc ==20 complex aa = (p4 )- 1 / z ^ p2 * z / p5 * (p4 )/ e ^ z / (z * p5 * #screenpixel ^ (fn4 ( z^#pi/(z*#pi) ))) ELSEIF @afunc ==21 complex aa = (p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) / z ^ z * ((fn2 ( z - p5 )/ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )* #pi ^ z )^ p4 / p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + (p3 )- #pi / (p4 + #screenpixel * z ^ e )/ (4 * (#pi )) ELSEIF @afunc ==22 complex aa = (2 / z ^ p2 * z ^ 2 + p1 )^ (3 - z ^ (fn2 ( p5 )^ z ^ 2 + p1 )/ 1 / z / (conj ( p6 ))) ELSEIF @afunc ==23 complex aa = p3 + #screenpixel - e ^ z - (z * (fn4 ( z / p5 )* (fn4 ( z - p2 )/ z ^ e )* (fn2 ( p2 )- #screenpixel )* z*#pi/(z^#pi) )- fn4 ( 4 / (z ^ z ))) ELSEIF @afunc ==24 complex aa = ((fn2 ( p1 )^ z / p1 )^ z ^ p1 + z ^ p2 * p3 + p4 * z - (z / (fn4 ( 3 )))) ELSEIF @afunc ==25 complex aa = (p6 )+ #pi * e ^ z / ((fn4 ( 4 / (p2 )- #e )/ ((cotanh ( p6 )^ (fn3 ( p3 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ z ^ e )+ 2 ^ (4 )))) ELSEIF @afunc ==26 complex aa = p1 + #e - p3 / (p1 / #pi )^ (3 * (z * p2 )+ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )+ (fn4 ( 4 )) ELSEIF @afunc ==27 complex aa = z ^ cotanh ( 2 / (z ^ 2 + p5 )/ #pi / ((log ( 1 )))) ELSEIF @afunc ==28 complex aa = (z - 4 ^ (z ^ 2 ^ (z / p2 )- (1 / z ))) ELSEIF @afunc ==29 complex aa = (round ( z - p5 )* fn3 ( z ^ p2 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ 1 / z + fn3 ( p5 ^ (1 / z ^ z )) ELSEIF @afunc ==30 complex aa = z / p2 + z^#pi/(z*#pi) ^ (z / p2 )^ z ^ 2 + p1 ^ z*#pi/(z^#pi) - (z * cos ( z ^ (fn1 ( z * p6 )+ (3 - (p1 ))))) ELSEIF @afunc ==31 complex aa = z - fn1 ( z * p2 )* p1 * z * ( 1 - z ) ^ ( p2 - 1 ) * (1 / p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z / (trunc ( z * p3 )/ #e )* 3 / (p6 ) ELSEIF @afunc ==32 complex aa = (z / p5 )- ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + z ^ e ^ (z ^ p6 )^ #e / (z / (fn3 ( (cotan ( 2 + (z / fn4 ( z ^ 2 + p1 ))))))) ELSEIF @afunc ==33 complex aa = p2 + z ^ e ^ (conj ( 2 / (p2 )/ (cabs ( z - z ^ (asinh ( p4 )- p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )/ #pi )/ (1 * (p3 ))))) ELSEIF @afunc ==34 complex aa = z - (fn4 ( z ^ p4 )+ z ^ e )/ (z / p4 )+ z ^ p1 + z ^ p2 * p3 + p4 * z - ((cotanh ( z + p2 )^ z )) ELSEIF @afunc ==35 complex aa = (z ^ 3 ^ (p6 )+ z ^ p1 + z ^ p2 * p3 + p4 * z )+ z ^ z ^ z * p3 - (p3 * #screenpixel - z ^ p2 )^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) + (#screenpixel ) ELSEIF @afunc ==36 complex aa = (p3 )+ z*#pi/(z^#pi) * (fn2 ( z - acosh ( 2 + z - 1 - (p3 )/ #e )+ (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ))) ELSEIF @afunc ==37 complex aa = (p2 - z ^ p1 + z ^ p2 * p3 + p4 * z )/ z*#pi/(z^#pi) + (fn4 ( z * p2 )/ e ^ z )+ p2 ^ #pi - (z / z ^ 2 + p1 ) ELSEIF @afunc ==38 complex aa = (p5 )/ ((fn2 ( z * p3 )^ ((fn1 ( z / p2 )- #pi )+ #e )^ (acosh ( 3 ^ (exp ( 1 )))))) ELSEIF @afunc ==39 complex aa = z ^ 3 - (z ^ z ^ (asinh ( p5 )+ #pi )+ fn3 ( p2 )^ z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z + z ) ELSEIF @afunc ==40 complex aa = 4 * (p3 * z ^ 2 + p1 )/ (z - p2 )* ((fn3 ( p5 )/ z ^ 2 + p1 )- fn1 ( 1 + ((fn3 ( #screenpixel ))))) ELSEIF @afunc ==41 complex aa = (z + p3 )* e ^ z * (fn1 ( 1 * (z / (fn4 ( z + p6 )- #screenpixel )^ #e )^ z * (fn1 ( 1 ^ z - (fn3 ( 3 ^ ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )))))) ELSEIF @afunc ==42 complex aa = z * (fn3 ( (fn3 ( tanh ( z ^ p3 )- z ^ p1 + z ^ p2 * p3 + p4 * z )+ (cotan ( p4 ))))) ELSEIF @afunc ==43 complex aa = (p1 )^ #e / (z ^ p4 + (2 / (z / p4 )+ z*#pi/(z^#pi) )^ fn3 ( z / fn1 ( 2 - 2 ))) ELSEIF @afunc ==44 complex aa = p6 + #pi ^ z / ((acosh ( 1 / z - p4 )- #pi )/ z*#pi/(z^#pi) )^ 3 * p4 - 1 / z + (z / p3 )^ z ^ e * p6 ELSEIF @afunc ==45 complex aa = (p6 ^ #pi ^ (z * p2 )+ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + #pi )- (fn2 ( z - p3 )/ #screenpixel )/ e ^ z / (z + p5 )- z ^ p1 + z ^ p2 * p3 + p4 * z / #e + (fn1 ( z * p4 )^ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )* z ^ e * (3 / (p1 )) ELSEIF @afunc ==46 complex aa = (z / p3 )^ (fn4 ( p1 )/ (z - 1 + (z - p4 )/ p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )^ z ^ e )/ p3 / (#pi ^ z ) ELSEIF @afunc ==47 complex aa = z * p3 + p1 * z * ( 1 - z ) ^ ( p2 - 1 ) ^ (trunc ( z * p6 )/ z ^ 2 + p1 )+ (z - 1 ^ z + 2 - p3 ) ELSEIF @afunc ==48 complex aa = (z - p3 / ((p1 - 1) * z^p1 + @r) / (p1 * z ^ (p1 - 1)) )- 1 - (4 + z ^ p1 )^ 1 / z ^ z - p2 / z ^ p1 + z ^ p2 * p3 + p4 * z ^ e ^ z ^ (z^#pi/(z*#pi) ) ELSEIF @afunc ==49 complex aa = (z * p4 )/ (z + z * (fn2 ( z / p1 )/ z - p5 )- z ^ z )+ ((fn2 ( z ^ e ))) ELSEIF @afunc ==50 complex aa = (z - fn4 ( fn1 ( 3 / p5 )- z ^ z )- (1 / ((fn2 ( p2 )- z*#pi/(z^#pi) )- ((fn3 ( z )))))) ELSEIF @afunc ==51 complex aa = 0 ENDIF if @oper1 == 0 z = z endif if @oper1 == 1 z = z + ra endif if @oper1 == 2 z = z - ra endif if @oper1 == 3 z = z /ra endif if @oper1 == 4 z = z * ra endif if @oper1 == 5 z = z ^ ra endif if @oper2 == 0 z = z endif if @oper2 == 1 z = z + ga endif if @oper2 == 2 z = z - ga endif if @oper2 == 3 z = z / ga endif if @oper2 == 4 z = z * ga endif if @oper2 == 5 z = z ^ ga endif if @oper3 == 0 z = z endif if @oper3 == 1 z = z + ba endif if @oper3 == 2 z = z - ba endif if @oper3 == 3 z = z / ba endif if @oper3 == 4 z = z * ba endif if @oper3 == 5 z = z ^ ba endif if @oper4 == 0 z = z endif if @oper4 == 1 z = z + aa endif if @oper4 == 2 z = z - aa endif if @oper4 == 3 z = z /aa endif if @oper4 == 4 z = z * aa endif if @oper4 == 5 z = z ^ aa endif float h = (real(z)%#width) float i = (imag(z)%#height) complex j = (0,0) j = |h| + flip(imag(h)) j = |i| + flip(real(i)) #pixel = j default: title = "random10" heading caption = " Z Tweakers" endheading bool paramztweak1 caption = " 1/z" default = false endparam bool paramztweak2 caption = " z ^ 2 + p1" default = false endparam bool paramztweak3 caption = " p1 *z * ( 1 - z ) ^ ( p2 - 1 )" default = false endparam bool paramztweak4 caption = " z ^ p1 + z ^ p2 * #pi + p3 * z" default = false endparam bool paramztweak5 caption = " ((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" default = false endparam bool paramztweak6 caption = " sqr( (z^2 + #pi - 1) / (2*z + #pi - 2) )" default = false endparam bool paramztweak7 caption = " (p2 )+ fn1 ( 2 - z )" default = false endparam bool paramztweak8 caption = " z = z + p1 * (trunc ( #screenpixel ))" default = false endparam bool paramztweak9 caption = " (p3 )/ z" default = false endparam bool paramztweak10 caption = " #e ^ z" default = false endparam bool paramztweak11 caption = " z ^ #e" default = false endparam bool paramztweak12 caption = " z ^ #pi" default = false endparam bool paramztweak13 caption = " #pi ^ z" default = false endparam bool paramztweak14 caption = " #pi / z" default = false endparam bool paramztweak15 caption = " z / #pi" default = false endparam bool paramztweak16 caption = " p5 * fn1(z) * (z )" default = false endparam bool paramztweak17 caption = " (p3 )/ (fn1 ( z ))" default = false endparam bool paramztweak18 caption = " (z ^ p4 - e ^ z )" default = false endparam bool paramztweak19 caption = " (z ^ p6 )* #pi ^ 1 / z + (z*#pi/(z^#pi) )" default = false endparam bool paramztweak20 caption = " z * p2 + ((fn3 ( z )))" default = false endparam bool paramztweak21 caption = " z = z * z ^ 2 + p1" default = false endparam bool paramztweak22 caption = " p3 )+ #e * (fn2 ( 2 + (4 )))" default = false endparam bool paramztweak23 caption = " (z + 2 * z ^ 2 + p1 )" default = false endparam bool paramztweak24 caption = " z + (fn2 ( 4 ))" default = false endparam bool paramztweak25 caption = " ((fn1 ( z*#pi/(z^#pi) )))" default = false endparam bool paramztweak26 caption = " 4 / (p1 * z * ( 1 - z ) ^ ( p2 - 1 ) )" default = false endparam bool paramztweak27 caption = " 2 ^ z" default = false endparam bool paramztweak28 caption = " p5 ^ z / z - (z )" default = false endparam bool paramztweak29 caption = " z / fn3 ( 4 ^ p2 )" default = false endparam bool paramztweak30 caption = " ((fn2 ( z )))" default = false endparam bool paramztweak31 caption = " z * p5 * fn4 ( 4 ^ z ^ e )" default = false endparam bool paramztweak32 caption = " (z * #screenpixel )" default = false endparam bool paramztweak33 caption = " z*#pi/(z^#pi)" default = false endparam bool paramztweak34 caption = " (z * p6 ^ z ^ p1 + z ^ p2 * p3 + p4 * z )/ 3" default = false endparam bool paramztweak35 caption = " p6 + z ^ p1 + z ^ p2 * p3 + p4 * z - (3 * 1 )" default = false endparam bool paramztweak36 caption = " (z + z )" default = false endparam bool paramztweak37 caption = " (z + (fn4 ( #e )))" default = false endparam bool paramztweak38 caption = " (z + p6 )* #pi ^ z ^ e - (p6 )" default = false endparam bool paramztweak39 caption = " z ^ (z*#pi/(z^#pi) )" default = false endparam bool paramztweak40 caption = " (z * 4 )" default = false endparam bool paramztweak41 caption = " z + p2 - p1 * z * ( 1 - z ) ^ ( p2 - 1 ) + 1 / z - flip ( z )" default = false endparam bool paramztweak42 caption = " (p2 - ((fn1 ( 3 ^ z ))))" default = false endparam bool paramztweak43 caption = " (z * fn1(z) )" default = false endparam bool paramztweak44 caption = " z / p1 - #pi ^ z + (fn4 ( z ))" default = false endparam bool paramztweak45 caption = " (z + p3 * #e )^ (fn4 ( #pi ^ z ))" default = false endparam bool paramztweak46 caption = " (z / (exp ( z*#pi/(z^#pi) )))" default = false endparam bool paramztweak47 caption = " (z / (fn4 ( 1/z )))" default = false endparam bool paramztweak48 caption = " (z * 1 / (p5 ))" default = false endparam bool paramztweak49 caption = " (p2 )/ #screenpixel + 1 / z + (2 / z ^ 2 + p1 )" default = false endparam bool paramztweak50 caption = " (z * p6 )* z ^ e / fn1 ( z^#pi/(z*#pi) )" default = false endparam heading caption = " Z Function Options" endheading param zfunc caption = "Main Z Function Flavor" hint = "(0 = Pixel)" enum = "Pixel" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42" "43" "44" "45" "46" "47" "48" "49" "50" "Nothing" endparam heading caption = " Function 1 Options" endheading param rfunc caption = "Function 1 Flavor" hint = "(0 = Pixel)" enum = "Pixel" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42" "43" "44" "45" "46" "47" "48" "49" "50" "Nothing" endparam param oper1 caption = "Operation for Function 1" default = 1 enum = "unused" "+" "-" "/" "*" "^" hint = "First formula Operator" endparam heading caption = " Function 2 Options" endheading param gfunc caption = "Function 2 Flavor" hint = "(0 = Pixel)" enum = "Pixel" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42" "43" "44" "45" "46" "47" "48" "49" "50" "Nothing" endparam param oper2 caption = "Operation for Function 2" default = 1 enum = "unused" "+" "-" "/" "*" "^" hint = "Second formula Operator" endparam heading caption = " Function 3 Options" endheading param bfunc caption = "Function 3 Flavor" hint = "(0 = Pixel)" enum = "Pixel" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42" "43" "44" "45" "46" "47" "48" "49" "50" "Nothing" endparam param oper3 caption = "Operation for Function 3" default = 1 enum = "unused" "+" "-" "/" "*" "^" hint = "Third formula Operator" endparam heading caption = " Function 4 Options" endheading param afunc caption = "Function 4 Flavor" hint = "(0 = Pixel)" enum = "Pixel" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28" "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42" "43" "44" "45" "46" "47" "48" "49" "50" "Nothing" endparam param oper4 caption = "Operation for Function 4" default = 1 enum = "unused" "+" "-" "/" "*" "^" hint = "Fourth formula Operator" endparam heading caption = " Variables" endheading param p1 caption = "Variable 1" endparam param p2 caption = "Variable 2" endparam param p3 caption = "Variable 3" endparam param p4 caption = "Variable 4" endparam param p5 caption = "Variable 5" endparam param p6 caption = "Variable 6" endparam param r caption = "Variable 7" endparam heading caption = " Functions" endheading func fn1 caption = "User Function 1" endfunc func fn2 caption = "User Function 2" endfunc func fn3 caption = "User Function 3" endfunc func fn4 caption = "User Function 4" endfunc } random11 { global: ;My 11th Randomly-Generated Transformation Formula transform: #pixel = ((cos ( #pixel - p4 )- (p2 )* 1 / (#pixel * fn3 ( p4 )^ ((fn4 ( p6 )^ (fn2 ( p2 )* (p2 )/ (#pixel * #pixel + p4 )+ p1 )^ (fn1 ( p1 )+ #e )- (#e )))))) default: title = "random11" } random12 { global: ;My 12th Randomly-Generated Transformation Formula transform: #pixel = (fn1 ( p3 )^ (fn2 ( (atan2 ( (acosh ( p5 )* p2 )- ((fn1 ( #pixel - #pixel ^ p2 )+ (#pixel + p1 )- #pixel - sinh ( (flip ( #pixel / p4 )* #skew )- (p4 )/ fn4 ( (fn4 ( #pixel + 2 ))))))))))) default: title = "random12" } JCdabblerTrans { ;The JC Dabbler Transformation Formula version 1.36, written by Jayce Cruel global: transform: complex z = (0,0) zbailrighttest = (0,0) zbaillefttest = (0,0) complex realpixel = (0,0) complex imagpixel = (0,0) complex tztweak = (0,0) complex zbailleft = (0,0) complex zbailright = (0,0) complex z0 = (0,0) complex zA = (0,0) complex zB = (0,0) complex zC = (0,0) complex zD = (0,0) complex zE = (0,0) complex zF = (0,0) complex zG = (0,0) complex zH = (0,0) complex zI = (0,0) complex zJ = (0,0) complex theinitvar1 = @initvar1 theinitvar1 = theinitvar1 complex theinitvar2 = @initvar2 theinitvar2 = theinitvar2 complex thetweakvar4 = @tweakvar4 thetweakvar4 = thetweakvar4 complex thetweakvar5 = @tweakvar5 thetweakvar5 = thetweakvar5 complex thetweakvar8 = @tweakvar8 thetweakvar8 = thetweakvar8 complex thetweakvar9 = @tweakvar9 thetweakvar9 = thetweakvar9 complex thetweakvar10 = @tweakvar10 thetweakvar10 = thetweakvar10 complex thetweakvar102 = @tweakvar102 thetweakvar102 = thetweakvar102 complex thetweakvar16 = @tweakvar16 thetweakvar16 = thetweakvar16 complex thetweakvar17 = @tweakvar17 thetweakvar17 = thetweakvar17 complex thetweakvar18 = @tweakvar18 thetweakvar18 = thetweakvar18 complex thetweakvar19 = @tweakvar19 thetweakvar19 = thetweakvar19 complex thetweakvar192 = @tweakvar192 thetweakvar192 = thetweakvar192 complex thetweakvar24 = @tweakvar24 thetweakvar24 = thetweakvar24 complex thetweakvar242 = @tweakvar242 thetweakvar242 = thetweakvar242 complex thetweakvar25 = @tweakvar25 thetweakvar25 = thetweakvar25 complex thetweakvar27 = @tweakvar27 thetweakvar27 = thetweakvar27 complex thetweakvar272 = @tweakvar272 thetweakvar272 = thetweakvar272 complex thetweakvar28 = @tweakvar28 thetweakvar28 = thetweakvar28 complex thetweakvar282 = @tweakvar282 thetweakvar282 = thetweakvar282 complex thetweakvar29 = @tweakvar29 thetweakvar29 = thetweakvar29 complex thetweakvar30 = @tweakvar30 thetweakvar30 = thetweakvar30 complex thez0var1 = @z0var1 thez0var1 = thez0var1 complex thez0var2 = @z0var2 thez0var2 = thez0var2 complex thezAvar1 = @zAvar1 thezAvar1 = thezAvar1 complex thezAvar2 = @zAvar2 thezAvar2 = thezAvar2 complex thezBvar1 = @zBvar1 thezBvar1 = thezBvar1 complex thezBvar2 = @zBvar2 thezBvar2 = thezBvar2 complex thezCvar1 = @zCvar1 thezCvar1 = thezCvar1 complex thezCvar2 = @zCvar2 thezCvar2 = thezCvar2 complex thezDvar1 = @zDvar1 thezDvar1 = thezDvar1 complex thezDvar2 = @zDvar2 thezDvar2 = thezDvar2 complex thezEvar1 = @zEvar1 thezEvar1 = thezEvar1 complex thezEvar2 = @zEvar2 thezEvar2 = thezEvar2 complex thezFvar1 = @zFvar1 thezFvar1 = thezFvar1 complex thezFvar2 = @zFvar2 thezFvar2 = thezFvar2 complex thezGvar1 = @zGvar1 thezGvar1 = thezGvar1 complex thezGvar2 = @zGvar2 thezGvar2 = thezGvar2 complex thezHvar1 = @zHvar1 thezHvar1 = thezHvar1 complex thezHvar2 = @zHvar2 thezHvar2 = thezHvar2 complex thezIvar1 = @zIvar1 thezIvar1 = thezIvar1 complex thezIvar2 = @zIvar2 thezIvar2 = thezIvar2 complex thezJvar1 = @zJvar1 thezJvar1 = thezJvar1 complex thezJvar2 = @zJvar2 thezJvar2 = thezJvar2 complex theleftbailoutvar1 = @leftbailoutvar1 theleftbailoutvar1 = theleftbailoutvar1 complex theleftbailoutvar2 = @leftbailoutvar2 theleftbailoutvar2 = theleftbailoutvar2 complex therightbailoutvar1 = @rightbailoutvar1 therightbailoutvar1 = therightbailoutvar1 complex therightbailoutvar2 = @rightbailoutvar2 therightbailoutvar2 = therightbailoutvar2 IF |z| < @bignumber IF @zinit == 0 z = z ELSEIF @zinit == 1 z = #pixel ELSEIF @zinit == 2 z = theinitvar1 ELSEIF @zinit == 3 z = z + #pixel + (@initfunc1 ( z * z + theinitvar1 )) ELSEIF @zinit == 4 z = (@initfunc1 ( theinitvar1 )) ELSEIF @zinit == 5 z = (theinitvar1 ) * z + @initfunc1 ( z / theinitvar2 ) ELSEIF @zinit == 6 z = (z ^ (@initfunc1 ( theinitvar1 ))) ELSEIF @zinit == 7 z = z * theinitvar1 ^ ((@initfunc1 ( z ))) ELSEIF @zinit == 8 z = z ^ @initfunc2 ( #pixel + z - z * z - theinitvar1 ) ELSEIF @zinit == 9 z = (z + @initfunc1 ( z + #pixel ^ (z - theinitvar1 )+ (z / (z-1)) )) ELSEIF @zinit == 10 z = z / @initfunc1 ( #pixel + z - @initfunc2 ( z )) ELSEIF @zinit == 11 z = (z + (theinitvar1 / (@initfunc1 ( z * #pixel + theinitvar1 + theinitvar2 )))) ELSEIF @zinit == 12 z = (#pixel + (theinitvar1 * #random )) ELSEIF @zinit == 13 z = (theinitvar1 )* z + @initfunc1(z / theinitvar2 / #pixel ) ELSEIF @zinit == 14 z = (@initfunc1 ( z*theinitvar1 ) + @initfunc2(#pixel * theinitvar2)) ELSEIF @zinit == 15 z = z * theinitvar1 + #e - #pixel ELSEIF @zinit == 16 z = theinitvar1 / @initfunc1(z ^ z ) ELSEIF @zinit == 17 z = (z ^ theinitvar1 ) * #pixel / z ^ @initfunc2 ( theinitvar2 * (#random + 1) ) ELSEIF @zinit == 18 z = z - #pixel / theinitvar2 * (theinitvar1 ) ELSEIF @zinit == 19 z = #pixel + theinitvar2 ^ #pi ELSEIF @zinit == 20 z = (z - (@initfunc1 ( z * #pixel ^ (@initfunc2( theinitvar1 ))))) ELSEIF @zinit == 21 z = ((@initfunc1 ( theinitvar2 )- #pixel )/ (theinitvar2 )) ELSEIF @zinit == 22 z = (z / theinitvar1 )* #pixel / (#e ) ELSEIF @zinit == 23 z = (z * theinitvar1 )+ (#pixel * theinitvar2 ) ELSEIF @zinit == 24 z = (@initfunc1 ( z * z )) ELSEIF @zinit == 25 z = (z - @initfunc1 ( #pixel * theinitvar1 )) ELSEIF @zinit == 26 z = (z + z / theinitvar1 )- @initfunc1 ( #pixel ) ELSEIF @zinit == 27 z = z / theinitvar1 ELSEIF @zinit == 28 z = z * z + theinitvar1 ELSEIF @zinit == 29 z = z * z + #pixel ELSEIF @zinit == 30 z = @initfunc1( (z^2 + #pixel - 1) / (2*z + #pixel - 2) ) ELSEIF @zinit == 31 z = @initfunc1( (z^2 + theinitvar1 - 1) / (2*z + theinitvar2 - 2) ) ELSEIF @zinit == 32 z = z - theinitvar1 * (z^theinitvar2-1) / (theinitvar2 * z^(theinitvar1-1)) + theinitvar1 ELSEIF @zinit == 33 z = z - theinitvar1 * (z^theinitvar2-1) / (theinitvar2 * z^(theinitvar2-1)) + #pixel ELSEIF @zinit == 34 z = ((theinitvar1 - 1) * z^theinitvar1 + theinitvar2) / (theinitvar1 * z ^ (theinitvar1 - 1)) ELSEIF @zinit == 35 z = 1/z ELSEIF @zinit == 36 z = 1/#pixel ELSEIF @zinit == 37 z = 1 / ( z * z - #pixel ) + theinitvar1 ELSEIF @zinit == 38 z = @initfunc1(z) + @initfunc2(#pixel) ELSEIF @zinit == 39 z = @initfunc1(z) + @initfunc2(theinitvar1) ELSEIF @zinit == 40 z = z * (@initfunc1(theinitvar1 ^ theinitvar2) / @initfunc2( theinitvar1 ^ theinitvar2))/theinitvar1 + (1/z) ELSEIF @zinit == 41 z = z*z+z/theinitvar1+@initfunc1(theinitvar2) ENDIF IF @ztweak1 == true tztweak = z IF @ztoper1 == 0 z = z ELSEIF @ztoper1 == 1 z = z + tztweak ELSEIF @ztoper1 == 2 z = z - tztweak ELSEIF @ztoper1 == 3 z = z * tztweak ELSEIF @ztoper1 == 4 z = z / tztweak ELSEIF @ztoper1 == 5 z = z ^ tztweak ELSEIF @ztoper1 == 6 z = tztweak - z ELSEIF @ztoper1 == 7 z = tztweak / z ELSEIF @ztoper1 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak2 == true tztweak = #pixel IF @ztoper2 == 0 z = z ELSEIF @ztoper2 == 1 z = z + tztweak ELSEIF @ztoper2 == 2 z = z - tztweak ELSEIF @ztoper2 == 3 z = z * tztweak ELSEIF @ztoper2 == 4 z = z / tztweak ELSEIF @ztoper2 == 5 z = z ^ tztweak ELSEIF @ztoper2 == 6 z = tztweak - z ELSEIF @ztoper2 == 7 z = tztweak / z ELSEIF @ztoper2 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak3 == true tztweak = z * z + #pixel IF @ztoper3 == 0 z = z ELSEIF @ztoper3 == 1 z = z + tztweak ELSEIF @ztoper3 == 2 z = z - tztweak ELSEIF @ztoper3 == 3 z = z * tztweak ELSEIF @ztoper3 == 4 z = z / tztweak ELSEIF @ztoper3 == 5 z = z ^ tztweak ELSEIF @ztoper3 == 6 z = tztweak - z ELSEIF @ztoper3 == 7 z = tztweak / z ELSEIF @ztoper3 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak4 == true tztweak = thetweakvar4 IF @ztoper4 == 0 z = z ELSEIF @ztoper4 == 1 z = z + tztweak ELSEIF @ztoper4 == 2 z = z - tztweak ELSEIF @ztoper4 == 3 z = z * tztweak ELSEIF @ztoper4 == 4 z = z / tztweak ELSEIF @ztoper4 == 5 z = z ^ tztweak ELSEIF @ztoper4 == 6 z = tztweak - z ELSEIF @ztoper4 == 7 z = tztweak / z ELSEIF @ztoper4 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak5 == true tztweak = thetweakvar5 IF @ztoper5 == 0 z = z ELSEIF @ztoper5 == 1 z = z + tztweak ELSEIF @ztoper5 == 2 z = z - tztweak ELSEIF @ztoper5 == 3 z = z * tztweak ELSEIF @ztoper5 == 4 z = z / tztweak ELSEIF @ztoper5 == 5 z = z ^ tztweak ELSEIF @ztoper5 == 6 z = tztweak - z ELSEIF @ztoper5 == 7 z = tztweak / z ELSEIF @ztoper5 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak6 == true tztweak = @tweakfunc6(z) IF @ztoper6 == 0 z = z ELSEIF @ztoper6 == 1 z = z + tztweak ELSEIF @ztoper6 == 2 z = z - tztweak ELSEIF @ztoper6 == 3 z = z * tztweak ELSEIF @ztoper6 == 4 z = z / tztweak ELSEIF @ztoper6 == 5 z = z ^ tztweak ELSEIF @ztoper6 == 6 z = tztweak - z ELSEIF @ztoper6 == 7 z = tztweak / z ELSEIF @ztoper6 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak7 == true tztweak = @tweakfunc7(#pixel) IF @ztoper7 == 0 z = z ELSEIF @ztoper7 == 1 z = z + tztweak ELSEIF @ztoper7 == 2 z = z - tztweak ELSEIF @ztoper7 == 3 z = z * tztweak ELSEIF @ztoper7 == 4 z = z / tztweak ELSEIF @ztoper7 == 5 z = z ^ tztweak ELSEIF @ztoper7 == 6 z = tztweak - z ELSEIF @ztoper7 == 7 z = tztweak / z ELSEIF @ztoper7 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak8 == true tztweak = @tweakfunc8(thetweakvar8) IF @ztoper8 == 0 z = z ELSEIF @ztoper8 == 1 z = z + tztweak ELSEIF @ztoper8 == 2 z = z - tztweak ELSEIF @ztoper8 == 3 z = z * tztweak ELSEIF @ztoper8 == 4 z = z / tztweak ELSEIF @ztoper8 == 5 z = z ^ tztweak ELSEIF @ztoper8 == 6 z = tztweak - z ELSEIF @ztoper8 == 7 z = tztweak / z ELSEIF @ztoper8 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak9 == true tztweak = (z - thetweakvar9 ) IF @ztoper9 == 0 z = z ELSEIF @ztoper9 == 1 z = z + tztweak ELSEIF @ztoper9 == 2 z = z - tztweak ELSEIF @ztoper9 == 3 z = z * tztweak ELSEIF @ztoper9 == 4 z = z / tztweak ELSEIF @ztoper9 == 5 z = z ^ tztweak ELSEIF @ztoper9 == 6 z = tztweak - z ELSEIF @ztoper9 == 7 z = tztweak / z ELSEIF @ztoper9 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak10 == true tztweak = thetweakvar10 ^ z + @tweakfunc10 ( thetweakvar102 ) IF @ztoper10 == 0 z = z ELSEIF @ztoper10 == 1 z = z + tztweak ELSEIF @ztoper10 == 2 z = z - tztweak ELSEIF @ztoper10 == 3 z = z * tztweak ELSEIF @ztoper10 == 4 z = z / tztweak ELSEIF @ztoper10 == 5 z = z ^ tztweak ELSEIF @ztoper10 == 6 z = tztweak - z ELSEIF @ztoper10 == 7 z = tztweak / z ELSEIF @ztoper10 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak11 == true tztweak = z + (@tweakfunc11 ( #pixel )) IF @ztoper11 == 0 z = z ELSEIF @ztoper11 == 1 z = z + tztweak ELSEIF @ztoper11 == 2 z = z - tztweak ELSEIF @ztoper11 == 3 z = z * tztweak ELSEIF @ztoper11 == 4 z = z / tztweak ELSEIF @ztoper11 == 5 z = z ^ tztweak ELSEIF @ztoper11 == 6 z = tztweak - z ELSEIF @ztoper11 == 7 z = tztweak / z ELSEIF @ztoper11 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak12 == true tztweak = #pi IF @ztoper12 == 0 z = z ELSEIF @ztoper12 == 1 z = z + tztweak ELSEIF @ztoper12 == 2 z = z - tztweak ELSEIF @ztoper12 == 3 z = z * tztweak ELSEIF @ztoper12 == 4 z = z / tztweak ELSEIF @ztoper12 == 5 z = z ^ tztweak ELSEIF @ztoper12 == 6 z = tztweak - z ELSEIF @ztoper12 == 7 z = tztweak / z ELSEIF @ztoper12 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak13 == true tztweak = #e IF @ztoper13 == 0 z = z ELSEIF @ztoper13 == 1 z = z + tztweak ELSEIF @ztoper13 == 2 z = z - tztweak ELSEIF @ztoper13 == 3 z = z * tztweak ELSEIF @ztoper13 == 4 z = z / tztweak ELSEIF @ztoper13 == 5 z = z ^ tztweak ELSEIF @ztoper13 == 6 z = tztweak - z ELSEIF @ztoper13 == 7 z = tztweak / z ELSEIF @ztoper13 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak14 == true tztweak = (z - @tweakfunc14 ( z )) IF @ztoper14 == 0 z = z ELSEIF @ztoper14 == 1 z = z + tztweak ELSEIF @ztoper14 == 2 z = z - tztweak ELSEIF @ztoper14 == 3 z = z * tztweak ELSEIF @ztoper14 == 4 z = z / tztweak ELSEIF @ztoper14 == 5 z = z ^ tztweak ELSEIF @ztoper14 == 6 z = tztweak - z ELSEIF @ztoper14 == 7 z = tztweak / z ELSEIF @ztoper14 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak15 == true tztweak = z * z - #e IF @ztoper15 == 0 z = z ELSEIF @ztoper15 == 1 z = z + tztweak ELSEIF @ztoper15 == 2 z = z - tztweak ELSEIF @ztoper15 == 3 z = z * tztweak ELSEIF @ztoper15 == 4 z = z / tztweak ELSEIF @ztoper15 == 5 z = z ^ tztweak ELSEIF @ztoper15 == 6 z = tztweak - z ELSEIF @ztoper15 == 7 z = tztweak / z ELSEIF @ztoper15 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak16 == true tztweak = (@tweakfunc16 ( z / (@tweakfunc162 ( thetweakvar16 )))) IF @ztoper16 == 0 z = z ELSEIF @ztoper16 == 1 z = z + tztweak ELSEIF @ztoper16 == 2 z = z - tztweak ELSEIF @ztoper16 == 3 z = z * tztweak ELSEIF @ztoper16 == 4 z = z / tztweak ELSEIF @ztoper16 == 5 z = z ^ tztweak ELSEIF @ztoper16 == 6 z = tztweak - z ELSEIF @ztoper16 == 7 z = tztweak / z ELSEIF @ztoper16 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak17 == true tztweak = z / thetweakvar17 * (#pixel ) IF @ztoper17 == 0 z = z ELSEIF @ztoper17 == 1 z = z + tztweak ELSEIF @ztoper17 == 2 z = z - tztweak ELSEIF @ztoper17 == 3 z = z * tztweak ELSEIF @ztoper17 == 4 z = z / tztweak ELSEIF @ztoper17 == 5 z = z ^ tztweak ELSEIF @ztoper17 == 6 z = tztweak - z ELSEIF @ztoper17 == 7 z = tztweak / z ELSEIF @ztoper17 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak18 == true tztweak = (@tweakfunc18 ( thetweakvar18 ^ z )) IF @ztoper18 == 0 z = z ELSEIF @ztoper18 == 1 z = z + tztweak ELSEIF @ztoper18 == 2 z = z - tztweak ELSEIF @ztoper18 == 3 z = z * tztweak ELSEIF @ztoper18 == 4 z = z / tztweak ELSEIF @ztoper18 == 5 z = z ^ tztweak ELSEIF @ztoper18 == 6 z = tztweak - z ELSEIF @ztoper18 == 7 z = tztweak / z ELSEIF @ztoper18 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak19 == true tztweak = (thetweakvar19 )^ (z - 1 - thetweakvar192 ) IF @ztoper19 == 0 z = z ELSEIF @ztoper19 == 1 z = z + tztweak ELSEIF @ztoper19 == 2 z = z - tztweak ELSEIF @ztoper19 == 3 z = z * tztweak ELSEIF @ztoper19 == 4 z = z / tztweak ELSEIF @ztoper19 == 5 z = z ^ tztweak ELSEIF @ztoper19 == 6 z = tztweak - z ELSEIF @ztoper19 == 7 z = tztweak / z ELSEIF @ztoper19 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak20 == true tztweak = ((@tweakfunc20 ( z * #pixel ))) IF @ztoper20 == 0 z = z ELSEIF @ztoper20 == 1 z = z + tztweak ELSEIF @ztoper20 == 2 z = z - tztweak ELSEIF @ztoper20 == 3 z = z * tztweak ELSEIF @ztoper20 == 4 z = z / tztweak ELSEIF @ztoper20 == 5 z = z ^ tztweak ELSEIF @ztoper20 == 6 z = tztweak - z ELSEIF @ztoper20 == 7 z = tztweak / z ELSEIF @ztoper20 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak21 == true tztweak = 1 / (z ^ #pixel ) IF @ztoper21 == 0 z = z ELSEIF @ztoper21 == 1 z = z + tztweak ELSEIF @ztoper21 == 2 z = z - tztweak ELSEIF @ztoper21 == 3 z = z * tztweak ELSEIF @ztoper21 == 4 z = z / tztweak ELSEIF @ztoper21 == 5 z = z ^ tztweak ELSEIF @ztoper21 == 6 z = tztweak - z ELSEIF @ztoper21 == 7 z = tztweak / z ELSEIF @ztoper21 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak22 == true tztweak = 1/z IF @ztoper22 == 0 z = z ELSEIF @ztoper22 == 1 z = z + tztweak ELSEIF @ztoper22 == 2 z = z - tztweak ELSEIF @ztoper22 == 3 z = z * tztweak ELSEIF @ztoper22 == 4 z = z / tztweak ELSEIF @ztoper22 == 5 z = z ^ tztweak ELSEIF @ztoper22 == 6 z = tztweak - z ELSEIF @ztoper22 == 7 z = tztweak / z ELSEIF @ztoper22 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak23 == true tztweak = 1/#pixel IF @ztoper23 == 0 z = z ELSEIF @ztoper23 == 1 z = z + tztweak ELSEIF @ztoper23 == 2 z = z - tztweak ELSEIF @ztoper23 == 3 z = z * tztweak ELSEIF @ztoper23 == 4 z = z / tztweak ELSEIF @ztoper23 == 5 z = z ^ tztweak ELSEIF @ztoper23 == 6 z = tztweak - z ELSEIF @ztoper23 == 7 z = tztweak / z ELSEIF @ztoper23 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak24 == true tztweak = (z / thetweakvar24 )* thetweakvar242 IF @ztoper24 == 0 z = z ELSEIF @ztoper24 == 1 z = z + tztweak ELSEIF @ztoper24 == 2 z = z - tztweak ELSEIF @ztoper24 == 3 z = z * tztweak ELSEIF @ztoper24 == 4 z = z / tztweak ELSEIF @ztoper24 == 5 z = z ^ tztweak ELSEIF @ztoper24 == 6 z = tztweak - z ELSEIF @ztoper24 == 7 z = tztweak / z ELSEIF @ztoper24 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak25 == true tztweak = (thetweakvar25 )- ((@tweakfunc25 ( z ))) IF @ztoper25 == 0 z = z ELSEIF @ztoper25 == 1 z = z + tztweak ELSEIF @ztoper25 == 2 z = z - tztweak ELSEIF @ztoper25 == 3 z = z * tztweak ELSEIF @ztoper25 == 4 z = z / tztweak ELSEIF @ztoper25 == 5 z = z ^ tztweak ELSEIF @ztoper25 == 6 z = tztweak - z ELSEIF @ztoper25 == 7 z = tztweak / z ELSEIF @ztoper25 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak26 == true tztweak = (z + z + (@tweakfunc26 ( #pixel ))) IF @ztoper26 == 0 z = z ELSEIF @ztoper26 == 1 z = z + tztweak ELSEIF @ztoper26 == 2 z = z - tztweak ELSEIF @ztoper26 == 3 z = z * tztweak ELSEIF @ztoper26 == 4 z = z / tztweak ELSEIF @ztoper26 == 5 z = z ^ tztweak ELSEIF @ztoper26 == 6 z = tztweak - z ELSEIF @ztoper26 == 7 z = tztweak / z ELSEIF @ztoper26 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak27 == true tztweak = z + z / thetweakvar27 ^ (@tweakfunc27 ( thetweakvar272 )) IF @ztoper27 == 0 z = z ELSEIF @ztoper27 == 1 z = z + tztweak ELSEIF @ztoper27 == 2 z = z - tztweak ELSEIF @ztoper27 == 3 z = z * tztweak ELSEIF @ztoper27 == 4 z = z / tztweak ELSEIF @ztoper27 == 5 z = z ^ tztweak ELSEIF @ztoper27 == 6 z = tztweak - z ELSEIF @ztoper27 == 7 z = tztweak / z ELSEIF @ztoper27 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak28 == true tztweak = (z / thetweakvar28 * (#pixel * thetweakvar282 )) IF @ztoper28 == 0 z = z ELSEIF @ztoper28 == 1 z = z + tztweak ELSEIF @ztoper28 == 2 z = z - tztweak ELSEIF @ztoper28 == 3 z = z * tztweak ELSEIF @ztoper28 == 4 z = z / tztweak ELSEIF @ztoper28 == 5 z = z ^ tztweak ELSEIF @ztoper28 == 6 z = tztweak - z ELSEIF @ztoper28 == 7 z = tztweak / z ELSEIF @ztoper28 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak29 == true tztweak = z * z + thetweakvar29 IF @ztoper29 == 0 z = z ELSEIF @ztoper29 == 1 z = z + tztweak ELSEIF @ztoper29 == 2 z = z - tztweak ELSEIF @ztoper29 == 3 z = z * tztweak ELSEIF @ztoper29 == 4 z = z / tztweak ELSEIF @ztoper29 == 5 z = z ^ tztweak ELSEIF @ztoper29 == 6 z = tztweak - z ELSEIF @ztoper29 == 7 z = tztweak / z ELSEIF @ztoper29 == 8 z = tztweak ^ z ENDIF ENDIF IF @ztweak30 == true tztweak = (z / (#pixel - thetweakvar30 )) IF @ztoper30 == 0 z = z ELSEIF @ztoper30 == 1 z = z + tztweak ELSEIF @ztoper30 == 2 z = z - tztweak ELSEIF @ztoper30 == 3 z = z * tztweak ELSEIF @ztoper30 == 4 z = z / tztweak ELSEIF @ztoper30 == 5 z = z ^ tztweak ELSEIF @ztoper30 == 6 z = tztweak - z ELSEIF @ztoper30 == 7 z = tztweak / z ELSEIF @ztoper30 == 8 z = tztweak ^ z ENDIF ENDIF IF @zfunc==0 complex z0 = z ELSEIF @zfunc==1 complex z0 = #pixel ELSEIF @zfunc==2 complex z0 = z*z+#pixel ELSEIF @zfunc==3 complex z0 = 1/z ELSEIF @zfunc==4 complex z0 = 1/#pixel ELSEIF @zfunc==5 complex z0 = thez0var1 ELSEIF @zfunc==6 complex z0 = thez0var2 ELSEIF @zfunc==7 complex z0 = @z0func1(z) ELSEIF @zfunc==8 complex z0 = @z0func1(#pixel) ELSEIF @zfunc==9 complex z0 = z*z+thez0var1 ELSEIF @zfunc==10 complex z0 = @z0func1(z*z+thez0var1) ELSEIF @zfunc==11 complex z0 = z * z - z / #pixel ELSEIF @zfunc==12 complex z0 = z ^ (@z0func1 ( z + z * z / thez0var1 )) ELSEIF @zfunc==13 complex z0 = (z ^ thez0var1 )- (z * z / #pixel ) ELSEIF @zfunc==14 complex z0 = @z0func1 ( z / thez0var1 ) ELSEIF @zfunc==15 complex z0 = (z + thez0var1 )* (z - #pixel - thez0var1 * (z )) ELSEIF @zfunc==16 complex z0 = (z + (@z0func1 ( z + 1 - #pixel ))) ELSEIF @zfunc==17 complex z0 = (z * thez0var1 / ((@z0func1 ( z / z + thez0var2 )- #pixel )^ (z - #pixel ))) ELSEIF @zfunc==18 complex z0 = (z * (@z0func1 ( z ^ thez0var1))) ELSEIF @zfunc==19 complex z0 = (z - thez0var1 )^ (z - #pixel * z ^ thez0var2 ) ELSEIF @zfunc==20 complex z0 = ((@z0func1 ( thez0var1 )* (z ))) ELSEIF @zfunc==21 complex z0 = ((@z0func1 ( z + thez0var2 )/ (z ^ thez0var1))) ELSEIF @zfunc==22 complex z0 = (thez0var2 )* #pixel * ((@z0func1 ( z / thez0var1 )* ((@z0func2 ( thez0var2 )* (#pixel ))))) ELSEIF @zfunc==23 complex z0 = (@z0func1 ( z * thez0var2 )* ((@z0func1 ( @z0func2 ( thez0var1 ))))) ELSEIF @zfunc==24 complex z0 = (z + thez0var1 )/ ((@z0func1 ( z - thez0var2 ))) ELSEIF @zfunc==25 complex z0 = z - (@z0func2 ( z - (@z0func1 ( z + thez0var1 )+ (z )))) ELSEIF @zfunc==26 complex z0 = z + z + (@z0func1 ( z ^ z - #pixel )) ELSEIF @zfunc==27 complex z0 = (thez0var2 ^ (z * (@z0func1 ( z / (@z0func2 (thez0var1 )))))) ELSEIF @zfunc==28 complex z0 = @z0func1 ( z / #pixel ) ELSEIF @zfunc==29 complex z0 = (z * z + (@z0func1 ( thez0var1 ))) ELSEIF @zfunc==30 complex z0 = ((@z0func1 ( 1 - z * thez0var1 ))) ELSEIF @zfunc==31 complex z0 = z + z * thez0var1 - (@z0func1 ( z ^ #pixel )) ELSEIF @zfunc==32 complex z0 = (z - (z ^ thez0var1 ))+ (#pixel ) ELSEIF @zfunc==33 complex z0 = z ^ thez0var1 / (z ) ELSEIF @zfunc==34 complex z0 = z - (@z0func2 ( z / @z0func1 ( thez0var1 ^ (thez0var2 )))) ELSEIF @zfunc==35 complex z0 = (z ^ @z0func1 ( z - (@z0func1 ( z * @z0func2 ( thez0var2 ))))) ELSEIF @zfunc==36 complex z0 = (z - #pixel / z + #pixel ) ELSEIF @zfunc==37 complex z0 = z * z - (@z0func1 ( z )) ELSEIF @zfunc==38 complex z0 = (z ^ (@z0func1 ( z + thez0var1 )/ (thez0var2 ))) ELSEIF @zfunc==39 complex z0 = (thez0var1 - z) / (z - thez0var2 ) ELSEIF @zfunc==40 complex z0 = z * (@z0func1 ( z + thez0var1 )- #pixel + z ) ELSEIF @zfunc==41 complex z0 = (z - (@z0func2 ( 1 / z ))) ELSEIF @zfunc==42 complex z0 = @z0func1 ( z * thez0var1 )- #pixel ^ z + z ELSEIF @zfunc==43 complex z0 = (z / z - thez0var2 )/ (thez0var1 )^ #pixel * (#pixel ) ELSEIF @zfunc==44 complex z0 = (z / thez0var1 )+ (thez0var2 / z) ELSEIF @zfunc==45 complex z0 = (z - thez0var2 + z ^ thez0var1 ) ELSEIF @zfunc==46 complex z0 = (z * thez0var1 / #pixel )- ((@z0func1 ( z + @z0func2 ( thez0var2 )))) ELSEIF @zfunc==47 complex z0 = thez0var2 - (z * thez0var1 ) ELSEIF @zfunc==48 complex z0 = z - z ^ thez0var1 - (@z0func1 ( thez0var2 )) ELSEIF @zfunc==49 complex z0 = (@z0func2 ( z - #pixel * @z0func1 ( thez0var1 ))) ELSEIF @zfunc==50 complex z0 = (z / @z0func2 ( z - thez0var1 )^ ((@z0func1 ( #pixel )))) ELSEIF @zfunc==51 complex z0 = (@z0func1 ( (@z0func2 ( thez0var1 + z)))) ELSEIF @zfunc==52 complex z0 = (z / thez0var1 )^ (#pixel - z + thez0var2 ) ELSEIF @zfunc==53 complex z0 = (z - z ^ #pixel ) ELSEIF @zfunc==54 complex z0 = (z + thez0var2 )^ z - thez0var1 - (z ) ELSEIF @zfunc==55 complex z0 = (z ^ z - (@z0func1 ( #pixel ))) ELSEIF @zfunc==56 complex z0 = z + z ^ (@z0func1 ( #pixel )) ELSEIF @zfunc==57 complex z0 = (z * @z0func1 ( z * thez0var1 )) ELSEIF @zfunc==58 complex z0 = z + (@z0func1 ( #pixel / z )) ELSEIF @zfunc==59 complex z0 = (z / thez0var2 )+ @z0func2 ( thez0var1 ) ELSEIF @zfunc==60 complex z0 = 1 / ( z * z - #pixel ) + thez0var1 ELSEIF @zfunc==61 complex z0 = @z0func1(z) + @z0func2(#pixel) ELSEIF @zfunc==62 complex z0 = @z0func1(z) + @z0func1(thez0var1) ELSEIF @zfunc==63 complex z0 = z * (@z0func1(thez0var1 ^ thez0var2) / @z0func2( thez0var1 ^ thez0var2))/thez0var1 + (1/z) ELSEIF @zfunc==64 complex z0 = z * z + z / thez0var1 + @z0func1 (thez0var2) ELSEIF @zfunc==65 complex z0 = @z0func1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zfunc==66 complex z0 = @z0func1( (z^2 + thez0var1 - 1) / (2*z + thez0var2 - 2) ) ELSEIF @zfunc==67 complex z0 = z - thez0var1 * (z^thez0var2-1) / (thez0var2 * z^(thez0var1-1)) + thez0var1 ELSEIF @zfunc==68 complex z0 = z - thez0var1 * (z^thez0var2-1) / (thez0var2 * z^(thez0var1-1)) + #pixel ELSEIF @zfunc==69 complex z0 = ((thez0var1 - 1) * z^thez0var1 + thez0var2) / (thez0var1 * z ^ (thez0var1 - 1)) ELSEIF @zfunc==70 complex z0 = (z ^ z + 1 / (z - 1 + z ^ thez0var1 )+ ((atan2 ( (@z0func2 ( z - z - z ^ thez0var1 )* ((@z0func2 ( z )))))))) ELSEIF @zfunc==71 complex z0 = (thez0var1 ^ (thez0var1 )/ @z0func2 ( 2 / (z + 4 ))) ELSEIF @zfunc==72 complex z0 = (4 + (@z0func1 ( @z0func2 ( thez0var1 )^ @z0func1 ( thez0var1 )+ ((@z0func1 ( #e )))))) ELSEIF @zfunc==73 complex z0 = (((@z0func1 (z - 2 - z - thez0var1 )^ #pixel )* ((@z0func2 ( z ))))) ELSEIF @zfunc==74 complex z0 = thez0var1 + #pixel * z ^ thez0var1 * #pixel ELSEIF @zfunc==75 complex z0 = (z * thez0var1 )- #pixel ELSEIF @zfunc==76 complex z0 = @z0func1 ( thez0var1 )/ (@z0func1 ( z)) ELSEIF @zfunc==77 complex z0 = (z / thez0var1 )+ (@z0func1 ( z + 1 )) ELSEIF @zfunc==78 complex z0 = (z - thez0var1 + (z / @z0func1 ( #pixel ))) ELSEIF @zfunc==79 complex z0 = z * thez0var1 - #pixel - z ELSEIF @zfunc==80 complex z0 = thez0var1 * (z - thez0var2 ^ (thez0var1 )) ELSEIF @zfunc==81 complex z0 = (thez0var1 )/ (z ^ thez0var2 ^ z ) ELSEIF @zfunc==82 complex z0 = thez0var1 ^ #pixel / (thez0var1 ^ @z0func2 ( z * z )) ELSEIF @zfunc==83 complex z0 = (z / thez0var1 - z ) ELSEIF @zfunc==84 complex z0 = ((@z0func1 ( thez0var1 )- (thez0var1 )^ (#random * thez0var2))- @z0func1 ( 2 ^ (#pixel ))) ELSEIF @zfunc==85 complex z0 = (@z0func1 ( thez0var1 )- (@z0func1 ( z ))) ELSEIF @zfunc==86 complex z0 = thez0var1 ^ @z0func1 ( #pixel ) ELSEIF @zfunc==87 complex z0 = thez0var1 * (@z0func2 ( 1 - #pixel )- z ) ELSEIF @zfunc==88 complex z0 = z - @z0func1 ( thez0var1 / (z )) ELSEIF @zfunc==89 complex z0 = @z0func1 ( thez0var1 / #pixel + (#pixel+z) ) ELSEIF @zfunc==90 complex z0 = z ^ thez0var1 - (@z0func1 ( #pixel )) ELSEIF @zfunc==91 complex z0 = z * z - z + z ELSEIF @zfunc==92 complex z0 = (thez0var1 / @z0func1 ( @z0func2 ( thez0var1 ^ z - #pixel ))) ELSEIF @zfunc==93 complex z0 = z + thez0var1 + @z0func1 ( @z0func2 ( z - @z0func2 ( z ))) ELSEIF @zfunc==94 complex z0 = z + thez0var1 / thez0var2 * z + thez0var1 - (@z0func2 ( z )) ELSEIF @zfunc==95 complex z0 = z / thez0var1 / z * #pixel ELSEIF @zfunc==96 complex z0 = thez0var1 * (1 / z / 3) * (z ) ELSEIF @zfunc==97 complex z0 = z * thez0var1 + z / thez0var2 ^ (@z0func1 ( z + z )) ELSEIF @zfunc==98 complex z0 = @z0func1 ( thez0var1 ^ #pixel / (@z0func2 ( z ))) ELSEIF @zfunc==99 complex z0 = (z / z - @z0func2 ( z * thez0var1 ^ #pixel )) ENDIF IF @zAfunc==0 complex zA = z ELSEIF @zAfunc==1 complex zA = #pixel ELSEIF @zAfunc==2 complex zA = z*z+#pixel ELSEIF @zAfunc==3 complex zA = 1/z ELSEIF @zAfunc==4 complex zA = 1/#pixel ELSEIF @zAfunc==5 complex zA = thezAvar1 ELSEIF @zAfunc==6 complex zA = thezAvar2 ELSEIF @zAfunc==7 complex zA = @zAfunc1(z) ELSEIF @zAfunc==8 complex zA = @zAfunc1(#pixel) ELSEIF @zAfunc==9 complex zA = z*z+thezAvar1 ELSEIF @zAfunc==10 complex zA = @zAfunc1(z*z+thezAvar1) ELSEIF @zAfunc==11 complex zA = z * z - z / #pixel ELSEIF @zAfunc==12 complex zA = z ^ (@zAfunc1 ( z + z * z / thezAvar1 )) ELSEIF @zAfunc==13 complex zA = (z ^ thezAvar1 )- (z * z / #pixel ) ELSEIF @zAfunc==14 complex zA = @zAfunc1 ( z / thezAvar1 ) ELSEIF @zAfunc==15 complex zA = (z + thezAvar1 )* (z - #pixel - thezAvar1 * (z )) ELSEIF @zAfunc==16 complex zA = (z + (@zAfunc1 ( z + 1 - #pixel ))) ELSEIF @zAfunc==17 complex zA = (z * thezAvar1 / ((@zAfunc1 ( z / z + thezAvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zAfunc==18 complex zA = (z * (@zAfunc1 ( z ^ thezAvar1))) ELSEIF @zAfunc==19 complex zA = (z - thezAvar1 )^ (z - #pixel * z ^ thezAvar2 ) ELSEIF @zAfunc==20 complex zA = ((@zAfunc1 ( thezAvar1 )* (z ))) ELSEIF @zAfunc==21 complex zA = ((@zAfunc1 ( z + thezAvar2 )/ (z ^ thezAvar1))) ELSEIF @zAfunc==22 complex zA = (thezAvar2 )* #pixel * ((@zAfunc1 ( z / thezAvar1 )* ((@zAfunc2 ( thezAvar2 )* (#pixel ))))) ELSEIF @zAfunc==23 complex zA = (@zAfunc1 ( z * thezAvar2 )* ((@zAfunc1 ( @zAfunc2 ( thezAvar1 ))))) ELSEIF @zAfunc==24 complex zA = (z + thezAvar1 )/ ((@zAfunc1 ( z - thezAvar2 ))) ELSEIF @zAfunc==25 complex zA = z - (@zAfunc2 ( z - (@zAfunc1 ( z + thezAvar1 )+ (z )))) ELSEIF @zAfunc==26 complex zA = z + z + (@zAfunc1 ( z ^ z - #pixel )) ELSEIF @zAfunc==27 complex zA = (thezAvar2 ^ (z * (@zAfunc1 ( z / (@zAfunc2 (thezAvar1 )))))) ELSEIF @zAfunc==28 complex zA = @zAfunc1 ( z / #pixel ) ELSEIF @zAfunc==29 complex zA = (z * z + (@zAfunc1 ( thezAvar1 ))) ELSEIF @zAfunc==30 complex zA = ((@zAfunc1 ( 1 - z * thezAvar1 ))) ELSEIF @zAfunc==31 complex zA = z + z * thezAvar1 - (@zAfunc1 ( z ^ #pixel )) ELSEIF @zAfunc==32 complex zA = (z - (z ^ thezAvar1 ))+ (#pixel ) ELSEIF @zAfunc==33 complex zA = z ^ thezAvar1 / (z ) ELSEIF @zAfunc==34 complex zA = z - (@zAfunc2 ( z / @zAfunc1 ( thezAvar1 ^ (thezAvar2 )))) ELSEIF @zAfunc==35 complex zA = (z ^ @zAfunc1 ( z - (@zAfunc1 ( z * @zAfunc2 ( thezAvar2 ))))) ELSEIF @zAfunc==36 complex zA = (z - #pixel / z + #pixel ) ELSEIF @zAfunc==37 complex zA = z * z - (@zAfunc1 ( z )) ELSEIF @zAfunc==38 complex zA = (z ^ (@zAfunc1 ( z + thezAvar1 )/ (thezAvar2 ))) ELSEIF @zAfunc==39 complex zA = (thezAvar1 - z) / (z - thezAvar2 ) ELSEIF @zAfunc==40 complex zA = z * (@zAfunc1 ( z + thezAvar1 )- #pixel + z ) ELSEIF @zAfunc==41 complex zA = (z - (@zAfunc2 ( 1 / z ))) ELSEIF @zAfunc==42 complex zA = @zAfunc1 ( z * thezAvar1 )- #pixel ^ z + z ELSEIF @zAfunc==43 complex zA = (z / z - thezAvar2 )/ (thezAvar1 )^ #pixel * (#pixel ) ELSEIF @zAfunc==44 complex zA = (z / thezAvar1 )+ (thezAvar2 / z) ELSEIF @zAfunc==45 complex zA = (z - thezAvar2 + z ^ thezAvar1 ) ELSEIF @zAfunc==46 complex zA = (z * thezAvar1 / #pixel )- ((@zAfunc1 ( z + @zAfunc2 ( thezAvar2 )))) ELSEIF @zAfunc==47 complex zA = thezAvar2 - (z * thezAvar1 ) ELSEIF @zAfunc==48 complex zA = z - z ^ thezAvar1 - (@zAfunc1 ( thezAvar2 )) ELSEIF @zAfunc==49 complex zA = (@zAfunc2 ( z - #pixel * @zAfunc1 ( thezAvar1 ))) ELSEIF @zAfunc==50 complex zA = (z / @zAfunc2 ( z - thezAvar1 )^ ((@zAfunc1 ( #pixel )))) ELSEIF @zAfunc==51 complex zA = (@zAfunc1 ( (@zAfunc2 ( thezAvar1 + z)))) ELSEIF @zAfunc==52 complex zA = (z / thezAvar1 )^ (#pixel - z + thezAvar2 ) ELSEIF @zAfunc==53 complex zA = (z - z ^ #pixel ) ELSEIF @zAfunc==54 complex zA = (z + thezAvar2 )^ z - thezAvar1 - (z ) ELSEIF @zAfunc==55 complex zA = (z ^ z - (@zAfunc1 ( #pixel ))) ELSEIF @zAfunc==56 complex zA = z + z ^ (@zAfunc1 ( #pixel )) ELSEIF @zAfunc==57 complex zA = (z * @zAfunc1 ( z * thezAvar1 )) ELSEIF @zAfunc==58 complex zA = z + (@zAfunc1 ( #pixel / z )) ELSEIF @zAfunc==59 complex zA = (z / thezAvar2 )+ @zAfunc2 ( thezAvar1 ) ELSEIF @zAfunc==60 complex zA = 1 / ( z * z - #pixel ) + thezAvar1 ELSEIF @zAfunc==61 complex zA = @zAfunc1(z) + @zAfunc2(#pixel) ELSEIF @zAfunc==62 complex zA = @zAfunc1(z) + @zAfunc1(thezAvar1) ELSEIF @zAfunc==63 complex zA = z * (@zAfunc1(thezAvar1 ^ thezAvar2) / @zAfunc2( thezAvar1 ^ thezAvar2))/thezAvar1 + (1/z) ELSEIF @zAfunc==64 complex zA = z * z + z / thezAvar1 + @zAfunc1 (thezAvar2) ELSEIF @zAfunc==65 complex zA = @zAfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zAfunc==66 complex zA = @zAfunc1( (z^2 + thezAvar1 - 1) / (2*z + thezAvar2 - 2) ) ELSEIF @zAfunc==67 complex zA = z - thezAvar1 * (z^thezAvar2-1) / (thezAvar2 * z^(thezAvar1-1)) + thezAvar1 ELSEIF @zAfunc==68 complex zA = z - thezAvar1 * (z^thezAvar2-1) / (thezAvar2 * z^(thezAvar1-1)) + #pixel ELSEIF @zAfunc==69 complex zA = ((thezAvar1 - 1) * z^thezAvar1 + thezAvar2) / (thezAvar1 * z ^ (thezAvar1 - 1)) ELSEIF @zAfunc==70 complex zA = (z ^ z + 1 / (z - 1 + z ^ thezAvar1 )+ ((atan2 ( (@zAfunc2 ( z - z - z ^ thezAvar1 )* ((@zAfunc2 ( z )))))))) ELSEIF @zAfunc==71 complex zA = (thezAvar1 ^ (thezAvar1 )/ @zAfunc2 ( 2 / (z + 4 ))) ELSEIF @zAfunc==72 complex zA = (4 + (@zAfunc1 ( @zAfunc2 ( thezAvar1 )^ @zAfunc1 ( thezAvar1 )+ ((@zAfunc1 ( #e )))))) ELSEIF @zAfunc==73 complex zA = (((@zAfunc1 (z - 2 - z - thezAvar1 )^ #pixel )* ((@zAfunc2 ( z ))))) ELSEIF @zAfunc==74 complex zA = thezAvar1 + #pixel * z ^ thezAvar1 * #pixel ELSEIF @zAfunc==75 complex zA = (z * thezAvar1 )- #pixel ELSEIF @zAfunc==76 complex zA = @zAfunc1 ( thezAvar1 )/ (@zAfunc1 ( z)) ELSEIF @zAfunc==77 complex zA = (z / thezAvar1 )+ (@zAfunc1 ( z + 1 )) ELSEIF @zAfunc==78 complex zA = (z - thezAvar1 + (z / @zAfunc1 ( #pixel ))) ELSEIF @zAfunc==79 complex zA = z * thezAvar1 - #pixel - z ELSEIF @zAfunc==80 complex zA = thezAvar1 * (z - thezAvar2 ^ (thezAvar1 )) ELSEIF @zAfunc==81 complex zA = (thezAvar1 )/ (z ^ thezAvar2 ^ z ) ELSEIF @zAfunc==82 complex zA = thezAvar1 ^ #pixel / (thezAvar1 ^ @zAfunc2 ( z * z )) ELSEIF @zAfunc==83 complex zA = (z / thezAvar1 - z ) ELSEIF @zAfunc==84 complex zA = ((@zAfunc1 ( thezAvar1 )- (thezAvar1 )^ (#random * thezAvar2))- @zAfunc1 ( 2 ^ (#pixel ))) ELSEIF @zAfunc==85 complex zA = (@zAfunc1 ( thezAvar1 )- (@zAfunc1 ( z ))) ELSEIF @zAfunc==86 complex zA = thezAvar1 ^ @zAfunc1 ( #pixel ) ELSEIF @zAfunc==87 complex zA = thezAvar1 * (@zAfunc2 ( 1 - #pixel )- z ) ELSEIF @zAfunc==88 complex zA = z - @zAfunc1 ( thezAvar1 / (z )) ELSEIF @zAfunc==89 complex zA = @zAfunc1 ( thezAvar1 / #pixel + (#pixel+z) ) ELSEIF @zAfunc==90 complex zA = z ^ thezAvar1 - (@zAfunc1 ( #pixel )) ELSEIF @zAfunc==91 complex zA = z * z - z + z ELSEIF @zAfunc==92 complex zA = (thezAvar1 / @zAfunc1 ( @zAfunc2 ( thezAvar1 ^ z - #pixel ))) ELSEIF @zAfunc==93 complex zA = z + thezAvar1 + @zAfunc1 ( @zAfunc2 ( z - @zAfunc2 ( z ))) ELSEIF @zAfunc==94 complex zA = z + thezAvar1 / thezAvar2 * z + thezAvar1 - (@zAfunc2 ( z )) ELSEIF @zAfunc==95 complex zA = z / thezAvar1 / z * #pixel ELSEIF @zAfunc==96 complex zA = thezAvar1 * (1 / z / 3) * (z ) ELSEIF @zAfunc==97 complex zA = z * thezAvar1 + z / thezAvar2 ^ (@zAfunc1 ( z + z )) ELSEIF @zAfunc==98 complex zA = @zAfunc1 ( thezAvar1 ^ #pixel / (@zAfunc2 ( z ))) ELSEIF @zAfunc==99 complex zA = (z / z - @zAfunc2 ( z * thezAvar1 ^ #pixel )) ENDIF IF @zBfunc==0 complex zB = z ELSEIF @zBfunc==1 complex zB = #pixel ELSEIF @zBfunc==2 complex zB = z*z+#pixel ELSEIF @zBfunc==3 complex zB = 1/z ELSEIF @zBfunc==4 complex zB = 1/#pixel ELSEIF @zBfunc==5 complex zB = thezBvar1 ELSEIF @zBfunc==6 complex zB = thezBvar2 ELSEIF @zBfunc==7 complex zB = @zBfunc1(z) ELSEIF @zBfunc==8 complex zB = @zBfunc1(#pixel) ELSEIF @zBfunc==9 complex zB = z*z+thezBvar1 ELSEIF @zBfunc==10 complex zB = @zBfunc1(z*z+thezBvar1) ELSEIF @zBfunc==11 complex zB = z * z - z / #pixel ELSEIF @zBfunc==12 complex zB = z ^ (@zBfunc1 ( z + z * z / thezBvar1 )) ELSEIF @zBfunc==13 complex zB = (z ^ thezBvar1 )- (z * z / #pixel ) ELSEIF @zBfunc==14 complex zB = @zBfunc1 ( z / thezBvar1 ) ELSEIF @zBfunc==15 complex zB = (z + thezBvar1 )* (z - #pixel - thezBvar1 * (z )) ELSEIF @zBfunc==16 complex zB = (z + (@zBfunc1 ( z + 1 - #pixel ))) ELSEIF @zBfunc==17 complex zB = (z * thezBvar1 / ((@zBfunc1 ( z / z + thezBvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zBfunc==18 complex zB = (z * (@zBfunc1 ( z ^ thezBvar1))) ELSEIF @zBfunc==19 complex zB = (z - thezBvar1 )^ (z - #pixel * z ^ thezBvar2 ) ELSEIF @zBfunc==20 complex zB = ((@zBfunc1 ( thezBvar1 )* (z ))) ELSEIF @zBfunc==21 complex zB = ((@zBfunc1 ( z + thezBvar2 )/ (z ^ thezBvar1))) ELSEIF @zBfunc==22 complex zB = (thezBvar2 )* #pixel * ((@zBfunc1 ( z / thezBvar1 )* ((@zBfunc2 ( thezBvar2 )* (#pixel ))))) ELSEIF @zBfunc==23 complex zB = (@zBfunc1 ( z * thezBvar2 )* ((@zBfunc1 ( @zBfunc2 ( thezBvar1 ))))) ELSEIF @zBfunc==24 complex zB = (z + thezBvar1 )/ ((@zBfunc1 ( z - thezBvar2 ))) ELSEIF @zBfunc==25 complex zB = z - (@zBfunc2 ( z - (@zBfunc1 ( z + thezBvar1 )+ (z )))) ELSEIF @zBfunc==26 complex zB = z + z + (@zBfunc1 ( z ^ z - #pixel )) ELSEIF @zBfunc==27 complex zB = (thezBvar2 ^ (z * (@zBfunc1 ( z / (@zBfunc2 (thezBvar1 )))))) ELSEIF @zBfunc==28 complex zB = @zBfunc1 ( z / #pixel ) ELSEIF @zBfunc==29 complex zB = (z * z + (@zBfunc1 ( thezBvar1 ))) ELSEIF @zBfunc==30 complex zB = ((@zBfunc1 ( 1 - z * thezBvar1 ))) ELSEIF @zBfunc==31 complex zB = z + z * thezBvar1 - (@zBfunc1 ( z ^ #pixel )) ELSEIF @zBfunc==32 complex zB = (z - (z ^ thezBvar1 ))+ (#pixel ) ELSEIF @zBfunc==33 complex zB = z ^ thezBvar1 / (z ) ELSEIF @zBfunc==34 complex zB = z - (@zBfunc2 ( z / @zBfunc1 ( thezBvar1 ^ (thezBvar2 )))) ELSEIF @zBfunc==35 complex zB = (z ^ @zBfunc1 ( z - (@zBfunc1 ( z * @zBfunc2 ( thezBvar2 ))))) ELSEIF @zBfunc==36 complex zB = (z - #pixel / z + #pixel ) ELSEIF @zBfunc==37 complex zB = z * z - (@zBfunc1 ( z )) ELSEIF @zBfunc==38 complex zB = (z ^ (@zBfunc1 ( z + thezBvar1 )/ (thezBvar2 ))) ELSEIF @zBfunc==39 complex zB = (thezBvar1 - z) / (z - thezBvar2 ) ELSEIF @zBfunc==40 complex zB = z * (@zBfunc1 ( z + thezBvar1 )- #pixel + z ) ELSEIF @zBfunc==41 complex zB = (z - (@zBfunc2 ( 1 / z ))) ELSEIF @zBfunc==42 complex zB = @zBfunc1 ( z * thezBvar1 )- #pixel ^ z + z ELSEIF @zBfunc==43 complex zB = (z / z - thezBvar2 )/ (thezBvar1 )^ #pixel * (#pixel ) ELSEIF @zBfunc==44 complex zB = (z / thezBvar1 )+ (thezBvar2 / z) ELSEIF @zBfunc==45 complex zB = (z - thezBvar2 + z ^ thezBvar1 ) ELSEIF @zBfunc==46 complex zB = (z * thezBvar1 / #pixel )- ((@zBfunc1 ( z + @zBfunc2 ( thezBvar2 )))) ELSEIF @zBfunc==47 complex zB = thezBvar2 - (z * thezBvar1 ) ELSEIF @zBfunc==48 complex zB = z - z ^ thezBvar1 - (@zBfunc1 ( thezBvar2 )) ELSEIF @zBfunc==49 complex zB = (@zBfunc2 ( z - #pixel * @zBfunc1 ( thezBvar1 ))) ELSEIF @zBfunc==50 complex zB = (z / @zBfunc2 ( z - thezBvar1 )^ ((@zBfunc1 ( #pixel )))) ELSEIF @zBfunc==51 complex zB = (@zBfunc1 ( (@zBfunc2 ( thezBvar1 + z)))) ELSEIF @zBfunc==52 complex zB = (z / thezBvar1 )^ (#pixel - z + thezBvar2 ) ELSEIF @zBfunc==53 complex zB = (z - z ^ #pixel ) ELSEIF @zBfunc==54 complex zB = (z + thezBvar2 )^ z - thezBvar1 - (z ) ELSEIF @zBfunc==55 complex zB = (z ^ z - (@zBfunc1 ( #pixel ))) ELSEIF @zBfunc==56 complex zB = z + z ^ (@zBfunc1 ( #pixel )) ELSEIF @zBfunc==57 complex zB = (z * @zBfunc1 ( z * thezBvar1 )) ELSEIF @zBfunc==58 complex zB = z + (@zBfunc1 ( #pixel / z )) ELSEIF @zBfunc==59 complex zB = (z / thezBvar2 )+ @zBfunc2 ( thezBvar1 ) ELSEIF @zBfunc==60 complex zB = 1 / ( z * z - #pixel ) + thezBvar1 ELSEIF @zBfunc==61 complex zB = @zBfunc1(z) + @zBfunc2(#pixel) ELSEIF @zBfunc==62 complex zB = @zBfunc1(z) + @zBfunc1(thezBvar1) ELSEIF @zBfunc==63 complex zB = z * (@zBfunc1(thezBvar1 ^ thezBvar2) / @zBfunc2( thezBvar1 ^ thezBvar2))/thezBvar1 + (1/z) ELSEIF @zBfunc==64 complex zB = z * z + z / thezBvar1 + @zBfunc1 (thezBvar2) ELSEIF @zBfunc==65 complex zB = @zBfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zBfunc==66 complex zB = @zBfunc1( (z^2 + thezBvar1 - 1) / (2*z + thezBvar2 - 2) ) ELSEIF @zBfunc==67 complex zB = z - thezBvar1 * (z^thezBvar2-1) / (thezBvar2 * z^(thezBvar1-1)) + thezBvar1 ELSEIF @zBfunc==68 complex zB = z - thezBvar1 * (z^thezBvar2-1) / (thezBvar2 * z^(thezBvar1-1)) + #pixel ELSEIF @zBfunc==69 complex zB = ((thezBvar1 - 1) * z^thezBvar1 + thezBvar2) / (thezBvar1 * z ^ (thezBvar1 - 1)) ELSEIF @zBfunc==70 complex zB = (z ^ z + 1 / (z - 1 + z ^ thezBvar1 )+ ((atan2 ( (@zBfunc2 ( z - z - z ^ thezBvar1 )* ((@zBfunc2 ( z )))))))) ELSEIF @zBfunc==71 complex zB = (thezBvar1 ^ (thezBvar1 )/ @zBfunc2 ( 2 / (z + 4 ))) ELSEIF @zBfunc==72 complex zB = (4 + (@zBfunc1 ( @zBfunc2 ( thezBvar1 )^ @zBfunc1 ( thezBvar1 )+ ((@zBfunc1 ( #e )))))) ELSEIF @zBfunc==73 complex zB = (((@zBfunc1 (z - 2 - z - thezBvar1 )^ #pixel )* ((@zBfunc2 ( z ))))) ELSEIF @zBfunc==74 complex zB = thezBvar1 + #pixel * z ^ thezBvar1 * #pixel ELSEIF @zBfunc==75 complex zB = (z * thezBvar1 )- #pixel ELSEIF @zBfunc==76 complex zB = @zBfunc1 ( thezBvar1 )/ (@zBfunc1 ( z)) ELSEIF @zBfunc==77 complex zB = (z / thezBvar1 )+ (@zBfunc1 ( z + 1 )) ELSEIF @zBfunc==78 complex zB = (z - thezBvar1 + (z / @zBfunc1 ( #pixel ))) ELSEIF @zBfunc==79 complex zB = z * thezBvar1 - #pixel - z ELSEIF @zBfunc==80 complex zB = thezBvar1 * (z - thezBvar2 ^ (thezBvar1 )) ELSEIF @zBfunc==81 complex zB = (thezBvar1 )/ (z ^ thezBvar2 ^ z ) ELSEIF @zBfunc==82 complex zB = thezBvar1 ^ #pixel / (thezBvar1 ^ @zBfunc2 ( z * z )) ELSEIF @zBfunc==83 complex zB = (z / thezBvar1 - z ) ELSEIF @zBfunc==84 complex zB = ((@zBfunc1 ( thezBvar1 )- (thezBvar1 )^ (#random * thezBvar2))- @zBfunc1 ( 2 ^ (#pixel ))) ELSEIF @zBfunc==85 complex zB = (@zBfunc1 ( thezBvar1 )- (@zBfunc1 ( z ))) ELSEIF @zBfunc==86 complex zB = thezBvar1 ^ @zBfunc1 ( #pixel ) ELSEIF @zBfunc==87 complex zB = thezBvar1 * (@zBfunc2 ( 1 - #pixel )- z ) ELSEIF @zBfunc==88 complex zB = z - @zBfunc1 ( thezBvar1 / (z )) ELSEIF @zBfunc==89 complex zB = @zBfunc1 ( thezBvar1 / #pixel + (#pixel+z) ) ELSEIF @zBfunc==90 complex zB = z ^ thezBvar1 - (@zBfunc1 ( #pixel )) ELSEIF @zBfunc==91 complex zB = z * z - z + z ELSEIF @zBfunc==92 complex zB = (thezBvar1 / @zBfunc1 ( @zBfunc2 ( thezBvar1 ^ z - #pixel ))) ELSEIF @zBfunc==93 complex zB = z + thezBvar1 + @zBfunc1 ( @zBfunc2 ( z - @zBfunc2 ( z ))) ELSEIF @zBfunc==94 complex zB = z + thezBvar1 / thezBvar2 * z + thezBvar1 - (@zBfunc2 ( z )) ELSEIF @zBfunc==95 complex zB = z / thezBvar1 / z * #pixel ELSEIF @zBfunc==96 complex zB = thezBvar1 * (1 / z / 3) * (z ) ELSEIF @zBfunc==97 complex zB = z * thezBvar1 + z / thezBvar2 ^ (@zBfunc1 ( z + z )) ELSEIF @zBfunc==98 complex zB = @zBfunc1 ( thezBvar1 ^ #pixel / (@zBfunc2 ( z ))) ELSEIF @zBfunc==99 complex zB = (z / z - @zBfunc2 ( z * thezBvar1 ^ #pixel )) ENDIF IF @zCfunc==0 complex zC = z ELSEIF @zCfunc==1 complex zC = #pixel ELSEIF @zCfunc==2 complex zC = z*z+#pixel ELSEIF @zCfunc==3 complex zC = 1/z ELSEIF @zCfunc==4 complex zC = 1/#pixel ELSEIF @zCfunc==5 complex zC = thezCvar1 ELSEIF @zCfunc==6 complex zC = thezCvar2 ELSEIF @zCfunc==7 complex zC = @zCfunc1(z) ELSEIF @zCfunc==8 complex zC = @zCfunc1(#pixel) ELSEIF @zCfunc==9 complex zC = z*z+thezCvar1 ELSEIF @zCfunc==10 complex zC = @zCfunc1(z*z+thezCvar1) ELSEIF @zCfunc==11 complex zC = z * z - z / #pixel ELSEIF @zCfunc==12 complex zC = z ^ (@zCfunc1 ( z + z * z / thezCvar1 )) ELSEIF @zCfunc==13 complex zC = (z ^ thezCvar1 )- (z * z / #pixel ) ELSEIF @zCfunc==14 complex zC = @zCfunc1 ( z / thezCvar1 ) ELSEIF @zCfunc==15 complex zC = (z + thezCvar1 )* (z - #pixel - thezCvar1 * (z )) ELSEIF @zCfunc==16 complex zC = (z + (@zCfunc1 ( z + 1 - #pixel ))) ELSEIF @zCfunc==17 complex zC = (z * thezCvar1 / ((@zCfunc1 ( z / z + thezCvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zCfunc==18 complex zC = (z * (@zCfunc1 ( z ^ thezCvar1))) ELSEIF @zCfunc==19 complex zC = (z - thezCvar1 )^ (z - #pixel * z ^ thezCvar2 ) ELSEIF @zCfunc==20 complex zC = ((@zCfunc1 ( thezCvar1 )* (z ))) ELSEIF @zCfunc==21 complex zC = ((@zCfunc1 ( z + thezCvar2 )/ (z ^ thezCvar1))) ELSEIF @zCfunc==22 complex zC = (thezCvar2 )* #pixel * ((@zCfunc1 ( z / thezCvar1 )* ((@zCfunc2 ( thezCvar2 )* (#pixel ))))) ELSEIF @zCfunc==23 complex zC = (@zCfunc1 ( z * thezCvar2 )* ((@zCfunc1 ( @zCfunc2 ( thezCvar1 ))))) ELSEIF @zCfunc==24 complex zC = (z + thezCvar1 )/ ((@zCfunc1 ( z - thezCvar2 ))) ELSEIF @zCfunc==25 complex zC = z - (@zCfunc2 ( z - (@zCfunc1 ( z + thezCvar1 )+ (z )))) ELSEIF @zCfunc==26 complex zC = z + z + (@zCfunc1 ( z ^ z - #pixel )) ELSEIF @zCfunc==27 complex zC = (thezCvar2 ^ (z * (@zCfunc1 ( z / (@zCfunc2 (thezCvar1 )))))) ELSEIF @zCfunc==28 complex zC = @zCfunc1 ( z / #pixel ) ELSEIF @zCfunc==29 complex zC = (z * z + (@zCfunc1 ( thezCvar1 ))) ELSEIF @zCfunc==30 complex zC = ((@zCfunc1 ( 1 - z * thezCvar1 ))) ELSEIF @zCfunc==31 complex zC = z + z * thezCvar1 - (@zCfunc1 ( z ^ #pixel )) ELSEIF @zCfunc==32 complex zC = (z - (z ^ thezCvar1 ))+ (#pixel ) ELSEIF @zCfunc==33 complex zC = z ^ thezCvar1 / (z ) ELSEIF @zCfunc==34 complex zC = z - (@zCfunc2 ( z / @zCfunc1 ( thezCvar1 ^ (thezCvar2 )))) ELSEIF @zCfunc==35 complex zC = (z ^ @zCfunc1 ( z - (@zCfunc1 ( z * @zCfunc2 ( thezCvar2 ))))) ELSEIF @zCfunc==36 complex zC = (z - #pixel / z + #pixel ) ELSEIF @zCfunc==37 complex zC = z * z - (@zCfunc1 ( z )) ELSEIF @zCfunc==38 complex zC = (z ^ (@zCfunc1 ( z + thezCvar1 )/ (thezCvar2 ))) ELSEIF @zCfunc==39 complex zC = (thezCvar1 - z) / (z - thezCvar2 ) ELSEIF @zCfunc==40 complex zC = z * (@zCfunc1 ( z + thezCvar1 )- #pixel + z ) ELSEIF @zCfunc==41 complex zC = (z - (@zCfunc2 ( 1 / z ))) ELSEIF @zCfunc==42 complex zC = @zCfunc1 ( z * thezCvar1 )- #pixel ^ z + z ELSEIF @zCfunc==43 complex zC = (z / z - thezCvar2 )/ (thezCvar1 )^ #pixel * (#pixel ) ELSEIF @zCfunc==44 complex zC = (z / thezCvar1 )+ (thezCvar2 / z) ELSEIF @zCfunc==45 complex zC = (z - thezCvar2 + z ^ thezCvar1 ) ELSEIF @zCfunc==46 complex zC = (z * thezCvar1 / #pixel )- ((@zCfunc1 ( z + @zCfunc2 ( thezCvar2 )))) ELSEIF @zCfunc==47 complex zC = thezCvar2 - (z * thezCvar1 ) ELSEIF @zCfunc==48 complex zC = z - z ^ thezCvar1 - (@zCfunc1 ( thezCvar2 )) ELSEIF @zCfunc==49 complex zC = (@zCfunc2 ( z - #pixel * @zCfunc1 ( thezCvar1 ))) ELSEIF @zCfunc==50 complex zC = (z / @zCfunc2 ( z - thezCvar1 )^ ((@zCfunc1 ( #pixel )))) ELSEIF @zCfunc==51 complex zC = (@zCfunc1 ( (@zCfunc2 ( thezCvar1 + z)))) ELSEIF @zCfunc==52 complex zC = (z / thezCvar1 )^ (#pixel - z + thezCvar2 ) ELSEIF @zCfunc==53 complex zC = (z - z ^ #pixel ) ELSEIF @zCfunc==54 complex zC = (z + thezCvar2 )^ z - thezCvar1 - (z ) ELSEIF @zCfunc==55 complex zC = (z ^ z - (@zCfunc1 ( #pixel ))) ELSEIF @zCfunc==56 complex zC = z + z ^ (@zCfunc1 ( #pixel )) ELSEIF @zCfunc==57 complex zC = (z * @zCfunc1 ( z * thezCvar1 )) ELSEIF @zCfunc==58 complex zC = z + (@zCfunc1 ( #pixel / z )) ELSEIF @zCfunc==59 complex zC = (z / thezCvar2 )+ @zCfunc2 ( thezCvar1 ) ELSEIF @zCfunc==60 complex zC = 1 / ( z * z - #pixel ) + thezCvar1 ELSEIF @zCfunc==61 complex zC = @zCfunc1(z) + @zCfunc2(#pixel) ELSEIF @zCfunc==62 complex zC = @zCfunc1(z) + @zCfunc1(thezCvar1) ELSEIF @zCfunc==63 complex zC = z * (@zCfunc1(thezCvar1 ^ thezCvar2) / @zCfunc2( thezCvar1 ^ thezCvar2))/thezCvar1 + (1/z) ELSEIF @zCfunc==64 complex zC = z * z + z / thezCvar1 + @zCfunc1 (thezCvar2) ELSEIF @zCfunc==65 complex zC = @zCfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zCfunc==66 complex zC = @zCfunc1( (z^2 + thezCvar1 - 1) / (2*z + thezCvar2 - 2) ) ELSEIF @zCfunc==67 complex zC = z - thezCvar1 * (z^thezCvar2-1) / (thezCvar2 * z^(thezCvar1-1)) + thezCvar1 ELSEIF @zCfunc==68 complex zC = z - thezCvar1 * (z^thezCvar2-1) / (thezCvar2 * z^(thezCvar1-1)) + #pixel ELSEIF @zCfunc==69 complex zC = ((thezCvar1 - 1) * z^thezCvar1 + thezCvar2) / (thezCvar1 * z ^ (thezCvar1 - 1)) ELSEIF @zCfunc==70 complex zC = (z ^ z + 1 / (z - 1 + z ^ thezCvar1 )+ ((atan2 ( (@zCfunc2 ( z - z - z ^ thezCvar1 )* ((@zCfunc2 ( z )))))))) ELSEIF @zCfunc==71 complex zC = (thezCvar1 ^ (thezCvar1 )/ @zCfunc2 ( 2 / (z + 4 ))) ELSEIF @zCfunc==72 complex zC = (4 + (@zCfunc1 ( @zCfunc2 ( thezCvar1 )^ @zCfunc1 ( thezCvar1 )+ ((@zCfunc1 ( #e )))))) ELSEIF @zCfunc==73 complex zC = (((@zCfunc1 (z - 2 - z - thezCvar1 )^ #pixel )* ((@zCfunc2 ( z ))))) ELSEIF @zCfunc==74 complex zC = thezCvar1 + #pixel * z ^ thezCvar1 * #pixel ELSEIF @zCfunc==75 complex zC = (z * thezCvar1 )- #pixel ELSEIF @zCfunc==76 complex zC = @zCfunc1 ( thezCvar1 )/ (@zCfunc1 ( z)) ELSEIF @zCfunc==77 complex zC = (z / thezCvar1 )+ (@zCfunc1 ( z + 1 )) ELSEIF @zCfunc==78 complex zC = (z - thezCvar1 + (z / @zCfunc1 ( #pixel ))) ELSEIF @zCfunc==79 complex zC = z * thezCvar1 - #pixel - z ELSEIF @zCfunc==80 complex zC = thezCvar1 * (z - thezCvar2 ^ (thezCvar1 )) ELSEIF @zCfunc==81 complex zC = (thezCvar1 )/ (z ^ thezCvar2 ^ z ) ELSEIF @zCfunc==82 complex zC = thezCvar1 ^ #pixel / (thezCvar1 ^ @zCfunc2 ( z * z )) ELSEIF @zCfunc==83 complex zC = (z / thezCvar1 - z ) ELSEIF @zCfunc==84 complex zC = ((@zCfunc1 ( thezCvar1 )- (thezCvar1 )^ (#random * thezCvar2))- @zCfunc1 ( 2 ^ (#pixel ))) ELSEIF @zCfunc==85 complex zC = (@zCfunc1 ( thezCvar1 )- (@zCfunc1 ( z ))) ELSEIF @zCfunc==86 complex zC = thezCvar1 ^ @zCfunc1 ( #pixel ) ELSEIF @zCfunc==87 complex zC = thezCvar1 * (@zCfunc2 ( 1 - #pixel )- z ) ELSEIF @zCfunc==88 complex zC = z - @zCfunc1 ( thezCvar1 / (z )) ELSEIF @zCfunc==89 complex zC = @zCfunc1 ( thezCvar1 / #pixel + (#pixel+z) ) ELSEIF @zCfunc==90 complex zC = z ^ thezCvar1 - (@zCfunc1 ( #pixel )) ELSEIF @zCfunc==91 complex zC = z * z - z + z ELSEIF @zCfunc==92 complex zC = (thezCvar1 / @zCfunc1 ( @zCfunc2 ( thezCvar1 ^ z - #pixel ))) ELSEIF @zCfunc==93 complex zC = z + thezCvar1 + @zCfunc1 ( @zCfunc2 ( z - @zCfunc2 ( z ))) ELSEIF @zCfunc==94 complex zC = z + thezCvar1 / thezCvar2 * z + thezCvar1 - (@zCfunc2 ( z )) ELSEIF @zCfunc==95 complex zC = z / thezCvar1 / z * #pixel ELSEIF @zCfunc==96 complex zC = thezCvar1 * (1 / z / 3) * (z ) ELSEIF @zCfunc==97 complex zC = z * thezCvar1 + z / thezCvar2 ^ (@zCfunc1 ( z + z )) ELSEIF @zCfunc==98 complex zC = @zCfunc1 ( thezCvar1 ^ #pixel / (@zCfunc2 ( z ))) ELSEIF @zCfunc==99 complex zC = (z / z - @zCfunc2 ( z * thezCvar1 ^ #pixel )) ENDIF IF @zDfunc==0 complex zD = z ELSEIF @zDfunc==1 complex zD = #pixel ELSEIF @zDfunc==2 complex zD = z*z+#pixel ELSEIF @zDfunc==3 complex zD = 1/z ELSEIF @zDfunc==4 complex zD = 1/#pixel ELSEIF @zDfunc==5 complex zD = thezDvar1 ELSEIF @zDfunc==6 complex zD = thezDvar2 ELSEIF @zDfunc==7 complex zD = @zDfunc1(z) ELSEIF @zDfunc==8 complex zD = @zDfunc1(#pixel) ELSEIF @zDfunc==9 complex zD = z*z+thezDvar1 ELSEIF @zDfunc==10 complex zD = @zDfunc1(z*z+thezDvar1) ELSEIF @zDfunc==11 complex zD = z * z - z / #pixel ELSEIF @zDfunc==12 complex zD = z ^ (@zDfunc1 ( z + z * z / thezDvar1 )) ELSEIF @zDfunc==13 complex zD = (z ^ thezDvar1 )- (z * z / #pixel ) ELSEIF @zDfunc==14 complex zD = @zDfunc1 ( z / thezDvar1 ) ELSEIF @zDfunc==15 complex zD = (z + thezDvar1 )* (z - #pixel - thezDvar1 * (z )) ELSEIF @zDfunc==16 complex zD = (z + (@zDfunc1 ( z + 1 - #pixel ))) ELSEIF @zDfunc==17 complex zD = (z * thezDvar1 / ((@zDfunc1 ( z / z + thezDvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zDfunc==18 complex zD = (z * (@zDfunc1 ( z ^ thezDvar1))) ELSEIF @zDfunc==19 complex zD = (z - thezDvar1 )^ (z - #pixel * z ^ thezDvar2 ) ELSEIF @zDfunc==20 complex zD = ((@zDfunc1 ( thezDvar1 )* (z ))) ELSEIF @zDfunc==21 complex zD = ((@zDfunc1 ( z + thezDvar2 )/ (z ^ thezDvar1))) ELSEIF @zDfunc==22 complex zD = (thezDvar2 )* #pixel * ((@zDfunc1 ( z / thezDvar1 )* ((@zDfunc2 ( thezDvar2 )* (#pixel ))))) ELSEIF @zDfunc==23 complex zD = (@zDfunc1 ( z * thezDvar2 )* ((@zDfunc1 ( @zDfunc2 ( thezDvar1 ))))) ELSEIF @zDfunc==24 complex zD = (z + thezDvar1 )/ ((@zDfunc1 ( z - thezDvar2 ))) ELSEIF @zDfunc==25 complex zD = z - (@zDfunc2 ( z - (@zDfunc1 ( z + thezDvar1 )+ (z )))) ELSEIF @zDfunc==26 complex zD = z + z + (@zDfunc1 ( z ^ z - #pixel )) ELSEIF @zDfunc==27 complex zD = (thezDvar2 ^ (z * (@zDfunc1 ( z / (@zDfunc2 (thezDvar1 )))))) ELSEIF @zDfunc==28 complex zD = @zDfunc1 ( z / #pixel ) ELSEIF @zDfunc==29 complex zD = (z * z + (@zDfunc1 ( thezDvar1 ))) ELSEIF @zDfunc==30 complex zD = ((@zDfunc1 ( 1 - z * thezDvar1 ))) ELSEIF @zDfunc==31 complex zD = z + z * thezDvar1 - (@zDfunc1 ( z ^ #pixel )) ELSEIF @zDfunc==32 complex zD = (z - (z ^ thezDvar1 ))+ (#pixel ) ELSEIF @zDfunc==33 complex zD = z ^ thezDvar1 / (z ) ELSEIF @zDfunc==34 complex zD = z - (@zDfunc2 ( z / @zDfunc1 ( thezDvar1 ^ (thezDvar2 )))) ELSEIF @zDfunc==35 complex zD = (z ^ @zDfunc1 ( z - (@zDfunc1 ( z * @zDfunc2 ( thezDvar2 ))))) ELSEIF @zDfunc==36 complex zD = (z - #pixel / z + #pixel ) ELSEIF @zDfunc==37 complex zD = z * z - (@zDfunc1 ( z )) ELSEIF @zDfunc==38 complex zD = (z ^ (@zDfunc1 ( z + thezDvar1 )/ (thezDvar2 ))) ELSEIF @zDfunc==39 complex zD = (thezDvar1 - z) / (z - thezDvar2 ) ELSEIF @zDfunc==40 complex zD = z * (@zDfunc1 ( z + thezDvar1 )- #pixel + z ) ELSEIF @zDfunc==41 complex zD = (z - (@zDfunc2 ( 1 / z ))) ELSEIF @zDfunc==42 complex zD = @zDfunc1 ( z * thezDvar1 )- #pixel ^ z + z ELSEIF @zDfunc==43 complex zD = (z / z - thezDvar2 )/ (thezDvar1 )^ #pixel * (#pixel ) ELSEIF @zDfunc==44 complex zD = (z / thezDvar1 )+ (thezDvar2 / z) ELSEIF @zDfunc==45 complex zD = (z - thezDvar2 + z ^ thezDvar1 ) ELSEIF @zDfunc==46 complex zD = (z * thezDvar1 / #pixel )- ((@zDfunc1 ( z + @zDfunc2 ( thezDvar2 )))) ELSEIF @zDfunc==47 complex zD = thezDvar2 - (z * thezDvar1 ) ELSEIF @zDfunc==48 complex zD = z - z ^ thezDvar1 - (@zDfunc1 ( thezDvar2 )) ELSEIF @zDfunc==49 complex zD = (@zDfunc2 ( z - #pixel * @zDfunc1 ( thezDvar1 ))) ELSEIF @zDfunc==50 complex zD = (z / @zDfunc2 ( z - thezDvar1 )^ ((@zDfunc1 ( #pixel )))) ELSEIF @zDfunc==51 complex zD = (@zDfunc1 ( (@zDfunc2 ( thezDvar1 + z)))) ELSEIF @zDfunc==52 complex zD = (z / thezDvar1 )^ (#pixel - z + thezDvar2 ) ELSEIF @zDfunc==53 complex zD = (z - z ^ #pixel ) ELSEIF @zDfunc==54 complex zD = (z + thezDvar2 )^ z - thezDvar1 - (z ) ELSEIF @zDfunc==55 complex zD = (z ^ z - (@zDfunc1 ( #pixel ))) ELSEIF @zDfunc==56 complex zD = z + z ^ (@zDfunc1 ( #pixel )) ELSEIF @zDfunc==57 complex zD = (z * @zDfunc1 ( z * thezDvar1 )) ELSEIF @zDfunc==58 complex zD = z + (@zDfunc1 ( #pixel / z )) ELSEIF @zDfunc==59 complex zD = (z / thezDvar2 )+ @zDfunc2 ( thezDvar1 ) ELSEIF @zDfunc==60 complex zD = 1 / ( z * z - #pixel ) + thezDvar1 ELSEIF @zDfunc==61 complex zD = @zDfunc1(z) + @zDfunc2(#pixel) ELSEIF @zDfunc==62 complex zD = @zDfunc1(z) + @zDfunc1(thezDvar1) ELSEIF @zDfunc==63 complex zD = z * (@zDfunc1(thezDvar1 ^ thezDvar2) / @zDfunc2( thezDvar1 ^ thezDvar2))/thezDvar1 + (1/z) ELSEIF @zDfunc==64 complex zD = z * z + z / thezDvar1 + @zDfunc1 (thezDvar2) ELSEIF @zDfunc==65 complex zD = @zDfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zDfunc==66 complex zD = @zDfunc1( (z^2 + thezDvar1 - 1) / (2*z + thezDvar2 - 2) ) ELSEIF @zDfunc==67 complex zD = z - thezDvar1 * (z^thezDvar2-1) / (thezDvar2 * z^(thezDvar1-1)) + thezDvar1 ELSEIF @zDfunc==68 complex zD = z - thezDvar1 * (z^thezDvar2-1) / (thezDvar2 * z^(thezDvar1-1)) + #pixel ELSEIF @zDfunc==69 complex zD = ((thezDvar1 - 1) * z^thezDvar1 + thezDvar2) / (thezDvar1 * z ^ (thezDvar1 - 1)) ELSEIF @zDfunc==70 complex zD = (z ^ z + 1 / (z - 1 + z ^ thezDvar1 )+ ((atan2 ( (@zDfunc2 ( z - z - z ^ thezDvar1 )* ((@zDfunc2 ( z )))))))) ELSEIF @zDfunc==71 complex zD = (thezDvar1 ^ (thezDvar1 )/ @zDfunc2 ( 2 / (z + 4 ))) ELSEIF @zDfunc==72 complex zD = (4 + (@zDfunc1 ( @zDfunc2 ( thezDvar1 )^ @zDfunc1 ( thezDvar1 )+ ((@zDfunc1 ( #e )))))) ELSEIF @zDfunc==73 complex zD = (((@zDfunc1 (z - 2 - z - thezDvar1 )^ #pixel )* ((@zDfunc2 ( z ))))) ELSEIF @zDfunc==74 complex zD = thezDvar1 + #pixel * z ^ thezDvar1 * #pixel ELSEIF @zDfunc==75 complex zD = (z * thezDvar1 )- #pixel ELSEIF @zDfunc==76 complex zD = @zDfunc1 ( thezDvar1 )/ (@zDfunc1 ( z)) ELSEIF @zDfunc==77 complex zD = (z / thezDvar1 )+ (@zDfunc1 ( z + 1 )) ELSEIF @zDfunc==78 complex zD = (z - thezDvar1 + (z / @zDfunc1 ( #pixel ))) ELSEIF @zDfunc==79 complex zD = z * thezDvar1 - #pixel - z ELSEIF @zDfunc==80 complex zD = thezDvar1 * (z - thezDvar2 ^ (thezDvar1 )) ELSEIF @zDfunc==81 complex zD = (thezDvar1 )/ (z ^ thezDvar2 ^ z ) ELSEIF @zDfunc==82 complex zD = thezDvar1 ^ #pixel / (thezDvar1 ^ @zDfunc2 ( z * z )) ELSEIF @zDfunc==83 complex zD = (z / thezDvar1 - z ) ELSEIF @zDfunc==84 complex zD = ((@zDfunc1 ( thezDvar1 )- (thezDvar1 )^ (#random * thezDvar2))- @zDfunc1 ( 2 ^ (#pixel ))) ELSEIF @zDfunc==85 complex zD = (@zDfunc1 ( thezDvar1 )- (@zDfunc1 ( z ))) ELSEIF @zDfunc==86 complex zD = thezDvar1 ^ @zDfunc1 ( #pixel ) ELSEIF @zDfunc==87 complex zD = thezDvar1 * (@zDfunc2 ( 1 - #pixel )- z ) ELSEIF @zDfunc==88 complex zD = z - @zDfunc1 ( thezDvar1 / (z )) ELSEIF @zDfunc==89 complex zD = @zDfunc1 ( thezDvar1 / #pixel + (#pixel+z) ) ELSEIF @zDfunc==90 complex zD = z ^ thezDvar1 - (@zDfunc1 ( #pixel )) ELSEIF @zDfunc==91 complex zD = z * z - z + z ELSEIF @zDfunc==92 complex zD = (thezDvar1 / @zDfunc1 ( @zDfunc2 ( thezDvar1 ^ z - #pixel ))) ELSEIF @zDfunc==93 complex zD = z + thezDvar1 + @zDfunc1 ( @zDfunc2 ( z - @zDfunc2 ( z ))) ELSEIF @zDfunc==94 complex zD = z + thezDvar1 / thezDvar2 * z + thezDvar1 - (@zDfunc2 ( z )) ELSEIF @zDfunc==95 complex zD = z / thezDvar1 / z * #pixel ELSEIF @zDfunc==96 complex zD = thezDvar1 * (1 / z / 3) * (z ) ELSEIF @zDfunc==97 complex zD = z * thezDvar1 + z / thezDvar2 ^ (@zDfunc1 ( z + z )) ELSEIF @zDfunc==98 complex zD = @zDfunc1 ( thezDvar1 ^ #pixel / (@zDfunc2 ( z ))) ELSEIF @zDfunc==99 complex zD = (z / z - @zDfunc2 ( z * thezDvar1 ^ #pixel )) ENDIF IF @zEfunc==0 complex zE = z ELSEIF @zEfunc==1 complex zE = #pixel ELSEIF @zEfunc==2 complex zE = z*z+#pixel ELSEIF @zEfunc==3 complex zE = 1/z ELSEIF @zEfunc==4 complex zE = 1/#pixel ELSEIF @zEfunc==5 complex zE = thezEvar1 ELSEIF @zEfunc==6 complex zE = thezEvar2 ELSEIF @zEfunc==7 complex zE = @zEfunc1(z) ELSEIF @zEfunc==8 complex zE = @zEfunc1(#pixel) ELSEIF @zEfunc==9 complex zE = z*z+thezEvar1 ELSEIF @zEfunc==10 complex zE = @zEfunc1(z*z+thezEvar1) ELSEIF @zEfunc==11 complex zE = z * z - z / #pixel ELSEIF @zEfunc==12 complex zE = z ^ (@zEfunc1 ( z + z * z / thezEvar1 )) ELSEIF @zEfunc==13 complex zE = (z ^ thezEvar1 )- (z * z / #pixel ) ELSEIF @zEfunc==14 complex zE = @zEfunc1 ( z / thezEvar1 ) ELSEIF @zEfunc==15 complex zE = (z + thezEvar1 )* (z - #pixel - thezEvar1 * (z )) ELSEIF @zEfunc==16 complex zE = (z + (@zEfunc1 ( z + 1 - #pixel ))) ELSEIF @zEfunc==17 complex zE = (z * thezEvar1 / ((@zEfunc1 ( z / z + thezEvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zEfunc==18 complex zE = (z * (@zEfunc1 ( z ^ thezEvar1))) ELSEIF @zEfunc==19 complex zE = (z - thezEvar1 )^ (z - #pixel * z ^ thezEvar2 ) ELSEIF @zEfunc==20 complex zE = ((@zEfunc1 ( thezEvar1 )* (z ))) ELSEIF @zEfunc==21 complex zE = ((@zEfunc1 ( z + thezEvar2 )/ (z ^ thezEvar1))) ELSEIF @zEfunc==22 complex zE = (thezEvar2 )* #pixel * ((@zEfunc1 ( z / thezEvar1 )* ((@zEfunc2 ( thezEvar2 )* (#pixel ))))) ELSEIF @zEfunc==23 complex zE = (@zEfunc1 ( z * thezEvar2 )* ((@zEfunc1 ( @zEfunc2 ( thezEvar1 ))))) ELSEIF @zEfunc==24 complex zE = (z + thezEvar1 )/ ((@zEfunc1 ( z - thezEvar2 ))) ELSEIF @zEfunc==25 complex zE = z - (@zEfunc2 ( z - (@zEfunc1 ( z + thezEvar1 )+ (z )))) ELSEIF @zEfunc==26 complex zE = z + z + (@zEfunc1 ( z ^ z - #pixel )) ELSEIF @zEfunc==27 complex zE = (thezEvar2 ^ (z * (@zEfunc1 ( z / (@zEfunc2 (thezEvar1 )))))) ELSEIF @zEfunc==28 complex zE = @zEfunc1 ( z / #pixel ) ELSEIF @zEfunc==29 complex zE = (z * z + (@zEfunc1 ( thezEvar1 ))) ELSEIF @zEfunc==30 complex zE = ((@zEfunc1 ( 1 - z * thezEvar1 ))) ELSEIF @zEfunc==31 complex zE = z + z * thezEvar1 - (@zEfunc1 ( z ^ #pixel )) ELSEIF @zEfunc==32 complex zE = (z - (z ^ thezEvar1 ))+ (#pixel ) ELSEIF @zEfunc==33 complex zE = z ^ thezEvar1 / (z ) ELSEIF @zEfunc==34 complex zE = z - (@zEfunc2 ( z / @zEfunc1 ( thezEvar1 ^ (thezEvar2 )))) ELSEIF @zEfunc==35 complex zE = (z ^ @zEfunc1 ( z - (@zEfunc1 ( z * @zEfunc2 ( thezEvar2 ))))) ELSEIF @zEfunc==36 complex zE = (z - #pixel / z + #pixel ) ELSEIF @zEfunc==37 complex zE = z * z - (@zEfunc1 ( z )) ELSEIF @zEfunc==38 complex zE = (z ^ (@zEfunc1 ( z + thezEvar1 )/ (thezEvar2 ))) ELSEIF @zEfunc==39 complex zE = (thezEvar1 - z) / (z - thezEvar2 ) ELSEIF @zEfunc==40 complex zE = z * (@zEfunc1 ( z + thezEvar1 )- #pixel + z ) ELSEIF @zEfunc==41 complex zE = (z - (@zEfunc2 ( 1 / z ))) ELSEIF @zEfunc==42 complex zE = @zEfunc1 ( z * thezEvar1 )- #pixel ^ z + z ELSEIF @zEfunc==43 complex zE = (z / z - thezEvar2 )/ (thezEvar1 )^ #pixel * (#pixel ) ELSEIF @zEfunc==44 complex zE = (z / thezEvar1 )+ (thezEvar2 / z) ELSEIF @zEfunc==45 complex zE = (z - thezEvar2 + z ^ thezEvar1 ) ELSEIF @zEfunc==46 complex zE = (z * thezEvar1 / #pixel )- ((@zEfunc1 ( z + @zEfunc2 ( thezEvar2 )))) ELSEIF @zEfunc==47 complex zE = thezEvar2 - (z * thezEvar1 ) ELSEIF @zEfunc==48 complex zE = z - z ^ thezEvar1 - (@zEfunc1 ( thezEvar2 )) ELSEIF @zEfunc==49 complex zE = (@zEfunc2 ( z - #pixel * @zEfunc1 ( thezEvar1 ))) ELSEIF @zEfunc==50 complex zE = (z / @zEfunc2 ( z - thezEvar1 )^ ((@zEfunc1 ( #pixel )))) ELSEIF @zEfunc==51 complex zE = (@zEfunc1 ( (@zEfunc2 ( thezEvar1 + z)))) ELSEIF @zEfunc==52 complex zE = (z / thezEvar1 )^ (#pixel - z + thezEvar2 ) ELSEIF @zEfunc==53 complex zE = (z - z ^ #pixel ) ELSEIF @zEfunc==54 complex zE = (z + thezEvar2 )^ z - thezEvar1 - (z ) ELSEIF @zEfunc==55 complex zE = (z ^ z - (@zEfunc1 ( #pixel ))) ELSEIF @zEfunc==56 complex zE = z + z ^ (@zEfunc1 ( #pixel )) ELSEIF @zEfunc==57 complex zE = (z * @zEfunc1 ( z * thezEvar1 )) ELSEIF @zEfunc==58 complex zE = z + (@zEfunc1 ( #pixel / z )) ELSEIF @zEfunc==59 complex zE = (z / thezEvar2 )+ @zEfunc2 ( thezEvar1 ) ELSEIF @zEfunc==60 complex zE = 1 / ( z * z - #pixel ) + thezEvar1 ELSEIF @zEfunc==61 complex zE = @zEfunc1(z) + @zEfunc2(#pixel) ELSEIF @zEfunc==62 complex zE = @zEfunc1(z) + @zEfunc1(thezEvar1) ELSEIF @zEfunc==63 complex zE = z * (@zEfunc1(thezEvar1 ^ thezEvar2) / @zEfunc2( thezEvar1 ^ thezEvar2))/thezEvar1 + (1/z) ELSEIF @zEfunc==64 complex zE = z * z + z / thezEvar1 + @zEfunc1 (thezEvar2) ELSEIF @zEfunc==65 complex zE = @zEfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zEfunc==66 complex zE = @zEfunc1( (z^2 + thezEvar1 - 1) / (2*z + thezEvar2 - 2) ) ELSEIF @zEfunc==67 complex zE = z - thezEvar1 * (z^thezEvar2-1) / (thezEvar2 * z^(thezEvar1-1)) + thezEvar1 ELSEIF @zEfunc==68 complex zE = z - thezEvar1 * (z^thezEvar2-1) / (thezEvar2 * z^(thezEvar1-1)) + #pixel ELSEIF @zEfunc==69 complex zE = ((thezEvar1 - 1) * z^thezEvar1 + thezEvar2) / (thezEvar1 * z ^ (thezEvar1 - 1)) ELSEIF @zEfunc==70 complex zE = (z ^ z + 1 / (z - 1 + z ^ thezEvar1 )+ ((atan2 ( (@zEfunc2 ( z - z - z ^ thezEvar1 )* ((@zEfunc2 ( z )))))))) ELSEIF @zEfunc==71 complex zE = (thezEvar1 ^ (thezEvar1 )/ @zEfunc2 ( 2 / (z + 4 ))) ELSEIF @zEfunc==72 complex zE = (4 + (@zEfunc1 ( @zEfunc2 ( thezEvar1 )^ @zEfunc1 ( thezEvar1 )+ ((@zEfunc1 ( #e )))))) ELSEIF @zEfunc==73 complex zE = (((@zEfunc1 (z - 2 - z - thezEvar1 )^ #pixel )* ((@zEfunc2 ( z ))))) ELSEIF @zEfunc==74 complex zE = thezEvar1 + #pixel * z ^ thezEvar1 * #pixel ELSEIF @zEfunc==75 complex zE = (z * thezEvar1 )- #pixel ELSEIF @zEfunc==76 complex zE = @zEfunc1 ( thezEvar1 )/ (@zEfunc1 ( z)) ELSEIF @zEfunc==77 complex zE = (z / thezEvar1 )+ (@zEfunc1 ( z + 1 )) ELSEIF @zEfunc==78 complex zE = (z - thezEvar1 + (z / @zEfunc1 ( #pixel ))) ELSEIF @zEfunc==79 complex zE = z * thezEvar1 - #pixel - z ELSEIF @zEfunc==80 complex zE = thezEvar1 * (z - thezEvar2 ^ (thezEvar1 )) ELSEIF @zEfunc==81 complex zE = (thezEvar1 )/ (z ^ thezEvar2 ^ z ) ELSEIF @zEfunc==82 complex zE = thezEvar1 ^ #pixel / (thezEvar1 ^ @zEfunc2 ( z * z )) ELSEIF @zEfunc==83 complex zE = (z / thezEvar1 - z ) ELSEIF @zEfunc==84 complex zE = ((@zEfunc1 ( thezEvar1 )- (thezEvar1 )^ (#random * thezEvar2))- @zEfunc1 ( 2 ^ (#pixel ))) ELSEIF @zEfunc==85 complex zE = (@zEfunc1 ( thezEvar1 )- (@zEfunc1 ( z ))) ELSEIF @zEfunc==86 complex zE = thezEvar1 ^ @zEfunc1 ( #pixel ) ELSEIF @zEfunc==87 complex zE = thezEvar1 * (@zEfunc2 ( 1 - #pixel )- z ) ELSEIF @zEfunc==88 complex zE = z - @zEfunc1 ( thezEvar1 / (z )) ELSEIF @zEfunc==89 complex zE = @zEfunc1 ( thezEvar1 / #pixel + (#pixel+z) ) ELSEIF @zEfunc==90 complex zE = z ^ thezEvar1 - (@zEfunc1 ( #pixel )) ELSEIF @zEfunc==91 complex zE = z * z - z + z ELSEIF @zEfunc==92 complex zE = (thezEvar1 / @zEfunc1 ( @zEfunc2 ( thezEvar1 ^ z - #pixel ))) ELSEIF @zEfunc==93 complex zE = z + thezEvar1 + @zEfunc1 ( @zEfunc2 ( z - @zEfunc2 ( z ))) ELSEIF @zEfunc==94 complex zE = z + thezEvar1 / thezEvar2 * z + thezEvar1 - (@zEfunc2 ( z )) ELSEIF @zEfunc==95 complex zE = z / thezEvar1 / z * #pixel ELSEIF @zEfunc==96 complex zE = thezEvar1 * (1 / z / 3) * (z ) ELSEIF @zEfunc==97 complex zE = z * thezEvar1 + z / thezEvar2 ^ (@zEfunc1 ( z + z )) ELSEIF @zEfunc==98 complex zE = @zEfunc1 ( thezEvar1 ^ #pixel / (@zEfunc2 ( z ))) ELSEIF @zEfunc==99 complex zE = (z / z - @zEfunc2 ( z * thezEvar1 ^ #pixel )) ENDIF IF @zFfunc==0 complex zF = z ELSEIF @zFfunc==1 complex zF = #pixel ELSEIF @zFfunc==2 complex zF = z*z+#pixel ELSEIF @zFfunc==3 complex zF = 1/z ELSEIF @zFfunc==4 complex zF = 1/#pixel ELSEIF @zFfunc==5 complex zF = thezFvar1 ELSEIF @zFfunc==6 complex zF = thezFvar2 ELSEIF @zFfunc==7 complex zF = @zFfunc1(z) ELSEIF @zFfunc==8 complex zF = @zFfunc1(#pixel) ELSEIF @zFfunc==9 complex zF = z*z+thezFvar1 ELSEIF @zFfunc==10 complex zF = @zFfunc1(z*z+thezFvar1) ELSEIF @zFfunc==11 complex zF = z * z - z / #pixel ELSEIF @zFfunc==12 complex zF = z ^ (@zFfunc1 ( z + z * z / thezFvar1 )) ELSEIF @zFfunc==13 complex zF = (z ^ thezFvar1 )- (z * z / #pixel ) ELSEIF @zFfunc==14 complex zF = @zFfunc1 ( z / thezFvar1 ) ELSEIF @zFfunc==15 complex zF = (z + thezFvar1 )* (z - #pixel - thezFvar1 * (z )) ELSEIF @zFfunc==16 complex zF = (z + (@zFfunc1 ( z + 1 - #pixel ))) ELSEIF @zFfunc==17 complex zF = (z * thezFvar1 / ((@zFfunc1 ( z / z + thezFvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zFfunc==18 complex zF = (z * (@zFfunc1 ( z ^ thezFvar1))) ELSEIF @zFfunc==19 complex zF = (z - thezFvar1 )^ (z - #pixel * z ^ thezFvar2 ) ELSEIF @zFfunc==20 complex zF = ((@zFfunc1 ( thezFvar1 )* (z ))) ELSEIF @zFfunc==21 complex zF = ((@zFfunc1 ( z + thezFvar2 )/ (z ^ thezFvar1))) ELSEIF @zFfunc==22 complex zF = (thezFvar2 )* #pixel * ((@zFfunc1 ( z / thezFvar1 )* ((@zFfunc2 ( thezFvar2 )* (#pixel ))))) ELSEIF @zFfunc==23 complex zF = (@zFfunc1 ( z * thezFvar2 )* ((@zFfunc1 ( @zFfunc2 ( thezFvar1 ))))) ELSEIF @zFfunc==24 complex zF = (z + thezFvar1 )/ ((@zFfunc1 ( z - thezFvar2 ))) ELSEIF @zFfunc==25 complex zF = z - (@zFfunc2 ( z - (@zFfunc1 ( z + thezFvar1 )+ (z )))) ELSEIF @zFfunc==26 complex zF = z + z + (@zFfunc1 ( z ^ z - #pixel )) ELSEIF @zFfunc==27 complex zF = (thezFvar2 ^ (z * (@zFfunc1 ( z / (@zFfunc2 (thezFvar1 )))))) ELSEIF @zFfunc==28 complex zF = @zFfunc1 ( z / #pixel ) ELSEIF @zFfunc==29 complex zF = (z * z + (@zFfunc1 ( thezFvar1 ))) ELSEIF @zFfunc==30 complex zF = ((@zFfunc1 ( 1 - z * thezFvar1 ))) ELSEIF @zFfunc==31 complex zF = z + z * thezFvar1 - (@zFfunc1 ( z ^ #pixel )) ELSEIF @zFfunc==32 complex zF = (z - (z ^ thezFvar1 ))+ (#pixel ) ELSEIF @zFfunc==33 complex zF = z ^ thezFvar1 / (z ) ELSEIF @zFfunc==34 complex zF = z - (@zFfunc2 ( z / @zFfunc1 ( thezFvar1 ^ (thezFvar2 )))) ELSEIF @zFfunc==35 complex zF = (z ^ @zFfunc1 ( z - (@zFfunc1 ( z * @zFfunc2 ( thezFvar2 ))))) ELSEIF @zFfunc==36 complex zF = (z - #pixel / z + #pixel ) ELSEIF @zFfunc==37 complex zF = z * z - (@zFfunc1 ( z )) ELSEIF @zFfunc==38 complex zF = (z ^ (@zFfunc1 ( z + thezFvar1 )/ (thezFvar2 ))) ELSEIF @zFfunc==39 complex zF = (thezFvar1 - z) / (z - thezFvar2 ) ELSEIF @zFfunc==40 complex zF = z * (@zFfunc1 ( z + thezFvar1 )- #pixel + z ) ELSEIF @zFfunc==41 complex zF = (z - (@zFfunc2 ( 1 / z ))) ELSEIF @zFfunc==42 complex zF = @zFfunc1 ( z * thezFvar1 )- #pixel ^ z + z ELSEIF @zFfunc==43 complex zF = (z / z - thezFvar2 )/ (thezFvar1 )^ #pixel * (#pixel ) ELSEIF @zFfunc==44 complex zF = (z / thezFvar1 )+ (thezFvar2 / z) ELSEIF @zFfunc==45 complex zF = (z - thezFvar2 + z ^ thezFvar1 ) ELSEIF @zFfunc==46 complex zF = (z * thezFvar1 / #pixel )- ((@zFfunc1 ( z + @zFfunc2 ( thezFvar2 )))) ELSEIF @zFfunc==47 complex zF = thezFvar2 - (z * thezFvar1 ) ELSEIF @zFfunc==48 complex zF = z - z ^ thezFvar1 - (@zFfunc1 ( thezFvar2 )) ELSEIF @zFfunc==49 complex zF = (@zFfunc2 ( z - #pixel * @zFfunc1 ( thezFvar1 ))) ELSEIF @zFfunc==50 complex zF = (z / @zFfunc2 ( z - thezFvar1 )^ ((@zFfunc1 ( #pixel )))) ELSEIF @zFfunc==51 complex zF = (@zFfunc1 ( (@zFfunc2 ( thezFvar1 + z)))) ELSEIF @zFfunc==52 complex zF = (z / thezFvar1 )^ (#pixel - z + thezFvar2 ) ELSEIF @zFfunc==53 complex zF = (z - z ^ #pixel ) ELSEIF @zFfunc==54 complex zF = (z + thezFvar2 )^ z - thezFvar1 - (z ) ELSEIF @zFfunc==55 complex zF = (z ^ z - (@zFfunc1 ( #pixel ))) ELSEIF @zFfunc==56 complex zF = z + z ^ (@zFfunc1 ( #pixel )) ELSEIF @zFfunc==57 complex zF = (z * @zFfunc1 ( z * thezFvar1 )) ELSEIF @zFfunc==58 complex zF = z + (@zFfunc1 ( #pixel / z )) ELSEIF @zFfunc==59 complex zF = (z / thezFvar2 )+ @zFfunc2 ( thezFvar1 ) ELSEIF @zFfunc==60 complex zF = 1 / ( z * z - #pixel ) + thezFvar1 ELSEIF @zFfunc==61 complex zF = @zFfunc1(z) + @zFfunc2(#pixel) ELSEIF @zFfunc==62 complex zF = @zFfunc1(z) + @zFfunc1(thezFvar1) ELSEIF @zFfunc==63 complex zF = z * (@zFfunc1(thezFvar1 ^ thezFvar2) / @zFfunc2( thezFvar1 ^ thezFvar2))/thezFvar1 + (1/z) ELSEIF @zFfunc==64 complex zF = z * z + z / thezFvar1 + @zFfunc1 (thezFvar2) ELSEIF @zFfunc==65 complex zF = @zFfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zFfunc==66 complex zF = @zFfunc1( (z^2 + thezFvar1 - 1) / (2*z + thezFvar2 - 2) ) ELSEIF @zFfunc==67 complex zF = z - thezFvar1 * (z^thezFvar2-1) / (thezFvar2 * z^(thezFvar1-1)) + thezFvar1 ELSEIF @zFfunc==68 complex zF = z - thezFvar1 * (z^thezFvar2-1) / (thezFvar2 * z^(thezFvar1-1)) + #pixel ELSEIF @zFfunc==69 complex zF = ((thezFvar1 - 1) * z^thezFvar1 + thezFvar2) / (thezFvar1 * z ^ (thezFvar1 - 1)) ELSEIF @zFfunc==70 complex zF = (z ^ z + 1 / (z - 1 + z ^ thezFvar1 )+ ((atan2 ( (@zFfunc2 ( z - z - z ^ thezFvar1 )* ((@zFfunc2 ( z )))))))) ELSEIF @zFfunc==71 complex zF = (thezFvar1 ^ (thezFvar1 )/ @zFfunc2 ( 2 / (z + 4 ))) ELSEIF @zFfunc==72 complex zF = (4 + (@zFfunc1 ( @zFfunc2 ( thezFvar1 )^ @zFfunc1 ( thezFvar1 )+ ((@zFfunc1 ( #e )))))) ELSEIF @zFfunc==73 complex zF = (((@zFfunc1 (z - 2 - z - thezFvar1 )^ #pixel )* ((@zFfunc2 ( z ))))) ELSEIF @zFfunc==74 complex zF = thezFvar1 + #pixel * z ^ thezFvar1 * #pixel ELSEIF @zFfunc==75 complex zF = (z * thezFvar1 )- #pixel ELSEIF @zFfunc==76 complex zF = @zFfunc1 ( thezFvar1 )/ (@zFfunc1 ( z)) ELSEIF @zFfunc==77 complex zF = (z / thezFvar1 )+ (@zFfunc1 ( z + 1 )) ELSEIF @zFfunc==78 complex zF = (z - thezFvar1 + (z / @zFfunc1 ( #pixel ))) ELSEIF @zFfunc==79 complex zF = z * thezFvar1 - #pixel - z ELSEIF @zFfunc==80 complex zF = thezFvar1 * (z - thezFvar2 ^ (thezFvar1 )) ELSEIF @zFfunc==81 complex zF = (thezFvar1 )/ (z ^ thezFvar2 ^ z ) ELSEIF @zFfunc==82 complex zF = thezFvar1 ^ #pixel / (thezFvar1 ^ @zFfunc2 ( z * z )) ELSEIF @zFfunc==83 complex zF = (z / thezFvar1 - z ) ELSEIF @zFfunc==84 complex zF = ((@zFfunc1 ( thezFvar1 )- (thezFvar1 )^ (#random * thezFvar2))- @zFfunc1 ( 2 ^ (#pixel ))) ELSEIF @zFfunc==85 complex zF = (@zFfunc1 ( thezFvar1 )- (@zFfunc1 ( z ))) ELSEIF @zFfunc==86 complex zF = thezFvar1 ^ @zFfunc1 ( #pixel ) ELSEIF @zFfunc==87 complex zF = thezFvar1 * (@zFfunc2 ( 1 - #pixel )- z ) ELSEIF @zFfunc==88 complex zF = z - @zFfunc1 ( thezFvar1 / (z )) ELSEIF @zFfunc==89 complex zF = @zFfunc1 ( thezFvar1 / #pixel + (#pixel+z) ) ELSEIF @zFfunc==90 complex zF = z ^ thezFvar1 - (@zFfunc1 ( #pixel )) ELSEIF @zFfunc==91 complex zF = z * z - z + z ELSEIF @zFfunc==92 complex zF = (thezFvar1 / @zFfunc1 ( @zFfunc2 ( thezFvar1 ^ z - #pixel ))) ELSEIF @zFfunc==93 complex zF = z + thezFvar1 + @zFfunc1 ( @zFfunc2 ( z - @zFfunc2 ( z ))) ELSEIF @zFfunc==94 complex zF = z + thezFvar1 / thezFvar2 * z + thezFvar1 - (@zFfunc2 ( z )) ELSEIF @zFfunc==95 complex zF = z / thezFvar1 / z * #pixel ELSEIF @zFfunc==96 complex zF = thezFvar1 * (1 / z / 3) * (z ) ELSEIF @zFfunc==97 complex zF = z * thezFvar1 + z / thezFvar2 ^ (@zFfunc1 ( z + z )) ELSEIF @zFfunc==98 complex zF = @zFfunc1 ( thezFvar1 ^ #pixel / (@zFfunc2 ( z ))) ELSEIF @zFfunc==99 complex zF = (z / z - @zFfunc2 ( z * thezFvar1 ^ #pixel )) ENDIF IF @zGfunc==0 complex zG = z ELSEIF @zGfunc==1 complex zG = #pixel ELSEIF @zGfunc==2 complex zG = z*z+#pixel ELSEIF @zGfunc==3 complex zG = 1/z ELSEIF @zGfunc==4 complex zG = 1/#pixel ELSEIF @zGfunc==5 complex zG = thezGvar1 ELSEIF @zGfunc==6 complex zG = thezGvar2 ELSEIF @zGfunc==7 complex zG = @zGfunc1(z) ELSEIF @zGfunc==8 complex zG = @zGfunc1(#pixel) ELSEIF @zGfunc==9 complex zG = z*z+thezGvar1 ELSEIF @zGfunc==10 complex zG = @zGfunc1(z*z+thezGvar1) ELSEIF @zGfunc==11 complex zG = z * z - z / #pixel ELSEIF @zGfunc==12 complex zG = z ^ (@zGfunc1 ( z + z * z / thezGvar1 )) ELSEIF @zGfunc==13 complex zG = (z ^ thezGvar1 )- (z * z / #pixel ) ELSEIF @zGfunc==14 complex zG = @zGfunc1 ( z / thezGvar1 ) ELSEIF @zGfunc==15 complex zG = (z + thezGvar1 )* (z - #pixel - thezGvar1 * (z )) ELSEIF @zGfunc==16 complex zG = (z + (@zGfunc1 ( z + 1 - #pixel ))) ELSEIF @zGfunc==17 complex zG = (z * thezGvar1 / ((@zGfunc1 ( z / z + thezGvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zGfunc==18 complex zG = (z * (@zGfunc1 ( z ^ thezGvar1))) ELSEIF @zGfunc==19 complex zG = (z - thezGvar1 )^ (z - #pixel * z ^ thezGvar2 ) ELSEIF @zGfunc==20 complex zG = ((@zGfunc1 ( thezGvar1 )* (z ))) ELSEIF @zGfunc==21 complex zG = ((@zGfunc1 ( z + thezGvar2 )/ (z ^ thezGvar1))) ELSEIF @zGfunc==22 complex zG = (thezGvar2 )* #pixel * ((@zGfunc1 ( z / thezGvar1 )* ((@zGfunc2 ( thezGvar2 )* (#pixel ))))) ELSEIF @zGfunc==23 complex zG = (@zGfunc1 ( z * thezGvar2 )* ((@zGfunc1 ( @zGfunc2 ( thezGvar1 ))))) ELSEIF @zGfunc==24 complex zG = (z + thezGvar1 )/ ((@zGfunc1 ( z - thezGvar2 ))) ELSEIF @zGfunc==25 complex zG = z - (@zGfunc2 ( z - (@zGfunc1 ( z + thezGvar1 )+ (z )))) ELSEIF @zGfunc==26 complex zG = z + z + (@zGfunc1 ( z ^ z - #pixel )) ELSEIF @zGfunc==27 complex zG = (thezGvar2 ^ (z * (@zGfunc1 ( z / (@zGfunc2 (thezGvar1 )))))) ELSEIF @zGfunc==28 complex zG = @zGfunc1 ( z / #pixel ) ELSEIF @zGfunc==29 complex zG = (z * z + (@zGfunc1 ( thezGvar1 ))) ELSEIF @zGfunc==30 complex zG = ((@zGfunc1 ( 1 - z * thezGvar1 ))) ELSEIF @zGfunc==31 complex zG = z + z * thezGvar1 - (@zGfunc1 ( z ^ #pixel )) ELSEIF @zGfunc==32 complex zG = (z - (z ^ thezGvar1 ))+ (#pixel ) ELSEIF @zGfunc==33 complex zG = z ^ thezGvar1 / (z ) ELSEIF @zGfunc==34 complex zG = z - (@zGfunc2 ( z / @zGfunc1 ( thezGvar1 ^ (thezGvar2 )))) ELSEIF @zGfunc==35 complex zG = (z ^ @zGfunc1 ( z - (@zGfunc1 ( z * @zGfunc2 ( thezGvar2 ))))) ELSEIF @zGfunc==36 complex zG = (z - #pixel / z + #pixel ) ELSEIF @zGfunc==37 complex zG = z * z - (@zGfunc1 ( z )) ELSEIF @zGfunc==38 complex zG = (z ^ (@zGfunc1 ( z + thezGvar1 )/ (thezGvar2 ))) ELSEIF @zGfunc==39 complex zG = (thezGvar1 - z) / (z - thezGvar2 ) ELSEIF @zGfunc==40 complex zG = z * (@zGfunc1 ( z + thezGvar1 )- #pixel + z ) ELSEIF @zGfunc==41 complex zG = (z - (@zGfunc2 ( 1 / z ))) ELSEIF @zGfunc==42 complex zG = @zGfunc1 ( z * thezGvar1 )- #pixel ^ z + z ELSEIF @zGfunc==43 complex zG = (z / z - thezGvar2 )/ (thezGvar1 )^ #pixel * (#pixel ) ELSEIF @zGfunc==44 complex zG = (z / thezGvar1 )+ (thezGvar2 / z) ELSEIF @zGfunc==45 complex zG = (z - thezGvar2 + z ^ thezGvar1 ) ELSEIF @zGfunc==46 complex zG = (z * thezGvar1 / #pixel )- ((@zGfunc1 ( z + @zGfunc2 ( thezGvar2 )))) ELSEIF @zGfunc==47 complex zG = thezGvar2 - (z * thezGvar1 ) ELSEIF @zGfunc==48 complex zG = z - z ^ thezGvar1 - (@zGfunc1 ( thezGvar2 )) ELSEIF @zGfunc==49 complex zG = (@zGfunc2 ( z - #pixel * @zGfunc1 ( thezGvar1 ))) ELSEIF @zGfunc==50 complex zG = (z / @zGfunc2 ( z - thezGvar1 )^ ((@zGfunc1 ( #pixel )))) ELSEIF @zGfunc==51 complex zG = (@zGfunc1 ( (@zGfunc2 ( thezGvar1 + z)))) ELSEIF @zGfunc==52 complex zG = (z / thezGvar1 )^ (#pixel - z + thezGvar2 ) ELSEIF @zGfunc==53 complex zG = (z - z ^ #pixel ) ELSEIF @zGfunc==54 complex zG = (z + thezGvar2 )^ z - thezGvar1 - (z ) ELSEIF @zGfunc==55 complex zG = (z ^ z - (@zGfunc1 ( #pixel ))) ELSEIF @zGfunc==56 complex zG = z + z ^ (@zGfunc1 ( #pixel )) ELSEIF @zGfunc==57 complex zG = (z * @zGfunc1 ( z * thezGvar1 )) ELSEIF @zGfunc==58 complex zG = z + (@zGfunc1 ( #pixel / z )) ELSEIF @zGfunc==59 complex zG = (z / thezGvar2 )+ @zGfunc2 ( thezGvar1 ) ELSEIF @zGfunc==60 complex zG = 1 / ( z * z - #pixel ) + thezGvar1 ELSEIF @zGfunc==61 complex zG = @zGfunc1(z) + @zGfunc2(#pixel) ELSEIF @zGfunc==62 complex zG = @zGfunc1(z) + @zGfunc1(thezGvar1) ELSEIF @zGfunc==63 complex zG = z * (@zGfunc1(thezGvar1 ^ thezGvar2) / @zGfunc2( thezGvar1 ^ thezGvar2))/thezGvar1 + (1/z) ELSEIF @zGfunc==64 complex zG = z * z + z / thezGvar1 + @zGfunc1 (thezGvar2) ELSEIF @zGfunc==65 complex zG = @zGfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zGfunc==66 complex zG = @zGfunc1( (z^2 + thezGvar1 - 1) / (2*z + thezGvar2 - 2) ) ELSEIF @zGfunc==67 complex zG = z - thezGvar1 * (z^thezGvar2-1) / (thezGvar2 * z^(thezGvar1-1)) + thezGvar1 ELSEIF @zGfunc==68 complex zG = z - thezGvar1 * (z^thezGvar2-1) / (thezGvar2 * z^(thezGvar1-1)) + #pixel ELSEIF @zGfunc==69 complex zG = ((thezGvar1 - 1) * z^thezGvar1 + thezGvar2) / (thezGvar1 * z ^ (thezGvar1 - 1)) ELSEIF @zGfunc==70 complex zG = (z ^ z + 1 / (z - 1 + z ^ thezGvar1 )+ ((atan2 ( (@zGfunc2 ( z - z - z ^ thezGvar1 )* ((@zGfunc2 ( z )))))))) ELSEIF @zGfunc==71 complex zG = (thezGvar1 ^ (thezGvar1 )/ @zGfunc2 ( 2 / (z + 4 ))) ELSEIF @zGfunc==72 complex zG = (4 + (@zGfunc1 ( @zGfunc2 ( thezGvar1 )^ @zGfunc1 ( thezGvar1 )+ ((@zGfunc1 ( #e )))))) ELSEIF @zGfunc==73 complex zG = (((@zGfunc1 (z - 2 - z - thezGvar1 )^ #pixel )* ((@zGfunc2 ( z ))))) ELSEIF @zGfunc==74 complex zG = thezGvar1 + #pixel * z ^ thezGvar1 * #pixel ELSEIF @zGfunc==75 complex zG = (z * thezGvar1 )- #pixel ELSEIF @zGfunc==76 complex zG = @zGfunc1 ( thezGvar1 )/ (@zGfunc1 ( z)) ELSEIF @zGfunc==77 complex zG = (z / thezGvar1 )+ (@zGfunc1 ( z + 1 )) ELSEIF @zGfunc==78 complex zG = (z - thezGvar1 + (z / @zGfunc1 ( #pixel ))) ELSEIF @zGfunc==79 complex zG = z * thezGvar1 - #pixel - z ELSEIF @zGfunc==80 complex zG = thezGvar1 * (z - thezGvar2 ^ (thezGvar1 )) ELSEIF @zGfunc==81 complex zG = (thezGvar1 )/ (z ^ thezGvar2 ^ z ) ELSEIF @zGfunc==82 complex zG = thezGvar1 ^ #pixel / (thezGvar1 ^ @zGfunc2 ( z * z )) ELSEIF @zGfunc==83 complex zG = (z / thezGvar1 - z ) ELSEIF @zGfunc==84 complex zG = ((@zGfunc1 ( thezGvar1 )- (thezGvar1 )^ (#random * thezGvar2))- @zGfunc1 ( 2 ^ (#pixel ))) ELSEIF @zGfunc==85 complex zG = (@zGfunc1 ( thezGvar1 )- (@zGfunc1 ( z ))) ELSEIF @zGfunc==86 complex zG = thezGvar1 ^ @zGfunc1 ( #pixel ) ELSEIF @zGfunc==87 complex zG = thezGvar1 * (@zGfunc2 ( 1 - #pixel )- z ) ELSEIF @zGfunc==88 complex zG = z - @zGfunc1 ( thezGvar1 / (z )) ELSEIF @zGfunc==89 complex zG = @zGfunc1 ( thezGvar1 / #pixel + (#pixel+z) ) ELSEIF @zGfunc==90 complex zG = z ^ thezGvar1 - (@zGfunc1 ( #pixel )) ELSEIF @zGfunc==91 complex zG = z * z - z + z ELSEIF @zGfunc==92 complex zG = (thezGvar1 / @zGfunc1 ( @zGfunc2 ( thezGvar1 ^ z - #pixel ))) ELSEIF @zGfunc==93 complex zG = z + thezGvar1 + @zGfunc1 ( @zGfunc2 ( z - @zGfunc2 ( z ))) ELSEIF @zGfunc==94 complex zG = z + thezGvar1 / thezGvar2 * z + thezGvar1 - (@zGfunc2 ( z )) ELSEIF @zGfunc==95 complex zG = z / thezGvar1 / z * #pixel ELSEIF @zGfunc==96 complex zG = thezGvar1 * (1 / z / 3) * (z ) ELSEIF @zGfunc==97 complex zG = z * thezGvar1 + z / thezGvar2 ^ (@zGfunc1 ( z + z )) ELSEIF @zGfunc==98 complex zG = @zGfunc1 ( thezGvar1 ^ #pixel / (@zGfunc2 ( z ))) ELSEIF @zGfunc==99 complex zG = (z / z - @zGfunc2 ( z * thezGvar1 ^ #pixel )) ENDIF IF @zHfunc==0 complex zH = z ELSEIF @zHfunc==1 complex zH = #pixel ELSEIF @zHfunc==2 complex zH = z*z+#pixel ELSEIF @zHfunc==3 complex zH = 1/z ELSEIF @zHfunc==4 complex zH = 1/#pixel ELSEIF @zHfunc==5 complex zH = thezHvar1 ELSEIF @zHfunc==6 complex zH = thezHvar2 ELSEIF @zHfunc==7 complex zH = @zHfunc1(z) ELSEIF @zHfunc==8 complex zH = @zHfunc1(#pixel) ELSEIF @zHfunc==9 complex zH = z*z+thezHvar1 ELSEIF @zHfunc==10 complex zH = @zHfunc1(z*z+thezHvar1) ELSEIF @zHfunc==11 complex zH = z * z - z / #pixel ELSEIF @zHfunc==12 complex zH = z ^ (@zHfunc1 ( z + z * z / thezHvar1 )) ELSEIF @zHfunc==13 complex zH = (z ^ thezHvar1 )- (z * z / #pixel ) ELSEIF @zHfunc==14 complex zH = @zHfunc1 ( z / thezHvar1 ) ELSEIF @zHfunc==15 complex zH = (z + thezHvar1 )* (z - #pixel - thezHvar1 * (z )) ELSEIF @zHfunc==16 complex zH = (z + (@zHfunc1 ( z + 1 - #pixel ))) ELSEIF @zHfunc==17 complex zH = (z * thezHvar1 / ((@zHfunc1 ( z / z + thezHvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zHfunc==18 complex zH = (z * (@zHfunc1 ( z ^ thezHvar1))) ELSEIF @zHfunc==19 complex zH = (z - thezHvar1 )^ (z - #pixel * z ^ thezHvar2 ) ELSEIF @zHfunc==20 complex zH = ((@zHfunc1 ( thezHvar1 )* (z ))) ELSEIF @zHfunc==21 complex zH = ((@zHfunc1 ( z + thezHvar2 )/ (z ^ thezHvar1))) ELSEIF @zHfunc==22 complex zH = (thezHvar2 )* #pixel * ((@zHfunc1 ( z / thezHvar1 )* ((@zHfunc2 ( thezHvar2 )* (#pixel ))))) ELSEIF @zHfunc==23 complex zH = (@zHfunc1 ( z * thezHvar2 )* ((@zHfunc1 ( @zHfunc2 ( thezHvar1 ))))) ELSEIF @zHfunc==24 complex zH = (z + thezHvar1 )/ ((@zHfunc1 ( z - thezHvar2 ))) ELSEIF @zHfunc==25 complex zH = z - (@zHfunc2 ( z - (@zHfunc1 ( z + thezHvar1 )+ (z )))) ELSEIF @zHfunc==26 complex zH = z + z + (@zHfunc1 ( z ^ z - #pixel )) ELSEIF @zHfunc==27 complex zH = (thezHvar2 ^ (z * (@zHfunc1 ( z / (@zHfunc2 (thezHvar1 )))))) ELSEIF @zHfunc==28 complex zH = @zHfunc1 ( z / #pixel ) ELSEIF @zHfunc==29 complex zH = (z * z + (@zHfunc1 ( thezHvar1 ))) ELSEIF @zHfunc==30 complex zH = ((@zHfunc1 ( 1 - z * thezHvar1 ))) ELSEIF @zHfunc==31 complex zH = z + z * thezHvar1 - (@zHfunc1 ( z ^ #pixel )) ELSEIF @zHfunc==32 complex zH = (z - (z ^ thezHvar1 ))+ (#pixel ) ELSEIF @zHfunc==33 complex zH = z ^ thezHvar1 / (z ) ELSEIF @zHfunc==34 complex zH = z - (@zHfunc2 ( z / @zHfunc1 ( thezHvar1 ^ (thezHvar2 )))) ELSEIF @zHfunc==35 complex zH = (z ^ @zHfunc1 ( z - (@zHfunc1 ( z * @zHfunc2 ( thezHvar2 ))))) ELSEIF @zHfunc==36 complex zH = (z - #pixel / z + #pixel ) ELSEIF @zHfunc==37 complex zH = z * z - (@zHfunc1 ( z )) ELSEIF @zHfunc==38 complex zH = (z ^ (@zHfunc1 ( z + thezHvar1 )/ (thezHvar2 ))) ELSEIF @zHfunc==39 complex zH = (thezHvar1 - z) / (z - thezHvar2 ) ELSEIF @zHfunc==40 complex zH = z * (@zHfunc1 ( z + thezHvar1 )- #pixel + z ) ELSEIF @zHfunc==41 complex zH = (z - (@zHfunc2 ( 1 / z ))) ELSEIF @zHfunc==42 complex zH = @zHfunc1 ( z * thezHvar1 )- #pixel ^ z + z ELSEIF @zHfunc==43 complex zH = (z / z - thezHvar2 )/ (thezHvar1 )^ #pixel * (#pixel ) ELSEIF @zHfunc==44 complex zH = (z / thezHvar1 )+ (thezHvar2 / z) ELSEIF @zHfunc==45 complex zH = (z - thezHvar2 + z ^ thezHvar1 ) ELSEIF @zHfunc==46 complex zH = (z * thezHvar1 / #pixel )- ((@zHfunc1 ( z + @zHfunc2 ( thezHvar2 )))) ELSEIF @zHfunc==47 complex zH = thezHvar2 - (z * thezHvar1 ) ELSEIF @zHfunc==48 complex zH = z - z ^ thezHvar1 - (@zHfunc1 ( thezHvar2 )) ELSEIF @zHfunc==49 complex zH = (@zHfunc2 ( z - #pixel * @zHfunc1 ( thezHvar1 ))) ELSEIF @zHfunc==50 complex zH = (z / @zHfunc2 ( z - thezHvar1 )^ ((@zHfunc1 ( #pixel )))) ELSEIF @zHfunc==51 complex zH = (@zHfunc1 ( (@zHfunc2 ( thezHvar1 + z)))) ELSEIF @zHfunc==52 complex zH = (z / thezHvar1 )^ (#pixel - z + thezHvar2 ) ELSEIF @zHfunc==53 complex zH = (z - z ^ #pixel ) ELSEIF @zHfunc==54 complex zH = (z + thezHvar2 )^ z - thezHvar1 - (z ) ELSEIF @zHfunc==55 complex zH = (z ^ z - (@zHfunc1 ( #pixel ))) ELSEIF @zHfunc==56 complex zH = z + z ^ (@zHfunc1 ( #pixel )) ELSEIF @zHfunc==57 complex zH = (z * @zHfunc1 ( z * thezHvar1 )) ELSEIF @zHfunc==58 complex zH = z + (@zHfunc1 ( #pixel / z )) ELSEIF @zHfunc==59 complex zH = (z / thezHvar2 )+ @zHfunc2 ( thezHvar1 ) ELSEIF @zHfunc==60 complex zH = 1 / ( z * z - #pixel ) + thezHvar1 ELSEIF @zHfunc==61 complex zH = @zHfunc1(z) + @zHfunc2(#pixel) ELSEIF @zHfunc==62 complex zH = @zHfunc1(z) + @zHfunc1(thezHvar1) ELSEIF @zHfunc==63 complex zH = z * (@zHfunc1(thezHvar1 ^ thezHvar2) / @zHfunc2( thezHvar1 ^ thezHvar2))/thezHvar1 + (1/z) ELSEIF @zHfunc==64 complex zH = z * z + z / thezHvar1 + @zHfunc1 (thezHvar2) ELSEIF @zHfunc==65 complex zH = @zHfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zHfunc==66 complex zH = @zHfunc1( (z^2 + thezHvar1 - 1) / (2*z + thezHvar2 - 2) ) ELSEIF @zHfunc==67 complex zH = z - thezHvar1 * (z^thezHvar2-1) / (thezHvar2 * z^(thezHvar1-1)) + thezHvar1 ELSEIF @zHfunc==68 complex zH = z - thezHvar1 * (z^thezHvar2-1) / (thezHvar2 * z^(thezHvar1-1)) + #pixel ELSEIF @zHfunc==69 complex zH = ((thezHvar1 - 1) * z^thezHvar1 + thezHvar2) / (thezHvar1 * z ^ (thezHvar1 - 1)) ELSEIF @zHfunc==70 complex zH = (z ^ z + 1 / (z - 1 + z ^ thezHvar1 )+ ((atan2 ( (@zHfunc2 ( z - z - z ^ thezHvar1 )* ((@zHfunc2 ( z )))))))) ELSEIF @zHfunc==71 complex zH = (thezHvar1 ^ (thezHvar1 )/ @zHfunc2 ( 2 / (z + 4 ))) ELSEIF @zHfunc==72 complex zH = (4 + (@zHfunc1 ( @zHfunc2 ( thezHvar1 )^ @zHfunc1 ( thezHvar1 )+ ((@zHfunc1 ( #e )))))) ELSEIF @zHfunc==73 complex zH = (((@zHfunc1 (z - 2 - z - thezHvar1 )^ #pixel )* ((@zHfunc2 ( z ))))) ELSEIF @zHfunc==74 complex zH = thezHvar1 + #pixel * z ^ thezHvar1 * #pixel ELSEIF @zHfunc==75 complex zH = (z * thezHvar1 )- #pixel ELSEIF @zHfunc==76 complex zH = @zHfunc1 ( thezHvar1 )/ (@zHfunc1 ( z)) ELSEIF @zHfunc==77 complex zH = (z / thezHvar1 )+ (@zHfunc1 ( z + 1 )) ELSEIF @zHfunc==78 complex zH = (z - thezHvar1 + (z / @zHfunc1 ( #pixel ))) ELSEIF @zHfunc==79 complex zH = z * thezHvar1 - #pixel - z ELSEIF @zHfunc==80 complex zH = thezHvar1 * (z - thezHvar2 ^ (thezHvar1 )) ELSEIF @zHfunc==81 complex zH = (thezHvar1 )/ (z ^ thezHvar2 ^ z ) ELSEIF @zHfunc==82 complex zH = thezHvar1 ^ #pixel / (thezHvar1 ^ @zHfunc2 ( z * z )) ELSEIF @zHfunc==83 complex zH = (z / thezHvar1 - z ) ELSEIF @zHfunc==84 complex zH = ((@zHfunc1 ( thezHvar1 )- (thezHvar1 )^ (#random * thezHvar2))- @zHfunc1 ( 2 ^ (#pixel ))) ELSEIF @zHfunc==85 complex zH = (@zHfunc1 ( thezHvar1 )- (@zHfunc1 ( z ))) ELSEIF @zHfunc==86 complex zH = thezHvar1 ^ @zHfunc1 ( #pixel ) ELSEIF @zHfunc==87 complex zH = thezHvar1 * (@zHfunc2 ( 1 - #pixel )- z ) ELSEIF @zHfunc==88 complex zH = z - @zHfunc1 ( thezHvar1 / (z )) ELSEIF @zHfunc==89 complex zH = @zHfunc1 ( thezHvar1 / #pixel + (#pixel+z) ) ELSEIF @zHfunc==90 complex zH = z ^ thezHvar1 - (@zHfunc1 ( #pixel )) ELSEIF @zHfunc==91 complex zH = z * z - z + z ELSEIF @zHfunc==92 complex zH = (thezHvar1 / @zHfunc1 ( @zHfunc2 ( thezHvar1 ^ z - #pixel ))) ELSEIF @zHfunc==93 complex zH = z + thezHvar1 + @zHfunc1 ( @zHfunc2 ( z - @zHfunc2 ( z ))) ELSEIF @zHfunc==94 complex zH = z + thezHvar1 / thezHvar2 * z + thezHvar1 - (@zHfunc2 ( z )) ELSEIF @zHfunc==95 complex zH = z / thezHvar1 / z * #pixel ELSEIF @zHfunc==96 complex zH = thezHvar1 * (1 / z / 3) * (z ) ELSEIF @zHfunc==97 complex zH = z * thezHvar1 + z / thezHvar2 ^ (@zHfunc1 ( z + z )) ELSEIF @zHfunc==98 complex zH = @zHfunc1 ( thezHvar1 ^ #pixel / (@zHfunc2 ( z ))) ELSEIF @zHfunc==99 complex zH = (z / z - @zHfunc2 ( z * thezHvar1 ^ #pixel )) ENDIF IF @zIfunc==0 complex zI = z ELSEIF @zIfunc==1 complex zI = #pixel ELSEIF @zIfunc==2 complex zI = z*z+#pixel ELSEIF @zIfunc==3 complex zI = 1/z ELSEIF @zIfunc==4 complex zI = 1/#pixel ELSEIF @zIfunc==5 complex zI = thezIvar1 ELSEIF @zIfunc==6 complex zI = thezIvar2 ELSEIF @zIfunc==7 complex zI = @zIfunc1(z) ELSEIF @zIfunc==8 complex zI = @zIfunc1(#pixel) ELSEIF @zIfunc==9 complex zI = z*z+thezIvar1 ELSEIF @zIfunc==10 complex zI = @zIfunc1(z*z+thezIvar1) ELSEIF @zIfunc==11 complex zI = z * z - z / #pixel ELSEIF @zIfunc==12 complex zI = z ^ (@zIfunc1 ( z + z * z / thezIvar1 )) ELSEIF @zIfunc==13 complex zI = (z ^ thezIvar1 )- (z * z / #pixel ) ELSEIF @zIfunc==14 complex zI = @zIfunc1 ( z / thezIvar1 ) ELSEIF @zIfunc==15 complex zI = (z + thezIvar1 )* (z - #pixel - thezIvar1 * (z )) ELSEIF @zIfunc==16 complex zI = (z + (@zIfunc1 ( z + 1 - #pixel ))) ELSEIF @zIfunc==17 complex zI = (z * thezIvar1 / ((@zIfunc1 ( z / z + thezIvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zIfunc==18 complex zI = (z * (@zIfunc1 ( z ^ thezIvar1))) ELSEIF @zIfunc==19 complex zI = (z - thezIvar1 )^ (z - #pixel * z ^ thezIvar2 ) ELSEIF @zIfunc==20 complex zI = ((@zIfunc1 ( thezIvar1 )* (z ))) ELSEIF @zIfunc==21 complex zI = ((@zIfunc1 ( z + thezIvar2 )/ (z ^ thezIvar1))) ELSEIF @zIfunc==22 complex zI = (thezIvar2 )* #pixel * ((@zIfunc1 ( z / thezIvar1 )* ((@zIfunc2 ( thezIvar2 )* (#pixel ))))) ELSEIF @zIfunc==23 complex zI = (@zIfunc1 ( z * thezIvar2 )* ((@zIfunc1 ( @zIfunc2 ( thezIvar1 ))))) ELSEIF @zIfunc==24 complex zI = (z + thezIvar1 )/ ((@zIfunc1 ( z - thezIvar2 ))) ELSEIF @zIfunc==25 complex zI = z - (@zIfunc2 ( z - (@zIfunc1 ( z + thezIvar1 )+ (z )))) ELSEIF @zIfunc==26 complex zI = z + z + (@zIfunc1 ( z ^ z - #pixel )) ELSEIF @zIfunc==27 complex zI = (thezIvar2 ^ (z * (@zIfunc1 ( z / (@zIfunc2 (thezIvar1 )))))) ELSEIF @zIfunc==28 complex zI = @zIfunc1 ( z / #pixel ) ELSEIF @zIfunc==29 complex zI = (z * z + (@zIfunc1 ( thezIvar1 ))) ELSEIF @zIfunc==30 complex zI = ((@zIfunc1 ( 1 - z * thezIvar1 ))) ELSEIF @zIfunc==31 complex zI = z + z * thezIvar1 - (@zIfunc1 ( z ^ #pixel )) ELSEIF @zIfunc==32 complex zI = (z - (z ^ thezIvar1 ))+ (#pixel ) ELSEIF @zIfunc==33 complex zI = z ^ thezIvar1 / (z ) ELSEIF @zIfunc==34 complex zI = z - (@zIfunc2 ( z / @zIfunc1 ( thezIvar1 ^ (thezIvar2 )))) ELSEIF @zIfunc==35 complex zI = (z ^ @zIfunc1 ( z - (@zIfunc1 ( z * @zIfunc2 ( thezIvar2 ))))) ELSEIF @zIfunc==36 complex zI = (z - #pixel / z + #pixel ) ELSEIF @zIfunc==37 complex zI = z * z - (@zIfunc1 ( z )) ELSEIF @zIfunc==38 complex zI = (z ^ (@zIfunc1 ( z + thezIvar1 )/ (thezIvar2 ))) ELSEIF @zIfunc==39 complex zI = (thezIvar1 - z) / (z - thezIvar2 ) ELSEIF @zIfunc==40 complex zI = z * (@zIfunc1 ( z + thezIvar1 )- #pixel + z ) ELSEIF @zIfunc==41 complex zI = (z - (@zIfunc2 ( 1 / z ))) ELSEIF @zIfunc==42 complex zI = @zIfunc1 ( z * thezIvar1 )- #pixel ^ z + z ELSEIF @zIfunc==43 complex zI = (z / z - thezIvar2 )/ (thezIvar1 )^ #pixel * (#pixel ) ELSEIF @zIfunc==44 complex zI = (z / thezIvar1 )+ (thezIvar2 / z) ELSEIF @zIfunc==45 complex zI = (z - thezIvar2 + z ^ thezIvar1 ) ELSEIF @zIfunc==46 complex zI = (z * thezIvar1 / #pixel )- ((@zIfunc1 ( z + @zIfunc2 ( thezIvar2 )))) ELSEIF @zIfunc==47 complex zI = thezIvar2 - (z * thezIvar1 ) ELSEIF @zIfunc==48 complex zI = z - z ^ thezIvar1 - (@zIfunc1 ( thezIvar2 )) ELSEIF @zIfunc==49 complex zI = (@zIfunc2 ( z - #pixel * @zIfunc1 ( thezIvar1 ))) ELSEIF @zIfunc==50 complex zI = (z / @zIfunc2 ( z - thezIvar1 )^ ((@zIfunc1 ( #pixel )))) ELSEIF @zIfunc==51 complex zI = (@zIfunc1 ( (@zIfunc2 ( thezIvar1 + z)))) ELSEIF @zIfunc==52 complex zI = (z / thezIvar1 )^ (#pixel - z + thezIvar2 ) ELSEIF @zIfunc==53 complex zI = (z - z ^ #pixel ) ELSEIF @zIfunc==54 complex zI = (z + thezIvar2 )^ z - thezIvar1 - (z ) ELSEIF @zIfunc==55 complex zI = (z ^ z - (@zIfunc1 ( #pixel ))) ELSEIF @zIfunc==56 complex zI = z + z ^ (@zIfunc1 ( #pixel )) ELSEIF @zIfunc==57 complex zI = (z * @zIfunc1 ( z * thezIvar1 )) ELSEIF @zIfunc==58 complex zI = z + (@zIfunc1 ( #pixel / z )) ELSEIF @zIfunc==59 complex zI = (z / thezIvar2 )+ @zIfunc2 ( thezIvar1 ) ELSEIF @zIfunc==60 complex zI = 1 / ( z * z - #pixel ) + thezIvar1 ELSEIF @zIfunc==61 complex zI = @zIfunc1(z) + @zIfunc2(#pixel) ELSEIF @zIfunc==62 complex zI = @zIfunc1(z) + @zIfunc1(thezIvar1) ELSEIF @zIfunc==63 complex zI = z * (@zIfunc1(thezIvar1 ^ thezIvar2) / @zIfunc2( thezIvar1 ^ thezIvar2))/thezIvar1 + (1/z) ELSEIF @zIfunc==64 complex zI = z * z + z / thezIvar1 + @zIfunc1 (thezIvar2) ELSEIF @zIfunc==65 complex zI = @zIfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zIfunc==66 complex zI = @zIfunc1( (z^2 + thezIvar1 - 1) / (2*z + thezIvar2 - 2) ) ELSEIF @zIfunc==67 complex zI = z - thezIvar1 * (z^thezIvar2-1) / (thezIvar2 * z^(thezIvar1-1)) + thezIvar1 ELSEIF @zIfunc==68 complex zI = z - thezIvar1 * (z^thezIvar2-1) / (thezIvar2 * z^(thezIvar1-1)) + #pixel ELSEIF @zIfunc==69 complex zI = ((thezIvar1 - 1) * z^thezIvar1 + thezIvar2) / (thezIvar1 * z ^ (thezIvar1 - 1)) ELSEIF @zIfunc==70 complex zI = (z ^ z + 1 / (z - 1 + z ^ thezIvar1 )+ ((atan2 ( (@zIfunc2 ( z - z - z ^ thezIvar1 )* ((@zIfunc2 ( z )))))))) ELSEIF @zIfunc==71 complex zI = (thezIvar1 ^ (thezIvar1 )/ @zIfunc2 ( 2 / (z + 4 ))) ELSEIF @zIfunc==72 complex zI = (4 + (@zIfunc1 ( @zIfunc2 ( thezIvar1 )^ @zIfunc1 ( thezIvar1 )+ ((@zIfunc1 ( #e )))))) ELSEIF @zIfunc==73 complex zI = (((@zIfunc1 (z - 2 - z - thezIvar1 )^ #pixel )* ((@zIfunc2 ( z ))))) ELSEIF @zIfunc==74 complex zI = thezIvar1 + #pixel * z ^ thezIvar1 * #pixel ELSEIF @zIfunc==75 complex zI = (z * thezIvar1 )- #pixel ELSEIF @zIfunc==76 complex zI = @zIfunc1 ( thezIvar1 )/ (@zIfunc1 ( z)) ELSEIF @zIfunc==77 complex zI = (z / thezIvar1 )+ (@zIfunc1 ( z + 1 )) ELSEIF @zIfunc==78 complex zI = (z - thezIvar1 + (z / @zIfunc1 ( #pixel ))) ELSEIF @zIfunc==79 complex zI = z * thezIvar1 - #pixel - z ELSEIF @zIfunc==80 complex zI = thezIvar1 * (z - thezIvar2 ^ (thezIvar1 )) ELSEIF @zIfunc==81 complex zI = (thezIvar1 )/ (z ^ thezIvar2 ^ z ) ELSEIF @zIfunc==82 complex zI = thezIvar1 ^ #pixel / (thezIvar1 ^ @zIfunc2 ( z * z )) ELSEIF @zIfunc==83 complex zI = (z / thezIvar1 - z ) ELSEIF @zIfunc==84 complex zI = ((@zIfunc1 ( thezIvar1 )- (thezIvar1 )^ (#random * thezIvar2))- @zIfunc1 ( 2 ^ (#pixel ))) ELSEIF @zIfunc==85 complex zI = (@zIfunc1 ( thezIvar1 )- (@zIfunc1 ( z ))) ELSEIF @zIfunc==86 complex zI = thezIvar1 ^ @zIfunc1 ( #pixel ) ELSEIF @zIfunc==87 complex zI = thezIvar1 * (@zIfunc2 ( 1 - #pixel )- z ) ELSEIF @zIfunc==88 complex zI = z - @zIfunc1 ( thezIvar1 / (z )) ELSEIF @zIfunc==89 complex zI = @zIfunc1 ( thezIvar1 / #pixel + (#pixel+z) ) ELSEIF @zIfunc==90 complex zI = z ^ thezIvar1 - (@zIfunc1 ( #pixel )) ELSEIF @zIfunc==91 complex zI = z * z - z + z ELSEIF @zIfunc==92 complex zI = (thezIvar1 / @zIfunc1 ( @zIfunc2 ( thezIvar1 ^ z - #pixel ))) ELSEIF @zIfunc==93 complex zI = z + thezIvar1 + @zIfunc1 ( @zIfunc2 ( z - @zIfunc2 ( z ))) ELSEIF @zIfunc==94 complex zI = z + thezIvar1 / thezIvar2 * z + thezIvar1 - (@zIfunc2 ( z )) ELSEIF @zIfunc==95 complex zI = z / thezIvar1 / z * #pixel ELSEIF @zIfunc==96 complex zI = thezIvar1 * (1 / z / 3) * (z ) ELSEIF @zIfunc==97 complex zI = z * thezIvar1 + z / thezIvar2 ^ (@zIfunc1 ( z + z )) ELSEIF @zIfunc==98 complex zI = @zIfunc1 ( thezIvar1 ^ #pixel / (@zIfunc2 ( z ))) ELSEIF @zIfunc==99 complex zI = (z / z - @zIfunc2 ( z * thezIvar1 ^ #pixel )) ENDIF IF @zJfunc==0 complex zJ = z ELSEIF @zJfunc==1 complex zJ = #pixel ELSEIF @zJfunc==2 complex zJ = z*z+#pixel ELSEIF @zJfunc==3 complex zJ = 1/z ELSEIF @zJfunc==4 complex zJ = 1/#pixel ELSEIF @zJfunc==5 complex zJ = thezJvar1 ELSEIF @zJfunc==6 complex zJ = thezJvar2 ELSEIF @zJfunc==7 complex zJ = @zJfunc1(z) ELSEIF @zJfunc==8 complex zJ = @zJfunc1(#pixel) ELSEIF @zJfunc==9 complex zJ = z*z+thezJvar1 ELSEIF @zJfunc==10 complex zJ = @zJfunc1(z*z+thezJvar1) ELSEIF @zJfunc==11 complex zJ = z * z - z / #pixel ELSEIF @zJfunc==12 complex zJ = z ^ (@zJfunc1 ( z + z * z / thezJvar1 )) ELSEIF @zJfunc==13 complex zJ = (z ^ thezJvar1 )- (z * z / #pixel ) ELSEIF @zJfunc==14 complex zJ = @zJfunc1 ( z / thezJvar1 ) ELSEIF @zJfunc==15 complex zJ = (z + thezJvar1 )* (z - #pixel - thezJvar1 * (z )) ELSEIF @zJfunc==16 complex zJ = (z + (@zJfunc1 ( z + 1 - #pixel ))) ELSEIF @zJfunc==17 complex zJ = (z * thezJvar1 / ((@zJfunc1 ( z / z + thezJvar2 )- #pixel )^ (z - #pixel ))) ELSEIF @zJfunc==18 complex zJ = (z * (@zJfunc1 ( z ^ thezJvar1))) ELSEIF @zJfunc==19 complex zJ = (z - thezJvar1 )^ (z - #pixel * z ^ thezJvar2 ) ELSEIF @zJfunc==20 complex zJ = ((@zJfunc1 ( thezJvar1 )* (z ))) ELSEIF @zJfunc==21 complex zJ = ((@zJfunc1 ( z + thezJvar2 )/ (z ^ thezJvar1))) ELSEIF @zJfunc==22 complex zJ = (thezJvar2 )* #pixel * ((@zJfunc1 ( z / thezJvar1 )* ((@zJfunc2 ( thezJvar2 )* (#pixel ))))) ELSEIF @zJfunc==23 complex zJ = (@zJfunc1 ( z * thezJvar2 )* ((@zJfunc1 ( @zJfunc2 ( thezJvar1 ))))) ELSEIF @zJfunc==24 complex zJ = (z + thezJvar1 )/ ((@zJfunc1 ( z - thezJvar2 ))) ELSEIF @zJfunc==25 complex zJ = z - (@zJfunc2 ( z - (@zJfunc1 ( z + thezJvar1 )+ (z )))) ELSEIF @zJfunc==26 complex zJ = z + z + (@zJfunc1 ( z ^ z - #pixel )) ELSEIF @zJfunc==27 complex zJ = (thezJvar2 ^ (z * (@zJfunc1 ( z / (@zJfunc2 (thezJvar1 )))))) ELSEIF @zJfunc==28 complex zJ = @zJfunc1 ( z / #pixel ) ELSEIF @zJfunc==29 complex zJ = (z * z + (@zJfunc1 ( thezJvar1 ))) ELSEIF @zJfunc==30 complex zJ = ((@zJfunc1 ( 1 - z * thezJvar1 ))) ELSEIF @zJfunc==31 complex zJ = z + z * thezJvar1 - (@zJfunc1 ( z ^ #pixel )) ELSEIF @zJfunc==32 complex zJ = (z - (z ^ thezJvar1 ))+ (#pixel ) ELSEIF @zJfunc==33 complex zJ = z ^ thezJvar1 / (z ) ELSEIF @zJfunc==34 complex zJ = z - (@zJfunc2 ( z / @zJfunc1 ( thezJvar1 ^ (thezJvar2 )))) ELSEIF @zJfunc==35 complex zJ = (z ^ @zJfunc1 ( z - (@zJfunc1 ( z * @zJfunc2 ( thezJvar2 ))))) ELSEIF @zJfunc==36 complex zJ = (z - #pixel / z + #pixel ) ELSEIF @zJfunc==37 complex zJ = z * z - (@zJfunc1 ( z )) ELSEIF @zJfunc==38 complex zJ = (z ^ (@zJfunc1 ( z + thezJvar1 )/ (thezJvar2 ))) ELSEIF @zJfunc==39 complex zJ = (thezJvar1 - z) / (z - thezJvar2 ) ELSEIF @zJfunc==40 complex zJ = z * (@zJfunc1 ( z + thezJvar1 )- #pixel + z ) ELSEIF @zJfunc==41 complex zJ = (z - (@zJfunc2 ( 1 / z ))) ELSEIF @zJfunc==42 complex zJ = @zJfunc1 ( z * thezJvar1 )- #pixel ^ z + z ELSEIF @zJfunc==43 complex zJ = (z / z - thezJvar2 )/ (thezJvar1 )^ #pixel * (#pixel ) ELSEIF @zJfunc==44 complex zJ = (z / thezJvar1 )+ (thezJvar2 / z) ELSEIF @zJfunc==45 complex zJ = (z - thezJvar2 + z ^ thezJvar1 ) ELSEIF @zJfunc==46 complex zJ = (z * thezJvar1 / #pixel )- ((@zJfunc1 ( z + @zJfunc2 ( thezJvar2 )))) ELSEIF @zJfunc==47 complex zJ = thezJvar2 - (z * thezJvar1 ) ELSEIF @zJfunc==48 complex zJ = z - z ^ thezJvar1 - (@zJfunc1 ( thezJvar2 )) ELSEIF @zJfunc==49 complex zJ = (@zJfunc2 ( z - #pixel * @zJfunc1 ( thezJvar1 ))) ELSEIF @zJfunc==50 complex zJ = (z / @zJfunc2 ( z - thezJvar1 )^ ((@zJfunc1 ( #pixel )))) ELSEIF @zJfunc==51 complex zJ = (@zJfunc1 ( (@zJfunc2 ( thezJvar1 + z)))) ELSEIF @zJfunc==52 complex zJ = (z / thezJvar1 )^ (#pixel - z + thezJvar2 ) ELSEIF @zJfunc==53 complex zJ = (z - z ^ #pixel ) ELSEIF @zJfunc==54 complex zJ = (z + thezJvar2 )^ z - thezJvar1 - (z ) ELSEIF @zJfunc==55 complex zJ = (z ^ z - (@zJfunc1 ( #pixel ))) ELSEIF @zJfunc==56 complex zJ = z + z ^ (@zJfunc1 ( #pixel )) ELSEIF @zJfunc==57 complex zJ = (z * @zJfunc1 ( z * thezJvar1 )) ELSEIF @zJfunc==58 complex zJ = z + (@zJfunc1 ( #pixel / z )) ELSEIF @zJfunc==59 complex zJ = (z / thezJvar2 )+ @zJfunc2 ( thezJvar1 ) ELSEIF @zJfunc==60 complex zJ = 1 / ( z * z - #pixel ) + thezJvar1 ELSEIF @zJfunc==61 complex zJ = @zJfunc1(z) + @zJfunc2(#pixel) ELSEIF @zJfunc==62 complex zJ = @zJfunc1(z) + @zJfunc1(thezJvar1) ELSEIF @zJfunc==63 complex zJ = z * (@zJfunc1(thezJvar1 ^ thezJvar2) / @zJfunc2( thezJvar1 ^ thezJvar2))/thezJvar1 + (1/z) ELSEIF @zJfunc==64 complex zJ = z * z + z / thezJvar1 + @zJfunc1 (thezJvar2) ELSEIF @zJfunc==65 complex zJ = @zJfunc1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) ) ELSEIF @zJfunc==66 complex zJ = @zJfunc1( (z^2 + thezJvar1 - 1) / (2*z + thezJvar2 - 2) ) ELSEIF @zJfunc==67 complex zJ = z - thezJvar1 * (z^thezJvar2-1) / (thezJvar2 * z^(thezJvar1-1)) + thezJvar1 ELSEIF @zJfunc==68 complex zJ = z - thezJvar1 * (z^thezJvar2-1) / (thezJvar2 * z^(thezJvar1-1)) + #pixel ELSEIF @zJfunc==69 complex zJ = ((thezJvar1 - 1) * z^thezJvar1 + thezJvar2) / (thezJvar1 * z ^ (thezJvar1 - 1)) ELSEIF @zJfunc==70 complex zJ = (z ^ z + 1 / (z - 1 + z ^ thezJvar1 )+ ((atan2 ( (@zJfunc2 ( z - z - z ^ thezJvar1 )* ((@zJfunc2 ( z )))))))) ELSEIF @zJfunc==71 complex zJ = (thezJvar1 ^ (thezJvar1 )/ @zJfunc2 ( 2 / (z + 4 ))) ELSEIF @zJfunc==72 complex zJ = (4 + (@zJfunc1 ( @zJfunc2 ( thezJvar1 )^ @zJfunc1 ( thezJvar1 )+ ((@zJfunc1 ( #e )))))) ELSEIF @zJfunc==73 complex zJ = (((@zJfunc1 (z - 2 - z - thezJvar1 )^ #pixel )* ((@zJfunc2 ( z ))))) ELSEIF @zJfunc==74 complex zJ = thezJvar1 + #pixel * z ^ thezJvar1 * #pixel ELSEIF @zJfunc==75 complex zJ = (z * thezJvar1 )- #pixel ELSEIF @zJfunc==76 complex zJ = @zJfunc1 ( thezJvar1 )/ (@zJfunc1 ( z)) ELSEIF @zJfunc==77 complex zJ = (z / thezJvar1 )+ (@zJfunc1 ( z + 1 )) ELSEIF @zJfunc==78 complex zJ = (z - thezJvar1 + (z / @zJfunc1 ( #pixel ))) ELSEIF @zJfunc==79 complex zJ = z * thezJvar1 - #pixel - z ELSEIF @zJfunc==80 complex zJ = thezJvar1 * (z - thezJvar2 ^ (thezJvar1 )) ELSEIF @zJfunc==81 complex zJ = (thezJvar1 )/ (z ^ thezJvar2 ^ z ) ELSEIF @zJfunc==82 complex zJ = thezJvar1 ^ #pixel / (thezJvar1 ^ @zJfunc2 ( z * z )) ELSEIF @zJfunc==83 complex zJ = (z / thezJvar1 - z ) ELSEIF @zJfunc==84 complex zJ = ((@zJfunc1 ( thezJvar1 )- (thezJvar1 )^ (#random * thezJvar2))- @zJfunc1 ( 2 ^ (#pixel ))) ELSEIF @zJfunc==85 complex zJ = (@zJfunc1 ( thezJvar1 )- (@zJfunc1 ( z ))) ELSEIF @zJfunc==86 complex zJ = thezJvar1 ^ @zJfunc1 ( #pixel ) ELSEIF @zJfunc==87 complex zJ = thezJvar1 * (@zJfunc2 ( 1 - #pixel )- z ) ELSEIF @zJfunc==88 complex zJ = z - @zJfunc1 ( thezJvar1 / (z )) ELSEIF @zJfunc==89 complex zJ = @zJfunc1 ( thezJvar1 / #pixel + (#pixel+z) ) ELSEIF @zJfunc==90 complex zJ = z ^ thezJvar1 - (@zJfunc1 ( #pixel )) ELSEIF @zJfunc==91 complex zJ = z * z - z + z ELSEIF @zJfunc==92 complex zJ = (thezJvar1 / @zJfunc1 ( @zJfunc2 ( thezJvar1 ^ z - #pixel ))) ELSEIF @zJfunc==93 complex zJ = z + thezJvar1 + @zJfunc1 ( @zJfunc2 ( z - @zJfunc2 ( z ))) ELSEIF @zJfunc==94 complex zJ = z + thezJvar1 / thezJvar2 * z + thezJvar1 - (@zJfunc2 ( z )) ELSEIF @zJfunc==95 complex zJ = z / thezJvar1 / z * #pixel ELSEIF @zJfunc==96 complex zJ = thezJvar1 * (1 / z / 3) * (z ) ELSEIF @zJfunc==97 complex zJ = z * thezJvar1 + z / thezJvar2 ^ (@zJfunc1 ( z + z )) ELSEIF @zJfunc==98 complex zJ = @zJfunc1 ( thezJvar1 ^ #pixel / (@zJfunc2 ( z ))) ELSEIF @zJfunc==99 complex zJ = (z / z - @zJfunc2 ( z * thezJvar1 ^ #pixel )) ENDIF IF @oper0 == 0 z = z ELSEIF @oper0 == 1 z = z + z0 ELSEIF @oper0 == 2 z = z - z0 ELSEIF @oper0 == 3 z = z * z0 ELSEIF @oper0 == 4 z = z / z0 ELSEIF @oper0 == 5 z = z ^ z0 ELSEIF @oper0 == 6 z = z0 - z ELSEIF @oper0 == 7 z = z0 / z ELSEIF @oper0 == 8 z = z0 ^ z ELSEIF @oper0 == 9 z = z0 ENDIF IF @oper1 == 0 z = z ELSEIF @oper1 == 1 z = z + zA ELSEIF @oper1 == 2 z = z - zA ELSEIF @oper1 == 3 z = z * zA ELSEIF @oper1 == 4 z = z / zA ELSEIF @oper1 == 5 z = z ^ zA ELSEIF @oper1 == 6 z = zA - z ELSEIF @oper1 == 7 z = zA / z ELSEIF @oper1 == 8 z = zA ^ z ELSEIF @oper1 == 9 z = zA ENDIF IF @oper2 == 0 z = z ELSEIF @oper2 == 1 z = z + zB ELSEIF @oper2 == 2 z = z - zB ELSEIF @oper2 == 3 z = z * zB ELSEIF @oper2 == 4 z = z / zB ELSEIF @oper2 == 5 z = z ^ zB ELSEIF @oper2 == 6 z = zB - z ELSEIF @oper2 == 7 z = zB / z ELSEIF @oper2 == 8 z = zB ^ z ELSEIF @oper2 == 9 z = zB ENDIF IF @oper3 == 0 z = z ELSEIF @oper3 == 1 z = z + zC ELSEIF @oper3 == 2 z = z - zC ELSEIF @oper3 == 3 z = z * zC ELSEIF @oper3 == 4 z = z / zC ELSEIF @oper3 == 5 z = z ^ zC ELSEIF @oper3 == 6 z = zC - z ELSEIF @oper3 == 7 z = zC / z ELSEIF @oper3 == 8 z = zC ^ z ELSEIF @oper3 == 9 z = zC ENDIF IF @oper4 == 0 z = z ELSEIF @oper4 == 1 z = z + zD ELSEIF @oper4 == 2 z = z - zD ELSEIF @oper4 == 3 z = z * zD ELSEIF @oper4 == 4 z = z / zD ELSEIF @oper4 == 5 z = z ^ zD ELSEIF @oper4 == 6 z = zD - z ELSEIF @oper4 == 7 z = zD / z ELSEIF @oper4 == 8 z = zD ^ z ELSEIF @oper4 == 9 z = zD ENDIF IF @oper5 == 0 z = z ELSEIF @oper5 == 1 z = z + zE ELSEIF @oper5 == 2 z = z - zE ELSEIF @oper5 == 3 z = z * zE ELSEIF @oper5 == 4 z = z / zE ELSEIF @oper5 == 5 z = z ^ zE ELSEIF @oper5 == 6 z = zE - z ELSEIF @oper5 == 7 z = zE / z ELSEIF @oper5 == 8 z = zE ^ z ELSEIF @oper5 == 9 z = zE ENDIF IF @oper6 == 0 z = z ELSEIF @oper6 == 1 z = z + zF ELSEIF @oper6 == 2 z = z - zF ELSEIF @oper6 == 3 z = z * zF ELSEIF @oper6 == 4 z = z / zF ELSEIF @oper6 == 5 z = z ^ zF ELSEIF @oper6 == 6 z = zF - z ELSEIF @oper6 == 7 z = zF / z ELSEIF @oper6 == 8 z = zF ^ z ELSEIF @oper6 == 9 z = zF ENDIF IF @oper7 == 0 z = z ELSEIF @oper7 == 1 z = z + zG ELSEIF @oper7 == 2 z = z - zG ELSEIF @oper7 == 3 z = z * zG ELSEIF @oper7 == 4 z = z / zG ELSEIF @oper7 == 5 z = z ^ zG ELSEIF @oper7 == 6 z = zG - z ELSEIF @oper7 == 7 z = zG / z ELSEIF @oper7 == 8 z = zG ^ z ELSEIF @oper7 == 9 z = zG ENDIF IF @oper8 == 0 z = z ELSEIF @oper8 == 1 z = z + zH ELSEIF @oper8 == 2 z = z - zH ELSEIF @oper8 == 3 z = z * zH ELSEIF @oper8 == 4 z = z / zH ELSEIF @oper8 == 5 z = z ^ zH ELSEIF @oper8 == 6 z = zH - z ELSEIF @oper8 == 7 z = zH / z ELSEIF @oper8 == 8 z = zH ^ z ELSEIF @oper8 == 9 z = zH ENDIF IF @oper9 == 0 z = z ELSEIF @oper9 == 1 z = z + zI ELSEIF @oper9 == 2 z = z - zI ELSEIF @oper9 == 3 z = z * zI ELSEIF @oper9 == 4 z = z / zI ELSEIF @oper9 == 5 z = z ^ zI ELSEIF @oper9 == 6 z = zI - z ELSEIF @oper9 == 7 z = zI / z ELSEIF @oper9 == 8 z = zI ^ z ELSEIF @oper9 == 9 z = zI ENDIF IF @oper10 == 0 z = z ELSEIF @oper10 == 1 z = z + zJ ELSEIF @oper10 == 2 z = z - zJ ELSEIF @oper10 == 3 z = z * zJ ELSEIF @oper10 == 4 z = z / zJ ELSEIF @oper10 == 5 z = z ^ zJ ELSEIF @oper10 == 6 z = zJ - z ELSEIF @oper10 == 7 z = zJ / z ELSEIF @oper10 == 8 z = zJ ^ z ELSEIF @oper10 == 9 z = zJ ENDIF IF @leftzbail == 0 zbailleft = z ELSEIF @leftzbail == 1 zbailleft = #pixel ELSEIF @leftzbail == 2 zbailleft = theleftbailoutvar1 ELSEIF @leftzbail == 3 zbailleft = theleftbailoutvar2 ELSEIF @leftzbail == 4 zbailleft = @leftbailoutfunc1(z) ELSEIF @leftzbail == 5 zbailleft = @leftbailoutfunc1(#pixel) ELSEIF @leftzbail == 6 zbailleft = @leftbailoutfunc1(theleftbailoutvar1) ELSEIF @leftzbail == 7 zbailleft = z * z + #pixel ELSEIF @leftzbail == 8 zbailleft = z * z + theleftbailoutvar1 ELSEIF @leftzbail == 9 zbailleft = theleftbailoutvar1 * (z * (@leftbailoutfunc1 ( z ^ theleftbailoutvar2 ))) ELSEIF @leftzbail == 10 zbailleft = (@leftbailoutfunc1 ( z - (@leftbailoutfunc2 ( z )))) ELSEIF @leftzbail == 11 zbailleft = z + (@leftbailoutfunc1 ( z - (@leftbailoutfunc2 ( theleftbailoutvar1 )^ (theleftbailoutvar2 )))) ELSEIF @leftzbail == 12 zbailleft = z - @leftbailoutfunc1 ( #pixel ) ELSEIF @leftzbail == 13 zbailleft = z * @leftbailoutfunc1 ( z ) ELSEIF @leftzbail == 14 zbailleft = z ^ theleftbailoutvar2 ^ ((@leftbailoutfunc1 ( @leftbailoutfunc2 ( z + theleftbailoutvar1 )))) ELSEIF @leftzbail == 15 zbailleft = z * @leftbailoutfunc1 ( z - (theleftbailoutvar1 * #random )) ELSEIF @leftzbail == 16 zbailleft = (z ^ theleftbailoutvar1 ) ELSEIF @leftzbail == 17 zbailleft = theleftbailoutvar1 - (@leftbailoutfunc1 ( z + @leftbailoutfunc2 ( z ))) ELSEIF @leftzbail == 18 zbailleft = (@leftbailoutfunc1 ( z + #pixel )) ELSEIF @leftzbail == 19 zbailleft = @leftbailoutfunc2 ( z + (@leftbailoutfunc1 ( #pixel ))) ELSEIF @leftzbail == 20 zbailleft = 1/z ELSEIF @leftzbail == 21 zbailleft = 1/#pixel ELSEIF @leftzbail == 22 zbailleft = @leftbailoutfunc1 (1/z) ELSEIF @leftzbail == 23 zbailleft = @leftbailoutfunc1 (1/#pixel) + theleftbailoutvar1 ENDIF IF @rightzbail == 0 zbailright = z ELSEIF @rightzbail == 1 zbailright = #pixel ELSEIF @rightzbail == 2 zbailright = therightbailoutvar1 ELSEIF @rightzbail == 3 zbailright = therightbailoutvar2 ELSEIF @rightzbail == 4 zbailright = @rightbailoutfunc1(z) ELSEIF @rightzbail == 5 zbailright = @rightbailoutfunc1(#pixel) ELSEIF @rightzbail == 6 zbailright = @rightbailoutfunc1(therightbailoutvar1) ELSEIF @rightzbail == 7 zbailright = z * z + #pixel ELSEIF @rightzbail == 8 zbailright = z * z + therightbailoutvar1 ELSEIF @rightzbail == 9 zbailright = therightbailoutvar1 * (z * (@rightbailoutfunc1 ( z ^ therightbailoutvar2 ))) ELSEIF @rightzbail == 10 zbailright = (@rightbailoutfunc1 ( z - (@rightbailoutfunc2 ( z )))) ELSEIF @rightzbail == 11 zbailright = z + (@rightbailoutfunc1 ( z - (@rightbailoutfunc2 ( therightbailoutvar1 )^ (therightbailoutvar2 )))) ELSEIF @rightzbail == 12 zbailright = z - @rightbailoutfunc1 ( #pixel ) ELSEIF @rightzbail == 13 zbailright = z * @rightbailoutfunc1 ( z ) ELSEIF @rightzbail == 14 zbailright = z ^ therightbailoutvar2 ^ ((@rightbailoutfunc1 ( @rightbailoutfunc2 ( z + therightbailoutvar1 )))) ELSEIF @rightzbail == 15 zbailright = z * @rightbailoutfunc1 ( z - (therightbailoutvar1 * #random )) ELSEIF @rightzbail == 16 zbailright = (z ^ therightbailoutvar1 ) ELSEIF @rightzbail == 17 zbailright = therightbailoutvar1 - (@rightbailoutfunc1 ( z + @rightbailoutfunc2 ( z ))) ELSEIF @rightzbail == 18 zbailright = (@rightbailoutfunc1 ( z + #pixel )) ELSEIF @rightzbail == 19 zbailright = @rightbailoutfunc2 ( z + (@rightbailoutfunc1 ( #pixel ))) ELSEIF @rightzbail == 20 zbailright = 1/z ELSEIF @rightzbail == 21 zbailright = 1/#pixel ELSEIF @rightzbail == 22 zbailright = @rightbailoutfunc1 (1/z) ELSEIF @rightzbail == 23 zbailright = @rightbailoutfunc1 (1/#pixel) + therightbailoutvar1 ENDIF IF @bailtestleft == 0 zbaillefttest = zbailleft ELSEIF @bailtestleft == 1 zbaillefttest = (real(zbailleft)) ELSEIF @bailtestleft == 2 zbaillefttest = (imag(zbailleft)) ELSEIF @bailtestleft == 3 zbaillefttest = ((abs(real(zbailleft))) + (abs(imag(zbailleft)))) ELSEIF @bailtestleft == 4 zbaillefttest = ((abs(real(zbailleft))) - (abs(imag(zbailleft)))) ELSEIF @bailtestleft == 5 zbaillefttest = ((abs(real(zbailleft))) * (abs(imag(zbailleft)))) ELSEIF @bailtestleft == 6 zbaillefttest = ((abs(real(zbailleft))) / (abs(imag(zbailleft)))) ELSEIF @bailtestleft == 7 zbaillefttest = ((abs(real(zbailleft))) ^ (abs(imag(zbailleft)))) ELSEIF @bailtestleft == 8 zbaillefttest = ((abs(imag(zbailleft))) - (abs(real(zbailleft)))) ELSEIF @bailtestleft == 9 zbaillefttest = ((abs(imag(zbailleft))) / (abs(real(zbailleft)))) ELSEIF @bailtestleft == 10 zbaillefttest = ((abs(imag(zbailleft))) ^ (abs(real(zbailleft)))) ELSEIF @bailtestleft == 11 zbaillefttest = (real(@leftbailoutfunc(zbailleft))) ELSEIF @bailtestleft == 12 zbaillefttest = (imag(@leftbailoutfunc(zbailleft))) ELSEIF @bailtestleft == 13 zbaillefttest = ((abs(real(@leftbailoutfunc(zbailleft)))) + (abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 14 zbaillefttest = ((abs(real(@leftbailoutfunc(zbailleft)))) - (abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 15 zbaillefttest = ((abs(real(@leftbailoutfunc(zbailleft)))) * (abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 16 zbaillefttest = ((abs(real(@leftbailoutfunc(zbailleft)))) / (abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 17 zbaillefttest = ((abs(real(@leftbailoutfunc(zbailleft)))) ^ (abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 18 zbaillefttest = ((abs(imag(@leftbailoutfunc(zbailleft)))) - (abs(real(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 19 zbaillefttest = ((abs(imag(@leftbailoutfunc(zbailleft)))) / (abs(real(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 20 zbaillefttest = ((abs(imag(@leftbailoutfunc(zbailleft)))) ^ (abs(real(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 21 zbaillefttest = @leftbailfunc(real(zbailleft)) ELSEIF @bailtestleft == 22 zbaillefttest = @leftbailfunc(imag(zbailleft)) ELSEIF @bailtestleft == 23 zbaillefttest = (@leftbailfunc(abs(real(zbailleft))) + @leftbailfunc(abs(imag(zbailleft)))) ELSEIF @bailtestleft == 24 zbaillefttest = (@leftbailfunc(abs(real(zbailleft))) - @leftbailfunc(abs(imag(zbailleft)))) ELSEIF @bailtestleft == 25 zbaillefttest = (@leftbailfunc(abs(real(zbailleft))) * @leftbailfunc(abs(imag(zbailleft)))) ELSEIF @bailtestleft == 26 zbaillefttest = (@leftbailfunc(abs(real(zbailleft))) / @leftbailfunc(abs(imag(zbailleft)))) ELSEIF @bailtestleft == 27 zbaillefttest = (@leftbailfunc(abs(real(zbailleft))) ^ @leftbailfunc(abs(imag(zbailleft)))) ELSEIF @bailtestleft == 28 zbaillefttest = (@leftbailfunc(abs(imag(zbailleft))) - @leftbailfunc(abs(real(zbailleft)))) ELSEIF @bailtestleft == 29 zbaillefttest = (@leftbailfunc(abs(imag(zbailleft))) / @leftbailfunc(abs(real(zbailleft)))) ELSEIF @bailtestleft == 30 zbaillefttest = (@leftbailfunc(abs(imag(zbailleft))) ^ @leftbailfunc(abs(real(zbailleft)))) ELSEIF @bailtestleft == 31 zbaillefttest = @leftbailfunc(real(@leftbailoutfunc(zbailleft))) ELSEIF @bailtestleft == 32 zbaillefttest = @leftbailfunc(imag(@leftbailoutfunc(zbailleft))) ELSEIF @bailtestleft == 33 zbaillefttest = (@leftbailfunc(abs(real(@leftbailoutfunc(zbailleft)))) + @leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 34 zbaillefttest = (@leftbailfunc(abs(real(@leftbailoutfunc(zbailleft)))) - @leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 35 zbaillefttest = (@leftbailfunc(abs(real(@leftbailoutfunc(zbailleft)))) * @leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 36 zbaillefttest = (@leftbailfunc(abs(real(@leftbailoutfunc(zbailleft)))) / @leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 37 zbaillefttest = (@leftbailfunc(abs(real(@leftbailoutfunc(zbailleft)))) ^ @leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 38 zbaillefttest = (@leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft)))) - @leftbailfunc(abs(real(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 39 zbaillefttest = (@leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft)))) / @leftbailfunc(abs(real(@leftbailoutfunc(zbailleft))))) ELSEIF @bailtestleft == 40 zbaillefttest = (@leftbailfunc(abs(imag(@leftbailoutfunc(zbailleft)))) ^ @leftbailfunc(abs(real(@leftbailoutfunc(zbailleft))))) ENDIF IF @bailtestright == 0 zbailrighttest = zbailright ELSEIF @bailtestright == 1 zbailrighttest = (real(zbailright)) ELSEIF @bailtestright == 2 zbailrighttest = (imag(zbailright)) ELSEIF @bailtestright == 3 zbailrighttest = ((abs(real(zbailright))) + (abs(imag(zbailright)))) ELSEIF @bailtestright == 4 zbailrighttest = ((abs(real(zbailright))) - (abs(imag(zbailright)))) ELSEIF @bailtestright == 5 zbailrighttest = ((abs(real(zbailright))) * (abs(imag(zbailright)))) ELSEIF @bailtestright == 6 zbailrighttest = ((abs(real(zbailright))) / (abs(imag(zbailright)))) ELSEIF @bailtestright == 7 zbailrighttest = ((abs(real(zbailright))) ^ (abs(imag(zbailright)))) ELSEIF @bailtestright == 8 zbailrighttest = ((abs(imag(zbailright))) - (abs(real(zbailright)))) ELSEIF @bailtestright == 9 zbailrighttest = ((abs(imag(zbailright))) / (abs(real(zbailright)))) ELSEIF @bailtestright == 10 zbailrighttest = ((abs(imag(zbailright))) ^ (abs(real(zbailright)))) ELSEIF @bailtestright == 11 zbailrighttest = (real(@rightbailoutfunc(zbailright))) ELSEIF @bailtestright == 12 zbailrighttest = (imag(@rightbailoutfunc(zbailright))) ELSEIF @bailtestright == 13 zbailrighttest = ((abs(real(@rightbailoutfunc(zbailright)))) + (abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 14 zbailrighttest = ((abs(real(@rightbailoutfunc(zbailright)))) - (abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 15 zbailrighttest = ((abs(real(@rightbailoutfunc(zbailright)))) * (abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 16 zbailrighttest = ((abs(real(@rightbailoutfunc(zbailright)))) / (abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 17 zbailrighttest = ((abs(real(@rightbailoutfunc(zbailright)))) ^ (abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 18 zbailrighttest = ((abs(imag(@rightbailoutfunc(zbailright)))) - (abs(real(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 19 zbailrighttest = ((abs(imag(@rightbailoutfunc(zbailright)))) / (abs(real(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 20 zbailrighttest = ((abs(imag(@rightbailoutfunc(zbailright)))) ^ (abs(real(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 21 zbailrighttest = @rightbailfunc(real(zbailright)) ELSEIF @bailtestright == 22 zbailrighttest = @rightbailfunc(imag(zbailright)) ELSEIF @bailtestright == 23 zbailrighttest = (@rightbailfunc(abs(real(zbailright))) + @rightbailfunc(abs(imag(zbailright)))) ELSEIF @bailtestright == 24 zbailrighttest = (@rightbailfunc(abs(real(zbailright))) - @rightbailfunc(abs(imag(zbailright)))) ELSEIF @bailtestright == 25 zbailrighttest = (@rightbailfunc(abs(real(zbailright))) * @rightbailfunc(abs(imag(zbailright)))) ELSEIF @bailtestright == 26 zbailrighttest = (@rightbailfunc(abs(real(zbailright))) / @rightbailfunc(abs(imag(zbailright)))) ELSEIF @bailtestright == 27 zbailrighttest = (@rightbailfunc(abs(real(zbailright))) ^ @rightbailfunc(abs(imag(zbailright)))) ELSEIF @bailtestright == 28 zbailrighttest = (@rightbailfunc(abs(imag(zbailright))) - @rightbailfunc(abs(real(zbailright)))) ELSEIF @bailtestright == 29 zbailrighttest = (@rightbailfunc(abs(imag(zbailright))) / @rightbailfunc(abs(real(zbailright)))) ELSEIF @bailtestright == 30 zbailrighttest = (@rightbailfunc(abs(imag(zbailright))) ^ @rightbailfunc(abs(real(zbailright)))) ELSEIF @bailtestright == 31 zbailrighttest = @rightbailfunc(real(@rightbailoutfunc(zbailright))) ELSEIF @bailtestright == 32 zbailrighttest = @rightbailfunc(imag(@rightbailoutfunc(zbailright))) ELSEIF @bailtestright == 33 zbailrighttest = (@rightbailfunc(abs(real(@rightbailoutfunc(zbailright)))) + @rightbailfunc(abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 34 zbailrighttest = (@rightbailfunc(abs(real(@rightbailoutfunc(zbailright)))) - @rightbailfunc(abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 35 zbailrighttest = (@rightbailfunc(abs(real(@rightbailoutfunc(zbailright)))) * @rightbailfunc(abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 36 zbailrighttest = (@rightbailfunc(abs(real(@rightbailoutfunc(zbailright)))) / @rightbailfunc(abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 37 zbailrighttest = (@rightbailfunc(abs(real(@rightbailoutfunc(zbailright)))) ^ @rightbailfunc(abs(imag(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 38 zbailrighttest = (@rightbailfunc(abs(imag(@rightbailoutfunc(zbailright)))) - @rightbailfunc(abs(real(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 39 zbailrighttest = (@rightbailfunc(abs(imag(@rightbailoutfunc(zbailright)))) / @rightbailfunc(abs(real(@rightbailoutfunc(zbailright))))) ELSEIF @bailtestright == 40 zbailrighttest = (@rightbailfunc(abs(imag(@rightbailoutfunc(zbailright)))) ^ @rightbailfunc(abs(real(@rightbailoutfunc(zbailright))))) ENDIF IF @zbailoper1 == 0 realpixel = zbaillefttest + zbailrighttest ENDIF IF @zbailoper1 == 1 realpixel = zbaillefttest - zbailrighttest ENDIF IF @zbailoper1 == 2 realpixel = zbaillefttest * zbailrighttest ENDIF IF @zbailoper1 == 3 realpixel = zbaillefttest / zbailrighttest ENDIF IF @zbailoper1 == 4 realpixel = zbaillefttest ^ zbailrighttest ENDIF IF @zbailoper1 == 5 realpixel = zbailrighttest - zbaillefttest ENDIF IF @zbailoper1 == 6 realpixel = zbailrighttest / zbaillefttest ENDIF IF @zbailoper1 == 7 realpixel = zbailrighttest ^ zbaillefttest ENDIF IF @zbailoper1 == 8 realpixel = zbaillefttest ENDIF IF @zbailoper1 == 9 realpixel = zbailrighttest ENDIF IF @zbailoper2 == 0 imagpixel = zbaillefttest + zbailrighttest ENDIF IF @zbailoper2 == 1 imagpixel = zbaillefttest - zbailrighttest ENDIF IF @zbailoper2 == 2 imagpixel = zbaillefttest * zbailrighttest ENDIF IF @zbailoper2 == 3 imagpixel = zbaillefttest / zbailrighttest ENDIF IF @zbailoper2 == 4 imagpixel = zbaillefttest ^ zbailrighttest ENDIF IF @zbailoper2 == 5 imagpixel = zbailrighttest - zbaillefttest ENDIF IF @zbailoper2 == 6 imagpixel = zbailrighttest / zbaillefttest ENDIF IF @zbailoper2 == 7 imagpixel = zbailrighttest ^ zbaillefttest ENDIF IF @zbailoper2 == 8 imagpixel = zbaillefttest ENDIF IF @zbailoper2 == 9 imagpixel = zbailrighttest ENDIF IF @usescreencenter == TRUE realpixel = realpixel - #center imagpixel = imagpixel - #center offset = real(#center) * -#magn + flip(imag(#center) * -#magn) trans = cabs(offset) * exp(flip(atan2(offset) + #angle)) realpixel = realpixel - (trans / #magn) imagpixel = imagpixel - (trans / #magn) realpixel = cabs(realpixel) * exp(flip(-#angle + atan2(realpixel))) imagpixel = cabs(imagpixel) * exp(flip(-#angle + atan2(imagpixel))) realpixel = realpixel - (trans / #magn) imagpixel = imagpixel - (trans / #magn) realpixel = cabs(realpixel) * exp(flip(-#angle + atan2(realpixel))) imagpixel = cabs(imagpixel) * exp(flip(-#angle + atan2(imagpixel))) realpixel = #center + cabs(realpixel - #center) * exp(flip(atan2(realpixel - #center) + (#angle * pi / 180))) imagpixel = #center + cabs(imagpixel - #center) * exp(flip(atan2(imagpixel - #center) + (#angle * pi / 180))) ENDIF #pixel = real(realpixel) + flip(real(imagpixel)) ENDIF default: title = "JC Dabbler Transformation Formula" float param version caption = "Version" default = 1.10 visible = false endparam heading caption = "Formula View Options" endheading bool param viewzinit caption = "View Z Initialzing Parameters?" default = false endparam bool param viewztweak caption = "View Z Tweak Parameters?" default = false endparam bool param viewzequs caption = "View Z Equation Parameters?" default = false endparam bool param viewbail caption = "View Finishing Parameters?" default = false endparam heading caption = "Z Initialize Options" visible = @viewzinit endheading param zinit caption = "Z initializer" hint = "Z will start from this inital equation every iteration" enum = "z" "#pixel" "p1" "z + #pixel + (fn1 ( z * z + p1 ))" "(fn1 ( p1 ))" "(p1 ) * z + fn1 ( z / p2 )" "(z ^ (fn1 ( p1 )))" "z * p1 ^ ((fn1 ( z )))" "z ^ fn2 ( #pixel + z - z * z - p1 )" "(z + fn1 ( z + #pixel ^ (z - p1 )+ (z / (z-1)) ))" "z / fn1 ( #pixel + z - fn2 ( z ))" "(z + (p1 / (fn1 ( z * #pixel + p1 + p2 ))))" "(#pixel + (p1 * #random ))" "(p1 )* z + fn1(z / p2 / #pixel )" "(fn1 ( z*p1 ) + fn2(#pixel * p2))" "z * p1 + #e - #pixel " "p1 / fn1(z ^ z )" "(z ^ p1 ) * #pixel / z ^ fn2 ( p2 * (#random + 1) )" "z - #pixel / p2 * (p1 )" "#pixel + p2 ^ #pi " "(z - (fn1 ( z * #pixel ^ (fn2( p1 )))))" "((fn1 ( p2 )- #pixel )/ (p2 ))" "(z / p1 )* #pixel / (#e )" "(z * p1 )+ (#pixel * p2 )" "(fn1 ( z * z ))" "(z - fn1 ( #pixel * p1 ))" "(z + z / p1 )- fn1 ( #pixel )" "z / p1" "z * z + p1" "z * z + #pixel" "fn1( (z^2 + #pixel - 1) / (2*z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p2-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "1/z" "1/#pixel" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn2(#pixel)" "fn1(z) + fn2(p1)" "z * (fn1(p1 ^ p2) / fn2( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" default = 1 visible = @viewzinit endparam heading caption = "Variables And Functions" visible = @viewzinit endheading param initvar1 caption = "p1" hint = "Initialize Variable 1" visible = @viewzinit && (@zinit == 2 || @zinit == 3 || @zinit == 4 || @zinit == 5 || @zinit == 6 || @zinit == 7 || @zinit == 8 || @zinit == 9 || @zinit == 11 || @zinit == 12 || @zinit == 13 || @zinit == 14 || @zinit == 15 || @zinit == 16 || @zinit == 17 || @zinit == 18 || @zinit == 20 || @zinit == 22 || @zinit == 23 || @zinit == 25 || @zinit == 26 || @zinit == 27 || @zinit == 28 || @zinit == 31 || @zinit == 32 || @zinit == 33 || @zinit == 34 || @zinit == 37 || @zinit == 39 || @zinit == 40 || @zinit == 41) endparam func initfunc1 caption = "fn1" hint = "Initialize Function 1" visible = @viewzinit && (@zinit == 3 || @zinit == 4 || @zinit == 5 || @zinit == 6 || @zinit == 7 || @zinit == 9 || @zinit == 10 || @zinit == 11 || @zinit == 13 || @zinit == 14 || @zinit == 16 || @zinit == 20 || @zinit == 21 || @zinit == 24 || @zinit == 25 || @zinit == 26 || @zinit == 30 || @zinit == 31 || @zinit == 38 || @zinit == 39 || @zinit == 40 || @zinit == 41) endfunc param initvar2 caption = "p2" hint = "Initialize Variable 2" visible = @viewzinit && (@zinit == 5 || @zinit == 11 || @zinit == 13 || @zinit == 14 || @zinit == 17 || @zinit == 18 || @zinit == 19 || @zinit == 21 || @zinit == 23 || @zinit == 31|| @zinit == 32 || @zinit == 33 || @zinit == 34 || @zinit == 40 || @zinit == 41) endparam func initfunc2 caption = "fn2" hint = "Initialize Function 2" visible = @viewzinit && (@zinit == 8 || @zinit == 10 || @zinit == 14 || @zinit == 17 || @zinit == 20 || @zinit == 38 || @zinit == 39 || @zinit == 40) endfunc heading caption = "Z Tweakers" visible = @viewztweak endheading bool param once caption = "tweak once or every iteration?" default = false visible = @viewztweak endparam heading caption = "Z Tweaker Options" visible = @viewztweak endheading bool param once caption = "tweak once or every iteration?" default = false visible = @viewztweak endparam heading caption = "Z Tweakers" visible = @viewztweak endheading bool param ztweak1 caption = "z" hint ="z" default = false visible = @viewztweak endparam param ztoper1 caption ="ztweak1 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak1 endparam heading visible = @viewztweak endheading bool param ztweak2 caption = "#pixel" hint ="#pixel" default = false visible = @viewztweak endparam param ztoper2 caption ="ztweak2 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak2 endparam heading visible = @viewztweak endheading bool param ztweak3 caption = "z * z + #pixel" hint ="z * z + #pixel" default = false visible = @viewztweak endparam param ztoper3 caption ="ztweak3 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak3 endparam heading visible = @viewztweak endheading bool param ztweak4 caption = "@tweakvar1" hint ="@tweakvar1" default = false visible = @viewztweak endparam param tweakvar4 caption = "Var- Tweak 4" visible = @viewztweak && @ztweak4 endparam param ztoper4 caption ="ztweak4 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak4 endparam heading visible = @viewztweak endheading bool param ztweak5 caption = "@tweakvar2" hint ="@tweakvar2" default = false visible = @viewztweak endparam param tweakvar5 caption = "Var- Tweak 5" visible = @viewztweak && @ztweak5 endparam param ztoper5 caption ="ztweak5 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak5 endparam heading visible = @viewztweak endheading bool param ztweak6 caption = "@tweakfunc1(z)" hint ="@tweakfunc1(z)" default = false visible = @viewztweak endparam func tweakfunc6 caption = "func- Tweak 6" visible = @viewztweak && @ztweak6 endfunc param ztoper6 caption ="ztweak6 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak6 endparam heading visible = @viewztweak endheading bool param ztweak7 caption = "@tweakfunc1(#pixel)" hint ="@tweakfunc1(#pixel)" default = false visible = @viewztweak endparam func tweakfunc7 caption = "func- Tweak 7" visible = @viewztweak && @ztweak7 endfunc param ztoper7 caption ="ztweak7 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak7 endparam heading visible = @viewztweak endheading bool param ztweak8 caption = "@tweakfunc1(@tweakvar1)" hint ="@tweakfunc1(@tweakvar1)" default = false visible = @viewztweak endparam func tweakfunc8 caption = "func- Tweak 8" visible = @viewztweak && @ztweak8 endfunc param tweakvar8 caption = "Var- Tweak 8" visible = @viewztweak && @ztweak8 endparam param ztoper8 caption ="ztweak8 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak8 endparam heading visible = @viewztweak endheading bool param ztweak9 caption = "(z - @tweakvar1 )" hint ="(z - @tweakvar1 )" default = false visible = @viewztweak endparam param tweakvar9 caption = "Var- Tweak 9" visible = @viewztweak && @ztweak9 endparam param ztoper9 caption ="ztweak9 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak9 endparam heading visible = @viewztweak endheading bool param ztweak10 caption = "@tweakvar1 ^ z + @tweakfunc1 ( @tweakvar2 )" hint ="@tweakvar1 ^ z + @tweakfunc1 ( @tweakvar2 )" default = false visible = @viewztweak endparam func tweakfunc10 caption = "func- Tweak 10" visible = @viewztweak && @ztweak10 endfunc param tweakvar10 caption = "Var- Tweak 10" visible = @viewztweak && @ztweak10 endparam param tweakvar102 caption = "Var- Tweak 10 2" visible = @viewztweak && @ztweak10 endparam param ztoper10 caption ="ztweak10 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak10 endparam heading visible = @viewztweak endheading bool param ztweak11 caption = "z + (@tweakfunc1 ( #pixel ))" hint ="z + (@tweakfunc1 ( #pixel ))" default = false visible = @viewztweak endparam func tweakfunc11 caption = "func- Tweak 11" visible = @viewztweak && @ztweak11 endfunc param ztoper11 caption ="ztweak11 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak11 endparam heading visible = @viewztweak endheading bool param ztweak12 caption = "#pi" hint ="#pi" default = false visible = @viewztweak endparam param ztoper12 caption ="ztweak12 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak12 endparam heading visible = @viewztweak endheading bool param ztweak13 caption = "#e" hint ="#e" default = false visible = @viewztweak endparam param ztoper13 caption ="ztweak13 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak13 endparam heading visible = @viewztweak endheading bool param ztweak14 caption = "(z - @tweakfunc1 ( z ))" hint ="(z - @tweakfunc1 ( z ))" default = false visible = @viewztweak endparam func tweakfunc14 caption = "func- Tweak 14" visible = @viewztweak && @ztweak14 endfunc param ztoper14 caption ="ztweak14 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak14 endparam heading visible = @viewztweak endheading bool param ztweak15 caption = "z * z - #e" hint ="z * z - #e" default = false visible = @viewztweak endparam param ztoper15 caption ="ztweak15 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak15 endparam heading visible = @viewztweak endheading bool param ztweak16 caption = "(@tweakfunc1 ( z / (@tweakfunc2 ( @tweakvar1 ))))" hint ="(@tweakfunc1 ( z / (@tweakfunc2 ( @tweakvar1 ))))" default = false visible = @viewztweak endparam func tweakfunc16 caption = "func- Tweak 16" visible = @viewztweak && @ztweak16 endfunc param tweakvar16 caption = "Var- Tweak 16" visible = @viewztweak && @ztweak16 endparam func tweakfunc162 caption = "func- Tweak 16 2" visible = @viewztweak && @ztweak16 endfunc param ztoper16 caption ="ztweak16 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak16 endparam heading visible = @viewztweak endheading bool param ztweak17 caption = "z / @tweakvar1 * (#pixel )" hint ="z / @tweakvar1 * (#pixel )" default = false visible = @viewztweak endparam param tweakvar17 caption = "Var- Tweak 17" visible = @viewztweak && @ztweak17 endparam param ztoper17 caption ="ztweak17 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak17 endparam heading visible = @viewztweak endheading bool param ztweak18 caption = "(@tweakfunc1 ( @tweakvar1 ^ z ))" hint ="(@tweakfunc1 ( @tweakvar1 ^ z ))" default = false visible = @viewztweak endparam func tweakfunc18 caption = "func- Tweak 18" visible = @viewztweak && @ztweak18 endfunc param tweakvar18 caption = "Var- Tweak 18" visible = @viewztweak && @ztweak18 endparam param ztoper18 caption ="ztweak18 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak18 endparam heading visible = @viewztweak endheading bool param ztweak19 caption = "(@tweakvar1 )^ (z - 1 - @tweakvar2 )" hint ="(@tweakvar1 )^ (z - 1 - @tweakvar2 )" default = false visible = @viewztweak endparam param tweakvar19 caption = "Var- Tweak 19" visible = @viewztweak && @ztweak19 endparam param tweakvar192 caption = "Var- Tweak 192" visible = @viewztweak && @ztweak19 endparam param ztoper19 caption ="ztweak19 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak19 endparam heading visible = @viewztweak endheading bool param ztweak20 caption = "((@tweakfunc1 ( z * #pixel )))" hint ="((@tweakfunc1 ( z * #pixel )))" default = false visible = @viewztweak endparam func tweakfunc20 caption = "func- Tweak 20" visible = @viewztweak && @ztweak20 endfunc param ztoper20 caption ="ztweak20 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak20 endparam heading visible = @viewztweak endheading bool param ztweak21 caption = "1 / (z ^ #pixel )" hint ="1 / (z ^ #pixel )" default = false visible = @viewztweak endparam param ztoper21 caption ="ztweak21 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak21 endparam heading visible = @viewztweak endheading bool param ztweak22 caption = "1/z" hint ="1/z" default = false visible = @viewztweak endparam param ztoper22 caption ="ztweak22 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak22 endparam heading visible = @viewztweak endheading bool param ztweak23 caption = "1/#pixel" hint ="1/#pixel" default = false visible = @viewztweak endparam param ztoper23 caption ="ztweak23 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak23 endparam heading visible = @viewztweak endheading bool param ztweak24 caption = "(z / @tweakvar1 )* @tweakvar2" hint ="(z / @tweakvar1 )* @tweakvar2" default = false visible = @viewztweak endparam param tweakvar24 caption = "Var- Tweak 24" visible = @viewztweak && @ztweak24 endparam param tweakvar242 caption = "Var- Tweak 24 2" visible = @viewztweak && @ztweak24 endparam param ztoper24 caption ="ztweak24 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak24 endparam heading visible = @viewztweak endheading bool param ztweak25 caption = "(@tweakvar1 )- ((@tweakfunc1 ( z )))" hint ="(@tweakvar1 )- ((@tweakfunc1 ( z )))" default = false visible = @viewztweak endparam func tweakfunc25 caption = "func- Tweak 25" visible = @viewztweak && @ztweak25 endfunc param tweakvar25 caption = "Var- Tweak 25" visible = @viewztweak && @ztweak25 endparam param ztoper25 caption ="ztweak25 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak25 endparam heading visible = @viewztweak endheading bool param ztweak26 caption = "(z + z + (@tweakfunc1 ( #pixel )))" hint ="(z + z + (@tweakfunc1 ( #pixel )))" default = false visible = @viewztweak endparam func tweakfunc26 caption = "func- Tweak 26" visible = @viewztweak && @ztweak26 endfunc param ztoper26 caption ="ztweak26 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak26 endparam heading visible = @viewztweak endheading bool param ztweak27 caption = "z + z / @tweakvar1 ^ (@tweakfunc1 ( @tweakvar2 ))" hint ="z + z / @tweakvar1 ^ (@tweakfunc1 ( @tweakvar2 ))" default = false visible = @viewztweak endparam func tweakfunc27 caption = "func- Tweak 27" visible = @viewztweak && @ztweak27 endfunc param tweakvar27 caption = "Var- Tweak 27" visible = @viewztweak && @ztweak27 endparam param tweakvar272 caption = "Var- Tweak 27 2" visible = @viewztweak && @ztweak27 endparam param ztoper27 caption ="ztweak27 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak27 endparam heading visible = @viewztweak endheading bool param ztweak28 caption = "(z / @tweakvar1 * (#pixel *@tweakvar2 ))" hint ="(z / @tweakvar1 * (#pixel *@tweakvar2 ))" default = false visible = @viewztweak endparam param tweakvar28 caption = "Var- Tweak 28" visible = @viewztweak && @ztweak28 endparam param tweakvar282 caption = "Var- Tweak 28 2" visible = @viewztweak && @ztweak28 endparam param ztoper28 caption ="ztweak28 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak28 endparam heading visible = @viewztweak endheading bool param ztweak29 caption = "z * z + @tweakvar1" hint ="z * z + @tweakvar1" default = false visible = @viewztweak endparam param tweakvar29 caption = "Var- Tweak 29" visible = @viewztweak && @ztweak29 endparam param ztoper29 caption ="ztweak29 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak29 endparam heading visible = @viewztweak endheading bool param ztweak30 caption = "(z / (#pixel - @tweakvar1 ))" hint ="(z / (#pixel - @tweakvar1 ))" default = false visible = @viewztweak endparam param tweakvar30 caption = "Var- Tweak 30" visible = @viewztweak && @ztweak30 endparam param ztoper30 caption ="ztweak30 modifier" enum = "unused" "Z + Tweak" "Z - Tweak" "Z * Tweak" "Z / Tweak" "Z ^ Tweak" "Tweak - Z" "Tweak / Z" "Tweak ^ Z" visible = @viewztweak && @ztweak30 endparam heading caption = "Z Formula Equation" visible = @viewzequs endheading param zfunc caption = "Main Equation Flavor" hint = "Main Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" default = 0 visible = @viewzequs endparam param z0var1 caption = "p1" hint = "Variable 1" visible = @viewzequs && (@zfunc == 5 || @zfunc == 9 || @zfunc == 10 || @zfunc == 12 || @zfunc == 13 || @zfunc == 14 || @zfunc == 15 || @zfunc == 17 || @zfunc == 18 || @zfunc == 19 || @zfunc == 20 || @zfunc == 21 || @zfunc == 22 || @zfunc == 23 || @zfunc == 24 || @zfunc == 25 || @zfunc == 27 || @zfunc == 29 || @zfunc == 30 || @zfunc == 31 || @zfunc == 32 || @zfunc == 33 || @zfunc == 34 || @zfunc == 38 || @zfunc == 39 || @zfunc == 40 || @zfunc == 42 || @zfunc == 43 || @zfunc == 44 || @zfunc == 45 || @zfunc == 46 || @zfunc == 47 || @zfunc == 48 || @zfunc == 49 || @zfunc == 50 || @zfunc == 51 || @zfunc == 52 || @zfunc == 54 || @zfunc == 57 || @zfunc == 59 || @zfunc == 60 || @zfunc == 62 || @zfunc == 63 || @zfunc == 64 || @zfunc == 66 || @zfunc == 67 || @zfunc == 68 || @zfunc == 69 || @zfunc == 70 || @zfunc == 71 || @zfunc == 72 || @zfunc == 73 || @zfunc == 74 || @zfunc == 75 || @zfunc == 76 || @zfunc == 77 || @zfunc == 78 || @zfunc == 79 || @zfunc == 80 || @zfunc == 81 || @zfunc == 82 || @zfunc == 83 || @zfunc == 84 || @zfunc == 85 || @zfunc == 86 || @zfunc == 87 || @zfunc == 88 || @zfunc == 89 || @zfunc == 90 || @zfunc == 92 || @zfunc == 93 || @zfunc == 94 || @zfunc == 95 || @zfunc == 96 || @zfunc == 97 || @zfunc == 98 || @zfunc == 99) endparam func z0func1 hint = "Function 1" caption = "Fn1" visible = @viewzequs && (@zfunc == 7 || @zfunc == 8 || @zfunc == 10 || @zfunc == 12 || @zfunc == 14 || @zfunc == 16 || @zfunc == 17 || @zfunc == 18 || @zfunc == 20 || @zfunc == 21 || @zfunc == 22 || @zfunc == 23 || @zfunc == 24 || @zfunc == 25 || @zfunc == 26 || @zfunc == 27 || @zfunc == 28 || @zfunc == 29 || @zfunc == 30 || @zfunc == 31 || @zfunc == 34 || @zfunc == 35 || @zfunc == 37 || @zfunc == 38 || @zfunc == 40 || @zfunc == 42 || @zfunc == 46 || @zfunc == 48 || @zfunc == 49 || @zfunc == 50 || @zfunc == 51 || @zfunc == 55 || @zfunc == 56 || @zfunc == 57 || @zfunc == 58 || @zfunc == 61 || @zfunc == 62 || @zfunc == 63 || @zfunc == 64 || @zfunc == 65 || @zfunc == 66 || @zfunc == 72 || @zfunc == 73 || @zfunc == 76 || @zfunc == 77 || @zfunc == 78 || @zfunc == 84 || @zfunc == 85 || @zfunc == 86 || @zfunc == 88 || @zfunc == 89 || @zfunc == 90 || @zfunc == 92 || @zfunc == 93 || @zfunc == 97 || @zfunc == 98) endfunc param z0var2 caption = "p2" hint = "Variable 2" visible = @viewzequs && (@zfunc == 6 || @zfunc == 17 || @zfunc == 19 || @zfunc == 21 || @zfunc == 22 || @zfunc == 23 || @zfunc == 24 || @zfunc == 27 || @zfunc == 34 || @zfunc == 35 || @zfunc == 38 || @zfunc == 39 || @zfunc == 43 || @zfunc == 44 || @zfunc == 45 || @zfunc == 46 || @zfunc == 47 || @zfunc == 48 || @zfunc == 52 || @zfunc == 54 || @zfunc == 59 || @zfunc == 63 || @zfunc == 64 || @zfunc == 66 || @zfunc == 67 || @zfunc == 68 || @zfunc == 69 || @zfunc == 80 || @zfunc == 81 || @zfunc == 84 || @zfunc == 94 || @zfunc == 97) endparam func z0func2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && (@zfunc == 22 || @zfunc == 23 || @zfunc == 25 || @zfunc == 27 || @zfunc == 34 || @zfunc == 35 || @zfunc == 41 || @zfunc == 46 || @zfunc == 49 || @zfunc == 50 || @zfunc == 51 || @zfunc == 59 || @zfunc == 61 || @zfunc == 63 || @zfunc == 70 || @zfunc == 71 || @zfunc == 72 || @zfunc == 73 || @zfunc == 82 || @zfunc == 87 || @zfunc == 92 || @zfunc == 93 || @zfunc == 94 || @zfunc == 98 || @zfunc == 99) endfunc param oper0 caption = "Main Equation Operation" hint = "The Main Equation will affect Z this way" enum = "unused" "Z = Z + Equation" "Z = Z - Equation" "Z = Z * Equation" "Z = Z / Equation" "Z = Z ^ Equation" "Z = Equation - Z" "Z = Equation / Z" "Z = Equation ^ Z" "Z = Equation" default = 9 visible = @viewzequs endparam heading visible = @viewzequs endheading bool param viewzAfunc caption = "Show 1st Equation?" visible = @viewzequs default = false endparam param zAfunc caption = "1st Equation Flavor" hint = "1st Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" default = 0 visible = @viewzequs && @viewzAfunc endparam param zAvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzAfunc && (@zAfunc == 5 || @zAfunc == 9 || @zAfunc == 10 || @zAfunc == 12 || @zAfunc == 13 || @zAfunc == 14 || @zAfunc == 15 || @zAfunc == 17 || @zAfunc == 18 || @zAfunc == 19 || @zAfunc == 20 || @zAfunc == 21 || @zAfunc == 22 || @zAfunc == 23 || @zAfunc == 24 || @zAfunc == 25 || @zAfunc == 27 || @zAfunc == 29 || @zAfunc == 30 || @zAfunc == 31 || @zAfunc == 32 || @zAfunc == 33 || @zAfunc == 34 || @zAfunc == 38 || @zAfunc == 39 || @zAfunc == 40 || @zAfunc == 42 || @zAfunc == 43 || @zAfunc == 44 || @zAfunc == 45 || @zAfunc == 46 || @zAfunc == 47 || @zAfunc == 48 || @zAfunc == 49 || @zAfunc == 50 || @zAfunc == 51 || @zAfunc == 52 || @zAfunc == 54 || @zAfunc == 57 || @zAfunc == 59 || @zAfunc == 60 || @zAfunc == 62 || @zAfunc == 63 || @zAfunc == 64 || @zAfunc == 66 || @zAfunc == 67 || @zAfunc == 68 || @zAfunc == 69 || @zAfunc == 70 || @zAfunc == 71 || @zAfunc == 72 || @zAfunc == 73 || @zAfunc == 74 || @zAfunc == 75 || @zAfunc == 76 || @zAfunc == 77 || @zAfunc == 78 || @zAfunc == 79 || @zAfunc == 80 || @zAfunc == 81 || @zAfunc == 82 || @zAfunc == 83 || @zAfunc == 84 || @zAfunc == 85 || @zAfunc == 86 || @zAfunc == 87 || @zAfunc == 88 || @zAfunc == 89 || @zAfunc == 90 || @zAfunc == 92 || @zAfunc == 93 || @zAfunc == 94 || @zAfunc == 95 || @zAfunc == 96 || @zAfunc == 97 || @zAfunc == 98 || @zAfunc == 99) endparam func zAfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzAfunc && (@zAfunc == 7 || @zAfunc == 8 || @zAfunc == 10 || @zAfunc == 12 || @zAfunc == 14 || @zAfunc == 16 || @zAfunc == 17 || @zAfunc == 18 || @zAfunc == 20 || @zAfunc == 21 || @zAfunc == 22 || @zAfunc == 23 || @zAfunc == 24 || @zAfunc == 25 || @zAfunc == 26 || @zAfunc == 27 || @zAfunc == 28 || @zAfunc == 29 || @zAfunc == 30 || @zAfunc == 31 || @zAfunc == 34 || @zAfunc == 35 || @zAfunc == 37 || @zAfunc == 38 || @zAfunc == 40 || @zAfunc == 42 || @zAfunc == 46 || @zAfunc == 48 || @zAfunc == 49 || @zAfunc == 50 || @zAfunc == 51 || @zAfunc == 55 || @zAfunc == 56 || @zAfunc == 57 || @zAfunc == 58 || @zAfunc == 61 || @zAfunc == 62 || @zAfunc == 63 || @zAfunc == 64 || @zAfunc == 65 || @zAfunc == 66 || @zAfunc == 72 || @zAfunc == 73 || @zAfunc == 76 || @zAfunc == 77 || @zAfunc == 78 || @zAfunc == 84 || @zAfunc == 85 || @zAfunc == 86 || @zAfunc == 88 || @zAfunc == 89 || @zAfunc == 90 || @zAfunc == 92 || @zAfunc == 93 || @zAfunc == 97 || @zAfunc == 98) endfunc param zAvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzAfunc && (@zAfunc == 6 || @zAfunc == 17 || @zAfunc == 19 || @zAfunc == 21 || @zAfunc == 22 || @zAfunc == 23 || @zAfunc == 24 || @zAfunc == 27 || @zAfunc == 34 || @zAfunc == 35 || @zAfunc == 38 || @zAfunc == 39 || @zAfunc == 43 || @zAfunc == 44 || @zAfunc == 45 || @zAfunc == 46 || @zAfunc == 47 || @zAfunc == 48 || @zAfunc == 52 || @zAfunc == 54 || @zAfunc == 59 || @zAfunc == 63 || @zAfunc == 64 || @zAfunc == 66 || @zAfunc == 67 || @zAfunc == 68 || @zAfunc == 69 || @zAfunc == 80 || @zAfunc == 81 || @zAfunc == 84 || @zAfunc == 94 || @zAfunc == 97) endparam func zAfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzAfunc && (@zAfunc == 22 || @zAfunc == 23 || @zAfunc == 25 || @zAfunc == 27 || @zAfunc == 34 || @zAfunc == 35 || @zAfunc == 41 || @zAfunc == 46 || @zAfunc == 49 || @zAfunc == 50 || @zAfunc == 51 || @zAfunc == 59 || @zAfunc == 61 || @zAfunc == 63 || @zAfunc == 70 || @zAfunc == 71 || @zAfunc == 72 || @zAfunc == 73 || @zAfunc == 82 || @zAfunc == 87 || @zAfunc == 92 || @zAfunc == 93 || @zAfunc == 94 || @zAfunc == 98 || @zAfunc == 99) endfunc param oper1 caption = "1st Equation Operation" hint = "1st Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" default = 0 visible = @viewzequs && @viewzAfunc endparam heading visible = @viewzequs endheading bool param viewzBfunc caption = "Show 2nd Equation?" visible = @viewzequs default = false endparam param zBfunc caption = "2nd Equation Flavor" hint = "2nd Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" default = 0 visible = @viewzequs && @viewzBfunc endparam param zBvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzBfunc && (@zBfunc == 5 || @zBfunc == 9 || @zBfunc == 10 || @zBfunc == 12 || @zBfunc == 13 || @zBfunc == 14 || @zBfunc == 15 || @zBfunc == 17 || @zBfunc == 18 || @zBfunc == 19 || @zBfunc == 20 || @zBfunc == 21 || @zBfunc == 22 || @zBfunc == 23 || @zBfunc == 24 || @zBfunc == 25 || @zBfunc == 27 || @zBfunc == 29 || @zBfunc == 30 || @zBfunc == 31 || @zBfunc == 32 || @zBfunc == 33 || @zBfunc == 34 || @zBfunc == 38 || @zBfunc == 39 || @zBfunc == 40 || @zBfunc == 42 || @zBfunc == 43 || @zBfunc == 44 || @zBfunc == 45 || @zBfunc == 46 || @zBfunc == 47 || @zBfunc == 48 || @zBfunc == 49 || @zBfunc == 50 || @zBfunc == 51 || @zBfunc == 52 || @zBfunc == 54 || @zBfunc == 57 || @zBfunc == 59 || @zBfunc == 60 || @zBfunc == 62 || @zBfunc == 63 || @zBfunc == 64 || @zBfunc == 66 || @zBfunc == 67 || @zBfunc == 68 || @zBfunc == 69 || @zBfunc == 70 || @zBfunc == 71 || @zBfunc == 72 || @zBfunc == 73 || @zBfunc == 74 || @zBfunc == 75 || @zBfunc == 76 || @zBfunc == 77 || @zBfunc == 78 || @zBfunc == 79 || @zBfunc == 80 || @zBfunc == 81 || @zBfunc == 82 || @zBfunc == 83 || @zBfunc == 84 || @zBfunc == 85 || @zBfunc == 86 || @zBfunc == 87 || @zBfunc == 88 || @zBfunc == 89 || @zBfunc == 90 || @zBfunc == 92 || @zBfunc == 93 || @zBfunc == 94 || @zBfunc == 95 || @zBfunc == 96 || @zBfunc == 97 || @zBfunc == 98 || @zBfunc == 99) endparam func zBfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzBfunc && (@zBfunc == 7 || @zBfunc == 8 || @zBfunc == 10 || @zBfunc == 12 || @zBfunc == 14 || @zBfunc == 16 || @zBfunc == 17 || @zBfunc == 18 || @zBfunc == 20 || @zBfunc == 21 || @zBfunc == 22 || @zBfunc == 23 || @zBfunc == 24 || @zBfunc == 25 || @zBfunc == 26 || @zBfunc == 27 || @zBfunc == 28 || @zBfunc == 29 || @zBfunc == 30 || @zBfunc == 31 || @zBfunc == 34 || @zBfunc == 35 || @zBfunc == 37 || @zBfunc == 38 || @zBfunc == 40 || @zBfunc == 42 || @zBfunc == 46 || @zBfunc == 48 || @zBfunc == 49 || @zBfunc == 50 || @zBfunc == 51 || @zBfunc == 55 || @zBfunc == 56 || @zBfunc == 57 || @zBfunc == 58 || @zBfunc == 61 || @zBfunc == 62 || @zBfunc == 63 || @zBfunc == 64 || @zBfunc == 65 || @zBfunc == 66 || @zBfunc == 72 || @zBfunc == 73 || @zBfunc == 76 || @zBfunc == 77 || @zBfunc == 78 || @zBfunc == 84 || @zBfunc == 85 || @zBfunc == 86 || @zBfunc == 88 || @zBfunc == 89 || @zBfunc == 90 || @zBfunc == 92 || @zBfunc == 93 || @zBfunc == 97 || @zBfunc == 98) endfunc param zBvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzBfunc && (@zBfunc == 6 || @zBfunc == 17 || @zBfunc == 19 || @zBfunc == 21 || @zBfunc == 22 || @zBfunc == 23 || @zBfunc == 24 || @zBfunc == 27 || @zBfunc == 34 || @zBfunc == 35 || @zBfunc == 38 || @zBfunc == 39 || @zBfunc == 43 || @zBfunc == 44 || @zBfunc == 45 || @zBfunc == 46 || @zBfunc == 47 || @zBfunc == 48 || @zBfunc == 52 || @zBfunc == 54 || @zBfunc == 59 || @zBfunc == 63 || @zBfunc == 64 || @zBfunc == 66 || @zBfunc == 67 || @zBfunc == 68 || @zBfunc == 69 || @zBfunc == 80 || @zBfunc == 81 || @zBfunc == 84 || @zBfunc == 94 || @zBfunc == 97) endparam func zBfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzBfunc && (@zBfunc == 22 || @zBfunc == 23 || @zBfunc == 25 || @zBfunc == 27 || @zBfunc == 34 || @zBfunc == 35 || @zBfunc == 41 || @zBfunc == 46 || @zBfunc == 49 || @zBfunc == 50 || @zBfunc == 51 || @zBfunc == 59 || @zBfunc == 61 || @zBfunc == 63 || @zBfunc == 70 || @zBfunc == 71 || @zBfunc == 72 || @zBfunc == 73 || @zBfunc == 82 || @zBfunc == 87 || @zBfunc == 92 || @zBfunc == 93 || @zBfunc == 94 || @zBfunc == 98 || @zBfunc == 99) endfunc param oper2 caption = "2nd Equation Operation" hint = "2nd Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" default = 0 visible = @viewzequs && @viewzBfunc endparam heading visible = @viewzequs endheading bool param viewzCfunc caption = "Show 3rd Equation?" visible = @viewzequs default = false endparam param zCfunc caption = "3rd Equation Flavor" hint = "3rd Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzCfunc endparam param zCvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzCfunc && (@zCfunc == 5 || @zCfunc == 9 || @zCfunc == 10 || @zCfunc == 12 || @zCfunc == 13 || @zCfunc == 14 || @zCfunc == 15 || @zCfunc == 17 || @zCfunc == 18 || @zCfunc == 19 || @zCfunc == 20 || @zCfunc == 21 || @zCfunc == 22 || @zCfunc == 23 || @zCfunc == 24 || @zCfunc == 25 || @zCfunc == 27 || @zCfunc == 29 || @zCfunc == 30 || @zCfunc == 31 || @zCfunc == 32 || @zCfunc == 33 || @zCfunc == 34 || @zCfunc == 38 || @zCfunc == 39 || @zCfunc == 40 || @zCfunc == 42 || @zCfunc == 43 || @zCfunc == 44 || @zCfunc == 45 || @zCfunc == 46 || @zCfunc == 47 || @zCfunc == 48 || @zCfunc == 49 || @zCfunc == 50 || @zCfunc == 51 || @zCfunc == 52 || @zCfunc == 54 || @zCfunc == 57 || @zCfunc == 59 || @zCfunc == 60 || @zCfunc == 62 || @zCfunc == 63 || @zCfunc == 64 || @zCfunc == 66 || @zCfunc == 67 || @zCfunc == 68 || @zCfunc == 69 || @zCfunc == 70 || @zCfunc == 71 || @zCfunc == 72 || @zCfunc == 73 || @zCfunc == 74 || @zCfunc == 75 || @zCfunc == 76 || @zCfunc == 77 || @zCfunc == 78 || @zCfunc == 79 || @zCfunc == 80 || @zCfunc == 81 || @zCfunc == 82 || @zCfunc == 83 || @zCfunc == 84 || @zCfunc == 85 || @zCfunc == 86 || @zCfunc == 87 || @zCfunc == 88 || @zCfunc == 89 || @zCfunc == 90 || @zCfunc == 92 || @zCfunc == 93 || @zCfunc == 94 || @zCfunc == 95 || @zCfunc == 96 || @zCfunc == 97 || @zCfunc == 98 || @zCfunc == 99) endparam func zCfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzCfunc && (@zCfunc == 7 || @zCfunc == 8 || @zCfunc == 10 || @zCfunc == 12 || @zCfunc == 14 || @zCfunc == 16 || @zCfunc == 17 || @zCfunc == 18 || @zCfunc == 20 || @zCfunc == 21 || @zCfunc == 22 || @zCfunc == 23 || @zCfunc == 24 || @zCfunc == 25 || @zCfunc == 26 || @zCfunc == 27 || @zCfunc == 28 || @zCfunc == 29 || @zCfunc == 30 || @zCfunc == 31 || @zCfunc == 34 || @zCfunc == 35 || @zCfunc == 37 || @zCfunc == 38 || @zCfunc == 40 || @zCfunc == 42 || @zCfunc == 46 || @zCfunc == 48 || @zCfunc == 49 || @zCfunc == 50 || @zCfunc == 51 || @zCfunc == 55 || @zCfunc == 56 || @zCfunc == 57 || @zCfunc == 58 || @zCfunc == 61 || @zCfunc == 62 || @zCfunc == 63 || @zCfunc == 64 || @zCfunc == 65 || @zCfunc == 66 || @zCfunc == 72 || @zCfunc == 73 || @zCfunc == 76 || @zCfunc == 77 || @zCfunc == 78 || @zCfunc == 84 || @zCfunc == 85 || @zCfunc == 86 || @zCfunc == 88 || @zCfunc == 89 || @zCfunc == 90 || @zCfunc == 92 || @zCfunc == 93 || @zCfunc == 97 || @zCfunc == 98) endfunc param zCvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzCfunc && (@zCfunc == 6 || @zCfunc == 17 || @zCfunc == 19 || @zCfunc == 21 || @zCfunc == 22 || @zCfunc == 23 || @zCfunc == 24 || @zCfunc == 27 || @zCfunc == 34 || @zCfunc == 35 || @zCfunc == 38 || @zCfunc == 39 || @zCfunc == 43 || @zCfunc == 44 || @zCfunc == 45 || @zCfunc == 46 || @zCfunc == 47 || @zCfunc == 48 || @zCfunc == 52 || @zCfunc == 54 || @zCfunc == 59 || @zCfunc == 63 || @zCfunc == 64 || @zCfunc == 66 || @zCfunc == 67 || @zCfunc == 68 || @zCfunc == 69 || @zCfunc == 80 || @zCfunc == 81 || @zCfunc == 84 || @zCfunc == 94 || @zCfunc == 97) endparam func zCfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzCfunc && (@zCfunc == 22 || @zCfunc == 23 || @zCfunc == 25 || @zCfunc == 27 || @zCfunc == 34 || @zCfunc == 35 || @zCfunc == 41 || @zCfunc == 46 || @zCfunc == 49 || @zCfunc == 50 || @zCfunc == 51 || @zCfunc == 59 || @zCfunc == 61 || @zCfunc == 63 || @zCfunc == 70 || @zCfunc == 71 || @zCfunc == 72 || @zCfunc == 73 || @zCfunc == 82 || @zCfunc == 87 || @zCfunc == 92 || @zCfunc == 93 || @zCfunc == 94 || @zCfunc == 98 || @zCfunc == 99) endfunc param oper3 caption = "3rd Equation Operation" hint = "3rd Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzCfunc endparam heading visible = @viewzequs endheading bool param viewzDfunc caption = "Show 4th Equation?" visible = @viewzequs default = false endparam param zDfunc caption = "4th Equation Flavor" hint = "4th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzDfunc endparam param zDvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzDfunc && (@zDfunc == 5 || @zDfunc == 9 || @zDfunc == 10 || @zDfunc == 12 || @zDfunc == 13 || @zDfunc == 14 || @zDfunc == 15 || @zDfunc == 17 || @zDfunc == 18 || @zDfunc == 19 || @zDfunc == 20 || @zDfunc == 21 || @zDfunc == 22 || @zDfunc == 23 || @zDfunc == 24 || @zDfunc == 25 || @zDfunc == 27 || @zDfunc == 29 || @zDfunc == 30 || @zDfunc == 31 || @zDfunc == 32 || @zDfunc == 33 || @zDfunc == 34 || @zDfunc == 38 || @zDfunc == 39 || @zDfunc == 40 || @zDfunc == 42 || @zDfunc == 43 || @zDfunc == 44 || @zDfunc == 45 || @zDfunc == 46 || @zDfunc == 47 || @zDfunc == 48 || @zDfunc == 49 || @zDfunc == 50 || @zDfunc == 51 || @zDfunc == 52 || @zDfunc == 54 || @zDfunc == 57 || @zDfunc == 59 || @zDfunc == 60 || @zDfunc == 62 || @zDfunc == 63 || @zDfunc == 64 || @zDfunc == 66 || @zDfunc == 67 || @zDfunc == 68 || @zDfunc == 69 || @zDfunc == 70 || @zDfunc == 71 || @zDfunc == 72 || @zDfunc == 73 || @zDfunc == 74 || @zDfunc == 75 || @zDfunc == 76 || @zDfunc == 77 || @zDfunc == 78 || @zDfunc == 79 || @zDfunc == 80 || @zDfunc == 81 || @zDfunc == 82 || @zDfunc == 83 || @zDfunc == 84 || @zDfunc == 85 || @zDfunc == 86 || @zDfunc == 87 || @zDfunc == 88 || @zDfunc == 89 || @zDfunc == 90 || @zDfunc == 92 || @zDfunc == 93 || @zDfunc == 94 || @zDfunc == 95 || @zDfunc == 96 || @zDfunc == 97 || @zDfunc == 98 || @zDfunc == 99) endparam func zDfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzDfunc && (@zDfunc == 7 || @zDfunc == 8 || @zDfunc == 10 || @zDfunc == 12 || @zDfunc == 14 || @zDfunc == 16 || @zDfunc == 17 || @zDfunc == 18 || @zDfunc == 20 || @zDfunc == 21 || @zDfunc == 22 || @zDfunc == 23 || @zDfunc == 24 || @zDfunc == 25 || @zDfunc == 26 || @zDfunc == 27 || @zDfunc == 28 || @zDfunc == 29 || @zDfunc == 30 || @zDfunc == 31 || @zDfunc == 34 || @zDfunc == 35 || @zDfunc == 37 || @zDfunc == 38 || @zDfunc == 40 || @zDfunc == 42 || @zDfunc == 46 || @zDfunc == 48 || @zDfunc == 49 || @zDfunc == 50 || @zDfunc == 51 || @zDfunc == 55 || @zDfunc == 56 || @zDfunc == 57 || @zDfunc == 58 || @zDfunc == 61 || @zDfunc == 62 || @zDfunc == 63 || @zDfunc == 64 || @zDfunc == 65 || @zDfunc == 66 || @zDfunc == 72 || @zDfunc == 73 || @zDfunc == 76 || @zDfunc == 77 || @zDfunc == 78 || @zDfunc == 84 || @zDfunc == 85 || @zDfunc == 86 || @zDfunc == 88 || @zDfunc == 89 || @zDfunc == 90 || @zDfunc == 92 || @zDfunc == 93 || @zDfunc == 97 || @zDfunc == 98) endfunc param zDvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzDfunc && (@zDfunc == 6 || @zDfunc == 17 || @zDfunc == 19 || @zDfunc == 21 || @zDfunc == 22 || @zDfunc == 23 || @zDfunc == 24 || @zDfunc == 27 || @zDfunc == 34 || @zDfunc == 35 || @zDfunc == 38 || @zDfunc == 39 || @zDfunc == 43 || @zDfunc == 44 || @zDfunc == 45 || @zDfunc == 46 || @zDfunc == 47 || @zDfunc == 48 || @zDfunc == 52 || @zDfunc == 54 || @zDfunc == 59 || @zDfunc == 63 || @zDfunc == 64 || @zDfunc == 66 || @zDfunc == 67 || @zDfunc == 68 || @zDfunc == 69 || @zDfunc == 80 || @zDfunc == 81 || @zDfunc == 84 || @zDfunc == 94 || @zDfunc == 97) endparam func zDfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzDfunc && (@zDfunc == 22 || @zDfunc == 23 || @zDfunc == 25 || @zDfunc == 27 || @zDfunc == 34 || @zDfunc == 35 || @zDfunc == 41 || @zDfunc == 46 || @zDfunc == 49 || @zDfunc == 50 || @zDfunc == 51 || @zDfunc == 59 || @zDfunc == 61 || @zDfunc == 63 || @zDfunc == 70 || @zDfunc == 71 || @zDfunc == 72 || @zDfunc == 73 || @zDfunc == 82 || @zDfunc == 87 || @zDfunc == 92 || @zDfunc == 93 || @zDfunc == 94 || @zDfunc == 98 || @zDfunc == 99) endfunc param oper4 caption = "4th Equation Operation" hint = "4th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzDfunc endparam heading visible = @viewzequs endheading bool param viewzEfunc caption = "Show 5th Equation?" visible = @viewzequs default = false endparam param zEfunc caption = "5th Equation Flavor" hint = "5th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzEfunc endparam param zEvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzEfunc && (@zEfunc == 5 || @zEfunc == 9 || @zEfunc == 10 || @zEfunc == 12 || @zEfunc == 13 || @zEfunc == 14 || @zEfunc == 15 || @zEfunc == 17 || @zEfunc == 18 || @zEfunc == 19 || @zEfunc == 20 || @zEfunc == 21 || @zEfunc == 22 || @zEfunc == 23 || @zEfunc == 24 || @zEfunc == 25 || @zEfunc == 27 || @zEfunc == 29 || @zEfunc == 30 || @zEfunc == 31 || @zEfunc == 32 || @zEfunc == 33 || @zEfunc == 34 || @zEfunc == 38 || @zEfunc == 39 || @zEfunc == 40 || @zEfunc == 42 || @zEfunc == 43 || @zEfunc == 44 || @zEfunc == 45 || @zEfunc == 46 || @zEfunc == 47 || @zEfunc == 48 || @zEfunc == 49 || @zEfunc == 50 || @zEfunc == 51 || @zEfunc == 52 || @zEfunc == 54 || @zEfunc == 57 || @zEfunc == 59 || @zEfunc == 60 || @zEfunc == 62 || @zEfunc == 63 || @zEfunc == 64 || @zEfunc == 66 || @zEfunc == 67 || @zEfunc == 68 || @zEfunc == 69 || @zEfunc == 70 || @zEfunc == 71 || @zEfunc == 72 || @zEfunc == 73 || @zEfunc == 74 || @zEfunc == 75 || @zEfunc == 76 || @zEfunc == 77 || @zEfunc == 78 || @zEfunc == 79 || @zEfunc == 80 || @zEfunc == 81 || @zEfunc == 82 || @zEfunc == 83 || @zEfunc == 84 || @zEfunc == 85 || @zEfunc == 86 || @zEfunc == 87 || @zEfunc == 88 || @zEfunc == 89 || @zEfunc == 90 || @zEfunc == 92 || @zEfunc == 93 || @zEfunc == 94 || @zEfunc == 95 || @zEfunc == 96 || @zEfunc == 97 || @zEfunc == 98 || @zEfunc == 99) endparam func zEfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzEfunc && (@zEfunc == 7 || @zEfunc == 8 || @zEfunc == 10 || @zEfunc == 12 || @zEfunc == 14 || @zEfunc == 16 || @zEfunc == 17 || @zEfunc == 18 || @zEfunc == 20 || @zEfunc == 21 || @zEfunc == 22 || @zEfunc == 23 || @zEfunc == 24 || @zEfunc == 25 || @zEfunc == 26 || @zEfunc == 27 || @zEfunc == 28 || @zEfunc == 29 || @zEfunc == 30 || @zEfunc == 31 || @zEfunc == 34 || @zEfunc == 35 || @zEfunc == 37 || @zEfunc == 38 || @zEfunc == 40 || @zEfunc == 42 || @zEfunc == 46 || @zEfunc == 48 || @zEfunc == 49 || @zEfunc == 50 || @zEfunc == 51 || @zEfunc == 55 || @zEfunc == 56 || @zEfunc == 57 || @zEfunc == 58 || @zEfunc == 61 || @zEfunc == 62 || @zEfunc == 63 || @zEfunc == 64 || @zEfunc == 65 || @zEfunc == 66 || @zEfunc == 72 || @zEfunc == 73 || @zEfunc == 76 || @zEfunc == 77 || @zEfunc == 78 || @zEfunc == 84 || @zEfunc == 85 || @zEfunc == 86 || @zEfunc == 88 || @zEfunc == 89 || @zEfunc == 90 || @zEfunc == 92 || @zEfunc == 93 || @zEfunc == 97 || @zEfunc == 98) endfunc param zEvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzEfunc && (@zEfunc == 6 || @zEfunc == 17 || @zEfunc == 19 || @zEfunc == 21 || @zEfunc == 22 || @zEfunc == 23 || @zEfunc == 24 || @zEfunc == 27 || @zEfunc == 34 || @zEfunc == 35 || @zEfunc == 38 || @zEfunc == 39 || @zEfunc == 43 || @zEfunc == 44 || @zEfunc == 45 || @zEfunc == 46 || @zEfunc == 47 || @zEfunc == 48 || @zEfunc == 52 || @zEfunc == 54 || @zEfunc == 59 || @zEfunc == 63 || @zEfunc == 64 || @zEfunc == 66 || @zEfunc == 67 || @zEfunc == 68 || @zEfunc == 69 || @zEfunc == 80 || @zEfunc == 81 || @zEfunc == 84 || @zEfunc == 94 || @zEfunc == 97) endparam func zEfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzEfunc && (@zEfunc == 22 || @zEfunc == 23 || @zEfunc == 25 || @zEfunc == 27 || @zEfunc == 34 || @zEfunc == 35 || @zEfunc == 41 || @zEfunc == 46 || @zEfunc == 49 || @zEfunc == 50 || @zEfunc == 51 || @zEfunc == 59 || @zEfunc == 61 || @zEfunc == 63 || @zEfunc == 70 || @zEfunc == 71 || @zEfunc == 72 || @zEfunc == 73 || @zEfunc == 82 || @zEfunc == 87 || @zEfunc == 92 || @zEfunc == 93 || @zEfunc == 94 || @zEfunc == 98 || @zEfunc == 99) endfunc param oper5 caption = "5th Equation Operation" hint = "5th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzEfunc endparam heading visible = @viewzequs endheading bool param viewzFfunc caption = "Show 6th Equation?" visible = @viewzequs default = false endparam param zFfunc caption = "6th Equation Flavor" hint = "6th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzFfunc endparam param zFvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzFfunc && (@zFfunc == 5 || @zFfunc == 9 || @zFfunc == 10 || @zFfunc == 12 || @zFfunc == 13 || @zFfunc == 14 || @zFfunc == 15 || @zFfunc == 17 || @zFfunc == 18 || @zFfunc == 19 || @zFfunc == 20 || @zFfunc == 21 || @zFfunc == 22 || @zFfunc == 23 || @zFfunc == 24 || @zFfunc == 25 || @zFfunc == 27 || @zFfunc == 29 || @zFfunc == 30 || @zFfunc == 31 || @zFfunc == 32 || @zFfunc == 33 || @zFfunc == 34 || @zFfunc == 38 || @zFfunc == 39 || @zFfunc == 40 || @zFfunc == 42 || @zFfunc == 43 || @zFfunc == 44 || @zFfunc == 45 || @zFfunc == 46 || @zFfunc == 47 || @zFfunc == 48 || @zFfunc == 49 || @zFfunc == 50 || @zFfunc == 51 || @zFfunc == 52 || @zFfunc == 54 || @zFfunc == 57 || @zFfunc == 59 || @zFfunc == 60 || @zFfunc == 62 || @zFfunc == 63 || @zFfunc == 64 || @zFfunc == 66 || @zFfunc == 67 || @zFfunc == 68 || @zFfunc == 69 || @zFfunc == 70 || @zFfunc == 71 || @zFfunc == 72 || @zFfunc == 73 || @zFfunc == 74 || @zFfunc == 75 || @zFfunc == 76 || @zFfunc == 77 || @zFfunc == 78 || @zFfunc == 79 || @zFfunc == 80 || @zFfunc == 81 || @zFfunc == 82 || @zFfunc == 83 || @zFfunc == 84 || @zFfunc == 85 || @zFfunc == 86 || @zFfunc == 87 || @zFfunc == 88 || @zFfunc == 89 || @zFfunc == 90 || @zFfunc == 92 || @zFfunc == 93 || @zFfunc == 94 || @zFfunc == 95 || @zFfunc == 96 || @zFfunc == 97 || @zFfunc == 98 || @zFfunc == 99) endparam func zFfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzFfunc && (@zFfunc == 7 || @zFfunc == 8 || @zFfunc == 10 || @zFfunc == 12 || @zFfunc == 14 || @zFfunc == 16 || @zFfunc == 17 || @zFfunc == 18 || @zFfunc == 20 || @zFfunc == 21 || @zFfunc == 22 || @zFfunc == 23 || @zFfunc == 24 || @zFfunc == 25 || @zFfunc == 26 || @zFfunc == 27 || @zFfunc == 28 || @zFfunc == 29 || @zFfunc == 30 || @zFfunc == 31 || @zFfunc == 34 || @zFfunc == 35 || @zFfunc == 37 || @zFfunc == 38 || @zFfunc == 40 || @zFfunc == 42 || @zFfunc == 46 || @zFfunc == 48 || @zFfunc == 49 || @zFfunc == 50 || @zFfunc == 51 || @zFfunc == 55 || @zFfunc == 56 || @zFfunc == 57 || @zFfunc == 58 || @zFfunc == 61 || @zFfunc == 62 || @zFfunc == 63 || @zFfunc == 64 || @zFfunc == 65 || @zFfunc == 66 || @zFfunc == 72 || @zFfunc == 73 || @zFfunc == 76 || @zFfunc == 77 || @zFfunc == 78 || @zFfunc == 84 || @zFfunc == 85 || @zFfunc == 86 || @zFfunc == 88 || @zFfunc == 89 || @zFfunc == 90 || @zFfunc == 92 || @zFfunc == 93 || @zFfunc == 97 || @zFfunc == 98) endfunc param zFvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzFfunc && (@zFfunc == 6 || @zFfunc == 17 || @zFfunc == 19 || @zFfunc == 21 || @zFfunc == 22 || @zFfunc == 23 || @zFfunc == 24 || @zFfunc == 27 || @zFfunc == 34 || @zFfunc == 35 || @zFfunc == 38 || @zFfunc == 39 || @zFfunc == 43 || @zFfunc == 44 || @zFfunc == 45 || @zFfunc == 46 || @zFfunc == 47 || @zFfunc == 48 || @zFfunc == 52 || @zFfunc == 54 || @zFfunc == 59 || @zFfunc == 63 || @zFfunc == 64 || @zFfunc == 66 || @zFfunc == 67 || @zFfunc == 68 || @zFfunc == 69 || @zFfunc == 80 || @zFfunc == 81 || @zFfunc == 84 || @zFfunc == 94 || @zFfunc == 97) endparam func zFfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzFfunc && (@zFfunc == 22 || @zFfunc == 23 || @zFfunc == 25 || @zFfunc == 27 || @zFfunc == 34 || @zFfunc == 35 || @zFfunc == 41 || @zFfunc == 46 || @zFfunc == 49 || @zFfunc == 50 || @zFfunc == 51 || @zFfunc == 59 || @zFfunc == 61 || @zFfunc == 63 || @zFfunc == 70 || @zFfunc == 71 || @zFfunc == 72 || @zFfunc == 73 || @zFfunc == 82 || @zFfunc == 87 || @zFfunc == 92 || @zFfunc == 93 || @zFfunc == 94 || @zFfunc == 98 || @zFfunc == 99) endfunc param oper6 caption = "6th Equation Operation" hint = "6th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzFfunc endparam heading visible = @viewzequs endheading bool param viewzGfunc caption = "Show 7th Equation?" visible = @viewzequs default = false endparam param zGfunc caption = "7th Equation Flavor" hint = "7th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzGfunc endparam param zGvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzGfunc && (@zGfunc == 5 || @zGfunc == 9 || @zGfunc == 10 || @zGfunc == 12 || @zGfunc == 13 || @zGfunc == 14 || @zGfunc == 15 || @zGfunc == 17 || @zGfunc == 18 || @zGfunc == 19 || @zGfunc == 20 || @zGfunc == 21 || @zGfunc == 22 || @zGfunc == 23 || @zGfunc == 24 || @zGfunc == 25 || @zGfunc == 27 || @zGfunc == 29 || @zGfunc == 30 || @zGfunc == 31 || @zGfunc == 32 || @zGfunc == 33 || @zGfunc == 34 || @zGfunc == 38 || @zGfunc == 39 || @zGfunc == 40 || @zGfunc == 42 || @zGfunc == 43 || @zGfunc == 44 || @zGfunc == 45 || @zGfunc == 46 || @zGfunc == 47 || @zGfunc == 48 || @zGfunc == 49 || @zGfunc == 50 || @zGfunc == 51 || @zGfunc == 52 || @zGfunc == 54 || @zGfunc == 57 || @zGfunc == 59 || @zGfunc == 60 || @zGfunc == 62 || @zGfunc == 63 || @zGfunc == 64 || @zGfunc == 66 || @zGfunc == 67 || @zGfunc == 68 || @zGfunc == 69 || @zGfunc == 70 || @zGfunc == 71 || @zGfunc == 72 || @zGfunc == 73 || @zGfunc == 74 || @zGfunc == 75 || @zGfunc == 76 || @zGfunc == 77 || @zGfunc == 78 || @zGfunc == 79 || @zGfunc == 80 || @zGfunc == 81 || @zGfunc == 82 || @zGfunc == 83 || @zGfunc == 84 || @zGfunc == 85 || @zGfunc == 86 || @zGfunc == 87 || @zGfunc == 88 || @zGfunc == 89 || @zGfunc == 90 || @zGfunc == 92 || @zGfunc == 93 || @zGfunc == 94 || @zGfunc == 95 || @zGfunc == 96 || @zGfunc == 97 || @zGfunc == 98 || @zGfunc == 99) endparam func zGfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzGfunc && (@zGfunc == 7 || @zGfunc == 8 || @zGfunc == 10 || @zGfunc == 12 || @zGfunc == 14 || @zGfunc == 16 || @zGfunc == 17 || @zGfunc == 18 || @zGfunc == 20 || @zGfunc == 21 || @zGfunc == 22 || @zGfunc == 23 || @zGfunc == 24 || @zGfunc == 25 || @zGfunc == 26 || @zGfunc == 27 || @zGfunc == 28 || @zGfunc == 29 || @zGfunc == 30 || @zGfunc == 31 || @zGfunc == 34 || @zGfunc == 35 || @zGfunc == 37 || @zGfunc == 38 || @zGfunc == 40 || @zGfunc == 42 || @zGfunc == 46 || @zGfunc == 48 || @zGfunc == 49 || @zGfunc == 50 || @zGfunc == 51 || @zGfunc == 55 || @zGfunc == 56 || @zGfunc == 57 || @zGfunc == 58 || @zGfunc == 61 || @zGfunc == 62 || @zGfunc == 63 || @zGfunc == 64 || @zGfunc == 65 || @zGfunc == 66 || @zGfunc == 72 || @zGfunc == 73 || @zGfunc == 76 || @zGfunc == 77 || @zGfunc == 78 || @zGfunc == 84 || @zGfunc == 85 || @zGfunc == 86 || @zGfunc == 88 || @zGfunc == 89 || @zGfunc == 90 || @zGfunc == 92 || @zGfunc == 93 || @zGfunc == 97 || @zGfunc == 98) endfunc param zGvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzGfunc && (@zGfunc == 6 || @zGfunc == 17 || @zGfunc == 19 || @zGfunc == 21 || @zGfunc == 22 || @zGfunc == 23 || @zGfunc == 24 || @zGfunc == 27 || @zGfunc == 34 || @zGfunc == 35 || @zGfunc == 38 || @zGfunc == 39 || @zGfunc == 43 || @zGfunc == 44 || @zGfunc == 45 || @zGfunc == 46 || @zGfunc == 47 || @zGfunc == 48 || @zGfunc == 52 || @zGfunc == 54 || @zGfunc == 59 || @zGfunc == 63 || @zGfunc == 64 || @zGfunc == 66 || @zGfunc == 67 || @zGfunc == 68 || @zGfunc == 69 || @zGfunc == 80 || @zGfunc == 81 || @zGfunc == 84 || @zGfunc == 94 || @zGfunc == 97) endparam func zGfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzGfunc && (@zGfunc == 22 || @zGfunc == 23 || @zGfunc == 25 || @zGfunc == 27 || @zGfunc == 34 || @zGfunc == 35 || @zGfunc == 41 || @zGfunc == 46 || @zGfunc == 49 || @zGfunc == 50 || @zGfunc == 51 || @zGfunc == 59 || @zGfunc == 61 || @zGfunc == 63 || @zGfunc == 70 || @zGfunc == 71 || @zGfunc == 72 || @zGfunc == 73 || @zGfunc == 82 || @zGfunc == 87 || @zGfunc == 92 || @zGfunc == 93 || @zGfunc == 94 || @zGfunc == 98 || @zGfunc == 99) endfunc param oper7 caption = "7th Equation Operation" hint = "7th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzGfunc endparam heading visible = @viewzequs endheading bool param viewzHfunc caption = "Show 8th Equation?" visible = @viewzequs default = false endparam param zHfunc caption = "8th Equation Flavor" hint = "8th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzHfunc endparam param zHvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzHfunc && (@zHfunc == 5 || @zHfunc == 9 || @zHfunc == 10 || @zHfunc == 12 || @zHfunc == 13 || @zHfunc == 14 || @zHfunc == 15 || @zHfunc == 17 || @zHfunc == 18 || @zHfunc == 19 || @zHfunc == 20 || @zHfunc == 21 || @zHfunc == 22 || @zHfunc == 23 || @zHfunc == 24 || @zHfunc == 25 || @zHfunc == 27 || @zHfunc == 29 || @zHfunc == 30 || @zHfunc == 31 || @zHfunc == 32 || @zHfunc == 33 || @zHfunc == 34 || @zHfunc == 38 || @zHfunc == 39 || @zHfunc == 40 || @zHfunc == 42 || @zHfunc == 43 || @zHfunc == 44 || @zHfunc == 45 || @zHfunc == 46 || @zHfunc == 47 || @zHfunc == 48 || @zHfunc == 49 || @zHfunc == 50 || @zHfunc == 51 || @zHfunc == 52 || @zHfunc == 54 || @zHfunc == 57 || @zHfunc == 59 || @zHfunc == 60 || @zHfunc == 62 || @zHfunc == 63 || @zHfunc == 64 || @zHfunc == 66 || @zHfunc == 67 || @zHfunc == 68 || @zHfunc == 69 || @zHfunc == 70 || @zHfunc == 71 || @zHfunc == 72 || @zHfunc == 73 || @zHfunc == 74 || @zHfunc == 75 || @zHfunc == 76 || @zHfunc == 77 || @zHfunc == 78 || @zHfunc == 79 || @zHfunc == 80 || @zHfunc == 81 || @zHfunc == 82 || @zHfunc == 83 || @zHfunc == 84 || @zHfunc == 85 || @zHfunc == 86 || @zHfunc == 87 || @zHfunc == 88 || @zHfunc == 89 || @zHfunc == 90 || @zHfunc == 92 || @zHfunc == 93 || @zHfunc == 94 || @zHfunc == 95 || @zHfunc == 96 || @zHfunc == 97 || @zHfunc == 98 || @zHfunc == 99) endparam func zHfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzHfunc && (@zHfunc == 7 || @zHfunc == 8 || @zHfunc == 10 || @zHfunc == 12 || @zHfunc == 14 || @zHfunc == 16 || @zHfunc == 17 || @zHfunc == 18 || @zHfunc == 20 || @zHfunc == 21 || @zHfunc == 22 || @zHfunc == 23 || @zHfunc == 24 || @zHfunc == 25 || @zHfunc == 26 || @zHfunc == 27 || @zHfunc == 28 || @zHfunc == 29 || @zHfunc == 30 || @zHfunc == 31 || @zHfunc == 34 || @zHfunc == 35 || @zHfunc == 37 || @zHfunc == 38 || @zHfunc == 40 || @zHfunc == 42 || @zHfunc == 46 || @zHfunc == 48 || @zHfunc == 49 || @zHfunc == 50 || @zHfunc == 51 || @zHfunc == 55 || @zHfunc == 56 || @zHfunc == 57 || @zHfunc == 58 || @zHfunc == 61 || @zHfunc == 62 || @zHfunc == 63 || @zHfunc == 64 || @zHfunc == 65 || @zHfunc == 66 || @zHfunc == 72 || @zHfunc == 73 || @zHfunc == 76 || @zHfunc == 77 || @zHfunc == 78 || @zHfunc == 84 || @zHfunc == 85 || @zHfunc == 86 || @zHfunc == 88 || @zHfunc == 89 || @zHfunc == 90 || @zHfunc == 92 || @zHfunc == 93 || @zHfunc == 97 || @zHfunc == 98) endfunc param zHvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzHfunc && (@zHfunc == 6 || @zHfunc == 17 || @zHfunc == 19 || @zHfunc == 21 || @zHfunc == 22 || @zHfunc == 23 || @zHfunc == 24 || @zHfunc == 27 || @zHfunc == 34 || @zHfunc == 35 || @zHfunc == 38 || @zHfunc == 39 || @zHfunc == 43 || @zHfunc == 44 || @zHfunc == 45 || @zHfunc == 46 || @zHfunc == 47 || @zHfunc == 48 || @zHfunc == 52 || @zHfunc == 54 || @zHfunc == 59 || @zHfunc == 63 || @zHfunc == 64 || @zHfunc == 66 || @zHfunc == 67 || @zHfunc == 68 || @zHfunc == 69 || @zHfunc == 80 || @zHfunc == 81 || @zHfunc == 84 || @zHfunc == 94 || @zHfunc == 97) endparam func zHfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzHfunc && (@zHfunc == 22 || @zHfunc == 23 || @zHfunc == 25 || @zHfunc == 27 || @zHfunc == 34 || @zHfunc == 35 || @zHfunc == 41 || @zHfunc == 46 || @zHfunc == 49 || @zHfunc == 50 || @zHfunc == 51 || @zHfunc == 59 || @zHfunc == 61 || @zHfunc == 63 || @zHfunc == 70 || @zHfunc == 71 || @zHfunc == 72 || @zHfunc == 73 || @zHfunc == 82 || @zHfunc == 87 || @zHfunc == 92 || @zHfunc == 93 || @zHfunc == 94 || @zHfunc == 98 || @zHfunc == 99) endfunc param oper8 caption = "8th Equation Operation" hint = "8th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzHfunc endparam heading visible = @viewzequs endheading bool param viewzIfunc caption = "Show 9th Equation?" visible = @viewzequs default = false endparam param zIfunc caption = "9th Equation Flavor" hint = "9th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzIfunc endparam param zIvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzIfunc && (@zIfunc == 5 || @zIfunc == 9 || @zIfunc == 10 || @zIfunc == 12 || @zIfunc == 13 || @zIfunc == 14 || @zIfunc == 15 || @zIfunc == 17 || @zIfunc == 18 || @zIfunc == 19 || @zIfunc == 20 || @zIfunc == 21 || @zIfunc == 22 || @zIfunc == 23 || @zIfunc == 24 || @zIfunc == 25 || @zIfunc == 27 || @zIfunc == 29 || @zIfunc == 30 || @zIfunc == 31 || @zIfunc == 32 || @zIfunc == 33 || @zIfunc == 34 || @zIfunc == 38 || @zIfunc == 39 || @zIfunc == 40 || @zIfunc == 42 || @zIfunc == 43 || @zIfunc == 44 || @zIfunc == 45 || @zIfunc == 46 || @zIfunc == 47 || @zIfunc == 48 || @zIfunc == 49 || @zIfunc == 50 || @zIfunc == 51 || @zIfunc == 52 || @zIfunc == 54 || @zIfunc == 57 || @zIfunc == 59 || @zIfunc == 60 || @zIfunc == 62 || @zIfunc == 63 || @zIfunc == 64 || @zIfunc == 66 || @zIfunc == 67 || @zIfunc == 68 || @zIfunc == 69 || @zIfunc == 70 || @zIfunc == 71 || @zIfunc == 72 || @zIfunc == 73 || @zIfunc == 74 || @zIfunc == 75 || @zIfunc == 76 || @zIfunc == 77 || @zIfunc == 78 || @zIfunc == 79 || @zIfunc == 80 || @zIfunc == 81 || @zIfunc == 82 || @zIfunc == 83 || @zIfunc == 84 || @zIfunc == 85 || @zIfunc == 86 || @zIfunc == 87 || @zIfunc == 88 || @zIfunc == 89 || @zIfunc == 90 || @zIfunc == 92 || @zIfunc == 93 || @zIfunc == 94 || @zIfunc == 95 || @zIfunc == 96 || @zIfunc == 97 || @zIfunc == 98 || @zIfunc == 99) endparam func zIfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzIfunc && (@zIfunc == 7 || @zIfunc == 8 || @zIfunc == 10 || @zIfunc == 12 || @zIfunc == 14 || @zIfunc == 16 || @zIfunc == 17 || @zIfunc == 18 || @zIfunc == 20 || @zIfunc == 21 || @zIfunc == 22 || @zIfunc == 23 || @zIfunc == 24 || @zIfunc == 25 || @zIfunc == 26 || @zIfunc == 27 || @zIfunc == 28 || @zIfunc == 29 || @zIfunc == 30 || @zIfunc == 31 || @zIfunc == 34 || @zIfunc == 35 || @zIfunc == 37 || @zIfunc == 38 || @zIfunc == 40 || @zIfunc == 42 || @zIfunc == 46 || @zIfunc == 48 || @zIfunc == 49 || @zIfunc == 50 || @zIfunc == 51 || @zIfunc == 55 || @zIfunc == 56 || @zIfunc == 57 || @zIfunc == 58 || @zIfunc == 61 || @zIfunc == 62 || @zIfunc == 63 || @zIfunc == 64 || @zIfunc == 65 || @zIfunc == 66 || @zIfunc == 72 || @zIfunc == 73 || @zIfunc == 76 || @zIfunc == 77 || @zIfunc == 78 || @zIfunc == 84 || @zIfunc == 85 || @zIfunc == 86 || @zIfunc == 88 || @zIfunc == 89 || @zIfunc == 90 || @zIfunc == 92 || @zIfunc == 93 || @zIfunc == 97 || @zIfunc == 98) endfunc param zIvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzIfunc && (@zIfunc == 6 || @zIfunc == 17 || @zIfunc == 19 || @zIfunc == 21 || @zIfunc == 22 || @zIfunc == 23 || @zIfunc == 24 || @zIfunc == 27 || @zIfunc == 34 || @zIfunc == 35 || @zIfunc == 38 || @zIfunc == 39 || @zIfunc == 43 || @zIfunc == 44 || @zIfunc == 45 || @zIfunc == 46 || @zIfunc == 47 || @zIfunc == 48 || @zIfunc == 52 || @zIfunc == 54 || @zIfunc == 59 || @zIfunc == 63 || @zIfunc == 64 || @zIfunc == 66 || @zIfunc == 67 || @zIfunc == 68 || @zIfunc == 69 || @zIfunc == 80 || @zIfunc == 81 || @zIfunc == 84 || @zIfunc == 94 || @zIfunc == 97) endparam func zIfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzIfunc && (@zIfunc == 22 || @zIfunc == 23 || @zIfunc == 25 || @zIfunc == 27 || @zIfunc == 34 || @zIfunc == 35 || @zIfunc == 41 || @zIfunc == 46 || @zIfunc == 49 || @zIfunc == 50 || @zIfunc == 51 || @zIfunc == 59 || @zIfunc == 61 || @zIfunc == 63 || @zIfunc == 70 || @zIfunc == 71 || @zIfunc == 72 || @zIfunc == 73 || @zIfunc == 82 || @zIfunc == 87 || @zIfunc == 92 || @zIfunc == 93 || @zIfunc == 94 || @zIfunc == 98 || @zIfunc == 99) endfunc param oper9 caption = "9th Equation Operation" hint = "9th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzIfunc endparam heading visible = @viewzequs endheading bool param viewzJfunc caption = "Show 10th Equation?" visible = @viewzequs default = false endparam param zJfunc caption = "10th Equation Flavor" hint = "10th Equation" enum = "z" "#pixel" "z*z+#pixel" "1/z" "1/#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "z*z+p1" "fn1(z*z+p1)" "z * z - z / #pixel " "z ^ (fn1 ( z + z * z / p1 ))" "(z ^ p1 )- (z * z / #pixel )" "fn1 ( z / p1 )" "(z + p1 )* (z - #pixel - p1 * (z ))" "(z + (fn1 ( z + 1 - #pixel )))" "(z * p1 / ((fn1 ( z / z + p2 )- #pixel )^ (z - #pixel )))" "(z * (fn1 ( z ^ p1)))" "(z - p1 )^ (z - #pixel * z ^ p2 )" "((fn1 ( p1 )* (z )))" "((fn1 ( z + p2 )/ (z ^ p1)))" "(p2 )* #pixel * ((fn1 ( z / p1 )* ((fn1 ( p2 )* (#pixel )))))" "(fn1 ( z * p2 )* ((fn1 ( fn1 ( p1 )))))" "(z + p1 )/ ((fn1 ( z - p2 )))" "z - (fn1 ( z - (fn1 ( z + p1 )+ (z ))))" "z + z + (fn1 ( z ^ z - #pixel ))" "(p2 ^ (z * (fn1 ( z / (fn1 (p1 ))))))" "fn1 ( z / #pixel )" "(z * z + (fn1 ( p1 )))" "((fn1 ( 1 - z * p1 )))" "z + z * p1 - (fn1 ( z ^ #pixel ))" "(z - (z ^ p1 ))+ (#pixel )" "z ^ p1 / (z )" "z - (fn1 ( z / fn1 ( p1 ^ (p2 ))))" "(z ^ fn1 ( z - (fn1 ( z * fn1 ( p2 )))))" "(z - #pixel / z + #pixel )" "z * z - (fn1 ( z ))" "(z ^ (fn1 ( z + p1 )/ (p2 )))" "(p1 - z) / (z - p2 )" "z * (fn1 ( z + p1 )- #pixel + z )" "(z - (fn1 ( 1 / z )))" "fn1 ( z * p1 )- #pixel ^ z + z " "(z / z - p2 )/ (p1 )^ #pixel * (#pixel )" "(z / p1 )+ (p2 / z)" "(z - p2 + z ^ p1 )" "(z * p1 / #pixel )- ((fn1 ( z + fn1 ( p2 ))))" "p2 - (z * p1 )" "z - z ^ p1 - (fn1 ( p2 ))" "(fn1 ( z - #pixel * fn1 ( p1 )))" "(z / fn1 ( z - p1 )^ ((fn1 ( #pixel ))))" "(fn1 ( (fn1 ( p1 + z))))" "(z / p1 )^ (#pixel - z + p2 )" "(z - z ^ #pixel )" "(z + p2 )^ z - p1 - (z )" "(z ^ z - (fn1 ( #pixel )))" "z + z ^ (fn1 ( #pixel ))" "(z * fn1 ( z * p1 ))" "z + (fn1 ( #pixel / z ))" "(z / p2 )+ fn1 ( p1 )" "1 / ( z * z - #pixel ) + p1" "fn1(z) + fn1(#pixel)" "fn1(z) + fn1(p1)" \ "z * (fn1(p1 ^ p2) /fn1( p1 ^ p2))/p1 + (1/z)" "z * z + z / p1 + fn1 (p2)" "fn1( (z ^ 2 + #pixel - 1) / (2 * z + #pixel - 2) )" "fn1( (z^2 + p1 - 1) / (2*z + p2 - 2) )" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + p1" "z - p1 * (z^p2-1) / (p2 * z^(p1-1)) + #pixel" "((p1 - 1) * z^p1 + p2) / (p1 * z ^ (p1 - 1))" "(z ^ z + 1 / (z - 1 + z ^ p1 )+ ((atan2 ( (fn1 ( z - z - z ^ p1 )* ((fn1 ( z ))))))))" "(p1 ^ (p1 )/ fn1 ( 2 / (z + 4 )))" "(4 + (fn1 ( fn1 ( p1 )^ fn1 ( p1 )+ ((fn1 ( #e ))))))" "(((fn1 (z - 2 - z - p1 )^ #pixel )* ((fn1 ( z )))" "p1 + #pixel * z ^ p1 * #pixel" "(z * p1 )- #pixel" "fn1 ( p1 )/ (fn1 ( z))" "(z / p1 )+ (fn1 ( z + 1 ))" "(z - p1 + (z / fn1 ( #pixel )))" "z * p1 - #pixel - z" "p1 * (z - p2 ^ (p1 ))" "(p1 )/ (z ^ p1 ^ z )" "p1 ^ #pixel / (p1 ^ fn1 ( z * z ))" "(z / p1 - z )" "((fn1 ( p1 )- (p1 )^ (#random * p2))- fn1 ( 2 ^ (#pixel )))" "(fn1 ( p1 )- (fn1 ( z )))" "p1 ^ fn1 ( #pixel )" "p1 * (fn1 ( 1 - #pixel )- z )" "z - fn1 ( p1 / (z ))" "fn1 ( p1 / #pixel + (#pixel+z) )" "z ^ p1 - (fn1 ( #pixel ))" "z * z - z + z " "(p1 / fn1 ( fn1 ( p1 ^ z - #pixel )))" "z + p1 + fn1 ( fn1 ( z - fn1 ( z )))" "z + p1 / p2 * z + p1 - (fn1 ( z ))" "z / p1 / z * #pixel" "p1 * (1 / z / 3) * (z )" "z * p1 + z / p2 ^ (fn1 ( z + z ))" "fn1 ( p1 ^ #pixel / (fn1 ( z )))" "(z / z - fn1 ( z * p1 ^ #pixel ))" visible = @viewzequs && @viewzJfunc endparam param zJvar1 caption = "p1" hint = "Variable 1" visible = @viewzequs && @viewzJfunc && (@zJfunc == 5 || @zJfunc == 9 || @zJfunc == 10 || @zJfunc == 12 || @zJfunc == 13 || @zJfunc == 14 || @zJfunc == 15 || @zJfunc == 17 || @zJfunc == 18 || @zJfunc == 19 || @zJfunc == 20 || @zJfunc == 21 || @zJfunc == 22 || @zJfunc == 23 || @zJfunc == 24 || @zJfunc == 25 || @zJfunc == 27 || @zJfunc == 29 || @zJfunc == 30 || @zJfunc == 31 || @zJfunc == 32 || @zJfunc == 33 || @zJfunc == 34 || @zJfunc == 38 || @zJfunc == 39 || @zJfunc == 40 || @zJfunc == 42 || @zJfunc == 43 || @zJfunc == 44 || @zJfunc == 45 || @zJfunc == 46 || @zJfunc == 47 || @zJfunc == 48 || @zJfunc == 49 || @zJfunc == 50 || @zJfunc == 51 || @zJfunc == 52 || @zJfunc == 54 || @zJfunc == 57 || @zJfunc == 59 || @zJfunc == 60 || @zJfunc == 62 || @zJfunc == 63 || @zJfunc == 64 || @zJfunc == 66 || @zJfunc == 67 || @zJfunc == 68 || @zJfunc == 69 || @zJfunc == 70 || @zJfunc == 71 || @zJfunc == 72 || @zJfunc == 73 || @zJfunc == 74 || @zJfunc == 75 || @zJfunc == 76 || @zJfunc == 77 || @zJfunc == 78 || @zJfunc == 79 || @zJfunc == 80 || @zJfunc == 81 || @zJfunc == 82 || @zJfunc == 83 || @zJfunc == 84 || @zJfunc == 85 || @zJfunc == 86 || @zJfunc == 87 || @zJfunc == 88 || @zJfunc == 89 || @zJfunc == 90 || @zJfunc == 92 || @zJfunc == 93 || @zJfunc == 94 || @zJfunc == 95 || @zJfunc == 96 || @zJfunc == 97 || @zJfunc == 98 || @zJfunc == 99) endparam func zJfunc1 caption = "Fn1" hint = "Function 1" visible = @viewzequs && @viewzJfunc && (@zJfunc == 7 || @zJfunc == 8 || @zJfunc == 10 || @zJfunc == 12 || @zJfunc == 14 || @zJfunc == 16 || @zJfunc == 17 || @zJfunc == 18 || @zJfunc == 20 || @zJfunc == 21 || @zJfunc == 22 || @zJfunc == 23 || @zJfunc == 24 || @zJfunc == 25 || @zJfunc == 26 || @zJfunc == 27 || @zJfunc == 28 || @zJfunc == 29 || @zJfunc == 30 || @zJfunc == 31 || @zJfunc == 34 || @zJfunc == 35 || @zJfunc == 37 || @zJfunc == 38 || @zJfunc == 40 || @zJfunc == 42 || @zJfunc == 46 || @zJfunc == 48 || @zJfunc == 49 || @zJfunc == 50 || @zJfunc == 51 || @zJfunc == 55 || @zJfunc == 56 || @zJfunc == 57 || @zJfunc == 58 || @zJfunc == 61 || @zJfunc == 62 || @zJfunc == 63 || @zJfunc == 64 || @zJfunc == 65 || @zJfunc == 66 || @zJfunc == 72 || @zJfunc == 73 || @zJfunc == 76 || @zJfunc == 77 || @zJfunc == 78 || @zJfunc == 84 || @zJfunc == 85 || @zJfunc == 86 || @zJfunc == 88 || @zJfunc == 89 || @zJfunc == 90 || @zJfunc == 92 || @zJfunc == 93 || @zJfunc == 97 || @zJfunc == 98) endfunc param zJvar2 caption = "p2" hint = "Variable 2" visible = @viewzequs && @viewzJfunc && (@zJfunc == 6 || @zJfunc == 17 || @zJfunc == 19 || @zJfunc == 21 || @zJfunc == 22 || @zJfunc == 23 || @zJfunc == 24 || @zJfunc == 27 || @zJfunc == 34 || @zJfunc == 35 || @zJfunc == 38 || @zJfunc == 39 || @zJfunc == 43 || @zJfunc == 44 || @zJfunc == 45 || @zJfunc == 46 || @zJfunc == 47 || @zJfunc == 48 || @zJfunc == 52 || @zJfunc == 54 || @zJfunc == 59 || @zJfunc == 63 || @zJfunc == 64 || @zJfunc == 66 || @zJfunc == 67 || @zJfunc == 68 || @zJfunc == 69 || @zJfunc == 80 || @zJfunc == 81 || @zJfunc == 84 || @zJfunc == 94 || @zJfunc == 97) endparam func zJfunc2 caption = "Fn2" hint = "Function 2" visible = @viewzequs && @viewzJfunc && (@zJfunc == 22 || @zJfunc == 23 || @zJfunc == 25 || @zJfunc == 27 || @zJfunc == 34 || @zJfunc == 35 || @zJfunc == 41 || @zJfunc == 46 || @zJfunc == 49 || @zJfunc == 50 || @zJfunc == 51 || @zJfunc == 59 || @zJfunc == 61 || @zJfunc == 63 || @zJfunc == 70 || @zJfunc == 71 || @zJfunc == 72 || @zJfunc == 73 || @zJfunc == 82 || @zJfunc == 87 || @zJfunc == 92 || @zJfunc == 93 || @zJfunc == 94 || @zJfunc == 98 || @zJfunc == 99) endfunc param oper10 caption = "10th Equation Operation" hint = "10th Equation will affect Z this way" enum = "unused" "Z + Equation" "Z - Equation" "Z * Equation" "Z / Equation" "Z ^ Equation" "Equation - Z" "Equation / Z" "Equation ^ Z" "Z = Equation" visible = @viewzequs && @viewzJfunc endparam heading caption = "Finishing Options" visible = @viewbail endheading float param bignumber caption = "Z Maximum" hint = "If the calculation is slow, set this to a smaller number" default = 10e5 visible = @viewbail endparam bool param usescreencenter caption = "Use Screen Center Extra Tweak?" visible = @viewbail && (#magn!=1 || #center!=0) default = FALSE endparam heading caption = "First Function Options" visible = @viewbail endheading param leftzbail caption = "Function 1" hint = "Custom Bailouts" enum = "z" "#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "fn1(p1)" "z * z + #pixel" "z * z + p1" "p1 * (z * (fn1 ( z ^ p2 )))" "(fn1 ( z - (fn2 ( z ))))" "z + (fn1 ( z - (fn2 ( p1 )^ (p2 ))))" "z - fn1 ( #pixel )" "z * fn1 ( z )" "z ^ p2 ^ ((fn1 ( fn2 ( z + p1 ))))" "z * fn1 ( z - (p1 * #random ))" "(z ^ p1 )" "p1 - (fn1 ( z + fn2 ( z )))" "(fn1 ( z + #pixel ))" "fn2 ( z + (fn1 ( #pixel )))" "1/z" "1/#pixel" "fn1 (1/z)" "fn1 (1/#pixel) + p1" default = 0 visible = @viewbail endparam param leftbailoutvar1 caption = "p1 for Advanced Function 1" default = (2,0) visible = @viewbail && (@leftzbail == 2 || @leftzbail == 6 || @leftzbail == 8 || @leftzbail == 9 || @leftzbail == 11 || @leftzbail == 14 || @leftzbail == 15 || @leftzbail == 16 || @leftzbail == 17) endparam func leftbailoutfunc1 caption = "fn1 for Advanced Function 1" visible = @viewbail && (@leftzbail == 4 || @leftzbail == 5 || @leftzbail == 6 || @leftzbail == 9 || @leftzbail == 10 || @leftzbail == 11 || @leftzbail == 12 || @leftzbail == 13 || @leftzbail == 14 || @leftzbail == 15 || @leftzbail == 17 || @leftzbail == 18 || @leftzbail == 19 || @leftzbail == 22) endfunc param leftbailoutvar2 caption = "p2 for Advanced Function 1" visible = @viewbail && (@leftzbail == 3 || @leftzbail == 9 || @leftzbail == 11 || @leftzbail == 14) endparam func leftbailoutfunc2 caption = "fn2 for Advanced Function 1" visible = @viewbail && (@leftzbail == 10 || @leftzbail == 11 || @leftzbail == 14 || @leftzbail == 17 || @leftzbail == 19) endfunc param bailtestleft caption =" Function 1 setup" enum = "original" "real" "imag" "real + imag" "real - imag" "real * imag" "real / imag" "real ^ imag" "imag - real" "imag ^ real" "original + internal fn()" "real + internal fn()" "imag + internal fn()" "real + imag + internal fn()" "real - imag + internal fn()" "real * imag + internal fn()" "real / imag + internal fn()" "real ^ imag + internal fn()" "imag - real + internal fn()" "imag ^ real + internal fn()" "original + external fn()" "real + external fn()" "imag + external fn()" "real + imag + external fn()" "real - imag + external fn()" "real * imag + external fn()" "real / imag + external fn()" "real ^ imag + external fn()" "imag - real + external fn()" "imag ^ real + external fn()" "original + both fn()s" "real + both fn()s" "imag + both fn()s" "real + imag + both fn()s" "real - imag + both fn()s" "real * imag + both fn()s" "real / imag + both fn()s" "real ^ imag + both fn()s" "imag - real + both fn()s" "imag ^ real + both fn()s" default = 1 visible = @viewbail endparam func leftbailfunc caption = "External Bailout Function" visible = @viewbail && (@bailtestleft == 20 || @bailtestleft == 21 || @bailtestleft == 22 || @bailtestleft == 23 || @bailtestleft == 24 || @bailtestleft == 25 || @bailtestleft == 26 || @bailtestleft == 27 || @bailtestleft == 28 || @bailtestleft == 29 || @bailtestleft == 30 || @bailtestleft == 31 || @bailtestleft == 32 || @bailtestleft == 33 || @bailtestleft == 34 || @bailtestleft == 35 || @bailtestleft == 36 || @bailtestleft == 37 || @bailtestleft == 38 || @bailtestleft == 39) default = ident() endfunc func leftbailoutfunc caption = "Internal Bailout Function" visible = @viewbail && (@bailtestleft == 10 || @bailtestleft == 11 || @bailtestleft == 12 || @bailtestleft == 13 || @bailtestleft == 14 || @bailtestleft == 15 || @bailtestleft == 16 || @bailtestleft == 17 || @bailtestleft == 18 || @bailtestleft == 19 || @bailtestleft == 30 || @bailtestleft == 31 || @bailtestleft == 32 || @bailtestleft == 33 || @bailtestleft == 34 || @bailtestleft == 35 || @bailtestleft == 36 || @bailtestleft == 37 || @bailtestleft == 38 || @bailtestleft == 39) default = ident() endfunc heading caption = "Second Function Options" visible = @viewbail endheading param rightzbail caption = "Function 2" hint = "Custom Bailouts" enum = "z" "#pixel" "p1" "p2" "fn1(z)" "fn1(#pixel)" "fn1(p1)" "z * z + #pixel" "z * z + p1" "p1 * (z * (fn1 ( z ^ p2 )))" "(fn1 ( z - (fn2 ( z ))))" "z + (fn1 ( z - (fn2 ( p1 )^ (p2 ))))" "z - fn1 ( #pixel )" "z * fn1 ( z )" "z ^ p2 ^ ((fn1 ( fn2 ( z + p1 ))))" "z * fn1 ( z - (p1 * #random ))" "(z ^ p1 )" "p1 - (fn1 ( z + fn2 ( z )))" "(fn1 ( z + #pixel ))" "fn2 ( z + (fn1 ( #pixel )))" "1/z" "1/#pixel" "fn1 (1/z)" "fn1 (1/#pixel) + p1" default = 0 visible = @viewbail endparam param rightbailoutvar1 caption = "p1 for Advanced Function 2" default = (2,0) visible = @viewbail && (@rightzbail == 2 || @rightzbail == 6 || @rightzbail == 8 || @rightzbail == 9 || @rightzbail == 11 || @rightzbail == 14 || @rightzbail == 15 || @rightzbail == 16 || @rightzbail == 17) endparam func rightbailoutfunc1 caption = "fn1 for Advanced Function 2" visible = @viewbail && (@rightzbail == 4 || @rightzbail == 5 || @rightzbail == 6 || @rightzbail == 9 || @rightzbail == 10 || @rightzbail == 11 || @rightzbail == 12 || @rightzbail == 13 || @rightzbail == 14 || @rightzbail == 15 || @rightzbail == 17 || @rightzbail == 18 || @rightzbail == 19 || @rightzbail == 22) endfunc param rightbailoutvar2 caption = "p2 for Advanced Function 2" visible = @viewbail && (@rightzbail == 3 || @rightzbail == 9 || @rightzbail == 11 || @rightzbail == 14) endparam func rightbailoutfunc2 caption = "fn2 for Advanced Function 2" visible = @viewbail && (@rightzbail == 10 || @rightzbail == 11 || @rightzbail == 14 || @rightzbail == 17 || @rightzbail == 19) endfunc param bailtestright caption =" Function 2 setup" enum = "original" "real" "imag" "real + imag" "real - imag" "real * imag" "real / imag" "real ^ imag" "imag - real" "imag ^ real" "original + internal fn()" "real + internal fn()" "imag + internal fn()" "real + imag + internal fn()" "real - imag + internal fn()" "real * imag + internal fn()" "real / imag + internal fn()" "real ^ imag + internal fn()" "imag - real + internal fn()" "imag ^ real + internal fn()" "original + external fn()" "real + external fn()" "imag + external fn()" "real + imag + external fn()" "real - imag + external fn()" "real * imag + external fn()" "real / imag + external fn()" "real ^ imag + external fn()" "imag - real + external fn()" "imag ^ real + external fn()" "original + both fn()s" "real + both fn()s" "imag + both fn()s" "real + imag + both fn()s" "real - imag + both fn()s" "real * imag + both fn()s" "real / imag + both fn()s" "real ^ imag + both fn()s" "imag - real + both fn()s" "imag ^ real + both fn()s" default = 2 visible = @viewbail endparam func rightbailfunc caption = "External Bailout Function" visible = @viewbail && (@bailtestright == 20 || @bailtestright == 21 || @bailtestright == 22 || @bailtestright == 23 || @bailtestright == 24 || @bailtestright == 25 || @bailtestright == 26 || @bailtestright == 27 || @bailtestright == 28 || @bailtestright == 29 || @bailtestright == 30 || @bailtestright == 31 || @bailtestright == 32 || @bailtestright == 33 || @bailtestright == 34 || @bailtestright == 35 || @bailtestright == 36 || @bailtestright == 37 || @bailtestright == 38 || @bailtestright == 39) default = ident() endfunc func rightbailoutfunc caption = "Internal Bailout Function" visible = @viewbail && (@bailtestright == 10 || @bailtestright == 11 || @bailtestright == 12 || @bailtestright == 13 || @bailtestright == 14 || @bailtestright == 15 || @bailtestright == 16 || @bailtestright == 17 || @bailtestright == 18 || @bailtestright == 19 || @bailtestright == 30 || @bailtestright == 31 || @bailtestright == 32 || @bailtestright == 33 || @bailtestright == 34 || @bailtestright == 35 || @bailtestright == 36 || @bailtestright == 37 || @bailtestright == 38 || @bailtestright == 39) default = ident() endfunc heading caption = "Finishing Transformation Options" visible = @viewbail endheading param zbailoper1 caption = "Pixel Real Value Modifier" enum = "Function 1 + Function 2" "Function 1 - Function 2" "Function 1 * Function 2" "Function 1 / Function 2" "Function 1 ^ Function 2" "Function 2 - Function 1" "Function 2 / Function 1" "Function 2 ^ Function 1" "Function 1" "Function 2" default = 8 visible = @viewbail endparam param zbailoper2 caption = "Pixel Imag Value Modifier" enum = "Function 1 + Function 2" "Function 1 - Function 2" "Function 1 * Function 2" "Function 1 / Function 2" "Function 1 ^ Function 2" "Function 2 - Function 1" "Function 2 / Function 1" "Function 2 ^ Function 1" "Function 1" "Function 2" default = 9 visible = @viewbail endparam }