me/advent-of-gode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

What a mess! 18-20, no Part 2 solve. Oh well!

Browse Source
This commit is contained in:
🐙PiperYxzzy
2023-12-21 07:26:06 +02:00
parent 9e2c2637e8
commit bcda89984d
13 changed files with 2172 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

516
2023/18/code.go
View File

@@ -2,6 +2,8 @@ package main
import ( import (
"fmt" "fmt"
"math"
"sort"
"strconv" "strconv"
"strings" "strings"
@@ -18,35 +20,164 @@ func main() {
// 3. with: false (part1), and user input // 3. with: false (part1), and user input
// 4. with: true (part2), and user input // 4. with: true (part2), and user input
// the return value of each run is printed to stdout // the return value of each run is printed to stdout
type Node struct {
Y int
X int
Next *Node
Prev *Node
}
func printNodes(nodes []*Node) {
maxY := 0
maxX := 0
minY := math.MaxInt
minX := math.MaxInt
for _, n := range nodes {
if maxY < n.Y {
maxY = n.Y
}
if minY > n.Y {
minY = n.Y
}
if maxX < n.X {
maxX = n.X
}
if minX > n.X {
minX = n.X
}
}
print := false
if print {
gridToPrint := make([][]rune, 0)
for y := 0; y <= maxY-minY; y++ {
gridLine := make([]rune, 0)
for x := 0; x <= maxX-minX; x++ {
gridLine = append(gridLine, ' ')
}
gridToPrint = append(gridToPrint, gridLine)
}
for y := minY; y <= maxY; y++ {
for x := minX; x <= maxX; x++ {
for _, n := range nodes {
//fmt.Printf("Checking node %v\n", n)
if n.X == x && n.Y == y {
if n.Prev.X == n.X {
// From previous, went up/down
if n.Prev.Y < n.Y {
// Has gone down
if n.Next.X > n.X {
// And right
gridToPrint[y-minY][x-minX] = '└'
} else {
// And left
gridToPrint[y-minY][x-minX] = '┘'
}
} else {
// Has gone up
if n.Next.X > n.X {
// And right
gridToPrint[y-minY][x-minX] = '┌'
} else {
// And left
gridToPrint[y-minY][x-minX] = '┐'
}
}
} else if n.Prev.Y == n.Y {
// From previous, went left/right
if n.Prev.X > n.X {
// Has gone left
if n.Next.Y > n.Y {
// And down
gridToPrint[y-minY][x-minX] = '┌'
} else {
// And up
gridToPrint[y-minY][x-minX] = '└'
}
} else {
// Has gone right
if n.Next.Y > n.Y {
// And down
gridToPrint[y-minY][x-minX] = '┐'
} else {
// And up
gridToPrint[y-minY][x-minX] = '┘'
}
}
} else {
panic(fmt.Sprintf("Could not align %v with Prev: %v", n, n.Prev))
}
}
}
}
}
// Now connect
for y := range gridToPrint {
for x := range gridToPrint[y] {
if gridToPrint[y][x] == '┌' || gridToPrint[y][x] == '└' {
xRun := x + 1
for gridToPrint[y][xRun] == ' ' {
gridToPrint[y][xRun] = '─'
xRun++
}
}
if gridToPrint[y][x] == '┌' || gridToPrint[y][x] == '┐' {
yRun := y + 1
for gridToPrint[yRun][x] == ' ' {
gridToPrint[yRun][x] = '│'
yRun++
}
}
}
}
for y := range gridToPrint {
for x := range gridToPrint[y] {
fmt.Printf("%v", string(gridToPrint[y][x]))
}
fmt.Println()
}
}
}
func abs(a int) int {
return int(math.Abs(float64(a)))
}
var rad90 float64 = 90 * math.Pi / 180
func rotate(nodes []*Node) {
for _, n := range nodes {
// rotate all points by 90 degrees
newX := int(math.Round(float64(n.X)*math.Cos(rad90) - float64(n.Y)*math.Sin(rad90)))
newY := int(math.Round(float64(n.X)*math.Sin(rad90) + float64(n.Y)*math.Cos(rad90)))
n.X, n.Y = newX, newY
}
}
func run(part2 bool, input string) any { func run(part2 bool, input string) any {
// when you're ready to do part 2, remove this "not implemented" block // when you're ready to do part 2, remove this "not implemented" block
if part2 { if part2 {
// More complex // More complex
// shrink wrap?
return "not implemented" return "not implemented"
} }
// solve part 1 here // solve part 1 here
// Get max dimensions (sumR + sumD) // Shrinkwrap approach
// or just make a big ass grid nodes := make([]*Node, 0)
x := 0
maxV := 1200 y := 0
maxH := 1200
grid := make([][]string, 0)
for v := 0; v < maxV; v++ {
gridLine := make([]string, 0)
for h := 0; h < maxH; h++ {
gridLine = append(gridLine, ".")
}
grid = append(grid, gridLine)
}
v := maxV / 2
h := maxH / 2
// Dig out trench
for _, l := range strings.Split(input, "\n") { for _, l := range strings.Split(input, "\n") {
if l == "" { if l == "" {
continue continue
@@ -54,79 +185,298 @@ func run(part2 bool, input string) any {
spl := strings.Split(l, " ") spl := strings.Split(l, " ")
order := spl[0] order := rune(spl[0][0])
dist, _ := strconv.Atoi(spl[1]) dist, _ := strconv.Atoi(spl[1])
colour := spl[2] //colour := spl[2]
for i := 0; i < dist; i++ { node := &Node{Y: y, X: x}
if order == "R" { nodes = append(nodes, node)
h += 1
} else if order == "L" { if order == 'R' {
h -= 1 x += dist
} else if order == "U" { } else if order == 'L' {
v -= 1 x -= dist
} else if order == "D" { } else if order == 'U' {
v += 1 y -= dist
} else if order == 'D' {
y += dist
} else { } else {
panic("bad direction") panic("bad order")
}
grid[v][h] = colour
} }
} }
// Fill out outside // Connect nodes (currently in order
outside := [][]int{{0, 0}}
for len(outside) > 0 {
o := outside[0]
outside = outside[1:]
if grid[o[0]][o[1]] == "." { for n := range nodes {
grid[o[0]][o[1]] = " " if n == 0 {
nodes[n].Next = nodes[1]
v = o[0] nodes[n].Prev = nodes[len(nodes)-1]
h = o[1] } else if n == len(nodes)-1 {
nodes[n].Next = nodes[0]
if v > 0 { nodes[n].Prev = nodes[n-1]
outside = append(outside, []int{v - 1, h})
}
if h > 0 {
outside = append(outside, []int{v, h - 1})
}
if v < len(grid)-1 {
outside = append(outside, []int{v + 1, h})
}
if h < len(grid[0])-1 {
outside = append(outside, []int{v, h + 1})
}
}
}
// Finally count fill-in
digout := 0
for v := range grid {
for h := range grid {
if grid[v][h] != " " {
digout += 1
}
}
}
print := false
if print {
for v := range grid {
for h := range grid[v] {
if len(grid[v][h]) == 1 {
fmt.Print(grid[v][h])
} else { } else {
fmt.Print("#") nodes[n].Next = nodes[n+1]
} nodes[n].Prev = nodes[n-1]
}
fmt.Println()
} }
} }
return digout firstNode := nodes[0]
lastNode := nodes[len(nodes)-1]
firstNode.Prev = lastNode
lastNode.Next = firstNode
// Begin downward collapse
printNodes(nodes)
totalArea := 0
for len(nodes) > 0 {
remove := make([]*Node, 0)
// try to find an "unbreakable, top-layer node"
/*
imagine:
............
.##########.
.##########.
.##########.
.####..####.
.####..####.
.####..####.
.####.......
............
*/
// Find the topmost node (i.e. lowest Y)
sort.Slice(nodes, func(i, j int) bool {
return nodes[i].Y < nodes[j].Y
})
n1 := nodes[0]
var n2, n3, n1adj, n2adj *Node
if n1.Next.Y == n1.Y {
n2 = n1.Next
n1adj = n1.Prev
n2adj = n2.Next
} else {
n2 = n1.Prev
n1adj = n1.Next
n2adj = n2.Prev
}
// Confirm that this is "unbreakable", else rotate and continue
if n1adj.Y < n2adj.Y {
n3 = n1adj
} else {
n3 = n2adj
}
// If there are any other nodes inside this box, reject
unbreakable := true
maxY := n3.Y
var minX, maxX int
if n1.X < n2.X {
minX = n1.X
maxX = n2.X
} else {
minX = n2.X
maxX = n1.X
}
for _, n := range nodes {
if n == n1 || n == n2 || n == n3 {
continue
}
if n.X > minX && n.X < maxX && n.Y < maxY {
unbreakable = false
}
}
if !unbreakable {
// try to find any other unbreakables
exclusionX := [][]int{{n1.X, n2.X}}
excludeX:
for _, n := range nodes {
n1 = n
if n1.Next.Y == n1.Y {
n2 = n1.Next
n1adj = n1.Prev
n2adj = n2.Next
} else {
n2 = n1.Prev
n1adj = n1.Next
n2adj = n2.Prev
}
if n1adj.Y < n1.Y || n2adj.Y < n1.Y {
continue excludeX
}
for _, ex := range exclusionX {
if ex[0] > ex[1] {
if n1.X <= ex[0] && n1.X >= ex[1] || n2.X <= ex[0] && n2.X >= ex[1] {
continue excludeX
}
} else {
if n1.X >= ex[0] && n1.X <= ex[1] || n2.X >= ex[0] && n2.X <= ex[1] {
continue excludeX
}
}
}
// Confirm that this is "unbreakable", else rotate and continue
if n1adj.Y < n2adj.Y {
n3 = n1adj
} else {
n3 = n2adj
}
unbreakable = true
maxY := n3.Y
var minX, maxX int
if n1.X < n2.X {
minX = n1.X
maxX = n2.X
} else {
minX = n2.X
maxX = n1.X
}
for _, n := range nodes {
if n == n1 || n == n2 || n == n3 {
continue
}
if n.X > minX && n.X < maxX && n.Y < maxY {
unbreakable = false
}
}
if !unbreakable {
exclusionX = append(exclusionX, []int{n1.X, n2.X})
} else {
break excludeX
}
}
if !unbreakable {
rotate(nodes)
printNodes(nodes)
continue
}
}
// We now have our "top" bar (n1-n2)
// Find the minimum to shift it by
// Now for the clever bit
xLen := abs(n1.X-n2.X) + 1
fmt.Printf("Bar len: %v (%v %v %v) \n", xLen, n1, n2, n3)
var addY int
if n1adj.Y < n2adj.Y {
addY = n1adj.Y
} else {
addY = n2adj.Y
}
addY -= n1.Y
fmt.Printf("Shift down by: %v\n", addY)
areaCollapse := xLen * addY
totalArea += areaCollapse
// And collapse the nodes
n1.Y += addY
n2.Y += addY
if n1.Y == n1adj.Y && n1.X == n1adj.X {
// merge into
remove = append(remove, n1)
if n1.Next == n1adj {
n1adj.Prev = n1.Prev
n1.Prev.Next = n1adj
} else if n1.Prev == n1adj {
n1adj.Next = n1.Next
n1.Next.Prev = n1adj
} else {
panic("Matched 1 but could not reassign")
}
}
if n2.Y == n2adj.Y && n2.X == n2adj.X {
remove = append(remove, n2)
if n2.Next == n2adj {
n2adj.Prev = n2.Prev
n2.Prev.Next = n2adj
} else if n2.Prev == n2adj {
n2adj.Next = n2.Next
n2.Next.Prev = n2adj
} else {
panic("Matched 2 but could not reassign")
}
}
// finally, find any sharp corners (3 nodes in a row with the same Y)
if n1adj.Next.Y == n1adj.Y && n1adj.Prev.Y == n1adj.Y {
if (n1adj.X > n1adj.Next.X && n1adj.X > n1adj.Prev.X) || (n1adj.X < n1adj.Next.X && n1adj.X < n1adj.Prev.X) {
diffNextPrev := abs(n1adj.Next.X - n1adj.Prev.X)
diffBoth := abs(n1adj.X-n1adj.Next.X) + abs(n1adj.X-n1adj.Prev.X)
areaCount := (diffBoth - diffNextPrev) / 2
fmt.Printf("Offcut area: %v\n", areaCount)
totalArea += areaCount
}
remove = append(remove, n1adj)
n1adj.Next.Prev = n1adj.Prev
n1adj.Prev.Next = n1adj.Next
}
if n2adj.Next.Y == n2adj.Y && n2adj.Prev.Y == n2adj.Y {
if (n2adj.X > n2adj.Next.X && n2adj.X > n2adj.Prev.X) || (n2adj.X < n2adj.Next.X && n2adj.X < n2adj.Prev.X) {
diffNextPrev := abs(n2adj.Next.X - n2adj.Prev.X)
diffBoth := abs(n2adj.X-n2adj.Next.X) + abs(n2adj.X-n2adj.Prev.X)
areaCount := (diffBoth - diffNextPrev) / 2
fmt.Printf("Offcut area: %v\n", areaCount)
totalArea += areaCount
}
remove = append(remove, n2adj)
n2adj.Next.Prev = n2adj.Prev
n2adj.Prev.Next = n2adj.Next
}
fmt.Printf("%v\n", totalArea)
remainingNodes := make([]*Node, 0)
for _, n := range nodes {
keep := true
for _, r := range remove {
if r == n {
keep = false
}
}
if keep {
remainingNodes = append(remainingNodes, n)
}
}
nodes = remainingNodes
//if totalArea == 48081 {
//}
//
printNodes(nodes)
//time.Sleep(500 * time.Millisecond)
}
// Expect 62
return totalArea + 1
} }

52
2023/18/input-example.txt Executable file → Normal file
View File

@@ -1,14 +1,38 @@
R 6 (#70c710) R 2 ()
D 5 (#0dc571) D 2 ()
L 2 (#5713f0) R 3 ()
D 2 (#d2c081) U 6 ()
R 2 (#59c680) R 10 ()
D 2 (#411b91) D 6 ()
L 5 (#8ceee2) L 1 ()
U 2 (#caa173) U 5 ()
L 1 (#1b58a2) L 8 ()
U 2 (#caa171) D 8 ()
R 2 (#7807d2) R 11 ()
U 3 (#a77fa3) D 3 ()
L 2 (#015232) L 2 ()
U 2 (#7a21e3) D 3 ()
R 6 ()
D 7 ()
L 4 ()
U 2 ()
R 2 ()
U 4 ()
L 6 ()
D 9 ()
L 9 ()
U 3 ()
R 1 ()
D 2 ()
R 7 ()
U 8 ()
L 18 ()
U 7 ()
R 3 ()
D 1 ()
L 2 ()
D 5 ()
R 6 ()
U 5 ()
L 1 ()
U 6 ()

38
2023/18/otherexamples/input-example-octo.txt Normal file
View File

@@ -0,0 +1,38 @@
R 2 ()
D 2 ()
R 3 ()
U 6 ()
R 10 ()
D 6 ()
L 1 ()
U 5 ()
L 8 ()
D 8 ()
R 11 ()
D 3 ()
L 2 ()
D 3 ()
R 6 ()
D 7 ()
L 4 ()
U 2 ()
R 2 ()
U 4 ()
L 6 ()
D 9 ()
L 9 ()
U 3 ()
R 1 ()
D 2 ()
R 7 ()
U 8 ()
L 18 ()
U 7 ()
R 3 ()
D 1 ()
L 2 ()
D 5 ()
R 6 ()
U 5 ()
L 1 ()
U 6 ()

14
2023/18/otherexamples/input-example.txt Normal file
View File

@@ -0,0 +1,14 @@
R 6 (#70c710)
D 5 (#0dc571)
L 2 (#5713f0)
D 2 (#d2c081)
R 2 (#59c680)
D 2 (#411b91)
L 5 (#8ceee2)
U 2 (#caa173)
L 1 (#1b58a2)
U 2 (#caa171)
R 2 (#7807d2)
U 3 (#a77fa3)
L 2 (#015232)
U 2 (#7a21e3)

16
2023/18/otherexamples/squomnk.txt Normal file
View File

@@ -0,0 +1,16 @@
R 7 ()
D 8 ()
L 2 ()
U 4 ()
L 3 ()
D 7 ()
R 7 ()
D 2 ()
L 2 ()
D 4 ()
L 7 ()
U 3 ()
R 1 ()
U 2 ()
L 1 ()
U 12 ()

58
2023/19/README.md Executable file
View File

@@ -0,0 +1,58 @@
## \-\-\- Day 19: Aplenty ---
The Elves of Gear Island are thankful for your help and send you on your way. They even have a hang glider that someone [stole](9) from Desert Island; since you're already going that direction, it would help them a lot if you would use it to get down there and return it to them.
As you reach the bottom of the _relentless avalanche of machine parts_, you discover that they're already forming a formidable heap. Don't worry, though - a group of Elves is already here organizing the parts, and they have a _system_.
To start, each part is rated in each of four categories:
- `x`: E _x_ tremely cool looking
- `m`: _M_ usical (it makes a noise when you hit it)
- `a`: _A_ erodynamic
- `s`: _S_ hiny
Then, each part is sent through a series of _workflows_ that will ultimately _accept_ or _reject_ the part. Each workflow has a name and contains a list of _rules_; each rule specifies a condition and where to send the part if the condition is true. The first rule that matches the part being considered is applied immediately, and the part moves on to the destination described by the rule. (The last rule in each workflow has no condition and always applies if reached.)
Consider the workflow `ex{x>10:one,m<20:two,a>30:R,A}`. This workflow is named `ex` and contains four rules. If workflow `ex` were considering a specific part, it would perform the following steps in order:
- Rule " `x>10:one`": If the part's `x` is more than `10`, send the part to the workflow named `one`.
- Rule " `m<20:two`": Otherwise, if the part's `m` is less than `20`, send the part to the workflow named `two`.
- Rule " `a>30:R`": Otherwise, if the part's `a` is more than `30`, the part is immediately _rejected_ ( `R`).
- Rule " `A`": Otherwise, because no other rules matched the part, the part is immediately _accepted_ ( `A`).
If a part is sent to another workflow, it immediately switches to the start of that workflow instead and never returns. If a part is _accepted_ (sent to `A`) or _rejected_ (sent to `R`), the part immediately stops any further processing.
The system works, but it's not keeping up with the torrent of weird metal shapes. The Elves ask if you can help sort a few parts and give you the list of workflows and some part ratings (your puzzle input). For example:
```
px{a<2006:qkq,m>2090:A,rfg}
pv{a>1716:R,A}
lnx{m>1548:A,A}
rfg{s<537:gd,x>2440:R,A}
qs{s>3448:A,lnx}
qkq{x<1416:A,crn}
crn{x>2662:A,R}
in{s<1351:px,qqz}
qqz{s>2770:qs,m<1801:hdj,R}
gd{a>3333:R,R}
hdj{m>838:A,pv}
{x=787,m=2655,a=1222,s=2876}
{x=1679,m=44,a=2067,s=496}
{x=2036,m=264,a=79,s=2244}
{x=2461,m=1339,a=466,s=291}
{x=2127,m=1623,a=2188,s=1013}
```
The workflows are listed first, followed by a blank line, then the ratings of the parts the Elves would like you to sort. All parts begin in the workflow named `in`. In this example, the five listed parts go through the following workflows:
- `{x=787,m=2655,a=1222,s=2876}`: `in` -\> `qqz` -\> `qs` -\> `lnx` -\> `A`
- `{x=1679,m=44,a=2067,s=496}`: `in` -\> `px` -\> `rfg` -\> `gd` -\> `R`
- `{x=2036,m=264,a=79,s=2244}`: `in` -\> `qqz` -\> `hdj` -\> `pv` -\> `A`
- `{x=2461,m=1339,a=466,s=291}`: `in` -\> `px` -\> `qkq` -\> `crn` -\> `R`
- `{x=2127,m=1623,a=2188,s=1013}`: `in` -\> `px` -\> `rfg` -\> `A`
Ultimately, three parts are _accepted_. Adding up the `x`, `m`, `a`, and `s` rating for each of the accepted parts gives `7540` for the part with `x=787`, `4623` for the part with `x=2036`, and `6951` for the part with `x=2127`. Adding all of the ratings for _all_ of the accepted parts gives the sum total of `19114`.
Sort through all of the parts you've been given; _what do you get if you add together all of the rating numbers for all of the parts that ultimately get accepted?_

389
2023/19/code.go Normal file
View File

@@ -0,0 +1,389 @@
package main
import (
"fmt"
"strconv"
"strings"
"github.com/jpillora/puzzler/harness/aoc"
)
func main() {
aoc.Harness(run)
}
// on code change, run will be executed 4 times:
// 1. with: false (part1), and example input
// 2. with: true (part2), and example input
// 3. with: false (part1), and user input
// 4. with: true (part2), and user input
// the return value of each run is printed to stdout
type Part struct {
X int
M int
A int
S int
}
type PartAcceptor struct {
Wfl []Workflow
Xmax int
Xmin int
Mmax int
Mmin int
Amax int
Amin int
Smax int
Smin int
}
type Workflow struct {
Comparing string
CompareType string
Value int
Result string
Method func(p Part) string
}
func run(part2 bool, input string) any {
// when you're ready to do part 2, remove this "not implemented" block
workflows := make(map[string][]Workflow)
parts := make([]Part, 0)
inParts := false
for _, l := range strings.Split(input, "\n") {
if l == "" {
inParts = true
continue
}
if !inParts {
cutoff := strings.Index(l, "{")
name := l[0:cutoff]
wkflow := l[cutoff+1 : len(l)-1]
functions := make([]Workflow, 0)
for _, wkF := range strings.Split(wkflow, ",") {
if strings.Contains(wkF, ":") {
// Mapping function
spl := strings.Split(wkF, ":")
comparing := spl[0][0:2]
compared, _ := strconv.Atoi(spl[0][2:])
res := spl[1]
if comparing == "x>" {
functions = append(functions, Workflow{"x", ">", compared, res, func(p Part) string {
if p.X > compared {
return res
}
return ""
}})
} else if comparing == "x<" {
functions = append(functions, Workflow{"x", "<", compared, res, func(p Part) string {
if p.X < compared {
return res
}
return ""
}})
} else if comparing == "m>" {
functions = append(functions, Workflow{"m", ">", compared, res, func(p Part) string {
if p.M > compared {
return res
}
return ""
}})
} else if comparing == "m<" {
functions = append(functions, Workflow{"m", "<", compared, res, func(p Part) string {
if p.M < compared {
return res
}
return ""
}})
} else if comparing == "a>" {
functions = append(functions, Workflow{"a", ">", compared, res, func(p Part) string {
if p.A > compared {
return res
}
return ""
}})
} else if comparing == "a<" {
functions = append(functions, Workflow{"a", "<", compared, res, func(p Part) string {
if p.A < compared {
return res
}
return ""
}})
} else if comparing == "s>" {
functions = append(functions, Workflow{"s", ">", compared, res, func(p Part) string {
if p.S > compared {
return res
}
return ""
}})
} else if comparing == "s<" {
functions = append(functions, Workflow{"s", "<", compared, res, func(p Part) string {
if p.S < compared {
return res
}
return ""
}})
} else {
panic("!??")
}
} else {
// Just a return function
functions = append(functions, Workflow{"", "", 0, wkF, func(p Part) string { return wkF }})
}
}
workflows[name] = functions
} else {
l = strings.Replace(strings.Replace(l, "{", "", -1), "}", "", -1)
spl := strings.Split(l, ",")
x, _ := strconv.Atoi(spl[0][2:])
m, _ := strconv.Atoi(spl[1][2:])
a, _ := strconv.Atoi(spl[2][2:])
s, _ := strconv.Atoi(spl[3][2:])
parts = append(parts, Part{x, m, a, s})
}
}
if part2 {
pa := PartAcceptor{workflows["in"], 4000, 1, 4000, 1, 4000, 1, 4000, 1}
pas := []PartAcceptor{pa}
combos := int64(0)
for len(pas) > 0 {
//fmt.Printf("%v\n", pas)
p := pas[0]
pas = pas[1:]
for _, wf := range p.Wfl {
if wf.CompareType != "" {
//fmt.Printf("Splitting comparator\n")
// Comparator! Will split
if wf.CompareType == ">" {
if wf.Comparing == "x" && p.Xmax > wf.Value {
if p.Xmin > wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted (split): %v\n", p)
combos += int64(p.Xmax-(wf.Value+1)+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Xmax = wf.Value
}
} else if wf.Comparing == "m" && p.Mmax > wf.Value {
if p.Mmin > wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-(wf.Value+1)+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Mmax = wf.Value
}
} else if wf.Comparing == "a" && p.Amax > wf.Value {
if p.Amin > wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-(wf.Value+1)+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Amax = wf.Value
}
} else if wf.Comparing == "s" && p.Smax > wf.Value {
if p.Smin > wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, wf.Value + 1}
pas = append(pas, newP)
}
p.Smax = wf.Value
}
}
} else if wf.CompareType == "<" {
if wf.Comparing == "x" && p.Xmin < wf.Value {
if p.Xmax < wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted (split): %v\n", p)
combos += int64((wf.Value-1)-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Xmin = wf.Value
}
} else if wf.Comparing == "m" && p.Mmin < wf.Value {
if p.Mmax < wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64((wf.Value-1)-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Mmin = wf.Value
}
} else if wf.Comparing == "a" && p.Amin < wf.Value {
if p.Amax < wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64((wf.Value-1)-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Amin = wf.Value
}
} else if wf.Comparing == "s" && p.Smin < wf.Value {
if p.Smax < wf.Value {
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
} else { // Split
if wf.Result == "A" {
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64((wf.Value-1)-p.Smin+1)
} else if wf.Result != "R" {
newP := PartAcceptor{workflows[wf.Result], p.Xmax, p.Xmin, p.Mmax, p.Mmin, p.Amax, p.Amin, p.Smax, p.Smin}
pas = append(pas, newP)
}
p.Smin = wf.Value
}
}
} else {
panic("!?!?")
}
} else if wf.Result == "A" {
// Auto accept
fmt.Printf("Accepted: %v\n", p)
combos += int64(p.Xmax-p.Xmin+1) * int64(p.Mmax-p.Mmin+1) * int64(p.Amax-p.Amin+1) * int64(p.Smax-p.Smin+1)
} else if wf.Result == "R" {
// Do nothing, rejected
fmt.Printf("Rejected: %v\n", p)
} else {
//fmt.Printf("Moved to %v (%v)\n", wf.Result, p)
p.Wfl = workflows[wf.Result]
pas = append(pas, p)
}
}
}
// Expect: 167409079868000
// Getting: 397530093888000
return combos
}
ratingSum := 0
for _, p := range parts {
wk := workflows["in"]
for wk != nil {
workflowOne:
for _, fnc := range wk {
res := fnc.Method(p)
if res != "" {
if res == "A" {
ratingSum += (p.X + p.M + p.A + p.S)
wk = nil
} else if res == "R" {
wk = nil
} else {
// it's a mapping
wk = workflows[res]
}
break workflowOne
}
}
}
}
// solve part 1 here
return ratingSum
}

18
2023/19/input-example.txt Executable file
View File

@@ -0,0 +1,18 @@
px{a<2006:qkq,m>2090:A,rfg}
pv{a>1716:R,A}
lnx{m>1548:A,A}
rfg{s<537:gd,x>2440:R,A}
qs{s>3448:A,lnx}
qkq{x<1416:A,crn}
crn{x>2662:A,R}
in{s<1351:px,qqz}
qqz{s>2770:qs,m<1801:hdj,R}
gd{a>3333:R,R}
hdj{m>838:A,pv}
{x=787,m=2655,a=1222,s=2876}
{x=1679,m=44,a=2067,s=496}
{x=2036,m=264,a=79,s=2244}
{x=2461,m=1339,a=466,s=291}
{x=2127,m=1623,a=2188,s=1013}
-

133
2023/20/README.md Executable file
View File

@@ -0,0 +1,133 @@
## \-\-\- Day 20: Pulse Propagation ---
With your help, the Elves manage to find the right parts and fix all of the machines. Now, they just need to send the command to boot up the machines and get the sand flowing again.
The machines are far apart and wired together with long _cables_. The cables don't connect to the machines directly, but rather to communication _modules_ attached to the machines that perform various initialization tasks and also act as communication relays.
Modules communicate using _pulses_. Each pulse is either a _high pulse_ or a _low pulse_. When a module sends a pulse, it sends that type of pulse to each module in its list of _destination modules_.
There are several different types of modules:
_Flip-flop_ modules (prefix `%`) are either _on_ or _off_; they are initially _off_. If a flip-flop module receives a high pulse, it is ignored and nothing happens. However, if a flip-flop module receives a low pulse, it _flips between on and off_. If it was off, it turns on and sends a high pulse. If it was on, it turns off and sends a low pulse.
_Conjunction_ modules (prefix `&`) _remember_ the type of the most recent pulse received from _each_ of their connected input modules; they initially default to remembering a _low pulse_ for each input. When a pulse is received, the conjunction module first updates its memory for that input. Then, if it remembers _high pulses_ for all inputs, it sends a _low pulse_; otherwise, it sends a _high pulse_.
There is a single _broadcast module_ (named `broadcaster`). When it receives a pulse, it sends the same pulse to all of its destination modules.
Here at Desert Machine Headquarters, there is a module with a single button on it called, aptly, the _button module_. When you push the button, a single _low pulse_ is sent directly to the `broadcaster` module.
After pushing the button, you must wait until all pulses have been delivered and fully handled before pushing it again. Never push the button if modules are still processing pulses.
Pulses are always processed _in the order they are sent_. So, if a pulse is sent to modules `a`, `b`, and `c`, and then module `a` processes its pulse and sends more pulses, the pulses sent to modules `b` and `c` would have to be handled first.
The module configuration (your puzzle input) lists each module. The name of the module is preceded by a symbol identifying its type, if any. The name is then followed by an arrow and a list of its destination modules. For example:
```
broadcaster -> a, b, c
%a -> b
%b -> c
%c -> inv
&inv -> a
```
In this module configuration, the broadcaster has three destination modules named `a`, `b`, and `c`. Each of these modules is a flip-flop module (as indicated by the `%` prefix). `a` outputs to `b` which outputs to `c` which outputs to another module named `inv`. `inv` is a conjunction module (as indicated by the `&` prefix) which, because it has only one input, acts like an inverter (it sends the opposite of the pulse type it receives); it outputs to `a`.
By pushing the button once, the following pulses are sent:
```
button -low-> broadcaster
broadcaster -low-> a
broadcaster -low-> b
broadcaster -low-> c
a -high-> b
b -high-> c
c -high-> inv
inv -low-> a
a -low-> b
b -low-> c
c -low-> inv
inv -high-> a
```
After this sequence, the flip-flop modules all end up _off_, so pushing the button again repeats the same sequence.
Here's a more interesting example:
```
broadcaster -> a
%a -> inv, con
&inv -> b
%b -> con
&con -> output
```
This module configuration includes the `broadcaster`, two flip-flops (named `a` and `b`), a single-input conjunction module ( `inv`), a multi-input conjunction module ( `con`), and an untyped module named `output` (for testing purposes). The multi-input conjunction module `con` watches the two flip-flop modules and, if they're both on, sends a _low pulse_ to the `output` module.
Here's what happens if you push the button once:
```
button -low-> broadcaster
broadcaster -low-> a
a -high-> inv
a -high-> con
inv -low-> b
con -high-> output
b -high-> con
con -low-> output
```
Both flip-flops turn on and a low pulse is sent to `output`! However, now that both flip-flops are on and `con` remembers a high pulse from each of its two inputs, pushing the button a second time does something different:
```
button -low-> broadcaster
broadcaster -low-> a
a -low-> inv
a -low-> con
inv -high-> b
con -high-> output
```
Flip-flop `a` turns off! Now, `con` remembers a low pulse from module `a`, and so it sends only a high pulse to `output`.
Push the button a third time:
```
button -low-> broadcaster
broadcaster -low-> a
a -high-> inv
a -high-> con
inv -low-> b
con -low-> output
b -low-> con
con -high-> output
```
This time, flip-flop `a` turns on, then flip-flop `b` turns off. However, before `b` can turn off, the pulse sent to `con` is handled first, so it _briefly remembers all high pulses_ for its inputs and sends a low pulse to `output`. After that, flip-flop `b` turns off, which causes `con` to update its state and send a high pulse to `output`.
Finally, with `a` on and `b` off, push the button a fourth time:
```
button -low-> broadcaster
broadcaster -low-> a
a -low-> inv
a -low-> con
inv -high-> b
con -high-> output
```
This completes the cycle: `a` turns off, causing `con` to remember only low pulses and restoring all modules to their original states.
To get the cables warmed up, the Elves have pushed the button `1000` times. How many pulses got sent as a result (including the pulses sent by the button itself)?
In the first example, the same thing happens every time the button is pushed: `8` low pulses and `4` high pulses are sent. So, after pushing the button `1000` times, `8000` low pulses and `4000` high pulses are sent. Multiplying these together gives `32000000`.
In the second example, after pushing the button `1000` times, `4250` low pulses and `2750` high pulses are sent. Multiplying these together gives `11687500`.
Consult your module configuration; determine the number of low pulses and high pulses that would be sent after pushing the button `1000` times, waiting for all pulses to be fully handled after each push of the button. _What do you get if you multiply the total number of low pulses sent by the total number of high pulses sent?_

243
2023/20/code.go Normal file
View File

@@ -0,0 +1,243 @@
package main
import (
"fmt"
"math"
"strings"
"github.com/jpillora/puzzler/harness/aoc"
)
func main() {
aoc.Harness(run)
}
// on code change, run will be executed 4 times:
// 1. with: false (part1), and example input
// 2. with: true (part2), and example input
// 3. with: false (part1), and user input
// 4. with: true (part2), and user input
// the return value of each run is printed to stdout
type Module struct {
Name string
Prefix rune
OutputsStr []string
Outputs []*Module
// For %
On bool
// For &
ConjMap map[*Module]bool
}
type Pulse struct {
From *Module
Destination *Module
High bool
}
func (m *Module) LowPulse(from *Module) []Pulse {
if m.Name == "rx" {
panic("WE GOT HERE")
}
next := make([]Pulse, 0)
if m.Prefix == '%' {
m.On = !m.On
for _, n := range m.Outputs {
next = append(next, Pulse{m, n, m.On})
}
} else if m.Prefix == '&' {
m.ConjMap[from] = false
for _, n := range m.Outputs {
next = append(next, Pulse{m, n, true})
}
} else if m.Prefix == 'b' {
for _, n := range m.Outputs {
next = append(next, Pulse{m, n, false})
}
} else if m.Prefix == '.' {
// Output, do nothing
} else {
panic("bad prefix")
}
return next
}
func (m *Module) HiPulse(from *Module) []Pulse {
next := make([]Pulse, 0)
if m.Prefix == '%' {
// Ignore
} else if m.Prefix == '&' {
m.ConjMap[from] = true
anyLow := false
for _, val := range m.ConjMap {
if !val {
anyLow = true
}
}
for _, n := range m.Outputs {
next = append(next, Pulse{m, n, anyLow})
}
} else if m.Prefix == 'b' {
for _, n := range m.Outputs {
next = append(next, Pulse{m, n, true})
}
} else if m.Prefix == '.' {
// Output, do nothing
} else {
panic("bad prefix")
}
return next
}
func (p *Pulse) Pulse(tally *Tally) ([]Pulse, bool) {
//fmt.Printf("Pulsing %v from %v to %v [L:%v H:%v] \n", p.High, p.From, p.Destination, tally.Lo, tally.Hi)
if p.High {
tally.Hi += 1
return p.Destination.HiPulse(p.From), false
}
if p.Destination.Name == "rx" {
fmt.Printf("Rx! Terminating!")
return nil, true
}
tally.Lo += 1
return p.Destination.LowPulse(p.From), false
}
type Tally struct {
Hi int
Lo int
}
func run(part2 bool, input string) any {
var broadcaster Module
mods := make(map[string]*Module)
for _, l := range strings.Split(input, "\n") {
if l == "" {
continue
}
spl := strings.Split(l, " -> ")
dests := strings.Split(spl[1], ", ")
if spl[0] == "broadcaster" {
broadcaster = Module{
"broadcaster",
'b',
dests,
make([]*Module, 0),
false,
make(map[*Module]bool),
}
mods["broadcaster"] = &broadcaster
} else {
mod := Module{
spl[0][1:],
rune(spl[0][0]),
dests,
make([]*Module, 0),
false,
make(map[*Module]bool),
}
mods[mod.Name] = &mod
}
}
// Now, configure
toProcess := []*Module{&broadcaster}
processed := make(map[string]bool)
for len(toProcess) > 0 {
m := toProcess[0]
toProcess = toProcess[1:]
if _, ok := processed[m.Name]; ok {
continue
}
processed[m.Name] = true
//fmt.Printf("Preprocessing %v\n", m.Name)
for _, d := range m.OutputsStr {
dest, ok := mods[d]
if !ok {
dest = &Module{
d,
'.',
make([]string, 0),
make([]*Module, 0),
false,
make(map[*Module]bool),
}
}
m.Outputs = append(m.Outputs, dest)
dest.ConjMap[m] = false
}
toProcess = append(toProcess, m.Outputs...)
}
// Print mappings:
modPrint := []*Module{&broadcaster}
processed = make(map[string]bool)
for len(modPrint) > 0 {
mp := modPrint[0]
modPrint = modPrint[1:]
if _, ok := processed[mp.Name]; ok {
continue
}
processed[mp.Name] = true
modPrint = append(modPrint, mp.Outputs...)
//fmt.Printf("%v (%v): %v (%v) [%v]\n", mp.Name, mp.Prefix, mp.OutputsStr, mp.Outputs, &mp)
}
tally := Tally{0, 0}
limit := 1000
if part2 {
limit = math.MaxInt
}
for i := 0; i < limit; i++ {
if i%1000000 == 0 {
fmt.Printf("Sent %v pulses\n", i)
}
pulsesToSend := []Pulse{{nil, &broadcaster, false}}
for len(pulsesToSend) > 0 {
pulse := pulsesToSend[0]
pulsesToSend = pulsesToSend[1:]
newPulses, rxLow := pulse.Pulse(&tally)
if rxLow && part2 {
return tally.Lo
}
//fmt.Printf("New pulses: %v\n", newPulses)
pulsesToSend = append(pulsesToSend, newPulses...)
}
}
fmt.Printf("Lo: %v ; Hi: %v\n", tally.Lo, tally.Hi)
return tally.Lo * tally.Hi
}

5
2023/20/input-example.txt Executable file
View File

@@ -0,0 +1,5 @@
broadcaster -> a, b, c
%a -> b
%b -> c
%c -> rx
&rx -> a

58
2023/20/input-user.txt Normal file
View File

@@ -0,0 +1,58 @@
&ls -> fg, ck, fv, sk, fl, hz
%px -> ls, dv
%jk -> xt, tx
%hd -> fs, vn
%pk -> ql
%bj -> tx, pr
%vg -> xl, sf
%cj -> bj
%sk -> bz
%fl -> fx
%th -> fl, ls
%pr -> gm
%xv -> sf, hp
%mh -> jb
%jh -> kx, tx
%jz -> pm, fs
%hr -> tx, gk
%kx -> cj
%ql -> jx
%gm -> tx, jt
%hz -> ls, fv
%dt -> fs
%gg -> sf, vg
%xl -> fh
&pq -> vr
%jx -> mv
%kr -> gg
%bn -> px, ls
&fs -> pm, rg, pq, pj, nk, mh, jb
%vn -> rt, fs
%jt -> tx, zb
broadcaster -> hz, hr, nk, nv
%fx -> sk, ls
%rt -> fs, kz
%gk -> tx, jh
%mv -> sf, kr
%bz -> bn, ls
%dv -> ls
%rg -> jz
%pj -> mh
%kz -> dt, fs
%ck -> hg
&fg -> vr
&sf -> pk, jx, nv, kr, xl, ql, dk
%jb -> rg
%nk -> fs, pj
&dk -> vr
%hp -> sf
&tx -> hr, fm, kx, cj, pr
%nv -> pk, sf
%fh -> xv, sf
%xt -> tx
%hg -> ls, th
%zb -> tx, jk
&fm -> vr
%pm -> hd
%fv -> ck
&vr -> rx

736
input-user.txt Normal file
View File

@@ -0,0 +1,736 @@
fzf{m<1642:A,px}
qqp{s>3732:R,m>946:R,a<1401:A,A}
mqh{x>1081:A,m<3344:R,m>3632:R,A}
bnk{a>2841:R,s<3562:R,x>3483:A,A}
jt{a>3076:A,s<2748:A,s>2805:R,A}
vl{x>2613:sv,a>2454:lhx,jg}
bhj{x>2768:jhd,mhd}
ggs{x>3053:R,x>2848:R,R}
lx{a>3685:A,bn}
hcz{x>763:R,s<2753:A,R}
mnr{x>1157:R,R}
cpd{a<320:A,m>1387:bz,A}
lbm{s<3387:R,s>3672:R,a<3818:R,A}
npb{a<1149:dmc,tgt}
bsh{x<1228:R,R}
px{x>1003:A,a>3750:A,A}
jl{a<1881:R,m>1146:R,s<400:A,R}
cs{s<3185:A,A}
krx{x<3153:A,a<2570:R,A}
dp{a>3221:A,A}
zxh{s<2883:R,vb}
dtj{x<1574:A,m<961:A,m>1183:R,R}
mhd{a<2806:vtt,R}
mll{s<2589:fs,rct}
nbf{x<2665:sgr,A}
jr{a>3301:tc,x>996:dh,a>2980:ncl,A}
lxc{x<1450:R,m>899:A,x>1653:A,R}
xfp{a>586:pbx,xzk}
crf{s>3081:R,a>1253:A,s<2740:R,A}
mc{a<330:A,a>440:A,x>2613:R,A}
lcl{m>1452:mls,R}
scv{a>653:R,a<385:A,s>2291:mcm,A}
jg{m>2877:gqc,a>2247:R,A}
kbt{a<75:A,x>3256:R,a>137:A,R}
cmf{m<795:R,A}
zxc{a<1971:A,a>2270:R,A}
lms{s>323:tfs,A}
mgs{x<2480:A,a<1050:A,R}
kz{s<3266:zg,a<2977:A,vqn}
lh{x>1958:pkf,m>3511:hx,mk}
db{m<1657:xvn,nsd}
gbg{m<1371:A,x>3428:A,s<3077:A,R}
gz{s<3104:A,m<2828:A,m>3281:R,R}
hpl{a>3117:A,ft}
zg{x<1698:R,R}
vqv{a>1031:A,x>2460:A,x<1912:A,R}
vb{m<1499:A,x>1894:R,R}
xkq{s<1553:cng,s<3162:tkj,mlj}
ngz{a<3373:A,s>402:A,s>204:A,A}
dq{m<801:rmb,a<2127:A,R}
kh{x>1408:A,A}
jfk{a>1219:qkz,s<1492:mt,m<2952:gkl,khv}
pl{s>3123:R,A}
tdg{a>1983:A,a<1853:gx,x>1678:kkc,qcb}
nlk{a<2055:R,zmn}
sxc{s<1553:R,R}
nzx{a<2569:A,x<1812:cbv,A}
cph{m<2856:A,A}
pxx{x<3670:qnj,m<3015:R,a<3243:R,A}
bnz{a<949:lsz,s>1899:hcp,s>1631:A,ntl}
tv{m<1352:R,m<1812:A,R}
qkz{a<2141:crk,x<1866:rlz,vl}
qrp{a>3607:R,m<2423:lj,qqj}
blf{s<1970:R,R}
xrc{x<2476:rjx,a>1724:tj,pbt}
nr{m>2092:hzc,A}
jld{s<1570:A,ps}
nk{a<3132:R,R}
rgl{a<2558:A,R}
rl{a<1021:A,R}
bjq{s<2821:R,s<2872:A,R}
qnj{s>1202:R,s>488:R,R}
bxb{m<911:A,x>468:bnx,s>3663:R,R}
ksl{x<688:A,x>1068:A,R}
qzz{a>1963:sdm,s<1753:R,cgx}
xmx{m<1231:qnv,m>1789:nsx,s>1698:xrp,A}
bqt{x>392:R,A}
nx{m<3603:R,s<2999:mg,m>3830:R,A}
kfr{a<2455:jf,m>1009:nzx,x<2605:cgv,sm}
rzc{m<3116:R,x>1302:R,s<2205:R,shf}
zbv{m<3299:R,x<740:A,R}
qds{a<3031:tg,a<3095:pp,x>2192:bf,cgf}
zz{m<602:R,m>616:A,A}
ctn{s<1118:qvc,jzc}
mv{m>3603:R,s<1044:R,A}
pm{m>2113:kd,a>278:A,R}
vcd{m<1762:A,R}
dn{m>2924:R,A}
cjf{a<886:jsn,s>538:hp,R}
fcr{s>738:vnp,s>647:cz,A}
kf{a<2869:R,m<1983:R,A}
zf{m>1116:vh,m<741:ljn,xz}
npl{m<604:R,x<2557:A,s>3273:A,lzl}
hxj{x>1696:lgt,hxt}
bk{m>2024:kqk,m>1977:A,A}
cgf{m>1839:mdc,nk}
fj{s<3773:R,A}
tvz{m<725:A,R}
nsd{a>549:A,rm}
ptj{a>2544:R,s<474:R,R}
jcf{a>3207:R,R}
jf{x>1679:R,hmd}
frc{a>3423:R,s<3574:R,R}
fs{s<2535:R,s>2554:R,s>2547:R,R}
gkt{x<3699:A,s<1808:R,R}
lk{x>1920:vgq,x<915:vc,s>911:dcg,pjd}
cpv{s<84:R,A}
hr{m>3382:mdn,x<1457:cph,vp}
fm{x<1347:kxk,dl}
rh{m>1468:A,a<3525:ngz,R}
bj{x>574:R,a<2312:A,R}
qqj{x>1087:R,A}
vs{x>1075:vcd,m<1978:jv,jr}
clk{x<444:R,m<2947:A,s<3126:A,A}
qrq{s>2012:R,a<1950:A,A}
blm{m<1460:rj,m>2331:pxx,s<1091:bmk,kq}
bh{x>1415:hj,a>1216:tr,cj}
qq{a<3194:qdz,rg}
pqb{s<3296:A,R}
lj{s<3684:R,s<3855:R,a<3556:R,A}
ktn{a>3308:R,x>2669:A,A}
bxg{a>1442:A,a>1347:A,A}
ksd{s<3546:mr,rhb}
pt{x<1007:A,s<3086:R,a<2912:R,R}
rtk{a<2468:A,s>1601:A,R}
tck{a>1635:tlj,m<329:xhx,hc}
jzc{a<1524:zrf,m>1067:pr,x>1870:bls,rrx}
csz{a>762:bnz,x<3126:qv,s>1898:csr,skm}
qps{a>615:cjf,s>671:pm,s>240:dbl,nl}
lp{x<3084:A,s<3733:A,R}
blx{m>131:R,R}
ctt{a<3522:nxf,x>1395:cnb,jzr}
xrp{x<574:R,m<1446:R,A}
sm{m<795:ptj,m>883:R,x<3307:A,sbd}
plc{x>559:R,a>3782:R,s>3878:R,A}
bnx{m<1013:A,A}
dz{s<3377:R,m>2092:R,A}
fpz{m>695:tvz,s<3213:qnp,a<1023:R,R}
mcm{a<540:A,R}
vgq{x<3260:xp,blm}
hrl{s>571:fcr,a>3310:lms,a>3059:dn,cc}
sgr{a<2253:R,a>2477:R,x>1631:A,R}
kbm{a<773:R,x<500:xs,A}
dmc{x>811:ddf,m>1293:ckz,R}
jx{x<147:A,s<3246:R,A}
xbr{s<3780:A,A}
cz{m>3005:A,x<1279:A,R}
zh{m>2724:R,A}
mx{a>2368:R,s<2360:R,x<3285:A,R}
pz{x>1619:A,a>965:R,x<1449:A,R}
rt{a>1181:R,x>2446:R,A}
lbk{a>2730:fz,hs}
cpm{a<3279:rsn,m<1164:dcz,x>1415:mcq,rh}
km{m>3737:A,a>3725:R,R}
qzx{s>1504:R,s>1454:R,x<415:A,A}
hp{x<2493:R,s<1127:A,R}
sj{m>683:R,x<1742:A,s<2208:R,A}
rs{m<1908:tnp,x<1393:R,A}
xp{m>1774:ktn,a<3517:bq,gj}
cbr{a>2266:R,m<819:A,A}
gcm{a<3170:A,a<3297:R,R}
kj{s>3251:bnk,x<3524:A,A}
lxb{a<536:A,a>630:R,s<1570:A,R}
rsn{m<1293:R,R}
jbk{x>3170:A,a>1074:R,A}
zv{x>2404:A,s>457:jmf,A}
jps{a<593:R,ggb}
mth{x>3569:gbv,ds}
mgd{s>2772:R,x<173:A,A}
rnh{x>460:vn,x>266:pl,a<2800:hvz,R}
psj{s<3000:R,s<3141:A,R}
qcb{x<798:A,x>1338:A,A}
shf{s<2342:R,A}
bgd{m>2415:nzb,s>3123:ld,lcl}
mlt{s<3301:A,m>2092:R,A}
vtt{a<2787:R,m<1501:A,R}
gk{a<815:A,s>2886:R,R}
vnq{x<655:A,s<3763:R,A}
spg{a<1477:R,R}
kqk{a>986:R,A}
zrf{a>904:gg,m<1153:ljh,s<1804:jld,cpd}
ltl{x>1025:mh,a<2706:mlt,mq}
kkc{a<1939:R,a>1966:R,A}
pk{s<3412:fzf,a>3726:hxs,qrp}
jct{x>2955:A,czg}
pbh{a>1099:A,R}
bkc{x<994:R,R}
lmm{m>3383:R,a>2887:A,A}
jjm{a>2703:lbk,fpj}
td{x<247:mpf,s>3739:tzv,gf}
mdn{a<3498:R,R}
st{s<3009:A,a>1143:rt,a<1107:rgz,qzr}
sts{a<1200:R,m<87:A,m>132:A,A}
pr{x>2249:dtm,qzz}
ds{s<3752:A,R}
dmp{m<3305:R,a<463:A,m<3681:cm,R}
sdr{a>3376:vdv,zbv}
nst{s>2046:cbr,mfn}
mk{a<388:R,pmb}
pkf{s>499:mv,A}
szs{m<3349:sq,a>718:A,gc}
zs{m<2661:R,A}
vp{x>1477:R,s>2269:R,A}
dl{s<1214:R,qp}
lb{x<3138:A,a>2670:R,R}
kl{m>3862:A,x>1259:mqj,x<1033:zn,blf}
hlx{a<2205:R,x>3579:A,s<1636:A,R}
hz{x>1358:A,x<1311:R,A}
lv{s>424:R,a>3455:R,m>513:A,A}
qs{a<3308:A,x>723:R,R}
gqc{x<2158:R,s<1851:R,R}
mpf{a>3792:A,a>3662:mml,a>3577:R,xk}
dm{m>3103:A,x<1276:R,A}
vq{s>2244:hz,x>1360:A,A}
rrx{s>1629:nst,s>1413:xnv,dq}
hxg{x<324:mgd,x<469:dj,gr}
pj{a<3150:A,a<3454:A,x>1606:A,R}
gjs{a<2848:A,x<651:A,R}
nbz{x<2579:rtg,bvg}
tkj{x<2510:zx,x>3340:blx,a>1123:ggs,ctb}
rk{m<105:A,s<2581:R,s>3343:A,R}
gr{s>2781:R,m>938:A,a<3798:A,A}
zlr{s>2444:A,R}
qzq{x>260:R,s>2233:R,A}
qb{a<3400:tv,x<1211:lbl,s<3532:A,A}
jkl{a>569:R,a>219:A,A}
kd{a<332:A,s>1163:A,a<441:A,R}
ztq{s<1701:xg,s>1889:dmp,x>944:szs,kbm}
vtl{s<1362:R,m>1164:R,s>1500:A,A}
tj{x>3274:A,s<708:A,a<1760:R,A}
dhp{a>3146:qzq,R}
bn{x<466:R,A}
jv{a<3111:R,bkc}
pjd{m<2011:cpm,hrl}
fh{a<3064:R,s<2885:jt,x>920:R,clk}
gf{s>3568:A,jcs}
cnb{x>2602:bgd,lpq}
rjs{x<3342:A,x>3570:R,a<1033:A,R}
sl{m>1009:fvp,spg}
dd{a<3115:A,R}
hl{a<3182:R,x<2541:A,s>1661:R,A}
zc{m>3224:R,x<1402:A,R}
jhv{a>2713:A,nh}
rjx{s>715:R,s<450:R,R}
bp{a>3418:R,a>2981:A,R}
rj{m>817:bp,A}
mmc{a>2356:bsh,A}
jzr{x>627:pk,s<3294:jjc,td}
hj{a<1124:R,A}
lpx{x>1886:R,s<521:R,a<379:A,R}
vxl{x>1956:A,R}
ncl{m>2887:A,A}
hxs{a>3893:zgx,a>3783:A,R}
xv{a>245:A,lg}
pfl{a<440:R,A}
jhd{a<2796:A,a<2813:R,A}
vjn{x<2270:R,s<1166:A,A}
gdk{a>2886:qds,x>1553:jkf,gmg}
ljv{m>954:A,bqt}
rf{m<2314:A,R}
zpb{s>1717:A,a>434:R,A}
xgr{s<2801:gd,x>2319:tb,nv}
ln{a<3324:A,a<3448:A,x>1756:R,A}
ntl{s<1540:R,x<2910:A,x>3423:A,R}
fg{m<3195:R,A}
kq{m<1917:R,A}
mln{m>674:dtc,x<3229:tl,s<3218:A,A}
sjq{x<2421:R,s<3380:zz,lp}
rpm{s>67:R,x<2573:A,A}
jc{s<799:A,m>3802:A,R}
lvq{x>3719:A,s<3613:ghp,a<1156:R,A}
cc{m>3325:A,m<2610:R,m>3049:zc,xxd}
kxk{m<1500:A,a>3205:R,m<2576:R,lmm}
qqs{s>3227:A,s>2736:R,x<2614:kqb,kbt}
lzl{a>399:R,A}
sh{x<2261:R,R}
pzx{a<1051:R,R}
mrc{x<2382:R,a<693:A,R}
sx{x>3458:A,A}
sv{a>2471:krx,a<2306:A,a<2413:mx,A}
jmf{a<292:R,m>1008:A,A}
hs{m<2526:R,x>2622:R,R}
ljn{m>627:pf,m>586:cfj,bh}
mq{x>903:A,s>3293:A,R}
gc{a<365:A,a<570:R,R}
zjx{m>2207:R,R}
kqb{m<602:R,A}
xr{s<3802:R,R}
lhx{m>3170:A,rgl}
kct{a<1891:ttc,zm}
vn{a>2795:A,s<3343:A,A}
bvg{a>1980:A,R}
tzr{a>2885:A,s<3105:R,A}
ghp{s>3260:A,A}
ljh{m>884:zpb,A}
crk{s<1819:zgv,m<3162:lz,a<1774:kh,nx}
ttc{x<2046:R,A}
hmd{a<2368:R,m>1132:R,x<1075:A,A}
tb{s>3294:R,s>2982:A,x<3285:A,R}
skm{s>1721:gkt,a>382:lxb,s>1637:A,A}
bmk{x<3657:fl,a<3341:R,R}
frf{m<2252:xmx,s<1800:bb,x>515:sdr,dhp}
grp{a>1183:R,x>2651:R,R}
qzr{a>1128:R,a>1121:A,A}
xxd{x>1538:A,a>2807:R,s<361:R,A}
nvs{s<2686:R,a>148:R,A}
sbd{a>2540:R,a>2502:A,x<3553:R,R}
rmb{x<949:A,x<1340:R,R}
sbh{x>3465:zxc,m>810:A,qrq}
kmc{m>2641:mqh,R}
ks{m<1434:vq,m<2308:rs,x>1362:hr,rzc}
dxl{x>2295:R,a>2873:A,s<3812:A,R}
czp{m<90:A,x>3608:A,s<1450:A,R}
lbl{x>571:A,R}
mbj{x>2946:A,s<1470:cmf,x<2327:R,A}
jsn{s>871:A,x>2587:A,A}
qjg{s>3258:R,m>2447:A,x>549:A,A}
tq{s<2590:lk,a<3153:gdk,ctt}
qnp{s>2942:R,s<2748:R,R}
gnb{s>1449:R,a<3469:A,R}
xq{x<740:R,x>822:A,s>1796:A,R}
ddr{x>825:kmc,a<2829:rnh,hb}
nl{s<112:rpm,R}
bgz{s<3472:A,s<3715:frc,s>3840:R,fj}
xd{s<3101:bv,a<3302:jcf,s<3572:jh,xr}
rxc{m>891:A,A}
gj{m<673:R,zds}
nzb{m<3405:R,lbm}
gg{a<1286:mgs,m>935:bxg,x<2090:A,R}
lcg{m<1248:A,s>3297:A,s>2766:A,R}
gq{x<3301:mz,lvq}
cng{x>2558:rjs,x>992:sts,vfk}
gkl{m>2141:dfh,m<1900:db,x>1897:vd,sp}
zx{m>98:R,R}
jcs{m<1494:A,x<389:A,a>3699:A,R}
sdm{a>2317:A,R}
btg{s>1891:A,x<2144:A,s>906:A,R}
rq{x<2267:R,a<513:R,x<3300:A,A}
fpj{s>3216:lb,a>2662:R,s<2815:A,psj}
vd{a<417:xv,a>769:bk,jps}
qvd{a>1423:kct,a<832:cql,xkq}
nxf{m>2417:xd,rc}
rhb{a<3055:R,A}
hq{s>949:zd,vcn}
qv{a<270:nls,x<2596:A,R}
hv{a>116:A,a<67:R,s<2371:R,A}
ttv{a<3583:R,a<3757:R,s>500:R,A}
nv{a>1042:A,x<1348:A,R}
cgx{a>1726:A,A}
mz{s>3365:qqp,R}
jnn{x>2684:A,m<1408:R,A}
vf{x<715:A,A}
gfk{a<633:zv,a>1261:vxl,cr}
dcg{x<1256:vs,x>1509:hxj,s>1703:ks,fm}
mp{m>1507:jfk,m<526:cv,s>2468:zf,ctn}
mg{x<1958:A,a>1912:A,A}
hzc{s>3226:A,x>2499:A,a<2843:A,R}
nc{m<494:R,R}
vlr{a<1639:R,m>965:A,R}
xkx{s<2878:R,s<3070:R,A}
bb{a>3530:R,s<1510:A,R}
nh{x>1430:R,a>2684:A,m<2349:A,R}
dh{x<1024:R,A}
gmg{a>2772:ddr,cl}
cl{x<745:qmm,x<1185:ltl,jhv}
xkb{s<1903:R,x>2528:R,R}
cbb{m<1781:A,qr}
fr{s<3106:slq,R}
mh{m>2269:A,x<1093:A,a<2684:A,R}
cv{m<197:qvd,tck}
mlj{s<3617:pzx,sh}
dcz{a<3605:lv,a<3752:A,s<468:R,R}
vcn{s<524:R,x<1378:R,vqv}
kqs{x<1335:R,lr}
mcq{x>1676:ttv,A}
hxt{s<2024:gnb,m>1410:pj,m<736:R,dtj}
ld{s<3688:ggh,s<3793:A,m>1290:A,A}
xs{x>258:A,s<1774:R,R}
mfn{s<1906:R,A}
qfs{m>1437:R,R}
tx{a<3403:jzm,tn}
rct{m<1016:A,s<2621:R,R}
nd{s>3135:A,R}
jjc{s>2911:mhf,m<1665:hxg,x<348:qcr,lx}
gtq{m>961:xbr,m<830:A,x<507:A,vnq}
cx{m>268:A,A}
xf{x<345:A,s>3174:R,m<1739:A,A}
cbv{m>1242:A,m>1121:R,x>897:R,A}
zgv{x>2074:A,s>733:A,s<478:R,R}
dgf{x<494:rtk,x<648:bj,xq}
xg{x<795:A,s>1607:A,m>3324:R,dm}
tzv{m<1869:jhs,m>3270:km,x>493:plc,zs}
nt{a>3068:A,a<3045:A,R}
gbv{s<3584:R,s<3728:R,R}
qmm{m>2061:zh,R}
cr{x>1870:R,x>982:A,s<463:R,rl}
gxs{s>3087:A,m>385:A,a<280:R,rq}
ctq{a>987:R,R}
mfh{a>1105:ll,lm}
ff{x<1886:pt,m<1867:A,R}
ggb{a<657:R,a>714:R,R}
jkf{a<2776:jjm,a<2825:bhj,a<2860:hhd,jhl}
fdx{s>3342:R,R}
bls{s<1648:mbj,x>3066:sbh,nlk}
czg{s<3077:R,x<2514:A,R}
sxz{m<937:grp,s<2655:mll,m>1045:vsx,sl}
vqn{m<1679:R,a>2998:A,R}
vdv{s>2257:R,a<3750:A,s<2080:A,R}
nsx{s>1907:A,a>3246:A,A}
gd{x<2557:A,a>1050:R,s>2360:R,R}
vnp{x<1424:A,x>1732:A,A}
dtc{m>702:R,A}
glj{s>2917:A,A}
qt{s>3494:dxl,x<2302:kf,R}
xzk{a>296:R,x>2358:R,hv}
mls{s<2885:A,m>1811:A,A}
qvc{a<1613:gfk,a>2225:kfr,a<1820:xrc,nbz}
ctb{s>2109:R,A}
xz{s<3018:sxz,x>2273:gq,fnv}
lg{m<2007:A,m<2082:R,A}
lpq{s>3341:zjx,zxh}
jhh{m<3882:A,s<3163:mrc,s<3625:nm,R}
tc{a<3635:A,A}
gx{a<1752:A,x<2622:A,A}
mqj{a>2450:R,R}
bz{a>676:A,s>2182:A,R}
fnv{x>879:mfh,s<3449:ljv,a>1353:gtq,bxb}
zfm{x>3316:czp,R}
vsx{x>1654:jbk,s>2805:R,a>1136:ksl,hcz}
csr{m<3505:R,A}
mhf{s<3158:R,s<3205:xf,x<414:jx,qjg}
vc{s<1158:qq,frf}
qnv{m<696:R,R}
cm{m>3441:R,x<1223:R,x>1733:A,A}
jhl{x<3102:qt,a<2877:cs,a>2880:cn,cbb}
sq{a>671:A,s<1821:A,x>1635:R,R}
hvz{m>2461:R,A}
tr{m>563:R,R}
cgv{a<2538:R,A}
ps{x<1895:R,x>3216:R,A}
rm{s<3054:R,s>3470:A,m>1762:R,A}
qp{m<2013:A,s<1385:R,s>1514:R,A}
qj{m<3381:fg,m<3694:pqb,jhh}
qr{x<3568:A,m<2760:A,R}
tfs{s>433:A,x<1324:R,A}
cql{x<2048:rk,zfm}
fvp{m>1027:A,x<2630:R,x<3279:R,A}
tgt{a>1670:R,mnr}
tn{m>824:R,A}
fl{x<3396:A,A}
vv{s>3244:R,a<3126:dd,s<2826:rf,R}
lr{s<2004:A,R}
xhx{x<1756:scv,cx}
jzm{x>1343:A,x>703:R,a>3373:A,A}
tlj{s>1605:nbf,tdg}
xk{x>152:R,A}
mt{m<2968:qps,a>701:hq,lh}
zk{m>416:R,x>3052:A,x<2638:A,A}
zn{a<2399:A,A}
ggh{m<894:A,a>3830:A,a>3691:R,A}
ht{x<1797:A,s>2872:A,A}
jbl{m>1401:R,dp}
vfk{x<479:R,m>117:A,A}
qdz{s>554:R,s<239:cpv,R}
ll{s>3366:A,s<3226:A,R}
vbp{a<527:R,m>2007:gk,pz}
rhg{m<1474:A,a>1417:A,a<862:A,A}
in{a>2639:tq,mp}
bv{m<3468:ln,ht}
zgx{a>3932:R,a>3907:R,x>1109:R,R}
hx{a<449:jc,R}
cfj{a>1414:fr,a>556:sjq,a>190:npl,qqs}
mr{m<2693:A,A}
hcp{a>1108:R,R}
bf{x>3211:vv,hpl}
rtg{a>1997:rxc,jl}
qcr{x>162:A,x>74:A,s>2711:bjq,A}
xnv{m<724:sxc,x<921:qzx,a<2263:mn,lxc}
pbx{a>826:ctq,m<3306:A,zlr}
nlp{s>1893:A,R}
mfr{x<2238:R,R}
tg{a<2948:ff,kz}
tnp{a<3177:R,s>2055:A,A}
slq{m>611:R,A}
fz{m>2476:R,s>3368:R,s<2963:R,A}
rgz{a<1096:A,x<2237:R,R}
rg{x<396:R,a<3472:qs,R}
nm{x>2253:A,R}
mdc{x>1209:gz,s<3278:vf,A}
pbt{a>1678:A,x>3246:vlr,m<1092:R,R}
dbl{m<2274:R,m<2607:mc,lpx}
cn{a<2884:dz,x>3410:sg,s>3454:R,tzr}
hb{s>3486:R,a>2860:glj,x<378:A,gjs}
nls{a<134:A,s>1825:R,m<3471:A,A}
tl{s>3434:A,A}
bl{a<555:R,a>1174:A,R}
mml{a<3707:A,R}
dtm{x>2903:hlx,a>1934:xkb,nlp}
rb{a>379:A,x<2450:nvs,a>224:A,sx}
pf{x<1899:fpz,mln}
zmn{m>882:A,a>2320:R,a>2208:R,A}
jh{x<2603:fdx,R}
crh{a>1398:xkx,s>2903:gbg,R}
fmp{a>709:R,x<507:A,s>2752:R,A}
sg{m>1527:R,R}
sp{x>1242:vbp,fmp}
cj{m<564:A,x<900:A,R}
khv{s>2714:qj,s>2119:xfp,x>2174:csz,ztq}
lsz{m<3503:A,A}
dfh{a<612:rb,a<1008:mfr,a>1087:st,xgr}
lm{x>1566:R,s>3634:A,m<917:A,A}
hn{x>1169:R,nt}
pp{x>2075:jct,m<1540:hn,s>3287:ksd,fh}
ddf{s>3058:A,A}
mn{x>1509:R,R}
hc{m>452:nc,s<2479:hml,a>714:crf,gxs}
lgt{x>1822:A,m>1939:R,s>1685:sj,vtl}
pmb{x<1257:R,R}
bq{m>749:hl,a<2978:R,m>283:A,gcm}
dj{x>419:R,m>890:A,m<591:R,R}
lz{m>2383:R,a<1605:A,nd}
rlz{x<908:dgf,m<2926:mmc,m>3586:kl,kqs}
lbs{m<1371:lcg,m>1435:rhg,jnn}
hml{m<403:jkl,x<2272:R,m<428:zk,bl}
ckz{s<3014:R,m>1426:A,a>431:A,A}
ft{x<2599:R,A}
mxb{x<3119:lbs,s>3317:mth,crh}
vh{x>2169:mxb,npb}
rc{a<3327:jbl,x>2380:bgz,s<3109:tx,qb}
zm{m<76:btg,R}
jhs{a<3796:A,a<3916:R,a>3966:R,A}
hhd{x>2759:kj,x<2163:qfs,nr}
zds{m<1380:R,R}
zd{a>899:pbh,vjn}
xvn{s>2657:pfl,R}
{x=6,m=309,a=1182,s=757}
{x=531,m=106,a=1009,s=142}
{x=3264,m=506,a=301,s=807}
{x=1197,m=394,a=351,s=1266}
{x=3009,m=1048,a=143,s=1549}
{x=617,m=1696,a=778,s=28}
{x=172,m=2243,a=1135,s=2330}
{x=309,m=457,a=1943,s=8}
{x=424,m=100,a=288,s=1745}
{x=282,m=138,a=2134,s=272}
{x=2982,m=2488,a=1452,s=3065}
{x=1760,m=2317,a=3608,s=119}
{x=682,m=303,a=1113,s=34}
{x=806,m=3417,a=720,s=1219}
{x=908,m=2564,a=1065,s=766}
{x=1044,m=70,a=511,s=1410}
{x=848,m=262,a=1100,s=778}
{x=1042,m=1887,a=2083,s=847}
{x=1051,m=1636,a=187,s=892}
{x=782,m=489,a=1940,s=18}
{x=33,m=1970,a=838,s=1123}
{x=20,m=2180,a=2036,s=1720}
{x=468,m=788,a=170,s=983}
{x=1893,m=1399,a=1661,s=1493}
{x=42,m=604,a=2889,s=219}
{x=109,m=56,a=1004,s=2498}
{x=1249,m=213,a=329,s=117}
{x=544,m=380,a=124,s=1479}
{x=1222,m=996,a=498,s=2270}
{x=38,m=228,a=59,s=1060}
{x=17,m=613,a=2060,s=1358}
{x=188,m=976,a=100,s=1415}
{x=965,m=641,a=1563,s=2718}
{x=867,m=386,a=1798,s=682}
{x=1596,m=350,a=143,s=167}
{x=390,m=2438,a=225,s=171}
{x=1014,m=1030,a=718,s=2678}
{x=473,m=2034,a=1270,s=449}
{x=2092,m=268,a=653,s=691}
{x=951,m=16,a=1869,s=2764}
{x=494,m=154,a=178,s=1323}
{x=2653,m=1230,a=238,s=787}
{x=922,m=1420,a=1390,s=2030}
{x=2958,m=2763,a=1486,s=2822}
{x=615,m=373,a=31,s=1548}
{x=1275,m=1486,a=2205,s=171}
{x=1,m=2571,a=234,s=1346}
{x=945,m=107,a=99,s=754}
{x=1398,m=1428,a=556,s=1724}
{x=693,m=3354,a=3,s=218}
{x=1706,m=39,a=1620,s=1403}
{x=465,m=408,a=2153,s=651}
{x=1026,m=794,a=340,s=920}
{x=1275,m=1806,a=120,s=599}
{x=78,m=1030,a=1601,s=1019}
{x=2442,m=1645,a=331,s=69}
{x=1797,m=480,a=479,s=1634}
{x=135,m=1838,a=216,s=1293}
{x=1914,m=1031,a=53,s=23}
{x=2862,m=303,a=883,s=537}
{x=60,m=192,a=109,s=1577}
{x=527,m=629,a=103,s=136}
{x=66,m=1861,a=135,s=1026}
{x=105,m=678,a=2551,s=495}
{x=2558,m=33,a=322,s=1359}
{x=2032,m=376,a=39,s=857}
{x=929,m=1035,a=174,s=2372}
{x=731,m=156,a=26,s=2512}
{x=1120,m=880,a=500,s=1070}
{x=845,m=108,a=1492,s=1340}
{x=2460,m=2527,a=1057,s=1382}
{x=390,m=942,a=953,s=402}
{x=557,m=440,a=335,s=426}
{x=1850,m=3068,a=1956,s=258}
{x=351,m=296,a=222,s=181}
{x=27,m=389,a=650,s=999}
{x=1941,m=3377,a=1600,s=1377}
{x=62,m=2099,a=9,s=25}
{x=34,m=658,a=215,s=32}
{x=1408,m=989,a=54,s=560}
{x=969,m=431,a=634,s=856}
{x=75,m=678,a=1523,s=157}
{x=1087,m=837,a=763,s=118}
{x=112,m=904,a=3317,s=313}
{x=2163,m=1100,a=271,s=882}
{x=474,m=289,a=305,s=197}
{x=1307,m=2741,a=279,s=1550}
{x=1109,m=629,a=1600,s=298}
{x=868,m=815,a=2970,s=21}
{x=1850,m=285,a=1158,s=373}
{x=1430,m=1078,a=226,s=2374}
{x=296,m=413,a=1609,s=1099}
{x=11,m=3105,a=505,s=2170}
{x=2126,m=1961,a=389,s=1087}
{x=592,m=1842,a=1991,s=1083}
{x=93,m=1662,a=1840,s=2377}
{x=433,m=30,a=1269,s=857}
{x=1898,m=662,a=861,s=1131}
{x=2484,m=278,a=1782,s=134}
{x=102,m=1146,a=3527,s=2090}
{x=2530,m=727,a=1577,s=211}
{x=316,m=2957,a=18,s=730}
{x=492,m=183,a=624,s=1454}
{x=3325,m=30,a=1660,s=938}
{x=407,m=1854,a=99,s=326}
{x=1336,m=1276,a=473,s=24}
{x=1718,m=438,a=956,s=384}
{x=353,m=1534,a=2180,s=2974}
{x=2705,m=211,a=94,s=837}
{x=104,m=123,a=413,s=1789}
{x=176,m=395,a=2652,s=50}
{x=738,m=1018,a=103,s=200}
{x=750,m=31,a=916,s=121}
{x=2967,m=1253,a=1593,s=1357}
{x=262,m=112,a=131,s=63}
{x=145,m=807,a=291,s=959}
{x=1476,m=239,a=1054,s=3491}
{x=428,m=351,a=2465,s=65}
{x=35,m=236,a=863,s=1089}
{x=1233,m=2010,a=177,s=764}
{x=1083,m=1863,a=25,s=1974}
{x=957,m=1180,a=837,s=679}
{x=66,m=1204,a=285,s=2075}
{x=444,m=560,a=172,s=1447}
{x=812,m=350,a=876,s=661}
{x=200,m=366,a=752,s=851}
{x=749,m=377,a=815,s=648}
{x=60,m=285,a=517,s=39}
{x=2921,m=381,a=119,s=249}
{x=466,m=1290,a=801,s=2159}
{x=62,m=201,a=881,s=95}
{x=3598,m=126,a=1688,s=979}
{x=2963,m=1112,a=2733,s=520}
{x=62,m=1067,a=920,s=451}
{x=2501,m=475,a=1074,s=1150}
{x=50,m=1111,a=12,s=44}
{x=617,m=1106,a=1489,s=1333}
{x=90,m=208,a=219,s=2352}
{x=1179,m=2166,a=1693,s=2055}
{x=61,m=595,a=1382,s=1140}
{x=62,m=354,a=123,s=793}
{x=436,m=865,a=2408,s=2578}
{x=515,m=398,a=303,s=312}
{x=637,m=2236,a=474,s=148}
{x=2488,m=35,a=75,s=924}
{x=461,m=1196,a=7,s=1092}
{x=923,m=3184,a=1161,s=308}
{x=191,m=1399,a=1324,s=2784}
{x=170,m=421,a=51,s=625}
{x=170,m=362,a=471,s=2100}
{x=289,m=66,a=143,s=284}
{x=542,m=339,a=455,s=54}
{x=155,m=124,a=732,s=2057}
{x=8,m=420,a=784,s=1455}
{x=479,m=251,a=1883,s=136}
{x=104,m=146,a=97,s=249}
{x=2766,m=833,a=386,s=585}
{x=373,m=514,a=466,s=2192}
{x=296,m=1190,a=249,s=963}
{x=518,m=1840,a=860,s=306}
{x=1003,m=1955,a=756,s=1098}
{x=1545,m=242,a=1479,s=576}
{x=77,m=1717,a=475,s=1692}
{x=417,m=1517,a=2199,s=374}
{x=3247,m=348,a=1065,s=1154}
{x=456,m=868,a=182,s=1077}
{x=464,m=425,a=15,s=781}
{x=640,m=294,a=303,s=261}
{x=1018,m=327,a=18,s=1830}
{x=262,m=988,a=1974,s=1665}
{x=123,m=525,a=3062,s=460}
{x=228,m=2020,a=29,s=701}
{x=129,m=1163,a=1561,s=958}
{x=29,m=1576,a=74,s=348}
{x=64,m=2153,a=63,s=1771}
{x=71,m=66,a=1642,s=1749}
{x=1373,m=3063,a=1958,s=561}
{x=2277,m=3766,a=384,s=363}
{x=2956,m=127,a=865,s=1862}
{x=599,m=115,a=2360,s=526}
{x=651,m=644,a=580,s=514}
{x=880,m=173,a=613,s=3270}
{x=1228,m=951,a=1515,s=333}
{x=1621,m=2392,a=2665,s=1515}
{x=933,m=1805,a=228,s=1720}
{x=25,m=1553,a=54,s=3177}
{x=85,m=550,a=273,s=142}
{x=489,m=624,a=126,s=557}
{x=256,m=2513,a=509,s=186}
{x=2616,m=377,a=2497,s=707}
{x=688,m=509,a=410,s=557}
{x=1306,m=105,a=1605,s=3217}
{x=1405,m=31,a=824,s=543}
{x=600,m=559,a=1299,s=110}
{x=2683,m=1112,a=458,s=27}
{x=1240,m=882,a=417,s=1066}
{x=651,m=667,a=178,s=3045}
{x=2089,m=19,a=879,s=90}
{x=263,m=423,a=41,s=734}
{x=630,m=44,a=135,s=98}