Super Op script made by me that i gave up on

 WindUI = (:())()

 Window = WindUI:({
    Title = ,
    Icon = ,
    Author = ,
    Folder = ,
    Size = .(, ),
    Transparent = ,
    Theme = ,
    SideBarWidth = ,
})

Window:({
    Title = ,
    Icon = ,
    CornerRadius = .(, ),
    StrokeThickness = ,
    Draggable = ,
})

 Tabs = {
    Main     = Window:({ Title = , Icon =  }),
    Player   = Window:({ Title = , Icon =  }),
    ESP      = Window:({ Title = , Icon =  }),
    Aimbot   = Window:({ Title = , Icon =  }),
    Misc     = Window:({ Title = , Icon =  }),
    PlotCopy = Window:({ Title = , Icon =  }),
    Settings = Window:({ Title = , Icon =  }),
}

 Players           = :()
 RunService        = :()
 UserInputService  = :()
 LocalPlayer       = Players.LocalPlayer
 Camera            = .CurrentCamera




 Rainbow = {
    Hue = ,
    Speed = , 
    Color = .(, , ),
}

RunService.RenderStepped:((dt)
    Rainbow.Hue = (Rainbow.Hue + dt * Rainbow.Speed) % 
    Rainbow.Color = .(Rainbow.Hue, , )
)




Tabs.Main:({ Title =  })
Tabs.Main:({
    Title = ,
    Desc = ,
})
Tabs.Main:({
    Title = ,
    Desc = ,
    Callback = ()
        WindUI:({
            Title = ,
            Content = ,
            Duration = ,
            Icon = ,
        })
    ,
})




Tabs.Player:({ Title =  })
 walkSpeed = 
Tabs.Player:({
    Title = ,
    Value = { Min = , Max = , Default =  },
    Callback = (value)
        walkSpeed = value
         char = LocalPlayer.Character
         char  char:() 
            char:().WalkSpeed = value
        
    ,
})
 jumpPower = 
Tabs.Player:({
    Title = ,
    Value = { Min = , Max = , Default =  },
    Callback = (value)
        jumpPower = value
         char = LocalPlayer.Character
         char  char:() 
             hum = char:()
            hum.UseJumpPower = 
            hum.JumpPower = value
        
    ,
})
Tabs.Player:({
    Title = ,
    Default = ,
    Callback = (state) .InfiniteJump = state ,
})
UserInputService.JumpRequest:(()
     .InfiniteJump 
         char = LocalPlayer.Character
         char  char:() 
            char:():(.HumanoidStateType.Jumping)
        
    
)
Tabs.Player:({
    Title = ,
    Callback = ()
         LocalPlayer.Character  LocalPlayer.Character:() 
    ,
})




 ESP = {
    Enabled     = ,
    Box         = ,
    Tracers     = ,
    Charms      = ,
    Health      = ,   
    HealthBar   = ,   
    HealthBarSide = , 
    Name        = ,
    Distance    = ,
    Rainbow     = ,    
    Color       = .(, , ),
    TeamCheck   = ,
    TracerOrigin = , 
}


  ()
     ESP.Rainbow   Rainbow.Color 
     ESP.Color


 ESPObjects = {} 

  (class, props)
     d = .(class)
     k, v  (props)  d[k] = v 
     d


  (player)
     ESPObjects[player]   
     objs = {}

    objs.Box = (, {
        Thickness = , Filled = , Color = ESP.Color, Transparency = , Visible = ,
    })
    objs.Tracer = (, {
        Thickness = , Color = ESP.Color, Transparency = , Visible = ,
    })
    objs.Name = (, {
        Size = , Center = , Outline = , Color = ESP.Color, Visible = ,
    })
    objs.Distance = (, {
        Size = , Center = , Outline = , Color = ESP.Color, Visible = ,
    })
    objs.Health = (, {
        Size = , Center = , Outline = , Color = .(, , ), Visible = ,
    })

    
    objs.HealthBarBG = (, {
        Thickness = , Filled = , Color = .(, , ), Transparency = , Visible = ,
    })
    objs.HealthBarFill = (, {
        Thickness = , Filled = , Color = .(, , ), Transparency = , Visible = ,
    })

    
     highlight = .()
    highlight.Name = 
    highlight.FillTransparency = 
    highlight.OutlineTransparency = 
    highlight.FillColor = ESP.Color
    highlight.OutlineColor = ESP.Color
    highlight.Enabled = 
    highlight.Parent = :()
    objs.Highlight = highlight

    ESPObjects[player] = objs


  (player)
     objs = ESPObjects[player]
      objs   
     _, obj  (objs) 
        (() obj:() )
        (() obj:() )
    
    ESPObjects[player] = 


  (objs)
    objs.Box.Visible = 
    objs.Tracer.Visible = 
    objs.Name.Visible = 
    objs.Distance.Visible = 
    objs.Health.Visible = 
    objs.HealthBarBG.Visible = 
    objs.HealthBarFill.Visible = 
    objs.Highlight.Enabled = 


