comment {
  Carr2400.ufm Version 1.1
  Ultra Fractal conversions of Robert Carr's formulas Carr2400 - Carr2499
  by Erik Reckase, March 2, 2000  

  History:  Version 1.1 - major optimization overhaul, cleanup, hints

            Version 1.0 - Initial Release
                          Original formulas pulled from _rc2.frm
                          Carr2402-2410,2413-2422,
                              2424,2430-2432,
                              2434-2462,2472,
                              2476-2482,2484-2499    : pixel fix
                          Carr2487-2488              : cosxx fix
                          Carr2444,2447              : modified cabs
                          Carr2411                   : bad assignment
}

Carr2400 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=pixel-conj(.1/pixel)-flip(conj(.01/pixel))
  c=conj(pixel)*sqr(pixel)-sinh(.1/pixel)-sqr(flip(.0051/pixel))
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2400"
  periodicity = 0
  maxiter = 500
  magn = 1.5
  center = (-.1,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2401 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=pixel, c=atan(pixel)*2+conj(pixel/3)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF 
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2401"
  periodicity = 0
  maxiter = 500
  magn = 3
  center = (-.1,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2402 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2, c=atan(pixel2)*2+conj(pixel2/3)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2402"
  periodicity = 0
  maxiter = 500
  magn = 3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2403 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  c=pixel2, z=atan(pixel2)*2+conj(pixel2/3)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF  
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2403"
  periodicity = 0
  maxiter = 500
  magn = 3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2404 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=conj(pixel2)*sqr(pixel2)-sqr(flip(.0051/pixel2))
  c=pixel2^2-.25
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2404"
  periodicity = 0
  maxiter = 500
  magn = 1.6
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2405 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=conj(pixel2)*sqr(pixel2)-sinh(.1/pixel2) \
    -sqr(flip(.0051/pixel2))
  c=pixel2^8+.196
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2405"
  periodicity = 0
  maxiter = 500
  magn = 1.6
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2406 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=conj(pixel2)*sqr(pixel2)-conj(.1/pixel2) \
    -sqr(flip(.0051/pixel2))
  c=pixel2^8+.296
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2406"
  periodicity = 0
  maxiter = 500
  magn = 1.6
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2407 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  c=pixel2^3-conj(.1/pixel2)-flip(.01/pixel2)
  z=pixel2/5+pixel2/3+(pixel2/2)^4
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2407"
  periodicity = 0
  maxiter = 500
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2408 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=3*pixel2+conj(pixel2-flip(.01/pixel2))
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2408"
  periodicity = 0
  maxiter = 500
  magn = 4
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2409 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=3*pixel2+conj(pixel2-conj(.02/pixel2))
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2409"
  periodicity = 0
  maxiter = 500
  magn = 5
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2410 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=pixel2-asin(pixel2)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2410"
  periodicity = 0
  maxiter = 500
  magn = .7
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2411 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=c=2*pixel
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2411"
  periodicity = 0
  maxiter = 500
  magn = 5
  center = (-.1,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2412 {; Updated for UF by Erik Reckase, March 2000
          ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
          ; Modified Brian Jones frm. mans-galore-012
init:
  r=conj(pixel/2)
  z=c=3.5*pixel^5-r-sin(.08*pixel-flip(.01/pixel))\
      +conj(.0535/pixel)+.05
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2412"
  periodicity = 0
  maxiter = 500
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2413 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=conj(pixel2/2)+sin(.08*pixel2-flip(.01/pixel2)) \
    -conj(.0535/pixel2)-.05
  z=2.5*pixel2^3-r, c=3.5*pixel2^5-r
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2413"
  periodicity = 0
  maxiter = 500
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2414 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Corrected typo (0.08pixel to 0.08*pixel) 
                  ;   G. Martin 10/98
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=conj(pixel2/2)+sin(.08*pixel2-flip(.01/pixel2)) \
    -conj(.0535/pixel2)
  z=1.5*pixel2^6-r, c=3.5*pixel2^5-r+.05
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2414"
  periodicity = 0
  maxiter = 500
  magn = 1.7
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2415 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2/2)+sin(.08*pixel2-flip(.01/pixel2)) \
    -conj(.0535/pixel2)
  z=1.5*pixel2^6-r, c=3.5*pixel2^5-r+.05
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2415"
  periodicity = 0
  maxiter = 500
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2416 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2/2)+cabs(.08*pixel2-flip(.01/pixel2))\
    -conj(.0535/pixel2)
  z=1.5*pixel2^9-r+.09, c=1.5*pixel2^5-r+0.1
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2416"
  periodicity = 0
  maxiter = 500
  magn = 1.6
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2417 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  c=2*pixel2^4-flip(pixel2/4+pixel2/3) \
    -sin(.8*pixel2-flip(.01/pixel2))+conj(.1275/pixel2)
  z=c-.2
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2417"
  periodicity = 0
  maxiter = 500
  magn = 1.6
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2418 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2), j=4.5*pixel2
  z=tanh(pixel2)-1/sqrt(j+.555/j-conj(.03/pixel2) \
    -flip(.055/pixel2)+2/r)
  c=2*pixel2+(-.099,-.2249)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*cotan(fn1(y+p3*fn2(y)))
  y1=y-p2*cotan(fn1(x+p3*fn2(x)))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2418"
  periodicity = 0
  maxiter = 500
  magn = 3.5
  center = (0,.07)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the cotan of the sum of the \
            z-coordinates and the scaled result of the \
            Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2419 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2), j=4.5*pixel2
  z=cabs(pixel2)-1/sqrt(j+.555/j-conj(.03/pixel2) \
    -flip(.055/pixel2)+2/r)
  c=3*pixel2+(-.099,-.2249)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2419"
  periodicity = 0
  maxiter = 500
  magn = 3.5
  center = (0,.1)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2420 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2), j=1.5*pixel2
  z=cabs(pixel2*2)-1/sqrt(j+.555/j-conj(.03/pixel2) \
    -flip(.055/pixel2)+2/r)
  c=3*pixel2+(-.099,-.2249)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2420"
  periodicity = 0
  maxiter = 500
  magn = 3.5
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2421 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2), j=(1.5*pixel2)^4
  z=1.5*pixel2-1/sqrt(j+.555/j-conj(.08/pixel2) \
    -flip(.095/pixel2)+2/r)
  c=3*pixel2+(-.099,-.0249)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2421"
  periodicity = 0
  maxiter = 500
  magn = 5
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2422 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  c=2*pixel2-log(pixel2-1/tan(.001/pixel2))^-3.8
  z=pixel2+conj(flip(pixel2))+flip(tanh(pixel2))
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2422"
  periodicity = 0
  maxiter = 500
  magn = 3.5
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2423 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Sylvie Gallet frm
init:
  z=c=pixel
  int iterspace = round(real(p1)), int nextzoom = iterspace
  int iter=0, k = flip(imag(.0375/pixel))
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = p2*c + p3
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2423"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (-.4,0)
  method = multipass
  param p1
    caption = "Nextzoom"
    default = (128,0)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is not used, but remains for Fractint compat."
  endparam
  param p2
    caption = "C-Mult"
    default = (1.2,.1)
    hint = "C is mutliplied by this value when the number of \
            iterations equals nextzoom (p1)"
  endparam
  param p3
    caption = "C-Add"
    default = (-.05,-.06)
    hint = "This value is added to C when the number of \
            iterations equals nextzoom (p1)"
  endparam
}

