anchor.diff:    ;; As...'), a file containing the encrypted ASCII codes, and the knowledge
     ;; that the plain text must contain common English words, decrypt the message
     ;; and find the sum of the ASCII values in the original text.
  -  (let* ((data (-<> "data/59-cipher.txt"
  +  (let* ((data (-<> "data/059-cipher.txt"
                    read-file-into-string
                    (substitute #\space #\, <>)
                    read-all-from-string))
  
positive.code:   ;;
    ;; What is the total of all the name scores in the file?
    (labels ((read-names ()
               (-<> "data/22-names.txt"
                 parse-strings-file
                 (sort <> #'string<)))
             (name-score (name)
  
negative.code:     (* 28433 <>)
      1+
      (mod <> (expt 10 10))))
  
  (defun problem-102 ()
    ;; Three distinct points are plotted at random on a Cartesian plane, for which
    ;; -1000 ≤ x, y ≤ 1000, such that a triangle is formed.
    ;;
    ;; Consider the following two triangles:
    ;;
    ;;     A(-340,495), B(-153,-910), C(835,-947)
    ;;
    ;;     X(-175,41), Y(-421,-714), Z(574,-645)
    ;;
    ;; It can be verified that triangle ABC contains the origin, whereas triangle
    ;; XYZ does not.
    ;;
    ;; Using triangles.txt (right click and 'Save Link/Target As...'), a 27K text
    ;; file containing the co-ordinates of one thousand "random" triangles, find
    ;; the number of triangles for which the interior contains the origin.
    ;;
    ;; NOTE: The first two examples in the file represent the triangles in the
    ;; example given above.
    (labels ((parse-file (file)
               (iterate (for line :in-file file :using #'read-line)
                        (for (ax ay bx by cx cy) =
                             (mapcar #'parse-integer (cl-strings:split line #\,)))
                        (collect (list (cons ax ay)
                                       (cons bx by)
                                       (cons cx cy)))))
             (find-side-vertical (a b p)
               "Return which side of the line AB point P falls on."
               (destructuring-bind (ax . ay) a
                 (destructuring-bind (bx . by) b
                   (if (= ax bx)
                     (find-side-horizontal a b p)
                     (destructuring-bind (px . py) p
                       (let* ((slope (/ (- ay by)
                                        (- ax bx)))
                              (y-intercept (- ay (* slope ax)))
                              (line-y (+ y-intercept (* slope px))))
                         (cond
                           ((> py line-y) :above)
                           ((< py line-y) :below)
                           ((= py line-y) :on))))))))
             (find-side-horizontal (a b p)
               "Return which side of the line AB point P falls on."
               (destructuring-bind (ax . ay) a
                 (destructuring-bind (bx . by) b
                   (if (= ay by)
                     (find-side-vertical a b p)
                     (destructuring-bind (px . py) p
                       (let* ((slope (/ (- ax bx)
                                        (- ay by)))
                              (x-intercept (- ax (* slope ay)))
                              (line-x (+ x-intercept (* slope py))))
                         (cond
                           ((> px line-x) :right)
                           ((< px line-x) :left)
                           ((= px line-x) :on))))))))
             (check-line (a b c p)
               (let ((result-triangle (find-side-vertical a b c))
                     (result-point (find-side-vertical a b p)))
                 (or (eq result-point :on)
                     (eq result-point result-triangle))))
             (check-triangle (a b c)
               (let ((origin (cons 0 0)))
                 (and (check-line a b c origin)
                      (check-line c a b origin)
                      (check-line b c a origin)))))
      (iterate (for (a b c) :in (parse-file "data/102-triangles.txt"))
               (counting (check-triangle a b c)))))
  
  (defun problem-145 ()
    ;; Some positive integers n have the property that the sum [ n + reverse(n) ]
  