feat: inline parser instead of executable (#113)

Former-commit-id: 5fc9bc33b92dc674c23e3fe4dc4e852615ffad24
author: Arda Serdar Pektezol <1669855+pektezol@users.noreply.github.com> 2023-11-06 18:43:54 +0300
committer: GitHub <noreply@github.com> 2023-11-06 18:43:54 +0300
commit: 18dc647ec85e77aca0a01fd701bf0dc115096426 (patch)
tree: 051fdf179cd5b51edc950a34b5615efc567fc507
parent: fix: sql typo in update user (#127) (diff)
download: lphub-18dc647ec85e77aca0a01fd701bf0dc115096426.tar.gz
lphub-18dc647ec85e77aca0a01fd701bf0dc115096426.tar.bz2
lphub-18dc647ec85e77aca0a01fd701bf0dc115096426.zip
4 files changed, 226 insertions, 27 deletions
diff --git a/backend/parser/parser-arm64.REMOVED.git-id b/backend/parser/parser-arm64.REMOVED.git-id
deleted file mode 100644
index 1491e2b..0000000
--- a/backend/parser/parser-arm64.REMOVED.git-id
+++ /dev/null
@@ -1 +0,0 @@
-2dd9762c1d6c97b34a1a88b7f788c6fc58ad4b47
-\ No newline at end of file
diff --git a/backend/parser/parser.go b/backend/parser/parser.go
index bf456d4..db84256 100644
--- a/backend/parser/parser.go
+++ b/backend/parser/parser.go
@@ -1,40 +1,237 @@
 package parser
 import (
-        "bufio"
+        "errors"
-        "os/exec"
+        "math"
-        "strconv"
+        "os"
-        "strings"
+        "github.com/pektezol/bitreader"
 )
-func ProcessDemo(demoPath string) (int, int, error) {
+// Don't try to understand it, feel it.
-        cmd := exec.Command("./backend/parser/parser-arm64", demoPath)
+func ProcessDemo(filePath string) (portalCount int, tickCount int, err error) {
-        stdout, err := cmd.StdoutPipe()
+        file, err := os.Open(filePath)
        if err != nil {
                return 0, 0, err
        }
-        if err := cmd.Start(); err != nil {
+        reader := bitreader.NewReader(file, true)
-                return 0, 0, err
+        demoFileStamp := reader.TryReadString()
+        demoProtocol := reader.TryReadSInt32()
+        networkProtocol := reader.TryReadSInt32()
+        reader.SkipBytes(1056)
+        if demoFileStamp != "HL2DEMO" {
+                return 0, 0, errors.New("invalid demo file stamp")
+        }
+        if demoProtocol != 4 {
+                return 0, 0, errors.New("this parser only supports demos from new engine")
        }
-        scanner := bufio.NewScanner(stdout)
+        if networkProtocol != 2001 {
-        var cmTicks, portalCount int
+                return 0, 0, errors.New("this parser only supports demos from portal 2")
-        for scanner.Scan() {
+        }
-                line := scanner.Text()
+        for {
-                if strings.Contains(line, "CM Ticks") {
+                packetType := reader.TryReadUInt8()
-                        cmTicksStr := strings.TrimSpace(strings.Split(line, ":")[1])
+                reader.SkipBits(40)
-                        cmTicks, err = strconv.Atoi(cmTicksStr)
+                switch packetType {
-                        if err != nil {
+                case 1:
-                                return 0, 0, err
+                        reader.SkipBytes(160)
+                        reader.SkipBytes(uint64(reader.TryReadSInt32()))
+                case 2:
+                        reader.SkipBytes(160)
+                        size := reader.TryReadUInt32()
+                        packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(size)), true)
+                        for {
+                                messageType, err := packetReader.ReadBits(6)
+                                if err != nil {
+                                        break
+                                }
+                                switch messageType {
+                                case 0:
+                                case 1:
+                                        packetReader.TryReadString()
+                                case 2:
+                                        packetReader.SkipBytes(4)
+                                        packetReader.TryReadString()
+                                        packetReader.SkipBits(2)
+                                case 3:
+                                        packetReader.SkipBits(1)
+                                case 4:
+                                        packetReader.SkipBytes(8)
+                                case 5:
+                                        packetReader.TryReadString()
+                                case 6:
+                                        for count := 0; count < int(packetReader.TryReadUInt8()); count++ {
+                                                packetReader.TryReadString()
+                                                packetReader.TryReadString()
+                                        }
+                                case 7:
+                                        packetReader.SkipBytes(9)
+                                        idsLength := packetReader.TryReadUInt32()
+                                        if idsLength > 0 {
+                                                packetReader.SkipBytes(uint64(idsLength))
+                                        }
+                                        mapLength := packetReader.TryReadUInt32()
+                                        if mapLength > 0 {
+                                                packetReader.TryReadStringLength(uint64(mapLength))
+                                        }
+                                case 8:
+                                        packetReader.SkipBits(210)
+                                        packetReader.TryReadStringLength(1)
+                                        packetReader.TryReadString()
+                                        packetReader.TryReadString()
+                                        packetReader.TryReadString()
+                                        packetReader.TryReadString()
+                                case 9:
+                                        packetReader.SkipBits(1)
+                                        packetReader.SkipBits(uint64(packetReader.TryReadUInt8()))
+                                case 10:
+                                        classCount := packetReader.TryReadUInt16()
+                                        if !packetReader.TryReadBool() {
+                                                for count := 0; count < int(classCount); count++ {
+                                                        packetReader.SkipBits(uint64(math.Log2(float64(classCount)) + 1))
+                                                        packetReader.TryReadString()
+                                                        packetReader.TryReadString()
+                                                }
+                                        }
+                                case 11:
+                                        packetReader.SkipBits(1)
+                                case 12:
+                                        packetReader.TryReadString()
+                                        maxEntries := packetReader.TryReadSInt16()
+                                        packetReader.SkipBits(uint64(math.Log2(float64(maxEntries))) + 1)
+                                        length := packetReader.TryReadBits(20)
+                                        if packetReader.TryReadBool() {
+                                                packetReader.SkipBytes(2)
+                                        }
+                                        packetReader.SkipBits(2)
+                                        packetReader.SkipBits(length)
+                                case 13:
+                                        packetReader.SkipBits(5)
+                                        if packetReader.TryReadBool() {
+                                                packetReader.SkipBytes(2)
+                                        }
+                                        packetReader.SkipBits(packetReader.TryReadBits(20))
+                                case 14:
+                                        packetReader.TryReadString()
+                                        if packetReader.TryReadUInt8() == 255 {
+                                                packetReader.SkipBytes(4)
+                                        }
+                                case 15:
+                                        packetReader.SkipBytes(2)
+                                        packetReader.SkipBits(uint64(packetReader.TryReadUInt16()))
+                                case 16:
+                                        packetReader.TryReadString()
+                                case 17:
+                                        var length uint16
+                                        if packetReader.TryReadBool() {
+                                                length = uint16(packetReader.TryReadUInt8())
+                                        } else {
+                                                packetReader.SkipBytes(1)
+                                                length = packetReader.TryReadUInt16()
+                                        }
+                                        packetReader.SkipBits(uint64(length))
+                                case 18:
+                                        packetReader.SkipBits(11)
+                                case 19:
+                                        packetReader.SkipBits(49)
+                                case 20:
+                                        packetReader.SkipBits(48)
+                                case 21:
+                                        readVectorCoord := func() float32 {
+                                                value := float32(0)
+                                                integer := packetReader.TryReadBits(1)
+                                                fraction := packetReader.TryReadBits(1)
+                                                if integer != 0 || fraction != 0 {
+                                                        sign := packetReader.TryReadBits(1)
+                                                        if integer != 0 {
+                                                                integer = packetReader.TryReadBits(uint64(14)) + 1
+                                                        }
+                                                        if fraction != 0 {
+                                                                fraction = packetReader.TryReadBits(uint64(5))
+                                                        }
+                                                        value = float32(integer) + float32(fraction)*(1.0/float32(1<<5))
+                                                        if sign != 0 {
+                                                                value = -value
+                                                        }
+                                                }
+                                                return value
+                                        }
+                                        packetReader.SkipBits(3)
+                                        readVectorCoord()
+                                        readVectorCoord()
+                                        readVectorCoord()
+                                        packetReader.SkipBits(9)
+                                        if packetReader.TryReadBool() {
+                                                packetReader.SkipBits(22)
+                                        }
+                                        packetReader.SkipBits(1)
+                                case 22:
+                                        packetReader.SkipBits(1)
+                                        packetReader.SkipBits(packetReader.TryReadBits(11))
+                                case 23:
+                                        msgType := int8(packetReader.TryReadBits(8))
+                                        msgLength := packetReader.TryReadBits(12)
+                                        userMessageReader := bitreader.NewReaderFromBytes(packetReader.TryReadBitsToSlice(msgLength), true)
+                                        switch msgType {
+                                        case 60:
+                                                scoreboardTempUpdate := struct {
+                                                        NumPortals int32
+                                                        TimeTaken  int32
+                                                }{
+                                                        NumPortals: userMessageReader.TryReadSInt32(),
+                                                        TimeTaken:  userMessageReader.TryReadSInt32(),
+                                                }
+                                                portalCount = int(scoreboardTempUpdate.NumPortals)
+                                                tickCount = int(math.Round(float64((float32(scoreboardTempUpdate.TimeTaken) / 100.0) / float32(1.0/60.0))))
+                                        }
+                                case 24:
+                                        packetReader.SkipBits(20)
+                                        packetReader.SkipBits(packetReader.TryReadBits(11))
+                                case 25:
+                                        packetReader.SkipBits(packetReader.TryReadBits(11))
+                                case 26:
+                                        packetReader.SkipBits(11)
+                                        if packetReader.TryReadBool() {
+                                                packetReader.SkipBytes(4)
+                                        }
+                                        packetReader.SkipBits(12)
+                                        length := packetReader.TryReadBits(20)
+                                        packetReader.SkipBits(1)
+                                        packetReader.SkipBits(length)
+                                case 27:
+                                        packetReader.SkipBits(8)
+                                        packetReader.SkipBits(packetReader.TryReadBits(17))
+                                case 28:
+                                        packetReader.SkipBits(13)
+                                case 29:
+                                        packetReader.SkipBits(16)
+                                        packetReader.SkipBits(packetReader.TryReadBits(32))
+                                case 30:
+                                        packetReader.SkipBits(9)
+                                        packetReader.SkipBits(packetReader.TryReadBits(20))
+                                case 31:
+                                        packetReader.SkipBits(32)
+                                        packetReader.TryReadString()
+                                case 32:
+                                        packetReader.SkipBytes(packetReader.TryReadBits(32))
+                                case 33:
+                                        packetReader.SkipBits(packetReader.TryReadBits(32))
+                                default:
+                                        panic("unknown msg type")
+                                }
                        }
+                case 3, 7:
+                case 4, 6, 9:
+                        reader.SkipBytes(uint64(reader.TryReadSInt32()))
+                case 5, 8:
+                        reader.SkipBits(32)
+                        reader.SkipBytes(uint64(reader.TryReadSInt32()))
+                default:
+                        return 0, 0, errors.New("invalid packet type")
                }
-                if strings.Contains(line, "Portal Count") {
+                if packetType == 7 {
-                        portalCountStr := strings.TrimSpace(strings.Split(line, ":")[1])
+                        break
-                        portalCount, err = strconv.Atoi(portalCountStr)
-                        if err != nil {
-                                return 0, 0, err
-                        }
                }
        }
-        cmd.Wait()
+        return portalCount, tickCount, nil
-        return portalCount, cmTicks, nil
 }
diff --git a/go.mod b/go.mod
index 1fdd17e..dc7c1aa 100644
--- a/go.mod
+++ b/go.mod
@@ -50,6 +50,7 @@ require (
        github.com/mattn/go-isatty v0.0.16 // indirect
        github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
        github.com/modern-go/reflect2 v1.0.2 // indirect
+        github.com/pektezol/bitreader v1.4.3
        github.com/pelletier/go-toml/v2 v2.0.5 // indirect
        github.com/ugorji/go/codec v1.2.7 // indirect
        golang.org/x/crypto v0.1.0 // indirect
diff --git a/go.sum b/go.sum
index 59724af..0e6023b 100644
--- a/go.sum
+++ b/go.sum
@@ -129,6 +129,8 @@ github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJ
 github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs=
 github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=
 github.com/otiai10/mint v1.3.3/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc=
+github.com/pektezol/bitreader v1.4.3 h1:+WjsD6qOAaI6Q1jOOlEJcnaEso8vPMKRZnnaDnZhTSg=
+github.com/pektezol/bitreader v1.4.3/go.mod h1:xBQEsQpOf8B5yPrnOTkirZGyVUV6Bqp0ups2RIlTskk=
 github.com/pektezol/steam_go v1.1.0 h1:mybEW6bQlSx7oCnKFSo4ZdxvQpNP4vkzyreEKUM5Czg=
 github.com/pektezol/steam_go v1.1.0/go.mod h1:8dk95CLOQKRr0BA8ChnNbTEe0/f2Ibi5O4rmpS9oZCo=
 github.com/pektezol/steam_go v1.1.1 h1:/sKaM9XYEyD/MoNNPpCqnkX7VdMmcFnlQUHyNy+z96Y=
author	Arda Serdar Pektezol <1669855+pektezol@users.noreply.github.com>	2023-11-06 18:43:54 +0300
committer	GitHub <noreply@github.com>	2023-11-06 18:43:54 +0300
commit	18dc647ec85e77aca0a01fd701bf0dc115096426 (patch)
tree	051fdf179cd5b51edc950a34b5615efc567fc507
parent	fix: sql typo in update user (#127) (diff)
download	lphub-18dc647ec85e77aca0a01fd701bf0dc115096426.tar.gz lphub-18dc647ec85e77aca0a01fd701bf0dc115096426.tar.bz2 lphub-18dc647ec85e77aca0a01fd701bf0dc115096426.zip

diff --git a/backend/parser/parser-arm64.REMOVED.git-id b/backend/parser/parser-arm64.REMOVED.git-id deleted file mode 100644 index 1491e2b..0000000 --- a/backend/parser/parser-arm64.REMOVED.git-id +++ /dev/null
@@ -1 +0,0 @@
1	2dd9762c1d6c97b34a1a88b7f788c6fc58ad4b47 \ No newline at end of file


diff --git a/backend/parser/parser.go b/backend/parser/parser.go index bf456d4..db84256 100644 --- a/backend/parser/parser.go +++ b/backend/parser/parser.go
@@ -1,40 +1,237 @@
1	package parser	1	package parser
2		2
3	import (	3	import (
4	"bufio"	4	"errors"
5	"os/exec"	5	"math"
6	"strconv"	6	"os"
7	"strings"	7
		8	"github.com/pektezol/bitreader"
8	)	9	)
9		10
10	func ProcessDemo(demoPath string) (int, int, error) {	11	// Don't try to understand it, feel it.
11	cmd := exec.Command("./backend/parser/parser-arm64", demoPath)	12	func ProcessDemo(filePath string) (portalCount int, tickCount int, err error) {
12	stdout, err := cmd.StdoutPipe()	13	file, err := os.Open(filePath)
13	if err != nil {	14	if err != nil {
14	return 0, 0, err	15	return 0, 0, err
15	}	16	}
16	if err := cmd.Start(); err != nil {	17	reader := bitreader.NewReader(file, true)
17	return 0, 0, err	18	demoFileStamp := reader.TryReadString()
		19	demoProtocol := reader.TryReadSInt32()
		20	networkProtocol := reader.TryReadSInt32()
		21	reader.SkipBytes(1056)
		22	if demoFileStamp != "HL2DEMO" {
		23	return 0, 0, errors.New("invalid demo file stamp")
		24	}
		25	if demoProtocol != 4 {
		26	return 0, 0, errors.New("this parser only supports demos from new engine")
18	}	27	}
19	scanner := bufio.NewScanner(stdout)	28	if networkProtocol != 2001 {
20	var cmTicks, portalCount int	29	return 0, 0, errors.New("this parser only supports demos from portal 2")
21	for scanner.Scan() {	30	}
22	line := scanner.Text()	31	for {
23	if strings.Contains(line, "CM Ticks") {	32	packetType := reader.TryReadUInt8()
24	cmTicksStr := strings.TrimSpace(strings.Split(line, ":")[1])	33	reader.SkipBits(40)
25	cmTicks, err = strconv.Atoi(cmTicksStr)	34	switch packetType {
26	if err != nil {	35	case 1:
27	return 0, 0, err	36	reader.SkipBytes(160)
		37	reader.SkipBytes(uint64(reader.TryReadSInt32()))
		38	case 2:
		39	reader.SkipBytes(160)
		40	size := reader.TryReadUInt32()
		41	packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(size)), true)
		42	for {
		43	messageType, err := packetReader.ReadBits(6)
		44	if err != nil {
		45	break
		46	}
		47	switch messageType {
		48	case 0:
		49	case 1:
		50	packetReader.TryReadString()
		51	case 2:
		52	packetReader.SkipBytes(4)
		53	packetReader.TryReadString()
		54	packetReader.SkipBits(2)
		55	case 3:
		56	packetReader.SkipBits(1)
		57	case 4:
		58	packetReader.SkipBytes(8)
		59	case 5:
		60	packetReader.TryReadString()
		61	case 6:
		62	for count := 0; count < int(packetReader.TryReadUInt8()); count++ {
		63	packetReader.TryReadString()
		64	packetReader.TryReadString()
		65	}
		66	case 7:
		67	packetReader.SkipBytes(9)
		68	idsLength := packetReader.TryReadUInt32()
		69	if idsLength > 0 {
		70	packetReader.SkipBytes(uint64(idsLength))
		71	}
		72	mapLength := packetReader.TryReadUInt32()
		73	if mapLength > 0 {
		74	packetReader.TryReadStringLength(uint64(mapLength))
		75	}
		76	case 8:
		77	packetReader.SkipBits(210)
		78	packetReader.TryReadStringLength(1)
		79	packetReader.TryReadString()
		80	packetReader.TryReadString()
		81	packetReader.TryReadString()
		82	packetReader.TryReadString()
		83	case 9:
		84	packetReader.SkipBits(1)
		85	packetReader.SkipBits(uint64(packetReader.TryReadUInt8()))
		86	case 10:
		87	classCount := packetReader.TryReadUInt16()
		88	if !packetReader.TryReadBool() {
		89	for count := 0; count < int(classCount); count++ {
		90	packetReader.SkipBits(uint64(math.Log2(float64(classCount)) + 1))
		91	packetReader.TryReadString()
		92	packetReader.TryReadString()
		93	}
		94	}
		95	case 11:
		96	packetReader.SkipBits(1)
		97	case 12:
		98	packetReader.TryReadString()
		99	maxEntries := packetReader.TryReadSInt16()
		100	packetReader.SkipBits(uint64(math.Log2(float64(maxEntries))) + 1)
		101	length := packetReader.TryReadBits(20)
		102	if packetReader.TryReadBool() {
		103	packetReader.SkipBytes(2)
		104	}
		105	packetReader.SkipBits(2)
		106	packetReader.SkipBits(length)
		107	case 13:
		108	packetReader.SkipBits(5)
		109	if packetReader.TryReadBool() {
		110	packetReader.SkipBytes(2)
		111	}
		112	packetReader.SkipBits(packetReader.TryReadBits(20))
		113	case 14:
		114	packetReader.TryReadString()
		115	if packetReader.TryReadUInt8() == 255 {
		116	packetReader.SkipBytes(4)
		117	}
		118	case 15:
		119	packetReader.SkipBytes(2)
		120	packetReader.SkipBits(uint64(packetReader.TryReadUInt16()))
		121	case 16:
		122	packetReader.TryReadString()
		123	case 17:
		124	var length uint16
		125	if packetReader.TryReadBool() {
		126	length = uint16(packetReader.TryReadUInt8())
		127	} else {
		128	packetReader.SkipBytes(1)
		129	length = packetReader.TryReadUInt16()
		130	}
		131	packetReader.SkipBits(uint64(length))
		132	case 18:
		133	packetReader.SkipBits(11)
		134	case 19:
		135	packetReader.SkipBits(49)
		136	case 20:
		137	packetReader.SkipBits(48)
		138	case 21:
		139	readVectorCoord := func() float32 {
		140	value := float32(0)
		141	integer := packetReader.TryReadBits(1)
		142	fraction := packetReader.TryReadBits(1)
		143	if integer != 0 \|\| fraction != 0 {
		144	sign := packetReader.TryReadBits(1)
		145	if integer != 0 {
		146	integer = packetReader.TryReadBits(uint64(14)) + 1
		147	}
		148	if fraction != 0 {
		149	fraction = packetReader.TryReadBits(uint64(5))
		150	}
		151	value = float32(integer) + float32(fraction)*(1.0/float32(1<<5))
		152	if sign != 0 {
		153	value = -value
		154	}
		155	}
		156	return value
		157	}
		158	packetReader.SkipBits(3)
		159	readVectorCoord()
		160	readVectorCoord()
		161	readVectorCoord()
		162	packetReader.SkipBits(9)
		163	if packetReader.TryReadBool() {
		164	packetReader.SkipBits(22)
		165	}
		166	packetReader.SkipBits(1)
		167	case 22:
		168	packetReader.SkipBits(1)
		169	packetReader.SkipBits(packetReader.TryReadBits(11))
		170	case 23:
		171	msgType := int8(packetReader.TryReadBits(8))
		172	msgLength := packetReader.TryReadBits(12)
		173	userMessageReader := bitreader.NewReaderFromBytes(packetReader.TryReadBitsToSlice(msgLength), true)
		174	switch msgType {
		175	case 60:
		176	scoreboardTempUpdate := struct {
		177	NumPortals int32
		178	TimeTaken int32
		179	}{
		180	NumPortals: userMessageReader.TryReadSInt32(),
		181	TimeTaken: userMessageReader.TryReadSInt32(),
		182	}
		183	portalCount = int(scoreboardTempUpdate.NumPortals)
		184	tickCount = int(math.Round(float64((float32(scoreboardTempUpdate.TimeTaken) / 100.0) / float32(1.0/60.0))))
		185	}
		186	case 24:
		187	packetReader.SkipBits(20)
		188	packetReader.SkipBits(packetReader.TryReadBits(11))
		189	case 25:
		190	packetReader.SkipBits(packetReader.TryReadBits(11))
		191	case 26:
		192	packetReader.SkipBits(11)
		193	if packetReader.TryReadBool() {
		194	packetReader.SkipBytes(4)
		195	}
		196	packetReader.SkipBits(12)
		197	length := packetReader.TryReadBits(20)
		198	packetReader.SkipBits(1)
		199	packetReader.SkipBits(length)
		200
		201	case 27:
		202	packetReader.SkipBits(8)
		203	packetReader.SkipBits(packetReader.TryReadBits(17))
		204	case 28:
		205	packetReader.SkipBits(13)
		206	case 29:
		207	packetReader.SkipBits(16)
		208	packetReader.SkipBits(packetReader.TryReadBits(32))
		209	case 30:
		210	packetReader.SkipBits(9)
		211	packetReader.SkipBits(packetReader.TryReadBits(20))
		212	case 31:
		213	packetReader.SkipBits(32)
		214	packetReader.TryReadString()
		215	case 32:
		216	packetReader.SkipBytes(packetReader.TryReadBits(32))
		217	case 33:
		218	packetReader.SkipBits(packetReader.TryReadBits(32))
		219	default:
		220	panic("unknown msg type")
		221	}
28	}	222	}
		223	case 3, 7:
		224	case 4, 6, 9:
		225	reader.SkipBytes(uint64(reader.TryReadSInt32()))
		226	case 5, 8:
		227	reader.SkipBits(32)
		228	reader.SkipBytes(uint64(reader.TryReadSInt32()))
		229	default:
		230	return 0, 0, errors.New("invalid packet type")
29	}	231	}
30	if strings.Contains(line, "Portal Count") {	232	if packetType == 7 {
31	portalCountStr := strings.TrimSpace(strings.Split(line, ":")[1])	233	break
32	portalCount, err = strconv.Atoi(portalCountStr)
33	if err != nil {
34	return 0, 0, err
35	}
36	}	234	}
37	}	235	}
38	cmd.Wait()	236	return portalCount, tickCount, nil
39	return portalCount, cmTicks, nil
40	}	237	}


diff --git a/go.mod b/go.mod index 1fdd17e..dc7c1aa 100644 --- a/go.mod +++ b/go.mod
@@ -50,6 +50,7 @@ require (
50	github.com/mattn/go-isatty v0.0.16 // indirect	50	github.com/mattn/go-isatty v0.0.16 // indirect
51	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect	51	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
52	github.com/modern-go/reflect2 v1.0.2 // indirect	52	github.com/modern-go/reflect2 v1.0.2 // indirect
		53	github.com/pektezol/bitreader v1.4.3
53	github.com/pelletier/go-toml/v2 v2.0.5 // indirect	54	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
54	github.com/ugorji/go/codec v1.2.7 // indirect	55	github.com/ugorji/go/codec v1.2.7 // indirect
55	golang.org/x/crypto v0.1.0 // indirect	56	golang.org/x/crypto v0.1.0 // indirect


diff --git a/go.sum b/go.sum index 59724af..0e6023b 100644 --- a/go.sum +++ b/go.sum
@@ -129,6 +129,8 @@ github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJ
129	github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs=	129	github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs=
130	github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=	130	github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=
131	github.com/otiai10/mint v1.3.3/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc=	131	github.com/otiai10/mint v1.3.3/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc=
		132	github.com/pektezol/bitreader v1.4.3 h1:+WjsD6qOAaI6Q1jOOlEJcnaEso8vPMKRZnnaDnZhTSg=
		133	github.com/pektezol/bitreader v1.4.3/go.mod h1:xBQEsQpOf8B5yPrnOTkirZGyVUV6Bqp0ups2RIlTskk=
132	github.com/pektezol/steam_go v1.1.0 h1:mybEW6bQlSx7oCnKFSo4ZdxvQpNP4vkzyreEKUM5Czg=	134	github.com/pektezol/steam_go v1.1.0 h1:mybEW6bQlSx7oCnKFSo4ZdxvQpNP4vkzyreEKUM5Czg=
133	github.com/pektezol/steam_go v1.1.0/go.mod h1:8dk95CLOQKRr0BA8ChnNbTEe0/f2Ibi5O4rmpS9oZCo=	135	github.com/pektezol/steam_go v1.1.0/go.mod h1:8dk95CLOQKRr0BA8ChnNbTEe0/f2Ibi5O4rmpS9oZCo=
134	github.com/pektezol/steam_go v1.1.1 h1:/sKaM9XYEyD/MoNNPpCqnkX7VdMmcFnlQUHyNy+z96Y=	136	github.com/pektezol/steam_go v1.1.1 h1:/sKaM9XYEyD/MoNNPpCqnkX7VdMmcFnlQUHyNy+z96Y=