RunService.RenderStepped:(()
     col = ()
     _, player  (Players:()) 
         player ~= LocalPlayer 
             objs = ESPObjects[player]
              objs   

             char = player.Character
             hrp  = char  char:()
             head = char  char:()
             hum  = char  char:()

              ESP.Enabled   char   hrp   hum  hum.Health <=  
                (objs); 
            
             ESP.TeamCheck  player.Team == LocalPlayer.Team 
                (objs); 
            

             pos, onScreen = Camera:(hrp.Position)
              onScreen  (objs);  

             topPos    = Camera:((head  head.Position  hrp.Position) + .(, , ))
             bottomPos = Camera:(hrp.Position - .(, , ))
             height = .(topPos.Y - bottomPos.Y)
             width  = height / 
             boxX = pos.X - width / 

            
             ESP.Box 
                objs.Box.Size = .(width, height)
                objs.Box.Position = .(boxX, topPos.Y)
                objs.Box.Color = col
                objs.Box.Visible = 
             objs.Box.Visible =  

            
             ESP.Tracers 
                 from
                 vp = Camera.ViewportSize
                 ESP.TracerOrigin ==  
                    from = .(vp.X / , vp.Y)
                 ESP.TracerOrigin ==  
                    from = .(vp.X / , )
                 ESP.TracerOrigin ==  
                    from = .(vp.X / , vp.Y / )
                 ESP.TracerOrigin ==  
                     m = UserInputService:()
                    from = .(m.X, m.Y)
                
                    from = .(vp.X / , vp.Y)
                
                objs.Tracer.From = from
                objs.Tracer.To = .(pos.X, bottomPos.Y)
                objs.Tracer.Color = col
                objs.Tracer.Visible = 
             objs.Tracer.Visible =  

            
             ESP.Charms 
                objs.Highlight.Adornee = char
                objs.Highlight.FillColor = col
                objs.Highlight.OutlineColor = col
                objs.Highlight.Enabled = 
             objs.Highlight.Enabled =  

            
             ESP.Name 
                objs.Name.Text = player.DisplayName  player.Name
                objs.Name.Position = .(pos.X, topPos.Y - )
                objs.Name.Color = col
                objs.Name.Visible = 
             objs.Name.Visible =  

            
             ESP.Distance 
                 dist = (Camera.CFrame.Position - hrp.Position).Magnitude
                objs.Distance.Text = .(, dist)
                objs.Distance.Position = .(pos.X, bottomPos.Y + )
                objs.Distance.Color = col
                objs.Distance.Visible = 
             objs.Distance.Visible =  

            
             ESP.Health 
                objs.Health.Text = .(, hum.Health)
                objs.Health.Position = .(pos.X, bottomPos.Y + (ESP.Distance    ))
                 ratio = hum.Health / .(hum.MaxHealth, )
                objs.Health.Color = .( * ( - ratio),  * ratio, )
                objs.Health.Visible = 
             objs.Health.Visible =  

            
             ESP.HealthBar 
                 ratio = .(hum.Health / .(hum.MaxHealth, ), , )
                 barColor = .( * ( - ratio),  * ratio, )
                 side = ESP.HealthBarSide

                 side ==   side ==  
                     barW = 
                     barX = (side == )  (boxX - barW - )  (boxX + width + )
                    objs.HealthBarBG.Size = .(barW, height)
                    objs.HealthBarBG.Position = .(barX, topPos.Y)
                     fillH = height * ratio
                    objs.HealthBarFill.Size = .(barW, fillH)
                    
                    objs.HealthBarFill.Position = .(barX, topPos.Y + (height - fillH))
                 
                     barH = 
                     barY = (side == )  (topPos.Y - barH - )  (topPos.Y + height + )
                    objs.HealthBarBG.Size = .(width, barH)
                    objs.HealthBarBG.Position = .(boxX, barY)
                     fillW = width * ratio
                    objs.HealthBarFill.Size = .(fillW, barH)
                    objs.HealthBarFill.Position = .(boxX, barY)
                
                objs.HealthBarFill.Color = barColor
                objs.HealthBarBG.Visible = 
                objs.HealthBarFill.Visible = 
            
                objs.HealthBarBG.Visible = 
                objs.HealthBarFill.Visible = 
            
        
    
)

 _, player  (Players:()) 
     player ~= LocalPlayer  (player) 

