Code Sketch


Village Scene
By: Sonaly R Pawar
Category: Art
cleari
  
setBackground(gradient3)
  
lady1
  .thatsTranslated(200,-40)
  .draw

house
  .thatsScaled(2,2)
  .withFlippedX
  .thatsTranslated(-160,-30)
  .draw

basket
  .thatsFilledWith(gradient6)
  .thatsStrokeColored(Color(204, 31, 16))
  .draw
  
tree
  .thatsScaled(0.8,0.8)
  .withFlippedX
  .thatsTranslated(180, 60)
  .draw 

ladyGrinding
  .thatsScaled(0.6,0.6)
  .thatsTranslated(-350,-130)
  .draw 

tulsi
  .thatsScaled(1.5,1.3)
  .thatsTranslated(-39,110)
  .draw

hen
  .thatsScaled(0.3,0.3)
  .thatsTranslated(0,-150)
  .draw

chick
  .thatsScaled(0.09,0.09)
  .thatsTranslated(20,-190)
  .draw
  
chick
  .thatsScaled(0.09,0.09)
  .thatsTranslated(0,-200)
  .draw

chick
  .thatsScaled(0.09,0.09)
  .withFlippedX
  .thatsTranslated(-20,-190)
  .draw

def eyebr = Picture.arc(30, 40)
def eye = Picture.arc(20,-40)
def recOne = Picture.rect(38, 60)
def round = Picture.ellipse(3, 1)
def round1 = Picture.ellipse(90, 30)
def round2 = Picture.circle(2)
def round3 = Picture.circle(50)
def round4 = Picture.circle(100)
def arc2 = Picture.arc(40,70)
def line1 = Picture.line(0, 45)
def line2 = Picture.line(45, 0)
def rect1 = Picture.rect(80, 150)
def hay = Picture.ellipse(5, 20)

def peach = Color(255, 241, 211)
def darkGreen = Color(0,155,82)  

def colorOne = 
  cm.linearGradient(
    -50, 0, 
    Color(204, 204, 204), 
    185, 0, 
    Color(46, 46, 46), 
    true
    )
def colors2 = 
  cm.linearGradient(
    -010, 0, 
    darkGreen, 
    100, 0, 
    yellow, 
    false
    )
def gradient1 = 
  cm.linearGradient(
    90, 140, 
    Color(153, 51, 0), 
    90, 210, 
    Color(211, 46, 46), 
    true
    )
def gradient2 = 
  cm.linearGradient(
    90, 140, 
    Color(255, 255, 255), 
    90, 210, 
    Color(111, 2, 2), 
    true
    )
def gradient3 = cm.linearMultipleGradient(
  0, 200, 
  0, -200, 
  Seq(0,0.3999,0.9),
  Seq(Color(0, 183, 241),
  Color(255, 255, 51),
  Color(218, 155, 36)), 
  false
  )
def gradient4 = 
  cm.linearGradient(
    0, 50, 
    green, 
    0, -100, 
    yellow, 
    true
    )
def gradient5 = 
  cm.linearGradient(
    0, -80, 
    Color(95, 69, 14), 
    0, -300, 
    Color(210, 128, 46),
    false
    )
def gradient6 = 
  cm.linearGradient(
    0, -190, 
    Color(133, 29, 42), 
    0, -200, 
    Color(204, 31, 16), 
    false
    )
def trunk = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-450, -320)
  x.bezierVertex(
    -450, -100, 
    -400, -80, 
    -450, 150
    )    
  x.vertex(-450, 150)
  x.bezierVertex(
    -420, 100, 
    -420, 55, 
    -410, 40
    )  
  x.vertex(-410, 40)
  x.bezierVertex(
    -390, 40, 
    -410, 40, 
    -380, 200
    )
  x.bezierVertex(
    -380, 200, 
    -385, 200, 
    -380, -80
    )
  x.vertex(-380, -80)
  x.bezierVertex(
    -380, -50, 
    -370, -50, 
    -350, 200
    )
  x.vertex(-350, 200)
  x.bezierVertex(
    -350, 200, 
    -340, 200, 
    -340, 60
    )
  x.vertex(-340, 60)
  x.bezierVertex(
    -330, 60, 
    -330, 60, 
    -280, 200
     )
  x.vertex(-280, 200)
  x.bezierVertex(
    -280, 0, 
    -380, 0, 
    -290, -320
    )
  x.vertex(-290, -320)
  x.bezierVertex(
    -290, -320, 
    -290, -320, 
    -450, -320
    )
  x.endShape()      
  }
def tri = Picture{
  right()
  forward(104)
  left(120)
  forward(104)
  left(120)
  forward(104)
  }

def collection(count:Long):Picture = 
  if (count==1) {
    hay
      .thatsFilledWith(noColor)
      .thatsStrokeColored(noColor)
        } else {
    
def iHave = hay
  .thatsScaled(0.6,1.2)
  .thatsRotated(28)
  .thatsFilledWith(gradient1)
  .thatsStrokeColored(Color(55, 44, 27))

def iGot = collection(count - 1)
  picStack(
    iHave,
    iGot
      .thatsTranslated(5, 0)
    )
    }

def hair = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(0, 0)
  x.bezierVertex(
    -20, 20, 
    -40, 20, 
    -52, -10
    )
  x.bezierVertex(
    -70, -10, 
    -70, -30, 
    -48, -30
    ) 
  x.bezierVertex(
    -30, -10, 
    -18, -1, 
    0, 0
    )
  x.endShape()
  }
def face = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(0, 0)
  x.bezierVertex(
    -2, -9, 
    -9, -10, 
    -7, -25
  )   
  x.bezierVertex(
    -7, -25, 
    -9, -25, 
    -9, -25
  )   
  x.bezierVertex(
    -35, -45, 
    -45, -30, 
    -40, -22
  )  
  x.bezierVertex(
    -40, -22, 
    -25, 0, 
    0, 0
  )  
  x.endShape() 
  }
