9 files changed, 72 insertions, 294 deletions

diff --git a/pkg/classes/consoleCmd.go b/pkg/classes/consoleCmd.go
index 75a56eb..aeb56a2 100644
--- a/pkg/classes/consoleCmd.go
+++ b/pkg/classes/consoleCmd.go
@@ -1,10 +1,7 @@
 package classes
 
 import (
-        "strings"
-
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type ConsoleCmd struct {
@@ -15,5 +12,5 @@ type ConsoleCmd struct {
 func (consoleCmd *ConsoleCmd) ParseConsoleCmd(reader *bitreader.Reader) {
         consoleCmd.Size = reader.TryReadSInt32()
         consoleCmd.Data = reader.TryReadStringLength(uint64(consoleCmd.Size))
-        writer.AppendLine("\t%s", strings.TrimSpace(consoleCmd.Data))
+
 }
diff --git a/pkg/classes/customData.go b/pkg/classes/customData.go
index 2dadde4..1fc8a1e 100644
--- a/pkg/classes/customData.go
+++ b/pkg/classes/customData.go
@@ -2,7 +2,6 @@ package classes
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type CustomData struct {
@@ -16,13 +15,13 @@ func (customData *CustomData) ParseCustomData(reader *bitreader.Reader, tickNumb
         customData.Size = reader.TryReadSInt32()
         if customData.Type != 0 || customData.Size == 8 {
                 // Not SAR data
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType)
+
                 customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size)))
-                writer.AppendLine("\t%s", customData.Data)
+
                 return
         }
         // SAR data
-        writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType)
+
         sarData := SarData{}
         data := reader.TryReadBytesToSlice(uint64(customData.Size))
         sarReader := bitreader.NewReaderFromBytes(data, true)
diff --git a/pkg/classes/dataTables.go b/pkg/classes/dataTables.go
index 27ab9e4..64b909e 100644
--- a/pkg/classes/dataTables.go
+++ b/pkg/classes/dataTables.go
@@ -4,7 +4,6 @@ import (
         "fmt"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type DataTables struct {
@@ -46,14 +45,12 @@ func (dataTables *DataTables) ParseDataTables(reader *bitreader.Reader) {
                 count++
                 dataTables.SendTable = append(dataTables.SendTable, ParseSendTable(dataTableReader))
         }
-        writer.AppendLine("\t%d Send Tables:", count)
-        writer.AppendOutputFromTemp()
+
         numOfClasses := dataTableReader.TryReadBits(16)
         for count = 0; count < int(numOfClasses); count++ {
                 dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses)))
         }
-        writer.AppendLine("\t%d Classes:", count)
-        writer.AppendOutputFromTemp()
+
 }
 
 func ParseSendTable(reader *bitreader.Reader) SendTable {
@@ -65,7 +62,7 @@ func ParseSendTable(reader *bitreader.Reader) SendTable {
         if sendTable.NumOfProps < 0 {
                 return sendTable
         }
-        writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps)
+
         for count := 0; count < int(sendTable.NumOfProps); count++ {
                 propType := int8(reader.TryReadBits(5))
                 if propType >= int8(7) {
@@ -77,26 +74,26 @@ func ParseSendTable(reader *bitreader.Reader) SendTable {
                         SendPropFlags: uint32(reader.TryReadBits(19)),
                         Priority:      reader.TryReadUInt8(),
                 }
-                writer.TempAppend("\t\t\t%s\t", prop.SendPropType)
+
                 if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) {
                         prop.ExcludeDtName = reader.TryReadString()
-                        writer.TempAppend(":\t%s\t", prop.ExcludeDtName)
+
                 } else {
                         switch propType {
                         case int8(ESendPropTypeString), int8(ESendPropTypeInt), int8(ESendPropTypeFloat), int8(ESendPropTypeVector3), int8(ESendPropTypeVector2):
                                 prop.LowValue = reader.TryReadFloat32()
                                 prop.HighValue = reader.TryReadFloat32()
                                 prop.NumBits = int32(reader.TryReadBits(7))
-                                writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits)
+
                         case int8(ESendPropTypeArray):
                                 prop.NumElements = int32(reader.TryReadBits(10))
-                                writer.TempAppend("Elements: %d\t", prop.NumElements)
+
                         default:
-                                writer.TempAppend("Unknown Prop Type: %v\t", propType)
+
                                 return sendTable
                         }
                 }
-                writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority)
+
                 sendTable.Props = append(sendTable.Props, prop)
         }
         return sendTable
