Code Sketch


Hanv Saiba Poltodi Vetam
By: Sonaly R Pawar
Category: Art
// "A special thank you to Sir Lalit Pant and Sir Anay Kamat"

/* The story that is depicted in this animation is a glimpse of the famous
Goan folk konkani song, "Hanv Saiba Poltoddi Vetam" The story narrates
the tale of a temple dancer who wants to attend Damu's wedding on the
other side of the river, but facing a challenge as the boatman is not
willing to ferry her across the river as it is approaching nightfall
and the water is a little turbulent due to the strong winds. She begins
to dance. But despite her persistent plea and attempts to persuade the
boatman with her jewelery, he is not convinced and remains determined
in his refusal.

This story combines feelings of excitement,difficulties and the ability
to express yourself through art. it's a fascinating tale of not giving
up when things get tough.*/

// #include /music.kojo
import net.kogics.kojo.music.Duration._

cleari()

/*  I'm going to the other side of the river
    I'm going to Damu's wedding
    show me the way,
    for i do not know the way */
val notes1 = Phrase(
    r, r,
    gs4, f4, g4, a4_i, a4_i, as4, a4, g4, r,
    gs4, f4, g4, a4_i, a4_i, as4, a4, g4, r,
    g4_i, gs4_i, f4, g4, a4, c4_i, as4, a4, r,
    g4_i, gs4_i, f4, g4, a4, c4_i, as4, a4, g4_h, r
)

/*  In the tent of Damu's wedding,
    the dancing girls are playing */
val notes2 = Phrase(
    gs4, f4, g4, a4, f5_i, f5, c5,
    b4, b4, a4, g4, a4, b4_i, b4, r,
    gs4, f4, g4, a4, f5_i, f5, c5,
    b4, b4, a4, g4, a4, g4_i, g4, r,
)

/*  Oh my boatman,
    Please take me to Shiroda, yes to Shiroda */
val notes3 = Phrase(
    b4, c4_i, c4, b4_i, b4, r,
    a4, b4_i, a4, g4_i, g4, r,
    g4_i, g4_i, a4_i, b4, a4_i, d4, r,
    g4, a4, b4, f5, r, b4, a4, g4, r,
)

/* Take it, take it, Oh my boatman */
val notes4 = Phrase(
    d4, e4, fs4, g4, g4, r,
    as4, a4_i, g4, d4, r,
)

/* I don't want it, i don't want it */
val notes5 = Phrase(
    f4_i, fs4_i, gs4_i, f4, f4_i, r,
    f4_i, fs4_i, gs4_i, f4, f4_i, r,
)

/*  This nose ring from my nose, please take it,
    This anklets from my feet, do take them boatman. */
val notes6 = Phrase(
    g4, g4, d4, g4_i, g4, a4_i,
    c4, b4, r, b4_i, b4, g4_i, a4, g4, r,
)

val notes7 = Phrase(
    d4, g4, g4, b4, a4, g4_i, g4_i, r,
)

val notes8 = Phrase(
    d4_i, g4, b4_i, a4, g4,
    d4_i, g4, a4_i, b4_i, b4_i, f4,
    a4_i, a4, b4_i, a4, g4_i, r,
)

val score1 =
    Score(
        180.0,
        InstrumentPart(Instrument.BANDNEON, notes1),
        InstrumentPart(Instrument.AC_GUITAR, notes1),
        InstrumentPart(Instrument.BASSOON, notes1),
        InstrumentPart(Instrument.PIANO, notes1),
        InstrumentPart(Instrument.BARITONE_SAX, notes1),
        InstrumentPart(Instrument.GUITAR, notes1),
        InstrumentPart(Instrument.BAGPIPES, notes1),
    )

val score2 =
    Score(
        180.0,
        InstrumentPart(Instrument.BANDNEON, notes2),
        InstrumentPart(Instrument.AC_GUITAR, notes2),
        InstrumentPart(Instrument.BASSOON, notes2),
        InstrumentPart(Instrument.PIANO, notes2),
        InstrumentPart(Instrument.BARITONE_SAX, notes2),
        InstrumentPart(Instrument.GUITAR, notes2),
        InstrumentPart(Instrument.BAGPIPES, notes2),
    )

val score3 =
    Score(
        160.0,
        InstrumentPart(Instrument.BANDNEON, notes3),
        InstrumentPart(Instrument.AC_GUITAR, notes3),
        InstrumentPart(Instrument.BASSOON, notes3),
        InstrumentPart(Instrument.PIANO, notes3),
        InstrumentPart(Instrument.BARITONE_SAX, notes3),
        InstrumentPart(Instrument.GUITAR, notes3),
        InstrumentPart(Instrument.BAGPIPES, notes3),
    )

val score4 =
    Score(
        190.0,
        InstrumentPart(Instrument.BANDNEON, notes4),
        InstrumentPart(Instrument.AC_GUITAR, notes4),
        InstrumentPart(Instrument.BASSOON, notes4),
        InstrumentPart(Instrument.PIANO, notes4),
        InstrumentPart(Instrument.BARITONE_SAX, notes4),
        InstrumentPart(Instrument.GUITAR, notes4),
        InstrumentPart(Instrument.BAGPIPES, notes4),
    )

val score5 =
    Score(
        170.0,
        InstrumentPart(Instrument.BANDNEON, notes5),
        InstrumentPart(Instrument.AC_GUITAR, notes5),
        InstrumentPart(Instrument.BASSOON, notes5),
        InstrumentPart(Instrument.PIANO, notes5),
        InstrumentPart(Instrument.BARITONE_SAX, notes5),
        InstrumentPart(Instrument.GUITAR, notes5),
        InstrumentPart(Instrument.BAGPIPES, notes5),
    )

val score6 =
    Score(
        180.0,
        InstrumentPart(Instrument.BANDNEON, notes6),
        InstrumentPart(Instrument.AC_GUITAR, notes6),
        InstrumentPart(Instrument.BASSOON, notes6),
        InstrumentPart(Instrument.PIANO, notes6),
        InstrumentPart(Instrument.BARITONE_SAX, notes6),
        InstrumentPart(Instrument.GUITAR, notes6),
        InstrumentPart(Instrument.BAGPIPES, notes6),
    )

val score7 =
    Score(
        180.0,
        InstrumentPart(Instrument.BASSOON, notes7),
        InstrumentPart(Instrument.AC_GUITAR, notes7),
        InstrumentPart(Instrument.BASSOON, notes7),
        InstrumentPart(Instrument.PIANO, notes7),
        InstrumentPart(Instrument.BARITONE_SAX, notes7),
        InstrumentPart(Instrument.GUITAR, notes7),
        InstrumentPart(Instrument.BAGPIPES, notes7),
    )

val score8 =
    Score(
        100.0,
        InstrumentPart(Instrument.BANDNEON, notes8),
        InstrumentPart(Instrument.AC_GUITAR, notes8),
        InstrumentPart(Instrument.BASSOON, notes8),
        InstrumentPart(Instrument.PIANO, notes8),
        InstrumentPart(Instrument.BARITONE_SAX, notes8),
        InstrumentPart(Instrument.GUITAR, notes8),
        InstrumentPart(Instrument.BAGPIPES, notes8),
    )

MusicPlayer.play(score1)
MusicPlayer.playNext(score2)
MusicPlayer.playNext(score3)
MusicPlayer.playNext(score4)
MusicPlayer.playNext(score5)
MusicPlayer.playNext(score4)
MusicPlayer.playNext(score5)
MusicPlayer.playNext(score6)
MusicPlayer.playNext(score5)
MusicPlayer.playNext(score6)
MusicPlayer.playNext(score5)
MusicPlayer.playNext(score7)
MusicPlayer.playNext(score8)
MusicPlayer.playNext(score4)
MusicPlayer.playNext(score5)
MusicPlayer.playNext(score4)
MusicPlayer.playNext(score5)

def animationC = animPar(animationA, animationB, animation.repeatedForever, waveAnimation.repeatedForever)

run(animationC)

def animationA = animSeq(
    animationInitial, handAnimation1,
    handAnimation2.repeated(2), handAnimation6.repeated(2),
    handAnimation1, handAnimation3, handAnimation1,
    handAnimation3, handAnimation5.repeated(2), handAnimation2,
    handAnimation6, handAnimation4.repeated(2), handAnimation2,
    handAnimation6, handAnimation4.repeated(3),
    handAnimation7.repeated(3), handAnimation1.repeated(2),
    handAnimation2.repeated(3), handAnimation7.repeated(3),
    animationInitial2.repeated(3), handAnimation7.repeated(3),
    animationInitial2.repeated(3), handAnimation8.repeated(2),
    handAnimation7.repeated(2), animationInitial2.repeated(3),
    handAnimation9.repeated(2), handAnimation7.repeated(2),
    animationInitial2.repeated(2), handAnimation10, handAnimation11,
    handAnimation10, handAnimation9.repeated(2), animationInitial2.repeated(4),
    handAnimation7.repeated(3), animationInitial2.repeated(3),
    handAnimation7.repeated(3), animationInitial2.repeated(4),
    animationInitial3,
)