def fig1 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-41, -26)
  x.bezierVertex(
    -41, -26, 
    -41, -26, 
    -50, -34
  )
  x.bezierVertex(
    -45, -36, 
    -45, -36, 
    -40, -38
  )
  x.bezierVertex(
    -40, -36, 
    -40, -36, 
    -35, -35
  )
  x.endShape()
  }    
def fig2 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-30, -58)
  x.bezierVertex(
    -30, -50, 
    -70, -28, 
    -90, -78
  )
  x.bezierVertex(
    -80, -70, 
    -35, -50, 
    -30, -60
  )
  x.endShape()   
  }      
def fig3 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-87, -70)
  x.bezierVertex(
    -50, -80, 
    -55, -70, 
    -38, -65
  ) 
  x.bezierVertex(
    -30, -79, 
    -30, -79, 
    -20, -70
  ) 
  x.bezierVertex(
    -15, -30, 
    -50, -50, 
    -87, -70
  )
  x.endShape()  
  }
def fig4 = Picture.fromVertexShape {
  x=>
  x.beginShape()
  x.vertex(-87,-70)
  x.bezierVertex(
    -92,-84,
    -92,-84,
    -75,-90
  ) 
  x.bezierVertex(
    -50, -74, 
    -50, -74, 
    -87, -70
  )  
  x.endShape()
  }
def fig5 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-75, -90)
  x.bezierVertex(
    0, -40, 
    0, -40, 
    -20, -120
  )
  x.bezierVertex(
    -39, -120, 
    -39, -120, 
    -20, -70
  )
  x.bezierVertex(
    -28, -120, 
    -90, -160, 
    -90, -84
  )
  x.bezierVertex(
    -90, -84, 
    -90, -84, 
    -70, -86
  )    
  x.endShape()
  }
def fig6 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-20, -70)
  x.bezierVertex(
    -20, -85, 
    -20, -85, 
    5, -88
  )
  x.bezierVertex(
    13, -80, 
    16, -80, 
    17, -92
  )
  x.bezierVertex(
    12, -89, 
    12, -89, 
    5, -92
  )
  x.bezierVertex(
    -28, -90, 
    -28, -90, 
    -30, -75
  )
  x.bezierVertex(
    -30, -75, 
    -30, -75, 
    -20, -70
  )
  x.endShape()
  }
def fig7 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-32, -120)
  x.bezierVertex(
    -32, -125, 
    -32, -125, 
    -10, -125
  )
  x.bezierVertex(
    -4, -122, 
    -10, -120, 
    -32, -120
  )    
  x.endShape()  
  }
def arcOne = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-36, 0)
  x.bezierVertex(
    -50, -28, 
    50, -28, 
    36, 0
  )  
  x.endShape()    
  }
def arcTwo = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(0, 0)
  x.bezierVertex(
    -7, 10, 
    -7, 90, 
    10, 100
  )
  x.bezierVertex(
    24, 100, 
    19, 10, 
    10, 0
  )
  x.bezierVertex(
    0, 0, 
    0, 0, 
    0, 0
  )
  x.endShape()  
  }
def arcThree = Picture.fromPath { 
  x =>
  x.moveTo(-75, -114)
  x.lineTo(-75, -108)
  x.arc(-62, -114, -80)
  x.arc(-54, -108, -80)
  x.arc(-47, -114, -80)
  x.arc(-34, -108, -80)
  x.lineTo(-34, -114)
  x.lineTo(-75, -114)
  }
def arcFour = Picture{
  left()
  hop(54)
  left()
  hop(122)
  turn(45)
  forward(17) 
  turn(-45)
  forward(19) 
  right()
  forward(23)
  right()
  forward(19)
  turn(-43)
  forward(16)
  }
def sa1 = Picture.fromPath { 
  x =>
  x.moveTo(70,48)
  x.arc(105, 45, -40)
  x.arc(50, -100, -50)
  x.lineTo(0, -50)
  x.arc(70, 48, 60)
  x.closePath()    
  }
def sa2 = Picture.fromPath { 
  x =>
  x.moveTo(0, -50)
  x.arc(70, 48, 60)
  x.arc(80, 49, -40)
  x.arc(10, -54, -60)
  x.closePath()
  }
def sa3 = Picture.fromPath { 
  x =>
  x.moveTo(80, -200)
  x.arc(125, -190, -60)    
  x.arc(41, -40, 30)
  x.arc(1, -53, 90)
  x.arc(-5, -210, 20)
  x.arc(80, -200, 40)
  x.arc(25, -98, -60)
  x.arc(80, -200, 60)
  x.closePath()
  }
def sa4 = Picture.fromPath { 
  x =>
  x.moveTo(80, -200)
  x.arc(125, -190, -60)    
  x.arc(125, -198, -50)
  x.arc(91, -206, 60)
  x.arc(80, -200, -50)
  }  
def face1 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(32, 100)
  x.bezierVertex(
    39, 150, 
    39, 150, 
    75, 185
  )
  x.bezierVertex(
    100, 165, 
    110, 140, 
    110, 140
  )
  x.bezierVertex(
    95, 120, 
    118, 105, 
    85, 70
  )
  x.bezierVertex(
    84, 70, 
    45, 65, 
    38, 125
  )
  x.bezierVertex(
    27, 50, 
    27, 50, 
    68, 30
  )
  x.bezierVertex(
    72, 50, 
    72, 50, 
    75, 69
  )
  x.bezierVertex(
    75, 75, 
    45, 70, 
    36, 125
  )
  x.endShape()
  }
def pallu = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-10, -200)
  x.bezierVertex(
    -75, -215, 
    -75, -215, 
    -120,-200
  )
  x.bezierVertex(
    -130, -200, 
    -120, -187, 
    -100,-175
  )
  x.bezierVertex(
    -85, -175, 
    -65, 0, 
     6, 145
  )
  x.bezierVertex(
    50, 220, 
    130, 250, 
    120, 20
  )
  x.bezierVertex(
    115, 12, 
    115, 12, 
    -10, -200
  ) 
  x.endShape()
  }
