test: add unit test for part one

internal/2015/DayFifteen/code.go

@@ -0,0 +1,141 @@
+package dayfifteen
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2015D15", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+type ingredient struct {
+	capacity   int
+	durability int
+	flavor     int
+	texture    int
+	calories   int
+}
+
+func parseIngredient(line string) ingredient {
+	parts := strings.Split(line, ": ")
+	props := strings.Split(parts[1], ", ")
+	var cap, dur, flav, tex, cal int
+
+	for _, prop := range props {
+		var name string
+		var value int
+		fmt.Sscanf(prop, "%s %d", &name, &value)
+		switch name {
+		case "capacity":
+			cap = value
+		case "durability":
+			dur = value
+		case "flavor":
+			flav = value
+		case "texture":
+			tex = value
+		case "calories":
+			cal = value
+		}
+	}
+
+	return ingredient{
+		capacity:   cap,
+		durability: dur,
+		flavor:     flav,
+		texture:    tex,
+		calories:   cal,
+	}
+}
+
+func calculateScore(ingredients []ingredient, amounts []int) int {
+	var capacity, durability, flavor, texture int
+	for idx, ing := range ingredients {
+		capacity += ing.capacity * amounts[idx]
+		durability += ing.durability * amounts[idx]
+		flavor += ing.flavor * amounts[idx]
+		texture += ing.texture * amounts[idx]
+	}
+	if capacity < 0 {
+		capacity = 0
+	}
+	if durability < 0 {
+		durability = 0
+	}
+	if flavor < 0 {
+		flavor = 0
+	}
+	if texture < 0 {
+		texture = 0
+	}
+	return capacity * durability * flavor * texture
+}
+
+func calculateCalories(ingredients []ingredient, amounts []int) int {
+	var calories int
+	for idx, ing := range ingredients {
+		calories += ing.calories * amounts[idx]
+	}
+	return calories
+}
+
+func PartOne(data []string) int {
+	var ingredients []ingredient
+	for _, line := range data {
+		ingredients = append(ingredients, parseIngredient(line))
+	}
+	amounts := make([]int, len(ingredients))
+	var findMaxScore func(remaining int, index int) int
+	findMaxScore = func(remaining int, index int) int {
+		if index == len(ingredients)-1 {
+			amounts[index] = remaining
+			return calculateScore(ingredients, amounts)
+		}
+		maxScore := 0
+		for idx := 0; idx <= remaining; idx++ {
+			amounts[index] = idx
+			score := findMaxScore(remaining-idx, index+1)
+			if score > maxScore {
+				maxScore = score
+			}
+		}
+		return maxScore
+	}
+	return findMaxScore(100, 0)
+}
+
+func PartTwo(data []string) int {
+	var ingredients []ingredient
+	for _, line := range data {
+		ingredients = append(ingredients, parseIngredient(line))
+	}
+	amounts := make([]int, len(ingredients))
+	var findMaxScoreWithCalories func(remaining int, index int) int
+	findMaxScoreWithCalories = func(remaining int, index int) int {
+		if index == len(ingredients)-1 {
+			amounts[index] = remaining
+			if calculateCalories(ingredients, amounts) == 500 {
+				return calculateScore(ingredients, amounts)
+			}
+			return 0
+		}
+		maxScore := 0
+		for idx := 0; idx <= remaining; idx++ {
+			amounts[index] = idx
+			score := findMaxScoreWithCalories(remaining-idx, index+1)
+			if score > maxScore {
+				maxScore = score
+			}
+		}
+		return maxScore
+	}
+	return findMaxScoreWithCalories(100, 0)
+}

internal/2015/DayFifteen/code_test.go

