import SwiftUI

struct ContentView: View {
   var body: some View {
       ZStack {
           LinearGradient(colors: [Color(red: 163 / 255, green: 161 / 255, blue: 228 / 255), Color(red: 255 / 255, green: 184 / 255, blue: 216 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.0), endPoint: UnitPoint(x: 0.5, y: 0.5)).ignoresSafeArea(.all)
               Limooonik()
               .scaledToFit()
               .frame(width: 150, height: 150) // your size
       }
   }
}

 struct Limooonik: View {
     
     @State private var shadowEndRadius = 450.0
     @State private var offsetAllY = 0.0
     @State private var scalePupil = 1.0
     @State private var scaleMouth = 1.1
     @State private var rotationMouth = 0.0
     @State private var offsetCheekX = 0.0
     @State private var rotationEyeRight = 0.0
     @State private var offsetHeadY = -5.0
     @State private var scaleFasteners = 1.05
     @State private var degreesEars = 0.0
      
     func move() {
         let animation = Animation.easeInOut(duration: 1.0) // your speed
         let repeated = animation.repeatForever()
         withAnimation(repeated) {
             shadowEndRadius = 200
             offsetAllY = -300
             scalePupil = 0.8
             scaleMouth = 0.7
             rotationMouth = 30.0
             offsetCheekX = 50.0
             rotationEyeRight = 40.0
             offsetHeadY = 10.0
             scaleFasteners = 0.95
             degreesEars = 30.0
         }
     }
     
