Common Lispで遅延評価を実装しよう

# はじめに
この記事はCommon Lispで純粋な**関数型プログラミング**をしようと考えた筆者の試行錯誤の一部を共有するためのものです．**遅延評価(lazy evaluation)**は関数型プログラミングをする際には避けては通れず，何度も実装するうちに共有するに値する知見が得られたと考えたので記事を書くことにしました．
Common Lispで有名な遅延評価ライブラリといえば[CLAZY](https://common-lisp.net/project/clazy/)などが挙げられますが，実装はそれほど難しくなく，マクロ定義の練習問題としても優秀なタスクですから，マクロを知ったばかりのCommon Lisp中級者もぜひ一度は自分の手で実装してみると良いでしょう．
前提知識としてCommon Lispの基本的な文法と初歩的なマクロの定義を要求しています．この記事をマクロの入門記事として読むこともできます．


## Common Lispと関数型プログラミング
しばしば「Common Lispは関数型言語の1つである」という主張がなされることがありますが，賛否両論のようです．確かに，C/C++，Java，Python，Scheme，OCaml，Haskellと一緒に並べてみたときにCommon Lispを関数型言語として分類したくなる気持ちもわかります．しかし，実際にコードを書いてみると，関数型のスタイルとはかけ離れたものになることは珍しくありません．Common Lispでは「極力関数型プログラミング」として次の規則が推奨されています．

1. 再代入などの**副作用(side effect)**を使わずに済むならば使わない．
2. 副作用でしかできない，または副作用によって可読性や効率が著しく向上する場合は使用する．
3. 副作用を使用する場合，その影響は極力関数内で完結させる．

要するに，関数内で完結する場合に限り，再代入を許しているわけです．もっとも，これは原則に過ぎず，効率や可読性のために破るべき場面というのもあります．Common Lispは関数型プログラミングの規則にそれほど従順な言語であるとは言えないでしょう．実際，この記事のコードも再代入を駆使しています．このことは良くも悪くもCommon Lispの柔軟さを示しています．Common Lispは関数型言語であることよりも，拡張性を選んでいるのです．

「Common Lispは関数型言語ではありません」という結論で終わっても良いのですが，「Common Lispでも関数型プログラミングをやりたい」と思うこともあるでしょう．筆者がそうです．Common Lispの拡張性を信じて，関数型プログラミングのための枠組みを自作してみようという試みの1つが遅延評価の実装になります．


## 関数型プログラミングと遅延評価
遅延評価は関数型プログラミングにおいて重要な位置を占めています．「関数型プログラミング」が何を指すのかは議論の余地がありますが，ここではひとまず「再代入を許さないプログラミングスタイル」のことだと思えばよいでしょう．関数型プログラミングのメリットとデメリットや手続き型プログラミングとの比較についてはここではひとまず置いておきますが，遅延評価を効果的に使っていこうと考えるならばよく理解しておく必要があるでしょう．なぜなら，「遅延評価は関数型プログラミングにおいて効率的に永続的データ構造を扱う」ために必要不可欠な手法であるからです．このことを理解していなくてもこの記事を読むことはできます．
詳しく知りたい人は[計算機プログラムの構造と解釈(SICP)の3.5節](https://sicp.iijlab.net/fulltext/x350.html)や[純粋関数型データ構造](https://asciidwango.jp/post/160831986220/%E7%B4%94%E7%B2%8B%E9%96%A2%E6%95%B0%E5%9E%8B%E3%83%87%E3%83%BC%E3%82%BF%E6%A7%8B%E9%80%A0)を読むことをオススメします．筆者は純粋関数型データ構造に登場するデータ構造をCommon Lispで実装でするために遅延評価の実装を始めたという経緯があります（実は最後まで読めていません）．


# サンク(thunk)
## `lambda`
この記事の読者ならば`lamda`のことはよくご存知でしょうし，好んで使っていることでしょう．実は`lambda`はある意味で遅延評価を行っていると解釈することもできます．

次の例では`lambda`は2つの引数の和を返す関数を作っています．

```common-lisp
(lambda (a b) (+ a b)) ; (+ a b)は未評価
```

`lambda`の中には`(+ a b)`という式が含まれますが，この時点ではまだ評価されていません．この関数に引数が与えられて初めて`(+ a b)`は評価されるのです．それでは，次の例はどうでしょうか．

```common-lisp
(lambda () (+ 2 7)) ; (+ 2 7)は未評価
(defparameter thunk (lambda () (+ 2 7))) ; (+ 2 7)は未評価
(funcall thunk) ; -> 9
```

この例でも1行目と2行目の`(+ 2 7)`は未評価になります．評価するために必要な情報は全て揃っているので評価しても良さそうなものですが，`lambda`のルールに従い，関数を作った時点では評価は行われません．3行目のようにこの関数を無引数で呼び出すと`(+ 2 7)`が評価され，`9`が返ることになります．このように「評価に必要な情報が全て揃っているのに未評価なオブジェクト」のことを**サンク(thunk)**といいます．無引数の`lambda`はサンクを作り出す構文であり，まさに遅延評価そのものなのです．

Common Lispに限らず，`lambda`やそれと同等の構文が存在する言語でこの方法は有効です．`(lambda () ...)`で評価を遅延し，`(funcall (lambda () ...))`で遅延された評価を強制することができます．

```common-lisp
(lambda () (+ 1 2 3)) ; (+ 1 2 3)は遅延されている
(funcall (lambda () (+ 1 2 3)) ; -> 6
```
無引数の`lambda`で評価を遅延できるとはいえ，毎回`(lambda () ...)`と書くのは可読性の観点からオススメできません．もっと明示的に遅延を表現したいものです．こういうとき，まずは関数で実装できるか考えましょう．関数名は`delay`が良さそうです．せっかくなのでサンクを評価する関数も作りましょう．関数名は`force`とします．

```common-lisp
(defun delay (expr)
  (lambda () expr))
(defun force (thunk)
  (funcall thunk))
```

こんな感じでしょうか．しかし，次の例を見れば失敗していることがわかります．

```common-lisp
(defparameter thunk
  (delay (princ 10))
; => 10
; -> THUNK
(force thunk)
; -> 10
```

`->`は返り値，`=>`は標準出力の結果を意味しています．`(delay (princ 10))`の時点で`10`が出力されてしまっているようです．それもそのはず，Common Lispでは，関数は引数から先に評価されるのです．`delay`が関数である限り，`(delay expr)`では遅延する前に`expr`が評価されてしまうのです．

`delay`を関数として実装するのは失敗でした．でも大丈夫．Common Lispには強力な**マクロ**があるのですから．

## マクロ
マクロとは何でしょう．一言で言えば「コードを評価前に書き換える機能」と表現できます．こう説明してしまうと他の言語でも同じことができそうなものですが，本物のマクロを備えているのはLispだけです．この記事でCommon Lispのマクロの真髄を説明し切ることはできないのですが，その片鱗は感じられるかもしれません．

Lispの重要な特徴として，カッコだらけの文法が挙げられます．Lispのことをよく知らない人にとっては煩わしい欠点として映るかもしれませんが，むしろこのカッコこそがLispに力を与えているのです．「カッコだらけの文法」を別の側面から見ると，「LispのコードはListのデータ（リストとアトム）である」ということができます．このことは`eval`関数が証明してくれています．

```common-lisp
(eval '(+ 2 3)) ; -> 5
(defparameter x 10)
(eval 'x) ; -> 10
```

`eval`は引数として受け取ったリストやアトムをCommon Lispのコードとして解釈し，評価してくれる関数です．このような「言語のコードが言語のデータでもある」性質のことを**同図像性(homo-iconicity)**といいます．

マクロに話を戻しましょう．`eval`はデータをコードとして解釈する関数でしたが，マクロは反対にコードをデータとして解釈して書き換えます．マクロの評価は次のように行われると考えてください．

1. `(macro arg)`は引数のコード`arg`をデータ（リストまたはアトム）として読み出し，**マクロ展開関数**に渡す．
2. マクロ展開関数は普通の関数と同じように`arg`を処理して値を返す．この処理は**マクロ展開(macro expand)**と呼ばれる．
3. マクロ展開関数の返した値はCommon Lispのコードとして評価される．

`delay`マクロを定義しながらこのことを見ていきましょう．

```common-lisp
(defmacro delay (expr)
  `(lambda () ,expr))

(defun force (thunk)
  (funcall thunk))
```

`defmacro`はマクロ展開関数を定義していると思ってください．`delay`のマクロ展開関数は，たとえばリスト`(+ 2 3)`をもらったらリスト`(lambda () (+ 2 3))`を返す関数であるようです．よって，`(delay (+ 2 3))`は次のように解釈できます．

1. コード`(+ 2 3)`をリストとして読み出し，`delay`のマクロ展開関数に渡す．
2. マクロ展開の結果，`(lambda () (+ 2 3))`が返る．
3. `(lambda () (+ 2 3))`がコードとして評価される．

それではマクロ版`delay`が本当に評価を遅延しているのか確認してみましょう．

```common-lisp
(defparameter thunk
  (delay (princ 10)))
; -> THUNK
(force thunk)
; => 10
; -> 10
```
`=>`は標準出力，`->`は返り値だと思ってください．ちゃんと評価が遅延しているのがわかります．
この`delay`マクロはCommon Lispのマクロ定義としては非常に簡単な例です．他の言語でも実装できるでしょう．

ここまでは`lambda`で評価を遅延し，マクロを使って`lambda`を簡潔な表現にできることを見てきました．


# メモ化
遅延評価はしばしば**メモ化(memoization)**とセットで語られます．次の例を見てみましょう．

```common-lisp
(defparameter x (+ 3 9)) ; ここで評価
(defparameter y (delay (+ 3 9))) ; まだ評価されていない
(princ x) ; 既に評価されている
(princ (force y)) ; ここで評価
(princ x) ; 既に評価されている
(princ (force y)) ; ここで評価
```

評価を遅延しなかった`x`の場合は評価の回数は1回ですが，遅延した`y`の場合は`(force y)`のたびに評価されます．これでは処理の重い計算を遅延した際にコストが嵩んでしまいます．そこで，遅延評価にメモ化を導入し，一度評価された後はキャッシュを参照するように定義を変更しましょう．メモ化の実装方法にはいくつかの選択肢があります．ここではクロージャ，構造体，クラスを用いた実装方法を紹介します．3つの実装はパフォーマンス的にはそれほど変わらないはずので，状況に合わせて利用すると良いでしょう．

この記事では今まで`(lambda () ...)`のような無引数の`lambda`をサンクと呼んできました．「メモ化されたサンク」のこともサンクと呼んで良いのですが，区別するために新しい用語として**プロミス(promise)**と呼ぶことにしましょう．サンクとプロミスは同じものを指すこともありますが，ここではあえて違うものとして扱います．

## クロージャによる実装
**クロージャ(closure)**とは**レキシカル変数(lexical variable)**を参照する関数のことです．クロージャとレキシカル変数は非常に興味深い概念ですが，ここではあまり踏み込まず，次のように`let`の中に`lambda`が含まれる式で作られる関数のことだと思いましょう．レキシカル変数は一種の**ローカル変数(local variable)**です．

```common-lisp
(let ((n 10))
  (lambda (x) (+ n x)))
```

この式は`x`を受け取って`(+ n x)`を返す関数を返します．ただし`n`の値は`10`です．次の例はクロージャの面白い性質を示しています．

```common-lisp
(let ((balance 100))
  (list (lambda () balance)
        (lambda (x) (setq balance (+ balance x)))
        (lambda (x) (setq balance (- balance x)))))
```

この式は3つのクロージャ（＝`let`内の関数）のリストを返します．1つ目の関数は無引数で`balance`の値を返します．2つ目の関数は引数`x`をとり，`balance`に`x`を足した値を代入します．3つ目の関数は引数`x`をとり，`balance`から`x`を引いた値を代入します．面白い点は，3つのクロージャが同じ局所変数を参照しているという点です．このクロージャのリストは次のように振る舞います．

```common-lisp
(defparameter account
  (let ((balance 100))
    (list (lambda () balance)
          (lambda (x) (setq balance (+ balance x)))
          (lambda (x) (setq balance (- balance x))))))

(funcall (first account)) ; -> 100
(funcall (second account) 10) ; -> 110
(funcall (first account)) ; -> 110
(funcall (third account) 40) ; -> 70
(funcall (first account)) ; -> 70
```

もちろん，この例は関数型プログラミングの範疇から逸脱しています．重要なのは3つの関数が同じ`balance`という変数を共有しているということと，`balance`が外からは見えないということです．この性質を応用すると，プロミス（＝メモ化されたサンク）を作ることができます．

```common-lisp
(let ((thunk (lambda () ...))
      (cache nil)
      (forced? nil))
  (lambda ()
    (unless forced?
      (setq cache (funcall thunk))
      (setq forced t))
    cache))
```

`...`には遅延させたい式が入ります．`thunk`は`(lambda () ...)`に束縛されており，今までサンクと呼んできたものと一致しています．`cache`は評価結果を入れておくための変数ですが，未評価の状態ではとりあえず`nil`に束縛されています．`forced`は評価が行われたかどうかを記録しておくための変数なので，初期値は`nil`になります．この関数が呼び出されると，まず`forced?`の値が確認されます．`forced?`が`nil`のときは未評価であることを意味しているので，`thunk`を読み出し，返り値を`cache`に保存します．評価が行われたので，`forced?`の値も`t`に変更しておきます．そして，最後に`cache`の値を返します．`forced?`が`nil`でないときは途中のステップを飛ばしてただ`cache`の値を返します．さらに，`thunk`，`cache`，`forced?`という変数たちは外からは決して見えないという点も重要です．

これを毎回書くのは`(lambda () ...)`を毎回書く以上に面倒です．前述した通り関数として`delay`を定義することもできません．こういうときはマクロでラップしてしまいましょう．

```common-lisp
(defmacro delay (expr)
  `(let ((thunk (lambda () ,expr))
         (cache nil)
         (forced? nil))
     (lambda ()
       (unless forced?
         (setq cache (funcall thunk))
         (setq forced? t))
       cache)))

(defun force (promise)
  (funcall promise))
```

できました！ ついでに`force`も定義しましたが，プロミスはただの無引数の関数に過ぎないので，実質`funcall`と同じです．

本当にメモ化されているのか試してみましょう．

```common-lisp
(defun fib (n)
  (if (<= n 1)
      1
      (+ (fib (- n 1)) (fib (- n 2)))))

(time (fib 40))
; => Evaluation took:
; =>   2.265 seconds of real time
; =>   2.257834 seconds of total run time (2.253533 user, 0.004301 system)
; =>   99.69% CPU
; =>   7,719,001,426 processor cycles
; =>   0 bytes consed
; -> 165580141

(time (delay (fib 40))
; => Evaluation took:
; =>   0.000 seconds of real time
; =>   0.000005 seconds of total run time (0.000005 user, 0.000000 system)
; =>   100.00% CPU
; =>   2,524 processor cycles
; =>   0 bytes consed
; -> 遅延された(fib 40)を意味する関数

(defparameter fib40 (delay (fib 40)))

(time (force fib40))
; => Evaluation took:
; =>   2.224 seconds of real time
; =>   2.224304 seconds of total run time (2.224304 user, 0.000000 system)
; =>   100.00% CPU
; =>   7,580,481,142 processor cycles
; =>   0 bytes consed
; -> 165580141

(time (force fib40))
; => Evaluation took:
; =>   0.000 seconds of real time
; =>   0.000005 seconds of total run time (0.000005 user, 0.000000 system)
; =>   100.00% CPU
; =>   4,902 processor cycles
; =>   0 bytes consed
; -> 165580141
```

確かに2回目の`(force fib40)`の呼び出しはメモ化のキャッシュを利用しているようです．

これでクロージャを使った遅延評価を実装できました．



## 構造体による実装
この節ではプロミスを`thunk`，`cache`，`forced?`という3つのスロットをもつ構造体として実装します．早速実装しましょう．

```common-lisp
(defstruct promise
  thunk cache forced?)

(defmacro delay (expr)
  `(make-promise :thunk (lambda () ,expr) :cache nil :forced? nil))

(defmethod force ((promise promise))
  (with-slots (thunk cache forced?) promise
    (unless forced?
      (setf cache (funcall thunk))
      (setf forced? t))
    cache))
```

ここでも`delay`はマクロとして実装されています．`delay`は任意の式を受け取るとサンクに変えてプロミスのインスタンスを生成します．このときの`cache`，`forced?`スロットの初期値はどちらも`nil`です．サンクやプロミスのクロージャ実装はどちらも関数だったので`force`は`funcall`と等価な実装になっていましたが，ここではメソッドとして定義しており，メモ化の仕組みも`force`内に実装されています．

クロージャ実装のときと同じように`fib`で試してみましょう．

```common-lisp
(time (delay (fib 40))
; => Evaluation took:
; =>   0.000 seconds of real time
; =>   0.000005 seconds of total run time (0.000004 user, 0.000001 system)
; =>   100.00% CPU
; =>   2,876 processor cycles
; =>   0 bytes consed
; -> 遅延された(fib 40)を意味するpromiseのインスタンス

(defparameter fib40 (delay (fib 40)))

(time (force fib40))
; => Evaluation took:
; =>   2.353 seconds of real time
; =>   2.352423 seconds of total run time (2.350984 user, 0.001439 system)
; =>   99.96% CPU
; =>   25 lambdas converted
; =>   8,017,128,998 processor cycles
; =>   1,177,904 bytes consed
; -> 165580141

(time (force fib40))
; => Evaluation took:
; =>   0.000 seconds of real time
; =>   0.000020 seconds of total run time (0.000020 user, 0.000000 system)
; =>   100.00% CPU
; =>   61,712 processor cycles
; =>   0 bytes consed
; -> 165580141
```

遅延とメモ化が確認されました．

## クラスによる実装
こちらはほとんど構造体と同じです．ささっと実装しましょう．

```common-lisp
(defclass promise ()
  ((thunk :initarg :thunk)
   (cache :initarg :cache)
   (forced? :initarg :forced?)))

(defmacro delay (expr)
  `(make-instance 'promise
                  :thunk (lambda () ,expr)
                  :cache nil
                  :forced? nil))

(defmethod force ((promise promise))
  (with-slots (thunk cache forced?) promise
    (unless forced?
      (setf cache (funcall thunk))
      (setf forced? t))
    cache))
```

`defclass`ではスロット`thunk`，`cache`，`forced?`をもつクラス`promise`を定義しています．このとき，`:initarg`を使って`make-instance`での初期値設定時のキーワードを決めています．キーワードはそれぞれ`:thunk`，`:cache`，`:forced?`です．クラスのコンストラクタは`make-instance`なので，`delay`は`make-instance`をラップするマクロとして定義しています．`force`は構造体のときと全く同じメソッド定義になっています．

`fib`でチェックしましょう．

```common-lisp
(time (delay (fib 40)))
; => Evaluation took:
; =>   0.006 seconds of real time
; =>   0.005641 seconds of total run time (0.005493 user, 0.000148 system)
; =>   100.00% CPU
; =>   18 lambdas converted
; =>   19,689,412 processor cycles
; =>   602,960 bytes consed
; -> 遅延された(fib 40)を意味するpromiseのインスタンス

(defparameter fib40 (delay (fib 40)))

(time (force fib40))
; => Evaluation took:
; =>   2.334 seconds of real time
; =>   2.334085 seconds of total run time (2.334085 user, 0.000000 system)
; =>   100.00% CPU
; =>   7,954,571,118 processor cycles
; =>   32,768 bytes consed
; -> 165580141

(time (force fib40))
; => Evaluation took:
; =>   0.000 seconds of real time
; =>   0.000059 seconds of total run time (0.000059 user, 0.000000 system)
; =>   100.00% CPU
; =>   186,380 processor cycles
; =>   0 bytes consed
; -> 165580141
```
遅延とメモ化が確認されました．


# 遅延リスト
ここからは`delay`と`force`を応用したデータ構造として，遅延リストを作りましょう．目標は無限リストを実装することします．ここでの`delay`と`force`の実装は上述の3つのうちどれでも構いません．


## `lcons`，`lcar`，`lcdr`
まずは`cons`，`car`，`cdr`の遅延リスト版を実装してみましょう．

```common-lisp
(defmacro lcons (se1 se2)
  `(delay (cons ,se1 ,se2)))

(defun lcar (lcons)
  (car (force lcons)))

(defun lcdr (lcons)
  (cdr (force lcons)))
```

`lcons`はマクロとして定義しています．せっかく遅延されたリストを作るのに，リストの要素が遅延されていなければあまり意味がありません．普通の関数として定義すると`se1`と`se2`の評価を遅延できないので，`lcons`はマクロでなければなりません．`lcons`はプロミスを返すので，`lcar`と`lcdr`は`force`してから`car`または`cdr`すれば良いことになります．こちらはただの関数で良いですね．


## 遅延リスト
Common Lispにおいて，リストの定義は`nil`または`cons`となっています．そこで，遅延リストは`nil`または`promise`ということにしましょう．`promise`は`force`したときに`cons`となるかはわかりませんが，ここでは簡単のために気にしないことにします．練習として`make-list`のように遅延リストを作る関数を定義してみましょう．

```common-lisp
(defun make-llist (n x)
  (if (zerop n)
      '()
      (lcons x (make-llist (1- n) x))))
```

`make-llist`を再帰的に定義しました．長さ`n`で全ての要素が`x`であるような遅延リストを作ります．普通のリストの関数のように定義できますね．もう少し練習問題をやってみましょう．遅延リストの`n`番目の要素を返す`lnth`と遅延リストの`0`番目から`n-1`番目までの要素を切り出してきてリストにして返す関数`ltake`を定義してみます．

```common-lisp
(defun lnth (n llist)
  (cond ((null llist) (error "out of index"))
        ((zerop n) (lcar llist))
        (t (lnth (1- n) (lcdr llist)))))

(defun ltake (n llist)
  (cond ((null llist) (error "out of index"))
        ((zerop n) '())
        (t (force (lcons (lcar llist) (ltake (1- n) (lcdr llist)))))))
```

`lcons`，`lcar`，`lcdr`が上手く詳細を隠してくれているおかげで苦なく遅延リストの関数を定義できます．


## 無限リスト
それでは無限リストを作る関数`make-inf-llist`を定義しましょう．

```common-lisp
(defun make-inf-llist (x)
  (lcons x (make-inf-llist x)))
```

`make-inf-llist`は全ての要素が`x`であるような遅延された無限リストを作ります．

```common-lisp
(lnth 0 (make-inf-llist 0))
; -> 0
(lnth 100 (make-inf-llist 0))
; -> 0
(lnth 100000 (make-inf-llist 0))
; -> 0
```

リソースが許す限りのインデックスの値にアクセスできます．

もう少し面白いことをしてみましょう．

```common-lisp
(defun llist-n->inf (n)
  (lcons n (llist-n->inf (1+ n))))

(defun lazy-remove-if (func llist)
  (cond ((null llist)
         '())
        ((funcall func (lcar llist))
         (lazy-remove-if func (lcdr llist)))
        (t
         (lcons (lcar llist) (lazy-remove-if func (lcdr llist))))))

(defun divide? (n m)
  (zerop (mod n m)))

(defun lazy-primes ()
  (labels ((primes (inf-lst)
             (lcons (lcar inf-lst)
                    (primes
                     (lazy-remove-if
                      (lambda (n) (divide? n (lcar inf-lst)))
                      inf-lst)))))
    (primes (llist-n->inf 2))))
```

`lazy-primes`はエラトステネスのふるいを使った全ての素数の遅延リストを返す関数です．「全て」とは言いましたが，もちろんマシンリソースは有限なので本当に全ての素数を求められるわけではありません．1つずつ見ていきましょう．`llist-n->inf`は`n`から始まる全ての整数の無限の遅延リストを返す関数です．`lazy-remove-if`は`remove-if`の遅延リスト版で，遅延リストの各要素を`x`としたとき，`(funcall func x)`が真になるものを取り除きます．`divide?`は`n`が`m`で割りきれるかを判定する関数です．

さて，親玉の`lazy-primes`を見ていきましょう．`lazy-primes`は局所関数`primes`に`2`から始まる整数の無限リストを渡しているだけのようです．本体は`primes`です．`primes`は無限リスト`inf-lst`を受け取ると，「先頭の要素」と「残りの無限リストから先頭の要素の約数を取り除いたものを`primes`に渡した返り値」を`lcons`して返します．これによって`primes`の全ての要素は，自分よりも前の要素の約数ではなくなります．`lazy-primes`は`primes`に`2`から始まる無限リストを渡しているので，結果的に全ての素数の無限リストを返すことになるというわけです．

最後に`lazy-primes`から1000個の素数を`ltake`を使って取り出してこの記事を締めましょう．

```common-lisp
(ltake 1000 (lazy-primes))
; -> (2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103
; -> 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
; ->  211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313
; ->  317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433
; ->  439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563
; ->  569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673
; ->  677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811
; ->  821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941
; ->  947 953 967 971 977 983 991 997 1009 1013 1019 1021 1031 1033 1039 1049 1051
; ->  1061 1063 1069 1087 1091 1093 1097 1103 1109 1117 1123 1129 1151 1153 1163
; ->  1171 1181 1187 1193 1201 1213 1217 1223 1229 1231 1237 1249 1259 1277 1279
; ->  1283 1289 1291 1297 1301 1303 1307 1319 1321 1327 1361 1367 1373 1381 1399
; ->  1409 1423 1427 1429 1433 1439 1447 1451 1453 1459 1471 1481 1483 1487 1489
; ->  1493 1499 1511 1523 1531 1543 1549 1553 1559 1567 1571 1579 1583 1597 1601
; ->  1607 1609 1613 1619 1621 1627 1637 1657 1663 1667 1669 1693 1697 1699 1709
; ->  1721 1723 1733 1741 1747 1753 1759 1777 1783 1787 1789 1801 1811 1823 1831
; ->  1847 1861 1867 1871 1873 1877 1879 1889 1901 1907 1913 1931 1933 1949 1951
; ->  1973 1979 1987 1993 1997 1999 2003 2011 2017 2027 2029 2039 2053 2063 2069
; ->  2081 2083 2087 2089 2099 2111 2113 2129 2131 2137 2141 2143 2153 2161 2179
; ->  2203 2207 2213 2221 2237 2239 2243 2251 2267 2269 2273 2281 2287 2293 2297
; ->  2309 2311 2333 2339 2341 2347 2351 2357 2371 2377 2381 2383 2389 2393 2399
; ->  2411 2417 2423 2437 2441 2447 2459 2467 2473 2477 2503 2521 2531 2539 2543
; ->  2549 2551 2557 2579 2591 2593 2609 2617 2621 2633 2647 2657 2659 2663 2671
; ->  2677 2683 2687 2689 2693 2699 2707 2711 2713 2719 2729 2731 2741 2749 2753
; ->  2767 2777 2789 2791 2797 2801 2803 2819 2833 2837 2843 2851 2857 2861 2879
; ->  2887 2897 2903 2909 2917 2927 2939 2953 2957 2963 2969 2971 2999 3001 3011
; ->  3019 3023 3037 3041 3049 3061 3067 3079 3083 3089 3109 3119 3121 3137 3163
; ->  3167 3169 3181 3187 3191 3203 3209 3217 3221 3229 3251 3253 3257 3259 3271
; ->  3299 3301 3307 3313 3319 3323 3329 3331 3343 3347 3359 3361 3371 3373 3389
; ->  3391 3407 3413 3433 3449 3457 3461 3463 3467 3469 3491 3499 3511 3517 3527
; ->  3529 3533 3539 3541 3547 3557 3559 3571 3581 3583 3593 3607 3613 3617 3623
; ->  3631 3637 3643 3659 3671 3673 3677 3691 3697 3701 3709 3719 3727 3733 3739
; ->  3761 3767 3769 3779 3793 3797 3803 3821 3823 3833 3847 3851 3853 3863 3877
; ->  3881 3889 3907 3911 3917 3919 3923 3929 3931 3943 3947 3967 3989 4001 4003
; ->  4007 4013 4019 4021 4027 4049 4051 4057 4073 4079 4091 4093 4099 4111 4127
; ->  4129 4133 4139 4153 4157 4159 4177 4201 4211 4217 4219 4229 4231 4241 4243
; ->  4253 4259 4261 4271 4273 4283 4289 4297 4327 4337 4339 4349 4357 4363 4373
; ->  4391 4397 4409 4421 4423 4441 4447 4451 4457 4463 4481 4483 4493 4507 4513
; ->  4517 4519 4523 4547 4549 4561 4567 4583 4591 4597 4603 4621 4637 4639 4643
; ->  4649 4651 4657 4663 4673 4679 4691 4703 4721 4723 4729 4733 4751 4759 4783
; ->  4787 4789 4793 4799 4801 4813 4817 4831 4861 4871 4877 4889 4903 4909 4919
; ->  4931 4933 4937 4943 4951 4957 4967 4969 4973 4987 4993 4999 5003 5009 5011
; ->  5021 5023 5039 5051 5059 5077 5081 5087 5099 5101 5107 5113 5119 5147 5153
; ->  5167 5171 5179 5189 5197 5209 5227 5231 5233 5237 5261 5273 5279 5281 5297
; ->  5303 5309 5323 5333 5347 5351 5381 5387 5393 5399 5407 5413 5417 5419 5431
; ->  5437 5441 5443 5449 5471 5477 5479 5483 5501 5503 5507 5519 5521 5527 5531
; ->  5557 5563 5569 5573 5581 5591 5623 5639 5641 5647 5651 5653 5657 5659 5669
; ->  5683 5689 5693 5701 5711 5717 5737 5741 5743 5749 5779 5783 5791 5801 5807
; ->  5813 5821 5827 5839 5843 5849 5851 5857 5861 5867 5869 5879 5881 5897 5903
; ->  5923 5927 5939 5953 5981 5987 6007 6011 6029 6037 6043 6047 6053 6067 6073
; ->  6079 6089 6091 6101 6113 6121 6131 6133 6143 6151 6163 6173 6197 6199 6203
; ->  6211 6217 6221 6229 6247 6257 6263 6269 6271 6277 6287 6299 6301 6311 6317
; ->  6323 6329 6337 6343 6353 6359 6361 6367 6373 6379 6389 6397 6421 6427 6449
; ->  6451 6469 6473 6481 6491 6521 6529 6547 6551 6553 6563 6569 6571 6577 6581
; ->  6599 6607 6619 6637 6653 6659 6661 6673 6679 6689 6691 6701 6703 6709 6719
; ->  6733 6737 6761 6763 6779 6781 6791 6793 6803 6823 6827 6829 6833 6841 6857
; ->  6863 6869 6871 6883 6899 6907 6911 6917 6947 6949 6959 6961 6967 6971 6977
; ->  6983 6991 6997 7001 7013 7019 7027 7039 7043 7057 7069 7079 7103 7109 7121
; ->  7127 7129 7151 7159 7177 7187 7193 7207 7211 7213 7219 7229 7237 7243 7247
; ->  7253 7283 7297 7307 7309 7321 7331 7333 7349 7351 7369 7393 7411 7417 7433
; ->  7451 7457 7459 7477 7481 7487 7489 7499 7507 7517 7523 7529 7537 7541 7547
; ->  7549 7559 7561 7573 7577 7583 7589 7591 7603 7607 7621 7639 7643 7649 7669
; ->  7673 7681 7687 7691 7699 7703 7717 7723 7727 7741 7753 7757 7759 7789 7793
; ->  7817 7823 7829 7841 7853 7867 7873 7877 7879 7883 7901 7907 7919)
```