@@ -0,0 +1,24 @@
+package dayfifteen
+
+import "testing"
+
+var testInput = []string{
+	"Butterscotch: capacity -1, durability -2, flavor 6, texture 3, calories 8",
+	"Cinnamon: capacity 2, durability 3, flavor -2, texture -1, calories 3",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 62842880
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 57600000
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2015/register.go

@@ -3,6 +3,7 @@ package year2015
 import (
 	_ "advent-of-code/internal/2015/DayEight"
 	_ "advent-of-code/internal/2015/DayEleven"
+	_ "advent-of-code/internal/2015/DayFifteen"
 	_ "advent-of-code/internal/2015/DayFive"
 	_ "advent-of-code/internal/2015/DayFour"
 	_ "advent-of-code/internal/2015/DayFourteen"

internal/2017/DayFive/code.go

@@ -0,0 +1,60 @@
+package dayfive
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2017D5", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []int {
+	content, _ := os.ReadFile(filepath)
+	var data []int
+	for line := range strings.SplitSeq(string(content), "\n") {
+		num, _ := strconv.Atoi(line)
+		data = append(data, num)
+	}
+	return data
+}
+
+func PartOne(data []int) int {
+	instructions := make([]int, len(data))
+	copy(instructions, data)
+
+	position := 0
+	steps := 0
+
+	for position >= 0 && position < len(instructions) {
+		jump := instructions[position]
+		instructions[position]++
+		position += jump
+		steps++
+	}
+
+	return steps
+}
+
+func PartTwo(data []int) int {
+	instructions := make([]int, len(data))
+	copy(instructions, data)
+
+	position := 0
+	steps := 0
+
+	for position >= 0 && position < len(instructions) {
+		jump := instructions[position]
+		if jump >= 3 {
+			instructions[position]--
+		} else {
+			instructions[position]++
+		}
+		position += jump
+		steps++
+	}
+
+	return steps
+}

internal/2017/DayFive/code_test.go

@@ -0,0 +1,27 @@
+package dayfive
+
+import "testing"
+
+var testInput = []int{
+	0,
+	3,
+	0,
+	1,
+	-3,
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 5
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 10
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2017/DayFour/code.go

@@ -0,0 +1,60 @@
+package dayfour
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"slices"
+	"strings"
+)
+
+func init() {
+	registry.Register("2017D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	validCount := 0
+	for _, passphrase := range data {
+		words := strings.Fields(passphrase)
+		seen := make(map[string]bool, len(words))
+		hasDuplicate := false
+		for _, word := range words {
+			if seen[word] {
+				hasDuplicate = true
+				break
+			}
+			seen[word] = true
+		}
+		if !hasDuplicate {
+			validCount++
+		}
+	}
+	return validCount
+}
+
+func PartTwo(data []string) int {
+	validCount := 0
+	for _, passphrase := range data {
+		words := strings.Fields(passphrase)
+		seen := make(map[string]bool, len(words))
+		hasAnagram := false
+		for _, word := range words {
+			runes := []rune(word)
+			slices.Sort(runes)
+			normalized := string(runes)
+			if seen[normalized] {
+				hasAnagram = true
+				break
+			}
+			seen[normalized] = true
+		}
+		if !hasAnagram {
+			validCount++
+		}
+	}
+	return validCount
+}

internal/2017/DayFour/code_test.go

@@ -0,0 +1,89 @@
+package dayfour
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		expected int
+	}{
+		{
+			name:     "aa bb cc dd ee is valid",
+			input:    []string{"aa bb cc dd ee"},
+			expected: 1,
+		},
+		{
+			name:     "aa bb cc dd aa is not valid",
+			input:    []string{"aa bb cc dd aa"},
+			expected: 0,
+		},
+		{
+			name:     "aa bb cc dd aaa is valid",
+			input:    []string{"aa bb cc dd aaa"},
+			expected: 1,
+		},
+		{
+			name:     "multiple passphrases",
+			input:    []string{"aa bb cc dd ee", "aa bb cc dd aa", "aa bb cc dd aaa"},
+			expected: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		expected int
+	}{
+		{
+			name:     "abcde fghij is valid",
+			input:    []string{"abcde fghij"},
+			expected: 1,
+		},
+		{
+			name:     "abcde xyz ecdab is not valid",
+			input:    []string{"abcde xyz ecdab"},
+			expected: 0,
+		},
+		{
+			name:     "a ab abc abd abf abj is valid",
+			input:    []string{"a ab abc abd abf abj"},
+			expected: 1,
+		},
+		{
+			name:     "iiii oiii ooii oooi oooo is valid",
+			input:    []string{"iiii oiii ooii oooi oooo"},
+			expected: 1,
+		},
+		{
+			name:     "oiii ioii iioi iiio is not valid",
+			input:    []string{"oiii ioii iioi iiio"},
+			expected: 0,
+		},
+		{
+			name:     "multiple passphrases",
+			input:    []string{"abcde fghij", "abcde xyz ecdab", "a ab abc abd abf abj", "oiii ioii iioi iiio"},
+			expected: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2017/DayThree/code.go

@@ -46,5 +46,36 @@ func PartOne(data int) int {
 }
 
 func PartTwo(data int) int {
-	return 0
+	grid := make(map[[2]int]int)
+	grid[[2]int{0, 0}] = 1
+
+	directions := [4][2]int{{1, 0}, {0, 1}, {-1, 0}, {0, -1}}
+	x, y := 1, 0
+	directionIdx := 0
+	sideLength := 1
+	stepsInSide := 1
+
+	for {
+		sum := grid[[2]int{x - 1, y - 1}] + grid[[2]int{x - 1, y}] + grid[[2]int{x - 1, y + 1}] +
+			grid[[2]int{x, y - 1}] + grid[[2]int{x, y + 1}] +
+			grid[[2]int{x + 1, y - 1}] + grid[[2]int{x + 1, y}] + grid[[2]int{x + 1, y + 1}]
+
+		if sum > data {
+			return sum
+		}
+
+		grid[[2]int{x, y}] = sum
+
+		if stepsInSide == sideLength {
+			stepsInSide = 0
+			if directionIdx%2 == 1 {
+				sideLength++
+			}
+			directionIdx = (directionIdx + 1) % 4
+		}
+
+		x += directions[directionIdx][0]
+		y += directions[directionIdx][1]
+		stepsInSide++
+	}
 }

internal/2017/DayThree/code_test.go

@@ -39,3 +39,46 @@ func TestPartOne(t *testing.T) {
 		})
 	}
 }
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    int
+		expected int
+	}{
+		{
+			name:     "input 1 returns first value larger than 1",
+			input:    1,
+			expected: 2,
+		},
+		{
+			name:     "input 2 returns first value larger than 2",
+			input:    2,
+			expected: 4,
+		},
+		{
+			name:     "input 4 returns first value larger than 4",
+			input:    4,
+			expected: 5,
+		},
+		{
+			name:     "input 5 returns first value larger than 5",
+			input:    5,
+			expected: 10,
+		},
+		{
+			name:     "input 747 returns first value larger than 747",
+			input:    747,
+			expected: 806,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2017/register.go

@@ -1,6 +1,8 @@
 package year2017
 
 import (
+	_ "advent-of-code/internal/2017/DayFive"
+	_ "advent-of-code/internal/2017/DayFour"
 	_ "advent-of-code/internal/2017/DayOne"
 	_ "advent-of-code/internal/2017/DayThree"
 	_ "advent-of-code/internal/2017/DayTwo"

internal/2025/DayEleven/code.go

@@ -0,0 +1,153 @@
+package dayeleven
+
+import (
+	"os"
+	"slices"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2025D11", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func buildGraph(data []string) map[string][]string {
+	graph := make(map[string][]string)
+
+	for _, line := range data {
+		device, outputsStr, _ := strings.Cut(line, ": ")
+		graph[device] = strings.Fields(outputsStr)
+	}
+
+	return graph
+}
+
+func hasCycle(graph map[string][]string) bool {
+	const (
+		unvisited = iota
+		visiting
+		visited
+	)
+
+	state := make(map[string]uint8)
+
+	var dfs func(node string) bool
+	dfs = func(node string) bool {
+		switch state[node] {
+		case visiting:
+			return true
+		case visited:
+			return false
+		}
+
+		state[node] = visiting
+		if slices.ContainsFunc(graph[node], dfs) {
+			return true
+		}
+		state[node] = visited
+		return false
+	}
+
+	for node := range graph {
+		if state[node] == unvisited {
+			if dfs(node) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func countPaths(graph map[string][]string, start, end string, requiredNodes map[string]bool) int {
+	requiredIndex := make(map[string]uint)
+	var targetMask uint
+	for node := range requiredNodes {
+		requiredIndex[node] = uint(len(requiredIndex))
+		targetMask |= 1 << requiredIndex[node]
+	}
+
+	if hasCycle(graph) {
+		var dfs func(node string, visited map[string]bool, seenMask uint) int
+		dfs = func(node string, visited map[string]bool, seenMask uint) int {
+			if node == end {
+				if seenMask != targetMask {
+					return 0
+				}
+				return 1
+			}
+
+			if idx, ok := requiredIndex[node]; ok {
+				seenMask |= 1 << idx
+			}
+
+			visited[node] = true
+			defer delete(visited, node)
+
+			count := 0
+			for _, neighbor := range graph[node] {
+				if !visited[neighbor] {
+					count += dfs(neighbor, visited, seenMask)
+				}
+			}
+			return count
+		}
+
+		return dfs(start, make(map[string]bool), 0)
+	}
+
+	type key struct {
+		node string
+		mask uint
+	}
+	memo := make(map[key]int)
+
+	var dfs func(node string, seenMask uint) int
+	dfs = func(node string, seenMask uint) int {
+		if node == end {
+			if seenMask != targetMask {
+				return 0
+			}
+			return 1
+		}
+
+		if idx, ok := requiredIndex[node]; ok {
+			seenMask |= 1 << idx
+		}
+
+		state := key{node: node, mask: seenMask}
+		if cached, ok := memo[state]; ok {
+			return cached
+		}
+
+		count := 0
+		for _, neighbor := range graph[node] {
+			count += dfs(neighbor, seenMask)
+		}
+
+		memo[state] = count
+		return count
+	}
+
+	return dfs(start, 0)
+}
+
+func PartOne(data []string) int {
+	graph := buildGraph(data)
+	return countPaths(graph, "you", "out", nil)
+}
+
+func PartTwo(data []string) int {
+	graph := buildGraph(data)
+	requiredNodes := map[string]bool{
+		"dac": true,
+		"fft": true,
+	}
+	return countPaths(graph, "svr", "out", requiredNodes)
+}

internal/2025/DayEleven/code_test.go

@@ -0,0 +1,46 @@
+package dayeleven
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	testInput := []string{
+		"aaa: you hhh",
+		"you: bbb ccc",
+		"bbb: ddd eee",
+		"ccc: ddd eee fff",
+		"ddd: ggg",
+		"eee: out",
+		"fff: out",
+		"ggg: out",
+		"hhh: ccc fff iii",
+		"iii: out",
+	}
+	expected := 5
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	testInput := []string{
+		"svr: aaa bbb",
+		"aaa: fft",
+		"fft: ccc",
+		"bbb: tty",
+		"tty: ccc",
+		"ccc: ddd eee",
+		"ddd: hub",
+		"hub: fff",
+		"eee: dac",
+		"dac: fff",
+		"fff: ggg hhh",
+		"ggg: out",
+		"hhh: out",
+	}
+	expected := 2
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2025/DayTen/code.go

@@ -1,11 +1,25 @@
 package dayten
 
 import (
-	"advent-of-code/internal/registry"
+	"math"
 	"os"
 	"regexp"
 	"strconv"
 	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+const (
+	positiveInfinity = math.MaxFloat64
+	negativeInfinity = -math.MaxFloat64
+	epsilon          = 1e-9
+)
+
+var (
+	bracketRegex     = regexp.MustCompile(`\[([.#]+)\]`)
+	parenthesisRegex = regexp.MustCompile(`\(([^)]+)\)`)
+	braceRegex       = regexp.MustCompile(`\{([^}]+)\}`)
 )
 
 func init() {
@@ -18,9 +32,6 @@ func ParseInput(filepath string) []string {
 }
 
 func parseMachine(line string) ([]bool, [][]int) {
-	bracketRegex := regexp.MustCompile(`\[([.#]+)\]`)
-	parenthesisRegex := regexp.MustCompile(`\(([^)]+)\)`)
-
 	bracketMatch := bracketRegex.FindStringSubmatch(line)
 	targetString := bracketMatch[1]
 	target := make([]bool, len(targetString))
@@ -45,6 +56,246 @@ func parseMachine(line string) ([]bool, [][]int) {
 	return target, buttons
 }
 
+func solveIntegerLinearMinimization(constraints [][]float64, objective []float64) int {
+	best := positiveInfinity
+	stack := [][][]float64{constraints}
+
+	for len(stack) > 0 {
+		current := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+
+		numberOfRows := len(current)
+		numberOfVariables := len(current[0]) - 1
+		rightHandSideIdx := numberOfVariables + 1
+
+		nonBasic := make([]int, numberOfVariables+1)
+		for idx := range numberOfVariables {
+			nonBasic[idx] = idx
+		}
+		nonBasic[numberOfVariables] = -1
+
+		basic := make([]int, numberOfRows)
+		for idx := range numberOfRows {
+			basic[idx] = numberOfVariables + idx
+		}
+
+		tableau := make([][]float64, numberOfRows+2)
+		for idx := range numberOfRows {
+			tableau[idx] = make([]float64, numberOfVariables+2)
+			copy(tableau[idx][:numberOfVariables+1], current[idx])
+			tableau[idx][rightHandSideIdx] = -1.0
+			tableau[idx][numberOfVariables], tableau[idx][rightHandSideIdx] = tableau[idx][rightHandSideIdx], tableau[idx][numberOfVariables]
+		}
+		tableau[numberOfRows] = make([]float64, numberOfVariables+2)
+		copy(tableau[numberOfRows][:numberOfVariables], objective)
+		tableau[numberOfRows+1] = make([]float64, numberOfVariables+2)
+		tableau[numberOfRows+1][numberOfVariables] = 1.0
+
+		pivot := func(row, column int) {
+			k := 1.0 / tableau[row][column]
+			for i := 0; i < numberOfRows+2; i++ {
+				if i == row {
+					continue
+				}
+				for j := 0; j < numberOfVariables+2; j++ {
+					if j != column {
+						tableau[i][j] -= tableau[row][j] * tableau[i][column] * k
+					}
+				}
+			}
+			for j := 0; j < numberOfVariables+2; j++ {
+				tableau[row][j] *= k
+			}
+			for i := 0; i < numberOfRows+2; i++ {
+				tableau[i][column] *= -k
+			}
+			tableau[row][column] = k
+			basic[row], nonBasic[column] = nonBasic[column], basic[row]
+		}
+
+		findOptimalPivot := func(phase int) bool {
+			for {
+				pivotColumn := -1
+				minimumValue := positiveInfinity
+				minimumIndex := math.MaxInt
+
+				for idx := 0; idx <= numberOfVariables; idx++ {
+					if phase == 0 && nonBasic[idx] == -1 {
+						continue
+					}
+					value := tableau[numberOfRows+phase][idx]
+					if pivotColumn == -1 || value < minimumValue-epsilon || (math.Abs(value-minimumValue) <= epsilon && nonBasic[idx] < minimumIndex) {
+						pivotColumn = idx
+						minimumValue = value
+						minimumIndex = nonBasic[idx]
+					}
+				}
+
+				if tableau[numberOfRows+phase][pivotColumn] > -epsilon {
+					return true
+				}
+
+				pivotRow := -1
+				minimumRatio := positiveInfinity
+				minimumBasicIndex := math.MaxInt
+
+				for idx := range numberOfRows {
+					if tableau[idx][pivotColumn] > epsilon {
+						ratio := tableau[idx][rightHandSideIdx] / tableau[idx][pivotColumn]
+						if pivotRow == -1 || ratio < minimumRatio-epsilon || (math.Abs(ratio-minimumRatio) <= epsilon && basic[idx] < minimumBasicIndex) {
+							pivotRow = idx
+							minimumRatio = ratio
+							minimumBasicIndex = basic[idx]
+						}
+					}
+				}
+
+				if pivotRow == -1 {
+					return false
+				}
+
+				pivot(pivotRow, pivotColumn)
+			}
+		}
+
+		extractSolution := func() (float64, []float64) {
+			solution := make([]float64, numberOfVariables)
+			for idx := range numberOfRows {
+				if basic[idx] >= 0 && basic[idx] < numberOfVariables {
+					solution[basic[idx]] = tableau[idx][rightHandSideIdx]
+				}
+			}
+			result := 0.0
+			for idx := range numberOfVariables {
+				result += objective[idx] * solution[idx]
+			}
+			return result, solution
+		}
+
+		var value float64
+		var solution []float64
+
+		mostNegativeRow := 0
+		mostNegativeValue := tableau[0][rightHandSideIdx]
+		for idx := 1; idx < numberOfRows; idx++ {
+			if tableau[idx][rightHandSideIdx] < mostNegativeValue {
+				mostNegativeValue = tableau[idx][rightHandSideIdx]
+				mostNegativeRow = idx
+			}
+		}
+
+		if mostNegativeValue < -epsilon {
+			pivot(mostNegativeRow, numberOfVariables)
+			if !findOptimalPivot(1) || tableau[numberOfRows+1][rightHandSideIdx] < -epsilon {
+				value = negativeInfinity
+				solution = nil
+			} else {
+				for i := range numberOfRows {
+					if basic[i] == -1 {
+						column := 0
+						columnValue := tableau[i][0]
+						columnIndex := nonBasic[0]
+						for j := 1; j < numberOfVariables; j++ {
+							if tableau[i][j] < columnValue-epsilon || (math.Abs(tableau[i][j]-columnValue) <= epsilon && nonBasic[j] < columnIndex) {
+								column = j
+								columnValue = tableau[i][j]
+								columnIndex = nonBasic[j]
+							}
+						}
+						pivot(i, column)
+					}
+				}
+				if findOptimalPivot(0) {
+					value, solution = extractSolution()
+				} else {
+					value = negativeInfinity
+					solution = nil
+				}
+			}
+		} else {
+			if findOptimalPivot(0) {
+				value, solution = extractSolution()
+			} else {
+				value = negativeInfinity
+				solution = nil
+			}
+		}
+
+		if value == negativeInfinity || value >= best-epsilon {
+			continue
+		}
+
+		fractionalIdx := -1
+		var fractionalValue float64
+		for idx, value := range solution {
+			if math.Abs(value-math.Round(value)) > epsilon {
+				fractionalIdx = idx
+				fractionalValue = value
+				break
+			}
+		}
+
+		if fractionalIdx == -1 {
+			best = value
+			continue
+		}
+
+		numberOfColumns := len(current[0])
+		fractionalPart := fractionalValue - math.Floor(fractionalValue)
+
+		ceilConstraint := make([]float64, numberOfColumns)
+		ceilConstraint[fractionalIdx] = -1.0
+		ceilConstraint[numberOfColumns-1] = -math.Ceil(fractionalValue)
+		ceilBranch := make([][]float64, len(current)+1)
+		copy(ceilBranch, current)
+		ceilBranch[len(current)] = ceilConstraint
+
+		floorConstraint := make([]float64, numberOfColumns)
+		floorConstraint[fractionalIdx] = 1.0
+		floorConstraint[numberOfColumns-1] = math.Floor(fractionalValue)
+		floorBranch := make([][]float64, len(current)+1)
+		copy(floorBranch, current)
+		floorBranch[len(current)] = floorConstraint
+
+		if fractionalPart > 0.5 {
+			stack = append(stack, ceilBranch, floorBranch)
+		} else {
+			stack = append(stack, floorBranch, ceilBranch)
+		}
+	}
+
+	return int(math.Round(best))
+}
+
+func findMinimumJoltagePresses(buttons [][]int, joltages []int) int {
+	numberOfCounters, numberOfButtons := len(joltages), len(buttons)
+	numberOfRows, numberOfColumns := 2*numberOfCounters+numberOfButtons, numberOfButtons+1
+	constraints := make([][]float64, numberOfRows)
+	for i := range constraints {
+		constraints[i] = make([]float64, numberOfColumns)
+	}
+	for j := range numberOfButtons {
+		constraints[numberOfRows-1-j][j] = -1.0
+	}
+	for buttonIdx, button := range buttons {
+		for _, counterIdx := range button {
+			constraints[counterIdx][buttonIdx] = 1.0
+			constraints[counterIdx+numberOfCounters][buttonIdx] = -1.0
+		}
+	}
+	for idx, value := range joltages {
+		value := float64(value)
+		constraints[idx][numberOfColumns-1] = value
+		constraints[idx+numberOfCounters][numberOfColumns-1] = -value
+	}
+	objective := make([]float64, numberOfButtons)
+	for idx := range objective {
+		objective[idx] = 1.0
+	}
+
+	return solveIntegerLinearMinimization(constraints, objective)
+}
+
 func PartOne(data []string) int {
 	total := 0
 	for _, line := range data {
@@ -87,5 +338,16 @@ func PartOne(data []string) int {
 }
 
 func PartTwo(data []string) int {
-	return 0
+	total := 0
+	for _, line := range data {
+		_, buttons := parseMachine(line)
+		braceMatch := braceRegex.FindStringSubmatch(line)
+		parts := strings.Split(braceMatch[1], ",")
+		joltages := make([]int, len(parts))
+		for idx, part := range parts {
+			joltages[idx], _ = strconv.Atoi(part)
+		}
+		total += findMinimumJoltagePresses(buttons, joltages)
+	}
+	return total
 }

internal/2025/DayTwelve/code.go

@@ -0,0 +1,17 @@
+package daytwelve
+
+import (
+	"os"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2025D12", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}

internal/2025/DayTwelve/code_test.go

@@ -0,0 +1,47 @@
+package daytwelve
+
+import "testing"
+
+var testInput = []string{
+	"0:",
+	"###",
+	"##.",
+	"##.",
+	"",
+	"1:",
+	"###",
+	"##.",
+	".##",
+	"",
+	"2:",
+	".##",
+	"###",
+	"##.",
+	"",
+	"3:",
+	"##.",
+	"###",
+	"##.",
+	"",
+	"4:",
+	"###",
+	"#..",
+	"###",
+	"",
+	"5:",
+	"###",
+	".#.",
+	"###",
+	"",
+	"4x4: 0 0 0 0 2 0",
+	"12x5: 1 0 1 0 2 2",
+	"12x5: 1 0 1 0 3 2",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 2
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}

internal/2025/register.go

@@ -2,6 +2,7 @@ package year2025
 
 import (
 	_ "advent-of-code/internal/2025/DayEight"
+	_ "advent-of-code/internal/2025/DayEleven"
 	_ "advent-of-code/internal/2025/DayFive"
 	_ "advent-of-code/internal/2025/DayFour"
 	_ "advent-of-code/internal/2025/DayNine"
@@ -10,5 +11,6 @@ import (
 	_ "advent-of-code/internal/2025/DaySix"
 	_ "advent-of-code/internal/2025/DayTen"
 	_ "advent-of-code/internal/2025/DayThree"
+	_ "advent-of-code/internal/2025/DayTwelve"
 	_ "advent-of-code/internal/2025/DayTwo"
 )

internal/data/2015/DayFifteen/input.txt

@@ -0,0 +1,4 @@
+Sprinkles: capacity 2, durability 0, flavor -2, texture 0, calories 3
+Butterscotch: capacity 0, durability 5, flavor -3, texture 0, calories 3
+Chocolate: capacity 0, durability 0, flavor 5, texture -1, calories 8
+Candy: capacity 0, durability -1, flavor 0, texture 5, calories 8

internal/data/2017/DayFour/input.txt

@@ -0,0 +1,512 @@
+bdwdjjo avricm cjbmj ran lmfsom ivsof
+mxonybc fndyzzi gmdp gdfyoi inrvhr kpuueel wdpga vkq
+bneh ylltsc vhryov lsd hmruxy ebnh pdln vdprrky
+fumay zbccai qymavw zwoove hqpd rcxyvy
+bcuo khhkkro mpt dxrebym qwum zqp lhmbma esmr qiyomu
+qjs giedut mzsubkn rcbugk voxk yrlp rqxfvz kspz vxg zskp
+srceh xdwao reshc shecr
+dcao isz wwse bbdgn ewsw qkze pwu
+lbnvl lviftmr zqiv iadanl fdhrldn dlaani lxy dhfndrl fkoukx
+raovmz pdysjsw hqps orsyqw rrwnzcz vrzoam jjljt
+wgt gzi icpwp qeefgbe msadakj jbbrma sbj dufuujx zex
+cfzx bvyu eswr hafcfy klw bgnhynv qrf aop
+rzlq atrzcpb hpl pajjw cdxep ean aptzcrb rzcbapt
+xogpf ucc nsukoz umtfbw xfvth ozusnk fopxg ubp iflb
+xot nqcdyu kpwix szo cyxv hpmp hwtrc zso nyuqdc aha
+mkzf cat tkjprc izxdggf obspan lmlbg bsyspf twox
+lfmfrd ooclx tcl clt
+dxvnyd nxwojj arutn eyqocj swzao tmh juvpezm
+teu eman rlmdmk xkbodv fvrcm zorgy wmwe
+hmo fdayx duciqf cgt duciqf
+imjnv vfmsha cyrusow xjswoq nclrmjy sjxowq ynjrcml
+rwbsay alsi bmzpvw ozq aduui nihwx glwdiz ixmkgfx
+vtjzc ntkh zekj qrbkjhn zekj lyfnbg
+afaig jqhli oie lhwyduh kqfnraz nfrzaqk mayfg iljqh
+inb zum zmu dnl zjxg vrdziq ypdnsvt
+uhbzmre mpdxm alkbmsq aopjmkl mqxenry ayvkrf zxvs qkfqva
+fimjr ccv cnug crdsv
+bqyve lhxdj ydu qbyve vihwjr vyodhc
+vmng dyttyf noagpji tdtyfy ewiest ogg
+kgscfj klmsv vmksl vmlks
+qlvh veo wruft wtm fbrlvjr evo wvwmny dhp bvrlrfj lvt vgzuyyw
+mxuro orxmu tivu tjdq ojjvju cdd
+kjexme gxbysxp yxrum hinrklv fxehytd qkt tqk umryx nim
+kywnux wab tzrft dsaz jgwuw dubarmi fle wjguvr umjp uzncwj mzz
+qokwh zrda xywufk tbxhhj eejqaoa hwoqk zer hwt hbjxth xyf hmh
+eregs qdx tdequa agrlrg mwwpba qjie yrjvhr txujk
+iyot fxwdcb zvwfv vfzwv wvkw ncwbr wdejrr ltcdza
+waix eza znmonya ldfghws ialwfvc dey ubsz uhbnh svgekg nonzyam
+bryz tfbqn xznfmw xiplgww wwxigpl jxzcgxl rzyb
+cqvl rrcoqxs staeuqr hzzow cwv tsvol dio coc ddavii uuojy
+txbn qvkkyh gbqnjtq ndpkqr srt bkpqfmm ytycev ypcv bpqmmfk
+uqkjmul dour zgq ztango yrrjhrg ufxnmuw
+ekxbcv vkxbec xbcevk jiq bar
+wczff qdu cwffz hhk wlvyg
+zjlconc osgsro dajzo hqih ehml
+hnio shccluw cpu ivaby tormn vkef abv vkef ivaby
+xgbdeso xiizs omqwy sbtnnt khago evviclw xyu dtvg wsyxfuc humewp
+cnzu bia vdyqrf wwb qveum hmh ouupgc owli
+pjpmfxa dvd lxgh ndy gwph oebfkqv vtlxdg efl ekj dyn
+mvan nmdkc ucyshia mavn ecst poo
+oybm pjwm bmyo wovgu xykziaq obmy eiirhqd
+xkvomx yxvv oxxpth elh vxvy lhe ycn
+okxglw gmaangx gnxaamg yduzrr nzwxtnd rcxcu xjjvno yat cin gaxnamg yss
+oicgs rrol zvnbna rrol
+abb edpnxuo peoudxn bab ceay
+ncpkfz gvwunb fckpzn caafx pkcfzn tsfl
+fnrt ymenkpq wodubcm niv nvi ziluu cuowbdm zocg pdakwt mlzxkex nuxqclo
+uouxcgl stgua otadr ideannq wizxunv iqsdpj mxddt ldst ucxogul
+rbrwyhk wqoz zqwo ikwgexl atpu iza
+smo yolp pcahlu muljxkq cbkljmz zlbcmkj zvbmgz eaiv ncv zplifm yplo
+ocutdhz zmnaap llgv llzpl loavju guzkfq saay rxyhng cwxzx lcv anrnzs
+etyzx tcm upxrtvd imyoiu rdpj fed dmm
+gonqa szteh szteh razdqh phyff upf knfqfaf knfqfaf fpsgl kakag
+mcju mixskop isrwat lcr nfyi lcr aaevr nfyi pqrbk gnful
+xfmr fkmnq fbnhd mxrf litniid xbae frxm zcenf
+yuh lzojtj rqsh hyu
+vbjgql yeshsuv lokt efqota wpwjfu ykyq rxc fxxh ycqfkk gndts vdf
+wnylmr kkuruxm azr xukrkum dohkwx dmdb
+bjiyrwf dvf fdv vdf gnokekr
+jsaq hcww iayqtu llv gdpxdrd hwlo nosjit wpm lcab fcgwr
+fxjp bys nnf xzllckh bys hvojw zcwtgwz wye ccyvjv
+grafa hbb ghk wkdpsf ufa uoqmysd
+yvacf kssbff iovrm mvrio cfbpb avh zzje
+gqd qmsen wkvrfz vhtsa zrwfkv gul zkvwrf
+hrbi svaogb aogsvb bgrk hibr jbtkr
+ljl ryc mrewrge yky
+fcqyymt emk qcmyytf mcfvusb luy qany cbsvumf
+oknt mcozuc ccmuoz uoccmz
+uziil xobutwf acnof iqgwl diso
+sekq fxbtsuv ddnnqg rnemlt dngnqd hhgjfus stxvubf
+lajcp qgiw fyz blrlcd pviwv buh wnkk
+wolqfk nvpapfc rwcqxfz xobno yzjfz irpj wolqfk wbnwjt
+vmabj noiljne hhqf holxkbk swwzx ylgj lnmxy lqodhk abjvm bmsrf
+bpnp yrz pjepxxs jlmhuy vihlx zacm inuazhc xsxjepp
+tryl kryh eonvaad ucevssk umkxg lqej nswopjj svkeucs bmh stosxxz
+cfdwd dmfdrvm ibuhsz nwtgmb pjt dmfdrvm cqdcm fzjjz afa ibuhsz
+erwp abn jwx ynmkkj rhgg abn epd atqhs rst rhgg
+jtnp cegdsoy gfuvfbg gdmn ahlsc
+jgrp diu jrgp onjnml nojmnl vxockc
+lakqyuw khq dcpiwt ykwlqua hkq plklx ujbckec hjcvur jnp pvyf
+usuvoo jkih ylafyy yhio jureyj
+uazisdf cnwlfnf ewodatr woaddkd wbla qmn atdrowe
+bnyepaa ntqh xppe ydtsw ppex
+yewjwsp jxylmtk ijese ewry ijese kbja nfml zeuwcsh juimz
+qbvmf nca zsfreo uurgaiz twe fbqmv ncwi etdcsk atowfp
+jeotslx kgdpzp wxlcww pdd dcn ddp
+macllv ldl kyluine lbt hbxbr wxcaspp ezwvc qxkeu
+ivg gxv zsf ucr uff yrz
+tdlwbny bqlrlz tbynwdl lwtbdny
+tnekq pdaievs ttwpfh xfm fcaa
+zqqhl zbf fbz uqrv bfz ffwavhk foccg
+vcw ebqdd cwv eddbq nrmq
+hpiusz sizphu xzq sgyehk wgagkv hsygek
+vagkxa iou frqdnnr ipcg uxvh vvh eskf katgpiq aqktigp gzvseyi
+xkwgd kzfxk pgdy fmtvq ngf rshx zti pamviob ely knz
+hwo rteohu qzwoe rotuhe wzb
+bsqgg tid dti gtats dit
+sjtux djwxv dljwjq xwvjd xnqfvx veqdrtl uxtsj nnkjn wnhilaf unirrp
+fruuqjk gtote gooklg bzwhim zfnccmm ezipnf cxwdxa wfu fdca
+zcyxb byzxc cxbyz pgcqco ivlxz
+wrjh zfdinsf ihw xwosiah hdg xpiabno bilyy azdeczg javuwa
+rinlv dcpt qhencba mmb njxw gadc
+qwcpua qzyzt cxjsgh kumh byiimas qhsgf qytzz rqqruwp ismyiba xydcxz rwkscqa
+xbzefi hltca ibzxfe fkx xizbfe wvaynts
+oyuce vzk ouxvj gfh efgbv ubc nyb bxnbhd mtwboe whksy ovmrt
+ljrebp tacn bpjler utphw wmfw rcnha
+drdnic eyodes rcnidd yseeod
+umxmsf kfroz ukhjin awpnnnu ooyyohh tuv rafano jze
+bakz lfzpjyg gfkqcgn kzh zwpvk gqfngck
+jpaony ojpnya hmro xaaz tovary aaxz iel pbg
+swvbgc bbhjp yvrcddd rhj clfu eao afrkegn qvvb yvcx nxjmdo rcvtx
+conbjy jeqtri wvujt jeqtri rkhllgw tsdt zowreo qxr qbpragn kuzmplw wvujt
+jrpxyp hchljy rkowqb eeaf ltllebb gtksrwx iazx vnsfmc zzrxw hlcjyh
+piehb cjdzt eqn kuje rls oaewoz lrqwt lcrrq
+hdjowxv uknhlv hluknv pokxg
+txiqxfr fyyp pyyf xfxtrqi tvm rtvby cfx trx nwrf kqrxtat alwot
+wdaadr stexpow ardawd uejqxc
+wwgwjel wwgwjel mtjt wwgwjel
+mczx uua lgceb dqru vkcea tcet ruz
+jkt yroojr qdrtdu wze ovwz fdmqnr xxsyfd kchytwl hctlkwy gyd
+eif irnrce iamhxgh bmis uxye azrwdi sznv yuowb vdlqqxu
+dxdjyj hngqwzs yhwku qhsctfe rhbc rchb tqhcfse
+fxyxnzs qtxevin rvtxtc iqnxtve
+zgbpk mwzxx bgpkz wkpkn
+rjiym iub lcyw agbtlb bzhx osv rbtf
+emmyu uoflio tinih skpqaj rbor gezbhhv ine mij qlqte uuj ycns
+owmwc uhxv pyho ftjh jzsg blqn bszyo bob trbycy mkru
+mwgz bbqsmpp fgzs bihhg bbn pjxxexs qrqmt htsxfwo qltqp vqqaxi
+lpr wcvy sxjqq ltd rftdgv pdnog ymu
+qhcos shuy icdhucu lrikh rwslv yxbgibl rcomhn wakirz
+civdmee owlzocl vedecim rogmjnn pix pohcmk dsjm yworm
+vzdpxp lvt inufv yofqt omm qfoty qrlseqy amkt kjcvg vgkjc
+huhq quhh levzsws sjuun ofgqr cjhp nfxbbft rnt wtbd tbzab
+tjftkx xpfcv hvftvhw lpypbjg batrn fhwhtvv uthl arbtn brb sthv
+ogr uyuxdco bpjgir edztxv sxtgu jzfmx ihnauz zwegqkr kvkw
+mhxthf pervvn gshy jig ezjteq ckkcpy gww
+tiljyki rpe prcojy tjkylii moxu
+pjsdqc lgqydfd lohck emrtejw axwmo wuuv rfi qzyncmw gjijdfb bljfd xrs
+ywjab gynzi relf kziy xmsby izyk ocwoho kqnyh bwayj
+bhjlz uonz jhmzuq eiajoos zjnbj tomj bmyv hjlbz fgw jjbnz
+kszz xzw xzw prtznyb
+ghzk vxhwt thxwv slwpayp qxegmi dawdwo kgzh
+ibpcvuf wnuwxu sbf jsj bfjynl cdp jbylnf
+epaxr vfhf hvff azepadz pwf sbo pgfzya hslyo rqqj rmklw hwtta
+yyolko pwbvxvg xdwl yfje hftep kzzsr kho jeyf yvslxpw kfyv
+xmk juyjxy eqno mdwklum reg dgn cirh wmxfyj bnxlgo dlobk
+oyv gshqyot jgcqe dsf gyohqst gqgeojo egoogjq dmqpyp
+sypianq yss lmhu ulmh itilh ndkda lhiit
+qbxxl bxxql ikald nfap qixwbqq
+jtqhqty ljysnl nwoj toa bmmyj pal
+ahktew sxody nkvsf pbxyt baws wgwfwej bevgzm jus hcvajfy kzrb jwgwewf
+jzsb szbj ujngwf nfuuf lfiuxdu uufnf orsy
+vgo hto isstyul gau wsmxoqw
+uxw itwf epaw hec wape hemol rpwyosc xzxmrll eetz zui kagca
+mjncux muv rygdeis rygdeis
+qgkqjvf iprzibd fkvqqgj llcrl vbh vlf lllrc zwrunt
+dslsa wvoex eqbwj tjem gbx ayn xcan fnacl xggxon gnwjlh
+yzosv hcxjiz yvon gcgd
+bixpny ecln sda eymt bjiwk
+rlcad lrdca adoqfzs rgty mds pwb kmwj
+wkai pmryffq rrdmodc wgyx taz yxwg nkap
+auynzwc vzg uapdv qkrh
+ldmuysp oyu kpn ejbl mfifa bzs hwyn brlw qpzqx uyilao ysdumpl
+czoxoj pwnultl wezolbw lyk aonesgb
+nqy nhb nle yycp lgtbo ojf dytwyh ufa
+rwr eph obg peh pejret prjtee ovgz
+vdqf vdqf ycjrg ovzl lelbe vdqf
+gvagdqm gvdgqam dmb zaxe nepzwn
+emwh bkkbgec qwdgk mhvfsrf wmdfpp ekzuua
+mbqw lgkyazt ckyhvnq uladwo owt
+qwiwd pbo tkjoqda zapo dygqopv zzdlwfn
+qty dhb iinncba ytq kvh idgoevt chx waq
+ulffsvk vplsz ulffsvk uxsh cpwgxd ikgcacx nrirke uowcjvn
+gknmxr grkxnm fco dilyyj grmxkn
+saqxkh uhue nvu fef xsuxq ekyyoc bcaavd
+qltwqa vrmpv vhra nof yprauc vkreojm eaq igiy mec
+wvheiyg uthy gpvcs nhnjrne mqaejr tfnsly zfbhn entcc nystfl cpq
+zxv jzk dwsjgrd gqqxhp xqxu naunwc yeh qzpkz awcnnu aoosa icadax
+vpmqmg qmvpgm tqs mvpqmg
+inehzu zwxeoy jxia fcyzxc hwikd
+bzwnp kamsen ajpn kdls bzh xqcb bzwnp cmjnfa wmgx
+hbuhc qgvhxy smzkxh zzebox hbcuh net wyrdppc yvgxqh
+oeum oemu iyags xaipdi euom
+tqljgoq ghtdhw xhnni lux qltojqg lki zxztda pcqjif acpzvwy
+ydijaq kbyjxpu onyd hsfgz geqvbg
+rwoih xog dtbzyr ryzbdt tdbyzr
+vcdxf zosw pardxfz bmb mscmain lwfc jvq hbszcqh fxomsmm ahnugx
+zutsemg pqzil ddv nsstz gmeuzst bedvy xkzzjpw xlqbd
+xxf ltnnu yeb hbml agj meovtjr qrul kexerkw xxf
+tqrpd hhcx bmdv nlmr pnu pajdtc rpatqi yekedx oeiuew epsshog
+ttbfpv plairk toh jagfsg njnqpa tmwh vwqp irtxv
+vdky uwc tkkkztp vdky vdky qlcw lza
+rzie yundymy pwgx wtwtbg kpiw mewnb liveysj uvsbn
+jgfvyny hacg pzra arpz uowswu puzsfu hoe heo vrq naup
+hqv vrl uko qgpikho lligvxa wdld qgpikho
+whvby yomxwj dieffc jkprinh dsaqy yfrnba woyq yexeb mjn cbszn xeswvvo
+wowtgu rciyg rlas bra quyfec ihe thuu asxhscu bsbdpbi ogxosu
+vydsaet tvnkjq piedkzj foeiqz zqivt iatsju tjnqvk drauaf vqitz invoz
+cppn jqzw zmxr qksuas iifmjg xtkgf cppn cppn jpsd
+nkifpsq cxdx bokxhm ebww kghagrp bofhrl grc cheuzyj
+ibgrlvm hrcx jjuoh ipmt
+hcoqkh fzt rgravb cimauj jxjq blct qhc vjxw pqpg qzp
+jycxz xcv czxjy vxc
+liljaur cgmg neldxb xfummcq yfhiukd dnqhl iolxn cmewhb
+hpvoihj fkwokod txy uuktw vmqqb dpldzh yxmcay cyaxmy xycaym wekr
+ccnaf wuxc ecadb vbgpt ccntf sezo skjdkbf fnctc
+hqdtwho kdhyman bjtcjvr bwllva ncyffyr
+xprn jrrvmj pdw yvexm ewbflbe eapml rvrmjj xmevy rxyzhf
+wjcbpy qdgtcp cfjh muww fhg sgfdleo nelpte yucqa aavev
+rci vqypsqt xmg rzii
+gramh wwprtc ampdhw dajr
+ovrm mdyhpbl mdylbph aykz
+cbmo fxs nuugu guunu upt ljjuhjw nituh utp kxqc
+rhabal rhabal rhabal vah lfrs
+nrq qway ftzp rtjcks mbygdtd hsiqbh wypqb rtjcks cllp hsiqbh
+ywa anhcf nvd puqkwg molrwck wsctx xvd molrwck
+wox jzq jfen wcvus cswvu oxw irg lmu tpj viahm jesic
+qenad neqad smlgi ydwzq ppdemvs ucyuf qtunm eoqx jlgv
+sucpl nrdwbl ltvetok npbw ozzw hafyay sjmui sjmui jkqlq pyn pbuopx
+nxgaiu ybyl meo kgh saqjaz xhbqr otelcyp vkwc
+iqrl ldjlwvl ajhrl dnhutr gkknyqs mcvluet fgyu ogiz cxo aiunl orb
+psd cyq xpoyqny yqc kozqh vonfd uhozwz pds hcpw
+tvaxder tulwmw qiw avddbmh irog vynjzcc refx efxr emnvk
+myjx npqk whm egw kpy igrrohg ukglx ldnuqw caqg ynx fckhnsh
+dafv bkdoqg zcqvbco xgikoac cvbqczo
+rtzhpwk ukuyp bayhzp upkuy ahbpyz
+oarcuv pnlkxvw fqdkj hwzsz nauwl lpufibz vzfbgc unkluxy rwh xuknuyl
+vxhsaj ppdxw qrswqtu ulwv uqtqwsr ppxwd
+cww cww cww scu
+wiiikwa bfpewt zbgxfkl iqpk tpbwfe aazdcxj ipqk icggn fwn fjr
+net ovxuwpz yvzmzd yvzmzd
+xgar czuhp vuhisaq fgrqxy evvrtf mnmar lsk
+hld mxuedug itswju vmmejqx snzslqj toe bbmugph mgubhpb mowj nrjnzu
+qbz ouhye hsldmp lcf hyhlrb ewvle zko
+cke mupaq quapm eck
+owu zdt lales tzd apjjo fhpx bmuktbw dvehpz
+libvl zxypk azazc vtsom ohdzycb
+kiowxnc scxygrf ckxnwio ycxsrgf
+vcjj fqz lfawfx mps zhv qykch vhz psu zud spu fnpvkx
+scfvum fuktgk tua ieosetl wwmjtt exnsw wwmttj plvd pfb kku pdbom
+wkfw snukd wkfw gyaojdf bjw htagy cdsp
+beh gatqxcu ibrooxr ssww orrioxb eenkqz
+jlv affah mtbemf tylh aafhf
+zqfajd uwzrw csouuip qzadjf
+gsnlrw tcel hha tfbzrp ild aenqa
+iirfxef kdux yvj vbzgj
+ibx pfll rgkp nancij llpf xib gbkfy
+uvw kkbavj pznsnk okigtxl ogitxkl eobbs xhaz wroabn ltogxki
+bivdf lotvmoh vrb kpaeeue tdab qhukcb qmy kuqf kesu
+egs hbsfeu esg twxko uib
+ocraimu qilp ijmx eco nhevqp juxf ksejr bcqqau uhpt
+pyx jmpglf juokd dxszjw cml vcjge pfg
+gxwrt btmimse dkpbha idmz mtignka ngakmti
+dpjhm jyalra hukf imocr lkgt rqywn quhe fukh
+nbau xyc bdh yni xaawxm cyx xwaaxm akx gyodqe htbifc
+bywdxe bfrp rvb rndl onal jghiwb nuta aint qlciwcx
+fpic yrqce land soxhci qzc zoebsq hcdohcc fzhcl iyxb dqinum hchdcoc
+zok ghgp zok lmk
+ozfz zofz dkdekzb sqc
+gfti zuqvg cexmtyl qwuqnj stepb erduqhy cuoizcs qudyreh kqvfdd guzqv
+jrugz jzugr lmqu jgihgo hjfbz duxkn unxkd
+ckiys dbqmi ckiys ckiys
+iylp uvvdp pluifaa djo
+esxec rwvel djxppqf jymwt ilm aiz upn aiz wrfefwi rwvel
+nitgjr pokxuy puhdwg qtxpb veylp zqvzkbd lrvpcgu zuy rnigjt ibci
+jboyzq ogcldr hlon ywav jqqtz qjzqt vyaw cok
+aqdw jxn hqknh azbylg
+jya qpxtmsj hqrtsgg qjtpxsm
+pofcs sxw dlvru dlvur swx
+yphvvb qqyyfsp sjkbff dqyerxe jxzes oof
+pwbya txk bbwsj ywgimd kmdpc bawpy lbnt
+bkbazff ldmaq tyfl acqurpy ndnrp
+asw ctiv mnxzyc weeuwb gsn bzk irbyhxl cgqomj izy zbk
+yrxcrbt bcrryxt pofe wwzl
+vuaqez kbtuyai vuaqez dxqud uvo gmhtg dxqud
+tpzs gqdxpxo zzpgta uurjx xpqxodg
+cil lsv vznqw vro zqzvjhm jhgauzw uxnwk lci zpgpu frjvyzo tsv
+zfvcuim gwn gnw dxfppok
+btb goof iwadca aac tbb jha uvzi
+qah ned ipmure kyta ffhrwe njz paq kaag xmlui
+rkmw vrblwyy gpax hxsf zpbza gypuwf jbib ypcjwd vrlybyw
+yfjljn uxpvg huik jsnah nkhsg yfjljn lqzsz
+hagjlqx agnax jqalxgh rvjgtc mjrmph azznzcq gxajlqh
+ipki bhoabp rmiyl dmjyxl zzsmap aju
+tyjrr rigrf ciq qic avmwu jtr wpq
+vuf cosgytm toycgms ufv qzpcbrs
+epzgxr lydrsj ezxrpg expzgr
+ecm prj kmak makk jpr
+ccwyq txy okj matxa socoa
+zrjphq gigayv ywkfmru yrwukmf fxjjrha gqkxx zhjy tisutx kufrywm izjfj igg
+lfhgsro gsroflh wrpo lofhgsr
+kgkgj wkhnab ubrjaoa ubrjaoa ubrjaoa ggdgh
+hztutpn epnqmz ffcroq mnqpez niibpn kdloak xjui ozttj lyzsc pzgq inpnib
+kruz sjqp mmd hhdxjgc mauouma asevvo upjwqi hxcgjhd etqzagp
+zylf qime cho oraid svytv gqrjufv mker cho vnkyiin tjms
+dotjul qyv hnh cibtg gdpauyx wzp
+fabtira ejxoeor cqyethv ndjrq hnxn joq otng lrr csytrub
+txhgepd fwdaanm nawdamf pxine qqrn pronw exnip qwkimt rvy
+kuxzhi jln urzxtw rzu ebsuylm tscru qwlhfgq nnu nuchvz vuht
+cqgu camlr umkltcf stx izp rtdwxff wkfvs
+jhje cxix lefcrsu nebv idfzhic xqri xkft
+utzxb znb ietupd uqgbhje aobip oawjwm hetyan uqtqv hpwzyri kwxyu
+jvzvbt xuyvp aegdkb srbw bzabpf lyfriez cruyfu
+nhi nih aeb ihn
+hcf zypt djcm pkjx pvhh
+rhvxcfk exydvk ids hybme hnk yfchvs mjbo meocn
+rpboxr rxoprb hdzje zhedj
+ziildbo apzvatr vsv isndq ebxyy ntm tdttg wkvdh qnids vkdhw xxolip
+ywu uyw ipcjz pjzci xjn kvgk vsocprw
+euzo njlpv ndrlhi drlnhi ivmjkb fjrtxta skvgmrd
+gbyvj dkck gevpfvb lhadhx rgjcdn yraxh bdk oen vqryd bkr
+vgkp hncttxb wgxh gdyjo bbdfzvc xhgw rznzgda yxrrlo gxhw
+ifjlb fpecyic svhjp ilmj oxgr svhaf
+vbqky lhccj xtmm xzjyykn oqmdq qywir bswly
+euxxziv totzer vsxfx leo djho uoeaz edaig fbu lumbi
+ooqtwq pvo kid vpo jxin bod btqc fbyuz
+jhabi mronu htqqyz umjcbv sgnbp wyn cetmt pcjf
+tnrkcyl dduuhxh rylkctn pwj rtynkcl mzzfomr
+rxx ldqffi ulappk nltawbn tplhb kyb cqyi
+vzkw gviooah vxh xeae ohvcad oaiwcj dkx
+sdofdjt hcifv dqws sia mlwm vfich kavh myzue roops mzuye
+uxs nlbmjp nlbmjp tlaxa tlaxa
+ynnisp twx xtw jgkc yinpns
+kumorsm wav xhx bpvz clqc ffmadzl ndny ymslo lobv
+ljzabj tqhves mezh pwn wue dwfqq lynvtt boeknvi xqbd pkud tzlanis
+lgq qiikzl oihnsr pivtjmu qhic yvmeebg rxu qgl yuxnqse dvu faxqez
+ldk mlwja vmdqr yzlxiua amlubt ejmzfx nonm zhkxbn gaqbnqq
+ttc ctt kneknx smtnaft abljip tct
+uybhbiw zwojzlm cfxoopp abulenj znz zzn opllzmm yufk witwxzp
+qvkybwi rdbxb qiuizmo fqgne jgot jxz dqhapn
+vzinf ehaley amnk laheye invfz
+pedakl ivld agzyhr wmzba tzzzg bazwm wjwgux thrnxkn
+cmyhae nwfs nfsw kmh pxkaffq
+vdf szupev tyunp qiiu deevxmy wozvtt nelnr kgdexy gparqj hajavz biizn
+pwspk skpwp ontbjee pkspw cfbj
+ihsmh djxtak wkzllao oyr djxtak prc
+uhvihqq jrgf hdfek pdrfpt tghz gthz awae wcygi wujti svq fhedk
+gnfhsj odqlt netmsul rviio nkzw nkzw
+xyvc clxw cyxv lxcw
+duegck pkviu npwsp zdx wpvn dmxgnv ixv fybs xteru
+vih kgk hads boaddu daiwo hozoufv nef vtcplc isiw
+tzqoo dqlgvno jzlay sywx ecej addt ecej addt mnfcu
+ymgmby zegudpx ipsjai ger wcwjw brzebb
+eqekxlx itra xekelxq exqkexl
+rciu ojaa ircu nxjga puvmwou remgu
+sltth pprimb slnxopq avtir hvpv ppww fhfap wisn kzs jcuuuuf
+xbppc ydpbq zhjh oym iljzvk vsb
+ueye shtps uccehi ccheiu dqm yeeu
+gwywf lcpv qza qza gzuovj jfzffyh oybfxqv
+aawi ynsvdco azdoz cqr tnyquq xlyvbx eca kcalpes
+zumgzhy rou kguqa vubw bwgd qprxcg etnbev nqmi
+fyd tuoz uwclqn cgl lrpkf irz dizv nxze clg jghx jbpt
+kwuanos eorjr tcahp kwuanos cyrpfji zxayggd kwuanos jkqt qqvbork lizk
+vtu ovje vhg ovje vtu zcy hrhtr puawfgv
+bliz exp wot svxv epx
+jiqgxwj yips hjsatc jgsrno msfp vxvbt bba bqmw xjgpgog
+vpvypp ggwp wggp gndp hedpse afji hcqgof
+hxueubt hiynoa qqzaj ohb qway
+akq nfnes sdrlza nfnes weq
+udxpdpx gctuv llhxuow rqtetm hdbnpte oebapv civy oeobu ftgivd pykj
+pbgbvn jgmr xrz dfn gosjobw ndf
+gnf dtbsnc fwcmml tscdnb fgn qgadusl eifpk
+vmnv yuxrup qcphi tanc tnca kjrv cphqi
+hclggs sghglc fgplp odn pfglp emkrulf whwtmbs qnuyg
+wcxtr ani ain sha hsa zxbkf bzxokat qezo ljqxi xqcwfmd dxo
+waiq smpbu dbyka uibxjrg nze wiqa rfpts ddjsjv jqqjez bpusm
+lpcxf vsbj owjwc tuqj vkrgrh jsjdepv oil lxrjox frsxsi clr
+vzunp prwk nnd rfs vpuzn
+pqpqv lvsk sqxf nhobsm hakbn ywj
+xxu uxx szqnmi lnwtmx
+akq nmlw fupwsth jduvhva
+nac wwlxqck hpbce vxxqa fyp xvxqa kxwclqw yvlmv bfwi
+pzxjbj nvwv mdooiez vvftp enjrsck iypu uhru fpx omtd
+llxgp qwf pwaj cuhb scloot hbcu jgp vjw ooclst
+sisd akawvzd wvdzkaa gyoij ikt eeeosb jiwiup
+tche vxj sbctqv jvx gosur usgor ibo yqxo qqgd zspl
+cidd welisl fxblxqk qxbklfx fbdoqcz glhq iylodvz zvds ghlq
+cnsa hrxst mrnkqtj bptq jmi cpbcofs kveyeur uzmga modphm rtx kntqjrm
+dvyup usfaq rtghoec bvcos fqsua zohwwg
+onf vncybi dlaxni oqyqqkn
+okfwa qyyx ebnv llql nphq etdt ytgivlo jwgwz kiob
+ann vqnqvpx wth lpwid bjvzw xpwqxcj azg ioeyzzp onwf
+smy epzomx xep yid zctvrfj astdj cfg fgc eriuxt
+rljqgin wzobzrh cuwtx vcsbx tmg tuysq vxipgho
+ewp rsrnsj wgeyin lrji ddgt utol xxwut fjiwopa
+upu ftvqbk tfkvbq fdwga rmu puu hbiasjw
+cfl lmqkb lfc wbtlfi uqsjs ejgmphi tbliwf nzcela gzb
+zop unwmiu acull mkwh hvruknw rfk mmhaz iqmenq fifino
+iczua bjut tlgf zicau jtbu
+mtka ipd mdifj kps
+irqkysw xfsjl tedx yckkbx iktxb sqxn pbfvubv uudzppz
+mdrn cihat wcext kufs awwtjok pfjg
+wdevt tyo zzbp pqlqq wdevt
+yhatqkv ntuhw tdfd buxazh xbcsv bas gkv rbzi tddf jbj bsa
+malip hiiy qezz yhii wlfojre
+zqnfll bssveq lprwbep bhqml tztbt
+npnxotu yupdytb jptqo klfydfe fpucmfq svxcqr unopxnt
+gdpz gwj iytiohu efk ctjzf asade abhotq brmhu tbtdur zzksbh
+kxft klzslf tjdzciy lzslkf
+ejei ezmemvg xlt zte tbwhz dgnfpao zotck wus uaz gbwbb
+dgednf vypmbs eiytot empfmny
+uopmui uehue wdvzt adpfcif mutl ifaztka vydi xumtz orstno
+dleero olxiq gxnlfm nfmxlg wloeavr olhrwg hrjd yicj ymyeex qav gxyjgfq
+hevj rqcne zycgb qgqtn rqcne ptfvu yyyu zlm hevj
+zrkhuh sttnkt hkuzhr vqtu
+ppsfm kcao qjq dgadglx cxaawjn pbucfu fed qgioarc dfe ricoaqg
+vmawf oktunea zraoir gkt zraoir jcvkqoq
+mqgml ecawug ugwace szwul iwbmooj owmiojb
+auggaw cypcuw npci vuyxijd pofswjx vdkrgx xylk rom ksj
+qmwx jgsrdj ikva xzxw avik
+zzhcqu rbg pywjdn wyndpj zchuqz
+wzd wqycftu yldezp zovuy oydia hovewe
+kfid qkkk thak qhbf rvzlzvu uuxh pbj hkat gow oeqcw knqqzha
+sua itv hfpg bdqye bznlrk hfpg bdqye kvir kaai ggtz jqn
+ulggl guitamm tkpckso fupacz otxtqpd jxnqc
+ueesb ndyik vjftz jgqqv nrcf
+krh dqpmsw fybzynl zhjbvkw exefc rhs neq ldprb bhhvxm pjwirun
+ymavl qwxr yavml wagwc ekokrpq zewppw iumcgin cxdvwx
+wwdukav kuawvwd kowv dkwvuwa
+eazot bil tzu vdwwbm fvauwrq
+esq tixokph yspf ztoxfut lgzush pwv swh pwv auqhuu tixokph
+pdbeyxi poio mugfkb brwbbx aao uszw fokjeb uswz
+sbs ryjr ptispi tvnhu htunv vthnu
+czjmg hbdjhvi jrkoy fpgwc syafy aar kvnq eaecsb wqzpx
+twtp dvl uvyje qtlzj dsvyr qpjnj eyoigx bhgpccy gwn dtuf
+mxit xunctu vbyks wmqc jriuupl ybvks uncutx nsoxwrb ykt prc
+yye mgf uhc irowpc dsdv iwaxod ftavlj dxzp tcch tcch mefz
+rxe xwrrgl xwrrgl duu rxe xbbgoe
+ucsz akswcd ojrmqq cox hgfh lxwu ltnnf cenikcp
+opjhdp svwezr svwezr opjhdp
+qojlkl ircxqnt utfmdg fcvr vehkcvt ufmzcpv xwlh ddavv xel bwlz fii
+rzkayeh iursm zhily hdnq fqydfvt uwoy hptpiqu tdqy bgr xdr
+ymruz umzry hbltwya jhwhzk flh tahylbw bdbaimb qscbp ntkuf
+uxpato owsqyao vaog oenomkc usrmnc epua vzkppls
+qxqczbk qyguz alawj xgjawtw wxtjgwa snfcdmz
+fjfgos rmpd mgs vbk dlls jkljao eoovdfb ucdvaoq qmjmqku ney porr
+nmcrqz zcoxpk dlnzksd ymh zyg spxss ruyk bychq gsgv eusiuid mnrqcz
+jbzadnx lzl sdamer okoico frqisrm lxet agriw
+xceoqr qai vahc jjzifsn exg
+igjpn wfy ukn aag quro wklsq cjq bgtjrdz gmub wyhh
+fzlwnm mygfn vkzwvw zvhsex gfki
+ijvzgai ebmeq wssfmbq uguh sfuutm nwkgmex dxael liakdxs rnf sky yowpxc
+bjzkyjh fced nji esowk qxsubsk qgtts
+nkdgo bbjfq fgnxnhd gfjchl jetdb xubsgj eiju ldlm oxsx znft bbqfj
+xovcnob pxfe pmstes yzkdm iqlvha nmcziix fexp ivqalh rxecqps
+xpyew xudfud wwqe qhfjlcu epv fnrbgyv ihli qngtx yjlfg ozqbzn esp
+timl gcohx vqzic gzm shwlkkv icqzv urchuc
+xpqq gaqzwo cci dowahsr gaqzwo
+jjsagdl umbpxre kyre zvaryft tmw pxpnjy
+aqovcz nunq nnuq xjrvvh autjmit jiatumt
+elg lps lge zjjot hwz tmqrup xaxxmo zlbzp uftd fukdad kvpymsm
+iokwzal ywti zbdmzbu lprywe wbgbwza ypogbga kzliwao wstqi eqm keaeaj gbabwwz
+lwfpk mhufe eddzgd ljxyqy vhzkct uemhf
+lwqil fzugdo faq feppo usl llwqi
+nje hthr ropq qvcepu bexszfj avmzjvv zajmvvv fhcd xnc cnx qnuaux
+kvksn dphbyz nsx wrcc ccrw
+nzpa pzzunfv ygzjy gxrrtcj hrt trh pwxpg yifgjmo fnupzzv wbzx
+aepti rbojui ypvhe ubojri tcema aan dntkw qjx bfvmyos tcm hvoqytn
+qpwq exu jvsiwj gsw avr vbemldy
+xsbzpf xbzyvx xax sxh vpxt gccy xxa zhgbwoa hwwxoky fhvdxfc pvtx
+pnsa ovtjolz tyutl eyjjzt jvtoolz owbypvr tytlu ewtzgec
+cyg dwwk eihsp aeuk bbnay aluwyz hdmv uaek mwt ihpse wjhnkeg
+fhzx vjetz vjub tejvz
+ewwyb jidhu pyvyenn igtnyd tiwr akwkkbi myz xxjwb jjrdeg
+jbkuw kwir rkiw ubwkj
+bltffuw lftwufb hhsh wfbtulf nrxaa rlszi toijxnz czlci
+bqrm pga zgblgcw pgwhhn lcgzwbg bcgzlgw yqb
+mhjj vjoa gnjlc kclcr ito ofksy giavy fpqeioj
+bkiqmif izidbui sttxxi bswhkxp sduuw
+mjgnvw mjgwnv ojzyuv gvj
+qxn kkhc whd fgwk auzugg augzgu kqfov wfgk
+spdxbnu xpfofsb bpfsoxf ahjywql spbxoff
+bwqxhlm wbqlxmh kqgpl fyzgf guhkvgx ovk qhmp gnrmu wvd wedj
+vvwf hcnc vvwsngj qedzoxm hcnc qedzoxm kjthdi cbwqep qtvu
+gio iqklmro noqablo bab jiqc rwebyg rqkloim wzmgs uunl amqs iwj
+snxj szobqt zcgvwv wiyqknu
+uto jteikwd cew gqsks hmvjtcy sach
+zpgl qnkoex amhufmr figns upv xezrl rjleak nwrna
+pzkvrdz dtonazj gtr gfxucuf lstjl lsjtl rgkope kzpdzrv lyptn zfxjys ttk
+ddxgm lumlgki jhv doft kok swy ckds swy ddxgm lbfbdv
+qfs rcufzgz iaiqw qfs qfs
+nvkbo sgv mquwb ritpye nbkov poex hraorm qrrr qdt qefl
+irxannd fiud ehyb ggx plqg pvvn uuptop tcvbm abuf bcfnmw
+qwya ukblz epmbfr vmlon yqwa
+hlo mmv vmm mvm
+svzpxun yugbbe sbbpxs dmy xspbbs zhpovyf fyovhzp cpbt pke
+zgk gft zybs zrgcoo ypu bue htgo
+xnesq srsx pkzaoh cfqzugh
+lntd nvxetbv clykjpd svmibpx evxtvnb yldkpjc
+jsqq tzwak hephg eqwczd ioisa yim tmdifn mceip
+kuwqz wzkqu zwchmj lfec uexne iztp llityt
+kvamkpc pvbryqh ion cwizjde gln kcpvmak pzzlw gnl
+ydeqf bfaab sydqhbp smsxdjr pynrs cqymt
+onb eiab bno nob
+mqslq scnelxv hyllrf scnelxv mqslq wmnbk
+pttu kubby lgop bbyuk gsk skg ikktlbb inbyvz
+xznvl zwtdj vbxdyd clhw
+hgy zudelp ickc drfjgn iyws xhc
+zzv wik iorhat qkb kjb lykdz vrce yjsjwj
+gyw xzgbi efus uuy
+hwcy ujdun bjjuvd jbdvju onnk xeyy mmp onkn qyzl
+jwfm ptjwrbl hhuv uolz adyweh qpj wxyogp igvnojq jmfw pqs fsnirby

internal/data/2025/DayEleven/input.txt

@@ -0,0 +1,599 @@
+vwm: xoe ydz tbn
+erq: qws zsm fmb rya
+wzf: mxt arh gjd
+qee: you wjk
+zhy: tyc
+pgy: out
+rkn: ads ybl hvw uzv
+aoz: cyk qhr scn jex pcv
+dot: kxu
+nbx: ffq ahp owr vvs
+dka: ksc bcv
+yej: nbx hpk fqp uub
+glt: lin jrw
+hbq: wjk you
+nja: mqk dmr
+nct: you eax
+mqk: cyw djr
+lfw: svi
+iyq: xdw rvx bcv
+wcr: iwz
+pkc: ron pst wte qug qee
+ehv: gst ibw knv
+uzv: abn nfd
+tiv: szt
+iii: mbl asl
+eok: eax you wjk
+fvh: mnp
+lyj: tsv dtv xrg jck
+qza: bor uzm kpa rgp
+xxj: jec
+gqm: out
+svr: brh elo yfy
+vxe: nzf
+pne: mup kma
+kkq: nzf
+szl: fdh
+pnn: yyo tyc dpx djd pfr
+vir: hak yog syp
+uvb: nlp mci
+hpa: uwd mlo
+tby: vwm zet
+qoe: out
+gio: own ohd
+wke: fqn nlp lmh dmf
+xaf: hug
+par: ipt uiu
+bjl: oic bkp
+rsv: luf
+klr: oax
+qwi: kxu tfq
+eld: you
+cyy: out
+xuj: mbl pne
+xnr: nja ycv zex dyg
+tuv: kpa bor uzm
+ohn: fgu
+trc: you eax
+qug: you eax
+ngl: out
+ybl: xeq
+djd: lyw tuv sxv
+ylt: mup kma dbb
+drm: pvr ust
+fgu: kxk cyw xax
+wsm: ron
+img: gao uwd
+xtb: wee
+cja: mlo
+hpk: ffq vvs
+xnb: gcc hbq
+qrj: luf fgn
+pbr: unh
+hak: zrf
+xax: zgj qpb ieb wki mpe yej
+ysz: jck dtv tsv sjw
+akt: jck dtv xrg
+qbe: mlo
+stb: ezs gju
+scn: mqs
+elr: out
+ksc: wcr
+mup: teo lwr wrw sah ozk yoc tby uwx xaf gis hyk bue rag lsq oci cfq uyd xft
+qqn: hfh mbf ptu
+vdm: bkp
+msc: lrh dpf xxq
+mxe: eax
+yyp: urh
+ryi: msc jec wlw
+zsm: scz wzm
+mjf: bff dsk
+nzx: you eax
+mbg: qxf wvx
+faw: zkd aiq
+you: ntn iyq slr aoi uzc cpc dka avk top jqq qrj fth edy
+dff: lau
+bcv: iiy nkk pbr
+emo: ohn cwd
+sxv: bor kpa rgp
+vzw: djr xax ert kxk
+fdh: xka lpc ygz
+muh: mbg mib
+mci: klt
+ojr: mup kma dbb
+zuo: msc
+woh: zew qgi
+nuk: fft
+vco: dyg ycv zex
+foq: wip kxu
+lqr: hqx jzq gfl hda
+aue: xaz lzf nzc fgu
+nzj: lin dwd
+bag: out
+xhc: xax djr cyw ert kxk
+nbs: lbi kgc
+qvd: cgy
+bin: cro ehv rbc
+fmb: ibn prl scz
+wcs: mnw xjx
+ouk: zuo xxj ieo
+hns: ksi ybl hvw uzv
+xnf: bsq pgy
+sib: pkc udo ebh wsm
+cqw: xnf
+tkm: uct xop
+pxt: fbq hrs
+ilf: xpg pgl
+uvm: rsi
+wgo: svi nvq idw
+cdp: gik hkk
+pfr: qza tuv
+azo: uzz
+rag: gsu grf hoj nuk
+pst: wjk eax you
+sjw: mnh
+puc: obs
+qjd: lab lau
+epu: kxk xax djr
+ovz: pxu bkt uvm ehs
+haz: eax
+nzc: kxk ert djr xax cyw
+dyd: nzf
+sah: nzj wxm glt leu
+pxu: vpa
+uiu: uwd mlo
+rqu: egm mfs tpu
+gxe: mbl pne asl
+yoc: por hug faj
+zew: out
+nlf: xyl
+mnp: zex ycv nja fmz
+uza: asl pne
+xkt: uiu usi ipt
+top: muh
+pdp: mlo gao
+foc: cyw kxk
+mnh: vii fbq hrs
+cwd: nzc
+ffq: wij nzf
+kkp: out
+dzt: fbq
+rsi: qjd
+rln: icq pje gqm qoe
+hqx: out
+snd: vco fcm isz
+umv: xaz lzf nzc fgu
+zty: syp
+pdd: qge uun
+roc: ivr wij
+cum: msc
+qge: kkp bag
+ptu: onp qwi tuz
+bny: bmk szl axt
+wlw: xxq lrh tct
+ykl: own
+hkk: etk gom
+svi: mib bgu yvd ufv
+shp: aiq trg bwr
+cyk: sbj
+hoj: nlk
+fcm: dyg zex ycv nja
+coz: mha qgi zew
+lab: kvl
+oto: mup
+wip: ylt ywu yzl
+lin: cja img dsl
+lsi: fxm loi
+jhg: ane usi
+xpg: mup dbb
+eeb: rzj dsk bff ngg
+jfh: bsq fyd
+ezf: onh snd
+ycv: mqk qpx dmr epu
+ntn: uvm ehs
+ane: mlo gao
+zbi: wij
+lou: you eax
+vgz: trc eld ntb eok
+fgn: uzz izu
+pxp: bjl iwz unh
+bsf: zwd vor ucw nff
+cro: aoz ibw
+bmx: eok eld
+zzu: mfs tpu
+ozk: gsu geo grf nuk
+ibn: hgy
+zna: pri uct
+tuz: wip
+eax: puc lfw gsq joi hbv rsv uzc jqq dep ovz
+tpu: iyk pli
+dyg: epu mqk qpx dmr
+piu: cum zuo xxj ieo ryi
+paz: ivr wij nzf
+yfy: dgz qqn smq hog hkz equ hns stb usx klr prz rkn zzu ltq ivl lsi fem nas
+nlp: ecu tiv
+sxp: uiu ipt usi
+uzc: idw nvq
+pgl: dbb
+dpk: wij
+iod: esi iac bsf
+lpc: mpt ddi qif
+xyl: emo tur
+hme: mha xnp
+iwz: oic
+spf: ygh bmk
+kru: sbx obs
+taf: szl ygh axt
+cpc: bkt uvm ehs pcw
+pje: out
+jzq: out
+lfr: uwd
+alp: nbs
+acu: lpc ygz
+prz: loi
+wee: suc kkq
+faj: pdp hpa lfr
+bkp: uih gfl
+evo: fqn dmf nlp
+lsb: cgk fmb rya
+psl: drm
+nff: wij
+zex: mqk
+jqq: rya cgk
+mha: out
+xrg: pxt irw fpk mnh
+hrs: xhc auk
+xch: aiq bwr fjm
+zrf: kxk ert djr xax
+lau: elr cyy hdl
+vsh: eax you
+fqp: ahp owr
+bmk: acu
+bkt: rsi
+uub: dpk owr
+dsf: wjk eax
+xoe: gao uwd
+dmr: djr kxk ert
+tct: vsh jnw dxe xwt
+wot: xax
+lyw: kpa bor
+uih: out
+kpf: gao
+wzm: cqw
+ezs: pzz ojr
+hhv: snd fvh tmy
+zgj: djd pfr yyo
+ehs: vcu
+hug: qcy
+hvw: abn
+leu: lin jrw dwd
+izu: fhs nbs pdd
+dpf: dxe jnw vsh nzx
+fhs: kgc lbi uun qge
+auk: cyw djr xax ert
+mlo: evo pap ysz dhz lbl wts tga zty ezf wke oag hhv hwv uvb
+oci: vwm
+bor: mym
+rpi: dsk rzj
+uwx: wxm gjy glt
+wql: bwr fjm aiq zkd
+ngg: dac omm
+vnt: pvr mxe
+gst: jex scn cyk
+tps: wte
+qpz: snd khk onh fvh tmy
+wte: eax you
+wtr: kma
+pcv: rtj foc kku mqs
+mfs: xmy pli iyk
+vqq: eax you wjk
+yqx: rln
+ivl: egm
+yza: zkd aiq fjm bwr
+xjx: gqm icq
+yzl: mup kma
+gll: qwi
+tbn: uwd
+nas: ksi uzv
+cwk: you wjk
+ntb: wjk
+dep: cdp sbx
+own: ntb eld trc
+gju: pzz gdo ojr
+edo: msw pgy bsq fyd
+kgc: bag ngl
+fft: kpf mxt jrf gjd
+gcc: wjk
+jex: mqs kku rtj sbj
+uct: kwe
+imz: ivr nzf wij
+qws: wzm ibn scz
+mxt: mlo uwd
+gsu: wzf
+hfh: tuz foq
+pap: mge cro ffk ehv
+hyk: geo
+ubs: dyd nff zwd vor
+icq: out
+tfq: ylt
+owr: ivr wij
+gjy: jrw
+slr: fmb qws zsm cgk
+nzf: rpi yza wql isk shp piu xsp zna sib tkm oeb bik ykl ouk mjf eeb xch faw gio wxd suw
+pcw: mrd vcu vpa rsi
+hwv: vvn urh
+xdw: pxp
+hda: out
+iaf: ert kxk xax djr
+tga: vvn xyl urh
+svp: gao
+dhz: ffk ehv cro
+mge: aoz knv
+lrh: xwt nzx
+yog: iaf zrf
+gsq: cdp obs sbx
+pli: yrt
+hvv: pvr ust
+xsp: pri xop psl
+klt: vzw
+xaz: cyw
+abn: qdv xpg pgl
+vvs: ivr nzf
+xop: kwe vnt hvv
+jrw: img dsl
+ian: bmk ygh szl
+fbq: wot
+trg: kuj kas
+mnw: icq lxi pje qoe
+gao: nlf tga wts lbl ysz vir qpz dhz lyj evo pap bin uvb hwv oag hhv ezf wke yyp zty
+wki: szl bmk ygh
+qgi: out
+bwr: kuj
+suw: tps pkc udo
+ddi: nzf
+cgy: suc cxi
+vpa: gvm dff
+uzm: imz mym paz
+khk: vco xnr mnp isz fcm
+avk: cdp sbx
+ygh: fdh jhf acu
+hkz: fxm loi oax
+usq: kma mup
+ksi: nfd xeq abn
+lbi: ngl kkp
+zet: zlg xoe
+cxx: mha
+rtj: xax djr
+smq: gju ezs
+wrw: geo gsu nuk
+odt: dbb mup
+ltq: gll mbf
+obs: hkk bry
+onh: vco fcm mnp isz
+ffk: gst aoz
+ucw: nzf
+scz: uqx
+iac: nff dyd vor zwd
+cfq: glt leu nzj wxm
+cpq: wjk
+qdv: kma dbb
+psy: jsl elr kvl cyy
+mib: phe
+jec: lrh xxq
+equ: mbf
+vcu: qjd dff
+aiq: kas kuj
+fxm: bkg gxe xuj uza
+xnp: out
+bff: dac omm
+fth: ksc rvx
+kuj: cpq
+uzz: nbs fhs
+kas: pxi vqq lou cpq
+cbs: fgu
+bsq: out
+qif: nzf wij ivr
+wts: hak
+dac: jbl ahy xnb
+usi: uwd
+mqs: ert xax djr
+szt: cyw djr kxk ert
+esi: dyd nff
+rbc: gst
+dgz: fxm loi
+pvr: eax wjk
+tyc: qza tuv
+knv: pcv jex qhr
+isz: zex ycv fmz nja
+lwr: uqr faj ngb por
+iyk: neg hdv
+kku: ert kxk cyw xax djr
+heo: uub hpk
+dxe: wjk you
+cyw: zhy xcd pqt vlm taf
+gom: rln xjx
+uwd: wke ezf yyp akt hwv bin uvb oag qpz lyj ysz pap evo tga wts lbl
+wbz: xnp qgi zew
+lmh: tiv
+dmf: tiv ecu
+vii: wot xhc auk
+ieb: cgy wee xkm mhu
+msw: out
+nlk: kpf arh jrf gjd
+qgm: lqr bkp
+tvt: ert kxk cyw djr xax
+tur: ohn cbs cwd umv aue
+pri: hvv
+uqx: edo
+fem: tpu
+dcb: ffq vvs dpk owr
+elo: prz stb fem nas equ rkn
+dhc: nkk
+jck: irw fpk dzt
+ngb: hpa
+luf: alp izu
+zlg: gao
+jbl: hbq haz
+ahy: dsf cwk gcc hbq
+oax: uza gxe
+joi: dhc
+jhf: lpc xka
+ywu: dbb
+qcy: uwd
+gvm: psy
+ufv: phe fgq wvx
+xwt: wjk eax you
+mhu: cxi kkq suc
+irw: fbq
+nfd: qdv
+yrt: luo odt
+tmy: vco xnr isz fcm
+etk: rln xjx
+pqt: bsf ubs esi
+idw: mib bgu mbg ufv yvd
+vvn: tur emo
+asl: mup kma dbb
+wjk: kru cpc dep top aoi iyq lfw lsb wgo erq dha hbv fth
+aoi: xdw dhc ksc
+xqs: aue umv
+chh: xnb jbl cph
+njc: ubs esi iac bsf
+wxm: dwd
+ert: vlm hyb bso iod njc qpb pqt xtb zgj taf qvd pnn spf mpe heo zhy
+rzj: omm
+djr: qvd pnn xcd heo zhy vlm hyb iod bny bso njc ieb qpb yej xtb eqf zgj
+suc: ivr nzf wij
+vor: nzf
+ieo: wlw
+mpt: nzf wij
+hdv: usq luo oto
+ibw: pcv
+sbx: bry gik hkk
+jnw: eax
+oeb: bmx ohd
+fjm: nbn kas
+hgy: xnf jfh edo
+isk: ohd own vgz fbn
+fpk: vii fbq
+yyo: lyw
+bik: ryi zuo xxj
+pxi: wjk you
+cxi: wij
+oag: tmy fvh onh khk
+dsl: uwd gao mlo
+teo: vwm ejh
+ipt: mlo gao
+yvd: wvx fgq
+grf: nlk wzf fft
+rvx: iiy wcr pbr
+prl: hgy uqx
+gfl: out
+ibu: gdo ojr pzz
+now: vxe suc cxi
+fgq: hme woh cxx coz
+syp: jxo
+ahp: nzf ivr
+xmy: hdv yrt neg
+ydz: mlo
+ygz: ddi roc qif ilb
+xcd: mhu xkm wee now cgy
+nbn: vqq pxi nct
+oic: gfl uih jzq hqx
+gjd: gao uwd
+xxq: jnw vsh
+qpb: hpk uub dcb
+hdl: out
+kwe: ust mxe
+fyd: out
+phe: coz
+onp: tfq wip kxu
+bso: dcb uub nbx hpk fqp
+uyd: par sxp jhg
+ilb: nzf
+dtv: irw mnh fpk
+nvq: ufv
+fqn: klt ecu tiv
+bkg: asl pne
+gik: gom yqx etk
+hyb: bsf iac
+usx: hfh gll
+luo: dbb mup
+qxf: wbz cxx coz hme woh
+qhr: sbj mqs foc
+kma: yoc teo lwr oci uyd xft lsq gis rag bue hyk uwx tby
+kxk: pqt mpe xtb eqf zgj zhy taf hyb iod bny njc ian
+geo: wzf
+lzf: ert xax djr
+cph: gcc dsf cwk
+brh: stb usx klr lsi ltq ivl rqu qqn dgz equ smq hog
+tcu: gsu grf
+xeq: pgl xpg
+lsq: faj hug uqr por
+rya: wzm
+zkd: kas
+fmz: epu qpx
+jrf: gao
+kpa: imz zbi mym paz
+cgk: scz
+dpx: tuv sxv lyw
+rgp: paz imz
+eqf: ubs bsf
+lxi: out
+uun: ngl
+kvl: out
+dbb: tcu lwr tby uwx cfq ozk oci uyd xft
+pzz: dbb kma
+xkm: kkq
+edy: luf
+unh: bkp
+yao: xjx
+wvx: wbz woh coz
+dwd: qbe
+egm: iyk xmy
+udo: wte qug ron
+iiy: qgm
+qpx: ert kxk djr
+zwd: ivr wij
+nkk: qgm vdm iwz
+axt: acu jhf
+jxo: cyw djr
+dha: pxu
+mbf: foq tuz qwi onp dot
+lbl: yog
+xka: qif ilb mpt
+ads: abn xeq ilf
+xft: zet ejh vwm
+fbn: eok ntb
+uqr: lfr
+omm: xnb cph ahy
+ecu: szt tvt vzw
+urh: tur xqs
+mym: ivr wij nzf
+ebh: pst qee qug wte
+wxd: ebh tps
+sbj: ert
+neg: oto odt
+kxu: wtr ywu
+dsk: dac chh
+ron: wjk
+ust: you eax
+tsv: pxt mnh fpk
+wij: shp oeb xsp zna sib rpi wql isk eeb xch suw wxd faw gio bik ouk ykl
+hog: ezs gju ibu
+mbl: kma dbb
+hbv: fgn azo
+gdo: kma dbb mup
+vlm: wee mhu
+gis: sxp jhg par xkt
+ohd: eok
+ivr: oeb zna gio tkm sib shp isk bik
+por: pdp qcy lfr
+mrd: gvm
+arh: uwd mlo gao
+loi: iii gxe bkg
+mpe: fqp hpk nbx dcb
+bue: sxp jhg xkt par
+bry: gom etk yqx yao wcs
+bgu: qxf fgq
+jsl: out
+ejh: svp zlg

internal/registry/registry.go

@@ -15,16 +15,16 @@ type DayRunner[T any] struct {
 	PartTwo    func(T) int
 }
 
-func (r *DayRunner[T]) Run(input string, part string) {
-	data := r.ParseInput(input)
+func (runner *DayRunner[T]) Run(input string, part string) {
+	data := runner.ParseInput(input)
 	switch part {
 	case "":
-		fmt.Println(r.PartOne(data))
-		fmt.Println(r.PartTwo(data))
+		fmt.Println(runner.PartOne(data))
+		fmt.Println(runner.PartTwo(data))
 	case "1":
-		fmt.Println(r.PartOne(data))
+		fmt.Println(runner.PartOne(data))
 	case "2":
-		fmt.Println(r.PartTwo(data))
+		fmt.Println(runner.PartTwo(data))
 	default:
 		fmt.Fprintf(os.Stderr, "Invalid part: %s\n", part)
 		os.Exit(1)