def hair1 = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(46, 150)
  x.bezierVertex(
    49, 182, 
    75, 220, 
    112, 140
  ) 
  x.bezierVertex(
    77, 180, 
    77, 180, 
    46, 135
  )
  x.endShape()
  }
def border = Picture.fromVertexShape { 
  x =>
  x.beginShape()
  x.vertex(-7, -200)
  x.bezierVertex(
    -10, -150, 
    10, -50, 
    18, 0
  )
  x.bezierVertex(
    22, 20, 
    35, 100, 
    55, 167
  )
  x.bezierVertex(
    60, 185, 
    90, 194, 
    114, 141
  )
  x.bezierVertex(
    85, 202, 
    60, 205, 
    43, 157
  )
  x.bezierVertex(
    0, -20, 
    -24, -150, 
    -15, -201
  )
  x.bezierVertex(
    -7, -200, 
    -7, -200, 
    -7, -200
  )
  x.endShape()
  }
def arm = Picture.fromPath { 
  x =>
  x.moveTo(55, 55)    
  x.lineTo(140, -17)
  x.lineTo(200, -19)
  x.lineTo(200, -41)
  x.lineTo(130, -45)
  x.lineTo(50, 10)
  x.closePath()
  }
def ha1 = Picture.fromPath { 
  x =>
  x.moveTo(215, -15)
  x.arc(215, -55, 165)
  x.arc(215, -25, 20)
  x.arc(235, -20, 30)
  x.closePath()    
  }
def ha2 = Picture.fromPath { 
  x =>
  x.moveTo(240, -24)    
  x.arc(230, -55, -175)
  x.arc(242, -45, -80)
  x.arc(230, -45, -80)
  x.arc(242, -38, -80)
  x.arc(230, -38, -80)
  x.arc(242, -32, -80)
  x.arc(230, -32, -80)
  x.arc(240, -24, -80)
  }
def ha3 = Picture.fromPath { 
  x =>
  x.moveTo(175,-100)
  x.lineTo(175, -123)
  x.arc(220, -130, 40)
  x.arc(220, -124, 80)
  x.lineTo(200, -124)
  x.lineTo(220, -124)
  x.arc(220, -117, 80)
  x.lineTo(200, -117)
  x.lineTo(220, -117)
  x.arc(220, -110, 80)
  x.lineTo(200, -110)
  x.lineTo(220, -110)
  x.arc(220, -104, 80)
  x.arc(190, -100, 15)
  x.arc(212, -100, -40)
  x.arc(212, -96, 80)
  x.arc(175, -100, 20)
  }
def nose = Picture.fromPath { 
  x =>
  x.moveTo(87, 120)
  x.arc(90, 107, 40)
  x.arc(85, 102,-80)
  x.arc(76, 105,-30)
  x.arc(78, 111, -90)
  }
def lips = Picture.fromPath { 
  x =>
  x.moveTo(72, 92)
  x.arc(81, 92, -50)
  x.arc(90, 92, -50)
  x.arc(72, 92, -70)
  }
def sup = Picture.fromPath { 
  x =>
  x.moveTo(50, -200)    
  x.arc(-65, -167, -07)
  x.arc(-100, -260, 140)
  x.lineTo(0, -300)
  x.arc(50, -200, -30)
  x.arc(0, -300, 30)
  x.lineTo(-100, -275)
  x.arc(-118, -225, -30)
  x.arc(-100, -260, 40)
  x.lineTo(0, -300)
  x.arc(50, -200, -30)
  }
def sup2 = Picture.fromPath { 
  x =>
  x.moveTo(140, -245)    
  x.arc(50, -219, -4)
  x.arc(27, -278, 160)
  x.arc(108, -309, -5)
  } 
def leg = Picture.fromPath { 
  x =>
  x.moveTo(125, -200)
  x.arc(145, -240, -30)      
  x.arc(110, -250, -50)
  x.arc(94, -205, -30)
  x.arc(125, -200, -80)
  }
def flame = Picture.fromPath { x =>
  x.moveTo(0,0)
  x.arc(0, 150, 80)
  x.arc(0, 0, 80)
  }
def lamp = Picture.fromPath { x =>
  x.moveTo(0,0)
  x.arc(-150, 0, -50)
  x.arc(150,0,180)
  x.arc(0, 0, -50)
  }
def sh1 = Picture.fromPath { 
  x =>
  x.moveTo(-100, 0)
  x.arc(-65, -50, 200)
  x.arc(30, -50, -50)
  x.arc(200, 40, 120)
  x.arc(186, 20, 60)
  x.arc(188, 60, 30)
  x.arc(178, 32, 20)
  x.arc(178, 75, 20)
  x.arc(170, 45, 30)
  x.arc(165, 70, 20)
  x.arc(160, 45, 20)
  x.arc(155, 60, 20)
  x.arc(153, 45, 20)
  x.arc(0, 20, 20)
  x.arc(-100, 0, -10)
  }
def sh2 = Picture.fromPath { 
  x =>
  x.moveTo(25,-35)    
  x.arc(135, 10, 90)
  x.arc(115, -2, 50)
  x.arc(135, 30, 10)
  x.arc(112, 10, 50)
  x.arc(135, 50, 10)
  x.arc(110, 25, 50)
  x.arc(130, 70, 10)
  x.arc(100, 40, 40)
  x.arc(107, 85, 60)
  x.arc(80, 41,1)
  x.arc(25, -35, 110)
  }
def sh3 = Picture.fromPath { 
  x =>
  x.moveTo(-110, -35)
  x.arc(-143, -40, -50)
  x.arc(-129, -30, -80)    
  x.arc(-150, -20, -50)
  x.arc(-124, -18, -50)
  x.arc(-145, -2, -50)
  x.arc(-120, -3, -50)
  x.arc(-125, 20, -50)
  x.arc(-100, -10, -50)
  x.lineTo(-110, -35)
  }
