package main

import (
	"fmt"
	"io"
	"math"
	"os"
)

type validator struct {
	Numbers []int
}

func newValidator() *validator {
	return &validator{
		Numbers: []int{},
	}
}

func (v *validator) validate(number int) (ok bool) {
	for i1, num1 := range v.Numbers {
		for i2, num2 := range v.Numbers {
			if i1 == i2 {
				continue
			}
			if num1+num2 == number {
				ok = true
				return
			}
		}
	}
	return
}

func (v *validator) Feed(number int) (ok bool) {
	if len(v.Numbers) >= 25 {
		// check if valid number
		if !v.validate(number) {
			return
		}
		v.Numbers = append(v.Numbers[len(v.Numbers)-24:], number)
	} else {
		v.Numbers = append(v.Numbers, number)
	}
	ok = true
	return
}

func main() {
	f, err := os.Open("input")
	if err != nil {
		panic(err)
	}

	v := newValidator()

	number := 0
	allNumbers := []int{}

	for {
		_, err := fmt.Fscanf(f, "%d\n", &number)
		if err == io.EOF {
			break
		}
		if err != nil {
			panic(err)
		}

		if !v.Feed(number) {
			fmt.Printf("%d does not validate\n", number)
			fmt.Printf("%d numbers tracked\n", len(allNumbers))

			// find contiguous set of numbers that add up to this invalid number
		weaknessloop:
			for i1 := range allNumbers {
				for i2 := i1 + 1; i2 < len(allNumbers); i2++ {
					sum := 0
					min := math.MaxInt32
					max := math.MinInt32
					for i := i1; i <= i2; i++ {
						newNum := allNumbers[i]
						if min > newNum {
							min = newNum
						}
						if max < newNum {
							max = newNum
						}
						sum += newNum
					}
					if sum == number {
						fmt.Printf("min: %d\n", min)
						fmt.Printf("max: %d\n", max)
						fmt.Printf("weakness: %d\n", min+max)
						break weaknessloop
					}
				}
			}

			break
		}

		allNumbers = append(allNumbers, number)
	}
}