import sys

from math import pi, sin, cos


class Point:
  def __init__(self, initx=0, inity=0):
    self.x = initx
    self.y = inity

  def __mul__(self, scalar):
    return Point (self.x * scalar, self.y * scalar)

  def __div__(self, scalar):
    return Point (self.x / scalar, self.y / scalar)

  def __add__(self, other):
    return Point (self.x + other.x, self.y + other.y)

  def __sub__(self, other):
    return Point (self.x - other.x, self.y - other.y)

  def __repr__(self):
    return "Point (%d, %d)" % (self.x, self.y)

  def dist(self, other):
    return (self.x-other.x)**2 + (self.y-other.y)**2
    
    


###################################################################
# This subdivides a bezier segment at the (optional) Parameter t

def subdivide (p, t=0.5):
   assert len (p) == 4
   p01   = p[0] * (1-t) + p[1] * t
   p12   = p[1] * (1-t) + p[2] * t
   p23   = p[2] * (1-t) + p[3] * t
   p012  = p01  * (1-t) + p12  * t
   p123  = p12  * (1-t) + p23  * t
   p0123 = p012 * (1-t) + p123 * t

   return (p[0], p01, p012, p0123, p123, p23, p[3])



def multisubdiv (p, params=[]):
   assert len (p) == 4
   
   r = p[:1]
   while params:
      t0 = params[0]
      sd = subdivide (p, t0)
      r += sd [1:4]
      p = sd[3:]
      params = [(t - t0) / (1 - t0) for t in params[1:]]
   
   r += p[1:]

   return r


   
def plot_ps (p, dashed = False):
   assert len (p) > 0
   assert (len (p) -1) % 3 == 0

   i = 0

   print "newpath"

   print p[0].x, p[0].y, "moveto"
   p = p[1:]

   while p:
      if not dashed or i % 2 == 0:
         print "%.4f %.4f %.4f %.4f %.4f %.4f %s" % (p[0].x, p[0].y,
                                                     p[1].x, p[1].y,
                                                     p[2].x, p[2].y, "curveto")
      else:
         print p[2].x, p[2].y, "moveto"
      
      p = p[3:]
      i += 1

   print "stroke"

   
def plot_polyline (p):
   assert len (p) >= 2

   print "newpath"
   print "%.4f %.4f %s" % (p[0].x, p[0].y, "moveto")
   
   for pt in p[1:]:
      print "%.4f %.4f %s" % (pt.x, pt.y, "lineto")
   print "stroke"

   

def ggt (a, b):
   if a % b == 0:
      return b
   else:
      return ggt (b, a % b)

def sinlist (n=1):
   s = 0.544485543966
   return [0.0] + [s, 1.0, 1.0, 1.0, s, 0, -s, -1.0, -1.0, -1.0, -s, 0.0] * n

def coslist (n=1):
   s = 0.544485543966
   return [1.0] + [1.0, s, 0, -s, -1.0, -1.0, -1.0, -s, 0.0, s, 1.0, 1.0] * n


def plotschwing (rx, ry, X, Y, dx, dy):
   sl = sinlist (X)
   cl = coslist (Y)

   dx = dx ** 0.25
   dy = dy ** 0.25

   for i in range (len (sl)):
      sl[i] *= rx * dx**i

   for i in range (len (cl)):
      cl[i] *= ry * dy**i

   r1 = sl[:1]
   r2 = cl[:1]

   i = 0
   while len (sl) > 1:
      tl = [float (j%Y)/Y for j in range (i*Y + 1, (i+1)*Y) if (j % X) == 0]
      r1 += multisubdiv (sl[:4], tl)[1:]
      sl = sl[3:]
      i += 1
      
   i = 0
   while len (cl) > 1:
      tl = [float (j%X)/X for j in range (i*X + 1, (i+1)*X) if (j % Y) == 0]
      r2 += multisubdiv (cl[:4], tl)[1:]
      cl = cl[3:]
      i += 1
      
   plot_ps (map (Point, r1, r2))



if __name__=='__main__':
   print "298 421 translate"
   print "30 30 scale"
   print "0.01 setlinewidth"

   plotschwing (6.2, 6.0, 100, 97, 0.99, 0.98)

   print "1 0 0 setrgbcolor"