def sh4 = Picture.fromPath { 
  x =>
  x.moveTo(50, -65)
  x.lineTo(36, -99)    
  x.lineTo(20, -97)
  x.lineTo(35, -103)
  x.lineTo(20, -106)
  x.lineTo(35, -107)
  x.lineTo(30, -115)
  x.lineTo(38, -107)
  x.lineTo(46, -110)
  x.lineTo(37, -100)
  x.lineTo(50, -65)
  }
def sh5 = Picture.fromPath { 
  x =>
  x.moveTo(0, -20)    
  x.arc(-70, -70, 250)
  x.lineTo(-78, -67)
  x.arc(40, -150, 90)
  x.lineTo(38, -144)
  x.lineTo(40, -150)
  x.arc(70, -139, 150)
  x.arc(150, -50, 50)
  x.arc(140, -60, 20)
  x.arc(145, -37, 40)
  x.arc(135, -50, 40)
  x.arc(140, -15, 40)
  x.arc(130, -35, 10)
  x.arc(135, 0, 30)
  x.arc(100, -30, -40)
  x.arc(0, -20, 50)
  x.closePath()
  } 
def sh6 = Picture.fromPath { 
  x =>
  x.moveTo(-100, -45)    
  x.arc(-103, -25, 180)
  x.lineTo(-123, -36)
  x.arc(-98, -36, 60)
  x.arc(-113, -44, 30)
  x.arc(-100, -45, 20)
  x.closePath()
  }
def basket = Picture.fromPath{
  x=>
  x.moveTo(200, -185)
  x.arc(250, -185, 80)
  x.arc(200, -185, 80)
  x.arc(250, -185, 180)
  }
def rec = Picture.fromPath { 
  x =>
  x.moveTo(-380, -130)
  x.lineTo(-100, -180)
  x.lineTo(-170, -300)
  x.lineTo(-460, -240)
  x.lineTo(-380, -130)
  }
def collection2(count:Long):Picture = 
  if (count==1) {
    round1
    .thatsFilledWith(Color(254, 251, 247))
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsScaled(0.03,0.05)
        } else {
    
def iHave2 = round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(35)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))

def iGot2 = collection2(count - 1)
  picStack(
    iHave2
      .thatsTranslated(-3, 0),
    iGot2
      .thatsRotated(198)
      .thatsTranslated(5, 0)
    )
    }

def tulsi = picStack(
  plant
    .thatsScaled(0.3,0.5)
    .thatsTranslated(-37,-54),
  recOne
    .thatsFilledWith(Color(255, 153, 51))
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsRotated(90)
    .thatsScaled(1,0.7)
    .thatsTranslated(-35, -160),
  recOne
    .thatsFilledWith(Color(255, 40, 13))
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsRotated(90)
    .thatsScaled(1.05,0.05)
    .thatsTranslated(-34, -163),
  recOne
    .thatsFilledWith(Color(255, 40, 13))
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsRotated(90)
    .thatsScaled(1.10,0.06)
    .thatsTranslated(-33, -165),
  recOne
    .thatsFilledWith(Color(255, 40, 13))
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsRotated(90)
    .thatsScaled(1.15,0.08)
    .thatsTranslated(-32, -169),
  recOne
    .thatsFilledWith(Color(255, 40, 13))
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsRotated(90)
    .thatsScaled(1.05,0.05)
    .thatsTranslated(-34, -118),
  arcThree
    .thatsFilledWith(Color(255, 40, 13))
    .thatsStrokeColored(Color(255, 40, 13)),
  arcFour
     .thatsStrokeColored(Color(255, 40, 13)),
  arcFour
    .thatsScaled(0.6,0.6)
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsTranslated(-21, -56),
  line1
    .thatsRotated(-25)
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsScaled(0.2,0.1)
    .thatsTranslated(-64, -152),
  line1
    .thatsRotated(20)
    .thatsStrokeColored(Color(255, 40, 13))
    .thatsScaled(0.2,0.1)
    .thatsTranslated(-43, -152),
  lamp
    .thatsScaled(0.03,0.03)
    .thatsFilledWith(brown)
    .thatsStrokeColored(brown)
    .thatsTranslated(-53,-147),
  flame
    .thatsScaled(0.02,0.02)
    .thatsFilledWith(yellow)
    .thatsStrokeColored(yellow)
    .thatsTranslated(-53,-147) 
  )

def plant = picStack(
  arc2
    .thatsStrokeColored(brown)
    .thatsTranslated(-94, -110),  
  arc2
    .withFlippedX
    .thatsScaled(1,0.5)
    .thatsRotated(14)
    .thatsStrokeColored(brown)
    .thatsTranslated(-18,-86),
  branch3
    .thatsScaled(0.3,0.2)
    .thatsRotated(41)
    .thatsTranslated(-5,-54),
  branch3
    .thatsScaled(0.3,0.2)
    .thatsRotated(109)
    .thatsTranslated(-70,-25),
  branch3
    .thatsScaled(0.3,0.2)
    .withFlippedX
    .thatsRotated(-22)
    .thatsTranslated(-124,-67),
  branch3
    .thatsScaled(0.3,0.2)
    .withFlippedX
    .thatsRotated(-90)
    .thatsTranslated(-63,-32)
  )  
    
def flower = picStack(
  round3
    .thatsStrokeColored(yellow)
    .thatsFilledWith(Color(255, 255, 204)),
  round3
    .thatsStrokeColored(yellow)
    .thatsFilledWith(Color(255, 255, 204))
    .thatsTranslated(75, 60),
  round3
    .thatsStrokeColored(yellow)
    .thatsFilledWith(Color(255, 255, 204))
    .thatsTranslated(40, -90),
  round3
    .thatsStrokeColored(yellow)
    .thatsFilledWith(Color(255, 255, 204))
    .thatsTranslated(155, 9),
  round3
    .thatsStrokeColored(yellow)
    .thatsFilledWith(Color(255, 255, 204))
    .thatsTranslated(130, -80),
  round3
    .thatsStrokeColored(yellow)
    .thatsFilledWith(Color(255, 255, 204))
    .thatsTranslated(76, -25)
  )