def animationB = animSeq(
    boatAnimation.repeated(32), boatAnimationB.repeated(3),
    boatAnimation.repeated(3), boatAnimationB.repeated(3),
    boatAnimation.repeated(3), boatAnimationB.repeated(3),
    boatAnimation.repeated(4), boatAnimationB.repeated(2),
    boatAnimation.repeated(6), boatAnimationC.repeated(2), boatAnimationD.repeated(2),
    boatAnimation.repeated(3), boatAnimationB.repeated(3),
    boatAnimation.repeated(3), boatAnimationB.repeated(3),
    boatAnimationA,
)

moon.thatsStrokeColored(noColor).thatsFilledWith(moonFill).thatsTranslated(300, 200).draw
setBackground(background1)

land.thatsStrokeColored(background2)
    .thatsFilledWith(background2)
    .draw

def step1(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(rightHand, body2),
        picStack(body1, head2)),
    picStack(pallu2Bor2.thatsFilledWith(yellow).thatsStrokeColored(yellow).thatsStrokeSized(4).thatsTranslated(-5, -1), leftHand)
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def step2(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            rightHand, leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4)), rightLeg.thatsTranslated(states(3), states(4))),
        picStack(
            rightLeg, body1)),
    picStack(
        picStack(
            head2.thatsTranslated(5, 0).thatsRotated(states(2)), pallu2Bor2.thatsFilledWith(yellow).thatsStrokeColored(yellow).thatsStrokeSized(4).thatsTranslated(-5, -1)),
        leftHand)
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4)), rightLeg.thatsTranslated(states(3), states(4))),
        picStack(rightHand, body1.thatsTranslated(-states(5), -states(6))),
        picStack(
            picStack(head.thatsRotated(-states(2)), hand.thatsTranslated(states(0), -states(1))),
            rect.thatsRotated(60).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-45, 46)))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL2(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            rect.thatsTranslated(-49, 73).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)),
            leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4))),
        picStack(rightLeg.thatsTranslated(states(3), states(4)), rightHand),
        picStack(
            picStack(hand2.thatsRotated(states(7)), body1.thatsTranslated(-states(5), -states(6))),
            head2.thatsRotated(-states(2))))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL3(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            picStack(
                rect.thatsRotated(131).thatsScaled(1, 1.2).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-11, 60),
                leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4))),
            picStack(rightLeg.thatsTranslated(states(3), states(4)), rightHand)),
        picStack(
            picStack(body1.thatsTranslated(-states(5), -states(6)), head2.thatsRotated(-states(2))),
            picStack(hand6.withFlippedX.thatsRotated(-states(2)))),
        rect.thatsRotated(130).thatsScaled(1, 1.2).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-26, 80)).thatsTranslated(-320, -20).thatsScaled(0.9)
)

def animatedHandL4(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            hand4.withFlippedX.thatsRotated(states(7)),
            leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4))),
        picStack(rightLeg.thatsTranslated(states(3), states(4)), body1.thatsTranslated(-states(5), -states(6)))),
    head.thatsRotated(-states(2))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL5(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4)),
            rightLeg.thatsTranslated(states(3), states(4))),
        picStack(
            hand5.thatsRotated(-states(8)).thatsRotated(10).thatsTranslated(3, -15),
            hand5.withFlippedX.thatsRotated(states(8)).thatsRotated(-10).thatsTranslated(8, 0))),
    picStack(
        picStack(
            rect3.withFlippedX.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(109, 0),
            body1.thatsTranslated(-states(5), -states(6))),
        picStack(
            head.thatsRotated(-states(2)),
            rect.thatsRotated(60).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-45, 45)))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL6(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            picStack(
                rect.thatsScaled(0.5, 0.5).thatsRotated(60).thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(86, 128),
                leftH2.withFlippedX.thatsRotated(-5).thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsTranslated(25, 97)),
            picStack(
                rect.thatsRotated(130).thatsScaled(1, 1.2).withFlippedX.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(26, 80),
                leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4)), rightLeg.thatsTranslated(states(3), states(4)))),
        picStack(
            picStack(
                rect.thatsRotated(131).thatsScaled(1, 1.2).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-11, 60),
                body1.thatsTranslated(-states(5), -states(6))),
            picStack(head2.thatsRotated(-states(2)), hand6.withFlippedX.thatsRotated(-states(2)))),
        picStack(
            hand6a.thatsRotated(-states(2)).thatsTranslated(4, 0),
            rect.thatsRotated(130).thatsScaled(1, 1.2).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-26, 80))),
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL7(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(rightHand3.thatsRotated(states(4)), leftLeg.thatsTranslated(states(5), -states(6)).thatsTranslated(states(7), states(8))),
        picStack(rightLeg.thatsTranslated(states(7), states(8)), body1.thatsTranslated(-states(9), -states(10)))),
    picStack(head2, pallu2Bor2.thatsFilledWith(yellow).thatsStrokeColored(yellow).thatsStrokeSized(4).thatsTranslated(-5, -1),
        leftHand3.thatsRotated(states(4)).thatsTranslated(-1, 0))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL8(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(hand3.thatsTranslated(25, 70), leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4))),
        picStack(rightLeg.thatsTranslated(states(3), states(4)), rightHand)),
    picStack(
        picStack(body1.thatsTranslated(-states(5), -states(6)), head.thatsScaled(0.95).thatsTranslated(0, -11).thatsRotated(-states(2))),
        picStack(rect.thatsRotated(56).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-49, 46), handC)),
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL9(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(hand3.thatsTranslated(44, 68).thatsRotated(30), hand3.withFlippedX.thatsRotated(-20).thatsTranslated(-7, 72)),
        picStack(leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4)), rightLeg.thatsTranslated(states(3), states(4)))),
    picStack(
        picStack(rightHand4, body1.thatsTranslated(-states(5), -states(6))),
        picStack(head4.thatsScaled(0.95).thatsTranslated(0, -11).thatsRotated(-states(2)), eye.thatsTranslated(0, -20))),
    picStack(
        picStack(
            handC.thatsStrokeColored(Color(224, 167, 98)).thatsRotated(235).thatsTranslated(-130, -27).thatsRotated(states(7)),
            handC.withFlippedX.thatsStrokeColored(Color(224, 167, 98)).thatsRotated(126).thatsTranslated(140, -27).thatsRotated(-states(7))),
        rect.thatsRotated(56).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-49, 46)),
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL10(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(hand7.withFlippedX.thatsRotated(states(7)), leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4))),
        picStack(rightLeg.thatsTranslated(states(3), states(4)), body1.thatsTranslated(-states(5), -states(6))),
        picStack(head3.thatsRotated(-states(2)), eye2, hand8.thatsRotated(states(7))))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedHandL11(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(hand7.thatsRotated(states(7)), leftLeg.thatsTranslated(states(0), -states(1)).thatsTranslated(states(3), states(4))),
        picStack(rightLeg.thatsTranslated(states(3), states(4)), body1.thatsTranslated(-states(5), -states(6)))),
    picStack(head3.thatsRotated(-states(2)), eye2,
        hand8.withFlippedX.thatsRotated(states(7)))
)
    .thatsTranslated(-320, -20).thatsScaled(0.9)

def animatedBoat(states: Seq[Double]): Picture = picStack(
    picStack(
        boat.thatsTranslated(states(2), states(3)).thatsScaled(1.4).thatsTranslated(-80, -85),
        boatman.thatsTranslated(states(2), states(3)).thatsScaled(0.8).thatsTranslated(180, -20))
)

def animatedBoatB(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            boat.thatsTranslated(states(2), states(3)).thatsScaled(1.4).thatsTranslated(-80, -85),
            boatmanB.thatsTranslated(states(2), states(3)).thatsScaled(0.8).thatsTranslated(180, -20)),
        picStack(
            hand5Male.withFlippedX.thatsRotated(-states(11)).thatsRotated(-5).thatsTranslated(263, -70),
            maleB1a.thatsFilledWith(gradient3).thatsStrokeColored(Color(176, 0, 102)).thatsScaled(0.85).thatsTranslated(180, -24)))
)

