48 files changed, 189 insertions, 504 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 {
diff --git a/pkg/messages/messages.go b/pkg/messages/messages.go
index 5cc781d..cf2d1dc 100644
--- a/pkg/messages/messages.go
+++ b/pkg/messages/messages.go
@@ -1,11 +1,8 @@
 package messages
 
 import (
-        "reflect"
-
         "github.com/pektezol/bitreader"
         messages "github.com/pektezol/demoparser/pkg/messages/types"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 func ParseMessages(messageType uint64, reader *bitreader.Reader) any {
@@ -82,7 +79,6 @@ func ParseMessages(messageType uint64, reader *bitreader.Reader) any {
         default:
                 return nil
         }
-        writer.AppendLine("\tMessage: %s (%d):", reflect.ValueOf(messageData).Type(), messageType)
-        writer.AppendOutputFromTemp()
+
         return messageData
 }
diff --git a/pkg/messages/types/netDisconnect.go b/pkg/messages/types/netDisconnect.go
index c2e22c1..ac5139f 100644
--- a/pkg/messages/types/netDisconnect.go
+++ b/pkg/messages/types/netDisconnect.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetDisconnect struct {
@@ -13,6 +12,5 @@ func ParseNetDisconnect(reader *bitreader.Reader) NetDisconnect {
         netDisconnect := NetDisconnect{
                 Text: reader.TryReadString(),
         }
-        writer.TempAppendLine("\t\tText: %s", netDisconnect.Text)
         return netDisconnect
 }
diff --git a/pkg/messages/types/netFile.go b/pkg/messages/types/netFile.go
index 4ebd770..fc65229 100644
--- a/pkg/messages/types/netFile.go
+++ b/pkg/messages/types/netFile.go
@@ -4,7 +4,6 @@ import (
         "fmt"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetFile struct {
@@ -40,8 +39,6 @@ func ParseNetFile(reader *bitreader.Reader) NetFile {
                 FileName:   reader.TryReadString(),
                 FileFlags:  NetFileFlags(reader.TryReadBits(2)).String(),
         }
-        writer.TempAppendLine("\t\tTransfer ID: %d", netFile.TransferId)
-        writer.TempAppendLine("\t\tFile Name: %s", netFile.FileName)
-        writer.TempAppendLine("\t\tFile Flags: %s", netFile.FileFlags)
+
         return netFile
 }
diff --git a/pkg/messages/types/netNop.go b/pkg/messages/types/netNop.go
index 0ee1d0d..826da6b 100644
--- a/pkg/messages/types/netNop.go
+++ b/pkg/messages/types/netNop.go
@@ -2,12 +2,11 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetNop struct{}
 
 func ParseNetNop(reader *bitreader.Reader) NetNop {
-        writer.TempAppendLine("\t\t{}")
+
         return NetNop{}
 }
diff --git a/pkg/messages/types/netSetConVar.go b/pkg/messages/types/netSetConVar.go
index 530cb6b..03e9e0d 100644
--- a/pkg/messages/types/netSetConVar.go
+++ b/pkg/messages/types/netSetConVar.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetSetConVar struct {
@@ -18,13 +17,13 @@ type conVar struct {
 func ParseNetSetConVar(reader *bitreader.Reader) NetSetConVar {
         length := reader.TryReadUInt8()
         convars := []conVar{}
-        writer.TempAppendLine("\t\tLength: %d", length)
+
         for count := 0; count < int(length); count++ {
                 convar := conVar{
                         Name:  reader.TryReadString(),
                         Value: reader.TryReadString(),
                 }
-                writer.TempAppendLine("\t\t[%d] %s: %s", count, convar.Name, convar.Value)
+
                 convars = append(convars, convar)
         }
         return NetSetConVar{
diff --git a/pkg/messages/types/netSignOnState.go b/pkg/messages/types/netSignOnState.go
index f784b0a..65e17a4 100644
--- a/pkg/messages/types/netSignOnState.go
+++ b/pkg/messages/types/netSignOnState.go
@@ -4,7 +4,6 @@ import (
         "fmt"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetSignOnState struct {
@@ -60,17 +59,15 @@ func ParseNetSignOnState(reader *bitreader.Reader) NetSignOnState {
                 NumServerPlayers: reader.TryReadUInt32(),
                 IdsLength:        reader.TryReadUInt32(),
         }
-        writer.TempAppendLine("\t\tSign On State: %s", netSignOnState.SignOnState)
-        writer.TempAppendLine("\t\tSpawn Count: %d", netSignOnState.SpawnCount)
-        writer.TempAppendLine("\t\tNumber Of Server Players: %d", netSignOnState.NumServerPlayers)
+
         if netSignOnState.IdsLength > 0 {
                 netSignOnState.PlayersNetworksIds = reader.TryReadBytesToSlice(uint64(netSignOnState.IdsLength))
-                writer.TempAppendLine("\t\tPlayer Network IDs: %v", netSignOnState.PlayersNetworksIds)
+
         }
         netSignOnState.MapNameLength = reader.TryReadUInt32()
         if netSignOnState.MapNameLength > 0 {
                 netSignOnState.MapName = reader.TryReadStringLength(uint64(netSignOnState.MapNameLength))
-                writer.TempAppendLine("\t\tMap Name: %s", netSignOnState.MapName)
+
         }
         return netSignOnState
 }
diff --git a/pkg/messages/types/netSplitScreenUser.go b/pkg/messages/types/netSplitScreenUser.go
index 6068a28..8b14f63 100644
--- a/pkg/messages/types/netSplitScreenUser.go
+++ b/pkg/messages/types/netSplitScreenUser.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetSplitScreenUser struct {
@@ -13,6 +12,6 @@ func ParseNetSplitScreenUser(reader *bitreader.Reader) NetSplitScreenUser {
         netSplitScreenUser := NetSplitScreenUser{
                 Slot: reader.TryReadBool(),
         }
-        writer.TempAppendLine("\t\tSlot: %t", netSplitScreenUser.Slot)
+
         return netSplitScreenUser
 }
diff --git a/pkg/messages/types/netStringCmd.go b/pkg/messages/types/netStringCmd.go
index 57ae813..2f7e830 100644
--- a/pkg/messages/types/netStringCmd.go
+++ b/pkg/messages/types/netStringCmd.go
@@ -1,10 +1,7 @@
 package messages
 
 import (
-        "strings"
-
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetStringCmd struct {
@@ -15,6 +12,6 @@ func ParseNetStringCmd(reader *bitreader.Reader) NetStringCmd {
         netStringCmd := NetStringCmd{
                 Command: reader.TryReadString(),
         }
-        writer.TempAppendLine("\t\tCommand: \"%s\"", strings.TrimSpace(netStringCmd.Command))
+
         return netStringCmd
 }
diff --git a/pkg/messages/types/netTick.go b/pkg/messages/types/netTick.go
index 1c01171..49e997e 100644
--- a/pkg/messages/types/netTick.go
+++ b/pkg/messages/types/netTick.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type NetTick struct {
@@ -17,8 +16,6 @@ func ParseNetTick(reader *bitreader.Reader) NetTick {
                 HostFrameTime:             float32(reader.TryReadUInt16()) / 1e5,
                 HostFrameTimeStdDeviation: float32(reader.TryReadUInt16()) / 1e5,
         }
-        writer.TempAppendLine("\t\tTick: %d", netTick.Tick)
-        writer.TempAppendLine("\t\tHost Frame Time: %f", netTick.HostFrameTime)
-        writer.TempAppendLine("\t\tHost Frame Time Std Deviation: %f", netTick.HostFrameTimeStdDeviation)
+
         return netTick
 }
diff --git a/pkg/messages/types/svcBspDecal.go b/pkg/messages/types/svcBspDecal.go
index cf94c1d..6bf96a3 100644
--- a/pkg/messages/types/svcBspDecal.go
+++ b/pkg/messages/types/svcBspDecal.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcBspDecal struct {
@@ -28,11 +27,7 @@ func ParseSvcBspDecal(reader *bitreader.Reader) SvcBspDecal {
                 svcBspDecal.ModelIndex = uint16(reader.TryReadBits(11))
         }
         svcBspDecal.LowPriority = reader.TryReadBool()
-        writer.TempAppendLine("\t\tPosition: %v", svcBspDecal.Pos)
-        writer.TempAppendLine("\t\tDecal Texture Index: %d", svcBspDecal.DecalTextureIndex)
-        writer.TempAppendLine("\t\tEntity Index: %d", svcBspDecal.EntityIndex)
-        writer.TempAppendLine("\t\tModel Index: %d", svcBspDecal.ModelIndex)
-        writer.TempAppendLine("\t\tLow Priority: %t", svcBspDecal.LowPriority)
+
         return svcBspDecal
 }
 
diff --git a/pkg/messages/types/svcClassInfo.go b/pkg/messages/types/svcClassInfo.go
index 384c501..4677946 100644
--- a/pkg/messages/types/svcClassInfo.go
+++ b/pkg/messages/types/svcClassInfo.go
@@ -4,7 +4,6 @@ import (
         "math"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcClassInfo struct {
@@ -25,19 +24,19 @@ func ParseSvcClassInfo(reader *bitreader.Reader) SvcClassInfo {
                 CreateOnClient: reader.TryReadBool(),
         }
         classes := []serverClass{}
-        writer.TempAppendLine("\t\tCreate On Client: %t", svcClassInfo.CreateOnClient)
+
         if !svcClassInfo.CreateOnClient {
-                writer.TempAppendLine("\t\t%d Server Classes:", svcClassInfo.ClassCount)
+
                 for count := 0; count < int(svcClassInfo.ClassCount); count++ {
                         classes = append(classes, serverClass{
                                 ClassId:       int16(reader.TryReadBits(uint64(math.Log2(float64(svcClassInfo.ClassCount)) + 1))),
                                 ClassName:     reader.TryReadString(),
                                 DataTableName: reader.TryReadString(),
                         })
-                        writer.TempAppendLine("\t\t\t[%d] %s (%s)", classes[len(classes)-1].ClassId, classes[len(classes)-1].ClassName, classes[len(classes)-1].DataTableName)
+
                 }
         } else {
-                writer.TempAppendLine("\t\t%d Server Classes", svcClassInfo.ClassCount)
+
         }
         svcClassInfo.ServerClasses = classes
         return svcClassInfo
diff --git a/pkg/messages/types/svcCmdKeyValues.go b/pkg/messages/types/svcCmdKeyValues.go
index 5c80d0b..61d6290 100644
--- a/pkg/messages/types/svcCmdKeyValues.go
+++ b/pkg/messages/types/svcCmdKeyValues.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcCmdKeyValues struct {
@@ -15,6 +14,6 @@ func ParseSvcCmdKeyValues(reader *bitreader.Reader) SvcCmdKeyValues {
                 Length: reader.TryReadUInt32(),
         }
         svcCmdKeyValues.Data = reader.TryReadBytesToSlice(uint64(svcCmdKeyValues.Length))
-        writer.TempAppendLine("\t\tData: %v", svcCmdKeyValues.Data)
+
         return svcCmdKeyValues
 }
diff --git a/pkg/messages/types/svcCreateStringTable.go b/pkg/messages/types/svcCreateStringTable.go
index ff2e27d..8d36fcf 100644
--- a/pkg/messages/types/svcCreateStringTable.go
+++ b/pkg/messages/types/svcCreateStringTable.go
@@ -4,7 +4,6 @@ import (
         "math"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcCreateStringTable struct {
@@ -32,13 +31,7 @@ func ParseSvcCreateStringTable(reader *bitreader.Reader) SvcCreateStringTable {
                 svcCreateStringTable.UserDataSizeBits = int8(reader.TryReadBits(4))
         }
         svcCreateStringTable.Flags = int8(reader.TryReadBits(2))
-        writer.TempAppendLine("\t\tName: %s", svcCreateStringTable.Name)
-        writer.TempAppendLine("\t\tMax Enties: %d", svcCreateStringTable.MaxEntries)
-        writer.TempAppendLine("\t\tNumber Of Entiries: %d", svcCreateStringTable.NumEntries)
-        writer.TempAppendLine("\t\tUser Data Fixed Size: %t", svcCreateStringTable.UserDataFixedSize)
-        writer.TempAppendLine("\t\tUser Data Size: %d", svcCreateStringTable.UserDataSize)
-        writer.TempAppendLine("\t\tUser Data Size In Bits: %d", svcCreateStringTable.UserDataSizeBits)
-        writer.TempAppendLine("\t\tFlags: %d", svcCreateStringTable.Flags)
+
         reader.SkipBits(uint64(svcCreateStringTable.Length)) // TODO: StringTable parsing
         return svcCreateStringTable
 }
diff --git a/pkg/messages/types/svcCrosshairAngle.go b/pkg/messages/types/svcCrosshairAngle.go
index efd6d77..f689876 100644
--- a/pkg/messages/types/svcCrosshairAngle.go
+++ b/pkg/messages/types/svcCrosshairAngle.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcCrosshairAngle struct {
@@ -23,8 +22,6 @@ func ParseSvcCrosshairAngle(reader *bitreader.Reader) SvcCrosshairAngle {
                         Z: float32(reader.TryReadBits(16)),
                 },
         }
-        writer.TempAppendLine("\t\tX: %f", svcCrosshairAngle.Angle.X)
-        writer.TempAppendLine("\t\tY: %f", svcCrosshairAngle.Angle.Y)
-        writer.TempAppendLine("\t\tZ: %f", svcCrosshairAngle.Angle.Z)
+
         return svcCrosshairAngle
 }
diff --git a/pkg/messages/types/svcEntityMessage.go b/pkg/messages/types/svcEntityMessage.go
index a511fea..c4676ec 100644
--- a/pkg/messages/types/svcEntityMessage.go
+++ b/pkg/messages/types/svcEntityMessage.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcEntityMessage struct {
@@ -19,8 +18,6 @@ func ParseSvcEntityMessage(reader *bitreader.Reader) SvcEntityMessage {
                 Length:      uint16(reader.TryReadBits(11)),
         }
         svcEntityMessage.Data = reader.TryReadBitsToSlice(uint64(svcEntityMessage.Length))
-        writer.TempAppendLine("\t\tEntity Index: %d", svcEntityMessage.EntityIndex)
-        writer.TempAppendLine("\t\tClass ID: %d", svcEntityMessage.ClassId)
-        writer.TempAppendLine("\t\tData: %v", svcEntityMessage.Data)
+
         return svcEntityMessage
 }
diff --git a/pkg/messages/types/svcFixAngle.go b/pkg/messages/types/svcFixAngle.go
index b79c02d..f00c239 100644
--- a/pkg/messages/types/svcFixAngle.go
+++ b/pkg/messages/types/svcFixAngle.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcFixAngle struct {
@@ -25,9 +24,6 @@ func ParseSvcFixAngle(reader *bitreader.Reader) SvcFixAngle {
                         Z: float32(reader.TryReadBits(16)),
                 },
         }
-        writer.TempAppendLine("\t\tRelative: %t", svcFixAngle.Relative)
-        writer.TempAppendLine("\t\tX: %f", svcFixAngle.Angle.X)
-        writer.TempAppendLine("\t\tY: %f", svcFixAngle.Angle.Y)
-        writer.TempAppendLine("\t\tZ: %f", svcFixAngle.Angle.Z)
+
         return svcFixAngle
 }
diff --git a/pkg/messages/types/svcGameEvent.go b/pkg/messages/types/svcGameEvent.go
index e12d75a..ec96653 100644
--- a/pkg/messages/types/svcGameEvent.go
+++ b/pkg/messages/types/svcGameEvent.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcGameEvent struct {
@@ -15,6 +14,6 @@ func ParseSvcGameEvent(reader *bitreader.Reader) SvcGameEvent {
                 Length: uint16(reader.TryReadBits(11)),
         }
         svcGameEvent.Data = reader.TryReadBitsToSlice(uint64(svcGameEvent.Length))
-        writer.TempAppendLine("\t\tData: %v", svcGameEvent.Data)
+
         return svcGameEvent
 }
diff --git a/pkg/messages/types/svcGameEventList.go b/pkg/messages/types/svcGameEventList.go
index 1fa7589..ca2cf76 100644
--- a/pkg/messages/types/svcGameEventList.go
+++ b/pkg/messages/types/svcGameEventList.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcGameEventList struct {
@@ -20,6 +19,6 @@ func ParseSvcGameEventList(reader *bitreader.Reader) SvcGameEventList {
                 Length: int32(reader.TryReadBits(20)),
         }
         reader.TryReadBitsToSlice(uint64(svcGameEventList.Length))
-        writer.TempAppendLine("\t\tEvents: %d", svcGameEventList.Events)
+
         return svcGameEventList
 }
diff --git a/pkg/messages/types/svcGetCvarValue.go b/pkg/messages/types/svcGetCvarValue.go
index 939e6b6..b0513d0 100644
--- a/pkg/messages/types/svcGetCvarValue.go
+++ b/pkg/messages/types/svcGetCvarValue.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcGetCvarValue struct {
@@ -15,7 +14,6 @@ func ParseSvcGetCvarValue(reader *bitreader.Reader) SvcGetCvarValue {
                 Cookie:   reader.TryReadSInt32(),
                 CvarName: reader.TryReadString(),
         }
-        writer.TempAppendLine("\t\tCookie: %d", svcGetCvarValue.Cookie)
-        writer.TempAppendLine("\t\tCvar: \"%s\"", svcGetCvarValue.CvarName)
+
         return svcGetCvarValue
 }
diff --git a/pkg/messages/types/svcMenu.go b/pkg/messages/types/svcMenu.go
index 33ccb70..df14048 100644
--- a/pkg/messages/types/svcMenu.go
+++ b/pkg/messages/types/svcMenu.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcMenu struct {
@@ -17,7 +16,6 @@ func ParseSvcMenu(reader *bitreader.Reader) SvcMenu {
                 Length: reader.TryReadUInt32(),
         }
         svcMenu.Data = reader.TryReadBitsToSlice(uint64(svcMenu.Length))
-        writer.TempAppendLine("\t\tType: %d", svcMenu.Type)
-        writer.TempAppendLine("\t\tData: %v", svcMenu.Data)
+
         return svcMenu
 }
diff --git a/pkg/messages/types/svcPacketEntities.go b/pkg/messages/types/svcPacketEntities.go
index 05b6794..8000a55 100644
--- a/pkg/messages/types/svcPacketEntities.go
+++ b/pkg/messages/types/svcPacketEntities.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcPacketEntities struct {
@@ -31,12 +30,6 @@ func ParseSvcPacketEntities(reader *bitreader.Reader) SvcPacketEntities {
         svcPacketEntities.Length = uint32(reader.TryReadBits(20))
         svcPacketEntities.UpdatedBaseline = reader.TryReadBool()
         svcPacketEntities.Data = reader.TryReadBitsToSlice(uint64(svcPacketEntities.Length))
-        writer.TempAppendLine("\t\tMax Entries: %d", svcPacketEntities.MaxEntries)
-        writer.TempAppendLine("\t\tIs Delta: %t", svcPacketEntities.IsDelta)
-        writer.TempAppendLine("\t\tDelta From: %d", svcPacketEntities.DeltaFrom)
-        writer.TempAppendLine("\t\tBaseline: %t", svcPacketEntities.BaseLine)
-        writer.TempAppendLine("\t\tUpdated Baseline: %t", svcPacketEntities.UpdatedBaseline)
-        writer.TempAppendLine("\t\t%d Updated Entries:", svcPacketEntities.UpdatedEntries)
-        writer.TempAppendLine("\t\tData: %v", svcPacketEntities.Data)
+
         return svcPacketEntities
 }
diff --git a/pkg/messages/types/svcPaintmapData.go b/pkg/messages/types/svcPaintmapData.go
index 40f6ad0..49aa433 100644
--- a/pkg/messages/types/svcPaintmapData.go
+++ b/pkg/messages/types/svcPaintmapData.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcPaintmapData struct {
@@ -15,6 +14,6 @@ func ParseSvcPaintmapData(reader *bitreader.Reader) SvcPaintmapData {
                 Length: reader.TryReadUInt32(),
         }
         svcPaintmapData.Data = reader.TryReadBitsToSlice(uint64(svcPaintmapData.Length))
-        writer.TempAppendLine("\t\tData: %v", svcPaintmapData.Data)
+
         return svcPaintmapData
 }
diff --git a/pkg/messages/types/svcPrefetch.go b/pkg/messages/types/svcPrefetch.go
index b71e61f..a9a88fe 100644
--- a/pkg/messages/types/svcPrefetch.go
+++ b/pkg/messages/types/svcPrefetch.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcPrefetch struct {
@@ -13,6 +12,6 @@ func ParseSvcPrefetch(reader *bitreader.Reader) SvcPrefetch {
         svcPrefetch := SvcPrefetch{
                 SoundIndex: int16(reader.TryReadBits(13)),
         }
-        writer.TempAppendLine("\t\tSound Index: %d", svcPrefetch.SoundIndex)
+
         return svcPrefetch
 }
diff --git a/pkg/messages/types/svcPrint.go b/pkg/messages/types/svcPrint.go
index 760a3c5..7b3b388 100644
--- a/pkg/messages/types/svcPrint.go
+++ b/pkg/messages/types/svcPrint.go
@@ -1,10 +1,13 @@
 package messages
 
 import (
+        "fmt"
+        "regexp"
+        "strconv"
         "strings"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
+        "github.com/pektezol/demoparser/pkg/verification"
 )
 
 type SvcPrint struct {
@@ -16,6 +19,19 @@ func ParseSvcPrint(reader *bitreader.Reader) SvcPrint {
                 Message: reader.TryReadString(),
         }
         // common psycopath behaviour
-        writer.TempAppendLine("\t\t%s", strings.Replace(strings.ReplaceAll(strings.ReplaceAll(svcPrint.Message, "\n", "\n\t\t"), "\n\t\t\n\t\t", ""), "\n\t\t", "", 1))
+        print := fmt.Sprintf("\t\t%s\n", strings.Replace(strings.ReplaceAll(strings.ReplaceAll(svcPrint.Message, "\n", "\n\t\t"), "\n\t\t\n\t\t", ""), "\n\t\t", "", 1))
+        // Define a regular expression pattern to match the "Server Number" line and capture the integer value.
+        pattern := `Server Number: (\d+)`
+
+        // Compile the regular expression pattern.
+        re := regexp.MustCompile(pattern)
+
+        // Find the match in the text.
+        match := re.FindStringSubmatch(print)
+        if len(match) >= 1 {
+                serverNumber := match[1]
+                n, _ := strconv.Atoi(serverNumber)
+                verification.ServerNumbers = append(verification.ServerNumbers, n)
+        }
         return svcPrint
 }
diff --git a/pkg/messages/types/svcSendTable.go b/pkg/messages/types/svcSendTable.go
index 78df195..4397db0 100644
--- a/pkg/messages/types/svcSendTable.go
+++ b/pkg/messages/types/svcSendTable.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcSendTable struct {
@@ -17,8 +16,6 @@ func ParseSvcSendTable(reader *bitreader.Reader) SvcSendTable {
                 Length:       reader.TryReadUInt8(),
         }
         svcSendTable.Props = uint32(reader.TryReadBits(uint64(svcSendTable.Length)))
-        writer.TempAppendLine("\t\tNeeds Decoder: %t", svcSendTable.NeedsDecoder)
-        writer.TempAppendLine("\t\tLength: %d", svcSendTable.Length)
-        writer.TempAppendLine("\t\tProps: %d", svcSendTable.Props)
+
         return svcSendTable
 }
diff --git a/pkg/messages/types/svcServerInfo.go b/pkg/messages/types/svcServerInfo.go
index a6acd53..507b7ca 100644
--- a/pkg/messages/types/svcServerInfo.go
+++ b/pkg/messages/types/svcServerInfo.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcServerInfo struct {
@@ -43,21 +42,6 @@ func ParseSvcServerInfo(reader *bitreader.Reader) SvcServerInfo {
                 SkyName:          reader.TryReadString(),
                 HostName:         reader.TryReadString(),
         }
-        writer.TempAppendLine("\t\tNetwork Protocol: %d", svcServerInfo.Protocol)
-        writer.TempAppendLine("\t\tServer Count: %d", svcServerInfo.ServerCount)
-        writer.TempAppendLine("\t\tIs Hltv: %t", svcServerInfo.IsHltv)
-        writer.TempAppendLine("\t\tIs Dedicated: %t", svcServerInfo.IsDedicated)
-        writer.TempAppendLine("\t\tServer Client CRC: %d", svcServerInfo.ClientCrc)
-        writer.TempAppendLine("\t\tString Table CRC: %d", svcServerInfo.StringTableCrc)
-        writer.TempAppendLine("\t\tMax Server Classes: %d", svcServerInfo.MaxServerClasses)
-        writer.TempAppendLine("\t\tServer Map CRC: %d", svcServerInfo.MapCrc)
-        writer.TempAppendLine("\t\tCurrent Player Count: %d", svcServerInfo.PlayerCount)
-        writer.TempAppendLine("\t\tMax Player Count: %d", svcServerInfo.MaxClients)
-        writer.TempAppendLine("\t\tInterval Per Tick: %f", svcServerInfo.TickInterval)
-        writer.TempAppendLine("\t\tPlatform: %s", svcServerInfo.Platform)
-        writer.TempAppendLine("\t\tGame Directory: %s", svcServerInfo.GameDir)
-        writer.TempAppendLine("\t\tMap Name: %s", svcServerInfo.MapName)
-        writer.TempAppendLine("\t\tSky Name: %s", svcServerInfo.SkyName)
-        writer.TempAppendLine("\t\tHost Name: %s", svcServerInfo.HostName)
+
         return svcServerInfo
 }
diff --git a/pkg/messages/types/svcSetPause.go b/pkg/messages/types/svcSetPause.go
index d979ac5..1f6f25f 100644
--- a/pkg/messages/types/svcSetPause.go
+++ b/pkg/messages/types/svcSetPause.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcSetPause struct {
@@ -13,6 +12,6 @@ func ParseSvcSetPause(reader *bitreader.Reader) SvcSetPause {
         svcSetPause := SvcSetPause{
                 Paused: reader.TryReadBool(),
         }
-        writer.TempAppendLine("\t\tPaused: %t", svcSetPause.Paused)
+
         return svcSetPause
 }
diff --git a/pkg/messages/types/svcSetView.go b/pkg/messages/types/svcSetView.go
index bdb6203..a60d547 100644
--- a/pkg/messages/types/svcSetView.go
+++ b/pkg/messages/types/svcSetView.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcSetView struct {
@@ -13,6 +12,6 @@ func ParseSvcSetView(reader *bitreader.Reader) SvcSetView {
         svcSetView := SvcSetView{
                 EntityIndex: uint16(reader.TryReadBits(11)),
         }
-        writer.TempAppendLine("\t\tEntity Index: %d", svcSetView.EntityIndex)
+
         return svcSetView
 }
diff --git a/pkg/messages/types/svcSounds.go b/pkg/messages/types/svcSounds.go
index 1affeb4..34d99f6 100644
--- a/pkg/messages/types/svcSounds.go
+++ b/pkg/messages/types/svcSounds.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcSounds struct {
@@ -24,8 +23,6 @@ func ParseSvcSounds(reader *bitreader.Reader) SvcSounds {
                 svcSounds.Length = reader.TryReadUInt16()
         }
         svcSounds.Data = reader.TryReadBitsToSlice(uint64(svcSounds.Length))
-        writer.TempAppendLine("\t\tReliable Sound: %t", svcSounds.ReliableSound)
-        writer.TempAppendLine("\t\tSound Count: %d", svcSounds.SoundCount)
-        writer.TempAppendLine("\t\tData: %v", svcSounds.Data)
+
         return svcSounds
 }
diff --git a/pkg/messages/types/svcSplitScreen.go b/pkg/messages/types/svcSplitScreen.go
index 653438a..fc6acb4 100644
--- a/pkg/messages/types/svcSplitScreen.go
+++ b/pkg/messages/types/svcSplitScreen.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcSplitScreen struct {
@@ -17,7 +16,6 @@ func ParseSvcSplitScreen(reader *bitreader.Reader) SvcSplitScreen {
                 Length:     uint16(reader.TryReadBits(11)),
         }
         svcSplitScreen.Data = reader.TryReadBitsToSlice(uint64(svcSplitScreen.Length))
-        writer.TempAppendLine("\t\tRemove User: %t", svcSplitScreen.RemoveUser)
-        writer.TempAppendLine("\t\tData: %v", svcSplitScreen.Data)
+
         return svcSplitScreen
 }
diff --git a/pkg/messages/types/svcTempEntities.go b/pkg/messages/types/svcTempEntities.go
index 407bfd6..41b1afb 100644
--- a/pkg/messages/types/svcTempEntities.go
+++ b/pkg/messages/types/svcTempEntities.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcTempEntities struct {
@@ -17,7 +16,6 @@ func ParseSvcTempEntities(reader *bitreader.Reader) SvcTempEntities {
                 Length:     uint32(reader.TryReadBits(17)),
         }
         svcTempEntities.Data = reader.TryReadBitsToSlice(uint64(svcTempEntities.Length))
-        writer.TempAppendLine("\t\tNumber Of Entries: %d", svcTempEntities.NumEntries)
-        writer.TempAppendLine("\t\tData: %v", svcTempEntities.Data)
+
         return svcTempEntities
 }
diff --git a/pkg/messages/types/svcUpdateStringTable.go b/pkg/messages/types/svcUpdateStringTable.go
index 68c8fb5..ca716eb 100644
--- a/pkg/messages/types/svcUpdateStringTable.go
+++ b/pkg/messages/types/svcUpdateStringTable.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcUpdateStringTable struct {
@@ -21,7 +20,6 @@ func ParseSvcUpdateStringTable(reader *bitreader.Reader) SvcUpdateStringTable {
         }
         svcUpdateStringTable.Length = int32(reader.TryReadBits(20))
         svcUpdateStringTable.Data = reader.TryReadBitsToSlice(uint64(svcUpdateStringTable.Length))
-        writer.TempAppendLine("\t\tTable ID: %d", svcUpdateStringTable.TableId)
-        writer.TempAppendLine("\t\tNumber Of Changed Entries: %d", svcUpdateStringTable.NumChangedEntries)
+
         return svcUpdateStringTable
 }
diff --git a/pkg/messages/types/svcUserMessage.go b/pkg/messages/types/svcUserMessage.go
index e5b1943..a26f0ff 100644
--- a/pkg/messages/types/svcUserMessage.go
+++ b/pkg/messages/types/svcUserMessage.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcUserMessage struct {
@@ -89,8 +88,7 @@ func ParseSvcUserMessage(reader *bitreader.Reader) SvcUserMessage {
                 Length: int16(reader.TryReadBits(12)),
         }
         svcUserMessage.Data = reader.TryReadBitsToSlice(uint64(svcUserMessage.Length))
-        writer.TempAppendLine("\t\tType: %d", svcUserMessage.Type)
-        writer.TempAppendLine("\t\tData: %v", svcUserMessage.Data)
+
         return svcUserMessage
 }
 
diff --git a/pkg/messages/types/svcVoiceData.go b/pkg/messages/types/svcVoiceData.go
index c3e08ee..6ac8050 100644
--- a/pkg/messages/types/svcVoiceData.go
+++ b/pkg/messages/types/svcVoiceData.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcVoiceData struct {
@@ -21,8 +20,6 @@ func ParseSvcVoiceData(reader *bitreader.Reader) SvcVoiceData {
                 svcVoiceData.Proximity = true
         }
         svcVoiceData.Data = reader.TryReadBitsToSlice(uint64(svcVoiceData.Length))
-        writer.TempAppendLine("\t\tFrom Client: %d", svcVoiceData.FromClient)
-        writer.TempAppendLine("\t\tProximity: %t", svcVoiceData.Proximity)
-        writer.TempAppendLine("\t\tData: %v", svcVoiceData.Data)
+
         return svcVoiceData
 }
diff --git a/pkg/messages/types/svcVoiceInit.go b/pkg/messages/types/svcVoiceInit.go
index 03e0e25..eb6093f 100644
--- a/pkg/messages/types/svcVoiceInit.go
+++ b/pkg/messages/types/svcVoiceInit.go
@@ -2,7 +2,6 @@ package messages
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SvcVoiceInit struct {
@@ -25,8 +24,6 @@ func ParseSvcVoiceInit(reader *bitreader.Reader) SvcVoiceInit {
                         svcVoiceInit.SampleRate = 11025
                 }
         }
-        writer.TempAppendLine("\t\tCodec: %s", svcVoiceInit.Codec)
-        writer.TempAppendLine("\t\tQuality: %d", svcVoiceInit.Quality)
-        writer.TempAppendLine("\t\tSample Rate: %d", svcVoiceInit.SampleRate)
+
         return svcVoiceInit
 }
diff --git a/pkg/packets/headers.go b/pkg/packets/headers.go
index d92b22d..124eb95 100644
--- a/pkg/packets/headers.go
+++ b/pkg/packets/headers.go
@@ -2,7 +2,6 @@ package packets
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type Headers struct {
@@ -42,6 +41,6 @@ func ParseHeaders(reader *bitreader.Reader) Headers {
         if headers.NetworkProtocol != 2001 {
                 panic("this parser only supports demos from portal 2")
         }
-        writer.AppendLine("Headers: %+v", headers)
+
         return headers
 }
diff --git a/pkg/packets/packets.go b/pkg/packets/packets.go
index b1d6a40..06eb48d 100644
--- a/pkg/packets/packets.go
+++ b/pkg/packets/packets.go
@@ -3,7 +3,7 @@ package packets
 import (
         "github.com/pektezol/bitreader"
         "github.com/pektezol/demoparser/pkg/classes"
-        "github.com/pektezol/demoparser/pkg/writer"
+        "github.com/pektezol/demoparser/pkg/messages"
 )
 
 type PacketMessageInfo struct {
@@ -18,42 +18,46 @@ func ParsePackets(reader *bitreader.Reader) PacketMessageInfo {
         slotNumber := reader.TryReadUInt8()
         switch packetType {
         case 1: // SignOn
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "SIGNON", packetType)
-                signOn := classes.SignOn{}
-                signOn.ParseSignOn(reader)
+                for count := 0; count < 2; count++ {
+                        reader.SkipBytes(76)
+                }
+                reader.SkipBytes(8)
+                packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(reader.TryReadUInt32())), true)
+                for {
+                        messageType, err := packetReader.ReadBits(6)
+                        if err != nil {
+                                break
+                        }
+                        messages.ParseMessages(messageType, packetReader)
+                }
         case 2: // Packet
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "PACKET", packetType)
-                packet := classes.Packet{}
-                packet.ParsePacket(reader)
+                for count := 0; count < 2; count++ {
+                        reader.SkipBytes(76)
+                }
+                reader.SkipBytes(8)
+                reader.TryReadBytesToSlice(uint64(reader.TryReadUInt32()))
         case 3: // SyncTick
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "SYNCTICK", packetType)
-                syncTick := classes.SyncTick{}
-                syncTick.ParseSyncTick()
         case 4: // ConsoleCmd
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "CONSOLECMD", packetType)
+
                 consoleCmd := classes.ConsoleCmd{}
                 consoleCmd.ParseConsoleCmd(reader)
         case 5: // UserCmd
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "USERCMD", packetType)
+
                 userCmd := classes.UserCmd{}
                 userCmd.ParseUserCmd(reader)
         case 6: // DataTables
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "DATATABLES", packetType)
-                dataTables := classes.DataTables{}
-                dataTables.ParseDataTables(reader)
+                reader.SkipBytes(uint64(reader.TryReadUInt32()))
         case 7: // Stop
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "STOP", packetType)
-                stop := classes.Stop{}
-                stop.ParseStop(reader)
+                if reader.TryReadBool() {
+                        reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
+                }
         case 8: // CustomData TODO: not sar data
                 customData := classes.CustomData{}
                 customData.ParseCustomData(reader, tickNumber, packetType)
         case 9: // StringTables TODO: parsing string table data
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "STRINGTABLES", packetType)
-                stringTables := classes.StringTables{}
-                stringTables.ParseStringTables(reader)
+                reader.SkipBytes(uint64(reader.TryReadUInt32()))
         default: // Invalid
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "INVALID", packetType)
+
                 panic("invalid packet type")
         }
         return PacketMessageInfo{
diff --git a/pkg/verification/verification.go b/pkg/verification/verification.go
new file mode 100644
index 0000000..487daf8
--- /dev/null
+++ b/pkg/verification/verification.go
@@ -0,0 +1,33 @@
+package verification
+
+import (
+        "log"
+        "sort"
+)
+
+var ServerNumbers []int
+
+var Ticks uint32
+
+func IsContinuous(arr []int) bool {
+        if len(arr) == 0 {
+                return false
+        }
+
+        // Sort the array first
+        sort.Ints(arr)
+
+        // Start with the first element
+        prev := arr[0]
+
+        for i := 1; i < len(arr); i++ {
+                // Check if the current element is consecutive to the previous one
+                if arr[i] != prev+1 {
+                        log.Printf("%d != %d", arr[i], prev+1)
+                        return false
+                }
+                prev = arr[i]
+        }
+
+        return true
+}
diff --git a/pkg/writer/writer.go b/pkg/writer/writer.go
deleted file mode 100644
index 6b66e75..0000000
--- a/pkg/writer/writer.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package writer
-
-import (
-        "fmt"
-        "strings"
-)
-
-var output strings.Builder
-
-var temp strings.Builder
-
-func Append(str string, a ...any) {
-        _, err := output.WriteString(fmt.Sprintf(str, a...))
-        if err != nil {
-                output.WriteString(err.Error())
-        }
-}
-
-func AppendLine(str string, a ...any) {
-        Append(str, a...)
-        output.WriteString("\n")
-}
-
-func GetString() string {
-        return output.String()
-}
-
-func TempAppend(str string, a ...any) {
-        _, err := temp.WriteString(fmt.Sprintf(str, a...))
-        if err != nil {
-                temp.WriteString(err.Error())
-        }
-}
-
-func TempAppendLine(str string, a ...any) {
-        TempAppend(str, a...)
-        temp.WriteString("\n")
-}
-
-func TempGetString() string {
-        return temp.String()
-}
-
-func AppendOutputFromTemp() {
-        output.WriteString(temp.String())
-        temp.Reset()
-}