For problem statement at 0-999/0-99/0-9/7/problemE.txt this is a correct solution, but verifier at 0-999/0-99/0-9/7/verifierE.go ends with All 148 tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Expr struct {
	Type       int // 0: Primary, 1: MultDiv, 2: AddSub
	Suspicious bool
}

func combine(left Expr, right Expr, op byte) Expr {
	suspicious := left.Suspicious || right.Suspicious

	if op == '*' || op == '/' {
		if left.Type == 2 {
			suspicious = true
		}
	}

	if op == '-' {
		if right.Type == 2 {
			suspicious = true
		}
	} else if op == '*' {
		if right.Type == 2 {
			suspicious = true
		}
	} else if op == '/' {
		if right.Type == 1 || right.Type == 2 {
			suspicious = true
		}
	}

	typ := 0
	if op == '+' || op == '-' {
		typ = 2
	} else if op == '*' || op == '/' {
		typ = 1
	}

	return Expr{Type: typ, Suspicious: suspicious}
}

func lex(s string) []string {
	var tokens []string
	for i := 0; i < len(s); i++ {
		if s[i] == ' ' || s[i] == '\t' || s[i] == '\r' || s[i] == '\n' {
			continue
		}
		if (s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') {
			j := i
			for j < len(s) && ((s[j] >= 'a' && s[j] <= 'z') || (s[j] >= 'A' && s[j] <= 'Z')) {
				j++
			}
			tokens = append(tokens, s[i:j])
			i = j - 1
		} else if s[i] >= '0' && s[i] <= '9' {
			j := i
			for j < len(s) && s[j] >= '0' && s[j] <= '9' {
				j++
			}
			tokens = append(tokens, s[i:j])
			i = j - 1
		} else if s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/' || s[i] == '(' || s[i] == ')' || s[i] == '#' {
			tokens = append(tokens, string(s[i]))
		}
	}
	return tokens
}

type Parser struct {
	tokens []string
	pos    int
	macros map[string]Expr
}

func (p *Parser) peek() string {
	if p.pos >= len(p.tokens) {
		return ""
	}
	return p.tokens[p.pos]
}

func (p *Parser) match(s string) bool {
	if p.peek() == s {
		p.pos++
		return true
	}
	return false
}

func (p *Parser) consume() string {
	s := p.peek()
	p.pos++
	return s
}

func (p *Parser) parseExpression() Expr {
	return p.parseAddSub()
}

func (p *Parser) parseAddSub() Expr {
	left := p.parseMultDiv()
	for {
		if p.match("+") {
			right := p.parseMultDiv()
			left = combine(left, right, '+')
		} else if p.match("-") {
			right := p.parseMultDiv()
			left = combine(left, right, '-')
		} else {
			break
		}
	}
	return left
}

func (p *Parser) parseMultDiv() Expr {
	left := p.parsePrimary()
	for {
		if p.match("*") {
			right := p.parsePrimary()
			left = combine(left, right, '*')
		} else if p.match("/") {
			right := p.parsePrimary()
			left = combine(left, right, '/')
		} else {
			break
		}
	}
	return left
}

func (p *Parser) parsePrimary() Expr {
	if p.match("(") {
		inner := p.parseExpression()
		p.match(")")
		return Expr{Type: 0, Suspicious: inner.Suspicious}
	}

	tok := p.consume()
	if isIdent(tok) {
		if val, ok := p.macros[tok]; ok {
			return val
		}
		return Expr{Type: 0, Suspicious: false}
	}
	return Expr{Type: 0, Suspicious: false}
}

func isIdent(s string) bool {
	if len(s) == 0 {
		return false
	}
	return (s[0] >= 'a' && s[0] <= 'z') || (s[0] >= 'A' && s[0] <= 'Z')
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	if !scanner.Scan() {
		return
	}
	firstLine := strings.TrimSpace(scanner.Text())
	n, _ := strconv.Atoi(firstLine)

	macros := make(map[string]Expr)

	for i := 0; i < n; i++ {
		if !scanner.Scan() {
			return
		}
		line := scanner.Text()
		tokens := lex(line)
		idx := 0
		if idx < len(tokens) && tokens[idx] == "#" {
			idx++
		}
		if idx < len(tokens) && tokens[idx] == "define" {
			idx++
		}
		if idx < len(tokens) {
			name := tokens[idx]
			exprTokens := tokens[idx+1:]
			p := &Parser{tokens: exprTokens, macros: macros}
			expr := p.parseExpression()
			macros[name] = expr
		}
	}

	for scanner.Scan() {
		line := scanner.Text()
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
		tokens := lex(line)
		if len(tokens) == 0 {
			continue
		}
		p := &Parser{tokens: tokens, macros: macros}
		expr := p.parseExpression()
		if expr.Suspicious {
			fmt.Println("Suspicious")
		} else {
			fmt.Println("OK")
		}
		return
	}
}
```