def animatedBoatC(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            boat.thatsTranslated(states(2), states(3)).thatsScaled(1.4).thatsTranslated(-80, -85),
            boatmanB.thatsTranslated(states(2), states(3)).thatsScaled(0.8).thatsTranslated(180, -20)),
        picStack(
            hand6Male.withFlippedX.thatsRotated(-states(11)).thatsRotated(-5).thatsTranslated(263, -50),
            maleB1a.thatsFilledWith(gradient3).thatsStrokeColored(Color(176, 0, 102)).thatsScaled(0.85).thatsTranslated(180, -24)))
)

def animatedBoatD(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            boat.thatsTranslated(states(2), states(3)).thatsScaled(1.4).thatsTranslated(-80, -85),
            boatmanB.thatsTranslated(states(2), states(3)).thatsScaled(0.8).thatsTranslated(180, -20)),
        picStack(
            leftH2.thatsScaled(1, 0.3).thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(32).thatsTranslated(220, -26),
            maleB1a.thatsFilledWith(gradient3).thatsStrokeColored(Color(176, 0, 102)).thatsScaled(0.85).thatsTranslated(180, -24),
            hand7Male.withFlippedX.thatsScaled(0.9, 0.7).thatsRotated(-states(11)).thatsRotated(95).thatsTranslated(185, 33))),
)

def animatedStar(state: Seq[Double]) = picStack(
    picStack(
        picStack(star.thatsScaled(state(0)).thatsTranslated(0, 190), star.thatsScaled(state(1)).thatsTranslated(-250, 250)),
        picStack(star.thatsScaled(state(0)).thatsTranslated(120, 250), star.thatsScaled(state(1)).thatsTranslated(110, 110))),
    picStack(
        picStack(star.thatsScaled(state(0)).thatsTranslated(390, 110), star.thatsScaled(state(1)).thatsTranslated(-423, 270)),
        picStack(star.thatsScaled(state(0)).thatsTranslated(-180, 140), star.thatsScaled(state(1)).thatsTranslated(-450, 120))),
    picStack(
        picStack(star.thatsScaled(state(0)).thatsTranslated(450, 250), star.thatsScaled(state(1)).thatsTranslated(650, 450)),
        picStack(star.thatsScaled(state(0)).thatsTranslated(850, 150), star.thatsScaled(state(1)).thatsTranslated(-750, 250)),
        star.thatsScaled(state(0)).thatsTranslated(-450, 450)),
)
    .thatsFilledWith(moonFill).thatsStrokeColored(white)

def animatedWave(states: Seq[Double]): Picture = picStack(
    picStack(
        picStack(
            waves.thatsTranslated(100, -35).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), states(3)),
            waves.thatsScaled(0.5).thatsTranslated(130, -20).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), states(3))),
        picStack(
            waves.thatsScaled(0.6).thatsTranslated(-20, -80).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), -states(3)),
            waves.thatsTranslated(450, -250).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), states(3)))),
    picStack(
        waves.thatsTranslated(580, -180).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), -states(3)),
        waves.thatsScaled(0.8).thatsTranslated(480, -196).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), -states(3)),
        waves.thatsTranslated(280, -250).thatsStrokeColored(Color(0, 27, 216)).thatsFilledWith(blue).thatsTranslated(states(2), states(3)))
)

def keyframes = KeyFrames(
    0 -> Seq(0, 0, 1, 2, 3, 0, -5, -2, 0, 2, 0, 9),
    25 -> Seq(0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0),
    50 -> Seq(0, 0, 3, 2, 3, 0, -5, 4, 0, -2, 0, -5),
    75 -> Seq(0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0),
    100 -> Seq(0, 0, 1, 2, 3, 0, -5, -2, 0, 2, 0, 9),
)

def keyframes1 = KeyFrames(
    0 -> Seq(0, 5, 0.5, -2, 0, 2, 0, 8),
    25 -> Seq(0, 0, 0, 0, 0, 0, 0, 0),
    50 -> Seq(0, 5, -0.5, 4, 0, -2, 0, 8),
    75 -> Seq(0, 0, 0, 0, 0, 0, 0, 0),
    100 -> Seq(0, 5, 0.5, -2, 0, 2, 0, 8),
)

def keyframes2 = KeyFrames(
    0 -> Seq(0, -5, 0.5, -2, 0, 2, 0, -2),
    25 -> Seq(0, 0, 0, 0, 0, 0, 0, 0),
    50 -> Seq(0, -5, -0.5, 4, 0, -2, 0, 2),
    75 -> Seq(0, 0, 0, 0, 0, 0, 0, 0),
    100 -> Seq(0, -5, 0.5, -2, 0, 2, 0, -2),
)

def keyframes3 = KeyFrames(
    0 -> Seq(0, 5, 0.5, -2, 0, 2, 0, 2, 9),
    25 -> Seq(0, 0, 0, 0, 0, 0, 0, 0, 0),
    50 -> Seq(0, 5, -0.5, 4, 0, -2, 0, -2, -5),
    75 -> Seq(0, 0, 0, 0, 0, 0, 0, 0, 0),
    100 -> Seq(0, 5, 0.5, -2, 0, 2, 0, 2, 9),
)

def keyframes4 = KeyFrames(
    0 -> Seq(0.1, 0.5, -55, 0),
    25 -> Seq(0.3, 0.3, -66, 3),
    50 -> Seq(0.5, 0.1, -77, 0),
    75 -> Seq(0.3, 0.3, -88, 3),
    100 -> Seq(0.1, 0.5, -99, 0),
)

def animationInitial = Timeline(
    01.00,
    keyframes,
    easing.Linear,
    step1,
    true
)

def animationInitial2 = Timeline(
    01.00,
    keyframes,
    easing.Linear,
    step2,
    true
)

def animationInitial3 = Timeline(
    01.00,
    keyframes,
    easing.Linear,
    step1,
    false
)

def boatAnimation = Timeline(
    1,
    keyframes,
    easing.Linear,
    animatedBoat,
    true
)

def boatAnimationA = Timeline(
    1,
    keyframes,
    easing.Linear,
    animatedBoat,
    false
)

def boatAnimationB = Timeline(
    1,
    keyframes,
    easing.Linear,
    animatedBoatB,
    true
)

def boatAnimationC = Timeline(
    1,
    keyframes,
    easing.Linear,
    animatedBoatC,
    true
)

def boatAnimationD = Timeline(
    1,
    keyframes,
    easing.Linear,
    animatedBoatD,
    true
)

def handAnimation1 = Timeline(
    1,
    keyframes1,
    easing.Linear,
    animatedHandL,
    true
)

def handAnimation2 = Timeline(
    1,
    keyframes2,
    easing.Linear,
    animatedHandL2,
    true
)

def handAnimation3 = Timeline(
    1,
    keyframes2,
    easing.Linear,
    animatedHandL3,
    true
)

def handAnimation4 = Timeline(
    1,
    keyframes3,
    easing.Linear,
    animatedHandL4,
    true
)

def handAnimation5 = Timeline(
    1,
    keyframes3,
    easing.Linear,
    animatedHandL5,
    true
)

def handAnimation6 = Timeline(
    1,
    keyframes2,
    easing.Linear,
    animatedHandL6,
    true
)

def handAnimation7 = Timeline(
    01.00,
    keyframes,
    easing.Linear,
    animatedHandL7,
    true
)

def handAnimation8 = Timeline(
    1,
    keyframes1,
    easing.Linear,
    animatedHandL8,
    true
)

def handAnimation9 = Timeline(
    1,
    keyframes1,
    easing.Linear,
    animatedHandL9,
    true
)

def handAnimation10 = Timeline(
    1,
    keyframes3,
    easing.Linear,
    animatedHandL10,
    true
)

def handAnimation11 = Timeline(
    1,
    keyframes3,
    easing.Linear,
    animatedHandL11,
    true
)

def animation = Timeline(
    3,
    keyframes4,
    easing.Linear,
    animatedStar,
    true
)

def waveAnimation = Timeline(
    3,
    keyframes4,
    easing.Linear,
    animatedWave,
    true
)

def head = picStack(
    picStack(
        picStack(
            picStack(
                headFlowers.thatsScaled(0.8).thatsTranslated(0, 50),
                rightEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(-7, -2)),
            picStack(
                leftEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(7, -2),
                face.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, 145))),
        picStack(
            picStack(
                hair.thatsFilledWith(brown).thatsStrokeColored(brown).thatsTranslated(0, 155),
                leftEyeB.thatsStrokeColored(brown).thatsTranslated(10, -8)),
            picStack(
                rightEyeB.thatsTranslated(-10, -8),
                leftEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(8, -8)))),
    picStack(
        picStack(
            picStack(
                rightEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(-8, -8),
                circle.thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(-16, 180)),
            picStack(
                earing.thatsScaled(0.6).thatsTranslated(-41, 171),
                earing.thatsScaled(0.6).thatsTranslated(41, 171))),
        picStack(
            picStack(
                lips.thatsFilledWith(red).thatsScaled(0.7, 0.95).thatsTranslated(0, 3),
                nose.thatsTranslated(0, -10).thatsFilledWith(Color(219, 152, 72)).thatsStrokeColored(Color(219, 152, 72))),
            picStack(
                circle.thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(16, 180),
                circle.thatsStrokeColored(red).thatsFilledWith(red).thatsTranslated(0, 195),
                noseRing.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(0.1).thatsTranslated(3, 162))))
)