Players.PlayerAdded:((player)
     player ~= LocalPlayer  (player) 
)
Players.PlayerRemoving:(removeESP)




Tabs.ESP:({ Title =  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Enabled = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Box = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Charms = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Tracers = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Name = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Distance = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.TeamCheck = s  })

Tabs.ESP:({ Title =  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.Health = s  })
Tabs.ESP:({ Title = , Desc = , Default = ,
    Callback = (s) ESP.HealthBar = s  })
Tabs.ESP:({
    Title = ,
    Desc = ,
    Values = { , , ,  },
    Value = ,
    Callback = (v) ESP.HealthBarSide = v ,
})

Tabs.ESP:({ Title =  })
Tabs.ESP:({
    Title = ,
    Desc = ,
    Values = { , , ,  },
    Value = ,
    Callback = (v) ESP.TracerOrigin = v ,
})

Tabs.ESP:({ Title =  })
Tabs.ESP:({
    Title = ,
    Desc = ,
    Default = ,
    Callback = (s) ESP.Rainbow = s ,
})
Tabs.ESP:({
    Title = ,
    Desc = ,
    Default = ESP.Color,
    Callback = (c) ESP.Color = c ,
})




 Aimbot = {
    Enabled     = ,
    TeamCheck   = ,
    WallCheck   = ,
    Smoothness  = ,        
    TargetPart  = ,      
    
    FOVEnabled  = ,
    FOVShow     = ,
    FOVRadius   = ,
    FOVRainbow  = ,
    FOVColor    = .(, , ),
    
    Key         = .UserInputType.MouseButton2, 
    Mode        = ,      
    Active      = ,       
}


 FOVCircle = (, {
    Thickness = ,
    NumSides = ,
    Radius = Aimbot.FOVRadius,
    Filled = ,
    Color = Aimbot.FOVColor,
    Transparency = ,
    Visible = ,
})

  ()
     Aimbot.FOVRainbow   Rainbow.Color 
     Aimbot.FOVColor


  (char)
      char    
     Aimbot.TargetPart ==  
         char:()
     Aimbot.TargetPart ==  
         char:()  char:()  char:()
    
         char:()
    



  (targetPart, char)
      Aimbot.WallCheck    
     origin = Camera.CFrame.Position
     dir = (targetPart.Position - origin)
     params = RaycastParams.()
    params.FilterType = .RaycastFilterType.Exclude
    params.FilterDescendantsInstances = { LocalPlayer.Character, Camera }
     result = :(origin, dir, params)
      result    
    
     result.Instance:(char)



  ()
     best, bestDist = , .huge
     center = Camera.ViewportSize / 
     Aimbot.FOVEnabled  center = .(center.X, center.Y) 

     _, player  (Players:()) 
         player ~= LocalPlayer 
             Aimbot.TeamCheck  player.Team == LocalPlayer.Team   
             char = player.Character
             hum = char  char:()
              char   hum  hum.Health <=    
             part = (char)
              part   

             screenPos, onScreen = Camera:(part.Position)
              onScreen   

             dist = (.(screenPos.X, screenPos.Y) - center).Magnitude
             Aimbot.FOVEnabled  dist > Aimbot.FOVRadius   

             dist < bestDist 
                 (part, char) 
                    best, bestDist = part, dist
                
            
        
    
     best



