func Run() {
	var s euler.Sieve

	p := 2
	count := 0

	// Move the closure out of the loop for efficiency.  It does
	// save some time.
	circular := true
	pcheck := func(num int) {
		if !s.IsPrime(num) {
			circular = false
		}
	}

	for p < 1000000 {
		circular = true
		eachRotation(p, pcheck)

		if circular {
			// fmt.Printf("%d\n", p)
			count++
		}
		p = s.NextPrime(p)
	}

	fmt.Printf("%d\n", count)
}

func familySize(sieve *euler.Sieve, base, part int) (size int) {
	orig := euler.DigitsOf(base)
	work := make([]int, len(orig))
	size = 0

	found := false
	for _, d := range orig {
		if d == part {
			found = true
			break
		}
	}
	if !found {
		return
	}

	for value := part; value <= 9; value++ {
		copy(work, orig)
		for i := range orig {
			if work[i] == part {
				work[i] = value
			}
		}

		prime := euler.OfDigits(work)
		if sieve.IsPrime(prime) {
			size++
		}
	}
	return
}

func Run() {
	var sieve euler.Sieve
	limit := 1000000
	ps := sieve.PrimesUpto(limit)

	longestLen := 0
	longestVal := 0

	for a := 1; a < len(ps); a++ {
		total := 0
		for b := a; b < len(ps); b++ {
			total += ps[b]
			if total >= limit {
				break
			}

			if b-a+1 > longestLen && sieve.IsPrime(total) {
				longestLen = b - a + 1
				longestVal = total
			}
		}
	}

	fmt.Printf("%d\n", longestVal)
}

func Run() {
	var sieve euler.Sieve

	prime := 2
	for i := 0; i < 10000; i++ {
		prime = sieve.NextPrime(prime)
	}
	fmt.Printf("%d\n", prime)
}

func isRightPrime(s *euler.Sieve, num int) bool {
	for num > 0 {
		if !s.IsPrime(num) {
			return false
		}
		num /= 10
	}
	return true
}

func longestSeries(sieve *euler.Sieve, a, b int) int {
	for n := 0; ; n++ {
		c := n*n + a*n + b
		if c < 2 || !sieve.IsPrime(c) {
			return n
		}
	}
	panic("Not reached")
}

func init() {
	earlyPrimes = make([]int, 10)
	var sieve euler.Sieve
	p := 2
	for i := range earlyPrimes {
		earlyPrimes[i] = p
		p = sieve.NextPrime(p)
	}
	return
}

func isAmicable(s *euler.Sieve, a int) bool {
	if a >= limit {
		return false
	}
	b := s.ProperDivisorSum(a)
	if b >= limit || a == b {
		return false
	}
	c := s.ProperDivisorSum(b)
	return a == c
}

func Run() {
	var sv euler.Sieve

	largest := 0
	for p := 2; p < 9999999; p = sv.NextPrime(p) {
		if isPandigital(p) {
			largest = p
		}
	}

	fmt.Printf("%d\n", largest)
}

func Run() {
	var sieve euler.Sieve

	all := make([][]euler.Factor, 0, 10000)
	for a := 2; a <= 100; a++ {
		for b := 2; b <= 100; b++ {
			tmp := factorPower(sieve.Factorize(a), b)
			all = append(all, tmp)
		}
	}
	sort.Sort(Nodes(all))
	all = unique(all)
	fmt.Printf("%v\n", len(all))
}

// Return the first goldbach prime for the given number, if present.
func goldbach(sieve *euler.Sieve, number int) (result int, present bool) {
	for _, p := range sieve.PrimesUpto(number) {
		if p == 2 {
			continue
		}
		_, perfect := perfect_root((number - p) / 2)
		if perfect {
			result = p
			present = true
			return
		}
	}
	return
}

func Run() {
	var s euler.Sieve

	n := 9
	for ; ; n += 2 {
		if s.IsPrime(n) {
			continue
		}
		_, present := goldbach(&s, n)
		if !present {
			break
		}
	}
	fmt.Printf("%d\n", n)
}

func Run() {
	var sieve euler.Sieve
	largest := 0
	largestValue := 0

	for p := 7; p < 1000; p = sieve.NextPrime(p) {
		size := dlog(p)
		if size > largest {
			largest = size
			largestValue = p
		}
	}

	fmt.Printf("%d\n", largestValue)
}

func Run() {
	var sieve euler.Sieve

	base := 2
	for {
		size := familySize(&sieve, base, 1)
		if size >= 8 {
			break
		}

		base = sieve.NextPrime(base)
	}

	fmt.Printf("%d\n", base)
}

func isLeftPrime(s *euler.Sieve, num int) bool {
	mod := 1
	for mod < num {
		mod *= 10
	}

	for mod > 1 {
		num %= mod
		mod /= 10
		if !s.IsPrime(num) {
			return false
		}
	}

	return true
}

func TestMR(t *testing.T) {
	var sv euler.Sieve

	limit := 1000000
	if testing.Short() {
		limit = 100000
	}

	for i := 2; i < limit; i++ {
		b := sv.IsPrime(i)
		b2 := euler.IsPrime(i, 20)

		if b != b2 {
			t.Errorf("Mismatch: %d (%v!=%v)", i, b, b2)
		}
	}
}

func Run() {
	var sieve euler.Sieve

	count := 0
	for i := 2; ; i++ {
		factors := sieve.Factorize(i)
		if len(factors) == expect {
			count += 1
			if count == expect {
				fmt.Printf("%d\n", i-expect+1)
				return
			}
		} else {
			count = 0
		}
	}
}

func Run() {
	var s euler.Sieve

	count := 0
	sum := 0
	p := 11
	for count < 11 {
		if isRightPrime(&s, p) && isLeftPrime(&s, p) {
			sum += p
			count++
			// fmt.Printf("%d\n", p)
		}

		p = s.NextPrime(p)
	}
	fmt.Printf("%d\n", sum)
}

func Run() {
	var sieve euler.Sieve

	num := start
	var prime int = 2
	for {
		if num == int64(prime) {
			fmt.Printf("%d\n", prime)
			break
		}

		// Divide out the prime as many times as possible.
		for num%int64(prime) == 0 {
			num /= int64(prime)
		}

		prime = sieve.NextPrime(prime)
	}
}

func divisorCount(sieve *euler.Sieve, n int) (result int) {
	result = 1
	tmp := n
	prime := 2

	for tmp > 1 {
		dcount := 0
		for tmp%prime == 0 {
			tmp /= prime
			dcount += 1
		}

		result *= dcount + 1

		if tmp > 1 {
			prime = sieve.NextPrime(prime)
		}
	}

	return
}