def head2 = picStack(
    picStack(
        picStack(
            picStack(
                headFlowers.thatsScaled(0.8).thatsTranslated(0, 50),
                rightEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(-7, -2)),
            picStack(
                leftEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(7, -2),
                face.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, 145))),
        picStack(
            picStack(
                hair.thatsFilledWith(brown).thatsStrokeColored(brown).thatsTranslated(0, 155),
                leftEyeB.thatsStrokeColored(brown).thatsTranslated(10, -8)),
            picStack(
                rightEyeB.thatsTranslated(-10, -8),
                leftEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(8, -8)))),
    picStack(
        picStack(
            picStack(
                rightEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(-8, -8),
                circle.thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(-13, 180)),
            picStack(
                earing.thatsScaled(0.6).thatsTranslated(-41, 171),
                earing.thatsScaled(0.6).thatsTranslated(41, 171))),
        picStack(
            picStack(
                lips.thatsFilledWith(red).thatsScaled(0.7, 0.95).thatsTranslated(0, 3),
                nose.thatsTranslated(0, -10).thatsFilledWith(Color(219, 152, 72)).thatsStrokeColored(Color(219, 152, 72))),
            picStack(
                circle.thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(19, 180),
                circle.thatsStrokeColored(red).thatsFilledWith(red).thatsTranslated(0, 195),
                noseRing.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(0.1).thatsTranslated(3, 162))))
)

def head3 = picStack(
    picStack(
        picStack(
            picStack(
                headFlowers.thatsScaled(0.8).thatsTranslated(0, 50),
                rightEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(-7, -2)),
            picStack(
                leftEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(7, -2),
                face.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, 145))),
        picStack(
            picStack(
                hair.thatsFilledWith(brown).thatsStrokeColored(brown).thatsTranslated(0, 155),
                leftEyeB.thatsStrokeColored(brown).thatsTranslated(10, -8)),
            picStack(
                rightEyeB.thatsTranslated(-10, -8),
                earing.thatsScaled(0.6).thatsTranslated(-41, 171)))),
    picStack(
        picStack(
            earing.thatsScaled(0.6).thatsTranslated(41, 171),
            lips.thatsFilledWith(red).thatsScaled(0.7, 0.95).thatsTranslated(0, 3)),
        picStack(
            nose.thatsTranslated(0, -10).thatsFilledWith(Color(219, 152, 72)).thatsStrokeColored(Color(219, 152, 72)),
            circle.thatsStrokeColored(red).thatsFilledWith(red).thatsTranslated(0, 195),
            noseRing.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(0.1).thatsTranslated(3, 162)))
)

def head4 = picStack(
    picStack(
        picStack(
            picStack(
                headFlowers.thatsScaled(0.8).thatsTranslated(0, 50),
                rightEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(-7, -2)),
            picStack(
                leftEar.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(7, -2),
                face.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, 145))),
        picStack(
            picStack(
                hair.thatsFilledWith(brown).thatsStrokeColored(brown).thatsTranslated(0, 155),
                leftEyeB.thatsStrokeColored(brown).thatsTranslated(10, -8)),
            picStack(
                rightEyeB.thatsTranslated(-10, -8),
                earing.thatsScaled(0.6).thatsTranslated(-41, 171)))),
    picStack(
        picStack(
            earing.thatsScaled(0.6).thatsTranslated(41, 171),
            lips.thatsFilledWith(red).thatsScaled(0.7, 0.95).thatsTranslated(0, 3)),
        picStack(
            nose.thatsTranslated(0, -10).thatsFilledWith(Color(219, 152, 72)).thatsStrokeColored(Color(219, 152, 72)),
            circle.thatsStrokeColored(red).thatsFilledWith(red).thatsTranslated(0, 195),
            noseRing.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(0.1).thatsTranslated(3, 162)))
)

def eye = picStack(
    picStack(
        leftEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(8, -8),
        rightEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(-8, -8)),
    picStack(
        arcO.thatsScaled(1.4).thatsStrokeColored(noColor).thatsFilledWith(black).thatsRotated(180).thatsTranslated(-15, 177),
        arcO.thatsScaled(1.4).thatsStrokeColored(noColor).thatsFilledWith(black).thatsRotated(180).thatsFilledWith(black).thatsTranslated(16, 177))
)

def eye2 = picStack(
    picStack(
        leftEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(8, -8),
        rightEye.thatsFilledWith(white).thatsScaled(0.9, 1).thatsStrokeColored(brown).thatsTranslated(-8, -8)),
    picStack(
        arcO.thatsScaled(1.4).thatsStrokeColored(noColor).thatsFilledWith(black).thatsTranslated(-15, 184),
        arcO.thatsScaled(1.4).thatsStrokeColored(noColor).thatsFilledWith(black).thatsFilledWith(black).thatsTranslated(16, 184))
)

def body1 = picStack(
    picStack(
        picStack(
            picStack(
                picStack(
                    body.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)),
                    neck.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120))),
                picStack(
                    pallu1.thatsFilledWith(gradient4).thatsStrokeColored(gradient4),
                    circle.thatsFilledWith(yellow).thatsTranslated(30, 100))),
            picStack(
                picStack(
                    circle.thatsFilledWith(yellow).thatsTranslated(10, 80),
                    circle.thatsFilledWith(yellow).thatsTranslated(30, 75)),
                picStack(
                    circle.thatsFilledWith(yellow).thatsTranslated(-10, 62),
                    circle.thatsFilledWith(yellow).thatsTranslated(14, 57)))),
        picStack(
            picStack(
                picStack(
                    circle.thatsFilledWith(yellow).thatsTranslated(-25, 42),
                    circle.thatsFilledWith(yellow).thatsTranslated(0, 37)),
                picStack(
                    circle.thatsFilledWith(yellow).thatsTranslated(25, 35),
                    circle.thatsFilledWith(yellow).thatsTranslated(-25, 18))),
            picStack(
                picStack(
                    circle.thatsFilledWith(yellow).thatsTranslated(0, 15),
                    circle.thatsFilledWith(yellow).thatsTranslated(20, 8)),
                picStack(
                    circle.thatsFilledWith(yellow).thatsTranslated(-15, -2),
                    pallu2.thatsStrokeColored(noColor).thatsFilledWith(gradient4))))),
    picStack(
        picStack(
            picStack(
                circle.thatsFilledWith(yellow).thatsTranslated(-25, -30),
                circle.thatsFilledWith(yellow).thatsTranslated(7, -32)),
            picStack(
                circle.thatsFilledWith(yellow).thatsTranslated(-15, -54),
                circle.thatsFilledWith(yellow).thatsTranslated(15, -50))),
        picStack(
            picStack(
                circle.thatsFilledWith(yellow).thatsTranslated(-35, -75),
                circle.thatsFilledWith(yellow).thatsTranslated(-5, -75)),
            picStack(
                circle.thatsFilledWith(yellow).thatsTranslated(-40, -53),
                pallu1Bor2.thatsFilledWith(yellow).thatsStrokeColored(yellow).thatsStrokeSized(1)))),
    picStack(
        picStack(
            pallu2Bor2.thatsFilledWith(yellow).thatsStrokeColored(yellow),
            pallu1Bor1.thatsFilledWith(yellow).thatsStrokeColored(yellow).thatsStrokeSized(1)),
        picStack(
            pallu2Bor1.thatsFilledWith(yellow).thatsStrokeColored(yellow),
            necklace2))
)

def body2 = picStack(
    picStack(
        picStack(
            leg.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsScaled(0.9, 1).thatsTranslated(-141, -3),
            leg.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsScaled(0.9, 1).thatsTranslated(-103, -3)),
        picStack(
            rLeg.thatsFilledWith(gradient4).thatsStrokeColored(gradient4).thatsTranslated(25, 0),
            lLeg.thatsFilledWith(gradient4).thatsStrokeColored(gradient4).thatsTranslated(-5, 0))),
    picStack(
        legBor1.thatsStrokeColored(yellow).thatsFilledWith(yellow),
        legBor1.thatsStrokeColored(yellow).thatsFilledWith(yellow).thatsTranslated(39, 0))
)