@@ -108,7 +105,7 @@ func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int)
                 ClassName:     reader.TryReadString(),
                 DataTableName: reader.TryReadString(),
         }
-        writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.ClassId, serverClassInfo.ClassName, serverClassInfo.DataTableName)
+
         return serverClassInfo
 }
 
diff --git a/pkg/classes/packet.go b/pkg/classes/packet.go
index 0bba102..a81cd87 100644
--- a/pkg/classes/packet.go
+++ b/pkg/classes/packet.go
@@ -1,11 +1,7 @@
 package classes
 
 import (
-        "fmt"
-
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/messages"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 const MSSC int = 2
@@ -30,61 +26,8 @@ type CmdInfo struct {
 
 func (packet *Packet) ParsePacket(reader *bitreader.Reader) {
         for count := 0; count < MSSC; count++ {
-                packet.ParseCmdInfo(reader)
-        }
-        packet.InSequence = reader.TryReadUInt32()
-        packet.OutSequence = reader.TryReadUInt32()
-        packet.Size = reader.TryReadUInt32()
-        packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(packet.Size)), true)
-        for {
-                messageType, err := packetReader.ReadBits(6)
-                if err != nil {
-                        break
-                }
-                packet.Data = append(packet.Data, messages.ParseMessages(messageType, packetReader))
-        }
-}
-
-func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader) {
-        packet.PacketInfo = append(packet.PacketInfo, CmdInfo{
-                Flags:            reader.TryReadUInt32(),
-                ViewOrigin:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                ViewAngles:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                LocalViewAngles:  []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                ViewOrigin2:      []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                ViewAngles2:      []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-        })
-        writer.AppendLine("\tFlags: %s", CmdInfoFlags(packet.PacketInfo[len(packet.PacketInfo)-1].Flags).String())
-        writer.AppendLine("\tView Origin: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin)
-        writer.AppendLine("\tView Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles)
-        writer.AppendLine("\tLocal View Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles)
-        writer.AppendLine("\tView Origin 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin2)
-        writer.AppendLine("\tView Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles2)
-        writer.AppendLine("\tLocal View Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles2)
-        writer.AppendLine("")
-}
-
-type CmdInfoFlags int
-
-const (
-        ECmdInfoFlagsNone        = 0
-        ECmdInfoFlagsUseOrigin2  = 1
-        ECmdInfoFlagsUserAngles2 = 1 << 1
-        ECmdInfoFlagsNoInterp    = 1 << 2
-)
-
-func (cmdInfoFlags CmdInfoFlags) String() string {
-        switch cmdInfoFlags {
-        case ECmdInfoFlagsNone:
-                return "None"
-        case ECmdInfoFlagsUseOrigin2:
-                return "UseOrigin2"
-        case ECmdInfoFlagsUserAngles2:
-                return "UserAngles2"
-        case ECmdInfoFlagsNoInterp:
-                return "NoInterp"
-        default:
-                return fmt.Sprintf("%d", int(cmdInfoFlags))
+                reader.SkipBytes(76)
         }
+        reader.SkipBytes(8)
+        reader.TryReadBytesToSlice(uint64(reader.TryReadUInt32()))
 }
diff --git a/pkg/classes/sarData.go b/pkg/classes/sarData.go
index 27e8a64..9e6ae0b 100644
--- a/pkg/classes/sarData.go
+++ b/pkg/classes/sarData.go
@@ -5,7 +5,7 @@ import (
         "fmt"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
+        "github.com/pektezol/demoparser/pkg/verification"
 )
 
 type SarDataType uint8
@@ -164,26 +164,31 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
                 len = 9
         }
         dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true)
-        writer.AppendLine("\tMessage: %s (%d):", sarData.Type.String(), sarData.Type)
         switch sarData.Type {
         case ESarDataTimescaleCheat:
+                fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseTimescaleCheatData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataInitialCVar:
+
                 sarData.Data = parseInitialCVarData(dataReader)
         case ESarDataEntityInputSlot:
                 sarData.Slot = int(dataReader.TryReadBytes(1))
-                writer.AppendLine("\t\tSlot: %d", sarData.Slot)
         case ESarDataEntityInput:
                 sarData.Data = parseEntityInputData(dataReader)
         case ESarDataChecksum:
+                // fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseChecksumData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataChecksumV2:
+                // fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseChecksumV2Data(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
@@ -197,37 +202,50 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
                         sarData.Slot = slot
                 }
         case ESarDataChallengeFlags, ESarDataCrouchFly:
+                // fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Slot, err = parseChallengeFlagsCrouchFlyData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
-                writer.AppendLine("\t\tSlot: %d", sarData.Slot)
+                // fmt.Printf("\t\tSlot: %d\n", sarData.Slot)
         case ESarDataPause:
+                fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parsePauseData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataWaitRun:
+                fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseWaitRunData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataHWaitRun:
+                fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseHWaitRunData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataSpeedrunTime:
+                fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseSpeedrunTimeData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataTimestamp:
+                // fmt.Printf("\tMessage: %s (%d):\n", sarData.Type.String(), sarData.Type)
+
                 sarData.Data, err = parseTimestampData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
                 }
         case ESarDataFileChecksum:
+
                 sarData.Data, err = parseFileChecksumData(dataReader, len)
                 if err != nil {
                         sarData.Data = nil
@@ -246,7 +264,7 @@ func parseTimescaleCheatData(reader *bitreader.Reader, length uint64) (SarDataTi
         sarDataTimescaleCheat := SarDataTimescaleCheat{
                 Timescale: reader.TryReadFloat32(),
         }
-        writer.AppendLine("\t\tTimescale: %f", sarDataTimescaleCheat.Timescale)
+        fmt.Printf("\t\tTimescale: %f\n", sarDataTimescaleCheat.Timescale)
         return sarDataTimescaleCheat, nil
 }
 
@@ -255,7 +273,7 @@ func parseInitialCVarData(reader *bitreader.Reader) SarDataInitialCVar {
                 CVar: reader.TryReadString(),
                 Val:  reader.TryReadString(),
         }
-        writer.AppendLine("\t\tCvar: \"%s\" = \"%s\"", sarDataInitialCvar.CVar, sarDataInitialCvar.Val)
+        // fmt.Printf("\t\tCvar: \"%s\" = \"%s\"\n", sarDataInitialCvar.CVar, sarDataInitialCvar.Val)
         return sarDataInitialCvar
 }
 
@@ -266,10 +284,10 @@ func parseEntityInputData(reader *bitreader.Reader) SarDataEntityInput {
                 InputName:  reader.TryReadString(),
                 Parameter:  reader.TryReadString(),
         }
-        writer.AppendLine("\t\tTarget: %s", sarDataEntityInput.TargetName)
-        writer.AppendLine("\t\tClass: %s", sarDataEntityInput.ClassName)
-        writer.AppendLine("\t\tInput: %s", sarDataEntityInput.InputName)
-        writer.AppendLine("\t\tParameter: %s", sarDataEntityInput.Parameter)
+        // fmt.Printf("\t\tTarget: %s\n", sarDataEntityInput.TargetName)
+        // fmt.Printf("\t\tClass: %s\n", sarDataEntityInput.ClassName)
+        // fmt.Printf("\t\tInput: %s\n", sarDataEntityInput.InputName)
+        // fmt.Printf("\t\tParameter: %s\n", sarDataEntityInput.Parameter)
         return sarDataEntityInput
 }
 
@@ -281,8 +299,8 @@ func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum
                 DemoSum: reader.TryReadUInt32(),
                 SarSum:  reader.TryReadUInt32(),
         }
-        writer.AppendLine("\t\tDemo Checksum: %d", sarDataChecksum.DemoSum)
-        writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksum.SarSum)
+        // fmt.Printf("\t\tDemo Checksum: %d\n", sarDataChecksum.DemoSum)
+        // fmt.Printf("\t\tSAR Checksum: %d\n", sarDataChecksum.SarSum)
         return sarDataChecksum, nil
 }
 