def tree = picStack(
  round4
    .thatsFilledWith(colors2)
    .thatsStrokeColored(colors2)
    .thatsTranslated(-200, 50),
  round4
    .thatsFilledWith(colors2)
    .thatsStrokeColored(colors2)
    .thatsTranslated(-170, 150),
  round4
    .thatsFilledWith(colors2)
    .thatsStrokeColored(colors2)
    .thatsTranslated(-20, 150),
  round4
    .thatsFilledWith(colors2)
    .thatsStrokeColored(colors2)
    .thatsTranslated(-20, 75),
  trunk
    .thatsScaled(0.85,1)
    .thatsFilledWith(gradient5)
    .thatsStrokeColored(Color(95, 69, 14))
    .thatsTranslated(56, -100),
  branch
    .thatsTranslated(110,-90),
  branch2
    .withFlippedX
    .thatsTranslated(-480,120),
  branch2
    .withFlippedX
    .thatsTranslated(-350,260),
  branch2
    .withFlippedX
    .thatsTranslated(-480,0),
  branch,
  branch2
    .thatsRotated(80)
    .thatsTranslated(-250,220),
  branch
    .thatsRotated(90)
    .thatsTranslated(-138,330),
  branch2
    .thatsRotated(-50)
    .thatsTranslated(60,118),
  branch
    .thatsRotated(35)
    .thatsTranslated(-20,250),
  branch2
    .thatsRotated(-10)
    .thatsTranslated(-45,85),
  branch2
    .thatsRotated(-30)
    .thatsTranslated(100,-15),
  branch2
    .thatsTranslated(-10,30),
  branch2
    .withFlippedX
    .thatsTranslated(-325,-20),
  flower2,
  flower2
    .thatsTranslated(0,-150),
  flower2
    .thatsTranslated(100,-190),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-50,-304),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-60,-304),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-70,-304),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-171,-240)
  )

def flower2 = picStack(
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-59, -110),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-99, -208),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-199, -188),
  flower
    .thatsScaled(0.07,0.07)
    .thatsTranslated(-130, -160)  
  )
  
def branch2 = picStack(
  branch
    .thatsRotated(12)
    .thatsTranslated(110, -50),
  branch
    .thatsRotated(28)
    .thatsTranslated(90, 10),
  branch
    .thatsRotated(28)
    .thatsTranslated(90, 80),
  branch
    .thatsRotated(12)
    .withFlippedX
    .thatsTranslated(-315, -51),
  branch
    .thatsRotated(38)
    .withFlippedX
    .thatsTranslated(-288, 45),
  branch
    .thatsRotated(85)
    .withFlippedX
    .thatsTranslated(-155, 150)
  )

def leaf = picStack(
  arc2
    .thatsRotated(-25)            
    .thatsFilledWith(colors2)
    .thatsStrokeColored(darkGreen), 
  arc2
    .withFlippedX
    .thatsRotated(45)
    .thatsFilledWith(colors2)
    .thatsStrokeColored(darkGreen)
    .thatsTranslated(65, 10)
    )

def leftLeaf = picStack(
  leaf
    .thatsRotated(130)
    .thatsTranslated(-135,47),
  leaf
    .thatsRotated(130)
    .thatsTranslated(-115,47),
  leaf
    .thatsRotated(130)
    .thatsTranslated(-99,47),
  leaf
    .thatsRotated(130)
    .thatsTranslated(-80,47),
  leaf
    .thatsRotated(130)
    .thatsTranslated(-61,47),
  leaf
    .thatsRotated(130)
    .thatsTranslated(-41,47),
  leaf
    .thatsRotated(119)
    .thatsTranslated(-25,40)
  )

def branch = picStack(
  leftLeaf,
  leftLeaf
    .withFlippedY
    .thatsTranslated(0,99),
  arc2
    .thatsScaled(6,1)
    .thatsRotated(187)
    .withFlippedY
    .thatsStrokeColored(Color(95, 69, 14))
    .thatsTranslated(28,2),
  leaf
    .thatsRotated(75)
    .thatsTranslated(-30,15),
  flower
    .thatsScaled(0.07,0.07)
    .thatsRotated(45)
    .thatsTranslated(-165, 48),
  flower
    .thatsScaled(0.07,0.07)
    .thatsRotated(45)
    .thatsTranslated(-153, 40),
  flower
    .thatsScaled(0.07,0.07)
    .thatsRotated(45)
    .thatsTranslated(-153, 55),
  flower
    .thatsScaled(0.07,0.07)
    .thatsRotated(45)
    .thatsTranslated(-80, 55),
  flower
    .thatsScaled(0.07,0.07)
    .thatsRotated(45)
    .thatsTranslated(-80, 40),
  flower
    .thatsScaled(0.07,0.07)
    .thatsRotated(45)
    .thatsTranslated(-69, 48),
  )

def branch3 = picStack(
  leftLeaf,
  leftLeaf
    .withFlippedY
    .thatsTranslated(0,99),
  arc2
    .thatsScaled(6,1)
    .thatsRotated(187)
    .withFlippedY
    .thatsStrokeColored(Color(95, 69, 14))
    .thatsTranslated(28,2),
  leaf
    .thatsRotated(75)
    .thatsTranslated(-30,15),
  )