def leftHand = picStack(
    picStack(
        leftH1.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)),
        BH1.thatsStrokeSized(3).thatsScaled(0.9).thatsRotated(68).thatsTranslated(25, -21)),
    picStack(
        BH1.thatsStrokeSized(3).thatsScaled(0.9).thatsRotated(85).thatsTranslated(20, -21),
        BH1.thatsStrokeSized(3).thatsScaled(0.9).thatsRotated(85).thatsTranslated(15, -21),
        rect.thatsRotated(60).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-45, 45))
)

def leftHand3 = picStack(
    picStack(
        picStack(
            circle.thatsScaled(3).thatsTranslated(-40, 97).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)),
            leftH7.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98))),
        picStack(
            BH1.thatsStrokeSized(3).thatsScaled(0.9).thatsRotated(68).thatsTranslated(25, -21),
            BH1.thatsStrokeSized(3).thatsScaled(0.9).thatsRotated(85).thatsTranslated(20, -21))),
    picStack(
        BH1.thatsStrokeSized(3).thatsScaled(0.9).thatsRotated(85).thatsTranslated(15, -21),
        rect.thatsRotated(60).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-45, 45))
)

def rightHand = picStack(
    picStack(
        rightH1.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsTranslated(27, 69),
        rect.thatsRotated(-50).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(29, 78)),
    picStack(
        BH1.thatsStrokeSized(3).thatsRotated(-30).thatsScaled(0.7).thatsTranslated(61, -16),
        BH1.thatsStrokeSized(3).thatsRotated(-40).thatsScaled(0.6).thatsTranslated(60, -18),
        BH1.thatsStrokeSized(3).thatsRotated(-40).thatsScaled(0.7).thatsTranslated(63, -12))
)

def rightHand3 = picStack(
    picStack(
        picStack(
            rect.thatsScaled(0.5).thatsRotated(-52).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(44, 90),
            leftH7.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-20).thatsTranslated(104, 0)),
        picStack(
            rect.thatsRotated(-65).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(40, 70),
            BH1.thatsStrokeSized(3).thatsScaled(0.80).thatsRotated(58).thatsTranslated(127, -30))),
    picStack(
        BH1.thatsStrokeSized(3).thatsScaled(0.80).thatsRotated(58).thatsTranslated(122, -28),
        BH1.thatsStrokeSized(3).thatsScaled(0.80).thatsRotated(58).thatsTranslated(118, -27)),
)

def rightHand4 = picStack(
    rect.thatsRotated(-50).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(29, 78),
)

def leftLeg = picStack(
    picStack(
        leg.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsScaled(0.9, 1).thatsTranslated(-103, -3),
        rLeg.thatsFilledWith(gradient4).thatsStrokeColored(gradient4).thatsTranslated(25, 0)),
    legBor1.thatsStrokeColored(yellow).thatsFilledWith(yellow).thatsTranslated(39, 0)
)

def rightLeg = picStack(
    picStack(
        leg.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsScaled(0.9, 1).thatsTranslated(-141, -3),
        lLeg.thatsFilledWith(gradient4).thatsStrokeColored(gradient4).thatsTranslated(-5, 0)),
    picStack(
        legBor1.thatsStrokeColored(yellow).thatsFilledWith(yellow),
        pallu2Bor2.thatsFilledWith(yellow).thatsStrokeColored(yellow).thatsStrokeSized(4).thatsTranslated(-5, -1))
)

def headMale = picStack(
    picStack(
        picStack(
            picStack(
                face.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, 20),
                hair2.thatsStrokeColored(black).thatsFilledWith(black)),
            picStack(
                leftEye.thatsStrokeColored(black).thatsFilledWith(white).thatsScaled(1, 0.7).thatsTranslated(7, -80),
                circle.thatsScaled(0.7).thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(-21, 52))),
        picStack(
            picStack(
                leftEye.thatsStrokeColored(black).thatsFilledWith(white).thatsScaled(1, 0.7).thatsTranslated(45, -80),
                circle.thatsScaled(0.7).thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(15, 52)),
            picStack(
                nose.thatsTranslated(0, -135).thatsFilledWith(Color(219, 152, 72)).thatsStrokeColored(Color(219, 152, 72)),
                lips2.thatsFilledWith(Color(99, 0, 0)).thatsStrokeColored(brown).thatsScaled(0.7, 0.55).thatsTranslated(0, -65)))),
    picStack(
        picStack(
            muchtache.thatsScaled(0.4).thatsStrokeColored(black).thatsFilledWith(black).thatsTranslated(0, 24),
            muchtache.thatsScaled(0.4).thatsStrokeColored(black).thatsFilledWith(black).withFlippedX.thatsTranslated(0, 24)),
        picStack(
            leftEyeB.thatsStrokeSized(4).thatsStrokeColored(black).thatsTranslated(8, -137),
            leftEyeB.thatsStrokeSized(4).thatsStrokeColored(black).thatsTranslated(45, -137)))
)

def lFlower = picStack(
    picStack(
        rose1.thatsFilledWith(colorR4).thatsStrokeColored(brown).thatsScaled(0.1, 0.1).thatsTranslated(-40, 190),
        rose1.thatsFilledWith(colorR4).thatsStrokeColored(brown).thatsScaled(0.1, 0.1).thatsTranslated(-40, 200),
        rose1.thatsFilledWith(colorR4).thatsStrokeColored(brown).thatsScaled(0.1, 0.1).thatsTranslated(-34, 213)),
    picStack(
        rose1.thatsFilledWith(colorR4).thatsStrokeColored(brown).thatsScaled(0.1, 0.1).thatsTranslated(-25, 224),
        rose1.thatsFilledWith(colorR4).thatsStrokeColored(brown).thatsScaled(0.1, 0.1).thatsTranslated(-11, 229))
)

def rFlower = lFlower.withFlippedX

def headFlowers = picStack(
    lFlower,
    picStack(
        rose1.thatsFilledWith(colorR4).thatsStrokeColored(brown).thatsScaled(0.1, 0.1).thatsTranslated(0, 230),
        rFlower))

def rose1 = picStack(
    petal3.thatsStrokeSized(4).thatsRotated(-80).withFlippedX.thatsTranslated(-100, 25),
    picStack(
        picStack(
            picStack(
                petal3.thatsStrokeSized(4).thatsRotated(-154).withFlippedY.thatsTranslated(44, 60),
                petal3.thatsStrokeSized(4).thatsRotated(-180).thatsTranslated(15, -112)),
            picStack(
                petal3.thatsStrokeSized(4).thatsRotated(-80).thatsTranslated(75, 15),
                petal1.thatsStrokeSized(5).thatsScaled(0.5, 0.5).thatsRotated(180).withFlippedX)),
        picStack(
            picStack(
                petal2.thatsStrokeSized(2).thatsScaled(1.0, 1.9).thatsTranslated(34, 123),
                petal2.thatsStrokeSized(2).thatsScaled(1.0, 1.9).thatsRotated(-75).thatsTranslated(135, -20)),
            picStack(
                petal2.thatsStrokeSized(2).thatsScaled(1.0, 1.9).thatsRotated(195).thatsTranslated(-16, -150),
                petal2.thatsStrokeSized(2).thatsScaled(1.0, 1.9).thatsRotated(100).thatsTranslated(-150, 15))))
)

def earing = picStack(
    circle.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(1.5),
    picStack(
        circle.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(1.5, 1.8).thatsTranslated(0, -8),
        circle.thatsStrokeColored(orange).thatsFilledWith(yellow).thatsScaled(2.5, 1.8).thatsTranslated(0, -18))
)

def noseRing = picStack(
    picStack(
        circle.thatsScaled(5),
        circle.thatsScaled(5).thatsTranslated(15, 10)),
    picStack(
        picStack(
            circle.thatsScaled(5).thatsTranslated(35, -10),
            circle.thatsScaled(5).thatsTranslated(29, -40)),
        picStack(
            circle.thatsScaled(5).thatsTranslated(22, -60),
            lineOne.thatsStrokeSized(6).thatsScaled(1).thatsRotated(45).thatsTranslated(3, -59)))
)

def lineO = Picture.line(2, 6)

def boat = picStack(
    picStack(
        picStack(
            lineO.thatsStrokeColored(brown),
            b2.thatsStrokeColored(brown).thatsFilledWith(Color(153, 102, 0))),
        picStack(
            lineO.thatsRotated(-125).thatsScaled(30, 1).thatsStrokeColored(brown).thatsTranslated(145, -16),
            lineO.thatsRotated(-125).thatsScaled(30, 1).thatsStrokeColored(brown).thatsTranslated(132, -9))),
    picStack(
        lineO.thatsRotated(-125).thatsScaled(40, 1).thatsStrokeColored(brown).thatsTranslated(145, -5),
        b1.thatsFilledWith(gradient1).thatsStrokeColored(brown))
)