UserInputService.InputBegan:((input, gpe)
     gpe   
     matched = 
     Aimbot.Key == input.UserInputType  matched =  
     input.KeyCode ~= .KeyCode.Unknown  Aimbot.Key == input.KeyCode  matched =  
     matched 
         Aimbot.Mode ==  
            Aimbot.Active = 
         
            Aimbot.Active =  Aimbot.Active
        
    
)

UserInputService.InputEnded:((input)
     matched = 
     Aimbot.Key == input.UserInputType  matched =  
     input.KeyCode ~= .KeyCode.Unknown  Aimbot.Key == input.KeyCode  matched =  
     matched  Aimbot.Mode ==  
        Aimbot.Active = 
    
)


RunService.RenderStepped:(()
    
     Aimbot.FOVEnabled  Aimbot.FOVShow 
         m = UserInputService:()
        FOVCircle.Position = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
        FOVCircle.Radius = Aimbot.FOVRadius
        FOVCircle.Color = ()
        FOVCircle.Visible = 
    
        FOVCircle.Visible = 
    

    
     Aimbot.Enabled  Aimbot.Active 
         target = ()
         target 
             screenPos = Camera:(target.Position)
             targetScreen = .(screenPos.X, screenPos.Y)
             current = UserInputService:()
            
             delta = targetScreen - current
             Aimbot.Smoothness >  
                delta = delta * ( - Aimbot.Smoothness)
            
            (()
                (delta.X, delta.Y)
            )
        
    
)




Tabs.Aimbot:({ Title =  })
Tabs.Aimbot:({ Title = , Desc = , Default = ,
    Callback = (s) Aimbot.Enabled = s  })
Tabs.Aimbot:({ Title = , Desc = , Default = ,
    Callback = (s) Aimbot.TeamCheck = s  })
Tabs.Aimbot:({ Title = , Desc = , Default = ,
    Callback = (s) Aimbot.WallCheck = s  })
Tabs.Aimbot:({
    Title = ,
    Values = { , ,  },
    Value = ,
    Callback = (v) Aimbot.TargetPart = v ,
})
Tabs.Aimbot:({
    Title = ,
    Desc = ,
    Value = { Min = , Max = , Default =  },
    Callback = (v) Aimbot.Smoothness = v /  ,
})

Tabs.Aimbot:({ Title =  })
Tabs.Aimbot:({ Title = , Desc = , Default = ,
    Callback = (s) Aimbot.FOVEnabled = s  })
Tabs.Aimbot:({ Title = , Desc = , Default = ,
    Callback = (s) Aimbot.FOVShow = s  })
Tabs.Aimbot:({
    Title = ,
    Desc = ,
    Value = { Min = , Max = , Default =  },
    Callback = (v) Aimbot.FOVRadius = v ,
})
Tabs.Aimbot:({ Title = , Desc = , Default = ,
    Callback = (s) Aimbot.FOVRainbow = s  })