def house = picStack(  
  rect1
    .thatsFilledWith(gradient2)
    .thatsStrokeColored(brown),
  tri
    .thatsFilledWith(gradient2)
    .thatsStrokeColored(brown)
    .thatsTranslated(-105, 80),
  rect1
    .thatsFilledWith(gradient2)
    .thatsStrokeColored(brown)
    .thatsScaled(0.7,1.0)
    .thatsTranslated(-104, 0),
  rect1
    .thatsFilledWith(gradient2)
    .thatsStrokeColored(brown)
    .thatsScaled(0.7,1.0)
    .thatsTranslated(-104, 0),
  rect1
    .thatsFilledWith(black)
    .thatsStrokeColored(Color(153, 51, 0))
    .thatsStrokeSized(15)
    .thatsScaled(0.3,0.5)
    .thatsTranslated(50, 18),
  line1
    .thatsScaled(1,0.8)
    .thatsStrokeColored(Color(204, 51, 0))
    .thatsStrokeSized(4)
    .thatsTranslated(73, 18),
  line2
    .thatsStrokeColored(Color(204, 51, 0))
    .thatsStrokeSized(4)
    .thatsTranslated(50, 38),
  rect1
    .thatsStrokeColored(Color(153, 51, 0))
    .thatsStrokeSized(15)
    .thatsScaled(0.3,0.5)
    .thatsTranslated(50, 18),
  rect1
    .thatsFilledWith(Color(139, 1, 1))
    .thatsScaled(1.0,0.2)
    .thatsStrokeColored(brown)
    .thatsTranslated(0, -16),
  rect1
    .thatsFilledWith(Color(139, 1, 1))
    .thatsScaled(0.7,0.2)
    .thatsStrokeColored(brown)
    .thatsTranslated(-104, -16),
  rect1
    .thatsFilledWith(black)
    .thatsStrokeColored(Color(153, 51, 0))
    .thatsStrokeSized(9)
    .thatsScaled(0.2,0.5)
    .thatsTranslated(-68, -14),
  collection(43)
    .thatsRotated(-120)
    .thatsScaled(0.5,0.5)
    .thatsTranslated(-43, 169),
  collection(35)
    .thatsTranslated(-43, 151),
  collection(35)
    .thatsTranslated(-30, 130),
  collection(35)
    .thatsTranslated(-12, 97),
  collection(22)
    .withFlippedX
    .thatsTranslated(-11, 59),
  )

def mat = picStack(
  rec
    .thatsFilledWith(Color(255, 255, 144))
    .thatsStrokeColored(purple)
    .thatsStrokeSized(7),
  line1
    .thatsScaled(1,2.7)
    .thatsRotated(-36)
    .thatsTranslated(-440,-238),
  line1
    .thatsScaled(1,2.4)
    .thatsRotated(-36)
    .thatsStrokeSized(9)
    .thatsTranslated(-426,-233),
  line1
    .thatsScaled(1,2.7)
    .thatsRotated(-36)
    .thatsTranslated(-422,-242),
  line1
    .thatsScaled(1,2.8)
    .thatsRotated(-31)
    .thatsTranslated(-181,-291),
  line1
    .thatsScaled(1,2.4)
    .thatsRotated(-31)
    .thatsStrokeSized(9)
    .thatsTranslated(-186,-282),
  line1
    .thatsScaled(1,2.8)
    .thatsRotated(-31)
    .thatsTranslated(-199,-288)
  )

def lady1 = picStack(
  hair
    .thatsFilledWith(brown)
    .thatsStrokeColored(brown),
  face
    .thatsFilledWith(Color(245, 227, 174))
    .thatsStrokeColored(Color(245, 227, 174)),
  round
    .thatsStrokeColored(red)
    .thatsScaled(0.1,0.5)
    .thatsRotated(-20)
    .thatsTranslated(-4, -10),
  eye
    .thatsStrokeColored(black)
    .thatsRotated(85)
    .thatsScaled(0.4,0.4)
    .thatsTranslated(-13, -15),
  round
    .thatsStrokeColored(brown)
    .thatsScaled(0.2,0.5)
    .thatsRotated(-20)
    .thatsTranslated(-10, -12),
  eye
    .thatsStrokeColored(black)
    .thatsRotated(85)
    .thatsScaled(0.4,0.4)
    .thatsTranslated(-14, -18),
  eye
    .thatsStrokeColored(black)
    .thatsRotated(-105)
    .thatsScaled(0.4,0.4)
    .thatsTranslated(-7, -6),
  tri
    .thatsFilledWith(red)
    .thatsRotated(55)
    .thatsScaled(0.05,0.02)
    .thatsTranslated(-18, -32),
  flower
    .thatsScaled(0.05,0.05)
    .thatsTranslated(7, -96), 
  flower
    .thatsScaled(0.03,0.03)
    .thatsTranslated(-50, -8), 
  fig1
    .thatsFilledWith(Color(245, 227, 174))
    .thatsStrokeColored(Color(245, 227, 174)),
  fig2
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(204, 0, 0))
    .thatsTranslated(5, 11),
  fig4
    .thatsFilledWith(Color(245, 227, 174))
    .thatsStrokeColored(Color(245, 227, 174)),
  fig7
    .thatsFilledWith(Color(245, 227, 174))
    .thatsStrokeColored(Color(245, 227, 174)),
  fig5
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(204, 0, 0)),
  fig6
   .thatsFilledWith(Color(245, 227, 174))
   .thatsStrokeColored(Color(245, 227, 174)),
  fig3
    .thatsFilledWith(green)
    .thatsStrokeColored(Color(0, 163, 79)),
  fig2
    .thatsFilledWith(blue)
    .thatsStrokeColored(blue)
    .thatsScaled(1.1,0.3)
    .thatsRotated(15) 
    .thatsTranslated(3, -21),
  recOne
    .thatsFilledWith(blue)
    .thatsStrokeColored(blue)
    .thatsScaled(0.26,0.1)
    .thatsTranslated(-34, -121)
  )
   
