H4CK3RD0G3 F3X MY SCRIPT DONT SKID

 player = .Players.LocalPlayer
 gui = .()
gui.Parent = player:()


 frame = .()
frame.Size = .(, , , )
frame.Position = .(, -, , -)
frame.BackgroundColor3 = .(,,)
frame.Active = 
frame.Draggable = 
frame.Parent = gui


 frameStroke = .()
frameStroke.Thickness = 
frameStroke.Color = .(,,)
frameStroke.Parent = frame


.(()
     colors = {
        .(,,),
        .(,,),
        .(,,),
        .(,,),
        .(,,),
        .(,,)
    }
     i = 
      
        frameStroke.Color = colors[i]
        i = i % #colors + 
        .()
    
)


 title = .()
title.Size = .(,,,)
title.BackgroundTransparency = 
title.Text = 
title.TextColor3 = .(,,)
title.TextScaled = 
title.Font = .Font.SourceSansBold
title.Parent = frame


  (name, yPos, callback)
     btn = .()
    btn.Size = .(, -, , )
    btn.Position = .(, , , yPos)
    btn.Text = name
    btn.BackgroundColor3 = .(,,)
    btn.TextColor3 = .(,,)
    btn.Font = .Font.SourceSansBold
    btn.TextScaled = 
    btn.Parent = frame

     stroke = .()
    stroke.Thickness = 
    stroke.Color = .(,,)
    stroke.Parent = btn

    btn.MouseButton1Click:(callback)



(, , ()
    ()
    
    
     ReplicatedStorage = :()
 RequestCommand = ReplicatedStorage:().Signals.RequestCommandSilent
RequestCommand:()
RequestCommand:()
()
RequestCommand:()
()

 player = .Players.LocalPlayer
 char = player.Character
 backpack = player.Backpack

  ()
     _, v  (backpack:()) 
         v:()   v 
    
     _, v  (char:()) 
         v:()   v 
    
     


 f3x = ()
  f3x  () 
 syncapi = f3x.SyncAPI
 serverendpoint = syncapi.ServerEndpoint

  (part)
    serverendpoint:(,{part})


  ()
     _, v  (:()) 
         v:()  v:() 
            (() (v) )
        
    


()

RequestCommand:()

  (part,size,cf)
    serverendpoint:(,{{Part=part,=cf,Size=size}})

  (part,mate)
    serverendpoint:(,{{Part=part,Material=mate}})

  (part,trans)
    serverendpoint:(,{{Part=part,Transparency=trans}})

  (part, color)
    serverendpoint:(,{{Part=part,Color=color,UnionColoring=}})

  (part, id)
    serverendpoint:(,{{Part=part,MeshId=..id}})

  (part)
    serverendpoint:(,{{Part=part}})

  (part, vectora)
    serverendpoint:(,{{Part=part,Scale=vectora}})

  (part, id)
    serverendpoint:(,{{Part=part,TextureId=..id}})

  (part, stringa)
    serverendpoint:(,{part},stringa)

  (part, boolean)
    serverendpoint:(,{part},boolean)

  (part, booleana)
    serverendpoint:(,{{Part=part,CanCollide=booleana}})

  (part, boolean)
    serverendpoint:(,{{Part=part,Anchored=boolean}})

  (part, side)
    serverendpoint:(,{{Part=part,Face=side,TextureType=}})

  (part, asset, side)
    serverendpoint:(,{{Part=part,Face=side,TextureType=,Texture=..asset}})


  ()
     position = .(, , )
     base = serverendpoint:(,,position,)
    (base, .(,,), position)
    (base, .Material.Concrete)
    (base, .(,,))
    (base,)
    (base,)

     spawnpos = .(, , -)
     spawna = serverendpoint:(,,spawnpos,)
    (spawna, .(,,), spawnpos)
    (spawna,)
    (spawna,)
    (spawna,.NormalId.Top)
    (spawna,,.NormalId.Top)
    (spawna,)

     pos = .(,,-)
     rules = serverendpoint:(,,pos,)
    (rules,)
    (rules,)
    (rules,.NormalId.Left)
    (rules,,.NormalId.Left)
    (rules,.(,,))
    (rules,.(,,),pos)

     pos2 = .(,,-)
     bad = serverendpoint:(,,pos2,)
    (bad,)
    (bad,)
    (bad,.NormalId.Right)
    (bad,,.NormalId.Right)
    (bad,.(,,),pos2)


  ()
     position = .(,,)
     sky = serverendpoint:(,,position,)
    (sky)
    (sky,)
    (sky,)
    (sky,.(,,))
    (sky,)
    (sky,)
    (sky,)


  ()
    ()
    ()


()

RequestCommand:()
()
RequestCommand:()
RequestCommand:()
()
RequestCommand:()
)