@@ -294,8 +312,8 @@ func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecks
                 SarSum:    reader.TryReadUInt32(),
                 Signature: [64]byte(reader.TryReadBytesToSlice(60)),
         }
-        writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksumV2.SarSum)
-        writer.AppendLine("\t\tSignature: %v", sarDataChecksumV2.Signature)
+        // fmt.Printf("\t\tSAR Checksum: %d\n", sarDataChecksumV2.SarSum)
+        // fmt.Printf("\t\tSignature: %v\n", sarDataChecksumV2.Signature)
         return sarDataChecksumV2, nil
 }
 
@@ -312,10 +330,10 @@ func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataP
                 Y:      reader.TryReadFloat32(),
                 Z:      reader.TryReadFloat32(),
         }
-        writer.AppendLine("\t\tOrange: %t", orange)
-        writer.AppendLine("\t\tX: %f", sarDataPortalPlacement.X)
-        writer.AppendLine("\t\tY: %f", sarDataPortalPlacement.Y)
-        writer.AppendLine("\t\tZ: %f", sarDataPortalPlacement.Z)
+        // fmt.Printf("\t\tOrange: %t\n", orange)
+        // fmt.Printf("\t\tX: %f\n", sarDataPortalPlacement.X)
+        // fmt.Printf("\t\tY: %f\n", sarDataPortalPlacement.Y)
+        // fmt.Printf("\t\tZ: %f\n", sarDataPortalPlacement.Z)
         return sarDataPortalPlacement, slot, nil
 }
 