Carr2424 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Brian Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  m=cabs(pixel2/4+pixel2/3)-conj(.1275/pixel2)
  z=2*pixel2^4-m-sin(.8*pixel2-flip(.01/pixel2))
  c=4*pixel2^4-m-sin(pixel2-flip(.01/pixel2))
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2424"
  periodicity = 0
  maxiter = 500
  magn = 1.9
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2425 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  m=cabs(pixel/4+pixel/3)-conj(0.1275/pixel)
  z=2*pixel^4-m-sin(.8*pixel-flip(.01/pixel))
  c=4*pixel^4-m-sin(pixel-flip(.01/pixel))
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2425"
  periodicity = 0
  maxiter = 500
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2426 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=pixel/cabs(.3/pixel), c=pixel*2
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
  k2 = conj(.12/pixel)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c - k2
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2426"
  periodicity = 0
  maxiter = 500
  magn = 3
  center = (-.07,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2427 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=pixel, c=sqr(cos(pixel))-cosh(pixel)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
  k2 = conj(.12/pixel)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c - k2
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2427"
  periodicity = 0
  maxiter = 500
  magn = 2.3
  center = (-.05,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2428 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=pixel-flip(.01/pixel)-conj(.1/pixel)+.285
  c=pixel/2-conj(.1/pixel)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2428"
  periodicity = 0
  maxiter = 500
  magn = 2
  center = (-.3,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2429 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian Jones frm. mans-galore-012
init:
  z=.55*(pixel-flip(.01/pixel)-conj(.1/pixel))+.285
  c=pixel/2-conj(.1/pixel)
  int iter=0, x=real(z), y=imag(z)
  int iterspace = round(real(p1)), int nextzoom = iterspace
  float magnification = imag(p1)  
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2429"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (-.6,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = tan()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2430 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=.55*(2*pixel2-flip(.01/pixel2)-conj(.1/pixel2))
  limit=p1, float b1=16, float b2=.0001, float iter=1
loop:
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1.099
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2430"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
}

Carr2431 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=pixel2/2-conj(.1/pixel2)
  limit=p1, float b1=16, float b2=.0001, float iter=1
loop:
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 2.099
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2431"
  periodicity = 0
  maxiter = 1000
  magn = .6
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
}

Carr2432 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2/2-conj(.1/pixel2), c=(-.7456,-.132)
  limit=p1, float b1=16, float b2=0.0001, float iter=1
loop:
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1.2
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2432"
  periodicity = 0
  maxiter = 1000
  magn = .6
  center = (0,0)
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
}

