test: add unit test for part one

internal/2015/DayFifteen/code.go

@@ -79,20 +79,12 @@ func calculateScore(ingredients []ingredient, amounts []int) int {
 	return capacity * durability * flavor * texture
 }
 
-func findMaxScore(ingredients []ingredient, remaining int, amounts []int, index int) int {
+func calculateCalories(ingredients []ingredient, amounts []int) int {
-	if index == len(ingredients)-1 {
+	var calories int
-		amounts[index] = remaining
+	for idx, ing := range ingredients {
-		return calculateScore(ingredients, amounts)
+		calories += ing.calories * amounts[idx]
 	}
-	maxScore := 0
+	return calories
-	for i := 0; i <= remaining; i++ {
-		amounts[index] = i
-		score := findMaxScore(ingredients, remaining-i, amounts, index+1)
-		if score > maxScore {
-			maxScore = score
-		}
-	}
-	return maxScore
 }
 
 func PartOne(data []string) int {
@@ -101,9 +93,49 @@ func PartOne(data []string) int {
 		ingredients = append(ingredients, parseIngredient(line))
 	}
 	amounts := make([]int, len(ingredients))
-	return findMaxScore(ingredients, 100, amounts, 0)
+	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/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/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