@@ -333,7 +351,7 @@ func parsePauseData(reader *bitreader.Reader, length uint64) (SarDataPause, erro
         sarDataPause := SarDataPause{
                 PauseTicks: reader.TryReadUInt32(),
         }
-        writer.AppendLine("\t\tPause Ticks: %d", sarDataPause.PauseTicks)
+        fmt.Printf("\t\tPause Ticks: %d\n", sarDataPause.PauseTicks)
         return sarDataPause, nil
 }
 
@@ -345,8 +363,8 @@ func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun,
                 Ticks: int(reader.TryReadUInt32()),
                 Cmd:   reader.TryReadString(),
         }
-        writer.AppendLine("\t\tTicks: %d", sarDataWaitRun.Ticks)
-        writer.AppendLine("\t\tCmd: \"%s\"", sarDataWaitRun.Cmd)
+        fmt.Printf("\t\tTicks: %d\n", sarDataWaitRun.Ticks)
+        fmt.Printf("\t\tCmd: \"%s\"\n", sarDataWaitRun.Cmd)
         return sarDataWaitRun, nil
 }
 
@@ -358,8 +376,8 @@ func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun
                 Ticks: int(reader.TryReadUInt32()),
                 Cmd:   reader.TryReadString(),
         }
-        writer.AppendLine("\t\tTicks: %d", sarDataHWaitRun.Ticks)
-        writer.AppendLine("\t\tCmd: \"%s\"", sarDataHWaitRun.Cmd)
+        fmt.Printf("\t\tTicks: %d\n", sarDataHWaitRun.Ticks)
+        fmt.Printf("\t\tCmd: \"%s\"\n", sarDataHWaitRun.Cmd)
         return sarDataHWaitRun, nil
 }
 
@@ -372,14 +390,15 @@ func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpee
         for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ {
                 splits[splitCount].Name = reader.TryReadString()
                 splits[splitCount].NSegs = reader.TryReadUInt32()
-                writer.AppendLine("\t\t[%d] Split Name: \"%s\"", splitCount, splits[splitCount].Name)
-                writer.AppendLine("\t\t[%d] Number of Segments: %d", splitCount, splits[splitCount].NSegs)
+                fmt.Printf("\t\t[%d] Split Name: \"%s\"\n", splitCount, splits[splitCount].Name)
+                fmt.Printf("\t\t[%d] Number of Segments: %d\n", splitCount, splits[splitCount].NSegs)
                 splits[splitCount].Segs = make([]SarDataSpeedrunTimeSegs, splits[splitCount].NSegs)
                 for segCount := 0; segCount < int(splits[splitCount].NSegs); segCount++ {
                         splits[splitCount].Segs[segCount].Name = reader.TryReadString()
                         splits[splitCount].Segs[segCount].Ticks = reader.TryReadUInt32()
-                        writer.AppendLine("\t\t\t[%d] Segment Name: \"%s\"", segCount, splits[splitCount].Segs[segCount].Name)
-                        writer.AppendLine("\t\t\t[%d] Segment Ticks: %d", segCount, splits[splitCount].Segs[segCount].Ticks)
+                        verification.Ticks += splits[splitCount].Segs[segCount].Ticks
+                        fmt.Printf("\t\t\t[%d] Segment Name: \"%s\"\n", segCount, splits[splitCount].Segs[segCount].Name)
+                        fmt.Printf("\t\t\t[%d] Segment Ticks: %d\n", segCount, splits[splitCount].Segs[segCount].Ticks)
                 }
         }
         return SarDataSpeedrunTime{
@@ -401,12 +420,12 @@ func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimesta
                 Minute: timestamp[5],
                 Second: timestamp[6],
         }