def handA = picStack(
    picStack(
        leftH3.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-35).thatsTranslated(-51, -3),
        BH1.thatsRotated(116).thatsScaled(0.7).thatsTranslated(-16, 20)),
    picStack(
        BH1.thatsRotated(113).thatsScaled(0.75).thatsTranslated(-20, 18),
        BH1.thatsRotated(116).thatsScaled(0.8).thatsTranslated(-24, 16))
)

def handB = picStack(
    picStack(
        leftH6.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-35).thatsTranslated(-51, -3),
        BH1.thatsRotated(116).thatsScaled(0.7).thatsTranslated(-16, 20)),
    picStack(
        BH1.thatsRotated(113).thatsScaled(0.75).thatsTranslated(-20, 18),
        BH1.thatsRotated(116).thatsScaled(0.8).thatsTranslated(-24, 16))
)
def hand2B = picStack(
    leftH2.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98))
        .thatsRotated(-45).thatsTranslated(-50, -10),
    handB
)
def handC = picStack(
    picStack(
        leftH8.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-2).thatsTranslated(-19, 65),
        BH1.thatsRotated(116).thatsScaled(0.8).thatsTranslated(-16, 90)),
    picStack(
        BH1.thatsRotated(113).thatsScaled(0.8).thatsTranslated(-19, 87),
        BH1.thatsRotated(116).thatsScaled(0.8).thatsTranslated(-21, 84))
)

def hand = picStack(
    leftH2.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98))
        .thatsRotated(-45).thatsTranslated(-50, -10),
    handA
)

def hand2 = picStack(
    hand2B.withFlippedX.thatsRotated(-55).thatsTranslated(-125, 85),
    rect.thatsRotated(60).thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).thatsTranslated(-44, 46)
)

def hand3 = picStack(
    leftH2.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-66).thatsTranslated(-75, -50),
)

def hand4 = picStack(
    picStack(
        picStack(
            leftH4.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)),
            rect2.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0))),
        picStack(
            leftH4.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).withFlippedX,
            rect2.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).withFlippedX)),
    picStack(
        picStack(
            BH1.thatsRotated(138).thatsTranslated(-66, 210),
            BH1.thatsRotated(138).thatsTranslated(-69, 205)),
        picStack(
            BH1.thatsRotated(138).thatsTranslated(-72, 200),
            BH1.thatsRotated(-138).thatsTranslated(66, 210))),
    picStack(
        BH1.thatsRotated(-138).thatsTranslated(69, 205),
        BH1.thatsRotated(-138).thatsTranslated(72, 200))
)

def hand5 = picStack(
    picStack(
        leftH2.thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-22).thatsTranslated(105, -10),
        leftH3.thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsTranslated(97, -1)),
    BH3.thatsTranslated(-4, 0)
)

def hand5a = picStack(
    hand5,
    hand5.withFlippedX
)

def hand5Male = picStack(
    leftH2.thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-22).thatsTranslated(105, -10),
    leftH9.thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsTranslated(97, -1),
)

def hand6 = picStack(
    picStack(
        picStack(
            rect.thatsScaled(0.5, 0.5).thatsRotated(60).thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(86, 128),
            leftH2.withFlippedX.thatsRotated(-5).thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsTranslated(25, 97)),
        picStack(
            leftH5.thatsRotated(80).thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsScaled(1, 0.7).thatsTranslated(77, 171),
            BH1.thatsRotated(120).thatsScaled(0.8).withFlippedX.thatsTranslated(54, 179))),
    picStack(
        BH1.thatsRotated(115).thatsScaled(0.8).withFlippedX.thatsTranslated(58, 177),
        BH1.thatsRotated(116).thatsScaled(0.8).withFlippedX.thatsTranslated(60, 176))
)

def hand6a = picStack(
    picStack(
        leftH5.thatsRotated(80).thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)).thatsScaled(1, 0.7).thatsTranslated(72, 170),
        BH1.thatsRotated(120).thatsScaled(0.8).withFlippedX.thatsTranslated(49, 179)),
    picStack(
        BH1.thatsRotated(115).thatsScaled(0.8).withFlippedX.thatsTranslated(54, 177),
        BH1.thatsRotated(116).thatsScaled(0.8).withFlippedX.thatsTranslated(55, 175))
)

def hand6Male = picStack(
    leftH2.thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-22).thatsTranslated(105, -10),
    leftH9.thatsScaled(1.2).thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(-130).thatsTranslated(76, -28),
)

def hand7 = picStack(
    picStack(
        picStack(
            leftH4.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)),
            rect2.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0))),
        picStack(
            rect2.thatsFilledWith(Color(209, 0, 0)).thatsStrokeColored(Color(209, 0, 0)).withFlippedX,
            BH1.thatsRotated(138).thatsTranslated(-66, 210))),
    picStack(
        BH1.thatsRotated(138).thatsTranslated(-69, 205),
        BH1.thatsRotated(138).thatsTranslated(-72, 200))
)

def hand7Male = picStack(
    leftH11.thatsScaled(1.1, 1.7).thatsStrokeColored(Color(224, 167, 98)).thatsFilledWith(Color(224, 167, 98)).thatsRotated(30).thatsTranslated(90, 48),
)

def hand8 = picStack(
    picStack(
        leftH10.thatsStrokeColored(Color(224, 177, 120)).thatsFilledWith(Color(224, 167, 98)),
        BH1.thatsScaled(0.9).thatsRotated(115).thatsTranslated(-66, 184)),
    picStack(
        BH1.thatsScaled(0.9).thatsRotated(115).thatsTranslated(-60, 186),
        BH1.thatsScaled(0.9).thatsRotated(115).thatsTranslated(-54, 189)))

def BH3 = picStack(
    picStack(
        BH1.thatsRotated(140).thatsTranslated(107, 21),
        BH1.thatsRotated(149).thatsScaled(0.9).thatsTranslated(109, 24)),
    BH1.thatsRotated(140).thatsTranslated(103, 15)
)

def boatman = picStack(
    picStack(
        picStack(
            rightHand2.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)),
            neck.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, -40)),
        picStack(
            maleB5.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)),
            maleB4.thatsFilledWith(gradient2).thatsStrokeColored(Color(0, 103, 49)))),
    picStack(
        picStack(
            maleB3.thatsFilledWith(gradient2).thatsStrokeColored(Color(0, 103, 49)),
            maleB2.thatsFilledWith(gradient3).thatsStrokeColored(Color(200, 0, 102))),
        picStack(
            maleB1.thatsFilledWith(gradient3).thatsStrokeColored(Color(176, 0, 102)),
            row.thatsFilledWith(brown).thatsStrokeColored(brown)),
        picStack(
            leftHand2.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)),
            headMale.thatsTranslated(0, 90)))
)

def boatmanB = picStack(
    picStack(
        rightHand2.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)),
        neck.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)).thatsTranslated(0, -40)),
    picStack(
        maleB5.thatsFilledWith(Color(224, 167, 98)).thatsStrokeColored(Color(224, 177, 120)),
        maleB4.thatsFilledWith(gradient2).thatsStrokeColored(Color(0, 103, 49))),
    picStack(
        maleB3.thatsFilledWith(gradient2).thatsStrokeColored(Color(0, 103, 49)),
        maleB2.thatsFilledWith(gradient3).thatsStrokeColored(Color(200, 0, 102))),
    picStack(
        maleB1.thatsFilledWith(gradient3).thatsStrokeColored(Color(176, 0, 102)),
        row.thatsFilledWith(brown).thatsStrokeColored(brown),
        headMale.thatsTranslated(0, 90))
)

def colorR4 =
    cm.linearGradient(
        -47, 0,
        Color(255, 167, 56),
        -10, 0,
        Color(255, 102, 51),
        true
    )

def gradient1 =
    cm.linearGradient(
        -10, 20,
        Color(153, 51, 0),
        -170, 10,
        Color(204, 102, 0),
        true
    )

def gradient2 =
    cm.linearGradient(
        110, 0,
        Color(21, 157, 20),
        170, 0,
        Color(21, 27, 28),
        true
    )

def gradient3 =
    cm.linearGradient(
        110, 0,
        Color(255, 0, 51),
        170, 0,
        Color(102, 0, 51),
        true
    )

def gradient4 =
    cm.linearGradient(
        -100, 0,
        Color(153, 0, 153),
        100, -100,
        Color(0, 51, 51),
        false
    )