def grinder = picStack(
  arcOne
    .thatsScaled(2.9,2.95)
    .thatsStrokeColored(Color(163, 163, 163))
    .thatsFilledWith(Color(152, 150, 150))
    .thatsTranslated(0, -22),
  arcOne
    .thatsScaled(2.9,2.95)
    .thatsStrokeColored(Color(115, 115, 115))
    .thatsFilledWith(Color(115, 115, 115))
    .thatsTranslated(0, -2),
  round1
    .thatsScaled(1.2,1.6)
    .thatsStrokeColored(Color(153, 153, 153))
    .thatsFilledWith(colorOne)
    .thatsTranslated(0, -2),
  arcOne
    .thatsStrokeColored(Color(135, 117, 117))
    .thatsFilledWith(Color(102, 88, 88)),
  round1
    .thatsScaled(0.4,0.4)
    .thatsStrokeColored(Color(195, 182, 182))
    .thatsFilledWith(Color(195, 182, 182)),
  round1
    .thatsScaled(0.25,0.25)
    .thatsStrokeColored(Color(195, 182, 182))
    .thatsFilledWith(Color(159, 144, 144)),
  round1
    .thatsScaled(0.15,0.15)
    .thatsStrokeColored(Color(195, 182, 182))
    .thatsFilledWith(Color(75, 59, 59))
    .thatsTranslated(0, -1)
  )

def handOne = picStack(
  arm
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152)),
  arcTwo
    .thatsStrokeColored(Color(153, 144, 144))
    .thatsFilledWith(Color(175, 165, 165))
    .thatsScaled(0.6,1)
    .thatsTranslated(218,-88),
  ha2
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152))
    .thatsTranslated(-10, 8),
  ha1
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152))
    .thatsTranslated(0, 5),
  recOne
    .thatsRotated(-38)
    .thatsFilledWith(red)
    .thatsTranslated(33, 24),
  recOne
    .thatsScaled(0.2,1.03)
    .thatsRotated(-38)
    .thatsFilledWith(yellow)
    .thatsStrokeColored(yellow)
    .thatsTranslated(73, -8),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(191, -44),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(193, -44),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(195, -44),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(197, -44)
  )

def handTwo = picStack(
  arm
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152)),
  recOne
    .thatsScaled(0.3,0.7)
    .thatsFilledWith(red)
    .thatsTranslated(33, 51),
  recOne
    .thatsRotated(-36)
    .thatsFilledWith(red)
    .thatsStrokeSized(7)
    .thatsTranslated(25, 28),
  recOne
    .thatsScaled(0.2,1.1)
    .thatsRotated(-36)
    .thatsFilledWith(yellow)
    .thatsStrokeColored(yellow)
    .thatsTranslated(73, -9),
  ha3
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152))
    .thatsTranslated(26, 82),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(194, -44),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(196, -44),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsFilledWith(red)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsTranslated(198, -44),
  arcTwo
    .thatsScaled(0.1,0.28)
    .thatsStrokeColored(Color(175, 8, 8))
    .thatsFilledWith(red)
    .thatsTranslated(200, -44)
  )
  
def ch = picStack(
  round2
    .thatsTranslated(35,55),
  round2
    .thatsTranslated(39,51),
  round2
    .thatsTranslated(43,48),
  round2
    .thatsTranslated(47,45)
    )
        
def leftch = picStack(
  ch
    .thatsTranslated(0,-2),
  ch
    .thatsTranslated(16, -16)
  )
    
def chain = picStack(
  round2
    .thatsFilledWith(black)
    .thatsStrokeColored(black)
    .thatsTranslated(32,58),  
  leftch
     .thatsFilledWith(black)
    .thatsStrokeColored(black),
  leftch
    .thatsFilledWith(black)
    .thatsStrokeColored(black)
    .withFlippedY
    .thatsRotated(38)
    .thatsTranslated(8, 46),
  round2
    .thatsScaled(1.15,1.15)
    .thatsFilledWith(Color(255, 163, 53))
    .thatsStrokeColored(Color(255, 122, 34))
    .thatsTranslated(68, 26)  
  ) 
     
def hen = picStack(
  tri
    .thatsFilledWith(Color(232, 48, 48))
    .thatsStrokeColored(Color(255,117,97))
    .thatsRotated(25)
    .thatsScaled(0.3,0.3)
    .thatsTranslated(-120, -68),
  sh3
    .thatsFilledWith(red)
    .thatsTranslated(5, 5),
  sh4
    .thatsFilledWith(Color(232, 48, 48))
    .thatsStrokeColored(Color(232, 48, 48))
    .thatsTranslated(8,0),
  sh4
    .thatsFilledWith(Color(232, 48, 48))
    .thatsStrokeColored(Color(232, 48, 48))
    .thatsTranslated(78,0),
  round3
    .thatsFilledWith(red)
    .thatsStrokeColored(red)
    .thatsScaled(0.2,0.3)
    .thatsTranslated(-82, -58),
  round3
    .thatsFilledWith(Color(255, 248, 212))
    .thatsStrokeColored(Color(255, 248, 212))
    .thatsScaled(0.4,0.5)
    .thatsTranslated(120, -60),
  round3
    .thatsFilledWith(Color(255, 248, 212))
    .thatsStrokeColored(Color(255, 248, 212))
    .thatsScaled(0.4,0.5)
    .thatsTranslated(60, -50),
  sh1
    .thatsFilledWith(Color(255, 248, 212))
    .thatsStrokeColored(Color(255, 248, 212)),
  sh2
    .thatsFilledWith(Color(255, 232, 191))
    .thatsStrokeColored(Color(255, 206, 171)),
  round3
    .thatsScaled(0.4,0.3)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(255, 248, 212))
    .thatsTranslated(-80, -28),
  round1
    .thatsFilledWith(black)
    .thatsRotated(96)
    .thatsScaled(0.18,0.08)
    .thatsTranslated(-85, -28),
  round1
    .thatsFilledWith(white)
    .thatsRotated(96)
    .thatsScaled(0.05,0.02)
    .thatsTranslated(-83, -25),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(180)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(-136,-68),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(180)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(-128,-75),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(180)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(-100,-75),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(180)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(0,-140),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(180)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(20,-150),
  )