Carr2433 {; Updated for UF by Erik Reckase, March 2000
          ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  z=pixel/3-conj(.1/pixel), c=conj(pixel^3)-conj(.1/pixel)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), int iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel+(5.,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  int limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2433"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2434 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=pixel2-(tanh(.1/pixel2)-sqr(sinh(.025/pixel2)))^-6
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), int iter=1
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  int limit=round(p1), float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2434"
  periodicity = 0
  maxiter = 1000
  magn = 11
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2435 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  op = (tanh(.1/pixel2)-sqr(sinh(.025/pixel2)))^-6
  z=cabs(2*pixel2)-op, c=pixel2-op
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1.2
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2435"
  periodicity = 0
  maxiter = 1000
  magn = 12
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2436 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  op = 1/(tanh(.1/pixel2)-sqr(sinh(.025/pixel2)))
  z=cabs(2*pixel2)-op^2+.4
  c=(pixel-op)^2-.4
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), int iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  int limit=round(p1), float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2436"
  periodicity = 0
  maxiter = 1000
  magn = 10
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2437 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  op = 1/(tanh(.1/pixel2)-sqr(sinh(.025/pixel2)))
  z=cabs(2*pixel2)-op^2+.4, c=((pixel2-op)^2-.4)^4
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1.5
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2437"
  periodicity = 0
  maxiter = 1000
  magn = 12
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2438 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=(pixel2-1/(tanh(.1/pixel2)-sqr(sinh(.025/pixel2))))^8
  c=(-.7456,.2)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 2
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2438"
  periodicity = 0
  maxiter = 1000
  magn = 10
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2439 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=cabs(2*pixel2)-(tanh(.1/pixel2)-sqr(sinh(.025/pixel2)))^-2+.3
  c=(-.7456,.2)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 2
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2439"
  periodicity = 0
  maxiter = 1000
  magn = 10
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2440 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=(pixel2-1/(tanh(.1/pixel2)-sqr(sinh(.025/pixel2))))^8
  c=(-1.099,-.3249)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 3
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2440"
  periodicity = 0
  maxiter = 1000
  magn = 10
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2441 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=(cabs(3*pixel2)-1/(conj(.1/pixel2)-sqr(flip(.025/pixel2))))^8
  c=(-.5495,-.16245)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 4
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2441"
  periodicity = 0
  maxiter = 1000
  magn = 14
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2442 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=sinh(pixel2^2)-1/log(pixel2-(.1/pixel2)-flip(.001/pixel2))
  c=sin((-.7896,.1309)/3)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1.5
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2442"
  periodicity = 0
  maxiter = 1000
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2443 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2-(conj(.1/pixel2)+flip(conj(.01/pixel2)))^4
  c=(-.7456,-.3815)/1.7
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 2
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2443"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2444 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  m3=conj(.1/pixel2), cb = cabs(.5-pixel2)
  z=(cb*sqr(conj(pixel2))-m3-sqr(flip(.0051/pixel2)))-.3
  c=(-1.099,-.2249)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 1
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2444"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2445 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=conj(.5-pixel2)*sqr(cabs(pixel2))-conj(.1/pixel2) \
    -sqr(flip(.0051/pixel2))-.44
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2445"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2446 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Sylvie Gallet [101324,3444], Mod. BEJ
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=conj(.5-pixel2)*sqr(cabs(pixel2))-conj(.1/pixel2) \
    -sqr(flip(.0051/pixel2))-.44
  c=(-1.099,-.2249)
  x=real(z), y=imag(z)
  x1=x-p2*fn1(y+p3*fn2(y))
  y1=y-p2*fn1(x+p3*fn2(x)), float iter=1 
  rad=fn1(3.1*fn3(x1+flip(y1))), center=(1,.1) 
  pix=fn2(10*pixel2+(5,-3.4))*(-.1,-.95)
  zn=center+fn4(rad)/(pix-center)
  float limit=p1, float b1=16, float b2=.0001
