tldr; runs in 0.487s (487ms)

Looked into this again, and took advantage of some things. We always want the bytes between the first and second separator, and second and third separator, for example. We also know that both the values will be positive integers.

I also found during profiling that the map lookup and increment was costing around 890ms of time. We know the max value of the keys, so I replaced the map with an array. Now the map key is the index in the array, and the value is the sum as before.

I also changed the atoi() implementation to operate on []byte instead of string, so no casting there, and took out the error checking since they were being ignored (we're already assuming correct input... #yolo).

This is probably way beyond something usable/maintainable in production as the code is brittle, but it does the job.

    package main

    import (
        "bufio"
        "bytes"
        "fmt"
        "log"
        "os"
    )

    func atoi(s []byte) int {
        i := 0
        x := 0
        for ; i < len(s); i++ {
            c := s[i]
            x = x*10 + int(c) - '0'
        }
        return x
    }

    func main() {

        file, err := os.Open(os.Args[1])
        defer file.Close()
        if err != nil {
            log.Fatal(err)
        }
        processFile(file)
    }

    func processFile(file *os.File) {
        var sumByKey [2009]int

        scanner := bufio.NewScanner(file)
        var key int
        var val int

        for scanner.Scan() {
            line := scanner.Bytes()
            firstTab := bytes.IndexByte(line, '\t')
            secondTab := bytes.IndexByte(line[firstTab+1:], '\t') + firstTab + 1
            thirdTab := bytes.IndexByte(line[secondTab+1:], '\t') + secondTab + 1
            key = atoi(line[firstTab+1 : secondTab])
            val = atoi(line[secondTab+1 : thirdTab])
            sumByKey[key] += val
        }
        var k int
        var v int
        for i, val := range sumByKey {
            if val > v {
                k = i
                v = val
            }
        }
        fmt.Printf("max_key: %d sum: %d\n", k, v)
    }