For problem statement at 1000-1999/1100-1199/1150-1159/1154/problemG.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1150-1159/1154/verifierG.go ends with all tests passed can you fix the verifier? ```go
package main

import (
    "bufio"
    "fmt"
    "math"
    "os"
)

func main() {
    in := bufio.NewReader(os.Stdin)

    readInt := func() int {
        var n int
        for {
            b, err := in.ReadByte()
            if err != nil {
                return -1
            }
            if b >= '0' {
                n = int(b - '0')
                break
            }
        }
        for {
            b, err := in.ReadByte()
            if err != nil || b < '0' {
                break
            }
            n = n*10 + int(b-'0')
        }
        return n
    }

    n := readInt()
    maxA := 0
    a := make([]int, n)
    for i := 0; i < n; i++ {
        a[i] = readInt()
        if a[i] > maxA {
            maxA = a[i]
        }
    }

    pos := make([]int32, maxA+1)
    var minLCM int64 = math.MaxInt64
    var bestI, bestJ int32

    for i := 1; i <= n; i++ {
        val := a[i-1]
        if pos[val] == 0 {
            pos[val] = int32(i)
        } else {
            if int64(val) < minLCM {
                minLCM = int64(val)
                bestI = pos[val]
                bestJ = int32(i)
            }
        }
    }

    next := make([]int32, maxA+2)
    next[maxA+1] = int32(maxA + 1)
    for i := maxA; i >= 1; i-- {
        if pos[i] != 0 {
            next[i] = int32(i)
        } else {
            next[i] = next[i+1]
        }
    }

    for g := 1; g <= maxA && int64(g) < minLCM; g++ {
        m := g
        for m <= maxA {
            if pos[m] != 0 {
                break
            }
            nxt := next[m]
            if int(nxt) > maxA {
                m = maxA + g
                break
            }
            m = int(((nxt + int32(g) - 1) / int32(g)) * int32(g))
        }
        if m > maxA {
            continue
        }
        m1 := m
        if int64(m1/g)*int64(m1+g) >= minLCM {
            continue
        }
        m2 := m1 + g
        for m2 <= maxA {
            if pos[m2] != 0 {
                break
            }
            nxt := next[m2]
            if int(nxt) > maxA {
                m2 = maxA + g
                break
            }
            m2 = int(((nxt + int32(g) - 1) / int32(g)) * int32(g))
        }
        if m2 > maxA {
            continue
        }
        lcm := int64(m1/g) * int64(m2)
        if lcm < minLCM {
            minLCM = lcm
            bestI = pos[m1]
            bestJ = pos[m2]
        }
    }

    if bestI > bestJ {
        bestI, bestJ = bestJ, bestI
    }
    fmt.Println(bestI, bestJ)
}
```