loop:
  IF (iter==limit)
    z = zn
  ENDIF
  IF (iter<limit)
    z = z^2 + c
    float zfinal = |z|
    float bfinal = b1
  ELSE
    z1 = (z^5-1)/4/z^4
    z = z - z1
    float bfinal = |z1|
    float zfinal = b2
  ENDIF
  iter = iter + 2
bailout:
  zfinal <= bfinal
default:
  title = "Carr 2446"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter. Limit"
    default = 25
    hint = "Number of iterations before z iteration procedure \
            changes"
  endparam
  param p2
    caption = "Parameter 2"
    default = (.0005,.0005)
  endparam
  param p3
    caption = "Parameter 3"
    default = (-3,250)
  endparam
  func fn1
    caption = "Function 1"
    default = cos()
  endfunc
  func fn2
    caption = "Function 2"
    default = zero()
  endfunc
  func fn3
    caption = "Function 3"
    default = log()
  endfunc
  func fn4
    caption = "Function 4"
    default = log()
  endfunc
}

Carr2447 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel)) 
  pm1=p1-1, m3=conj(.1/pixel2), cb = cabs(.5-pixel2)
  z=cb*sqr(conj(pixel2))-m3-sqr(flip(.0051/pixel2))-.3
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2447"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2448 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=1/(pixel2-1/log(.001/pixel2)-cos(.01/pixel2+1.25) \
    -conj(.1/pixel2))
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2448"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2449 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=(pixel2-flip(.001/pixel2)-cabs(.01/pixel2)-conj(.1/pixel2))
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2449"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2450 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=flip(.33-sin(pixel2))*sqr(pixel2)-conj(.1/pixel2) \
    -flip(.01/pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=0.001
default:
  title = "Carr 2450"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2451 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=pixel2-conj(.09/pixel2-flip(.01/pixel2))
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2451"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2452 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=pixel2-tan(1/pixel2)-sin(1/pixel2)+flip(1/pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2452"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2453 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=cabs(pixel2)-((.3,.6)+pixel2)*pixel2/.2
loop:
  oldz = z
  z = (pm1*(z^p1)+1)/(p1*z^pm1)
bailout:
  |z-oldz|>=0.001
