For problem statement at 1000-1999/1500-1599/1590-1599/1599/problemA.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1590-1599/1599/verifierA.go ends with case 1 failed: expected "-1\n48 L\n10 R\n19 R\n26 L\n38 R" got "10 L\n19 L\n26 R\n32 L\n38 R\n48 L"
input:
6
38 48 10 32 19 26
LLLLRL can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"time"
)

type Node struct {
	key      int64
	priority uint32
	left     *Node
	right    *Node
}

type Treap struct {
	root *Node
	rng  *rand.Rand
}

func NewTreap() *Treap {
	return &Treap{rng: rand.New(rand.NewSource(time.Now().UnixNano()))}
}

func rotateRight(y *Node) *Node {
	x := y.left
	t2 := x.right
	x.right = y
	y.left = t2
	return x
}

func rotateLeft(x *Node) *Node {
	y := x.right
	t2 := y.left
	y.left = x
	x.right = t2
	return y
}

func insert(n *Node, key int64, pr uint32) *Node {
	if n == nil {
		return &Node{key: key, priority: pr}
	}
	if key < n.key {
		n.left = insert(n.left, key, pr)
		if n.left.priority > n.priority {
			n = rotateRight(n)
		}
	} else {
		n.right = insert(n.right, key, pr)
		if n.right.priority > n.priority {
			n = rotateLeft(n)
		}
	}
	return n
}

func deleteNode(n *Node, key int64) *Node {
	if n == nil {
		return nil
	}
	if key < n.key {
		n.left = deleteNode(n.left, key)
	} else if key > n.key {
		n.right = deleteNode(n.right, key)
	} else {
		if n.left == nil {
			return n.right
		}
		if n.right == nil {
			return n.left
		}
		if n.left.priority > n.right.priority {
			n = rotateRight(n)
			n.right = deleteNode(n.right, key)
		} else {
			n = rotateLeft(n)
			n.left = deleteNode(n.left, key)
		}
	}
	return n
}

func lowerBound(n *Node, key int64) *Node {
	var res *Node
	for n != nil {
		if key <= n.key {
			res = n
			n = n.left
		} else {
			n = n.right
		}
	}
	return res
}

func prevNode(n *Node, key int64) *Node {
	var res *Node
	for n != nil {
		if key <= n.key {
			n = n.left
		} else {
			res = n
			n = n.right
		}
	}
	return res
}

func minNode(n *Node) *Node {
	if n == nil {
		return nil
	}
	for n.left != nil {
		n = n.left
	}
	return n
}

func (t *Treap) Insert(key int64) {
	t.root = insert(t.root, key, t.rng.Uint32())
}

func (t *Treap) Delete(key int64) {
	t.root = deleteNode(t.root, key)
}

func (t *Treap) LowerBound(key int64) (int64, bool) {
	n := lowerBound(t.root, key)
	if n == nil {
		return 0, false
	}
	return n.key, true
}

func (t *Treap) Prev(key int64) (int64, bool) {
	n := prevNode(t.root, key)
	if n == nil {
		return 0, false
	}
	return n.key, true
}

func (t *Treap) Min() (int64, bool) {
	n := minNode(t.root)
	if n == nil {
		return 0, false
	}
	return n.key, true
}

type Move struct {
	w    int64
	side byte
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n int
	if _, err := fmt.Fscan(in, &n); err != nil {
		return
	}
	A := make([]int64, n)
	for i := 0; i < n; i++ {
		var x int64
		fmt.Fscan(in, &x)
		A[i] = x
	}
	var S string
	fmt.Fscan(in, &S)

	treap := NewTreap()
	for i := 0; i < n; i++ {
		treap.Insert(A[i])
	}

	moves := make([]Move, 0, n)
	var D int64 = 0

	for i := 0; i < n; i++ {
		c := S[i]
		if c == 'L' {
			if D <= 0 {
				t := -D + 1
				w, ok := treap.LowerBound(t)
				if !ok {
					fmt.Fprintln(out, -1)
					return
				}
				treap.Delete(w)
				D += w
				moves = append(moves, Move{w: w, side: 'L'})
			} else {
				w, ok := treap.Prev(D)
				if ok {
					treap.Delete(w)
					D -= w
					moves = append(moves, Move{w: w, side: 'R'})
				} else {
					wmin, _ := treap.Min()
					treap.Delete(wmin)
					D += wmin
					moves = append(moves, Move{w: wmin, side: 'L'})
				}
			}
		} else {
			if D >= 0 {
				t := D + 1
				w, ok := treap.LowerBound(t)
				if !ok {
					fmt.Fprintln(out, -1)
					return
				}
				treap.Delete(w)
				D -= w
				moves = append(moves, Move{w: w, side: 'R'})
			} else {
				w, ok := treap.Prev(-D)
				if ok {
					treap.Delete(w)
					D += w
					moves = append(moves, Move{w: w, side: 'L'})
				} else {
					wmin, _ := treap.Min()
					treap.Delete(wmin)
					D -= wmin
					moves = append(moves, Move{w: wmin, side: 'R'})
				}
			}
		}
	}

	for _, mv := range moves {
		fmt.Fprintf(out, "%d %c\n", mv.w, mv.side)
	}
}
```