-        writer.AppendLine("\t\tYear: %d", sarDataTimeStamp.Year)
-        writer.AppendLine("\t\tMonth: %d", sarDataTimeStamp.Month)
-        writer.AppendLine("\t\tDay: %d", sarDataTimeStamp.Day)
-        writer.AppendLine("\t\tHour: %d", sarDataTimeStamp.Hour)
-        writer.AppendLine("\t\tMinute: %d", sarDataTimeStamp.Minute)
-        writer.AppendLine("\t\tSecond: %d", sarDataTimeStamp.Second)
+        // fmt.Printf("\t\tYear: %d\n", sarDataTimeStamp.Year)
+        // fmt.Printf("\t\tMonth: %d\n", sarDataTimeStamp.Month)
+        // fmt.Printf("\t\tDay: %d\n", sarDataTimeStamp.Day)
+        // fmt.Printf("\t\tHour: %d\n", sarDataTimeStamp.Hour)
+        // fmt.Printf("\t\tMinute: %d\n", sarDataTimeStamp.Minute)
+        // fmt.Printf("\t\tSecond: %d\n", sarDataTimeStamp.Second)
         return sarDataTimeStamp, nil
 }
 
@@ -418,7 +437,7 @@ func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFile
                 Sum:  reader.TryReadUInt32(),
                 Path: reader.TryReadString(),
         }
-        writer.AppendLine("\t\tChecksum: %d", sarDataFileChecksum.Sum)
-        writer.AppendLine("\t\tPath: \"%s\"", sarDataFileChecksum.Path)
+        // fmt.Printf("\t\tChecksum: %d\n", sarDataFileChecksum.Sum)
+        // fmt.Printf("\t\tPath: \"%s\"\n", sarDataFileChecksum.Path)
         return sarDataFileChecksum, nil
 }