def background1 = cm.linearMultipleGradient(
    0, 230,
    0, -230,
    Seq(0.35, 0.40, 0.50),
    Seq(Color(0, 0, 190), Color(102, 102, 255), Color(0, 0, 223)),
    false
)

def background2 = cm.linearMultipleGradient(
    -450, 0,
    300, -230,
    Seq(0.20, 0.52, 0.91),
    Seq(Color(165, 120, 29), Color(195, 169, 116), Color(249, 213, 140)),
    false
)

def moonFill = cm.radialMultipleGradient(
    0, 7,
    100,
    Seq(0.15, 0.40, 0.68),
    Seq(Color(255, 253, 236), white, Color(0, 0, 190)),
    false
)

def moon = Picture.circle(85)

def lineOne = Picture.line(5, 20)

def necklace2 = picStack(
    necklace.thatsFilledWith(yellow).thatsStrokeColored(orange), circle.thatsStrokeColored(orange).thatsFilledWith(red).thatsScaled(1.9).thatsTranslated(0, 92))

def square = Picture.rect(25, 23)

def maleB1 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(31, 69)
        x.bezierVertex(
            45, 79,
            91, 39,
            30, -25
        )
        x.bezierVertex(
            0, -25,
            0, 10,
            0, -10
        )
        x.bezierVertex(
            3, 25,
            3, 50,
            31, 69
        )
        x.bezierVertex(
            75, 79,
            65, -40,
            55, -40)
        x.bezierVertex(
            55, -40,
            95, -130,
            0, -120)
        x.bezierVertex(
            -10, -120,
            -20, -100,
            -40, -90
        )
        x.bezierVertex(
            -40, -90,
            -20, -80,
            0, -80)
        x.bezierVertex(
            -40, 0,
            -14, 71,
            34, 70
        )

        x.endShape()
}

def maleB1a = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(31, 69)
        x.bezierVertex(
            45, 79,
            91, 39,
            30, -25
        )
        x.bezierVertex(
            0, -25,
            0, 10,
            0, 10
        )
        x.bezierVertex(
            3, 25,
            3, 50,
            31, 69
        )
        x.endShape()
}

def maleB2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, 50)
        x.bezierVertex(
            0, 50,
            -25, 65,
            -26, 73
        )
        x.bezierVertex(
            -70, 50,
            -60, 20,
            -75, 0
        )
        x.bezierVertex(
            -75, 0,
            -55, -10,
            -50, -25)
        x.bezierVertex(
            -30, -25,
            -35, 0,
            -35, 0
        )
        x.bezierVertex(
            -35, 0,
            -30, -50,
            -30, -60
        )
        x.bezierVertex(
            -30, -60,
            -80, -50,
            -70, -50)
        x.bezierVertex(
            -70, -50,
            -50, -90,
            -40, -90)
        x.bezierVertex(
            -40, -90,
            0, -70,
            0, -90)
        x.endShape()
}

def maleB3 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, -120)
        x.bezierVertex(
            -105, -150,
            -220, -120,
            -106, -80)
        x.bezierVertex(
            -40, -72,
            0, -120,
            0, -120)
        x.endShape()
}

def maleB4 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-50, -80)
        x.bezierVertex(
            -100, 100,
            -150, -40,
            -150, -40)
        x.bezierVertex(
            -80, -20,
            -117, -150,
            -130, -100)
        x.endShape()
}

def maleB5 = Picture.fromPath {
    x =>
        x.moveTo(-147, -40)
        x.lineTo(-134, -126)
        x.lineTo(-100, -126)
        x.lineTo(-100, -40)
        x.closePath()

}

def row = Picture.fromPath {
    x =>
        x.moveTo(80, -250)
        x.lineTo(-200, 80)
        x.arc(-180, 70, -30)
        x.lineTo(90, -250)
}

def leftHand2 = Picture.fromPath {
    x =>
        x.moveTo(3, 2)
        x.lineTo(-10, -25)
        x.lineTo(-60, -55)
        x.arc(-75, -57, 60)
        x.arc(-60, -60, 60)
        x.arc(-80, -66, 60)
        x.arc(-65, -87, 80)
        x.arc(-50, -70, 40)
        x.lineTo(-7, -50)
        x.lineTo(30, -25)

}

def rightHand2 = Picture.fromPath {
    x =>
        x.moveTo(-70, 0)
        x.lineTo(-75, -10)
        x.lineTo(-140, 25)
        x.arc(-145, 25, 30)
        x.arc(-130, 0, 130)
        x.lineTo(-59, -40)
        x.lineTo(-50, -20)
}

def muchtache = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, 0)
        x.bezierVertex(
            20, 20,
            45, -20,
            50, 4
        )
        x.bezierVertex(
            55, -20,
            20, -6,
            0, 0
        )
        x.endShape()
}

def lips2 = Picture.fromPath {
    x =>
        x.moveTo(-12, 155)
        x.arc(0, 155, -90)
        x.arc(12, 155, -90)
        x.arc(-12, 155, -90)
}

def hair2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-38, 40)
        x.bezierVertex(
            -55, 66,
            -50, 110,
            30, 93
        )
        x.bezierVertex(
            55, 70,
            45, 50,
            34, 30
        )
        x.bezierVertex(
            30, 40,
            45, 40,
            25, 75)
        x.bezierVertex(
            -10, 70,
            -39, 72,
            -38, 40)
        x.endShape()
}

def arcO = Picture.arc(4, -180)

def circle = Picture.circle(3)
def rect = Picture.rect(32, 50)
def rect2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, 0)
        x.bezierVertex(
            -55, 20,
            -58, 70,
            -85, 130
        )
        x.bezierVertex(
            -47, 180,
            -20, 70,
            0, 0,
        )
        x.endShape()
}

def rect3 = Picture.fromPath {
    x =>
        x.moveTo(55, 100)
        x.arc(70, 75, -85)
        x.lineTo(55, 30)
        x.lineTo(25, 40)
        x.arc(55, 100, 0)
        x.closePath()
}

def face = Picture.fromPath {
    x =>
        x.moveTo(-29, 8)
        x.arc(-37, 40, -40)
        x.arc(37, 40, -175)
        x.arc(29, 8, -40)
        x.arc(-29, 8, -140)
        x.closePath()
}

def hair = Picture.fromPath {
    x =>
        x.moveTo(-37, 33)
        x.lineTo(0, 57)
        x.lineTo(37, 33)
        x.arc(-37, 33, 190)
}

def leftEyeB = Picture.fromPath {
    x =>
        x.moveTo(-40, 195)
        x.arc(-15, 195, -70)
}

def rightEyeB = leftEyeB.withFlippedX.thatsStrokeColored(brown)

def leftEye = Picture.fromPath {
    x =>
        x.moveTo(-38, 188)
        x.arc(-15, 188, -70)
        x.arc(-38, 188, -70)
}

def rightEye = leftEye.withFlippedX
def nose = Picture.fromPath {
    x =>
        x.moveTo(-2, 185)
        x.lineTo(-6, 170)
        x.arc(6, 170, 80)
        x.lineTo(2, 185)
        x.closePath()
}

def lips = Picture.fromPath {
    x =>
        x.moveTo(-15, 155)
        x.lineTo(-12, 153)
        x.arc(0, 153, -40)
        x.arc(12, 153, -40)
        x.lineTo(15, 155)
        x.arc(-15, 155, -100)
}

def leftEar = Picture.fromPath {
    x =>
        x.moveTo(-45, 188)
        x.arc(-50, 190, 140)
        x.arc(-40, 168, 100)
}

def rightEar = leftEar.withFlippedX

def petal1 = Picture.fromPath { x =>
    x.moveTo(0, 0)
    x.arc(-45, 10, 180)
    x.arc(30, 5, 185)
    x.arc(-80, -10, 200)
}

def petal2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-30, -58)
        x.bezierVertex(
            -30, -50,
            -70, -28,
            -90, -68
        )
        x.bezierVertex(
            -80, -70,
            -35, -50,
            -30, -60
        )
        x.endShape()
}

def petal3 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-20, -45)
        x.bezierVertex(
            15, 25,
            25, -25,
            75, -30
        )
        x.bezierVertex(
            125, -45,
            75, -70,
            50, -100
        )
        x.endShape()
}

def pallu1 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(24, 115)
        x.bezierVertex(
            -45, 65,
            -55, 40,
            -30, -10
        )
        x.bezierVertex(
            0, -18,
            0, -18,
            30, -10
        )
        x.bezierVertex(
            70, 90,
            63, 105,
            24, 115
        )
        x.endShape()
}