Tabs.Aimbot:({
    Title = ,
    Desc = ,
    Default = Aimbot.FOVColor,
    Callback = (c) Aimbot.FOVColor = c ,
})

Tabs.Aimbot:({ Title =  })
Tabs.Aimbot:({
    Title = ,
    Desc = ,
    Values = { ,  },
    Value = ,
    Callback = (v) Aimbot.Mode = v; Aimbot.Active =  ,
})
Tabs.Aimbot:({
    Title = ,
    Desc = ,
    Value = ,
    Callback = (key)
        
         key ==  
            Aimbot.Key = .UserInputType.MouseButton1
         key ==  
            Aimbot.Key = .UserInputType.MouseButton2
         key ==  
            Aimbot.Key = .UserInputType.MouseButton3
        
             ok, code = (()  .KeyCode[key] )
             ok  code  Aimbot.Key = code 
        
    ,
})

Tabs.Aimbot:({ Title =  })
Tabs.Aimbot:({
    Title = ,
    Desc = ,
    Value = { Min = , Max = , Default =  },
    Callback = (v) Rainbow.Speed = v /  ,
})




 Misc = {
    Noclip      = ,
    Fly         = ,
    FlySpeed    = ,
    Fullbright  = ,
}


 noclipParts = {}

 noclipCF =        
 TELEPORT_THRESHOLD =   











  (char)
      char   
     _, part  (char:()) 
         part:()  part.CanCollide 
            noclipParts[part] = 
            part.CanCollide = 
        
    


  ()
     part  (noclipParts) 
         part  part.Parent 
            (() part.CanCollide =  )
        
    
    noclipParts = {}
    noclipCF = 



RunService.Stepped:(()
     Misc.Noclip 
        (LocalPlayer.Character)
    
)



RunService.RenderStepped:((dt)
      Misc.Noclip  noclipCF = ;  

     char = LocalPlayer.Character
     hrp  = char  char:()
     hum  = char  char:()
      hrp   hum  noclipCF = ;  

    
      noclipCF  noclipCF = hrp.CFrame 

    
     drift = (hrp.Position - noclipCF.Position).Magnitude
     drift > TELEPORT_THRESHOLD 
        
        hrp.CFrame = noclipCF
        hrp.AssemblyLinearVelocity = .zero
    

    
     moveDir = hum.MoveDirection
     speed = (hum.WalkSpeed >   hum.WalkSpeed  )
     moveDir.Magnitude >  
        
         rot = hrp.CFrame - hrp.CFrame.Position
         newPos = noclipCF.Position + moveDir * speed * dt
        noclipCF = .(newPos) * rot
        hrp.CFrame = noclipCF
        hrp.AssemblyLinearVelocity = .zero
    
        
        
        noclipCF = hrp.CFrame
    
)




 flyBV, flyBG
 flyConn

  ()
     char = LocalPlayer.Character
     hrp = char  char:()
     hum = char  char:()
      hrp   

     hum  hum.PlatformStand =  

    flyBV = .()
    flyBV.MaxForce = .(, , )
    flyBV.Velocity = .zero
    flyBV.Parent = hrp

    flyBG = .()
    flyBG.MaxTorque = .(, , )
    flyBG.P = 
    flyBG.CFrame = hrp.CFrame
    flyBG.Parent = hrp

    flyConn = RunService.RenderStepped:(()
          Misc.Fly   
         cam = Camera.CFrame
         move = .zero
         UserInputService:(.KeyCode.W)  move += cam.LookVector 
         UserInputService:(.KeyCode.S)  move -= cam.LookVector 
         UserInputService:(.KeyCode.A)  move -= cam.RightVector 
         UserInputService:(.KeyCode.D)  move += cam.RightVector 
         UserInputService:(.KeyCode.Space)  move += .(, , ) 
         UserInputService:(.KeyCode.LeftControl)  move -= .(, , ) 

         flyBV 
             move.Magnitude >  
                flyBV.Velocity = move.Unit * Misc.FlySpeed
            
                flyBV.Velocity = .zero
            
        
         flyBG  flyBG.CFrame = cam 
    )


  ()
     char = LocalPlayer.Character
     hum = char  char:()
     hum  hum.PlatformStand =  
     flyConn  flyConn:(); flyConn =  
     flyBV  flyBV:(); flyBV =  
     flyBG  flyBG:(); flyBG =  