     var body: some View {
         GeometryReader { geo in
             let center: CGFloat = min(geo.size.width, geo.size.height)
             let middle = center / 1000
             
             ZStack {
              
                     // shadow
                     Path { path in
                         path.addArc(center: CGPoint(x: middle * 500, y: middle * 500), radius: middle * 500, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                     }
                     .fill(RadialGradient(colors: [Color(red: 1 / 255, green: 29 / 255, blue: 43 / 255).opacity(0.6), Color(red: 136 / 255, green: 133 / 255, blue: 213 / 255).opacity(0)], center: UnitPoint(x: 0.5, y: 0.5), startRadius: middle * 0, endRadius: middle * shadowEndRadius))
                     .rotation3DEffect(.degrees(85), axis: (x: 1, y: 0, z: 0))
                     .offset(y: middle * 450)
                     
                 ZStack {
                     Group {
                         // line middle
                         Path { path in
                             path.move(to: CGPoint(x: middle * 116.555, y: middle * 242.33))
                             path.addLine(to: CGPoint(x: middle * 885.59, y: middle * 242.33))
                             path.addLine(to: CGPoint(x: middle * 885.59, y: middle * 542.33))
                             path.addLine(to: CGPoint(x: middle * 116.555, y: middle * 542.33))
                             path.addLine(to: CGPoint(x: middle * 116.555, y: middle * 242.33))
                         }
                         .fill(LinearGradient(colors: [Color(red: 1 / 255, green: 39 / 255, blue: 83 / 255), Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), Color(red: 95 / 255, green: 186 / 255, blue: 143 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.375), endPoint: UnitPoint(x: 0.5, y: 0.405)))
                         
                         // head top
                         Path { path in
                             path.move(to: CGPoint(x: middle * 93.048, y: middle * 376.819))
                             path.addCurve(to: CGPoint(x: middle * 86.639, y: middle * 370.41), control1: CGPoint(x: middle * 89.509, y: middle * 376.819), control2: CGPoint(x: middle * 86.639, y: middle * 373.949))
                             path.addLine(to: CGPoint(x: middle * 86.639, y: middle * 283.937))
                             path.addCurve(to: CGPoint(x: middle * 309.757, y: middle * 68.819), control1: CGPoint(x: middle * 86.639, y: middle * 160.712), control2: CGPoint(x: middle * 165.216, y: middle * 84.325))
                             path.addCurve(to: CGPoint(x: middle * 694.85, y: middle * 67.819), control1: CGPoint(x: middle * 415.959, y: middle * 57.425), control2: CGPoint(x: middle * 599.941, y: middle * 59.578))
                             path.addCurve(to: CGPoint(x: middle * 917.639, y: middle * 287.599), control1: CGPoint(x: middle * 829.753, y: middle * 79.53), control2: CGPoint(x: middle * 917.639, y: middle * 162.352))
                             path.addLine(to: CGPoint(x: middle * 917.639, y: middle * 370.41))
                             path.addCurve(to: CGPoint(x: middle * 911.23, y: middle * 376.819), control1: CGPoint(x: middle * 917.639, y: middle * 373.949), control2: CGPoint(x: middle * 914.77, y: middle * 376.819))
                             path.addLine(to: CGPoint(x: middle * 93.048, y: middle * 376.819))
                             
                         }
                         .fill(LinearGradient(colors: [Color(red: 161 / 255, green: 255 / 255, blue: 220 / 255), Color(red: 117 / 255, green: 195 / 255, blue: 155 / 255), Color(red: 82 / 255, green: 175 / 255, blue: 135 / 255), Color(red: 56 / 255, green: 119 / 255, blue: 139 / 255), Color(red: 91 / 255, green: 101 / 255, blue: 207 / 255)], startPoint: UnitPoint(x: 0.263, y: 0.172), endPoint: UnitPoint(x: 0.957, y: 0.384)).shadow(.inner(color: Color(red: 82 / 255, green: 175 / 255, blue: 135 / 255), radius: middle * 10, x: middle * 5, y: middle * -5)))
                         .offset(y: middle * -offsetHeadY)
                         
                         // head bottom
                         Path { path in
                             path.move(to: CGPoint(x: middle * 86.553, y: middle * 445.56))
                             path.addCurve(to: CGPoint(x: middle * 125.222, y: middle * 406.89), control1: CGPoint(x: middle * 86.553, y: middle * 424.212), control2: CGPoint(x: middle * 103.866, y: middle * 406.89))
                             path.addLine(to: CGPoint(x: middle * 877.884, y: middle * 406.89))
                             path.addCurve(to: CGPoint(x: middle * 916.553, y: middle * 445.56), control1: CGPoint(x: middle * 899.24, y: middle * 406.89), control2: CGPoint(x: middle * 916.553, y: middle * 424.212))
                             path.addLine(to: CGPoint(x: middle * 916.553, y: middle * 645.767))
                             path.addCurve(to: CGPoint(x: middle * 626.421, y: middle * 935.89), control1: CGPoint(x: middle * 916.553, y: middle * 806), control2: CGPoint(x: middle * 786.657, y: middle * 935.89))
                             path.addLine(to: CGPoint(x: middle * 376.685, y: middle * 935.89))
                             path.addCurve(to: CGPoint(x: middle * 86.553, y: middle * 645.767), control1: CGPoint(x: middle * 216.45, y: middle * 935.89), control2: CGPoint(x: middle * 86.553, y: middle * 806))
                             path.addLine(to: CGPoint(x: middle * 86.553, y: middle * 445.56))
                         }
                         .fill(LinearGradient(colors: [Color(red: 161 / 255, green: 255 / 255, blue: 220 / 255), Color(red: 117 / 255, green: 195 / 255, blue: 155 / 255), Color(red: 82 / 255, green: 175 / 255, blue: 135 / 255), Color(red: 56 / 255, green: 119 / 255, blue: 139 / 255), Color(red: 91 / 255, green: 101 / 255, blue: 207 / 255)], startPoint: UnitPoint(x: 0.201, y: 0.455), endPoint: UnitPoint(x: 0.966, y: 0.889)).shadow(.inner(color: Color(red: 225 / 255, green: 255 / 255, blue: 225 / 255), radius: middle * 10, x: middle * 5, y: middle * 10)))
                         .offset(y: middle * offsetHeadY)
                         
                         // hair
                         Path { path in
                             path.move(to: CGPoint(x: middle * 257.03, y: middle * 82.446))
                             path.addCurve(to: CGPoint(x: middle * 745.122, y: middle * 82.446), control1: CGPoint(x: middle * 260.227, y: middle * 50.894), control2: CGPoint(x: middle * 741.925, y: middle * 50.894))
                             path.addQuadCurve(to: CGPoint(x: middle * 745.445, y: middle * 96.648), control: CGPoint(x: middle * 745.313, y: middle * 83.899))
                             path.addCurve(to: CGPoint(x: middle * 703.433, y: middle * 129.983), control1: CGPoint(x: middle * 745.445, y: middle * 118.011), control2: CGPoint(x: middle * 725.599, y: middle * 134.965))
                             path.addQuadCurve(to: CGPoint(x: middle * 677.021, y: middle * 91.668), control: CGPoint(x: middle * 675.192, y: middle * 123.636))
                             path.addCurve(to: CGPoint(x: middle * 661.382, y: middle * 91.668), control1: CGPoint(x: middle * 677.022, y: middle * 86.946), control2: CGPoint(x: middle * 661.382, y: middle * 87.041))
                             path.addQuadCurve(to: CGPoint(x: middle * 619.371, y: middle * 129.983), control: CGPoint(x: middle * 660.74, y: middle * 139.282))
                             path.addQuadCurve(to: CGPoint(x: middle * 592.959, y: middle * 91.668), control: CGPoint(x: middle * 591.13, y: middle * 123.637))
                             path.addCurve(to: CGPoint(x: middle * 577.319, y: middle * 91.668), control1: CGPoint(x: middle * 592.959, y: middle * 86.946), control2: CGPoint(x: middle * 577.319, y: middle * 87.041))
                             path.addQuadCurve(to: CGPoint(x: middle * 543.108, y: middle * 130.859), control: CGPoint(x: middle * 578.74, y: middle * 130.859))
                             path.addQuadCurve(to: CGPoint(x: middle * 508.89, y: middle * 91.668), control: CGPoint(x: middle * 507.216, y: middle * 130.859))
                             path.addCurve(to: CGPoint(x: middle * 493.257, y: middle * 91.668), control1: CGPoint(x: middle * 508.89, y: middle * 86.946), control2: CGPoint(x: middle * 493.257, y: middle * 87.041))
                             path.addQuadCurve(to: CGPoint(x: middle * 459.04, y: middle * 130.859), control: CGPoint(x: middle * 494.67, y: middle * 130.859))
                             path.addQuadCurve(to: CGPoint(x: middle * 424.833, y: middle * 91.668), control: CGPoint(x: middle * 423.154, y: middle * 130.859))
                             path.addCurve(to: CGPoint(x: middle * 409.194, y: middle * 91.668), control1: CGPoint(x: middle * 424.833, y: middle * 86.946), control2: CGPoint(x: middle * 409.194, y: middle * 87.041))
                             path.addQuadCurve(to: CGPoint(x: middle * 367.182, y: middle * 129.983), control: CGPoint(x: middle * 408.55, y: middle * 139.283))
                             path.addQuadCurve(to: CGPoint(x: middle * 340.77, y: middle * 91.668), control: CGPoint(x: middle * 338.941, y: middle * 123.636))
                             path.addCurve(to: CGPoint(x: middle * 325.131, y: middle * 91.668), control1: CGPoint(x: middle * 340.77, y: middle * 86.946), control2: CGPoint(x: middle * 325.131, y: middle * 87.041))
                             path.addQuadCurve(to: CGPoint(x: middle * 283.119, y: middle * 129.983), control: CGPoint(x: middle * 324.49, y: middle * 139.283))
                             path.addCurve(to: CGPoint(x: middle * 256.7, y: middle * 95.503), control1: CGPoint(x: middle * 267.372, y: middle * 126.444), control2: CGPoint(x: middle * 256.7, y: middle * 111.643))
                             path.addQuadCurve(to: CGPoint(x: middle * 257.03, y: middle * 82.446), control: CGPoint(x: middle * 256.5, y: middle * 87.637))
                         }
                         .fill(LinearGradient(colors: [Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255), Color(red: 83 / 255, green: 71 / 255, blue: 65 / 255), Color(red: 0 / 255, green: 0 / 255, blue: 0 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.01), endPoint: UnitPoint(x: 0.5, y: 0.127)).shadow(.drop(color: Color(red: 42 / 255, green: 78 / 255, blue: 52 / 255), radius: middle * 10, x: middle * 0, y: middle * 15)))
                         .offset(y: middle * -offsetHeadY)
                         
                         // left ear round
                         Path { path in
                             path.move(to: CGPoint(x: middle * 108.708, y: middle * 214.383))
                             path.addCurve(to: CGPoint(x: middle * 156.093, y: middle * 187.58), control1: CGPoint(x: middle * 117.72, y: middle * 192.51), control2: CGPoint(x: middle * 138.935, y: middle * 180.51))
                             path.addCurve(to: CGPoint(x: middle * 170.841, y: middle * 239.984), control1: CGPoint(x: middle * 173.25, y: middle * 194.65), control2: CGPoint(x: middle * 179.853, y: middle * 218.112))
                             path.addCurve(to: CGPoint(x: middle * 123.456, y: middle * 266.78), control1: CGPoint(x: middle * 161.828, y: middle * 261.857), control2: CGPoint(x: middle * 140.613, y: middle * 273.857))
                             path.addCurve(to: CGPoint(x: middle * 108.708, y: middle * 214.383), control1: CGPoint(x: middle * 106.298, y: middle * 259.718), control2: CGPoint(x: middle * 99.965, y: middle * 236.25))
                         }
                         .fill(LinearGradient(colors: [ Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255), Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255).opacity(0)], startPoint: UnitPoint(x: 0.137, y: 0.178), endPoint: UnitPoint(x: 0.143, y: 0.271)))
                         
                         // right ear round
                         Path { path in
                             path.move(to: CGPoint(x: middle * 830.661, y: middle * 239.984))
                             path.addCurve(to: CGPoint(x: middle * 845.4, y: middle * 187.58), control1: CGPoint(x: middle * 821.648, y: middle * 218.112), control2: CGPoint(x: middle * 828.251, y: middle * 194.65))
                             path.addCurve(to: CGPoint(x: middle * 892.793, y: middle * 214.383), control1: CGPoint(x: middle * 862.56, y: middle * 180.51), control2: CGPoint(x: middle * 883.781, y: middle * 192.51))
                             path.addCurve(to: CGPoint(x: middle * 878.04, y: middle * 266.78), control1: CGPoint(x: middle * 901.806, y: middle * 236.25), control2: CGPoint(x: middle * 895.2, y: middle * 259.718))
                             path.addCurve(to: CGPoint(x: middle * 830.661, y: middle * 239.984), control1: CGPoint(x: middle * 860.88, y: middle * 273.857), control2: CGPoint(x: middle * 839.673, y: middle * 261.857))
                         }
                         .fill(LinearGradient(colors: [ Color(red: 2 / 255, green: 38 / 255, blue: 22 / 255), Color(red: 2 / 255, green: 71 / 255, blue: 39 / 255), Color(red: 2 / 255, green: 71 / 255, blue: 39 / 255).opacity(0)], startPoint: UnitPoint(x: 0.865, y: 0.176), endPoint: UnitPoint(x: 0.863, y: 0.274)))
                     }
                     
                     // left ear
                     ZStack {
                         Group {
                             // left ear part 1
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 25.157, y: middle * 213.732))
                                 path.addCurve(to: CGPoint(x: middle * 22.609, y: middle * 208.5), control1: CGPoint(x: middle * 23.01, y: middle * 212.992), control2: CGPoint(x: middle * 21.869, y: middle * 210.652))
                                 path.addLine(to: CGPoint(x: middle * 41.976, y: middle * 152.296))
                                 path.addCurve(to: CGPoint(x: middle * 47.203, y: middle * 149.747), control1: CGPoint(x: middle * 42.716, y: middle * 150.148), control2: CGPoint(x: middle * 45.056, y: middle * 149.008))
                                 path.addLine(to: CGPoint(x: middle * 171.901, y: middle * 192.712))
                                 path.addCurve(to: CGPoint(x: middle * 175.309, y: middle * 199.703), control1: CGPoint(x: middle * 174.773, y: middle * 193.701), control2: CGPoint(x: middle * 176.299, y: middle * 196.831))
                                 path.addLine(to: CGPoint(x: middle * 156.847, y: middle * 253.288))
                                 path.addCurve(to: CGPoint(x: middle * 149.855, y: middle * 256.69), control1: CGPoint(x: middle * 155.857, y: middle * 256.159), control2: CGPoint(x: middle * 152.727, y: middle * 257.685))
                                 path.addLine(to: CGPoint(x: middle * 25.157, y: middle * 213.732))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255), Color(red: 95 / 255, green: 186 / 255, blue: 143 / 255)], startPoint: UnitPoint(x: 0.115, y: 0.173), endPoint: UnitPoint(x: 0.091, y: 0.236)))
                             