def chick = picStack(
  sh4
    .thatsFilledWith(red)
    .thatsStrokeColored(red)
    .thatsScaled(0.7,0.7)
    .thatsTranslated(-57, -94),
  sh4
    .thatsFilledWith(red)
    .thatsStrokeColored(red)
    .thatsScaled(0.7,0.7)
    .thatsTranslated(24, -97),
  round3
    .thatsScaled(0.3,0.3)
    .thatsFilledWith(yellow)
    .thatsStrokeColored(yellow)
    .thatsTranslated(-20, -140),
  sh5
    .thatsFilledWith(yellow)
    .thatsStrokeColored(Color(255, 210, 171)),
  round1
    .thatsScaled(0.1,0.19)
    .thatsStrokeColored(black)
    .thatsFilledWith(black)
    .thatsTranslated(-82, -10),
  round2
    .thatsScaled(1,1)
    .thatsStrokeColored(white)
    .thatsFilledWith(white)
    .thatsTranslated(-88, -10),
  arc2
    .thatsScaled(1.8,1.8)
    .thatsRotated(22)
    .thatsStrokeColored(Color(255, 178, 63))
    .thatsTranslated(10, -120),
  arc2
    .thatsScaled(2.4,2.4)
    .thatsRotated(58)
    .withFlippedY
    .thatsStrokeColored(Color(255, 178, 63))
    .thatsTranslated(24, -13),
  sh6
    .thatsFilledWith(Color(232, 48, 48))
    .thatsStrokeColored(Color(239, 74, 74)),
   )

def ladyGrinding = picStack(
  mat
    .thatsScaled(1.8,1.8)
    .thatsTranslated(600,245),
  sa1
    .thatsFilledWith(Color(0, 179, 87))
    .thatsStrokeColored(Color(0, 148, 93))
    .thatsRotated(-360)
    .withFlippedX
    .thatsTranslated(160, -38),
  pallu
    .thatsFilledWith(Color(0, 179, 87))
    .thatsStrokeColored(Color(0, 148, 93)),
  sa1
    .thatsScaled(0.9,0.5)
    .thatsRotated(290)
    .thatsFilledWith(red)
    .thatsTranslated(49, 80),
  face1
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152)),
  hair1
    .thatsFilledWith(brown)
    .thatsStrokeColored(brown),
  grinder
    .thatsTranslated(218, -117),
  handOne
    .thatsTranslated(53, 3),
  sa1
    .thatsFilledWith(Color(0, 179, 87))
    .thatsStrokeColored(Color(0, 148, 93))
    .thatsTranslated(4, 13),
  sa2
    .thatsFilledWith(yellow)
    .thatsStrokeColored(yellow)
    .thatsTranslated(4, 13),
  handTwo
    .thatsRotated(6)
    .thatsTranslated(-13, -55),
  sa3
    .thatsFilledWith(Color(0, 179, 87))
    .thatsStrokeColored(Color(0, 148, 93)),
  sa4
    .thatsFilledWith(yellow)
     .thatsStrokeColored(yellow),
  chain,
  border
    .thatsStrokeColored(yellow)
    .thatsFilledWith(yellow),
  eyebr
    .thatsRotated(66)
    .thatsStrokeColored(brown)
    .thatsTranslated(65, 110),
  nose
    .thatsStrokeColored(Color(255, 217, 152))
    .thatsScaled(0.8,1)
    .thatsTranslated(16, 0),
  eyebr
    .thatsRotated(66)
    .thatsScaled(0.6,1)
    .thatsStrokeColored(brown)
    .thatsTranslated(95,108),
  lips
    .thatsFilledWith(white)
    .thatsTranslated(-1,0),
  eye
    .thatsStrokeColored(brown)
    .thatsRotated(104)
    .thatsTranslated(65,111),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(brown)
    .thatsStrokeColored(brown)
    .thatsTranslated(68,128),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(brown)
    .thatsStrokeColored(brown)
    .thatsTranslated(95,127),
  eyebr
    .thatsStrokeColored(brown)
    .thatsRotated(66)
    .thatsScaled(0.5,1)
    .thatsTranslated(95,99),
  leg
    .thatsFilledWith(peach)
    .thatsStrokeColored(Color(255, 217, 152)),
  sup
    .thatsFilledWith(Color(254, 213, 131))
    .thatsStrokeColored(Color(235, 170, 105))
    .thatsStrokeSized(4)
    .thatsTranslated(105,-30),
  sup2
   .thatsStrokeColored(Color(246, 201, 111)),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(210,-90),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(215,-90),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(220,-87),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(220,-94),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(212,-98),
  round1
    .thatsScaled(0.03,0.05)
    .thatsRotated(90)
    .thatsFilledWith(white)
    .thatsStrokeColored(Color(227, 186, 64))
    .thatsTranslated(217,-100),
  round1
    .thatsScaled(0.02,0.1)
    .thatsFilledWith(red)
    .thatsTranslated(85,140),
  collection2(8)
    .thatsTranslated(20, -235),
  collection2(8)
    .thatsTranslated(30, -226),
  collection2(8)
    .thatsTranslated(50, -226),
  grain2
    .thatsTranslated(-2,0),
  grain2
    .thatsTranslated(-2,12),
  grain2
    .thatsTranslated(7,20),
  grain2
    .thatsTranslated(17,30), 
  grain2
    .withFlippedX
    .thatsRotated(149)
    .thatsTranslated(-110,-445)  
  )

def grain = picStack(
  collection2(11)
    .thatsRotated(59)
    .thatsTranslated(65,-280),
  collection2(11)
    .thatsRotated(59)
    .thatsTranslated(60,-280),
    )

def grain2 = picStack(
  grain
    .thatsTranslated(0, -2),
  grain
    .thatsTranslated(-12,2), 
  grain
    .thatsTranslated(-25,5),  
  grain
    .thatsTranslated(-37,11),
  grain
    .thatsTranslated(-40,20)
  )