LocalPlayer.CharacterAdded:(()
    .()
    noclipParts = {}
     Misc.Fly  (); () 
)


 Lighting = :()
 fbSaved = 
  (on)
     on 
          fbSaved 
            fbSaved = {
                Brightness  = Lighting.Brightness,
                ClockTime   = Lighting.ClockTime,
                FogEnd      = Lighting.FogEnd,
                GlobalShadows = Lighting.GlobalShadows,
                Ambient     = Lighting.Ambient,
                OutdoorAmbient = Lighting.OutdoorAmbient,
            }
        
        Lighting.Brightness = 
        Lighting.ClockTime = 
        Lighting.FogEnd = 
        Lighting.GlobalShadows = 
        Lighting.Ambient = .(, , )
        Lighting.OutdoorAmbient = .(, , )
    
         fbSaved 
            Lighting.Brightness = fbSaved.Brightness
            Lighting.ClockTime = fbSaved.ClockTime
            Lighting.FogEnd = fbSaved.FogEnd
            Lighting.GlobalShadows = fbSaved.GlobalShadows
            Lighting.Ambient = fbSaved.Ambient
            Lighting.OutdoorAmbient = fbSaved.OutdoorAmbient
        
    





Tabs.Misc:({ Title =  })
Tabs.Misc:({
    Title = ,
    Desc = ,
    Default = ,
    Callback = (state)
        Misc.Noclip = state
          state  () 
    ,
})
Tabs.Misc:({
    Title = ,
    Desc = ,
    Default = ,
    Callback = (state)
        Misc.Fly = state
         state  ()  () 
    ,
})
Tabs.Misc:({
    Title = ,
    Desc = ,
    Value = { Min = , Max = , Default =  },
    Callback = (v) Misc.FlySpeed = v ,
})