diff --git a/pkg/classes/signOn.go b/pkg/classes/signOn.go
deleted file mode 100644
index fad696c..0000000
--- a/pkg/classes/signOn.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package classes
-
-import (
-        "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/messages"
-        "github.com/pektezol/demoparser/pkg/writer"
-)
-
-type SignOn struct {
-        PacketInfo  []CmdInfo
-        InSequence  uint32
-        OutSequence uint32
-        Size        uint32
-        Data        []any
-}
-
-func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader) {
-        for count := 0; count < MSSC; count++ {
-                signOn.ParseCmdInfo(reader)
-        }
-        signOn.InSequence = reader.TryReadUInt32()
-        signOn.OutSequence = reader.TryReadUInt32()
-        signOn.Size = reader.TryReadUInt32()
-        packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(signOn.Size)), true)
-        for {
-                messageType, err := packetReader.ReadBits(6)
-                if err != nil {
-                        break
-                }
-                signOn.Data = append(signOn.Data, messages.ParseMessages(messageType, packetReader))
-        }
-}
-
-func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader) {
-        signOn.PacketInfo = append(signOn.PacketInfo, CmdInfo{
-                Flags:            reader.TryReadUInt32(),
-                ViewOrigin:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                ViewAngles:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                LocalViewAngles:  []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                ViewOrigin2:      []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                ViewAngles2:      []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-                LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
-        })
-        writer.AppendLine("\tFlags: %s", CmdInfoFlags(signOn.PacketInfo[len(signOn.PacketInfo)-1].Flags).String())
-        writer.AppendLine("\tView Origin: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin)
-        writer.AppendLine("\tView Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles)
-        writer.AppendLine("\tLocal View Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles)
-        writer.AppendLine("\tView Origin 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin2)
-        writer.AppendLine("\tView Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles2)
-        writer.AppendLine("\tLocal View Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles2)
-        writer.AppendLine("")
-}
diff --git a/pkg/classes/stop.go b/pkg/classes/stop.go
deleted file mode 100644
index 753be19..0000000
--- a/pkg/classes/stop.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package classes
-
-import (
-        "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
-)
-
-type Stop struct {
-        RemainingData []byte
-}
-
-func (stop *Stop) ParseStop(reader *bitreader.Reader) {
-        if reader.TryReadBool() {
-                stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
-                writer.AppendLine("\tRemaining Data: %v", stop.RemainingData)
-        }
-}
diff --git a/pkg/classes/stringTables.go b/pkg/classes/stringTables.go
deleted file mode 100644
index 01939b2..0000000
--- a/pkg/classes/stringTables.go
+++ /dev/null
@@ -1,100 +0,0 @@
-package classes
-
-import (
-        "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
-)
-
-type StringTables struct {
-        Size int32
-        Data []StringTable
-}
-
-type StringTable struct {
-        Name         string
-        TableEntries []StringTableEntry
-        Classes      []StringTableClass
-}
-
-type StringTableEntry struct {
-        Name      string
-        EntryData StringTableEntryData
-}
-
-type StringTableEntryData struct {
-        // TODO: Parse StringTableEntry
-}
-
-type StringTableClass struct {
-        Name string
-        Data string
-}
-
-func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader) {
-        stringTables.Size = reader.TryReadSInt32()
-        stringTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(stringTables.Size)), true)
-        tableCount := stringTableReader.TryReadBits(8)
-        tables := make([]StringTable, tableCount)
-        for i := 0; i < int(tableCount); i++ {
-                var table StringTable
-                table.ParseStream(stringTableReader)
-                tables[i] = table
-        }
-        stringTables.Data = tables
-}
-
-func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
-        stringTable.Name = reader.TryReadString()
-        entryCount := reader.TryReadBits(16)
-        writer.AppendLine("\tTable Name: %s", stringTable.Name)
-        stringTable.TableEntries = make([]StringTableEntry, entryCount)
-
-        for i := 0; i < int(entryCount); i++ {
-                var entry StringTableEntry
-                entry.Parse(reader)
-                stringTable.TableEntries[i] = entry
-        }
-        if entryCount != 0 {
-                writer.AppendLine("\t\t%d Table Entries:", entryCount)
-                writer.AppendOutputFromTemp()
-        } else {
-                writer.AppendLine("\t\tNo Table Entries")
-        }
-        if reader.TryReadBool() {
-                classCount := reader.TryReadBits(16)
-                stringTable.Classes = make([]StringTableClass, classCount)
-
-                for i := 0; i < int(classCount); i++ {
-                        var class StringTableClass
-                        class.Parse(reader)
-                        stringTable.Classes[i] = class
-                }
-                writer.AppendLine("\t\t%d Classes:", classCount)
-                writer.AppendOutputFromTemp()
-        } else {
-                writer.AppendLine("\t\tNo Class Entries")
-        }
-}
-
-func (stringTableEntry *StringTableEntry) Parse(reader *bitreader.Reader) {
-        stringTableEntry.Name = reader.TryReadString()
-        if reader.TryReadBool() {
-                byteLen, err := reader.ReadBits(16)
-                if err != nil {
-                        return
-                }
-                dataBsr := reader.TryReadBytesToSlice(byteLen)
-                _ = bitreader.NewReaderFromBytes(dataBsr, true) // TODO: Parse StringTableEntry
-                // stringTableEntry.EntryData.ParseStream(entryReader)
-        }
-}
-
-func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader) {
-        stringTableClass.Name = reader.TryReadString()
-        writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name)
-        if reader.TryReadBool() {
-                dataLen := reader.TryReadBits(16)
-                stringTableClass.Data = reader.TryReadStringLength(dataLen)
-                writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data)
-        }
-}
diff --git a/pkg/classes/userCmd.go b/pkg/classes/userCmd.go
index 24969f1..c793612 100644
--- a/pkg/classes/userCmd.go
+++ b/pkg/classes/userCmd.go
@@ -2,7 +2,6 @@ package classes
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type UserCmd struct {
@@ -78,14 +77,7 @@ func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader) {
         if reader.TryReadBool() {
                 userCmd.Data.MouseDy = reader.TryReadUInt16()
         }
-        writer.AppendLine("\tCommand Number: %v", userCmd.Data.CommandNumber)
-        writer.AppendLine("\tTick Count: %v", userCmd.Data.TickCount)
-        writer.AppendLine("\tView Angles: %v", []float32{userCmd.Data.ViewAnglesX, userCmd.Data.ViewAnglesY, userCmd.Data.ViewAnglesZ})
-        writer.AppendLine("\tMovement: %v", []float32{userCmd.Data.ForwardMove, userCmd.Data.SideMove, userCmd.Data.UpMove})
-        writer.AppendLine("\tButtons: %v", Buttons(userCmd.Data.Buttons).GetButtons())
-        writer.AppendLine("\tImpulse: %v", userCmd.Data.Impulse)
-        writer.AppendLine("\tWeapon, Subtype: %v, %v", userCmd.Data.WeaponSelect, userCmd.Data.WeaponSubType)
-        writer.AppendLine("\tMouse Dx, Mouse Dy: %v, %v", userCmd.Data.MouseDx, userCmd.Data.MouseDy)
+
 }
 
 func (button Buttons) GetButtons() []string {