def pallu1Bor1 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(24, 115)
        x.bezierVertex(
            -45, 65,
            -55, 40,
            -30, -10
        )
        x.bezierVertex(
            -50, 40,
            -40, 65,
            24, 115
        )
        x.endShape()
}

def pallu1Bor2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(45, -17)
        x.bezierVertex(
            66, 50,
            60, 72,
            55, 100
        )
        x.bezierVertex(
            40, 112,
            40, 112,
            40, 110
        )
        x.bezierVertex(
            45, 100,
            36, 50,
            20, -17
        )
        x.endShape()
}

def lLeg = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, 0)
        x.bezierVertex(
            -50, 0,
            -60, -100,
            -15, -250
        )
        x.bezierVertex(
            30, -290,
            30, -100,
            0, 0)
        x.endShape()
}

def rLeg = lLeg.withFlippedX

def pallu2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, 0)
        x.bezierVertex(
            -50, -10,
            -43, -70,
            -42, -96)
        x.bezierVertex(
            50, -70,
            50, -50,
            50, 0)
        x.bezierVertex(
            0, 0,
            0, 0,
            0, 0)
        x.endShape()
}

def pallu2Bor1 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-35, -18)
        x.bezierVertex(
            -40, 0,
            50, 10,
            55, -20)
        x.bezierVertex(
            55, -15,
            -38, -17,
            -35, -18)
        x.endShape()
}

def pallu2Bor2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(50, 0)
        x.bezierVertex(
            60, -20,
            65, -80,
            -41, -101)

        x.bezierVertex(
            34, -80,
            35, -20,
            25, 0)
        x.endShape()
}

def leg = Picture.fromPath {
    x =>
        x.moveTo(160, -250)
        x.arc(170, -285, -40)
        x.arc(165, -284, -100)
        x.arc(160, -284, -90)
        x.arc(155, -284, -90)
        x.arc(150, -284, -90)
        x.arc(145, -284, -90)
        x.arc(135, -250, -50)
        x.lineTo(160, -250)
}

def legBor1 = Picture.fromPath {
    x =>
        x.moveTo(-20, -250)
        x.arc(2, -250, 65)
        x.arc(-20, -250, -150)
}

def body: Picture = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(50, 90)
        x.bezierVertex(
            0, -20,
            -30, -10,
            -30, -10
        )
        x.bezierVertex(
            -44, 60,
            -40, 90,
            -47, 105
        )
        x.bezierVertex(
            -40, 107,
            -30, 111,
            -20, 111)
        x.endShape()
}

def land = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-980, 0)
        x.bezierVertex(
            -550, 65,
            -180, -62,
            -190, -89,
        )
        x.bezierVertex(
            -330, -100,
            90, -250,
            550, -550
        )
        x.bezierVertex(
            -1500, -570,
            -1500, -570,
            -980, 0,
        )
        x.endShape()

}

def b1 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(0, 0)
        x.bezierVertex(
            -20, -140,
            100, -100,
            300, -40,
        )
        x.bezierVertex(
            300, -40,
            350, -10,
            350, 20)
        x.bezierVertex(
            250, -30,
            50, -50,
            0, 0)
        x.bezierVertex(
            -10, -20,
            -30, -70,
            29, -89)
        x.endShape()
}

def b2 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(20, -20)
        x.bezierVertex(
            50, -10,
            250, 40,
            350, 20
        )
        x.bezierVertex(
            350, 10,
            80, -70,
            20, -25)
        x.endShape()
}

def rightH1 = Picture.fromPath {
    x =>
        x.moveTo(56, -10)
        x.lineTo(75, -50)
        x.lineTo(38, -90)
        x.arc(48, -125, -80)
        x.arc(26, -85, -20)
        x.lineTo(42, -52)
        x.lineTo(33, -22)
}

def leftH1 = Picture.fromPath {
    x =>
        x.moveTo(-50, 54)
        x.lineTo(-12, -8)
        x.arc(40, -14, -10)
        x.arc(72, -25, -80)
        x.arc(40, -30, -30)
        x.arc(-25, -28, -10)
        x.arc(-70, 60, -30)
}

def BH1 = Picture.arc(12, 200)

def leftH2 = Picture.fromPath {
    x =>
        x.moveTo(-50, 54)
        x.lineTo(-12, -8)
        x.lineTo(-25, -28)
        x.arc(-70, 60, -30)
        x.lineTo(-50, 54)
}

def leftH3 = Picture.fromPath {
    x =>
        x.moveTo(-25, -8)
        x.arc(10, 44, -10)
        x.arc(27, 74, -100)
        x.arc(23, 40, -100)
        x.arc(-25, -28, -50)
}

def leftH4 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-77, 120)
        x.bezierVertex(
            -100, 185,
            -120, 165,
            -40, 255,
        )
        x.bezierVertex(
            22, 290,
            0, 240,
            -40, 230)
        x.bezierVertex(
            -110, 150,
            -10, 120,
            -77, 120,
        )
        x.endShape()
}

def leftH5 = Picture.fromPath {
    x =>
        x.moveTo(-25, -8)
        x.arc(10, 44, -10)
        x.arc(25, 84, -40)
        x.arc(23, 40, -60)
        x.arc(-25, -28, -50)

}

def leftH6 = Picture.fromPath {
    x =>
        x.moveTo(-25, -8)
        x.arc(10, 44, -10)
        x.arc(10, 74, -100)
        x.arc(23, 40, -100)
        x.arc(-25, -28, -50)

}

def leftH7 = Picture.fromPath {
    x =>
        x.moveTo(-50, 54)
        x.lineTo(-12, -8)
        x.arc(40, -14, -10)
        x.arc(72, -15, -30)
        x.arc(40, -29, -35)
        x.arc(-25, -28, -10)
        x.arc(-70, 60, -30)
}

def leftH8 = Picture.fromPath {
    x =>
        x.moveTo(-66, -37)
        x.arc(10, 44, -10)
        x.arc(27, 74, -100)
        x.arc(23, 40, -100)
        x.arc(-40, -40, -10)
        x.arc(-66, -37, -70)
}

def leftH9 = Picture.fromPath {
    x =>
        x.moveTo(-25, -8)
        x.arc(10, 44, -10)
        x.arc(24, 74, -30)
        x.arc(15, 60, -10)
        x.arc(32, 75, -30)
        x.arc(18, 60, -30)
        x.arc(37, 74, -30)
        x.arc(25, 60, -30)
        x.arc(38, 70, -30)
        x.arc(20, 50, -30)
        x.arc(36, 60, -30)
        x.arc(18, 40, -30)
        x.arc(-25, -28, -50)
}

def leftH10 = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-85, 132)
        x.bezierVertex(
            -110, 185,
            -110, 175,
            -40, 205,
        )
        x.bezierVertex(
            -22, 215,
            0, 225,
            10, 205)
        x.bezierVertex(
            0, 180,
            -22, 210,
            -40, 185,
        )
        x.bezierVertex(
            -40, 185,
            -90, 175,
            -60, 142,
        )
        x.endShape()
}

def leftH11 = Picture.fromPath {
    x =>
        x.moveTo(-33, -10)
        x.arc(10, 44, -10)
        x.arc(24, 74, -30)
        x.arc(15, 60, -10)
        x.arc(32, 75, -30)
        x.arc(18, 60, -30)
        x.arc(37, 74, -30)
        x.arc(25, 60, -30)
        x.arc(38, 70, -30)
        x.arc(20, 50, -30)
        x.arc(36, 60, -30)
        x.arc(18, 40, -30)
        x.arc(-25, -28, -40)
        x.arc(-25, -8, -210)
}

def necklace = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-20, 117)
        x.bezierVertex(
            -10, 90,
            10, 90,
            20, 117
        )
        x.bezierVertex(
            15, 80,
            -15, 80,
            -20, 117
        )
        x.endShape()
}

def neck = Picture.fromPath {
    x =>
        x.moveTo(-12, 145)
        x.arc(12, 145, -40)
        x.lineTo(14, 120)
        x.lineTo(30, 110)
        x.arc(-30, 110, -125)
        x.lineTo(-14, 120)
        x.lineTo(-12, 145)
}

def star = Picture.fromVertexShape { s =>
    s.beginShape()

    for {

        angle <- Seq(18, 162, 306, 90, 234, 18)

        x = 15 * Math.cos(angle.toRadians)
        y = 15 * Math.sin(angle.toRadians)

        _ = s.vertex(x, y)

    } yield {}

    s.endShape()
}

def waves = Picture.fromVertexShape {
    x =>
        x.beginShape()
        x.vertex(-100, 0)
        x.bezierVertex(
            -180, 70,
            -100, -35,
            0, -50
        )
        x.bezierVertex(
            0, -50,
            -120, -35,
            -100, 0)
        x.endShape()
}