default:
  title = "Carr 2453"
  periodicity = 0
  maxiter = 500
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2454 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=pixel2^3-conj(.01/pixel2)-flip(.01/pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2454"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2455 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  m3=flip(cabs(1-pixel2))*sqr(conj(pixel2))
  z=m3-conj(.1/pixel2)-flip(.01/pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2455"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2456 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=sqr(pixel2)/conj(pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2456"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2457 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=flip(cabs(1+pixel2))-flip(.01/pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2457"
  periodicity = 0
  maxiter = 500
  magn = 40
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2458 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  m3=cabs(pixel2+.5)*pixel2^7
  z=m3-conj(.1/pixel2)-sqr(flip(.0051/pixel2))-.25
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2458"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2459 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=abs(pixel2)-.15
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2459"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2460 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=pixel2^2-flip(.01/pixel2)-conj(.1/pixel2)
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2460"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2461 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Jo Weber frm.
init:
  pixel2=abs(real(pixel))+flip(imag(pixel)), pm1=p1-1
  z=1.5*pixel2^9-cabs(.08*pixel2-flip(.01/pixel2)) \
    +conj(.0535/pixel2)+0.09
loop:
  oldz = z
  z = (pm1*z^p1+1)/p1/z^pm1
bailout:
  |z-oldz|>=.001
default:
  title = "Carr 2461"
  periodicity = 0
  maxiter = 500
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Scalar/Exponent"
    default = (5,-1)
  endparam
}

Carr2462 {; Updated for UF by Erik Reckase, March 2000
          ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
          ; Modified Brian E. Jones frm. mans-galore-012
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  r=cabs(pixel2/2)+sin(.08*pixel2-flip(.01/pixel2)) \
    -conj(.0535/pixel2)-.097
  z=3.5*pixel2^5-r, c=3.5*pixel2^8-r
  int iter=0, x=real(z), y=imag(z)
  int nextzoom=round(real(p1)), int iterspace=nextzoom
  float magnification=imag(p1)
  x1=x-p2*(fn1(y+p3*fn2(y)))
  y1=y-p2*(fn1(x+p3*fn2(x)))
  d1=flip(.0001/pixel2)-.0003299/pixel2
  k = x1 + flip(y1) + d1
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF 
  z = z + k
  c = c + d1
  z = z^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2462"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = cos()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2463 {; Updated for UF by Erik Reckase, March 2000
          ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
          ; Modified Brian E. Jones frm. mans-galore-012
init:
  r=cabs(pixel/2), z=pixel
  c=3.5*pixel^8-r-sin(.08*pixel-flip(.01/pixel)) \
    +conj(.0535/pixel)+.097
  int iter=0, x=real(z), y=imag(z)
  int nextzoom=round(real(p1)), int iterspace=nextzoom
  float magnification=imag(p1)
  x1=x-p2*(fn1(y+p3*fn2(y)))
  y1=y-p2*(fn1(x+p3*fn2(x)))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2463"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = cos()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2464 {; Updated for UF by Erik Reckase, March 2000
          ; Corrected typo (0.08pixel to 0.08*pixel) G. Martin 10/98
          ; Modified Brian E. Jones frm. mans-galore-012
init:
  r=cabs(pixel/2), z=.75*pixel
  c=3.5*pixel^8-r-sin(.08*pixel-flip(.01/pixel)) \
    +conj(.0535/pixel)+.097
  int iter=0, x=real(z), y=imag(z)
  int nextzoom=round(real(p1)), int iterspace=nextzoom
  float magnification=imag(p1)
  x1=x-p2*(fn1(y+p3*fn2(y)))
  y1=y-p2*(fn1(x+p3*fn2(x)))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2464"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = cos()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2465 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian E. Jones frm. mans-galore-012
init:
  c=pixel, z=sqr(cos(pixel))-cosh(pixel)
  int iter=0, x=real(z), y=imag(z)
  int nextzoom=round(real(p1)), int iterspace=nextzoom
  float magnification=imag(p1)
  x1=x-p2*(fn1(y+p3*fn2(y)))
  y1=y-p2*(fn1(x+p3*fn2(x)))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2465"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = cos()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2466 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian E. Jones frm. mans-galore-012
init:
  c=pixel, z=cos(pixel)-cosh(pixel)^4
  int iter=0, x=real(z), y=imag(z)
  int nextzoom=round(real(p1)), int iterspace=nextzoom
  float magnification=imag(p1)
  x1=x-p2*(fn1(y+p3*fn2(y)))
  y1=y-p2*(fn1(x+p3*fn2(x)))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2466"
  periodicity = 0
  maxiter = 1000
  magn = 3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = cos()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2467 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Brian E. Jones frm. mans-galore-012
init:
  c=pixel
  z=cos(pixel-conj(.01/pixel))-cosh(pixel-conj(.1/pixel))
  int iter=0, x=real(z), y=imag(z)
  int nextzoom=round(real(p1)), int iterspace=nextzoom
  float magnification=imag(p1)
  x1=x-p2*(fn1(y+p3*fn2(y)))
  y1=y-p2*(fn1(x+p3*fn2(x)))
  k = x1 + flip(y1)
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = magnification*c
  ENDIF
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2467"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom/Mag"
    default = (25,1.33)
    hint = "The real part of this parameter is the number of \
            iteration steps between value resets.  The imag \
            part is the magnification factor."
  endparam
  param p2
    caption = "Outer Fn Mult"
    default = (.05,0)
    hint = "This value scales the result of the coordinate \
            transform's Outer Function."
  endparam
  param p3
    caption = "Inner Fn Mult"
    default = (50,0)
    hint = "This value scales the result of the coordinate \
            transform's Inner Function."
  endparam
  func fn1
    caption = "Outer Function"
    default = cos()
    hint = "Operates on the sum of the z-coordinates and the \
            scaled result of the Inner Function"
  endfunc
  func fn2
    caption = "Inner Function"
    default = asin()
    hint = "Operates on raw z-coordinates"
  endfunc
}

Carr2468 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Sylvie Gallet frm.
init:
  z=pixel, c=(-.63,-.4), d1=-.00099475/pixel
  int iter=0, k = flip(imag(.0375/pixel))
  int nextzoom=round(real(p1)), int iterspace=nextzoom
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = p2*c+p3
  ENDIF
  c = c + d1
  z = (z+k)^4 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2468"
  periodicity = 0
  maxiter = 1000
  magn = 1.2
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom"
    default = 128
    hint = "The number of iteration steps between value resets."
  endparam
  param p2
    caption = "C-Mult"
    default = (1.2,.1)
    hint = "C is mutliplied by this value when the number of \
            iterations equals nextzoom (p1)"
  endparam
  param p3
    caption = "C-Add"
    default = (-.05,-.06)
    hint = "This value is added to C when the number of \
            iterations equals nextzoom (p1)"
  endparam
}

Carr2469 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Sylvie Gallet frm.
init:
  z=pixel, c=(-.315,-.2)
  d1=-.00129475/pixel+flip(.0001/pixel)
  int iter=0, k = flip(imag(.0375/pixel))
  int nextzoom=round(real(p1)), int iterspace=nextzoom
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = p2*c+p3
  ENDIF
  c = c + d1
  z = (z+k)^5 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2469"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom"
    default = 128
    hint = "The number of iteration steps between value resets."
  endparam
  param p2
    caption = "C-Mult"
    default = (1.2,.1)
    hint = "C is mutliplied by this value when the number of \
            iterations equals nextzoom (p1)"
  endparam
  param p3
    caption = "C-Add"
    default = (-.05,-.06)
    hint = "This value is added to C when the number of \
            iterations equals nextzoom (p1)"
  endparam
}

