gistfile1.txt

read-input = READ_BYTE
print-byte = PRINT_BYTE

Z = λf.(λx.(x x) λx.(f λy.((x x) y)))
fix = Z

make-pair = λa.λb.λf.(f a b)
fst = λp.(p (λx.λy.x))
snd = λp.(p (λx.λy.y))

const = λx.λy.x
id = λx.x
to-cont = λval.λcont.(cont val)

nil = λonNil.λonCons.(onNil void)
nil? = λls.(ls (const true) (λl.λls.false))
cons = λl.λls.λonNil.λonCons.(onCons l ls)
head = λls.(ls void fst)
tail = λls.(ls void snd)
match = id

let = λx.λy.(y x)
U = λf. (f f)
omega = λ_.(U U)
void = omega
; = omega

true = λt.λf.t
false = λt.λf.f
not = λb.λt.λf.(b f t)
and = λa.λb.(a b false)
if = λp.λa.λb.((p a b) p)
else = id

zero? = λa. (a (const false) true)
succ = λn.λp.λz.(p(n p z))
+ = λn.λm.(n succ m)
* = λn.λm.λp.(n (m p))
/ = (fix λ/.λn.λm.
  (if (eq? n m)
      λ_. 1
      λ_. (if (le? n m)
              λ_. 0
              λ_. (+ 1 (/ (- n m) m)))))
% = λn.λm. (- n (* (/ n m) m))
pred = λn.λp.λz.(n (λapply-to-acc. (to-cont (apply-to-acc p))) (const z) id)
- = λn.λm.(n pred m)
0 = λp.λz. z
1 = λp.λz. (p z)
2 = λp.λz. (p (p z))
3 = λp.λz. (p (p (p z)))
4 = λp.λz. (p (p (p (p z))))
5 = λp.λz. (p (p (p (p (p z)))))
6 = λp.λz. (p (p (p (p (p (p z))))))
7 = λp.λz. (p (p (p (p (p (p (p z)))))))
8 = λp.λz. (p (p (p (p (p (p (p (p z))))))))
9 = λp.λz. (p (p (p (p (p (p (p (p (p z)))))))))
10 = λp.λz. (p (p (p (p (p (p (p (p (p (p z))))))))))
100 = (* 10 10)
num = λa.λb.λc.(+ (+ (* 100 a) (* 10 b)) c)
le? = λa.λb. (zero? (- b a))
ge? = λa.λb. (zero? (- a b))
eq? = λa.λb.(and (le? a b) (ge? a b))
gt? = λa.λb. (not (le? a b))
lt? = λa.λb. (not (ge? a b))

ascii-0 = (num 0 4 8)
itoa = ((fix λloop.λacc.λcur.
    (if (zero? cur)
        λ_. (if (nil? acc)
               λ_. (cons ascii-0 nil)
               λ_. acc)
        λ_. (loop (cons (+ ascii-0 (% cur 10)) acc) (/ cur 10))))
    nil)

+, = λp1.λp2.(make-pair (+ (fst p1) (fst p2)) (+ (snd p1) (snd p2)))
-, = λp1.λp2.(make-pair (+ (fst p1) (snd p2)) (+ (fst p2) (snd p1)))
*, = λp1.λp2.(make-pair (+ (* (fst p1) (fst p2)) (* (snd p1) (snd p2))) (+ (* (fst p1) (snd p2)) (* (snd p1) (fst p2))))

int = λn. (make-pair n 0)
neg = λp. (make-pair (snd p) (fst p))
-1, = (neg (int 1))
1, = (int 1)
0, = (int 0)
simplify = (fix λloop. λi.
    (if (or (zero? (fst i)) (zero? (snd i))) λ_.i
    (else λ_.(loop (make-pair (pred (fst i)) (pred (snd i)))))))
abs = λi. (let (simplify i) λs. (+ (fst s) (snd s)))
neg? = λi. (gt? (snd i) (fst i))

do2 = λ_.λx.x
print-list = (fix λloop.λls.λafter.
    (match ls
        λ_. after
        λx.λxs. (do2 (print-byte x)
                 (loop xs after))))

is-eof? = λls. (or (nil? ls) (zero? (snd ls)))
charVal = snd

read-all = (Y λloop.λ_.
    (let (READ_BYTE void) λb.
    (if (nil? b)
      λ_.(nil)
      λ_.((cons (charVal b) (loop void))))))

max-by = λgt?.λls.
    ((fix λloop.λacc.λls.
        (match ls
            λ_.acc
            λx.λxs.
                (if (gt? x acc)
                    λ_.(loop x xs)
                (else
                    λ_.(loop acc xs))))
      ) (head ls) (tail ls))

print-then = λi.λafter. (do2 (print-byte i) after)

newline = (print-then (num 0 1 0))
prenL = (print-then (num 0 4 0))
prenR = (print-then (num 0 4 1))
comma = (print-then (num 0 4 4))
space = (print-then (num 0 3 2))
minus = (print-then (num 0 4 5))

showN = λi. (print-list (itoa i))
showI = λi.λafter.
    (if (zero? (fst i))
    λ_. (if (zero? (snd i))
        λ_.(showN 0 after)
        λ_.(minus (showN (snd i)) after))
    λ_.(showN (fst i) after))
showP = λp. (prenL (showI (fst p)) comma space (showI (snd p)) prenR)


map = λf. (fix λloop.λls.
    (match ls
        λ_. nil
        λx.λxs.
            (cons (f x) (loop xs))))

append = (fix λappend.λxs.λys.
    (match xs
        λ_.ys
        λa.λas.
            (cons a (append as ys))))

combinations = (fix λcombinations. λxs.
    (match xs
      λ_.nil
      λv.λvs.
        (append (map (make-pair v) vs) (combinations vs))))

lU = (num 0 8 5)
lD = (num 0 6 8)
lL = (num 0 7 6)
lR = (num 0 8 2)
lA = (num 0 6 5)
lB = (num 0 6 6)

shift-pair = λx.λy.λp. (make-pair (+, (fst p) x) (+, (snd p) y))

move-up = (shift-pair 0, 1,)
move-down = (shift-pair 0, -1,)
move-right = (shift-pair 1, 0,)
move-left = (shift-pair -1, 0,)

step-dir = λcur.λpos.
    (if (eq? cur lU) λ_.(move-up pos)
    λ_.(else if (eq? cur lD) λ_. (move-down pos)
    λ_.(else if (eq? cur lL) λ_. (move-left pos)
    λ_.(else if (eq? cur lR) λ_. (move-right pos)
    λ_.(else λ_. pos)))))

get-marks = 
    ((fix λloop. λcur-pos. λinput.
        (match input
          λ_. nil
          λcur.λrest.
            (if (or (eq? cur lB) (eq? cur lA))
                λ_.(cons cur-pos (loop cur-pos rest))
            (else
                λ_.(loop (step-dir cur cur-pos) rest)))))
     (make-pair (int 0) (int 0)))

taxi = λp. (+ (abs (fst p)) (abs (snd p)))

max-taxi-origin = (max-by λa.λb.(gt? (taxi a) (taxi b)))
max-taxi-points = λls. (max-by gt? (map λp.(taxi (fst p) (snd p)) (combinations ls)))

main = λ_.
    (let (get-marks (read-all void)) λmarks.
    (let (max-taxi-origin marks) λex1.
    (let (max-taxi-points marks) λex2.
    ((showP ex1) comma space  (showN ex2) ;))))

(main void)