Tabs.Misc:({ Title =  })
Tabs.Misc:({
    Title = ,
    Desc = ,
    Default = ,
    Callback = (state)
        Misc.Fullbright = state
        (state)
    ,
})












 HttpService     = :()
 ReplicatedStorage = :()

 PlotCopy = {
    Target      = ,   
    SpyLog      = {},    
    Spying      = ,
    LastScan    = {},    
    PlaceDelay  = ,   
}










 PLACEMENT_CONFIG = {
    RemotePath = ,      
    Method     = ,
    
    buildArgs  = (item)
        
        
         item.Id, item.CFrame
    ,
}

  (path)
     node = 
     _, name  (path) 
        node = node:(name)
          node    
    
     node














 canReadScripts = (getgc  getscripts)  (decompile  getscriptbytecode  getsource)
 KEYWORDS = { , , , , , , ,  }


  ()
    PlotCopy.SpyLog = {}
     scriptList = {}
     getscripts 
         _, s  (())  scriptList[#scriptList+] = s 
     getgc 
         _, o  (()) 
             (o) ==   (o:()  o:()) 
                scriptList[#scriptList+] = o
            
        
    

     decomp = decompile  getsource
     hits = 
     _, s  (scriptList) 
         ok, src = (()  decomp  (s) )
         ok  (src) ==  
             low = src:()
             low:()  low:() 
                 _, kw  (KEYWORDS) 
                     low:(kw) 
                        (.(, s:(), kw))
                        
                         line  src:() 
                             ll = line:()
                             (ll:()  ll:()) 
                                (..line:(, ))
                            
                        
                        .(PlotCopy.SpyLog, { remote = s:(), method = , argc =  })
                        hits += 
                        
                    
                
            
        
    
     hits ==  
        ()
         _, r  (:()) 
             r:()  r:() 
                 n = r.Name:()
                 _, kw  (KEYWORDS) 
                     n:(kw)  (..r:()....r.ClassName..);  
                
            
        
    
    WindUI:({
        Title = ,
        Content = hits >   (hits..)
             ,
        Duration = , Icon = ,
    })




  (nameKeyword)
     decomp = decompile  getsource
      decomp 
        WindUI:({ Title = , Content = , Duration = , Icon =  }); 
    
     scriptList = {}
     getscripts 
         _, s  (())  scriptList[#scriptList+] = s 
     getgc 
         _, o  (()) 
             (o) ==   (o:()  o:()) 
                scriptList[#scriptList+] = o
            
        
    
     matches = {}
     _, s  (scriptList) 
         s:():():(nameKeyword:()) 
            matches[#matches+] = s
        
    
     #matches ==  
        (..nameKeyword..); 
    
    (.(, #matches, nameKeyword))
     _, s  (matches)  (..s:()) 

     _, target  (matches) 
     ok, src = (()  (target) )
      ok  (src) ~=  
        (..target:())
    

    
     lines = {}
     line  (src..):()  lines[#lines+] = line 

    (..target:()....#lines..)
    
    ()
     i, line  (lines) 
         ll = line:()
         ll:()  ll:()
            ll:()  ll:()  ll:()
            ll:() 
            (.(, i, line:(, )))
        
    
    
    ()
     i, line  (lines) 
         ll = line:()
         ll:()  ll:() 
             a = .(, i - )
             b = .(#lines, i + )
            (.(, i))
             j = a, b 
                (.(, j, lines[j]))
            
        
    
    (..target:()..)
    
    
    WindUI:({ Title = , Content = ..#matches.., Duration = , Icon =  })




 hookRef, restoreHook
  ()
      (    checkcaller) 
        WindUI:({ Title = , Content = , Duration = , Icon =  })
        
    
     hookRef   
     captured = 
     old
    old = (, , ((self, ...)
        
          ()   captured 
             method = getnamecallmethod  ()
             method ==   method ==  
                 n = (self.Name):()
                 _, kw  (KEYWORDS) 
                     n:(kw) 
                         args = { ... }
                        (.(, self:(), method, #args))
                         i, a  (args) 
                            (.(, i, (a), (a)))
                        
                        .(PlotCopy.SpyLog, { remote = self:(), method = method, argc = #args })
                        captured = 
                        
                         restoreHook  .(restoreHook) 
                        
                    
                
            
        
         (self, ...)
    ))
    hookRef = old
    restoreHook = ()
         hookRef   
            (() (, , hookRef) )
            hookRef = 
        
    
    ()








 PLOT_ROOTS = { , , , ,  }

  (player)
     _, rootName  (PLOT_ROOTS) 
         root = :(rootName)
         root 
            
             _, plot  (root:()) 
                 ownerVal = plot:()  plot:()
                 ownerVal  (ownerVal.Value == player  (ownerVal.Value) == player.Name) 
                     plot
                
                 plot.Name == player.Name   plot 
            
        
    
     


  (plot)
     items = {}
    
     container = plot:()
         plot:()
         plot:()
         plot
     basePart = plot:()  plot.PrimaryPart
         plot:()
     baseCF = basePart  basePart.CFrame  .()

     _, obj  (container:()) 
         model = obj:()  obj  
         part  = obj:()  obj  (model  model.PrimaryPart)
         part 
            .(items, {
                Id       = obj.Name,                       
                   = baseCF:(part.CFrame), 
                Color    = part.Color,
                Size     = part.Size,
            })
        
    
     items





  (items)
      PLACEMENT_CONFIG.RemotePath 
        WindUI:({ Title = , Content = , Duration = , Icon =  })
        
    
     remote = (PLACEMENT_CONFIG.RemotePath)
      remote 
        WindUI:({ Title = , Content = , Duration = , Icon =  })
        
    
     myPlot = (LocalPlayer)
     baseCF = .()
     myPlot 
         bp = myPlot:()  myPlot.PrimaryPart  myPlot:()
         bp  baseCF = bp.CFrame 
    

     placed, failed = , 
    .(()
         _, item  (items) 
            
             worldItem = {
                Id = item.Id,
                 = baseCF:(item.CFrame),
                Color = item.Color,
                Size = item.Size,
            }
             ok = (()
                remote[PLACEMENT_CONFIG.Method](remote, PLACEMENT_CONFIG.(worldItem))
            )
             ok  placed +=   failed +=  
            .(PlotCopy.PlaceDelay)
        
        WindUI:({
            Title = ,
            Content = .(, placed, failed),
            Duration = , Icon = ,
        })
    )





Tabs.PlotCopy:({ Title =  })
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Callback = ()
        ()
    ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Callback = ()
        ()
    ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Default = ,
    Callback = (state)
         state  ()   restoreHook  ()  
    ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Callback = ()
         #PlotCopy.SpyLog ==  
            ()
        
             i, e  (PlotCopy.SpyLog) 
                (.(, i, e.remote, e.method, e.argc))
            
        
    ,
})

Tabs.PlotCopy:({ Title =  })
  ()
     names = {}
     _, p  (Players:()) 
         p ~= LocalPlayer  .(names, p.Name) 
    
     #names ==   .(names, ) 
     names

 targetDropdown = Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Values = (),
    Value = ()[],
    Callback = (name)
        PlotCopy.Target = Players:(name)
    ,
})
Tabs.PlotCopy:({
    Title = ,
    Callback = ()
         targetDropdown  targetDropdown.Refresh 
            targetDropdown:(())
        
    ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Callback = ()
         target = PlotCopy.Target
          target 
            WindUI:({ Title = , Content = , Duration = , Icon =  }); 
        
         plot = (target)
          plot 
            WindUI:({ Title = , Content = , Duration = , Icon =  }); 
        
        PlotCopy.LastScan = (plot)
        WindUI:({
            Title = ,
            Content = .(, #PlotCopy.LastScan, target.Name),
            Duration = , Icon = ,
        })
        (.(, #PlotCopy.LastScan))
         i, it  (PlotCopy.LastScan) 
             i <=   (, it.Id) 
        
    ,
})

Tabs.PlotCopy:({ Title =  })
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Value = { Min = , Max = , Default =  },
    Callback = (v) PlotCopy.PlaceDelay = v /  ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Callback = ()
         #PlotCopy.LastScan ==  
            WindUI:({ Title = , Content = , Duration = , Icon =  }); 
        
        (PlotCopy.LastScan)
    ,
})
Tabs.PlotCopy:({
    Title = ,
    Desc = ,
    Callback = ()
         #PlotCopy.LastScan ==  
            WindUI:({ Title = , Content = , Duration = , Icon =  }); 
        
         ok, json = (()
            
             out = {}
             _, it  (PlotCopy.LastScan) 
                .(out, { Id = it.Id,  = (it.CFrame) })
            
             HttpService:(out)
        )
         ok  setclipboard  (json) 
        WindUI:({ Title = , Content = ok    , Duration = , Icon =  })
    ,
})




Tabs.Settings:({ Title =  })
Tabs.Settings:({
    Title = ,
    Default = ,
    Callback = (state) Window:(state) ,
})
Tabs.Settings:({
    Title = ,
    Desc = ,
    Callback = () Window:() ,
})

WindUI:({
    Title = ,
    Content = ,
    Duration = ,
    Icon = ,
})