Carr2470 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Sylvie Gallet frm.
init:
  z=pixel, c=(-.315,-.2)
  d1=-.00099475/pixel+flip(.0001/pixel)
  int iter=0, k = flip(imag(.0375/pixel))
  int nextzoom=round(real(p1)), int iterspace=nextzoom
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = p2*c+p3
  ENDIF
  c = c + d1
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2470"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom"
    default = 128
    hint = "The number of iteration steps between value resets."
  endparam
  param p2
    caption = "C-Mult"
    default = (1.2,.1)
    hint = "C is mutliplied by this value when the number of \
            iterations equals nextzoom (p1)"
  endparam
  param p3
    caption = "C-Add"
    default = (-.05,-.06)
    hint = "This value is added to C when the number of \
            iterations equals nextzoom (p1)"
  endparam
}

Carr2471 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Sylvie Gallet frm.
init:
  z=pixel, c=(-.7456,.132)
  d1=-.00099475/pixel+flip(.0001/pixel)
  int iter=0, k = flip(imag(.0375/pixel))
  int nextzoom=round(real(p1)), int iterspace=nextzoom
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = p2*c+p3
  ENDIF
  c = c + d1
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2471"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Nextzoom"
    default = 128
    hint = "The number of iteration steps between value resets."
  endparam
  param p2
    caption = "C-Mult"
    default = (1.2,.1)
    hint = "C is mutliplied by this value when the number of \
            iterations equals nextzoom (p1)"
  endparam
  param p3
    caption = "C-Add"
    default = (-.05,-.06)
    hint = "This value is added to C when the number of \
            iterations equals nextzoom (p1)"
  endparam
}