                             // left ear part 2
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 63.645, y: middle * 226.785))
                                 path.addCurve(to: CGPoint(x: middle * 47.968, y: middle * 194.626), control1: CGPoint(x: middle * 50.436, y: middle * 222.23), control2: CGPoint(x: middle * 43.416, y: middle * 207.836))
                                 path.addLine(to: CGPoint(x: middle * 53.531, y: middle * 178.479))
                                 path.addCurve(to: CGPoint(x: middle * 85.691, y: middle * 162.801), control1: CGPoint(x: middle * 58.082, y: middle * 165.269), control2: CGPoint(x: middle * 72.481, y: middle * 158.25))
                                 path.addLine(to: CGPoint(x: middle * 125.195, y: middle * 176.412))
                                 path.addLine(to: CGPoint(x: middle * 112.701, y: middle * 243.88))
                                 path.addLine(to: CGPoint(x: middle * 63.645, y: middle * 226.785))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255).opacity(0)], startPoint: UnitPoint(x: 0.055, y: 0.196), endPoint: UnitPoint(x: 0.122, y: 0.2)))
                             
                             // left ear part 3
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 11.769, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 44.709, y: middle * 182.117), control1: CGPoint(x: middle * 18.407, y: middle * 242.261), control2: CGPoint(x: middle * 32.877, y: middle * 216.266))
                                 path.addCurve(to: CGPoint(x: middle * 55.769, y: middle * 113.802), control1: CGPoint(x: middle * 56.8, y: middle * 147.043), control2: CGPoint(x: middle * 61.497, y: middle * 117.319))
                                 path.addLine(to: CGPoint(x: middle * 97.167, y: middle * 128.332))
                                 path.addCurve(to: CGPoint(x: middle * 85.646, y: middle * 195.529), control1: CGPoint(x: middle * 101.839, y: middle * 133.744), control2: CGPoint(x: middle * 97.029, y: middle * 162.491))
                                 path.addCurve(to: CGPoint(x: middle * 53.331, y: middle * 255.561), control1: CGPoint(x: middle * 74.262, y: middle * 228.567), control2: CGPoint(x: middle * 60.345, y: middle * 254.176))
                                 path.addLine(to: CGPoint(x: middle * 11.769, y: middle * 241.508))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255)], startPoint: UnitPoint(x: 0.055, y: 0.115), endPoint: UnitPoint(x: 0.057, y: 0.178)))
                             
                             // left ear part 4
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 11.769, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 44.709, y: middle * 182.117), control1: CGPoint(x: middle * 18.407, y: middle * 242.261), control2: CGPoint(x: middle * 32.877, y: middle * 216.266))
                                 path.addLine(to: CGPoint(x: middle * 89.867, y: middle * 182.48))
                                 path.addCurve(to: CGPoint(x: middle * 85.646, y: middle * 195.529), control1: CGPoint(x: middle * 88.58, y: middle * 186.725), control2: CGPoint(x: middle * 87.178, y: middle * 191.082))
                                 path.addCurve(to: CGPoint(x: middle * 53.331, y: middle * 255.561), control1: CGPoint(x: middle * 74.262, y: middle * 228.567), control2: CGPoint(x: middle * 60.345, y: middle * 254.176))
                                 path.addLine(to: CGPoint(x: middle * 11.769, y: middle * 241.508))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 95 / 255, green: 186 / 255, blue: 143 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255).opacity(0)], startPoint: UnitPoint(x: 0.043, y: 0.238), endPoint: UnitPoint(x: 0.065, y: 0.184)))
                             
                             // left ear part 5
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 11.769, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 44.709, y: middle * 182.117), control1: CGPoint(x: middle * 18.407, y: middle * 242.261), control2: CGPoint(x: middle * 32.877, y: middle * 216.266))
                                 path.addCurve(to: CGPoint(x: middle * 55.769, y: middle * 113.802), control1: CGPoint(x: middle * 56.8, y: middle * 147.043), control2: CGPoint(x: middle * 61.497, y: middle * 117.319))
                                 path.addCurve(to: CGPoint(x: middle * 21.661, y: middle * 173.483), control1: CGPoint(x: middle * 46.962, y: middle * 114.836), control2: CGPoint(x: middle * 33.044, y: middle * 140.445))
                                 path.addCurve(to: CGPoint(x: middle * 11.769, y: middle * 241.508), control1: CGPoint(x: middle * 10.278, y: middle * 206.521), control2: CGPoint(x: middle * 5.467, y: middle * 235.26))
                             }
                             .fill(Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255))
                             
                             // left ear part 6
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 11.769, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 44.709, y: middle * 182.117), control1: CGPoint(x: middle * 18.407, y: middle * 242.261), control2: CGPoint(x: middle * 32.877, y: middle * 216.266))
                                 path.addCurve(to: CGPoint(x: middle * 55.769, y: middle * 113.802), control1: CGPoint(x: middle * 56.8, y: middle * 147.043), control2: CGPoint(x: middle * 61.497, y: middle * 117.319))
                                 path.addCurve(to: CGPoint(x: middle * 21.661, y: middle * 173.483), control1: CGPoint(x: middle * 46.962, y: middle * 114.836), control2: CGPoint(x: middle * 33.044, y: middle * 140.445))
                                 path.addCurve(to: CGPoint(x: middle * 11.769, y: middle * 241.508), control1: CGPoint(x: middle * 10.278, y: middle * 206.521), control2: CGPoint(x: middle * 5.467, y: middle * 235.26))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255).opacity(0)], startPoint: UnitPoint(x: 0.01, y: 0.176), endPoint: UnitPoint(x: 0.058, y: 0.178)))
                         }
                     }
                     .rotationEffect(.degrees(degreesEars), anchor: UnitPoint(x: 0.15, y: 0.2))
                     
                     // right ear
                     ZStack {
                         Group {
                             // right ear part 1
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 976.34, y: middle * 213.732))
                                 path.addCurve(to: CGPoint(x: middle * 978.892, y: middle * 208.5), control1: CGPoint(x: middle * 978.491, y: middle * 212.992), control2: CGPoint(x: middle * 979.632, y: middle * 210.652))
                                 path.addLine(to: CGPoint(x: middle * 959.526, y: middle * 152.296))
                                 path.addCurve(to: CGPoint(x: middle * 954.29, y: middle * 149.747), control1: CGPoint(x: middle * 958.78, y: middle * 150.148), control2: CGPoint(x: middle * 956.44, y: middle * 149.008))
                                 path.addLine(to: CGPoint(x: middle * 829.601, y: middle * 192.712))
                                 path.addCurve(to: CGPoint(x: middle * 826.192, y: middle * 199.703), control1: CGPoint(x: middle * 826.729, y: middle * 193.701), control2: CGPoint(x: middle * 825.2, y: middle * 196.831))
                                 path.addLine(to: CGPoint(x: middle * 844.65, y: middle * 253.288))
                                 path.addCurve(to: CGPoint(x: middle * 851.646, y: middle * 256.69), control1: CGPoint(x: middle * 845.64, y: middle * 256.159), control2: CGPoint(x: middle * 848.774, y: middle * 257.685))
                                 path.addLine(to: CGPoint(x: middle * 976.34, y: middle * 213.732))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255), Color(red: 77 / 255, green: 86 / 255, blue: 170 / 255)], startPoint: UnitPoint(x: 0.891, y: 0.173), endPoint: UnitPoint(x: 0.914, y: 0.236)))
                             
                             // right ear part 2
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 937.856, y: middle * 226.785))
                                 path.addCurve(to: CGPoint(x: middle * 953.53, y: middle * 194.626), control1: CGPoint(x: middle * 951.066, y: middle * 222.23), control2: CGPoint(x: middle * 958.08, y: middle * 207.836))
                                 path.addLine(to: CGPoint(x: middle * 947.97, y: middle * 178.479))
                                 path.addCurve(to: CGPoint(x: middle * 915.81, y: middle * 162.801), control1: CGPoint(x: middle * 943.419, y: middle * 165.269), control2: CGPoint(x: middle * 929.02, y: middle * 158.25))
                                 path.addLine(to: CGPoint(x: middle * 876.3, y: middle * 176.412))
                                 path.addLine(to: CGPoint(x: middle * 888.801, y: middle * 243.88))
                                 path.addLine(to: CGPoint(x: middle * 937.856, y: middle * 226.785))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 136 / 255, green: 133 / 255, blue: 213 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255).opacity(0)], startPoint: UnitPoint(x: 0.936, y: 0.192), endPoint: UnitPoint(x: 0.86, y: 0.21)))
                             
                             // right ear part 3
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 989.733, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 956.57, y: middle * 182.117), control1: CGPoint(x: middle * 983.05, y: middle * 242.261), control2: CGPoint(x: middle * 968.44, y: middle * 216.266))
                                 path.addCurve(to: CGPoint(x: middle * 945.732, y: middle * 113.802), control1: CGPoint(x: middle * 944.701, y: middle * 147.043), control2: CGPoint(x: middle * 940, y: middle * 117.319))
                                 path.addLine(to: CGPoint(x: middle * 904.33, y: middle * 128.332))
                                 path.addCurve(to: CGPoint(x: middle * 915.856, y: middle * 195.529), control1: CGPoint(x: middle * 899.66, y: middle * 133.744), control2: CGPoint(x: middle * 904.47, y: middle * 162.491))
                                 path.addCurve(to: CGPoint(x: middle * 948.171, y: middle * 255.561), control1: CGPoint(x: middle * 927.239, y: middle * 228.567), control2: CGPoint(x: middle * 941.157, y: middle * 254.176))
                                 path.addLine(to: CGPoint(x: middle * 989.733, y: middle * 241.508))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255)], startPoint: UnitPoint(x: 0.945, y: 0.115), endPoint: UnitPoint(x: 0.943, y: 0.178)))
                             
                             // right ear part 4
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 989.733, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 956.57, y: middle * 182.117), control1: CGPoint(x: middle * 983.05, y: middle * 242.261), control2: CGPoint(x: middle * 968.44, y: middle * 216.266))
                                 path.addLine(to: CGPoint(x: middle * 911.635, y: middle * 182.48))
                                 path.addCurve(to: CGPoint(x: middle * 915.856, y: middle * 195.529), control1: CGPoint(x: middle * 912.922, y: middle * 186.725), control2: CGPoint(x: middle * 914.324, y: middle * 191.082))
                                 path.addCurve(to: CGPoint(x: middle * 948.171, y: middle * 255.561), control1: CGPoint(x: middle * 927.239, y: middle * 228.567), control2: CGPoint(x: middle * 941.157, y: middle * 254.176))
                                 path.addLine(to: CGPoint(x: middle * 989.733, y: middle * 241.508))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 136 / 255, green: 133 / 255, blue: 213 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255).opacity(0)], startPoint: UnitPoint(x: 0.952, y: 0.242), endPoint: UnitPoint(x: 0.947, y: 0.197)))
                             
                             // right ear part 5
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 989.733, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 956.57, y: middle * 182.117), control1: CGPoint(x: middle * 983.05, y: middle * 242.261), control2: CGPoint(x: middle * 968.44, y: middle * 216.266))
                                 path.addCurve(to: CGPoint(x: middle * 945.732, y: middle * 113.802), control1: CGPoint(x: middle * 944.701, y: middle * 147.043), control2: CGPoint(x: middle * 940, y: middle * 117.319))
                                 path.addCurve(to: CGPoint(x: middle * 979.84, y: middle * 173.483), control1: CGPoint(x: middle * 954.53, y: middle * 114.836), control2: CGPoint(x: middle * 968.45, y: middle * 140.445))
                                 path.addCurve(to: CGPoint(x: middle * 989.733, y: middle * 241.508), control1: CGPoint(x: middle * 991.224, y: middle * 206.521), control2: CGPoint(x: middle * 996.03, y: middle * 235.26))
                             }
                             .fill(Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255))
                             
                             // right ear part 6
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 989.733, y: middle * 241.508))
                                 path.addCurve(to: CGPoint(x: middle * 956.57, y: middle * 182.117), control1: CGPoint(x: middle * 983.05, y: middle * 242.261), control2: CGPoint(x: middle * 968.44, y: middle * 216.266))
                                 path.addCurve(to: CGPoint(x: middle * 945.732, y: middle * 113.802), control1: CGPoint(x: middle * 944.701, y: middle * 147.043), control2: CGPoint(x: middle * 940, y: middle * 117.319))
                                 path.addCurve(to: CGPoint(x: middle * 979.84, y: middle * 173.483), control1: CGPoint(x: middle * 954.53, y: middle * 114.836), control2: CGPoint(x: middle * 968.45, y: middle * 140.445))
                                 path.addCurve(to: CGPoint(x: middle * 989.733, y: middle * 241.508), control1: CGPoint(x: middle * 991.224, y: middle * 206.521), control2: CGPoint(x: middle * 996.03, y: middle * 235.26))
                             }
                             .fill(LinearGradient(colors: [ Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255).opacity(0)], startPoint: UnitPoint(x: 0.938, y: 0.167), endPoint: UnitPoint(x: 0.991, y: 0.170)))
                         }
                     }
                     .rotationEffect(.degrees(-degreesEars), anchor: UnitPoint(x: 0.85, y: 0.2))
                     
                     // fasteners
                     ZStack {
                     Group {
                         // fastener left 1-1
                         Path { path in
                             path.move(to: CGPoint(x: middle * 208.84, y: middle * 416.918))
                             path.addCurve(to: CGPoint(x: middle * 224.24, y: middle * 432.324), control1: CGPoint(x: middle * 208.84, y: middle * 425.42), control2: CGPoint(x: middle * 215.738, y: middle * 432.324))
                             path.addLine(to: CGPoint(x: middle * 254.957, y: middle * 432.324))
                             path.addCurve(to: CGPoint(x: middle * 270.363, y: middle * 416.918), control1: CGPoint(x: middle * 263.46, y: middle * 432.324), control2: CGPoint(x: middle * 270.363, y: middle * 425.42))
                             path.addLine(to: CGPoint(x: middle * 270.363, y: middle * 330))
                             path.addLine(to: CGPoint(x: middle * 208.84, y: middle * 330))
                             path.addLine(to: CGPoint(x: middle * 208.84, y: middle * 416.918))
                         }
                         .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255)], startPoint: UnitPoint(x: 0.208, y: 0.5), endPoint: UnitPoint(x: 0.27, y: 0.5)).shadow(.drop(color: Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), radius: middle * 7, x: middle * 10, y: middle * 10)))
                         
                         // fastener left 1-2
                         Path { path in
                             path.move(to: CGPoint(x: middle * 208.84, y: middle * 416.918))
                             path.addCurve(to: CGPoint(x: middle * 224.24, y: middle * 432.324), control1: CGPoint(x: middle * 208.84, y: middle * 425.42), control2: CGPoint(x: middle * 215.738, y: middle * 432.324))
                             path.addLine(to: CGPoint(x: middle * 254.957, y: middle * 432.324))
                             path.addCurve(to: CGPoint(x: middle * 270.363, y: middle * 416.918), control1: CGPoint(x: middle * 263.46, y: middle * 432.324), control2: CGPoint(x: middle * 270.363, y: middle * 425.42))
                             path.addLine(to: CGPoint(x: middle * 270.363, y: middle * 381.573))
                             path.addLine(to: CGPoint(x: middle * 208.84, y: middle * 381.642))
                             path.addLine(to: CGPoint(x: middle * 208.84, y: middle * 416.918))
                         }
                         .fill(LinearGradient(colors: [ Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255).opacity(0), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.384), endPoint: UnitPoint(x: 0.5, y: 0.432)))
                         
                         // fastener 2-1
                         Path { path in
                             path.move(to: CGPoint(x: middle * 393.38, y: middle * 423.13))
                             path.addCurve(to: CGPoint(x: middle * 407.973, y: middle * 432.661), control1: CGPoint(x: middle * 394.778, y: middle * 429.792), control2: CGPoint(x: middle * 401.312, y: middle * 434.05))
                             path.addLine(to: CGPoint(x: middle * 432.018, y: middle * 427.616))
                             path.addCurve(to: CGPoint(x: middle * 441.55, y: middle * 413.022), control1: CGPoint(x: middle * 438.68, y: middle * 426.218), control2: CGPoint(x: middle * 442.94, y: middle * 419.684))
                             path.addLine(to: CGPoint(x: middle * 427.412, y: middle * 345.64))
                             path.addLine(to: CGPoint(x: middle * 379.242, y: middle * 355.754))
                             path.addLine(to: CGPoint(x: middle * 393.38, y: middle * 423.13))
                         }
                         .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255)], startPoint: UnitPoint(x: 0.387, y: 0.393), endPoint: UnitPoint(x: 0.434, y: 0.382)).shadow(.drop(color: Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), radius: middle * 6, x: middle * 10, y: middle * 10)))
                         
                         // fastener 2-2
                         Path { path in
                             path.move(to: CGPoint(x: middle * 393.38, y: middle * 423.13))
                             path.addCurve(to: CGPoint(x: middle * 407.973, y: middle * 432.661), control1: CGPoint(x: middle * 394.778, y: middle * 429.792), control2: CGPoint(x: middle * 401.312, y: middle * 434.05))
                             path.addLine(to: CGPoint(x: middle * 432.018, y: middle * 427.616))
                             path.addCurve(to: CGPoint(x: middle * 441.55, y: middle * 413.022), control1: CGPoint(x: middle * 438.68, y: middle * 426.218), control2: CGPoint(x: middle * 442.94, y: middle * 419.684))
                             path.addLine(to: CGPoint(x: middle * 435.743, y: middle * 385.34))
                             path.addLine(to: CGPoint(x: middle * 387.584, y: middle * 395.511))
                             path.addLine(to: CGPoint(x: middle * 393.38, y: middle * 423.13))
                         }
                         .fill(LinearGradient(colors: [ Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255).opacity(0), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255)], startPoint: UnitPoint(x: 0.41, y: 0.395), endPoint: UnitPoint(x: 0.42, y: 0.43)))
                         
                         // fastener left 3-1
                         Path { path in
                             path.move(to: CGPoint(x: middle * 559.523, y: middle * 416.918))
                             path.addCurve(to: CGPoint(x: middle * 574.93, y: middle * 432.324), control1: CGPoint(x: middle * 559.523, y: middle * 425.42), control2: CGPoint(x: middle * 566.421, y: middle * 432.324))
                             path.addLine(to: CGPoint(x: middle * 605.641, y: middle * 432.324))
                             path.addCurve(to: CGPoint(x: middle * 621.047, y: middle * 416.918), control1: CGPoint(x: middle * 614.149, y: middle * 432.324), control2: CGPoint(x: middle * 621.047, y: middle * 425.42))
                             path.addLine(to: CGPoint(x: middle * 621.047, y: middle * 330))
                             path.addLine(to: CGPoint(x: middle * 559.523, y: middle * 330))
                             path.addLine(to: CGPoint(x: middle * 559.523, y: middle * 416.918))
                         }
                         .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255)], startPoint: UnitPoint(x: 0.559, y: 0.5), endPoint: UnitPoint(x: 0.621, y: 0.5)).shadow(.drop(color: Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), radius: middle * 7, x: middle * 10, y: middle * 10)))
                         
                         // fastener left 3-2
                         Path { path in
                             path.move(to: CGPoint(x: middle * 559.523, y: middle * 416.918))
                             path.addCurve(to: CGPoint(x: middle * 574.93, y: middle * 432.324), control1: CGPoint(x: middle * 559.523, y: middle * 425.42), control2: CGPoint(x: middle * 566.421, y: middle * 432.324))
                             path.addLine(to: CGPoint(x: middle * 605.641, y: middle * 432.324))
                             path.addCurve(to: CGPoint(x: middle * 621.047, y: middle * 416.918), control1: CGPoint(x: middle * 614.149, y: middle * 432.324), control2: CGPoint(x: middle * 621.047, y: middle * 425.42))
                             path.addLine(to: CGPoint(x: middle * 621.047, y: middle * 381.573))
                             path.addLine(to: CGPoint(x: middle * 559.523, y: middle * 381.642))
                             path.addLine(to: CGPoint(x: middle * 559.523, y: middle * 416.918))
                         }
                         .fill(LinearGradient(colors: [ Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255).opacity(0), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.384), endPoint: UnitPoint(x: 0.5, y: 0.432)))
                         
                         // fastener 4-1
                         Path { path in
                             path.move(to: CGPoint(x: middle * 728.993, y: middle * 411.448))
                             path.addCurve(to: CGPoint(x: middle * 738.526, y: middle * 426.04), control1: CGPoint(x: middle * 727.596, y: middle * 418.11), control2: CGPoint(x: middle * 731.864, y: middle * 424.64))
                             path.addLine(to: CGPoint(x: middle * 762.572, y: middle * 431.081))
                             path.addCurve(to: CGPoint(x: middle * 777.164, y: middle * 421.548), control1: CGPoint(x: middle * 769.234, y: middle * 432.478), control2: CGPoint(x: middle * 775.767, y: middle * 428.21))
                             path.addLine(to: CGPoint(x: middle * 791.291, y: middle * 354.17))
                             path.addLine(to: CGPoint(x: middle * 743.12, y: middle * 344.07))
                             path.addLine(to: CGPoint(x: middle * 728.993, y: middle * 411.448))
                         }
                         .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255), Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255)], startPoint: UnitPoint(x: 0.735, y: 0.382), endPoint: UnitPoint(x: 0.782, y: 0.393)).shadow(.drop(color: Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), radius: middle * 6, x: middle * 10, y: middle * 10)))
                         
                         // fastener 4-2
                         Path { path in
                             path.move(to: CGPoint(x: middle * 728.993, y: middle * 411.448))
                             path.addCurve(to: CGPoint(x: middle * 738.526, y: middle * 426.04), control1: CGPoint(x: middle * 727.596, y: middle * 418.11), control2: CGPoint(x: middle * 731.864, y: middle * 424.64))
                             path.addLine(to: CGPoint(x: middle * 762.572, y: middle * 431.081))
                             path.addCurve(to: CGPoint(x: middle * 777.164, y: middle * 421.548), control1: CGPoint(x: middle * 769.234, y: middle * 432.478), control2: CGPoint(x: middle * 775.767, y: middle * 428.21))
                             path.addLine(to: CGPoint(x: middle * 782.96, y: middle * 393.96))
                             path.addLine(to: CGPoint(x: middle * 734.784, y: middle * 383.828))
                             path.addLine(to: CGPoint(x: middle * 728.993, y: middle * 411.448))
                         }
                         .fill(LinearGradient(colors: [ Color(red: 147 / 255, green: 160 / 255, blue: 156 / 255).opacity(0), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255)],startPoint: UnitPoint(x: 0.758, y: 0.388), endPoint: UnitPoint(x: 0.75, y: 0.428)))
                     }
                 }
                     .scaleEffect(scaleFasteners)
                     
                     // cheeks mouth nostrils
                     Group {
                         // cheek left
                         Path { path in
                             path.addArc(center: CGPoint(x: middle * 315, y: middle * 814), radius: middle * 56, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                         }
                         .fill(LinearGradient(colors: [Color(red: 221 / 255, green: 190 / 255, blue: 221 / 255), Color(red: 111 / 255, green: 192 / 255, blue: 152 / 255).opacity(0)],startPoint: UnitPoint(x: 0.347, y: 0.77), endPoint: UnitPoint(x: 0.278, y: 0.856)))
                         .offset(x: middle * offsetCheekX)
                         
                         // cheek right
                         Path { path in
                             path.addArc(center: CGPoint(x: middle * 680, y: middle * 814), radius: middle * 56, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                         }
                         .fill(LinearGradient(colors: [Color(red: 221 / 255, green: 180 / 255, blue: 221 / 255), Color(red: 57 / 255, green: 121 / 255, blue: 159 / 255).opacity(0)], startPoint: UnitPoint(x: 0.64, y: 0.774), endPoint: UnitPoint(x: 0.718, y: 0.85)))
                         .offset(x: middle * -offsetCheekX)
                         
                         ZStack {
                             // mouth bottom
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 421.919, y: middle * 800.291))
                                 path.addCurve(to: CGPoint(x: middle * 493.5, y: middle * 834.821), control1: CGPoint(x: middle * 439.557, y: middle * 821.249), control2: CGPoint(x: middle * 464.97, y: middle * 833.515))
                                 path.addCurve(to: CGPoint(x: middle * 573.279, y: middle * 807.06), control1: CGPoint(x: middle * 522.118, y: middle * 836.137), control2: CGPoint(x: middle * 550.451, y: middle * 826.26))
                                 path.addLine(to: CGPoint(x: middle * 577.239, y: middle * 811.776))
                                 path.addCurve(to: CGPoint(x: middle * 555.38, y: middle * 826.63), control1: CGPoint(x: middle * 570.385, y: middle * 817.542), control2: CGPoint(x: middle * 563, y: middle * 822.513))
                                 path.addCurve(to: CGPoint(x: middle * 493.214, y: middle * 840.96), control1: CGPoint(x: middle * 536.165, y: middle * 836.94), control2: CGPoint(x: middle * 514.777, y: middle * 841.96))
                                 path.addCurve(to: CGPoint(x: middle * 417.212, y: middle * 804.25), control1: CGPoint(x: middle * 462.957, y: middle * 839.578), control2: CGPoint(x: middle * 435.96, y: middle * 826.53))
                                 path.addLine(to: CGPoint(x: middle * 421.919, y: middle * 800.291))
                             }
                             .fill(LinearGradient(colors: [Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255).opacity(0), Color(red: 176 / 255, green: 225 / 255, blue: 188 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255).opacity(0)], startPoint: UnitPoint(x: 0.417, y: 0.5), endPoint: UnitPoint(x: 0.577, y: 0.5)))
                             .rotation3DEffect(.degrees(rotationMouth), axis: (x: 0, y: 1, z: 0))
                             
                             // mouth top
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 421.919, y: middle * 794.87))
                                 path.addCurve(to: CGPoint(x: middle * 493.5, y: middle * 829.4), control1: CGPoint(x: middle * 439.557, y: middle * 815.829), control2: CGPoint(x: middle * 464.97, y: middle * 828.09))
                                 path.addCurve(to: CGPoint(x: middle * 573.279, y: middle * 801.648), control1: CGPoint(x: middle * 522.118, y: middle * 830.716), control2: CGPoint(x: middle * 550.451, y: middle * 820.84))
                                 path.addLine(to: CGPoint(x: middle * 577.239, y: middle * 806.35))
                                 path.addCurve(to: CGPoint(x: middle * 555.38, y: middle * 821.21), control1: CGPoint(x: middle * 570.385, y: middle * 812.121), control2: CGPoint(x: middle * 563, y: middle * 817.092))
                                 path.addCurve(to: CGPoint(x: middle * 493.214, y: middle * 835.54), control1: CGPoint(x: middle * 536.165, y: middle * 831.529), control2: CGPoint(x: middle * 514.777, y: middle * 836.54))
                                 path.addCurve(to: CGPoint(x: middle * 417.212, y: middle * 798.82), control1: CGPoint(x: middle * 462.957, y: middle * 834.157), control2: CGPoint(x: middle * 435.96, y: middle * 821.118))
                                 path.addLine(to: CGPoint(x: middle * 421.919, y: middle * 794.87))
                             }
                             .fill(LinearGradient(colors: [Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255).opacity(0), Color(red: 41 / 255, green: 79 / 255, blue: 56 / 255), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255).opacity(0)], startPoint: UnitPoint(x: 0.417, y: 0.5), endPoint: UnitPoint(x: 0.577, y: 0.5)))
                             .rotation3DEffect(.degrees(rotationMouth), axis: (x: 0, y: 1, z: 0))
                             
                             // nostril left
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 472.787, y: middle * 762.69))
                                 path.addCurve(to: CGPoint(x: middle * 487.222, y: middle * 757.373), control1: CGPoint(x: middle * 477.456, y: middle * 757.033), control2: CGPoint(x: middle * 483.919, y: middle * 754.65))
                                 path.addCurve(to: CGPoint(x: middle * 484.749, y: middle * 772.558), control1: CGPoint(x: middle * 490.52, y: middle * 760.097), control2: CGPoint(x: middle * 489.418, y: middle * 766.89))
                                 path.addCurve(to: CGPoint(x: middle * 470.315, y: middle * 777.88), control1: CGPoint(x: middle * 480.081, y: middle * 778.221), control2: CGPoint(x: middle * 473.618, y: middle * 780.6))
                                 path.addCurve(to: CGPoint(x: middle * 472.787, y: middle * 762.69), control1: CGPoint(x: middle * 467.011, y: middle * 775.157), control2: CGPoint(x: middle * 468.118, y: middle * 768.359))
                             }
                             .fill(LinearGradient(colors: [Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255).opacity(0)], startPoint: UnitPoint(x: 0.49, y: 0.757), endPoint: UnitPoint(x: 0.47, y: 0.778)))
                             
                             // nostril right
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 521.664, y: middle * 762.69))
                                 path.addCurve(to: CGPoint(x: middle * 507.229, y: middle * 757.373), control1: CGPoint(x: middle * 516.995, y: middle * 757.033), control2: CGPoint(x: middle * 510.532, y: middle * 754.65))
                                 path.addCurve(to: CGPoint(x: middle * 509.701, y: middle * 772.558), control1: CGPoint(x: middle * 503.925, y: middle * 760.097), control2: CGPoint(x: middle * 505.032, y: middle * 766.89))
                                 path.addCurve(to: CGPoint(x: middle * 524.136, y: middle * 777.88), control1: CGPoint(x: middle * 514.37, y: middle * 778.221), control2: CGPoint(x: middle * 520.833, y: middle * 780.6))
                                 path.addCurve(to: CGPoint(x: middle * 521.664, y: middle * 762.69), control1: CGPoint(x: middle * 527.439, y: middle * 775.157), control2: CGPoint(x: middle * 526.332, y: middle * 768.359))
                             }
                             .fill(LinearGradient(colors: [Color(red: 22 / 255, green: 131 / 255, blue: 99 / 255), Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255).opacity(0)], startPoint: UnitPoint(x: 0.51, y: 0.757), endPoint: UnitPoint(x: 0.53, y: 0.778)))
                         }
                         .scaleEffect(scaleMouth)
                     }
                     
                     // eyes
                     ZStack {
                         Group {
                             // eye left part 3
                             Path { path in
                                 path.move(to: CGPoint(x: middle * 392, y: middle * 651))
                                 path.addCurve(to: CGPoint(x: middle * 444.62, y: middle * 716.281), control1: CGPoint(x: middle * 423.5, y: middle * 651), control2: CGPoint(x: middle * 445.96, y: middle * 681.392))
                                 path.addCurve(to: CGPoint(x: middle * 392, y: middle * 777), control1: CGPoint(x: middle * 443.28, y: middle * 751.171), control2: CGPoint(x: middle * 418, y: middle * 777))
                                 path.addCurve(to: CGPoint(x: middle * 339, y: middle * 712), control1: CGPoint(x: middle * 360, y: middle * 777), control2: CGPoint(x: middle * 337.873, y: middle * 747.123))
                                 path.addCurve(to: CGPoint(x: middle * 392, y: middle * 651), control1: CGPoint(x: middle * 340, y: middle * 677), control2: CGPoint(x: middle * 365, y: middle * 651))
                             }
                             .fill(LinearGradient(colors: [Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255).opacity(0)], startPoint: UnitPoint(x: 0.391, y: 0.68), endPoint: UnitPoint(x: 0.390, y: 0.777)))
                             
                             // eye left pupil
                             Path { path in
                                 path.addArc(center: CGPoint(x: middle * 392, y: middle * 693), radius: middle * 42, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                             }
                             .fill(LinearGradient(colors: [Color(red: 0 / 255, green: 0 / 255, blue: 0 / 255), Color(red: 83 / 255, green: 71 / 255, blue: 65 / 255)], startPoint: UnitPoint(x: 0.422, y: 0.663), endPoint: UnitPoint(x: 0.361, y: 0.723)).shadow(.drop(color: Color(red: 176 / 255, green: 255 / 255, blue: 188 / 255), radius: middle * 1, x: middle * 0, y: middle * 10)))
                             
                             // eye left part 1
                             Path { path in
                                 path.addArc(center: CGPoint(x: middle * 376, y: middle * 676), radius: middle * 12, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                             }
                             .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 102 / 255, green: 102 / 255, blue: 102 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.664), endPoint: UnitPoint(x: 0.5, y: 0.688)))
                             
                             // eye left part 2
                             Path { path in
                                 path.addArc(center: CGPoint(x: middle * 397, y: middle * 686), radius: middle * 5, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                             }
                             .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 102 / 255, green: 102 / 255, blue: 102 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.681), endPoint: UnitPoint(x: 0.5, y: 0.691)))
                             
                             ZStack {
                                 // eye right part 3
                                 Path { path in
                                     path.move(to: CGPoint(x: middle * 608, y: middle * 651))
                                     path.addCurve(to: CGPoint(x: middle * 555.38, y: middle * 716.281), control1: CGPoint(x: middle * 576.5, y: middle * 651), control2: CGPoint(x: middle * 554.04, y: middle * 681.392))
                                     path.addCurve(to: CGPoint(x: middle * 608, y: middle * 777), control1: CGPoint(x: middle * 556.72, y: middle * 751.171), control2: CGPoint(x: middle * 582, y: middle * 777))
                                     path.addCurve(to: CGPoint(x: middle * 661, y: middle * 712), control1: CGPoint(x: middle * 640, y: middle * 777), control2: CGPoint(x: middle * 662.127, y: middle * 747.123))
                                     path.addCurve(to: CGPoint(x: middle * 608, y: middle * 651), control1: CGPoint(x: middle * 660, y: middle * 677), control2: CGPoint(x: middle * 635, y: middle * 651))
                                 }
                                 .fill(LinearGradient(colors: [Color(red: 72 / 255, green: 108 / 255, blue: 82 / 255), Color(red: 203 / 255, green: 201 / 255, blue: 210 / 255).opacity(0)], startPoint: UnitPoint(x: 0.5, y: 0.68), endPoint: UnitPoint(x: 0.5, y: 0.777)))
                                 
                                 // eye right pupil
                                 Path { path in
                                     path.addArc(center: CGPoint(x: middle * 608, y: middle * 693), radius: middle * 42, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                                 }
                                 .fill(LinearGradient(colors: [Color(red: 0 / 255, green: 0 / 255, blue: 0 / 255), Color(red: 83 / 255, green: 71 / 255, blue: 65 / 255)], startPoint: UnitPoint(x: 0.627, y: 0.659), endPoint: UnitPoint(x: 0.577, y: 0.726)).shadow(.drop(color: Color(red: 176 / 255, green: 255 / 255, blue: 188 / 255), radius: middle * 1, x: middle * 0, y: middle * 10)))
                                 
                                 // eye right part 1
                                 Path { path in
                                     path.addArc(center: CGPoint(x: middle * 591, y: middle * 676), radius: middle * 12, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                                 }
                                 .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 102 / 255, green: 102 / 255, blue: 102 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.664), endPoint: UnitPoint(x: 0.5, y: 0.688)))
                                 
                                 // eye right part 2
                                 Path { path in
                                     path.addArc(center: CGPoint(x: middle * 613, y: middle * 688), radius: middle * 5, startAngle: .degrees(0), endAngle: .degrees(360), clockwise: true)
                                 }
                                 .fill(LinearGradient(colors: [Color(red: 255 / 255, green: 255 / 255, blue: 255 / 255), Color(red: 102 / 255, green: 102 / 255, blue: 102 / 255)], startPoint: UnitPoint(x: 0.5, y: 0.681), endPoint: UnitPoint(x: 0.5, y: 0.691)))
                             }
                             .rotation3DEffect(.degrees(rotationEyeRight), axis: (x: 1, y: 0, z: 0))
                         }
                 }
                     .scaleEffect(scalePupil)
             }
                     .offset(y: middle * offsetAllY)
         }
             .onAppear { move() }
         }
     }
 }