(, , ()
    ()
    
    
     P = :()
 R = :()

 p = P.LocalPlayer
 c = p.Character  p.CharacterAdded:()

 t
 _, v  (p:()) 
     v.Name ==  
        t = v.Parent
        
    

  t 
     _, v  (R:()) 
         v.Name ==  
            t = v.Parent
            
        
    


 r = t.SyncAPI.ServerEndpoint
  (a) r:((a)) 

  (p, b) ({, {{Part = p, CanCollide = b}}}) 
  (b, p) ({, {{Part = p, Anchored = b}}}) 
  (cf, pr) ({,,cf,pr}) 
  (p) ({,{p}}) 
  (p, cf) ({, {{Part = p,  = cf}}}) 
  (p, s, cf) ({, {{Part = p, Size = s,  = cf}}}) 
  (p, n) ({,{p},n}) 
  (p, b) ({,{p},b}) 
  (p, v) ({, {{Part = p, Transparency = v}}}) 
  (p, f) ({, {{Part = p, Face = f, TextureType = }}}) 
  (p, id, f) ({, {{Part = p, Face = f, TextureType = , Texture = ..id}}}) 

 ids = {}

 .() 
     _, plr  (P:()) 
         pC = plr.Character
         pC  pC:() 
             h = pC.Head
             cf = h.CFrame * .(, , )

            (cf,)
            .()

             part
             _, v  (:()) 
                 v:()  (v.Position - cf.p).Magnitude <  
                    part = v
                    
                
            

             part 
                (part,)
                 id = ids[.(#ids)]

                (part, .NormalId.Front)
                (part, id, .NormalId.Front)

                (part, .NormalId.Back)
                (part, id, .NormalId.Back)

                (part, )
                (part, .(, , ), part.CFrame)
                (part, )
                (part, )

                .(()
                     i = ,  
                        (part, part.CFrame + .(, , ))
                        .()
                    
                    (part)
                )
            
        
    


)


(, , ()
    ()
    
    
     ReplicatedStorage = :()
 RequestCommand = ReplicatedStorage:().Signals.RequestCommand

 A0=:()
 A1=:()
 A2=:()

 A3=A0.LocalPlayer
 A4=A3.Character  A3.CharacterAdded:()

 A5

 _,v  (A3:()) 
     v.Name== 
        A5=v.Parent
        
    


  A5 
     _,v  (A1:()) 
         v.Name== 
            A5=v.Parent
            
        
    


  A5 
    


 A8=A5.SyncAPI.ServerEndpoint

  (x)
    A8:((x))


  (x,y)
    ({
        ,
        ,
        x,
        y
    })


  (x,y)
    ({
        ,
        {{
            Part=x,
            Anchored=y
        }}
    })


  (x)
    ({
        ,
        {{
            Part=x
        }}
    })


  (x,y)
    ({
        ,
        {{
            Part=x,
            MeshId=..y
        }}
    })


  (x,y)
    ({
        ,
        {{
            Part=x,
            TextureId=y
        }}
    })


  (x,y)
    ({
        ,
        {{
            Part=x,
            Scale=y
        }}
    })


  (x,y)
    ({
        ,
        {{
            Part=x,
            Transparency=y
        }}
    })


  (x)
    ({
        ,
        {x}
    })


 B0={
    ,
    ,
    ,
    ,
    ,
    ,
    ,
    ,
    ,
    ,
}

 B1
 B2

  ()
     H=A4:()
      H   

     P=H.Position+.(,,)
    (.(P),)

     _=, 
        .()
         _,v  (:()) 
             v:() 
                 (v.Position-P).Magnitude< 
                    B1=v
                    
                
            
        
         B1   
    

      B1   

    (B1,)
    (B1)
    (B1,)
    (B1,.(,,))
    (B1,)

     I=
     T=

    B2=A2.Heartbeat:((D)
          B1   B1.Parent 
             B2 
                B2:()
                B2=
            
            
        

        T+=D
         T>= 
            T=
            (B1,B0[I])
            I+=
             I>#B0  I= 
        
    )


  ()
     B2 
        B2:()
        B2=
    
     B1 
        (() (B1) )
        B1=
    
    .()
    ()


A3.CharacterAdded:((C)
    A4=C
    C:().Died:(()
        ()
    )
    ()
)

 A4:() 
    A4.Humanoid.Died:(()
        ()
    )


()
RequestCommand:() 
RequestCommand:()

)


(, , ()
    ()
    
    
     player = .Players.LocalPlayer
 char = player.Character
 tool

 i,v  player:() 
     v.Name ==  
        tool = v.Parent
    

 i,v  .ReplicatedStorage:() 
     v.Name ==  
        tool = v.Parent
    


 remote = tool.SyncAPI.ServerEndpoint
 (args) remote:((args)) 

 (part,boolean)
    ( {, {{Part = part, CanCollide = boolean}}} )

 (boolean,part)
    ( {, {{Part = part, Anchored = boolean}}} )

 (cf,parent)
    ( {,,cf,parent} )

 (part)
    ( {,{part}} )

 (part,cf)
    ( {, {{Part = part,  = cf}}} )

 (part,size,cf)
    ( {, {{Part = part,  = cf, Size = size}}} )

 (part)
    ( {, {{Part = part}}} )

 (part,meshid)
    ( {, {{Part = part, MeshId = ..meshid}}} )

 (part, texid)
    ( {, {{Part = part, TextureId = ..texid}}} )

 (part, stringg)
    ( {,{part},stringg} )

 (part,size)
    ( {, {{Part = part, Scale = size}}} )

 (part1, part2,lead)
    ( {,{part1,part2},lead} )

 (part,boolean)
    ( {,{part},boolean} )

 (part,int)
    ( {, {{Part = part, Transparency = int}}} )

 (part)
    ( {, {{Part = part, LightType = }}} )

 (part,brightness)
    ( {, {{Part = part, LightType = , Brightness = brightness}}} )

 (part,color)
    ( {, {{Part = part, Color = color, UnionColoring = }}} )

 (part,side)
    ( {, {{Part = part, Face = side, TextureType = }}} )

 (part,asset,side)
    ( {, {{Part = part, Face = side, TextureType = , Texture = ..asset}}} )


 (id)
     i,v  .workspace:() 
         v:() 
            (()
                (v,)
                (v,.NormalId.Front) (v,id,.NormalId.Front)
                (v,.NormalId.Back) (v,id,.NormalId.Back)
                (v,.NormalId.Right) (v,id,.NormalId.Right)
                (v,.NormalId.Left) (v,id,.NormalId.Left)
                (v,.NormalId.Bottom) (v,id,.NormalId.Bottom)
                (v,.NormalId.Top) (v,id,.NormalId.Top)
            )
        
     


()

)


(, , ()
    ()
    
    
     player = .Players.LocalPlayer
 char = player.Character  player.CharacterAdded:()
 hrp = char:()
 tool

 _, v  player:() 
     v.Name ==  
        tool = v.Parent
        
    

 _, v  .ReplicatedStorage:() 
     v.Name ==  
        tool = v.Parent
        
    


 remote = tool.SyncAPI.ServerEndpoint
  (args) remote:((args)) 

  (cf, parent)
    ({, , cf, parent})

  (part, cf)
    ({, {{Part = part,  = cf}}})

  (bool, part)
    ({, {{Part = part, Anchored = bool}}})

  (part, bool)
    ({, {part}, bool})

  (part)
    ({, {{Part = part}}})

  (part, size, cf)
    ({, {{Part = part, Size = size,  = cf}}})

  (part, color)
    ({, {{Part = part, Color = color, UnionColoring = }}})

  (part)
    ({, {{Part = part}}})
    ({, {{Part = part, Scale = .(, , )}}})


 padCF = .(hrp.Position.X, hrp.Position.Y - , hrp.Position.Z)
(padCF, )

 pad
 _, v  :() 
     v:()  (v.Position - .(hrp.Position.X, hrp.Position.Y - , hrp.Position.Z)).Magnitude <  
        pad = v
        
    


 pad 
    (, pad)
    (pad, )
    (pad, .(, , ), pad.CFrame)
    (pad, .(, , ))
    (pad)

      
         targetCF = .(hrp.Position.X, hrp.Position.Y - , hrp.Position.Z)
        (pad, targetCF)
        ()
    


)