Carr2472 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm.
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2-.3, c=(-.7456,.132)
  d1=-.00099475/pixel2+flip(.0001/pixel2)
  int iter=0, k = flip(imag(.0375/pixel))
  int nextzoom=round(real(p1)), int iterspace=nextzoom
loop:
  IF (iter==nextzoom)
    nextzoom = nextzoom + iterspace
    z = 0, c = p2*c+p3
  ENDIF
  c = c + d1
  z = (z+k)^2 + c
  iter = iter + 1
bailout:
  |z| <= 16
default:
  title = "Carr 2472"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,.1)
  method = multipass
  param p1
    caption = "Nextzoom"
    default = 128
    hint = "The number of iteration steps between value resets."
  endparam
  param p2
    caption = "C-Mult"
    default = (1.2,.1)
    hint = "C is mutliplied by this value when the number of \
            iterations equals nextzoom (p1)"
  endparam
  param p3
    caption = "C-Add"
    default = (-.05,-.06)
    hint = "This value is added to C when the number of \
            iterations equals nextzoom (p1)"
  endparam
}

Carr2473 (XAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  z=pixel-conj(.1/pixel)-.4, c=2*pixel-1/log(cos(1/pixel))
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel/imag(p2)
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2473"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (-.3,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2474 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  z=2*pixel-conj(.1/pixel), c=2*pixel-1/log(cos(1/pixel))+.2
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel/imag(p2)-.004
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2474"
  periodicity = 0
  maxiter = 1000
  magn = 2.5
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2475 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  z=2*conj(pixel)-conj(.3/pixel)+.2
  c=2*pixel-1/log(cos(1/pixel))+.2
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel/imag(p2)-.004
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2475"
  periodicity = 0
  maxiter = 1000
  magn = 2
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2476 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=2*tanh(pixel2)-conj(.1/pixel2)+.2
  c=(-.7456,-.132)/1.25
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.004
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2476"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2477 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2^2-log(cos(1.5/pixel2))/pixel2+.2
  c=(-.7456,-.132)/1.25
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0045
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2477"
  periodicity = 0
  maxiter = 1000
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2478 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2+1/log(pixel2), c=(-.7456,-.132)/1.25
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0045
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2478"
  periodicity = 0
  maxiter = 1000
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2479 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2-1/log(-.7456,.2), c=(-.7456,-.132)/1.25
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.003
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2479"
  periodicity = 0
  maxiter = 1000
  magn = 1
  center = (0,-.3)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2480 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  c=pixel2/2+1/log(pixel2)
  z=pixel2-1/log(pixel2-1/log(tan(1/pixel2))-1/log(2/pixel2))
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0055
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2480"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2481 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=cabs(pixel2*2)-1/log(conj(.5/pixel2))
  c=pixel2-1/log(conj(.5/pixel2-1))
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.006
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2481"
  periodicity = 0
  maxiter = 1000
  magn = 4.5
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2482 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2-.5/pixel2, c=(-.7456,-.132)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0033
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2482"
  periodicity = 0
  maxiter = 1000
  magn = 1
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2483 {; Updated for UF by Erik Reckase, March 2000
          ; Modified Sylvie Gallet frm. 
init:
  z=pixel^3-(.5/pixel)^8, c=(-.7456,-.132)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0075
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2483"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2484 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2^1.75-(.5/pixel2)^4, c=(-.3728,-.066)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0065
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2484"
  periodicity = 0
  maxiter = 1000
  magn = 1.2
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2485 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2^1.75-(.1/pixel2)^4, c=(-0.3728,-0.066)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0064
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2485"
  periodicity = 0
  maxiter = 1000
  magn = 1.2
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2486 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=pixel2+tan(.1/pixel2-.025)/log(cos(.1/pixel2-.025))
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0155
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2486"
  periodicity = 0
  maxiter = 1000
  magn = 20
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2487 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2+tan(.1/pixel2-.025)/log(cos(.1/pixel2-.025))
  c=pixel2+tan(.1/pixel2-.025)/log(conj(cos(.1/pixel2-.025)))
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0105
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2487"
  periodicity = 0
  maxiter = 1000
  magn = 20
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2488 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2^2+tan(.1/pixel2-.025)/log(cos(.1/pixel2-.025))
  c=cabs(pixel2)+tan(.1/pixel2-.025) \
    /log(conj(cos(.1/pixel2-.025)))
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0105
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2488"
  periodicity = 0
  maxiter = 1000
  magn = 20
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2489 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2+tan(.1/pixel2-.025)/log(cos(.1/pixel2-.025))
  c=(-.7456,-.122)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0065
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2489"
  periodicity = 0
  maxiter = 1000
  magn = 24
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2490 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=tanh(pixel2)+((.3,.6)+pixel2)*pixel2/.2
  c=(-.7586,-.132)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.00375
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2490"
  periodicity = 0
  maxiter = 1000
  magn = 5
  center = (0,.02)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2491 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=tanh(2*pixel2)-(.3,-.6)-pixel2^4+conj(.2/pixel2)
  c=(-0.7456,-0.132)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.00475
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2491"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2492 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=conj(pixel2)^4-conj(.1/pixel2)-flip(.02/pixel2)
  c=(-.7456,.13)+.009/pixel2
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.00575
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2492"
  periodicity = 0
  maxiter = 1000
  magn = 1.3
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2493 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  c=pixel2
  z=|pixel2|*pixel2-(.1/pixel2)^(-3*pixel2)-.01/pixel2
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.00575
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2493"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2494 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=pixel2
  c=|pixel2|*pixel2-(.1/pixel2)^(-3*pixel2)-.01/pixel2
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.00675
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2494"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2495 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=|pixel2|*pixel2-sinh(.1/pixel2)^(-3*pixel2)-flip(.001/pixel2)
  c=(-.7556,-.122)
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0044
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2495"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2496 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=|pixel2|*pixel2-sinh(.1/pixel2)^(-3*pixel2)-flip(.001/pixel2)
  c=(-.7556,-.122)/1.33
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0035
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2496"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2497 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=flip(abs(1-pixel2))*sqr(pixel2)-conj(.1/pixel2) \
    -flip(.01/pixel2)-.3
  c=(-.7456,-.11)/1.15
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0024
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2497"
  periodicity = 0
  maxiter = 1000
  magn = 1.8
  center = (0,-.07)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2498 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=(1-pixel2)*conj(pixel2^2)-conj(.1/pixel2)-flip(.01/pixel2)-.3
  c=(-.7456,-.11)/1.35
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0032
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2498"
  periodicity = 0
  maxiter = 1000
  magn = 1.6
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}

Carr2499 (YAXIS) {; Updated for UF by Erik Reckase, March 2000
                  ; Modified Sylvie Gallet frm. 
init:
  pixel2=-abs(real(pixel))+flip(imag(pixel))
  z=c=conj(pixel2)*cabs(pixel2^4+.25)-conj(.1/pixel2)\
      -flip(.01/pixel2)^2
  c1=1.5*z, c2=2.25*z, c3=3.375*z, c4=5.0625*z
  l1=round(real(p1)), l2=round(imag(p1))
  l3=round(real(p2)), l4=round(imag(p2))
  k = pixel2/imag(p2)-.0032
  float bailout=16, int iter=0
loop:
  IF (iter==l1)
    c = c1, z=0
  ELSEIF (iter==l2)
    c = c2, z=0
  ELSEIF (iter==l3)
    c = c3, z=0
  ELSEIF (iter==l4)
    c = c4, z=0
  ENDIF
  c = c + k
  z = z*z + c
  iter=iter+1
bailout:
  |real(z)| <= bailout
default:
  title = "Carr 2499"
  periodicity = 0
  maxiter = 1000
  magn = 1.4
  center = (0,0)
  method = multipass
  param p1
    caption = "Iter Limits 1,2"
    default = (100,150) 
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
  param p2
    caption = "Iter Limits 3,4"
    default = (200,250)
    hint = "0< Re(P1) < Im(P1) < Re(P2) < Im(P2) <maxiter \
            for best results"
  endparam
}