Drei Beiträge zur diskreten Mathematik:

Additionsketten, No-Three-in-Line-Problem, Sociable Numbers Drei Beiträge zur diskreten Mathematik:

Additionsketten, No-Three-in-Line-Problem, Sociable Numbers

Diplomarbeit von Achim Flammenkamp

Fakultät für Mathematik der Universität Bielefeld

vorgelegt im Juni 1991 1. Revision Juli 1991

Meinen Eltern gewidmet

Abstracts

Minimal Addition Chains

A task of D.E. Knuth, to characterize all addition chains with three smallsteps and the corresponding starchains, has been settled.

Progress in the No-Three-in-Line Problem ^{†}

New Solutions to the No-Three-in-Line Problem for n=11, 12, …, 32, 34, 35, 36, 38, 40, 42, 44, 46

New Sociable Numbers ^{‡}

An exhaustive search has yielded new sociable groups; one of order 9, two of order 8 and the others of order 4.

† This part has been accepted for publication in “Journal of Combinatorial Theory, Series A”. ‡ This note appears in “Mathematics of Computation” in June 1991.

Vorwort

Der älteste Teil dieser Arbeit, der Beitrag über das “No-Three-in-Line-Problem”, wurde vor drei Jahren von meinem Mitstudenten Torsten Sillke angeregt. Eigentlich ist es das Produkt einer Wette zwischen mir und einem weiteren Wirtschaftswissenschaftsstudenten, ein effektives, schnelles Verfahren zu programmieren, um Lösungen dieser geometrisch-kombinatorischen Aufgabe zu finden. Seinerzeit wußten wir alle Drei nicht, daß dies eines Tages zu meiner Diplomarbeit gehören würde. Ebenso überraschend wurde der dritte Beitrag, ein zahlentheoretisches Problem, Teil meiner Arbeit. Er wurde durch einen Physikstudenten motiviert, dessen Computerprogramm, das ebenfalls “sociable numbers” suchte, mir zu langsam erschien. Der erste und textmäßig umfangreichste Beitrag über Additionsketten entstand aufgrund einer langen Diskussion vor drei Monaten mit Klaus-Uwe Koschnick, einem Studienkollegen, der mich überzeugte, daß es an der Zeit sei, etwas für meine Diplomarbeit aufzuschreiben. Als Thema dieser Arbeit sollte meine seinerzeit aktuelle Privatbeschäftigung mit Additionsketten mit fester Kleinschrittanzahl dienen. Auch Andreas Dress, mein Professor und Ansprechpartner in der Fakultät für Mathematik, war damit einverstanden, dieses zusammen mit den beiden anderen Kurzbeiträgen vorzulegen. So war meine Diplomarbeit in der vorliegenden Form geboren.

Für die Möglichkeit einer solchen Diplomarbeit und der Mithilfe bei der präzisen sprachlichen Ausarbeitung spreche ich Andreas Dress meinen Dank aus.

Als weiteren Korrektor, auch schon an den englischsprachigen Beiträgen erprobt, möchte ich Ingo Althöfer nennen, der mich damals erst überreden mußte, diese beiden Beiträge meiner Arbeit zur Veröffentlichung einzureichen. Auch Klaus-Uwe Koschnick sei in diesem Rahmen nochmals erwähnt, der den Stein erst ins Rollen brachte. Ebenso denke ich noch dankbar an Torsten Sillke, der mir während unseres gemeinsamen Mathematik-Studiums viele interessante Probleme, Zeitschriftenartikel oder andere fachspezifische Informationen erzählte. Als letztes möchte ich noch das Hochschulrechenzentrum dieser Universität loben, das vielen einfachen Studenten, insbesondere meiner Person, unentgeltlich langjährige und intensive Nutzung ihrer Softund Hardware gestattet.

Bielefeld, im Juni 1991

Inhaltsverzeichnis

Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Inhaltsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Minimale Additionsketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Exposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Beschreibung des Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Nicht-Sternketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Resumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Anhang A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Anhang B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Anhang C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Ergebnistabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Progress in the No-Three-in-Line-Problem . . . . . . . . . . 119 New Sociable Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

Minimale Additionsketten

Einführung

Bei der Addition natürlicher Zahlen tritt das folgende Problem auf (vergl. [3]): Gegeben sei eine beliebige, aber feste natürliche Zahl n und diese soll, ausgehend von der Zahl 1, durch eine Folge von Additionen erzeugt werden. Dazu haben wir einen Pool von Zahlen, der zu Anfang nur aus der Zahl 1 besteht. Aus diesem Pool dürfen wir zwei beliebige Zahlen auswählen, die auch identisch sein können, und zu einer neuen Zahl zusammenaddieren. Diese gehört dann auch zum Pool. Betrachten wir die Zahlen des Pools als Elemente einer Folge natürlicher Zahlen a_{0}, a_{1}, …, a_{r} , die durch r Additionen aufgebaut wird, so gelten für diese Folge die Aussagen:

∃ r ∈ _{0} , ∃ a_{0}, …, a_{r} ∈ : a_{0} := 1, a_{r} := n  (1)
∀h ∈ {1, 2, …, r} ∃ i, j ∈ {0, 1, …, h−1} : a_{h} := a_{i} + a_{j}

Eine solche, von 1 bis zur vorgegebenen Zahl n reichende Zahlenfolge bezeichnen wir als Additionskette von n [4]. Zum Beispiel wären 1,2,3,6,7 aber auch 1,2,3,4,5,6,7 und 1,2,4,8,3,7 Additionsketten für 7. Elemente der Kette, die größer als die Endzahl sind, oder mehrfach erzeugte Zahlen können natürlich entfallen, ohne die Additionskettenbedingung zu zerstören. Auch sieht man sofort, daß das Umstellen der Kettenglieder in eine streng monoton wachsende Folge keine wesentliche Änderung ist. Im folgenden wollen wir daher unter einer Additionskette nur noch eine von 1 an streng monoton wachsende Folge bis zur vorgegebenen Endzahl n verstehen, die der Konstruktion (1) genügt. Das letzte Beispiel einer Additionskette für 7 ist somit nicht mehr zulässig. Wenn wir das zweite Beispiel betrachten, so wird klar, daß man durch fortgesetztes Addieren von 1 zum vorherigen Folgenglied eine sehr lange Additionskette erzeugen kann. Wesentlich schwieriger ist es, eine möglichst kurze Kette für eine vorgegebene Zahl zu finden. Diese Fragestellung kommt aus der Problematik des Potenzierens mit natürlichem Exponenten. Man möchte z.B. x^{15} für verschiedene Basen x mit möglichst wenigen Multiplikationen ausrechnen. Die triviale Methode, nehme x und multipliziere dann solange x dazu, bis die gewünschte Potenz erreicht ist, würde in unserem Beispiel 14 Multiplikationen erfordern. Die Folge der Exponenten unserer so erzeugten Potenzen stellt eine Additionskette dar, da das Multiplizieren von Potenzen mit gleicher Basis einem Addieren der Exponenten entspricht.

Schon seit langer Zeit [1, 2] ist ein effektiveres Verfahren zum Potenzieren allgemein bekannt. Dazu betrachte man den zu erreichenden Exponenten in seiner Binärdarstellung. Für 15 zum Beispiel ist dies 1111_{2}. Der Index 2 an dieser Zahl soll bedeuten, daß es sich nicht um eine Dezimalzahl, sondern um eine Binärzahl handelt. Man lese nun diese Binärdarstellung als Arbeitsanweisung von links nach rechts, um x^{15} zu erzeugen:

1. Starte mit dem neutralen Element der Multiplikation, 1, als aktueller Zahl und betrachte die 1. Ziffer der Binärdarstellung des Exponenten als aktuelle Ziffer.

2. Multipliziere die aktuelle Zahl genau dann mit der Basis x , wenn die aktuelle Ziffer eine 1 ist.

3. Betrachte die nächste Ziffer der Binärdarstellung. Falls diese nicht mehr vorhanden ist, ist man fertig und hat genau die gewünschte Potenz als Endresultat; andernfalls setze diese Ziffer als aktuelle Ziffer an und quadriere die aktuelle Zahl.

4. Fahre mit Punkt 2 fort.

Die Folge der Potenzen würde in unserem Beispiel x^{1}, x^{2}, x^{3}, x^{6}, x^{7}, x^{14}, x^{15} lauten und die zugehörige Additionskette für 15 wäre 1,2,3,6,7,14,15 . Als Länge einer Additionskette bezeichnen wir die dafür notwendigen Additionen. Wir haben somit eine Additionskette der Länge 6 für die Zahl 15 konstruiert.

Viele Leute meinen, daß dieses Verfahren, auch unter dem Namen Russische Multiplikation bekannt, ein optimales Verfahren darstellt, um mit einer minimalen Anzahl von Operationen die gewünschte Endzahl zu erzeugen. Das ist leider nicht so. Für kleine Zahlen kann man mit diesem Algorithmus leicht minimale Additionsketten gewinnen, für größere geht dies aber immer seltener. Tatsächlich können für alle Zahlen kleiner als 15 auf diese Art und Weise minimale Ketten gewonnen werden. Für 15 lassen sich aber um eins kürzere Ketten konstruieren. Der Leser möge eine solche einmal selbst austüfteln, bevor er weiterliest.

Somit ist es eine sinnvolle und interessante Frage, für beliebiges n eine minimale Additionskette zu konstruieren oder wenigstens ihre Länge zu bestimmen bzw., da die NP-Vollständigkeit dieses Problems offen ist (vergl. [11]), es zumindest für gewisse Teilmengen der natürlichen Zahlen zu lösen. Das Ziel dieser Arbeit ist es, alle minimalen Additionsketten mit höchstens drei Kleinschritten zu beschreiben und von diesen diejenigen zu charakterisieren, die keine Stern-Ketten sind.

Grundlagen

Wir beginnen mit einigen neuen Bezeichnungen. Mit ν(n) bezeichnen wir die Anzahl der Einsen in der Binärdarstellung von n ∈ und mit l(n) die minimal mögliche Länge einer Additionskette von n. Einen Schritt in der Additionskette, der das vorherige Element verdoppelt, nennen wir einen Doppelschritt; dieser stellt gleichzeitig den maximal möglichen Zuwachs von Element zu Element dar. Einen Schritt, der kein Doppelschritt ist, bezeichnen wir als Standardschritt ^{1} und einen Schritt, der das nächste Glied der Kette durch Addition irgendeines Elementes zum unmittelbar vorangehenden Glied erzeugt, wollen wir als Stern-Schritt bezeichnen. Eine Additionskette, die nur aus Stern-Schritten besteht, heißt Stern-Kette. Noch Mitte dieses Jahrhunderts hatte man die Vermutung, daß unter den minimalen Additionsketten einer Zahl immer auch Stern-Ketten auftreten; erst Hansen konnte dies widerlegen [5]. Wie man heute nach aufwendigen Computerrechnungen weiß, ist das kleinste n, unter dessen minimalen Additionsketten keine Stern-Kette existiert, 12509 — also viel zu groß, um durch die Papier-und-Bleistift Methode entdeckt zu werden.

Als Kleinschritt bezeichnen wir eine Addition, bei der die Binärdarstellung der neuen Zahl nicht länger als die der vorherigen Zahl ist. Man kann auch sagen, der Binär-Logarithmus der aktuellen Zahl ist konstant geblieben. Unter diesem Binär-Logarithmus einer natürlichen Zahl verstehen wir den ganzzahligen Anteil des reellen Logarithmuswertes zur Basis 2. Formell:

∀n ∈ :  lb(n) := ⌊log_{2}(n)⌋  (2)

1in der englisch-sprachigen Literatur als “nondoublestep” bezeichnet

— die Summe 1 + lb(n) ist also genau die Länge der Binärdarstellung von n. Dieser Wert entspricht auch der Mindestlänge einer Additionskette für n, da man durch wiederholtes Verdoppeln von 1 höchstens 2^{lb(n)} ≤ n erreichen kann. Ist n genau eine 2er-Potenz, ist somit auch eine minimale Additionskette gefunden. Der Algorithmus, der aus der Binärdarstellung von n eine Additionskette erzeugt, liefert als obere Abschätzung l(n) ≤ lb(n)+ν(n)−1. Die Länge einer beliebigen Additionskette für n ist offensichtlich gleich lb(n) plus der Anzahl der Kleinschritte dieser Kette. Da mit gegebenem n auch lb(n) fest liegt, muß man versuchen, die Anzahl der Kleinschritte für eine Additionskette von n möglichst klein zu halten.

Alle Ketten ohne Kleinschritte sind die minimalen Ketten für Werte von n der Form n = 2^{A} mit A ∈ _{0}.

Welche Zahlen lassen sich mit Ketten mit genau einem Kleinschritt erzeugen? Von 1 ≡ 2^{0} startend bis 2^{A} sind die ersten A Schritte nur Doppelschritte. Dann folgt ein Schritt, der ein Stern-Schritt sein muß, da sonst das neue Kettenglied kleiner als das vorherige sein würde. Sie beginnen also mit 1, …, 2^{A}, 2^{A} + 2^{B} für A > B ≥ 0, wobei die “… ” A − 1 Doppelschritte darstellen. Da danach kein weiterer Kleinschritt mehr auftreten darf, muß in allen folgenden Kettenglieder der höchstwertige Exponent immer um 1 anwachsen. Bezeichnen wir nun für alle n, m ∈ mit carries(n, m) die Anzahl der Überträge ^{2} , die bei der Addition ihrer Binärdarstellungen auftreten, und beachten wir die elementare Relation

∀n, m ∈ : ν(n) + ν(m) = ν(n + m) + carries(n, m),

so erhalten wir für die Kettenglieder nach (1):

ν(a_{h}) = ν(a_{i}) + ν(a_{j}) − carries(a_{i}, a_{j}) .

Bezeichnen wir das einzige Kleinschritt-Kettenglied mit a_{k}, so folgt sofort ν(a_{k+1}) ≤ 2 + 2 − 2, falls dies ein Doppelschritt ist, oder anderenfalls ν(a_{k+1}) ≤ 2 + 1 − 1, denn es kann höchstens ein Summand gleich a_{k} sein, welcher als bisher einziges Kettenglied zwei Einsen in seiner Binärdarstellung hat. Demnach haben alle a_{h} mit h ≤ k + 1 höchstens zwei Einsen in ihrer Binärdarstellung. Alle weiteren Kettenglieder müssen aufgrund der strikten Monotonie des höchstwertigen Exponenten entweder Doppelschritte sein, also ν(a_{h+1}) = ν(a_{h}), oder sie haben mindestens zwei Überträge in den beiden höchstwertigen Exponenten der Summanden. Somit kann jedes weitere Kettenglied ebenfalls höchstens 2 Einsen besitzen.

2Als Überträge bezeichnet man die Ziffern, die bei der ziffernweisen Addition zweier Zahlen entstehen, wenn die jeweilige Ziffernsumme größer oder gleich der Basis des gewählten Zahlensystems wird. Im Binärsystem können daher nur Überträge auftreten, wenn zwei Ziffern, die 1 sind, addiert werden.

Die Antwort auf unsere Frage lautet daher: Es lassen sich genau die Zahlen mit Hilfe einer Additionskette mit höchstens einem Kleinschritt erreichen, in deren Binärdarstellung höchstens 2 Einsen auftreten. Insbesondere genügt der notwendige Additionskettenbeginn 1, …, 2^{A}, 2^{A} + 2^{B} , um jene Zahlen zu erreichen. Der erste Beweis dieser Aussage wurde 1962 in [6], S.482-483, veröffentlicht.

Die Binärdarstellung einer Zahl scheint also eine effektive Darstellung einer Zahl zu sein, um die Länge ihrer minimalen Additionsketten zu erkennen. Dies liegt daran, daß ein Verdoppeln, welches einem Anhängen einer 0 in der Binärdarstellung entspricht, einen maximal möglichen Wertzuwachs ermöglicht, was heuristisch wünschenswert ist, um schnell zur Endzahl zu kommen.

Eine konsequente Vorgehensweise wäre es, nun alle Additionsketten mit genau zwei Kleinschritten zu betrachten und aus den erreichbaren Endgliedern zu schließen, welche Zahlen durch solche Ketten auf minimale Weise erzeugt werden. Dies ist allerdings schon wesentlich schwieriger, da bei mehr als einem Kleinschritt die obengenannten Überträge in der Addition der Binärzahlen häufiger auftreten können und dann eine verwickelte Fallunterscheidung erfordern. Sieht man sich die vollständige Analyse dieser Situation in [9], S.449-450 an, so erkennt man, daß dies leichter mit einem Computerprogramm geschehen könnte. In der Tat schlägt Knuth dies in [9], S.457 auch vor.

Meine Arbeit realisiert nun einen solchen computergestützten Beweis, bei dem der Rechner die extrem vielfältigen Fallunterscheidungen übernimmt. Abhängig von der zur Verfügung stehenden Rechenleistung können so alle Additionsketten mit 1, 2, 3 und sogar 4 Kleinschritten erzeugt und klassifiziert werden, wobei die Fälle s = 1, 2 und 3 mit dieser Arbeit analysiert wurden. Daraus läßt sich dann erkennen, welche Zahlen mit dieser Anzahl von Kleinschritten erzeugbar sind, und somit auch deren minimale Additionskettenlänge; nebenbei werden noch die Additionsketten mit 3 Kleinschritten, die nur aus Stern-Schritten bestehen, charakterisiert. Auch läßt sich dann an der Binärdarstellung einer vorgegebenen Zahl sofort ablesen, ob und aus welchen Additionsketten mit 1, 2, oder 3 Kleinschritten sie erreicht werden kann.

Ferner ließe sich bei mehr zur Verfügung stehender Rechenleistung auch leicht eine Aussage von Thurber [7] von 3 auf 4 erweitern, oder ein unerwartetes Gegenbeispiel finden. Die erweiterte Aussage würde besagen, daß alle Zahlen, die mehr als 16 = 2^{4} Einsen in ihrer Binärdarstellung haben, sich nur mit mehr als 4 Kleinschritte enthaltenden Additionsketten aufbauen lassen. Auf den mir zur Verfügung stehenden Rechnern würde dies allerdings Jahre an Rechenzeit beanspruchen, so daß ich diese Rechnung noch nicht durchführen konnte.

Exposition

Um den mathematischen Hintergrund des Problems besser beschreiben zu können, machen wir uns mit zwei speziellen Teilmengen E_{κ} und F_{κ} der Menge aller Funktionen N_{κ} := {(D, h) | D ⊂ _{0}^{κ} , h : D → _{0}} vertraut, wobei κ eine natürliche Zahl ist, die später nur von der Anzahl der Kleinschritte der zu untersuchenden Additionsketten abhängen wird. Bezeichnen wir die Variablen unserer Funktionen mit v_{1}, v_{2}, …, v_{κ} und setzen v_{0} := 1, so können wir E_{κ} und F_{κ} wie folgt definieren:

E_{κ} ≡ {(D, e) ∈ N_{κ} | D ⊂ _{0}^{κ} , ∃ c_{0}, …, c_{κ} ∈ : e(v_{1}, v_{2}, …, v_{κ}) = ∑_{i=0}^{κ} c_{i}v_{i}}

(3)

und

F_{κ} ≡ {(D, f) ∈ N_{κ} | ∃ ν ∈ , ∃ (D_{1}, e_{1}), …, (D_{ν}, e_{ν}) ∈ E_{κ} : e_{1} > … > e_{ν} (4)

und D ⊂ ⋂_{j=1}^{ν} D_{j} und f(v_{1}, v_{2}, …, v_{κ}) = ∑_{j=1}^{ν} 2^{e_{j}(v_{1},v_{2},...,v_{κ})} }

E_{κ} ist also die Menge aller linearen Funktionen in κ Variablen mit rationalen Koeffizienten, aber Wertebereich nur in _{0} , und die Menge F_{κ} sind Summen von 2er-Potenzen deren Exponenten gerade diese linearen Funktionen sind. Für Funktionen g_{1} und g_{2} mit Definitionsbereich D_{1}, D_{2} und auf deren Wertebereich eine gemeinsame Ordnungsrelation < existiert, definiere

g_{1} < g_{2} :⇔ ∀x ∈ D_{1} ∩ D_{2} : g_{1}(x) < g_{2}(x) . Wir möchten jetzt jeder Additionskette beliebiger Länge eine endliche Folge von Funktionen aus F_{κ} zuordnen. Diese Zuordnung wird im Allgemeinen nicht nur von den Kettengliedern, sondern auch von der Konstruktion der Additionskette nach (1) abhängen.

Nun zur Definition dieser Zuordnung: Wir betrachten Additionsketten mit einer festen Anzahl s von Kleinschritten. Alle Zahlen der Kette werden als Summe von 2er-Potenzen aufgefaßt, die in Form ihrer Binärdarstellung eindeutig gegeben ist. Deren Exponenten werden als lineare Funktionen in den obigen Variablen v_{0}, v_{1}, v_{2}, … angesetzt, wobei v_{0} ≡ 1 ist, um den konstanten Anteil einfach zu erfassen. Orientieren wir uns an der Konstruktion (1) , so werden die Werte dieser Variablen höchstens die maximale Anzahl von direkt aufeinanderfolgenden Verdopplungen angeben. Wir ordnen also aufeinanderfolgenden Elementen der Additionskette, die durch Verdopplung entstanden sind, die gleiche Funktion aus F_{κ} zu, wobei κ, wie wir gleich zeigen werden, nur von s abhängt. Einem Kettenglied a_{h} ordnen wir somit ein Tupel (D_{h}, f_{h}) aus F_{κ} mit

f_{h} ≡ ∑_{j=1}^{ν(a_{h})}2^{∑_{i=0}^{κ} c_{ijh}v_{i}} und c_{ijh} ∈  und a_{h} ∈ f_{h}(D_{h})  (5)

zu ^{3}.

Wie wir später sehen werden, ist es aufgrund der Relationen der v_{i} untereinander möglich, daß die Koeffizienten c_{ijh} bei Transformationen der Funktionen f_{h} echt gebrochene Werte annehmen können, so daß wir sie nicht auf einschränken können ^{4}. Lassen wir aus der Folge der f_{h} die gleichen Terme fort, so bilden die übrigen der f_{h} , mit einem noch näher zu bestimmenden Definitionsbereich versehen, eine Folge von Elementen aus F_{κ} . Mit k bezeichnen wir im folgenden deren Länge. Da sie sicher durch κ beschränkt ist, zielen wir darauf ab, mit endlich vielen solcher Folgen alle Additionsketten zu überdecken. Wir haben also eine Abbildung einer Additionskette der Form (1) auf eine gewisse endliche Teilfolge, die aus der Folge der f_{h} gewonnen wird:

3Beispiele solcher Darstellungen sind die Ergebnistabellen ab S. 67 , in denen jedoch statt der Variablennamen v_{i} die lateinischen Buchstaben p, q, r, … oder A, B, C, … verwendet werden

4oder gar auf{-1, 0, 1} wie die nachfolgende Konstruktion auf den ersten Blick nahelegt

(a_{0}, …, a_{h_{1}}, …, a_{h_{2}}, . . . . . . , a_{h_{k−1}}, …, a_{r}) → ((D_{0}, g_{0}), (D_{1}, g_{1}), …, (D_{k}, g_{k}))

mit 0=h_{0} < h_{1} < … < h_{k−1} < h_{k} =r und  (6)

α: {h_{0}, …, h_{k}} ⟶^{surjektiv}_{monoton}{0, …, k} mit g_{α(h_{l})} = f_{h_{l}}

Wenden wir uns jetzt der oberen Schranke von κ zu. In [9] S. 448, “Corollary to Theorem A”, werden die Standardschritte durch die Anzahl der Kleinschritte s abgeschätzt. Die dort angegebene obere Schranke für die Standardschritte lautet:

⌊\frac{s}{log_{2}(\sqrt{5} − 1)}⌋ ≈ ⌊3.27056s⌋ .

Da die Folgen von direkt aufeinander folgenden Doppelschritten immer durch mindestens einen Standardschritt getrennt sind, ist die maximale Länge einer durch (6) dargestellten Kette durch 1 + 2⌊3.271s⌋ nach oben beschränkt. Die Anzahl der Variablen κ(s) ist durch diese maximale Länge beschränkt ^{5}, da die direkt aufeinander folgenden Doppelschritte durch eine einzige Variable erfaßt werden und da man in jedem Standardschritt ebenfalls nur eine weitere Variable v benötigt^{6}, um den kleineren Summanden auszuwählen, wie noch in dieser Arbeit gezeigt wird. In dem Beweis in [9] wird die strenge Monotonie der Additionskette ausgenutzt und man erkennt dort ferner, daß sich die v_{i} unabhängig von h wählen lassen.

Anmerkung: Die Kettenmonotonie hat für die Darstellung (5) der Folgenglieder für deren jeweils ersten Summanden die notwendige Bedingung

∀f_{n}, f_{m} aus (5) : n > m ⇒ ∑_{i=0}^{κ} c_{i1n}v_{i} ≥ ∑_{i=0}^{κ} c_{i1m}v_{i}

als Konsequenz, welche das Programm in Anhang C an mehreren Stellen überprüft, um unzulässige Additionsketten auszusondern. Genau dann wenn n gleich m + 1 ist und die rechte Seite der Bedingung mit dem Gleichheitszeichen erfüllt ist, liegt ein Kleinschritt vor.

5Im Anhang A gebe ich noch einen Beweis für eine scharfe Schranke (≈ 1 + ⌊4.81s⌋)

von κ(s) an.

6zwei weitere Variabalen v würden trivialerweise immer ausreichen

Nun zur expliziten konstruktiven Definition der benötigten Funktionenfolgen aus F_{κ} ; der Index h ∈ {0, …, r} bezeichnet wie früher ein Kettenglied aus (1) und der Index l ∈ {0, …, k} ein Folgenglied aus (6). Das nullte Glied a_{0} ist per Definition 1, so daß man in natürlicherweise (D_{0}, g_{0}) ≡ (D_{0}, f_{0}) als ( _{0}^{κ}, 2^{0}) definiert. Da eine Additionskette, die nicht nur aus einem Element besteht, immer mit Verdopplungen anfangen muß, ist das erste Glied (D_{1}, f_{1}) in (6) gleich ( _{0}^{κ}, 2^{v_{1}}). Allgemein wählt man nun für das nächste Kettenglied a_{h} aus (1) entweder das vorherige Glied zur Verdopplung aus oder bildet es als Summe von zwei verschiedenen vorherigen Kettengliedern. Ist im ersten Fall a_{h} durch direkt aufeinander folgende Verdopplungen entstanden, so ergibt sich f_{h} , wenn a_{m} das letzte, nicht durch Verdopplung erzeugtem Kettenglied vor a_{h} ist, aus f_{m} durch Multiplikation mit 2^{v_{l}}. Nun ist α(m) = l − 1 und das nächste Element der Folge der g_{l} ergibt sich dann zu (D_{l}, 2^{v_{l}}g_{l−1}). Wird der Index h_{l} jetzt als der Index des letzten Elementes einer solchen Verdopplungsteilfolge der a_{h} definiert, so erfüllt dies alle Bedingungen von (6). Auf die Darstellung (5) bezogen bedeutet dies: Alle c_{ijh} mit i ≠ l und m = h_{l−1} < h ≤ h_{l} in der Darstellung (5) sind die c_{ijm} aus f_{m} ≡ g_{l−1}, und für i = l ist c_{ljh} gleich eins statt null in c_{ljm}. Im zweiten Fall sei der kleinere der Ausgangssummanden mit a_{n} und der größere mit a_{m} bezeichnet. Das a_{n} ist wertmäßig immer gleich einem eindeutig bestimmten a_{x}, welches durch einen Standardschritt entstanden ist^{7}, multipliziert mit einer 2er-Potenz, eventuell 2^{0}. Das neue Glied f_{h} ergibt sich dann zu f_{m} + 2^{v_{l}}f_{x} , wobei zwischen a_{m} und dem neuen a_{h} keine Verdopplungsschritte sein können, um die strenge Kettenmonotonie nicht zu verletzen. Insbesondere ist a_{m} immer ein Kettenglied unmittelbar vor einem Standardschritt und α(m) ist definiert ^{8}. Die Variable v_{l} muß kleiner oder gleich v_{y} sein, wenn der Wert von v_{y} die maximale unmittelbar auf a_{x} folgende Anzahl von Verdopplungsschritten bezeichnet. In diesem Fall liegt also eine echte Einschränkung des Definitionsbereiches von D_{l} vor. Das Tupel (D_{l}, g_{l}) ist dann (D_{l} ⊂ D_{α(m)} ∩ D_{α(x)} , g_{α(m)} + 2^{v_{l}}g_{α(x)}). Meistens wird D_{l} durch Überträge, die bei dieser Addition auftreten noch weiter eingeschränkt.

7Somit ist α(x) wohldefiniert.

8Ist α(m) = l − 1, so liegt ein Sternschritt vor.

Wie behauptet, wird in beiden Fällen genau eine neue Variable v benötigt. Wir sehen außerdem, daß die Länge r einer Additionskette, welche durch (1) beschrieben wird, sich im Bildbereich von (6) , als Summe der Werte der Variablen v_{l} des ersten Falls plus die Anzahl der benötigten Variablen v_{l} des zweiten Falls, ergibt. Der maximale Definitionsbereich einer Funktionenfolge aus (6) ist gleich ⋂_{l=0}^{k} D_{l} , der D_{k} sein sollte, andernfalls enthält die Additionskette Glieder, die nicht zur Erzeugung des letzten Additionsgliedes a_{r} benötigt würden und entfallen könnten.

Man steht im Fall des Standardschrittes vor dem Problem, zwei Binärzahlen in der Darstellung (5) formal zu addieren, so daß wieder eine Darstellung (5) erhalten wird. Dabei können unterschiedliche Werte der freien Variablen v_{i} zu unterschiedlichen Normaldarstellungen führen. Dies bedeutet, daß Fallunterscheidungen nötig sind, um die strenge Monotonie in (5) für die neuen Glieder zu garantieren. Dabei müssen bis zu \binom{ν(a_{m})+ν(a_{x})}{ν(a_{m})} Fälle untersucht werden. Zusätzlich können Überträge auftreten, wenn Summanden aus f_{m} mit Summanden aus 2^{v_{l}}f_{x} übereinstimmen. Dies wird im Programm dazu genutzt, pro Übertrag eine Variable v zu eliminieren; hierbei können dann tatsächlich echt gebrochene Zahlen in den c_{ij} auftreten. Jeder neue Übertrag impliziert die Gleichheit der beteiligten Exponenten. Ist diese Bedingung nicht identisch für alle Variablen v erfüllt, so bedeutet diese Bedingung eine weitere Einschränkung der Menge D_{l}. Das Eliminieren von Variablen hat den Sinn, möglichst frühzeitig Widersprüche in den Größer-Kleiner-Relationen zu entdecken, um nachfolgende Fallunterscheidungen zu vermeiden, die nur noch auf Funktionen aus F_{κ} mit leerem Definitionsbereich führten.

Obige Überlegungen führen daher zu einem rekursiven baumartigen Algorithmus. Nun wird deutlich, daß dies wahrscheinlich exponentielles Zeitverhalten des Programmes in Abhängigkeit von der Anzahl s der Kleinschritte und der Länge k zur Folge haben wird. Um eine akzeptable Geschwindigkeit zu erreichen, besteht die Kunst darin, den Beweis so gering wie möglich aufzuzweigen, indem man frühzeitig Bedingungen unter den freien Variablen heranzieht, um den Beweisbaum abzuschneiden (“branch and bound”). Andererseits sollte man aber nicht das Letzte an Information ausnutzen, da dies viel zu lange dauert (zu viele Bedingungen sind zu deduzieren) im Verhältnis zum Gewinn eines geringfügig kürzeren Beweisbaumes.

Weiterhin ist man primär an den Endgliedern einer Additionskette interessiert, um die erzeugbaren Zahlen zu charakterisieren. Dies bedeutet, daß man für Additionsketten, die zu Funktionenfolgen mit formal gleichen Endgliedern führen, nur jeweils eine Folge für die Konstruktion irgendeiner minimalen Additionskette benötigt, oder man merkt sich Funktionenfolgen, die zu logisch allgemeineren Endgliedern führen; diese haben weniger einschränkende Bedingungen. Dies erfordert für Terme in der Form (5) ein algebraisches Werkzeug, um unter diesen eine Teilordung aufgrund der ⊂-Relation zu erkennen. Im Programm ist dies anhand der Funktionen normalize result und arrange in order realisiert. Die erstgenannte Funktion prüft für jedes Folgenendglied aus (6), ob dessen Definitionsbereich D_{k} nicht leer ist und transformiert es dann in eine äquivalente Funktion, seine sogenannte Normaldarstellung. Die Normalfunktion einer Funktion f aus F_{κ} gewinnt man, indem man die Exponenten e_{j} von f , als Linearformen auf ^{κ} betrachtet, einem Isomorphismus des -Vektorraumes L( ^{κ}) dieser Linearformen unterwirft. Als neue Basis des Bildraumes wählt man die linear unabhängigen Exponenten mit dem niedrigsten Index in (5). Solche Normalfunktionen sind gerade in den ersten Teilen der Ergebnistabellen aufgelistet.

Beschreibung des Algorithmus

Um den Algorithmus zu verdeutlichen, gebe ich die Ablaufschemata der Funktionen main, next addition, add binary, add bincar sowie des ⨁- Operators in Form von ”Kochrezepten“ an. Zur Erinnerung: Diese fünf Programmfunktionen müssen die Funktionenfolgen im Bildraum von (6) erzeugen, um alle potentiellen Additionsketten zu überdecken.

main

1. Setze die aktuelle Länge der Funktionsfolge, h auf 0 und f_{0} auf 2^{0}.

2. Bilde das erste Folgenglied: f_{h+1} = f_{1} := 2^{v_{1}}

3. Führe die Prozedur next addition durch.

4. Gebe alle gesammelten Funktionsfolgen aus.

next addition

1. Berechne die Anzahl z der Kleinschritte der aktuellen Folge. Ist z größer als die vorgegebene Anzahl s, dann beende diese Prozedur. Ist z gleich der Anzahl der vorgegebenen Kleinschritte s, dann führe die Prozedur normalize result durch.

2. Erhöhe h um 1.

3. Setze i gleich h.

4. Setze j gleich 1.

5. Wenn j gleich i ist und f_{i} nicht durch Verdoppeln gewonnen wurde, überspringe die folgenden drei Anweisungen:

(a) Ist f_{j} durch Verdoppeln entstanden, definiere x als 2^{v_{h+1}}f_{j−1} und vermerke die Restriktion v_{h+1} ≤ v_{j}. Andernfalls definiere x als f_{j}.

(b) Erzeuge E := f_{i} ⨁ x und setze jedes Element von E als ein f_{h+1} an.

(c) Führe mit jeder dieser Folgen die Prozedur next addition durch.

6. Erhöhe j um 1. Wenn j nicht größer als i ist, fahre mit Punkt 5 fort.

7. Wenn i gleich h ist und f_{h} durch Verdoppeln entstanden ist, gehe zum letzten Punkt dieser Prozedur.

8. Setze f_{h+1} gleich 2^{v_{h+1}}f_{i} und führe die Prozedur next addition durch.

9. Wenn f_{i} durch Verdoppeln entstanden ist oder 1 + c_{i0} < c_{h0} ist, gehe zum letzten Punkt dieser Prozedur.

10. Verringere i um 1. Wenn i positiv ist, fahre mit Punkt 5 fort.

11. Verringere h um 1 und verlasse dann diese Prozedur.

Definition und Eigenschaften des ⨁-Operators

Dieser Operator hat einen linken Term, f, und einen rechten Term, g, der Form (5). Er liefert als Ergebnis eine endliche Menge von Termen der Form (5). Formell:

M := {f_{h} | f_{h} von der Form (5)} und  ⨁ : M^{2} → P ⊂ P(M) (7)

Eine lineare Abbildung in κ Variablen heiße größer (oder gleich) einer anderen linearen Abbildung in diesen κ Variablen auf einer Menge T, wenn diese eine Teilmenge des Definitionsbereiches der beiden Abbildungen ist, so daß der Wert der einen linearen Abbildung in jedem Punkt aus T größer (oder gleich) dem Wert der anderen Abbildung in diesem Punkt ist.

Im Programm ist der Operator ⨁ durch die beiden Funktionen add binary und add bincar realisiert, die sich gegenseitig verschachtelt aufrufen. Das Resultat sind Permutationen der Summanden von f und g, wobei die ν(f) Summanden von f und die ν(g) Summanden von g in ihrer ursprünglichen Reihenfolge verbleiben. \binom{ν(g)+ν(f)}{ν(f)} Möglichkeiten sind daher denkbar. Jede dieser Permutationen wird von links nach rechts, von höherwertigen Potenzen nach niederwertigen Potenzen aufgebaut. Dies geschieht im Programm durch die Funktion add binary. Dabei werden auch gewisse Monotoniebedingungen, die aus der formalen Darstellung folgen, überprüft. Dies geschieht entweder explizit oder mit Hilfe der Funktion check conditions. Ergibt sich hierbei ein Widerspruch, braucht dieser Permutationsbeginn nicht weiter berücksichtigt zu werden. So können, besonders bei vielen Summanden, schon frühzeitig unzulässige Permutationen ausgeschlossen werden.

Desweiteren können Überträge auftreten, wenn in der neuen Summe ein ehemaliger Summand aus g unmittelbar einem Summanden aus f folgt. Nun ist eine Fallunterscheidung nötig. Entweder die beiden Summanden sind verschieden im Exponenten oder ihre Exponenten sind formal gleich. Im letzten Fall erfolgt ein Übertrag dieser beiden Summanden, der sich eventuell auch auf schon erzeugte, höherwertige Summanden fortpflanzen kann. Diese Übertragskonsequenzen werden im Programm durch die Funktion add bincar weiter verfolgt. Wie oben erwähnt, wird aufgrund der Gleichheit der z.Z. letzten beiden Exponenten, eine Variable v_{k} eliminiert. Dabei ändern sich natürlich Koeffizienten c_{ij} in den Exponenten der Folgenglieder. Hierbei geschieht es auch, daß die c_{ij} echt rationale Werte annehmen.

Für das folgende Schema seien die Exponenten von f mit α_{i}, die von g mit β_{j} und die von e ∈ E ≡ f ⨁ g mit γ_{h} bezeichnet. Dabei seien alle Exponenten, die lineare Funktionen auf einer Teilmenge des _{0} sind, monoton fallend indiziert.

Erzeuge E := f ⨁ g

1. Setze i, j und h gleich 1.

2. Setze γ_{h} gleich α_{i} und erhöhe i um 1.

3. Führe die Prozedur add binary durch.

add binary

1. Erhöhe h um 1.

2. Wenn i ≤ ν(f) ist, dann tue folgendes:

(a) Setze γ_{h} gleich α_{i} und erhöhe i um 1.

(b) Führe die Prozedur add binary durch.

(c) Erniedrige i um 1.

3. Wenn j ≤ ν(g) ist, dann tue folgendes:

(a) Setze γ_{h} gleich β_{j} und erhöhe j um 1.

(b) Führe die Prozedur add binary durch.

(c) Wenn γ_{h−1} gleich α_{i−1} ist, dann führe die Prozedur add bincar durch.

(d) Erniedrige j um 1.

(e) Gehe zum letzten Punkt dieser Prozedur.

4. Wenn i > ν(f) und j > ν(g) ist, dann liefere ∑_{l=1}^{h} 2^{γ_{l}} als weiteres Element aus E.

5. Erniedrige h um 1 und verlasse dann diese Prozedur.

add bincar

1. Eliminiere mit Hilfe der Gleichung γ_{h} = γ_{h−1} eine der Variablen v_{k} aus allen γ_{1}, γ_{2}, ..., γ_{h}.

2. Verringere h um 1 und erhöhe dann c_{0h} (in γ_{h}) um 1.

3. Wenn h = 1 oder wenn in γ_{1} der Koeffizient c_{01} ≥ c_{01} aus a_{h−1} ist, dann führe die Prozedur add binary durch.

4. Wenn h > 1 und wenn γ_{h−1} nicht durch Übertrag entstanden ist, dann führe die Prozedur add bincar durch.

5. Verlasse diese Prozedur.

Wie oben gesagt, ist die Ordnungsrelation zwischen linearen Abbildungen nur bezüglich einer Menge T, die Teilmenge der Schnittmenge beider Definitionsbereiche ist, definiert. Deshalb gehört zu jeder Funktionsfolge ein genauer Definitionsbereich für deren Variablen v_{k}. Dieser ist in unserem Kontext stets der _{0}^{κ}, restringiert in Form eines Ungleichungssystems in den v_{k}. In Punkt 5 des Schemas für next addition entstehen diese Ungleichungen.

Dieses System von Ungleichungen wird am Anfang von next addition und in add bincar auf die Existenz von zulässigen Lösungen geprüft. Dies geschieht, indem das globale Feld elem als Koeffizienten-Matrix eines dualen Simplexverfahrens benutzt wird, wobei die Koeffizienten elem_{ij} aus dem Ungleichungssystem und den Monotoniebedingungen der Exponenten der aktuellen Funktionsfolge stammen. Die Funktion check conditions führt dann den dualen Simplexalgorithmus durch, der wegen vollständiger Entartung immer mit lexikografischem Zusatz gerechnet wird. Für diesen Algorithmus sei z.B. auf [10], S. 739-755 verwiesen. Ist der zulässige Bereich leer, das heißt, die Prozedur check conditions liefert einen negativen Wert, dann bedeutet dies, daß keine zugehörige Funktionsfolge existiert und es wird die aktuelle Prozedur sofort verlassen, denn diese Funktionsfolge braucht nicht weiter aufgebaut zu werden.

An dieser Stelle möchte ich kurz die Funktion minimize erwähnen, die das primale Simplexverfahren realisiert. Wie check conditions arbeitet sie auf dem globalen Feld elem, welches schon durch vorheriges Aufrufen von check conditions einen zulässigen Lösungsvektor enthält. Sie minimiert eine lineare Funktion, die als dritter Parameter übergeben wird, und liefert das Minimum dieser Funktion zurück oder MOST falls die Funktion nach unten unbeschränkt ist.

Sammeln der erzeugten Funktionsfolgen

Ist eine weitere Folge mit der gewünschten Kleinschrittanzahl erzeugt, wird die Funktion normalize result aufgerufen. Hier erfolgt zuerst ein vollständiger Check, ob der Definitionsbereich der Funktionsfolge leer ist. Dies geschieht durch wiederholtes Anwenden der Funktion check next condition , die auch redundante Restriktionen entfernen kann, auf die Ungleichungen des Definitionsbereiches und die Ungleichungen, die aus der Monotonieforderung der Exponenten der Folgenglieder folgen. Hat die Folge diesen Test bestanden, wird ihr Endglied in eine Normalform überführt. Dies geschieht, indem von den höherwertigeren Exponenten zu den niederwertigeren die linear unabhängigen Exponenten des Folgenendgliedes als neue freie Variablen angesehen werden ^{9}, und die übrigen Exponenten entsprechend transformiert werden. Hierbei können echt rationale Koeffizienten im Exponenten auftreten. Andererseits werden aber auch schon in den Koeffizienten vorhandene Brüche gekürzt.

Anschließend werden die Nebenbedingungen der Funktionsfolge daraufhin untersucht, ob aus ihnen bereits ein eindeutiger Wert für eine freie Variable folgt. Diese wird gegebenenfalls eliminiert. Nun wird die Funktion reduce conditions auf alle Bedingungen denen die Variablen genügen müssen angewandt. Diese Funktion versucht, die Restriktionen des Definitionsbereiches so weit wie möglich aus den Bedingungen der Exponentenmonotonie der Folgenglieder zu folgern. Dabei werden die meisten redundanten Nebenbedingungen, das sind linear abhängige, eliminiert. Insbesondere fallen viele Bedingungen fort, die Variablen enthalten, die nicht im Endglied einer Funktionsfolge auftreten. Auf diese Art und Weise waren im 3-Kleinschrittfall nie mehr als zwei weitere explizite Restriktionen für den Definitionsbereich nötig. Dies fördert die Übersichtlichkeit der Tabellen und kommt der anschließenden Funktion arrange in order zu Gute. Diese Funktion sortiert jedes neu erzeugte, normalisierte Endglied einer Folge in eine Liste der wesentlich verschiedenen Folgenendglieder ein. Dabei wird untersucht, ob ein neues Folgenendglied als Spezialfall eines allgemeineren Termes schon vorhanden ist, oder ob mit ihm bereits gespeicherte Terme zu einem allgemeineren Endglied zusammengefaßt werden können. Mit dieser Technik läßt sich die Sammlung der Folgenendglieder wesentlich komprimieren. Die Algorithmen, um solche algebraischen Äquivalenzen oder Teilordnungen unter den Termen mit ihren Restriktionen festzustellen, sind heuristisch auf dieses Problem zugeschnitten worden. Sie sind nicht perfekt, aber fast immer ausreichend und auf einem Rechner relativ schnell zu durchlaufen.

9in der Tabelle im Anhang sind sie durch die Variablen p, q, r, … gekennzeichnet

Die beiden Funktionen put chain und put term dienen nur der Ausgabe der Funktionsfolgen, b.z.w. der einzelnen linearen Ungleichungen. Die Funktion heap sort mit ihrer Vergleichsfunktion compare less than ist eine Variante des Heapsort-Sortieralgorithmuses. Sie dient hier dazu, die Sammlung der Funktionsfolgen nach ihren Endgliedern zu sortieren. Im Fall der Funktionsfolgen aus 3 Kleinschritten bleiben zum Schluß nur 204 wesentlich verschiedene Endglieder übrig, aber im Fall der 4 Kleinschritte weit mehr als 10000, so daß ein einfacher “Bubblesort” unpraktikabel wird.

Anzumerken ist noch, daß von den 204 Endgliedern im 3 Kleinschrittfall diese vier Funktionen redundant sind^{10}:

 5* @(p)+@(q)+@(q-1)+@(q-3)+@(p-6)
 6* @(p)+@(q)+@(p-6)+@(q-3)+@(q-4)+@(q-5)
 6* @(p)+@(q)+@(q-1)+@(q-2)+@(q-3)+@(p-6)
 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+r+s) ,p-q-t>=2,s-t>=3,q-s+t>=-1,
                                              -p+r+s-t>=1

Das Erste wird für q = p − 2 durch Nr. 28 und für q = p − 1 durch Nr. 29, das Zweite wird für q = p − 5 durch Nr. 59 und für q = p − 4 durch Nr. 70, das Dritte wird für q = p − 1 durch Nr. 107 und für q = p − 2 durch Nr. 114 und das Vierte für alle t durch Nr. 120 der Ergebnistabellen erfaßt. Nach dieser Handaussiebung verbleiben die 200, die dort aufgelistet sind. Hieran sieht man auch, daß sich die Funktion arrange in order sicher noch verbessern ließe.

10Der Ausdruck @(…) steht für 2^{(...)}.

Nicht-Sternketten

Da nur eine Nicht-Sternkette unter den 200 Additionsketten auftritt, ist die notwendige Bedingung für eine minimale Nicht-Sternkette mit drei Kleinschritten, daß die zugehörige Zahl die Form 2^{p} + 2^{q} + 2^{r} + 2^{s} + 2^{−q+r+s} hat, mit p > q > r > s > −q + r + s ≥ 0 . Für die Exponenten der Binärdarstellung heißt dies: die Summe des niederwertigen und zweithöchsten Exponenten ist gleich der Summe des 3. und 4. Exponenten. Läßt man sich nur Sternketten durch das Programm erzeugen, so treten an Stelle der einzigen Nicht-Sterndarstellung fünf andere Darstellungen:

5* @(p)+@(q)+@(q-2)+@(r)+@(r-2) ,p-q>=2
5* @(p)+@(q)+@(q-1)+@(r)+@(r-1)
5* @(p)+@(q)+@(-p+2q-1)+@(r)+@(-p+q+r-1)
5* @(p)+@(q)+@(r)+@(-p+2q-1)+@(-p+q+r-1)
5* @(p)+@(q)+@(r)+@(-p+q+r-1)+@(-p+2r-1)

Zusammen mit den in den Ergebnistabellen aufgeführten 34 anderen Darstellungen für 5-Bit Zahlen, sind dies potentielle Darstellungen, die auch Zahlen der obigen Form erzeugen könnten. Ein Überprüfen per Hand ergibt, daß diese sich auf folgende Liste reduzieren lassen:

5* @(p)+@(p-3)+@(q)+@(q-1)+@(-p+2q+2)
5* @(p)+@(p-1)+@(q)+@(r)+@(-p+q+r+1)
5* @(p)+@(q)+@(-p+2q)+@(r)+@(-p+q+r)
5* @(p)+@(q)+@(-p+2q-1)+@(r)+@(-p+q+r-1)
5* @(p)+@(q)+@(-p+2q+1)+@(r)+@(-p+q+r+1)
5* @(p)+@(q)+@(-p+2q+3)+@(-p+2q+2)+@(-2p+3q+5)
5* @(p)+@(q)+@(q-2)+@(r)+@(r-2) ,p-q>=2
5* @(p)+@(q)+@(q-1)+@(r)+@(r-1)
5* @(p)+@(q)+@(r)+@(-p+q+r)+@(-p+2r)
5* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-p+2r+1)
5* @(p)+@(q)+@(r)+@(-p+2q)+@(-p+q+r)
5* @(p)+@(q)+@(r)+@(-p+2q+1)+@(-p+q+r+1)
5* @(p)+@(q)+@(r)+@(-p+2q-1)+@(-p+q+r-1)
5* @(p)+@(q)+@(r)+@(-p+q+r-1)+@(-p+2r-1)

Die hinreichende Bedingung ist somit, daß sich eine Zahl nicht durch eine dieser 14 Formen erfassen läßt. Die kleinsten dieser Zahlen lauten: 16537, 20753, 32921, 33065, 33074, ….

Wie die Arbeiten am 4-Kleinschritt-Fall zeigen, gibt es hier für minimale Additionsketten mit vier Kleinschritten viele verschiedene Darstellungen, die nicht durch Sternketten erreicht werden.

Resumé

Wie man schon am Ergebnis für 3-Kleinschritt-Ketten sieht, dürfte ein klassischer Beweis ohne Computereinsatz sehr langwierig werden und für 4 Kleinschritte praktisch undurchführbar sein. Da die vorliegende Arbeit eine Mathematik-Diplomarbeit und keine Informatik-Diplomarbeit ist, habe ich das in C geschriebene Programm nur soweit optimiert, daß es in ein paar Tagen den 3-Kleinschritt-Fall vollständig analysieren kann. Die Optimierungen waren dabei von heuristisch-mathematischer Art, nicht von programmiersprachen- oder gar rechnerspezifischer Art. Ich denke, durch eine weitere Optimierung auf algorithmischer Ebene läßt sich das Verfahren noch wesentlich beschleunigen, was für den 4-Kleinschritt-Fall relevant ist. Alle 5-Kleinschritt-Ketten zu erzeugen, dürfte dagegen auch heute auf schnellsten Rechnern noch Jahrzehnte dauern, sprich: nicht realistisch sein.

Das Ergebnis für 2- und 3-Kleinschritt-Ketten ist am Ende des ersten Teils dieser Arbeit in je zwei Tabellen dargestellt. Die erste Tabelle listet in jeder Zeile eine Funktionsdarstellung nach (5) mit bekannten c_{ij} auf, die durch minimale Kleinschritt-Additionsketten erreichbar ist. Jeder Term ist mit einer fortlaufenden Nummer versehen, dem der Wert vom ν dieser Funktion folgt und danach ein ⋆, wenn diese Funktion durch eine Stern-Kette erzeugbar ist. Insbesondere fällt auf, daß es nur eine einzige Nicht-Stern-Kette bei den 3-Kleinschritt-Ketten gibt. Zu beachten ist, daß dies normalisierte Funktionen von normalize result sind.

Der besseren Lesbarkeit wegen sind die freien Variablen mit den Buchstaben p, q, r, … bezeichnet. Der Ausdruck @(…) steht für 2^{(...)}, um die jeweilige Funktion in einer Zeile kompakt darstellen zu können. Der Definitionsbereich der Funktion ist eine Teilmenge des _{0}^{s+1}, da offensichtlich nicht mehr als s+1 Variablen für eine Funktion, die mit s Kleinschritten erreicht wird, benötigt werden. Die Einschränkung des Definitionsbereiches ist: Für alle aufeinanderfolgenden Exponenten einer Funktion gilt die >-Relation und für ihren letzten Exponenten gilt natürlich außerdem die Nicht-Negativitäts-Bedingung. Wenn die Variablen weiteren Ordnungs-Relationen genügen müssen, sind diese, durch Kommata getrennt, angehängt.

Die zweite Tabelle gibt zu jeder Darstellung an, durch welche Art von Additionskettenabbildung (6) diese erzeugt werden kann. Die freien Variablen v_{1}, v_{2}, … sind wegen der besseren Lesbarkeit mit A, B, C, … bezeichnet. Vor jedem Folgenglied steht ein Eintrag der Form h(i, j), wobei h, i und j die Werte der entsprechenden Indizes in (1) unter der Auswahlfunktion α aus (6) sind; ist j ein D, so ist das f_{h} aus dem f_{i} Glied durch Doppelschritte erzeugt worden. Die aufgeführten Funktionenfolgen gehören immer zu den Kürzesten mit der geforderten Endfunktion.

Als Anhang C folgt das C-Programm, mit dem die gesamten Berechnungen durchgeführt wurden. Am Anfang dieses Programmes sind noch CPU-Zeiten für verschiedene Programmläufe, auch für 4-Kleinschritt-Ketten, verzeichnet.

Anhang A

In diesem Abschnitt betrachten wir nur Additionsketten die bei festvorgegebener Anzahl s von Kleinschritten für ihre zugehörige Funktionsfolge nach (6) maximale Länge κ(s) besitzen. Wir werden dann unter all diesen Additionsketten eine einzige mit charakteristischer Struktur herausfiltern, für dessen Funktionsfolge wir κ(s) leicht angeben können.

Sei 1, a_{1}, …, a_{k} irgendeine dieser Additionsketten mit Länge k in der Form (1). Diese läßt sich durch eine Additionskette 1, b_{1}, …, b_{k} majorisieren, mit b_{h} gleich 2b_{h−1} falls a_{h} ein Verdopplungsschritt ist, andernfalls b_{h} gleich b_{h−1} + b_{h−2}. Dies ist offensichtlich eine Kette, die die gleiche Doppelschritt/Standardschritt- Sequenz hat wie die ursprüngliche, aber alle b_{h} sind mindestens so groß wie die zugehörigen a_{h}. Die Anzahl der Kleinschritte der neuen Kette kann daher nicht abgenommen haben und aufgrund der Maximalität von κ(s) muß sie gleich geblieben sein. Als nächstes bemerken wir, daß es für κ(s) irrelevant ist, wie viele direkt aufeinander folgende Verdopplungsschritte in einer solchen Additionskette auftreten. Dies bedeutet, wir brauchen nur noch Ketten betrachten für die a_{h+1} = a_{h} + a_{h−1} falls a_{h} = 2a_{h−1} ist; die Kettenlänge k ist nun genau κ.

Sei a_{h} ein Kettenglied unmittelbar vor einem Verdopplungsschritt, dann sieht die Additionskette lokal aus wie a_{h}, 2a_{h}, 3a_{h}, 5a_{h}, 8a_{h}, …, wobei die Länge dieser “Fibonaccifolge” durch die Anzahl der Schritte bis zum nächsten Verdopplungsschritt gegeben ist. Vergleichen wir diese Folge mit a_{h}, 2a_{h}, 3a_{h}, 6a_{h}, 9a_{h}, …, so erkennen wir, daß man jede “Fibonaccifolge” mit mindestens drei direkt aufeinanderfolgenden Standardschritten durch alternierde Doppelschritt/Standardschritt-Konstruktion majorisieren kann. Für die so substituierte Additionskette besitzt ihre neue Funktionsfolge sicher immer noch den gleichen maximalen Wert κ(s) , da auch sie in jedem Schritt eine neue Variable v benötigt. Wir beschränken uns daher auf Additionsketten, die nach jedem Verdopplungsschritt höchstens zwei Standardschritte haben. Da außer im letzten Additionsschritt nach jedem Verdopplungsschritt mindestens ein Standardschritt folgt, haben alle Zahlen, die durch diese Ketten erreicht werden, die Form 2^{1}3^{i}5^{j} , wobei i die Anzahl der Teilfolgen mit genau einem Standardschritt (1-S-Folge) und j die Anzahl derer mit genau zwei Standardschritten (2-S-Folge) angibt. Nun können wir uns auf Additionsketten beschränken, in denen sich alle 1-S-Folgen vor allen 2-S-Folgen befinden. Betrachten wir zwei aufeinanderfolgende 2-S-Folgen, a_{h}, 2a_{h}, 3a_{h}, 5a_{h}, 10a_{h}, 15a_{h}, 25a_{h}, so erkennen wir, daß sie sich durch a_{h}, 2a_{h}, 3a_{h}, 6a_{h}, 9a_{h}, 18a_{h}, 27a_{h} majorisieren lassen. Somit ersetzen wir bis auf höchstens die letzte 2-S-Folge, alle übrigen durch drei 1-S-Folgen. Verbleibt eine letzte 2-S-Folge, so muß 9a_{h} < 2^{n} < 10a_{h} für ein bestimmtes n sein. Weil der Faktor 3 mit zwei Additionen und der Faktor 5 mit drei Additionen aufgebaut wird, gilt:

κ(s) = max{1 + 2i + 3j | i ∈ _{0} j ∈ {0, 1} und 2 3^{i}5^{j} ≥ 2^{1+2i+3j−s}}

Getrenntes Maximieren für j null und j gleich eins, ermöglicht das Auflösen der Ungleichung nach i. Logarithmieren und weitere Umformungen führen dann direkt zu der behaupteten oberen Schranke von κ(s):

κ(s) ≤ ⌊\frac{s + log_{2}(4/3)}{2 − log_{2}(3)}⌋ + ⌊\frac{s + log_{2}(10/9)}{2 − log_{2}(3)}⌋ ≈ 1 + ⌊4.81s⌋

Anhang B

Beim Aufschreiben dieser Arbeit wurde ich von Herrn Sillke auf den Tagungsband ([13]) von ”Advanced International Workshop on Sequences”, die im Juni 1988 in Neapel stattfand, aufmerksam gemacht. Er enthielt einen Vortrag über Additionsketten von Elias und Neri, in dem die Autoren eine Tabelle angaben, die ich schon vor einigen Jahren, unabhängig von meiner Arbeit, weiter berechnet hatte. Da ich jetzt annehmen muß, daß diese Ergebnisse doch noch nicht bekannt sind, seien sie hier veröffentlicht.

Definieren wir mit L(i) die Menge der natürlichen Zahlen n, für die l(n) gleich i ist, so bezeichne d(i) deren Mächtigkeit und c(i) ihr Minimum. Durch einen numerischen Algorithmus, der für alle Zahlen kleiner als 2^{17} deren minimale Additionskettenlänge bestimmte, ließen sich zu vorgegebenem i die Werte von c(i) und d(i) finden. Dies hat Knuth in ([9]) für i bis 18 bzw. 15 getan.

\begin{matrix}i & c(i) & s(c(i)) & d(i) \\ 0 & 1 & 0 & 1 \\ 1 & 2 & 0 & 1 \\ 2 & 3 & 1 & 2 \\ 3 & 5 & 1 & 3 \\ 4 & 7 & 2 & 5 \\ 5 & 11 & 2 & 9 \\ 6 & 19 & 2 & 15 \\ 7 & 29 & 3 & 26 \\ 8 & 47 & 3 & 44 \\ 9 & 71 & 3 & 78 \\ 10 & 127 & 4 & 136 \\ 11 & 191 & 4 & 246 \end{matrix}  \begin{matrix}i & c(i) & s(c(i)) & d(i) \\ 12 & 379 & 4 & 432 \\ 13 & 607 & 4 & 772 \\ 14 & 1087 & 4 & 1382 \\ 15 & 1903 & 5 & 2481 \\ 16 & 3583 & 5 & 4490 \\ 17 & 6271 & 5 & 8170 \\ 18 & 11231 & 5 & 14866 \\ 19 & 18287 & 5 & 27128 \\ 20 & 34303 & 5 & 49544^{⋆} \\ 21 & 65131 & 6 & 90371^{⋆} \\ 22 & 110591 & 6 & · \\ 23 & 196591^{∗} & 6 & · \end{matrix}

⋆ Dieser Wert konnte erst jetzt mit dem neuen Programm berechnet werden.

Bemerkung I: Definiert man ε(n) = l(n) − lb(n) − ⌈log_{2}(ν(n))⌉ , so nimmt ε(n) für n kleiner als 2^{17} nur die Werte 0, 1 und 2 an. Übrigens ist es eine noch unbewiesene Hypothese, die besagt, daß ε(n) stets nicht negativ ist ([8]). Mit dieser Kodierung lassen sich sehr kompakte Tabellen für l(n) erstellen.

Bemerkung II: Für i → ∞ scheint c(i) ∼ Θ(\frac{2^{i}}{i^{2}} ) zu sein und bezeichne g(x) die inverse Funktion zu f(x) = lb(x)(1 + \frac{1}{lb(lb(x))}) , dann gilt d(i) ∼ g(i) − g(i − 1) .

Anhang C

#include <stdio.h>
# ifndef  MAX_SMALLS
#define  MAX_SMALLS         3
# endif
#define  MAX_BITS    (2<<MAX_SMALLS)
# if   MAX_SMALLS >= 4
#define  MAX_LENG          12
# else
#define  MAX_LENG    (2+2*((13*MAX_SMALLS)/4)+1)
# endif
#define  MAX_VARS       MAX_LENG
#define  MAX_COND       MAX_VARS
#define  CONDITIONS  (MAX_COND+MAX_BITS+MAX_VARS)
#define  MAX_REDC      (2<<MAX_SMALLS)
#define   MR                2
#define  MAX_ELEM      (2*CONDITIONS)
#define  SHIFT              8
#define  MASK         ((1<<SHIFT)-1)
# if   MAX_SMALLS >= 4
#define  ANZ             8192
#else
#define  ANZ              512
# endif
#define  COMPACT          256
#define  VBITS              5
#define  VERSION           42
#define  ABS(arg)     ( (arg) >= 0 ? (arg) : -(arg) )
#define  MOST         (int)(~((unsigned)~0>>1))
#define  INT_LIMIT    ((unsigned)MOST>>4)

/***  12.06.91  ***  Computer:  Dec 5400 / Ultrix V3.1  &  HP850 / HP-UX 7.0
small  len      cases   counter   chains  terms    Dec  cpu-time  HP
  0   >= 2          2         1        1      1      0 sec
  1      2          2         1        1      1      0 sec
  1      3         10         5        5      2      0 sec
  1      4         40        11       11      2      0 sec
  1      5         90        15       15      2      0 sec
  1   >= 6        134        15       15      2      0 sec
  2      3         10         4        4      2      0 sec     0 sec
  2      4        108        59       56      4      0 sec     0 sec
  2      5       1314       338      327      6      2 sec     2 sec
  2      6       7581      1036     1025      7      8 sec    11 sec
  2      7      25406      1889     1878      7     28 sec    36 sec
  2      8      52243      2403     2392      7     59 sec    77 sec
  2      9      71157      2581     2570      7     83 sec   106 sec
  2     10      78070      2613     2602      7     94 sec   121 sec
  2  >= 11      79735      2613     2602      7    101 sec   126 sec
  3      4        108        31       28      3      0 sec     0 sec
  3      5       2187      1134     1004     19      4 sec     7 sec

3      6      66604     13293    12361     58    121 sec   138 sec
3      7    1060606     78965    76834    126     27 min    32 min
3      8    9167916    263260   260087    184    245 min   301 min
3      9   37302931    554200   549914    203   1030 min       min
3     10   86504468    835397   830503    204     45 h         h
3     11  131829325   1009821  1004795    204        h         h
3     12  155052030   1078118  1073092    204     97 h         h
3     13
3     14
3     15  165531124   1096265  1091239    204    114 h         h
3  >= 16  165543372   1096265  1091239    204        h         h
4      5       2273       371      280      8      4 sec     5 sec
4      6      85062     35032    28414    342      6 min     7 min
4      7    6669567    766756   680135   2097    288 min   384 min
4      8  765711964   7828350  7388661  12041   ~420 h
(C) Achim Flammenkamp, Department of Mathematics, University of Bielefeld  ***/

unsigned   max_length, smallsteps, no, counter, cases, admiss, max_len,
         max_compact, max_anz, max_cond, star_chain;
int    bitsn[ANZ], number[ANZ][MAX_BITS][MAX_VARS], denomn[ANZ], ccn[ANZ],
     condn[ANZ][MAX_REDC][MAX_VARS], compr[ANZ][COMPACT], vari[ANZ];
int    elem[MAX_ELEM][MAX_VARS+MAX_ELEM/2], deelem;
#define    CHAIN    int
#define   chain1    denom1, bits1, sequ1, info1, cc1, cond1
#define   chain2    denom2, bits2, sequ2, info2, cc2, cond2
#define   Chain1    bits1[MAX_LENG], sequ1[MAX_LENG][MAX_BITS][MAX_VARS], \
                  info1[MAX_LENG], cc1, cond1[MAX_COND][MAX_VARS], denom1
#define   Chain2    bits2[MAX_LENG], sequ2[MAX_LENG][MAX_BITS][MAX_VARS], \
                  info2[MAX_LENG], cc2, cond2[MAX_COND][MAX_VARS], denom2
#define  indices12  index1, index2, next1, next2, mask

# ifdef  INT_LIMIT
ggt (first,incr,anz)
int  *first, incr, anz;
{  int  h, i, j, k;
 for (i=0;i<anz;i++,first+=incr)
    if (*first)  break;
 if (i == anz)  return 0;
 else  j = ABS(*first);
 for (i=i+1,first+=incr; i<anz ; i++,first+=incr)
 {  if (k = ABS(*first))
       while (h = k % j)
       {  k = j,  j = h;
          if (j==1)  return  1;
       }
 }
 return  j;
}

#define  column_simplify(r1,r2,c1,c2)   {  int  a, b, c, d;        \
         for (d=(c1);d<(c2);d++)                                \
         {  c= ggt(&elem[r1][d],MAX_VARS+MAX_ELEM/2,(r2)-(r1)); \
            if (!d  &&  c > 1)                                  \
            {  a = deelem;                                      \
               while (b = a % c)                                \
                  a=pivot,  c=b;                                \
            }                                                   \
            if (c > 1)                                          \
            {  deelem /= c;                                     \
               for (a=(r1);a<(r2);a++)                          \
                  elem[a][d] /= c;                              \
            }                                                   \
         }                                                      \
      }
#define  row_simplify(r1,r2,c1,c2)      {  int  a, b, c, d;        \
         for (a=(r1);a<(r2);a++)                                \
         {  c= ggt(&elem[a][c1],1,(r2)-(r1));                   \
            if (c > 1)                                          \
               for (d=(c1);d<(c2);d++)                          \
                  elem[a][d] /= c;                              \
         }                                                      \
      }
# endif

main(argc,argv)
int  argc;
char  *argv[];
{  int  h, i, j, k, v;
int  len, vars, smalls, carrys[MAX_BITS], index[ANZ];
CHAIN  Chain1;
FILE  *fp;
# ifndef  __unix
#  define  RLIMIT_DATA    2
#  define  RLIMIT_STACK   3
#  define  RLIMIT_CORE    4
int   rlimits[2];
# endif
if (COMPACT < 2*MAX_LENG+4)
{  fprintf(stderr,"Error  COMPACT must be >= 2*MAX_LENG+3\n",argv[0]);
   return 0;
}
if (argc <= 1)
{  fprintf(stderr,"usage: %s smallsteps [max_length [data_file] ]\n",
           argv[0]);
   return 0;
}
else if (sscanf(argv[1],"%d",&i) != 1)
{  fprintf(stderr,"smallsteps is not numerical\n");  return 1;  }
smallsteps = ((star_chain = i<0) ? -i : i);
if (smallsteps > MAX_SMALLS)
{  printf("smallsteps must be <= %d\n",MAX_SMALLS);  return 1;  }
if (argc > 2)

{  if (sscanf(argv[2],"%u",&max_length) != 1)
   {  fprintf(stderr,"max_length is not numerical\n");  return 1;  }
   if (max_length > MAX_LENG-2)
   {  printf("max length must be <= %d\n",MAX_LENG-2);  return 1;  }
}
else
   max_length = MAX_LENG-2;
if (argc > 3)
{  if (!(fp = fopen(argv[3],"w")))
   {  fprintf(stderr,"Error  can not open %s\n",argv[3]);  return -1; }
}
else
   fp = (FILE *) 0;
# ifndef  __unix
getrlimit(RLIMIT_STACK,rlimits);
rlimits[0] = (MAX_LENG*(MAX_BITS*MAX_VARS+2)+(MAX_COND+1)*MAX_VARS+32) *
             (2*MAX_BITS+MAX_LENG+1) + MAX_VARS*(CONDITIONS+MAX_BITS+1) ;
rlimits[0] *= sizeof(int) ;
setrlimit(RLIMIT_STACK,rlimits);
# endif
denom1 = 1;
/**  define first term == 1  (used scratch)  **/
len = 0;
bits1[len] = 1;
for (i=0;i<bits1[len];i++)
{  for (v=0;v<MAX_VARS;v++)
      sequ1[len][i][v] = 0;
}
info1[len] = 0;
cc1 = 0;
vars = 1;
smalls = 0;
len++;
/**  define second term , ever a doubling  **/
for (i=0;i<bits1[len-1];i++)
{  for (v=0;v<MAX_VARS;v++)
      sequ1[len][i][v] = sequ1[len-1][i][v];
   sequ1[len][i][vars] = 1;
}
bits1[len] = bits1[len-1];
info1[len] = ((len-1)<<SHIFT) + 0;
cond1[cc1][0] = -1;
for (v=1;v<MAX_VARS;v++)
   cond1[cc1][v] = 0;
cond1[cc1][vars] = 1;
cc1++;
vars++;
len++;
max_len = len;
max_anz = max_compact = max_cond = 0;
/**  start recursion  **/
admiss = counter=0;
cases=1;
no=1;
if (len <= max_length)
   next_addition(len,chain1,vars,smalls,carrys);

no--;
printf(" %u cases tested: %u(%u) chains generated, ",cases,admiss,counter);
printf("%u different with max length %u\n",no,max_len-1);
printf("max compact <= %u , max conditions <= %u , max anz chains <= %u\n",
     max_compact,max_cond,max_anz);
for (i=0;i<bitsn[no];i++)
for (v=0;v<MAX_VARS;v++)
   number[0][i][v] = number[no][i][v];
bitsn[0] = bitsn[no];
denomn[0] = denomn[no];
for (i=0;i<ccn[no];i++)
for (v=0;v<MAX_VARS;v++)
   condn[0][i][v] = condn[no][i][v];
ccn[0] = ccn[no];
vari[0] = vari[no];
for (i=0;i<compr[no][0];i++)
compr[0][i] = compr[no][i];
for (i=0;i<no;i++)
index[i] = i;
heapsort(no,index);
index[no] = MOST;
if (fp)
{  int  header[8];
header[0] = no;
header[1] = smallsteps;
header[2] = MAX_VARS;
header[3] = MAX_BITS;
header[4] = MAX_REDC;
header[5] = COMPACT;
header[6] = max_len;
header[7] = VERSION;
fwrite( (char*)header, sizeof(int), 8, fp);
fwrite( (char*)bitsn,  sizeof(int), no, fp);
fwrite( (char*)number, sizeof(int)*MAX_BITS*MAX_VARS, no, fp);
fwrite( (char*)denomn, sizeof(int), no, fp);
fwrite( (char*)ccn,    sizeof(int), no, fp);
fwrite( (char*)condn,  sizeof(int)*MAX_REDC*MAX_VARS, no, fp);
fwrite( (char*)compr,  sizeof(int)*COMPACT, no ,fp);
fwrite( (char*)vari,   sizeof(int), no, fp);
(void) fclose(fp);
}
else
for (h=0;index[h] != MOST;h++)
{  no = index[h];
   if (denomn[no] != 1)
      printf("b=%d  ",denomn[no]);
   for (i=0;i<bitsn[no];i++)
   {  printf("%c 2^(", (i ? '+' : ' ') );
      put_term(number[no][i]);
      printf(") ");
   }
   for (i=0;i<ccn[no];i++)
   {  printf(" ,  ");
      v = condn[no][i][0];
      condn[no][i][0] = 0;
      put_term(condn[no][i]);

   condn[no][i][0] = v;
   printf(" >= %d",-v);
}
printf("\n");
len = compr[no][1];
denom1 = compr[no][3];
k=4;
for (i=0;i<len;i++)
   info1[i] = compr[no][k++];
for (i=0;i<len;i++)
   bits1[i] = compr[no][k++];
for (i=0;i<len;i++)
   for (j=0;j<bits1[i];j++)
   {  for (v=1;v<MAX_VARS;v++)
         sequ1[i][j][v] = 0;
      while (k < COMPACT)
      {  v = compr[no][k] & (1<<VBITS)-1;
         sequ1[i][j][v] = compr[no][k++]>>VBITS;
         if (!v)  break;
      }
   }
cc1=0;
put_chain((unsigned)(h+1),len,chain1);
}
return 0;
}

next_addition(len,chain1,vars,smalls,carrys)
int  len, vars, smalls, carrys[MAX_BITS];
CHAIN  Chain1;
{  int  h, i, j, k, v, carsave;
CHAIN  Chain2;
if (smalls > smallsteps)  return;
/**  check monotony of sums in leading term  **/
for (j=1;j<len;j++)
{  for (v=0;v<vars;v++)
elem[j-1][v] = sequ1[j][0][v] - (j>1?sequ1[j-1][0][v]:0);
}
for (i=0;i<cc1;i++)
for (v=0;v<vars;v++)
elem[len-1+i][v] = cond1[i][v];
if (check_conditions(vars,len-1+cc1) < 0)
return;
/**  check strict monotony of terms in each sum whith conditions  **/
for (j=len-1;j;j--)
{  if (!(info1[j]&MASK))  continue;
for (i=1;i<bits1[j];i++)
{  for (v=0;v<vars;v++)
   elem[i-1][v] = sequ1[j][i-1][v] - sequ1[j][i][v];
elem[i-1][0] -= 1;
}
k = bits1[j]-1;
for (v=0;v<vars;v++)
elem[k][v] = sequ1[j][k][v];

   for (i=0;i<cc1;i++)
      for (v=0;v<vars;v++)
         elem[bits1[j]+i][v] = cond1[i][v];
   if (check_conditions(vars,bits1[j]+cc1) < 0)
      return;
}
if (bits1[len-1] > 1<<smalls)
{   printf("BIG  ");
    put_chain(cases,len,chain1);
}
if (len > max_len)
   max_len = len;
if (smalls == smallsteps)
{  ++counter;
#ifndef  TEST
   if (!(counter&(1<<14)-1))   fprintf(stderr,"%8d",counter);
#endif
   if  (normalize_result(len,chain1,vars) < 0)  return;
}
if (len > max_length)
   return;
/**  copy sequ1 to sequ2  **/
for (j=0;j<len;j++)
{  for (i=0;i<bits1[j];i++)
      for (v=0;v<MAX_VARS;v++)
         sequ2[j][i][v] = sequ1[j][i][v];
   info2[j] = info1[j];
   bits2[j] = bits1[j];
}
denom2 = denom1;
for (j=0;j<cc1;j++)
   for (v=0;v<MAX_VARS;v++)
      cond2[j][v] = cond1[j][v];
/**  test possible elements (h,j) for next sum  **/
carsave = carrys[0];
for (j=len-1;j;j--)
{  for (h=1;h<=j;h++)
   {  if (h==j  &&  (info1[j]&MASK))  continue;
/**  copy first term of element j to new sum  **/
      for (v=0;v<MAX_VARS;v++)
         sequ2[len][0][v] = sequ2[j][0][v];
      info2[len] = (j<<SHIFT) + h;
      bits2[len] = 1;
      cc2=cc1;
      carrys[0] = 0;
      k=h;
/**  look for shift_variable  **/
      if (!(info2[h]&MASK))
      {  if (vars >= MAX_VARS)
         {  fprintf(stderr,"Error  MAX_VARS exceeded\n");  continue; }
         k = info2[h]>>SHIFT;
/**  copy element k to element 0  **/
         if (k)
         {  for (i=0;i<bits2[k];i++)
            {  for (v=0;v<MAX_VARS;v++)
                  sequ2[0][i][v] = sequ2[k][i][v];

      sequ2[0][i][vars] = 1;
      sequ2[0][i][0]++;
   }
   info2[0] = info2[k];
   bits2[0] = bits2[k];
}
else
{  for (v=0;v<MAX_VARS;v++)
      sequ2[0][0][v] = 0;
   sequ2[0][0][vars] = 1;
   info2[0] = 0;
   bits2[0] = 1;
}
if (cc2 >= MAX_COND)
{  fprintf(stderr,"Error  MAX_COND exceeded\n");  continue; }
if (k)
{  for (v=0;v<MAX_VARS;v++)
      cond2[cc2][v] = sequ1[h][0][v] - sequ1[k][0][v];
   cond2[cc2][0] -= 1;
}
else
   for (v=0;v<MAX_VARS;v++)
      cond2[cc2][v] = sequ1[h][0][v];
cond2[cc2][vars] = -1;
if (h==j)  cond2[cc2][0] -= 1;
cc2++;
k=0;
}
v = (sequ2[len-1][0][0] != sequ2[j][0][0]);
add_binary(len,chain2,vars+!k,smalls+1+v,j,k,1,0,0,carrys);
}
carrys[0] = carsave;
/**  both elements are equal => pseudo_double step  **/
if (j == len-1  &&  !(info2[j]&MASK))  break;
if (vars >= MAX_VARS)
{  fprintf(stderr,"Error  MAX_VARS exceeded\n");  break; }
for (i=0;i<bits2[j];i++)
{  for (v=0;v<MAX_VARS;v++)
sequ2[len][i][v] = sequ2[j][i][v];
sequ2[len][i][vars] = 1;
sequ2[len][i][0]++;
}
bits2[len] = bits2[j];
info2[len] = (j<<SHIFT) + 0;
cc2=cc1;
cases++;
if (sequ2[len][0][0] == sequ2[len-1][0][0])
/**  check new element is greater previous  **/
{  for (k=0;k<bits2[len-1];k++)
{  if (k >= bits2[len])  return;
for (v=1;v<vars;v++)
   if (sequ2[len][k][v] != sequ2[len-1][k][v])  break;
if (v != vars)
{  for (i=k+1;i<bits2[len-1];i++)
   {  for (v=1;v<vars;v++)
         if (sequ2[len][k][v] != sequ2[len-1][i][v])  break;

            if (v==vars)
            {  if (sequ2[len][k][0] - sequ2[len-1][i][0] < i-k)  return;
               else  break;
            }
         }
         break;
      }
      else if (sequ2[len][k][0] > sequ2[len-1][k][0])  break;
      else if (sequ2[len][k][0] < sequ2[len-1][k][0])  return;
   }
   if (k == bits2[len-1]  &&  bits2[len] >= bits2[len-1])
      return;
   next_addition(len+1,chain2,vars+1,smalls+1,carrys);
}
else if (sequ2[len][0][0] > sequ2[len-1][0][0])
   next_addition(len+1,chain2,vars+1,smalls,carrys);
else
   return;
if (!(info2[j]&MASK)  ||  sequ2[len-1][0][0] > sequ2[j][0][0]+1)
   break;
if (star_chain)  break;
}
return;
}

add_binary(len,chain1,vars,smalls,indices12,carrys)
int  len, vars, smalls, indices12, carrys[MAX_BITS];
CHAIN  Chain1;
{  int  v, h, i, k, carsave;
if (next1 < bits1[index1])
{  k = bits1[len];
if (k >= MAX_BITS)
{  fprintf(stderr,"Error  MAX_BITS exceeded\n");  return; }
for (v=0;v<MAX_VARS;v++)
   sequ1[len][k][v] = sequ1[index1][next1][v];
for (i=0;i<k;i++)
{  for (v=1;v<vars;v++)
      if (sequ1[len][k][v] != sequ1[len][i][v])  break;
   if (v == vars)
      if (k-i > sequ1[len][i][0]-carrys[i] - sequ1[len][k][0])
         return;
}
carsave = carrys[k];
carrys[k] = 0;
bits1[len]++;
next1++;
mask &= ~(1<<k);
add_binary(len,chain1,vars,smalls,indices12,carrys);
next1--;
bits1[len]--;
carrys[k] = carsave;
}
if (next2 < bits1[index2])
{  k = bits1[len];
if (k >= MAX_BITS)

{  fprintf(stderr,"Error  MAX_BITS exceeded\n");  return;  }
for (v=0;v<MAX_VARS;v++)
   sequ1[len][k][v] = sequ1[index2][next2][v];
h=0;
for (i=0;i<k;i++)
{  for (v=1;v<vars;v++)
      if (sequ1[len][k][v] != sequ1[len][i][v])  break;
   if (v == vars)
   {  if (k-1-i > sequ1[len][i][0]-carrys[i] - sequ1[len][k][0])
         return;
      if (k-1-i == sequ1[len][i][0]-carrys[i] - sequ1[len][k][0])
         h=1;
   }
}
carsave = carrys[k];
carrys[k] = 0;
bits1[len]++;
next2++;
mask |= 1<<k;
if (!h)
   add_binary(len,chain1,vars,smalls,indices12,carrys);
if ((mask&1<<(k-1))==0  &&  !carrys[k-1])
   add_bincar(len,chain1,vars,smalls,indices12,carrys);
next2--;
bits1[len]--;
carrys[k] = carsave;
return;
}
if (next1 == bits1[index1]  &&  next2 == bits1[index2])
/**  check new element is greater previous  **/
{  if (sequ1[len][0][0] < sequ1[len-1][0][0])
   return;
for (k=0;k<bits1[len-1];k++)
{  if (k >= bits1[len])  return;
   for (v=1;v<vars;v++)
      if (sequ1[len][k][v] != sequ1[len-1][k][v])  break;
   if (v != vars)
   {  for (i=k+1;i<bits1[len-1];i++)
      {  for (v=1;v<vars;v++)
            if (sequ1[len][k][v] != sequ1[len-1][i][v])  break;
         if (v==vars)
         {  if (sequ1[len][k][0] - sequ1[len-1][i][0] < i-k)  return;
            else  break;
         }
      }
      break;
   }
   else if (sequ1[len][k][0] > sequ1[len-1][k][0])  break;
   else if (sequ1[len][k][0] < sequ1[len-1][k][0])  return;
}
if (k == bits1[len-1]  &&  bits1[len] == bits1[len-1])
   return;
k=0;
for (i=1;i<len;i++)
{  for (v=1;v<vars;v++)
      if (sequ1[i+1][0][v] != sequ1[i][0][v])  break;

      if (v==vars)
      {  if (sequ1[i+1][0][0] < sequ1[i][0][0])
            return;
         else if (sequ1[i+1][0][0] == sequ1[i][0][0])  k++;
      }
      else if (sequ1[i+1][0][0] <= sequ1[i][0][0])
      {  for (;v<vars;v++)
            if (sequ1[i+1][0][v] > sequ1[i][0][v])  break;
         if (v==vars)  k++;
         if (v==vars  &&  sequ1[i+1][0][0] < sequ1[i][0][0])
            return;
      }
   }
   if (k > smalls)  return;
   len++;
   cases++;
   next_addition(len,chain1,vars,smalls,carrys);
}
return;
}

add_bincar(len,chain1,vars,smalls,indices12,carrys)
int  len, vars, smalls, indices12, carrys[MAX_BITS];
CHAIN  Chain1;
{
int  h, i, j, k, v, l, pivot, coeff[MAX_VARS];
CHAIN  Chain2;
h=bits1[len];
/**  copy sequ1 to sequ2  **/
for (j=0;j<=len;j++)
{  for (i=0;i<bits1[j];i++)
      for (v=0;v<MAX_VARS;v++)
         sequ2[j][i][v] = sequ1[j][i][v];
   info2[j] = info1[j];
   bits2[j] = bits1[j];
}
denom2 = denom1;
for (j=0;j<cc1;j++)
   for (v=0;v<MAX_VARS;v++)
      cond2[j][v] = cond1[j][v];
cc2 = cc1;
/**  find highest variable  **/
for (v=0;v<vars;v++)
   coeff[v] = sequ2[len][h-2][v] - sequ2[len][h-1][v];
for (k=vars-1;k;k--)
   if (coeff[k])  break;
if (k)
{  for (v=1;v<vars;v++)
      if (coeff[v] < 0)  break;
   if (v==vars  &&  coeff[0] > 0)
      return;
   for (v=1;v<vars;v++)
      if (coeff[v] > 0)  break;
   if (v==vars  &&  coeff[0] < 0)
      return;

do {
pivot = coeff[k];
/**  look for appropriate pivot  **/
if (pivot != 1  &&  pivot != -1)
for (v=vars-1;v>=0;v--)
{  if (!coeff[v])
continue;
else if (coeff[v] % ABS(pivot))
{  if (v==0)  return;
for (v=v+1;v<vars;v++)
   coeff[v] *= pivot;
pivot = 0;
for (k=k-1;k;k--)
   if (coeff[k])  break;
if (k)  break;
for (k=vars-1;k;k--)
   if (coeff[k])  break;
pivot = ABS(coeff[k]);
for (v=k-1;v;v--)
   if (coeff[v]  &&  coeff[v] < pivot  &&  -coeff[v] < pivot)
      pivot = ABS(coeff[k=v]);
if (coeff[k] < 0)
   for (v=0;v<vars;v++)
      coeff[v] = -coeff[v];
pivot = coeff[k];
/***    fprintf(stderr,"Warning pivot non integral %d\n",pivot);  **/
for (l=0;l<=len;l++)
   for (i=0;i<bits1[l];i++)
      for (v=0;v<vars;v++)
         if (v!=k)  sequ2[l][i][v] *= pivot;
for (j=0;j<cc2;j++)
   for (v=0;v<vars;v++)
      if (v!=k)  cond2[j][v] *= pivot;
coeff[k] = 1;
denom2 *= pivot;
break;
}
coeff[v] /= pivot;
}
else if (pivot == -1)
for (v=0;v<vars;v++)
coeff[v] = -coeff[v];
} while (!pivot);
for (v=1;v<vars;v++)
if (coeff[v] < 0)  break;
if (v==vars  &&  coeff[0] > 0)
return;
/**  substitute variable  **/
for (l=0;l<=len;l++)
for (i=0;i<bits1[l];i++)
{  if (pivot = sequ2[l][i][k])
{  for (v=0;v<vars;v++)
sequ2[l][i][v] -= pivot * coeff[v];
for (v=1;v<vars;v++)
if (sequ2[l][i][v] > 0)  break;
if (v==vars)  return;

}
}
for (j=0;j<cc2;j++)
{  if (pivot = cond2[j][k])
for (v=0;v<vars;v++)
   cond2[j][v] -= pivot * coeff[v];
}
if (cc2 >= MAX_COND)
{  fprintf(stderr,"Error  MAX_COND exceeded\n");  return; }
for (v=0;v<vars;v++)
cond2[cc2][v] = -coeff[v];
for (v=vars;v<MAX_VARS;v++)
cond2[cc2][v] = 0;
cond2[cc2][k] = 0;
cc2++;
/**  check conditions  **/
for (j=0;j<cc2;j++)
{  for (v=1;v<vars;v++)
if (cond2[j][v])  break;
if (v==vars)
{  if (cond2[j][0] < 0)
   return;
for (v=0;v<vars;v++)
   cond2[j][v] = cond2[cc2-1][v];
cc2--;
j--;
continue;
}
for (v=1;v<vars;v++)
if (cond2[j][v] > 0)  break;
if (v==vars)
{  if (cond2[j][0] < 0)
   return;
else if (cond2[j][0] == 0)
{  for (v=1;v<vars;v++)
      if (cond2[j][v] < 0)
      {  for (l=0;l<=len;l++)
            for (i=0;i<bits2[l];i++)
               sequ2[l][i][v] = 0;
         for (i=0;i<cc2;i++)
            cond2[i][v] = 0;
      }
   j= -1;  /* restart of condition checking */
}
}
}
for (j=0;j<cc2;j++)
for (i=j+1;i<cc2;i++)
{  for (v=1;v<vars;v++)
   if (cond2[j][v] != cond2[i][v])  break;
if (v==vars)
{  if (cond2[j][0] > cond2[i][0])
      cond2[j][0] = cond2[i][0];
   for (v=0;v<vars;v++)
      cond2[i][v] = cond2[cc2-1][v];
   i--;

            cc2--;
         }
      }
   for (j=0;j<cc2;j++)
      for (v=0;v<vars;v++)
         elem[j][v] = cond2[j][v];
   if (check_conditions(vars,cc2) < 0)
      return;
}
else if (coeff[k])
   return;
bits2[len]--;
k = bits2[len]-1;
sequ2[len][k][0]++;
h=0;
for (i=0;i<k;i++)
{  for (v=1;v<vars;v++)
      if (sequ2[len][k][v] != sequ2[len][i][v])  break;
   if (v == vars)
   {  if (k-1-i > sequ2[len][i][0]-carrys[i] - sequ2[len][k][0]+1)
         return;
      if (k-1-i == sequ2[len][i][0]-carrys[i] - sequ2[len][k][0]+1)
{  if (!h)
    for (j=i;j<k;j++)
       if (carrys[j])  return;
         h=1;
      }
      else if (sequ2[len][k][0] == sequ2[len][i][0])
         h=1;
   }
}
carrys[k] = carrys[k+1]+1;
if (bits2[len] == 1)
{  if (!h)
      add_binary(len,chain2,vars,smalls-1,indices12,carrys);
}
else
{  if (!h  &&  sequ2[len][0][0] >= sequ2[len-1][0][0])
      add_binary(len,chain2,vars,smalls,indices12,carrys);
   if (!carrys[k-1])
      add_bincar(len,chain2,vars,smalls,indices12,carrys);
}
carrys[k] = 0;
return;
}

normalize_result(len,chain1,vars)
int  len, vars;
CHAIN  Chain1;
{
int  bitsb, num[MAX_BITS][MAX_VARS], ccb, condb[CONDITIONS][MAX_VARS],
     denomb, coeff[MAX_VARS], pivot;
int  h, i, j, k, v, w;
if (vars == MAX_VARS)
   return( fprintf(stderr,"Error  MAX_VARS exceeded in normalize\n"), -1);

bitsb = bits1[len-1];
for (i=0;i<bitsb;i++)
   for (v=0;v<vars;v++)
      num[i][v] = sequ1[len-1][i][v];
(void) check_next_condition(&vars,(int*) 0);
k=0;
for (i=0;i<cc1;i++)
{  for (v=0;v<vars;v++)
      condb[k][v] = cond1[i][v];
   if (check_next_condition(&k,condb[k]) < 0)
      return -1;
}
denomb=denom1;
for (h=1;h<len;h++)
{  for (i=1;i<bits1[h];i++)
   {  if (k >= CONDITIONS)
         return( fprintf(stderr,"Error  too many conditions\n"), -1);
      for (v=0;v<vars;v++)
         condb[k][v] = sequ1[h][i-1][v] - sequ1[h][i][v];
      condb[k][0] -= 1;
      if (check_next_condition(&k,condb[k]) < 0)
         return -1;
   }
   if (k >= CONDITIONS)
      return( fprintf(stderr,"Error  too many conditions\n"), -1);
   for (v=0;v<vars;v++)
      condb[k][v] = sequ1[h][bits1[h]-1][v];
   if (check_next_condition(&k,condb[k]) < 0)
      return -1;
}
for (h=2;h<len;h++)
{  for (i=0;i<bits1[h-1];i++)
   {  if (bits1[h] == i)
         return -1;
      for (v=0;v<vars;v++)
         if (sequ1[h][i][v] != sequ1[h-1][i][v])  break;
      if (v != vars)
      {  if (k >= CONDITIONS)
            return( fprintf(stderr,"Error  too many conditions\n"), -1);
         for (v=0;v<vars;v++)
            condb[k][v] = sequ1[h][i][v] - sequ1[h-1][i][v];
         condb[k][0] -= 1;
         if (check_next_condition(&k,condb[k]) < 0)
            return -1;
         break;
      }
   }
   if (i == bits1[h-1]  &&  bits1[h] == bits1[h-1])
      return -1;
}
for (w=2;w<vars;w++)   /*  always  A >= 1  */
{  for (i=0;i<k;i++)
   {  for (v=1;v<vars;v++)
         if (condb[i][v] && v != w)  break;
      if (v==vars)  break;
   }

if (v != vars)
{  if (k >= CONDITIONS)
   return( fprintf(stderr,"Error  too many conditions\n"), -1);
for (v=0;v<vars;v++)
   condb[k][v] = 0;
condb[k][w] = 1;
k++;
}
}
ccb = k;
w=0;
for (j=0;j<bitsb;j++)
{
/**  find highest variable  **/
for (k=w+1;k<vars;k++)
if (num[j][k])  break;
if (k != vars)
{  pivot = 1;
for (;k<vars;k++)
   if (num[j][k] == 1  ||  num[j][k] == -1)  break;
if (k == vars)
{  for (v=vars-1;v>w;v--)
      if (coeff[v]=num[j][v])   k=v;
   for (v=w;v>=0;v--)
      coeff[v]=num[j][v];
   pivot = ABS(coeff[k]);
   for (v=k+1;v<vars;v++)
      if (coeff[v]  &&  coeff[v] < pivot  &&  -coeff[v] < pivot)
         pivot = ABS(coeff[k=v]);
   if (coeff[k] < 0)
      for (v=0;v<vars;v++)
         coeff[v] = -coeff[v];
   pivot = coeff[k];
   for (i=0;i<bitsb;i++)
      for (v=0;v<vars;v++)
         if (v!=k)  num[i][v] *= pivot;
   for (i=0;i<ccb;i++)
      for (v=0;v<vars;v++)
         if (v!=k)  condb[i][v] *= pivot;
   coeff[k] = 1;
}
else if (num[j][k] == -1)
   for (v=0;v<vars;v++)
      coeff[v] = -num[j][v];
else
   for (v=0;v<vars;v++)
      coeff[v] = num[j][v];
w++;
coeff[vars] = coeff[w];
coeff[w] = (num[j][k] < 0 ? denomb : -denomb);
denomb *= pivot;
for (i=0;i<bitsb;i++)
{  num[i][vars] = num[i][w];
   num[i][w] = 0;
}
for (i=0;i<ccb;i++)

{  condb[i][vars] = condb[i][w];
   condb[i][w] = 0;
}
if (k==w)  k=vars;
/**  substitute variable  **/
for (i=0;i<bitsb;i++)
{  pivot = num[i][k];
   for (v=0;v<=vars;v++)
      num[i][v] -= pivot * coeff[v];
}
for (i=0;i<ccb;i++)
{  pivot = condb[i][k];
   for (v=0;v<=vars;v++)
      condb[i][v] -= pivot * coeff[v];
}
for (i=0;i<bitsb;i++)
{  num[i][k] = num[i][vars];
   num[i][vars] = 0;
}
for (i=0;i<ccb;i++)
{  condb[i][k] = condb[i][vars];
   condb[i][vars] = 0;
}
}
}
w++;
pivot = denomb;
if (pivot > 2)
{  for (j=0;pivot!=1 && j<bitsb;j++)
for (v=0;v<vars;v++)
   if (num[j][v])
   {  i = pivot;
      h = ABS(num[j][v]);
      while (k = i % h)
         i = h,   h = k;
      pivot = h;
      if (pivot == 1)  break;
   }
for (j=0;pivot!=1 && j<ccb;j++)
for (v=0;v<vars;v++)
   if (condb[j][v])
   {  i = pivot;
      h = ABS(condb[j][v]);
      while (k = i % h)
         i = h,   h = k;
      pivot = h;
      if (pivot == 1)  break;
   }
}
else if (pivot == 2)
{  for (j=0;pivot!=1 && j<bitsb;j++)
for (v=0;v<vars;v++)
   if (num[j][v]&1)
   {  pivot=1;  break;  }
for (j=0;pivot!=1 && j<ccb;j++)

for (v=0;v<vars;v++)
if (condb[j][v]&1)
{  pivot=1;  break;  }
}
if (pivot != 1)
{  for (i=0;i<bitsb;i++)
for (v=0;v<vars;v++)
num[i][v] /= pivot;
for (i=0;i<ccb;i++)
for (v=0;v<vars;v++)
condb[i][v] /= pivot;
denomb /= pivot;
}
/**  force exact values  **/
for (i=0;i<bitsb;i++)
for (j=i+1;j<bitsb;j++)
{  if (j==i+1)
{  for (v=0;v<vars;v++)
   coeff[v] = num[j][v] - num[i][v];
coeff[0]+=1;
for (h=0;h<ccb;h++)
{  for (v=1;v<vars;v++)
      if (condb[h][v] != coeff[v])  break;
   if (v==vars)
      if (coeff[0] == condb[h][0])  break;
}
if (h==ccb)  break;
}
else
for (v=1;v<vars;v++)
   if (num[i][v] != num[j][v])  break;
if (v==vars)
{  if (j==i+1)
   ;
else if (num[i][0] - num[j][0] < j-i)
   return -1;
else if (num[i][0] - num[j][0] > j-i)
{  for (v=1;v<vars;v++)
      if (num[i+1][v] != num[j-1][v])  break;
   if (v != vars)
      break;
   else if (num[i][0]-num[i+1][0]+num[j-1][0]-num[j][0] != 2)
      break;
}
for (v=0;v<vars;v++)
   coeff[v] = num[j][v] - num[j-1][v];
coeff[0]++;
for (k=vars-1;k;k--)
   if (coeff[k] == 1  ||  coeff[k] == -1)  break;
if (!k)  continue;
if (coeff[k] == -1)
   for (v=0;v<vars;v++)
      coeff[v] = -coeff[v];
for (h=0;h<bitsb;h++)
   if (pivot = num[h][k])
      for (v=0;v<vars;v++)

                  num[h][v] -= pivot*coeff[v];
         for (h=0;h<ccb;h++)
            if (pivot = condb[h][k])
               for (v=0;v<vars;v++)
                  condb[h][v] -= pivot*coeff[v];
         for (h=0;h<bitsb;h++)
         {  for (v=k+1;v<w;v++)
               num[h][v-1] = num[h][v];
            num[h][w-1] = 0;
         }
         w--;
         for (h=0;h<ccb;h++)
         {  for (v=k+1;v<vars;v++)
               condb[h][v-1] = condb[h][v];
            condb[h][vars-1] = 0;
         }
         j--;
      }
   }
reduce_conditions(bitsb,num,w,&ccb,condb,vars);
/**  store in global arrays  **/
for (i=0;i<bitsb;i++)
{  for (v=0;v<vars;v++)
      number[no][i][v] = num[i][v];
   for (;v<MAX_VARS;v++)
      number[no][i][v] = 0;
}
bitsn[no] = bitsb;
denomn[no] = denomb;
if (ccb > MR*MAX_REDC)
{  fprintf(stderr,"Error   MR*MAX_REDC exceeded\n");  ccb=MR*MAX_REDC;  }
for (i=0;i<ccb;i++)
{  for (v=0;v<vars;v++)
      condn[no][i][v] = condb[i][v];
   for (;v<MAX_VARS;v++)
      condn[no][i][v] = 0;
}
ccn[no] = ccb;
vari[no] = w;
return  arrange_in_order(len,chain1,vars);
}

arrange_in_order(len,chain1,vars)
int  len, vars;
CHAIN  Chain1;
{
int  bitsb, coeff[MAX_VARS], pivot, star_bit;
int  h, i, j, k, v, w, d;
admiss++;
for (i=1;i<len;i++)
   if (info1[i]>>SHIFT != i-1)  break;
star_bit = (i==len);
/**  match conditions  **/
w=2;
for (j=1;j<no;j++)

{  d=0;
if (bitsn[j] != bitsn[no]  ||  denomn[j] != denomn[no])  continue;
bitsb = bitsn[no];
for (i=0;i<bitsb;i++)
{  for (v=0;v<MAX_VARS;v++)
if (number[j][i][v] != number[no][i][v])  break;
if (v!=MAX_VARS)
{  for (v=0;v<MAX_VARS;v++)
   if (number[j][i][v] || number[no][i][v])  break;
if (number[j][i][v] == 0)
{  d=j;
   for (v=v+1;v<MAX_VARS;v++)
      if (number[d][i][v])  break;
}
else if (number[no][i][v] == 0)
{  d=no;
   for (v=v+1;v<MAX_VARS;v++)
      if (number[d][i][v])  break;
}
break;
}
}
if (v != MAX_VARS  &&  d)
{  k=v;
for (v=k+1;v<MAX_VARS;v++)
if (number[d][i][v])  break;
if (v==MAX_VARS)
{  for (h=0;h<bitsb;h++)
   for (v=0;v<MAX_VARS;v++)
      number[0][h][v] = number[d][h][v];
bitsn[0] = bitsn[d];
for (h=0;h<ccn[d];h++)
   for (v=0;v<MAX_VARS;v++)
      condn[0][h][v] = condn[d][h][v];
ccn[0] = ccn[d];
do {
   for (v=0;v<MAX_VARS;v++)
      coeff[v] = number[no+j-d][i][v];
   if ((pivot=number[0][i][k]) != 1)
   {  for (v=0;v<MAX_VARS;v++)
         if (coeff[v]  &&  coeff[v] % pivot)  break;
      if (v == MAX_VARS)
      {  for (v=0;v<MAX_VARS;v++)
            if (coeff[v])
               coeff[v] /= pivot;
      }
      else
         break;
   }
   coeff[k] = -1;
   for (h=0;h<bitsb;h++)
      if (pivot = number[0][h][k])
         for (v=0;v<MAX_VARS;v++)
            number[0][h][v] += pivot * coeff[v];
   for (h=0;h<ccn[0];h++)
      if (pivot = condn[0][h][k])

      for (v=0;v<MAX_VARS;v++)
         condn[0][h][v] += pivot * coeff[v];
for (i=i+1;i<bitsb;i++)
{  for (v=0;v<MAX_VARS;v++)
      if (number[0][i][v] != number[no+j-d][i][v])  break;
   if (v!=MAX_VARS)
   {  for (v=0;v<MAX_VARS;v++)
         if (number[0][i][v])  break;
      if (v==MAX_VARS)  v=k;
      break;
   }
}
if (v==MAX_VARS  ||  v<=k)  break;
k=v;
if (number[no+j-d][i][k])   break;
for (v=k+1;v<MAX_VARS;v++)
   if (number[0][i][v])  break;
} while (v==MAX_VARS);
if (v==MAX_VARS  &&  ccn[0])
{  for (i=1;i<bitsb;i++)
{  for (v=0;v<vars;v++)
      elem[i-1][v] = number[0][i-1][v] - number[0][i][v];
   elem[i-1][0] -= 1;
}
for (v=0;v<vars;v++)
   elem[bitsb-1][v] = number[0][bitsb-1][v];
for (i=0;i<ccn[0];i++)
   for (v=0;v<vars;v++)
      elem[bitsb+i][v] = condn[0][i][v];
if (check_conditions(vars,bitsb+ccn[0]) < 0)
   v=0;
else
{  reduce_conditions(bitsb,number[0],vari[no+j-d],
                     &ccn[0],condn[0],vars);
   v = MAX_VARS;
}
}
}
}
if (v==MAX_VARS)
{  if (d)
{  k=0;  h=no+j-d;  w=1;  }
else if (ccn[no] < ccn[j])
{  k=no;  h=j;  w=1;  }
else if (ccn[no] > ccn[j])
{  k=j;  h=no;  w=1;  }
else
{  k=no;  h=j;  w=0;  }
for (i=0,d=0;i<ccn[k]&&d<ccn[h];i++,d++)
{  for (v=MAX_VARS-1;v;v--)
if (!condn[h][d][v] != !condn[k][i][v])  break;
if (!v)
for (v=MAX_VARS-1;v;v--)
   if (condn[h][d][v] != condn[k][i][v])  break;
if (v)
{  if (!condn[k][i][v]  ||

        condn[h][d][v]  &&  condn[k][i][v] < condn[h][d][v])
   {  k^=h;  h^=k;  k^=h;
      i^=d;  d^=i;  i^=d;
      w++;
   }
   else
      w |= 1;
   i--;
}
else if (condn[k][i][0] != condn[h][d][0])
{  if (condn[k][i][0] < condn[h][d][0])
   {  k^=h;  h^=k;  k^=h;
      i^=d;  d^=i;  i^=d;
      w++;
   }
   else
      w |= 1;
}
if (w >= 2)  break;
}
if (i < ccn[k]  &&  d == ccn[h])
{  k^=h;  h^=k;  k^=h;
i^=d;  d^=i;  i^=d;
w++;
}
v = compr[j][4]&1;
if (w > 1)
continue;
else if (!w && (v > star_bit || v==star_bit && len >= compr[j][1]) )
break;
else if (!w  ||  k==no  ||  k==0  &&  h==j)
{  for (i=0;i<bitsn[no-1];i++)
   for (v=0;v<MAX_VARS;v++)
      number[j][i][v] = number[no-1][i][v];
bitsn[j] = bitsn[no-1];
denomn[j] = denomn[no-1];
for (i=0;i<ccn[no-1];i++)
   for (v=0;v<MAX_VARS;v++)
      condn[j][i][v] = condn[no-1][i][v];
ccn[j] = ccn[no-1];
vari[j] = vari[no-1];
for (i=0;i<compr[no-1][0];i++)
   compr[j][i] = compr[no-1][i];
for (i=0;i<bitsn[no];i++)
   for (v=0;v<MAX_VARS;v++)
      number[no-1][i][v] = number[no][i][v];
bitsn[no-1] = bitsn[no];
denomn[no-1] = denomn[no];
for (i=0;i<ccn[no];i++)
   for (v=0;v<MAX_VARS;v++)
      condn[no-1][i][v] = condn[no][i][v];
ccn[no-1] = ccn[no];
vari[no-1] = vari[no];
j--;
no--;
if (!w)

      {  w=2;
         break;
      }
      else
      {  w=2;
         continue;
      }
   }
   else
      break;
}
}
if (w < 2)  return 0;
if (no == ANZ-MR-1)
fprintf(stderr,"Error   MAX_ANZ exceeded\n");
if (no < ANZ-MR)
{  if (ccn[no] > max_cond)
   max_cond = ccn[no];
if (ccn[no] > MAX_REDC)
{  fprintf(stderr,"Error   MAX_REDC exceeded\n");  ccn[no]=MAX_REDC;  }
if (vars >= 1<<VBITS)
   fprintf(stderr,"Error  VBITS too less %d variables\n", vars);
k=1;
compr[no][k++] = len;
compr[no][k++] = VBITS;
compr[no][k++] = denom1;
if (k+len < COMPACT)
{  compr[no][k++] = star_bit;
   for (i=1;i<len;i++)
      compr[no][k++] = info1[i];
}
else
   k += len;
if (k+len < COMPACT)
   for (i=0;i<len;i++)
      compr[no][k++] = bits1[i];
else
   k += len;
for (i=0;i<len;i++)
   for (j=0;j<bits1[i];j++)
   {  for (v=vars-1;v;v--)
         if (sequ1[i][j][v])
         {  if (k < COMPACT)
               compr[no][k++] = sequ1[i][j][v]<<VBITS | v;
            else
               k++;
         }
      if (k < COMPACT)
         compr[no][k++] = sequ1[i][j][0]<<VBITS;
   }
if (k >= COMPACT)
   fprintf(stderr,"Error  COMPACT <= %d \n", k);
compr[no][0] = (k < COMPACT ? k : COMPACT);
if (k > max_compact)  max_compact = k;
no++;
if (no >= max_anz)  max_anz = no;

}
return 1;
}

#define  delete_multiple_conditions(i,j,ccb)                    \
   for (j=0;j<ccb;j++)                                 \
      for (i=0;i<ccb;i++)                              \
      {  if (i == j)  continue;                        \
         for (v=0;v<vars;v++)                          \
            if (condb[j][v] > condb[i][v])  break;     \
         if (v==vars)                                  \
         {  for (v=0;v<vars;v++)                       \
               condb[i][v] = condb[ccb-1][v];          \
            i--;                                       \
            ccb--;                                     \
            if (j==ccb)  break;                        \
         }                                             \
      }

reduce_conditions(bitsb,num,w,ccc,condb,vars)
int  bitsb, num[MAX_BITS][MAX_VARS], w, vars,
*ccc, condb[CONDITIONS][MAX_VARS];
{
int  h, i, j, k, v, ccb = *ccc, pivot;
for (j=0;j<ccb;j++)
{  if (condb[j][0] < 0)  continue;
for (v=1;v<vars;v++)
if (condb[j][v] < 0)  break;
if (v==vars)
{  for (v=0;v<vars;v++)
   condb[j][v] = condb[ccb-1][v];
j--;
ccb--;
}
}
delete_multiple_conditions(i,j,ccb);
/**  check free variables  **/
for (j=w;j<vars;j++)
{  for (h=0;h<ccb;h++)
if (condb[h][j] > 0)  break;
for (i=h+1;i<ccb;i++)
if (condb[i][j] > 0)  break;
for (k=0;k<ccb;k++)
if (condb[k][j] < 0)  break;
if (h < ccb  &&  i == ccb  &&  k != ccb)
{  for (i=0;i<ccb;i++)
   for (v=0;v<vars;v++)
      elem[i][v] = condb[i][v];
if ((k=check_conditions(vars,ccb)) < 0)
{  fprintf(stderr,"Error  reduce check conditions vari\n");
   continue;
}
else if (ccb >= CONDITIONS)
{  fprintf(stderr,"Error  reduce conditions exceeded\n");

   continue;
}
else
{  for (v=0;v<vars;v++)
      condb[ccb][v] = condb[h][v];
   condb[ccb][j] = 0;
   for (v=1;v<vars;v++)
      if (condb[ccb][v])  break;
   if (v==vars)
   {  if (condb[ccb][0] > 0)   condb[h][0] = 0;
   }
   else if (minimize_condition(vars,k,condb[ccb]) > 0)
      goto other;
}
if (condb[h][j] != 1)
{  pivot = condb[h][j];
   for (v=0;v<vars;v++)
      if (k = ABS(elem[h][v]))
      {  while (i = k % pivot)
            k = pivot,  pivot = i;
         if (pivot == 1)  break;
      }
   if (v==vars)
      for (v=0;v<vars;v++)
         condb[h][v] /= pivot;
   if (condb[h][j] != 1)
   {  pivot = condb[h][j];
      for (i=0;i<ccb;i++)
      {  if (i!=h)
            for (v=0;v<vars;v++)
               if (v!=j)
                  condb[i][v] *= pivot;
      }
      condb[h][j] = 1;
   }
}
for (i=0;i<ccb;i++)
{  if (i != h)
      if (pivot = condb[i][j])
         for (v=0;v<vars;v++)
            condb[i][v] -= pivot*condb[h][v];
}
for (v=0;v<vars;v++)
      condb[h][v] = -condb[h][v];
condb[h][j] = 0;
delete_multiple_conditions(i,j,ccb);
j = w-1;
continue;
}
else if (h == ccb  &&  k != ccb)
{  for (i=0;i<ccb;i++)
   if (condb[i][j] < 0)  condb[i][j] = 0;
delete_multiple_conditions(i,j,ccb);
j = w-1;
continue;
}

other:
for (h=0;h<ccb;h++)
   if (condb[h][j] < 0)  break;
for (i=h+1;i<ccb;i++)
   if (condb[i][j] < 0)  break;
for (k=0;k<ccb;k++)
   if (condb[k][j] > 0)  break;
if (h < ccb  &&  i == ccb  &&  k != ccb)
{  if (condb[h][j] != -1)
   {  pivot = -condb[h][j];
      for (v=0;v<vars;v++)
         if (k = ABS(elem[h][v]))
         {  while (i = k % pivot)
               k = pivot,  pivot = i;
            if (pivot == 1)  break;
         }
      if (v==vars)
         for (v=0;v<vars;v++)
            condb[h][v] /= pivot;
      if (condb[h][j] != -1)
      {  pivot = -condb[h][j];
         for (i=0;i<ccb;i++)
         {  if (i!=h)
               for (v=0;v<vars;v++)
                  if (v!=j)
                     condb[i][v] *= pivot;
         }
         condb[h][j] = -1;
      }
   }
   for (i=0;i<ccb;i++)
   {  if (i != h)
         if (pivot = -condb[i][j])
            for (v=0;v<vars;v++)
               condb[i][v] -= pivot*condb[h][v];
   }
   condb[h][j] = 0;
   delete_multiple_conditions(i,j,ccb);
   j = w-1;
   continue;
}
else if (h == ccb  &&  k != ccb)
{  for (i=0;i<ccb;i++)
      if (condb[i][j] > 0)
      {  for (v=0;v<vars;v++)
            condb[i][v] = condb[ccb-1][v];
         ccb--;
         i--;
      }
}
else
{  for ( ;h<ccb;h++)
      if (condb[h][j] < 0)
      {  for (v=1;v<vars;v++)
            if (condb[h][v] > 0)  break;
         if (v==vars  &&  condb[h][0] < 0)

               fprintf(stderr,"Error  reduce check conditions\n");
            else if (v==vars  &&  condb[h][0] == 0)
            {  for (i=0;i<ccb;i++)
                  condb[i][j] = 0;
               delete_multiple_conditions(i,j,ccb);
               j = w-1;
               break;
            }
         }
      if (h < ccb)  continue;
   }
}
/**  sieve and reduce conditions  **/
j=w;
for (k=w;k<vars;k++)
{  for (i=0;i<ccb;i++)
      if (condb[i][k])  break;
   if (i != ccb)
   {  if (j < k)
         for (i=0;i<ccb;i++)
            condb[i][j] = condb[i][k];
      j++;
   }
}
for (v=j;v<vars;v++)
   for (i=0;i<ccb;i++)
      condb[i][v] = 0;
vars = j;
/**  delete conditions without variables  **/
for (j=0;j<ccb;j++)
{  for (v=1;v<vars;v++)
      if (condb[j][v])  break;
   if (v==vars)
   {  if (condb[j][0] < 0)
         fprintf(stderr,"Error  reduce contradiction\n");
      else
      {  for (v=0;v<vars;v++)
            condb[j][v] = condb[ccb-1][v];
         j--;
         ccb--;
      }
   }
}
/**  delete conditions of exponents  **/
for (j=0;j<bitsb;j++)
{  for (i=0;i<ccb;i++)
   {  for (v=1;v<vars;v++)
         if (condb[i][v] != num[j][v])  break;
      if (v==vars)
         if (condb[i][0] >= num[j][0]-bitsb+1+j)
         {  for (v=0;v<vars;v++)
               condb[i][v] = condb[ccb-1][v];
            i--;
            ccb--;
         }
   }

}
/**  delete conditions of differences of two bounded variables  **/
for (i=0;i<ccb;i++)
{  for (k=1;k<vars;k++)
   if (condb[i][k])  break;
if (k>=w)  continue;
if (condb[i][k] != 1)  continue;
for (v=k+1;v<vars;v++)
   if (condb[i][v])  break;
if (v>=w)  continue;
if (condb[i][v] != -1)  continue;
for (j=v+1;j<vars;j++)
   if (condb[i][j])  break;
if (j!=vars)  continue;
if (k-v <= condb[i][0])
{  for (v=0;v<vars;v++)
      condb[i][v] = condb[ccb-1][v];
   i--;
   ccb--;
}
}
/**  delete conditions of exponent monotony  **/
for (j=1;j<bitsb;j++)
{  for (v=0;v<w;v++)
   condb[ccb][v] = num[j-1][v] - num[j][v];
for (v=w;v<vars;v++)
   condb[ccb][v] = 0;
condb[ccb][0]--;
for (i=0;i<ccb;i++)
{  for (v=1;v<vars;v++)
      if (condb[i][v] != condb[ccb][v])  break;
   if (v==vars)
   {  if (condb[i][0] >= condb[ccb][0])
      {  for (v=0;v<vars;v++)
            condb[i][v] = condb[ccb-1][v];
         for (v=0;v<vars;v++)
            condb[ccb-1][v] = condb[ccb][v];
         i--;
         ccb--;
      }
   }
}
}
for (i=0;i<ccb;i++)
for (j=1;j<bitsb;j++)
{  for (v=1;v<vars;v++)
      if (num[bitsb-1][v]+num[j-1][v]-num[j][v] != condb[i][v])  break;
   if (v==vars && num[bitsb-1][0]+num[j-1][0]-num[j][0]-1 <= condb[i][0])
   {  for (v=0;v<vars;v++)
         condb[i][v] = condb[ccb-1][v];
      i--;
      ccb--;
      break;
   }
}
for (i=0;i<ccb;i++)

for (j=0;j<bitsb-1;j++)
{  for (v=1;v<vars;v++)
if (num[j][v]-num[bitsb-1][v] != condb[i][v])  break;
if (v==vars  &&  num[j][0]-num[bitsb-1][0]-(bitsb-1-j) <= condb[i][0])
{  for (v=0;v<vars;v++)
   condb[i][v] = condb[ccb-1][v];
i--;
ccb--;
break;
}
}
/**  special conditions for 1- and 2-bit_terms needed  **/
if (bitsb <= 2  &&  smallsteps > 1)
{  if (ccb >= MAX_ELEM)
fprintf(stderr,"Error  reduce conditions exceeded\n");
else
{  for (k=0;k<ccb;k++)
for (v=0;v<vars;v++)
   elem[k][v] = condb[k][v];
if (bitsb==2)
{  if (k >= MAX_ELEM)
   fprintf(stderr,"Error  reduce conditions exceeded\n");
else if (!num[1][2])
{  for (v=0;v<vars;v++)
      elem[k][v] = num[1][v];
   k++;
}
else
{  for (v=0;v<vars;v++)
      elem[k][v] = num[0][v] - num[1][v];
   elem[k][0]--;
   k++;
}
}
if ((k=check_conditions(vars,k)) < 0)
fprintf(stderr,"Error  reduce check conditions special\n");
else
{  for (h=0;h<3;h++)
{  for (v=0;v<MAX_VARS;v++)
      condb[ccb][v] = 0;
   condb[ccb][1] = !(h&1);
   condb[ccb][2] = (h&1) - (h>>1);
   condb[ccb][0] = minimize_condition(vars,k,condb[ccb]);
   if (condb[ccb][0] != MOST)
   {  condb[ccb][0]= -condb[ccb][0];
      if (h<=1  &&  condb[ccb][0] == 0)
         continue;
      if (h==2  &&  condb[ccb][0] == -1)
         continue;
      for (i=0;i<ccb;i++)
      {  for (v=1;v<vars;v++)
            if (condb[i][v] != condb[ccb][v])  break;
         if (v==vars)  break;
      }
      if (v==vars)
         condb[i][0] = condb[ccb][0];

         else
            ccb++;
      }
      if (bitsb==1  ||  !num[1][2])
         break;
      else if (ccb >= CONDITIONS)
      {  fprintf(stderr,"Error  reduce conditions exceeded\n");
         break;
      }
   }
}
}
}
/**  sort conditions  **/
for (j=ccb-1;j>=0;j--)
for (i=j-1;i>=0;i--)
{  for (v=vars-1;v;v--)
   if (!condb[j][v] != !condb[i][v])  break;
if (v  &&  condb[i][v])
{  for (v=0;v<vars;v++)
      k=condb[j][v],  condb[j][v]=condb[i][v],  condb[i][v]=k;
}
else if (!v)
{  for (v=vars-1;v;v--)
      if (condb[j][v] != condb[i][v])  break;
   if (v  &&  condb[j][v] < condb[i][v])
      for (v=0;v<vars;v++)
         k=condb[j][v],  condb[j][v]=condb[i][v],  condb[i][v]=k;
}
}
*ccc = ccb;
return;
}

check_conditions(vars,ccv)
int  vars, ccv;
{
/***  duale simplex algorithmn for total degenerated equation_system  ***/
int  h, i, j, k, v, pivot;
for (i=0;i<ccv;i++)
{  for (v=1;v<vars;v++)
if (elem[i][v])  break;
if (v==vars)
{  if (elem[i][0] < 0)  return -1;
for (v=0;v<vars;v++)
   elem[i][v] = elem[ccv-1][v];
i--;
ccv--;
}
}
for (i=0;i<ccv;i++)
for (j=i+1;j<ccv;j++)
{  for (v=1;v<vars;v++)
   if (elem[i][v] != elem[j][v])  break;
if (v==vars)

{  if (elem[i][0] > elem[j][0])
      elem[i][0] = elem[j][0];
   for (v=0;v<vars;v++)
      elem[j][v] = elem[ccv-1][v];
   j--;
   ccv--;
}
}
deelem=1;
if (!ccv)  return 0;
if (ccv+vars > MAX_ELEM)
{  fprintf(stderr,"Error  elem exceeded conditions\n");  return ccv;  }
for (i=0;i<vars;i++)
{  for (v=0;v<vars;v++)
elem[ccv+i][v] = 0;
elem[ccv+i][i] = 1;
}
elem[ccv][0] = 0;
while (1)
{  pivot = 0;
h=ccv+vars;
for (i=0;i<ccv+vars;i++)
if (elem[i][0] < pivot)
   pivot = elem[i][0],  h=i;
if (h == ccv+vars)  break;
j=0;
for (v=1;v<vars;v++)
if (elem[h][v] > 0)
{  if (!j)
      j=v;
   else
   {  for (i=1;i<vars;i++)
         if (elem[ccv+i][v]*elem[h][j] != elem[ccv+i][j]*elem[h][v])
            break;
      if (elem[ccv+i][v]*elem[h][j] < elem[ccv+i][j]*elem[h][v])
         j=v;
   }
}
if (!j)  return -1;
if (elem[h][j] != 1)
{
#ifdef  INT_LIMIT
unsigned  ILDP = INT_LIMIT/ABS(elem[h][j]);
for (v=0;v<vars;v++)
   if (v!=j  &&  elem[h][v])
   {  for (i=0;i<ccv;i++)
         if (i != h  &&  ABS(elem[i][v]) > ILDP)
            break;
      if (i != ccv)  break;
   }
if (v != vars)  column_simplify(0,ccv,0,vars)
#endif
pivot = elem[h][j];
for (v=0;v<vars;v++)
   if (k = ABS(elem[h][v]))
   {  while (i = k % pivot)

               k = pivot,  pivot = i;
            if (pivot == 1)  break;
         }
      if (v==vars)
         for (v=0;v<vars;v++)
            elem[h][v] /= pivot;
      if (elem[h][j] != 1)
      {  pivot = elem[h][j];
         deelem *= pivot;
         for (v=0;v<vars;v++)
            if (v!=j  &&  elem[h][v])
               for (i=0;i<ccv+vars;i++)
                  if (i!=h)
                     elem[i][v] *= pivot;
         elem[h][j] = 1;
      }
   }
#ifdef  INT_LIMIT
   for (v=0;v<vars;v++)
      if (v!=j  &&  (pivot = elem[h][v]))
      {  unsigned  ILDP = INT_LIMIT/ABS(pivot);
         for (i=0;i<ccv+vars;i++)
            if (ABS(elem[i][v]) > INT_LIMIT  ||  ABS(elem[i][j]) > ILDP)
               break;
         if (i != ccv+vars)  break;
      }
   if (v != vars)  column_simplify(0,ccv+vars,0,vars)
#endif
   for (v=0;v<vars;v++)
   {  if (v!=j  &&  (pivot = elem[h][v]))
            for (i=0;i<ccv+vars;i++)
               elem[i][v] -= pivot*elem[i][j];
   }
}
return ccv;
}

minimize_condition(vars,ccv,cond0)
int  vars, ccv, cond0[MAX_VARS];
{
int  h, i, j, k, v, pivot;
pivot = 0;  j=0;
for (i=0;i<vars;i++)
{  elem[ccv][i] = (i ? 0 : cond0[0]*deelem);
   for (v=1;v<vars;v++)
      elem[ccv][i] += cond0[v]*elem[ccv+v][i];
   if (i  &&  elem[ccv][i] < pivot)
      pivot = elem[ccv][i],  j=i;
}
if (ccv+vars > MAX_VARS+MAX_ELEM/2)
{  fprintf(stderr,"Error  elem exceeded variables\n");  return 0;  }
for (i=0;i<ccv;i++)
{  for (v=0;v<ccv;v++)
      elem[i][vars+v] = 0;
   elem[i][vars+i] = -1;

}
for (v=0;v<ccv;v++)
elem[ccv][vars+v] = 0;
while (j)
{  h=ccv;
for (i=0;i<ccv;i++)
if (elem[i][j] < 0)
{  if (h==ccv  ||  elem[i][0]*elem[h][j] > elem[h][0]*elem[i][j])
   h=i;
else if (elem[i][0]*elem[h][j] == elem[h][0]*elem[i][j])
{  for (v=0;v<ccv;v++)
      if (elem[i][vars+v]*elem[h][j] != elem[h][vars+v]*elem[i][j])
         break;
   if (elem[i][vars+v]*elem[h][j] > elem[h][vars+v]*elem[i][j])
      h=i;
}
}
if (h==ccv)  return MOST;
if (elem[h][j] != -1)
{  pivot = -elem[h][j];
for (v=0;v<vars+ccv;v++)
if (k = ABS(elem[h][v]))
{  while (i = k % pivot)
      k = pivot,  pivot = i;
   if (pivot == 1)  break;
}
if (v==vars+ccv)
for (v=0;v<vars+ccv;v++)
   elem[h][v] /= pivot;
if (elem[h][j] != -1)
{
#ifdef  INT_LIMIT
unsigned  ILDP = INT_LIMIT/ABS(-elem[h][j]);
for (i=0;i<=ccv;i++)
   if (i!=h  &&  elem[i][j])
   {  for (v=0;v<vars+ccv;v++)
         if (v != j  &&  ABS(elem[i][v]) > ILDP)
            break;
      if (v != vars+ccv)  break;
   }
if (i != ccv)  row_simplify(0,ccv,0,vars+ccv)
#endif
pivot = -elem[h][j];
deelem *= pivot;
for (i=0;i<=ccv;i++)
{  if (i!=h  &&  elem[i][j])
      for (v=0;v<vars+ccv;v++)
         if (v!=j)
            elem[i][v] *= pivot;
}
elem[h][j] = -1;
}
}
#ifdef  INT_LIMIT
for (i=0;i<=ccv;i++)
if (i!=h  &&  (pivot = -elem[i][j]))

   {  unsigned  ILDP = INT_LIMIT/ABS(pivot);
      for (v=0;v<vars+ccv;v++)
         if (ABS(elem[i][v]) > INT_LIMIT  ||  ABS(elem[h][v]) > ILDP)
            break;
      if (v != vars+ccv)  break;
   }
if (i != ccv+1)  row_simplify(0,ccv+1,0,vars+ccv)
#endif
for (i=0;i<=ccv;i++)
{  if (i!=h  &&  (pivot = -elem[i][j]))
         for (v=0;v<vars+ccv;v++)
            elem[i][v] -= pivot*elem[h][v];
}
pivot = 0;  j=0;
for (v=1;v<vars+ccv;v++)
   if (elem[ccv][v] < pivot)
      pivot = elem[ccv][v],  j=v;
}
return  elem[ccv][0];
}

check_next_condition(cce,cond0)
int  *cce, cond0[MAX_VARS];
{
int  h, i, j, k, v, pivot, ccv;
static  vars;
if (cond0 == (int*) 0)
{  vars = *cce;
if (vars > MAX_ELEM)
{  fprintf(stderr,"Error  elem exceeded in check_next_conditions\n");
   return  -1;
}
deelem=1;
for (i=0;i<vars;i++)
{  for (v=0;v<vars;v++)
      elem[i][v] = 0;
   elem[i][i] = 1;
}
if (vars > 0)
   elem[0][0] = 0;
return 0;
}
else
ccv = *cce + vars;
if (ccv >= MAX_ELEM)
{  fprintf(stderr,"Error  elem exceeded in check_next_conditions\n");
(*cce)++;
return  0;
}
elem[ccv][0] = cond0[0]*deelem;
for (v=1;v<vars;v++)
elem[ccv][0] += cond0[v]*elem[v][0];
for (i=1;i<vars;i++)
{  elem[ccv][i] = 0;
for (v=1;v<vars;v++)

elem[ccv][i] += cond0[v]*elem[v][i];
}
h=ccv;
if (elem[h][0] < 0)
{  ccv++;
/***  duale simplex algorithmn for total degenerated equation_system  ***/
do
{  j=0;
for (v=1;v<vars;v++)
if (elem[h][v] > 0)
{  if (!j)
   j=v;
else
{  for (i=1;i<vars;i++)
      if (elem[i][v]*elem[h][j] != elem[i][j]*elem[h][v])
         break;
   if (elem[i][v]*elem[h][j] < elem[i][j]*elem[h][v])
      j=v;
}
}
if (!j)  return -1;
if (elem[h][j] != 1)
{  pivot = elem[h][j];
for (v=0;v<vars;v++)
if (k = ABS(elem[h][v]))
{  while (i = k % pivot)
      k = pivot,  pivot = i;
   if (pivot == 1)  break;
}
if (v==vars)
for (v=0;v<vars;v++)
   elem[h][v] /= pivot;
if (elem[h][j] != 1)
{
#ifdef  INT_LIMIT
unsigned  ILDP = INT_LIMIT/ABS(elem[h][j]);
for (v=0;v<vars;v++)
   if (v!=j  &&  elem[h][v])
   {  for (i=0;i<ccv;i++)
         if (i != h  &&  ABS(elem[i][v]) > ILDP)
            break;
      if (i != ccv)  break;
   }
if (v != vars)  column_simplify(0,ccv,0,vars)
#endif
pivot = elem[h][j];
deelem *= pivot;
for (v=0;v<vars;v++)
   if (v!=j  &&  elem[h][v])
      for (i=0;i<ccv;i++)
         if (i!=h)
            elem[i][v] *= pivot;
elem[h][j] = 1;
}
}
#ifdef  INT_LIMIT

for (v=0;v<vars;v++)
   if (v!=j  &&  (pivot = elem[h][v]))
   {  unsigned  ILDP = INT_LIMIT/ABS(pivot);
      for (i=1;i<ccv;i++)
         if (ABS(elem[i][v]) > INT_LIMIT  ||  ABS(elem[i][j]) > ILDP)
            break;
      if (i != ccv)  break;
   }
if (v != vars)  column_simplify(0,ccv,0,vars)
#endif
for (v=0;v<vars;v++)
{  if (v!=j  &&  (pivot = elem[h][v]))
         for (i=1;i<ccv;i++)
            elem[i][v] -= pivot*elem[i][j];
}
pivot = 0;
h=0;
for (i=1;i<ccv;i++)
   if (elem[i][0] < pivot)
      pivot = elem[i][0],  h=i;
} while (elem[h][0] < 0);
}
/***  primale simplex algorithmn for admissible equation_system  ***/
else if (ccv+ccv-vars >= MAX_ELEM)
{  fprintf(stderr,"Error  elem exceeded in copy check_next_conditions\n");
if (ccv-vars >= MAX_ELEM)
fprintf(stderr,"Error  elem exceeded in check_next_conditions\n");
else
ccv++;
}
else if (ccv+vars > MAX_VARS+MAX_ELEM/2)
fprintf(stderr,"Error  elem exceeded variables\n");
else
{  for (i=vars;i<=ccv;i++)
for (v=0;v<vars;v++)
   elem[ccv+1+i-vars][v] = elem[i][v];
for (i=0;i<ccv;i++)
{  for (v=0;v<ccv;v++)
   elem[i][vars+v] = 0;
elem[i][vars+i] = -1;
}
for (v=0;v<ccv;v++)
elem[ccv][vars+v] = 0;
do
{  pivot = 0;  j=0;
for (v=1;v<vars+ccv;v++)
   if (elem[ccv][v] < pivot)
      pivot = elem[ccv][v],  j=v;
if (!j)  break;
h=0;
for (i=vars;i<ccv;i++)
   if (elem[i][j] < 0)
   {  if (!h  ||  elem[i][0]*elem[h][j] > elem[h][0]*elem[i][j])
         h=i;
      else if (elem[i][0]*elem[h][j] == elem[h][0]*elem[i][j])
      {  for (v=0;v<ccv;v++)

      if (elem[i][vars+v]*elem[h][j] !=
          elem[h][vars+v]*elem[i][j])
         break;
   if (elem[i][vars+v]*elem[h][j] > elem[h][vars+v]*elem[i][j])
      h=i;
}
}
if (!h  ||  elem[ccv][0]*elem[h][j] > elem[h][0]*elem[ccv][j])
break;
if (elem[h][j] != -1)
{  pivot = -elem[h][j];
for (v=0;v<vars+ccv;v++)
if (k = ABS(elem[h][v]))
{  while (i = k % pivot)
      k = pivot,  pivot = i;
   if (pivot == 1)  break;
}
if (v==vars+ccv)
for (v=0;v<vars+ccv;v++)
   elem[h][v] /= pivot;
if (elem[h][j] != -1)
{  pivot = -elem[h][j];
for (i=vars;i<=ccv;i++)
{  if (i!=h)
      for (v=0;v<vars+ccv;v++)
         if (v!=j  &&  elem[i][j])
            elem[i][v] *= pivot;
}
elem[h][j] = -1;
}
}
for (i=vars;i<=ccv;i++)
{  if (i!=h)
if (pivot = -elem[i][j])
   for (v=0;v<vars+ccv;v++)
      elem[i][v] -= pivot*elem[h][v];
}
} while (elem[ccv][0] >= 0);
for (i=vars;i<=ccv;i++)
for (v=0;v<vars;v++)
elem[i][v] = elem[ccv+1+i-vars][v];
if (j)  ccv++;
}
*cce = ccv-vars;
return 0;
}

put_chain(myself,len,chain1)
unsigned  myself;
int  len;
CHAIN  Chain1;
{  unsigned  i, j;
if (denom1 != 1)
printf("base=%d  ",denom1);
#ifdef  TEST

printf("%5d:  ",myself);
#else
printf("%4d:   1 ",myself);
#endif
for (j=1;j<len;j++)
{  if (!(info1[j]&MASK))
#ifdef  TEST
      printf(";");
   else
      printf(",");
#else
      printf(", ..... ");
   printf(",");
#endif
   for (i=0;i<bits1[j];i++)
#ifdef  TEST
   {  printf("@(");
      put_term(sequ1[j][i]);
      printf(")");
#else
   {  printf("%c 2^(", (i ? '+' : ' ') );
      put_term(sequ1[j][i]);
      printf(") ");
#endif
   }
}
printf("\n");
for (j=0;j<cc1;j++)
{  printf(" %c  ",(j ? ',' : ' '));
   i = cond1[j][0];
   cond1[j][0] = 0;
   put_term(cond1[j]);
   cond1[j][0] = i;
   printf(" >= %d",-i);
}
if (cc1)  printf("\n");
}

put_term(term)
int  term[MAX_VARS];
{
char  let;
unsigned  k=0, v;
for (let='A',v=1;v<MAX_VARS;v++,let++)
   if (term[v])
   {  if (!k  &&  term[v] == 1)
         printf("%c",let);
      else if (!k  &&  term[v] > 0)
         printf("%d%c",term[v],let);
      else if (term[v] == 1)
         printf("+%c",let);
      else if (term[v] == -1)
         printf("-%c",let);
      else
         printf("%+d%c",term[v],let);

      k=v;
   }
if (term[0])
   printf("%+d",term[0]);
return;
}

heapsort(n,data)
unsigned  n;     /*  number of elements to sort  */
register int       *data;  /*  pointer to 1. element  */
{
#define  IF_data_j_LESS_THAN_(other)   if (compare_less_than(data[j],other))
#define  MOVE_j_TO_i  { data[i]=data[j];  i=j; }
register  int       next;
register  unsigned  i, j, l, r;
if (n)  data--;   /* map addresses to indices 1 - n  */
else  return;
for (l=n/2;l;l--)
{  next = data[l];
   i = l;
   for (j=i+i;j<n;j+=j)
   {  IF_data_j_LESS_THAN_(data[j+1])  j++;
      MOVE_j_TO_i
   }
   if (j==n)  MOVE_j_TO_i
   while((j=i>>1) >= l)
      IF_data_j_LESS_THAN_(next)  MOVE_j_TO_i
      else  break;
   data[i] = next;
}
for (r=n-1;r;r--)
{  next=data[r+1];  data[r+1] = data[1];
   i = 1;
   for (j=2;j<r;j+=j)
   {  IF_data_j_LESS_THAN_(data[j+1])  j++;
      MOVE_j_TO_i
   }
   if (j==r)  MOVE_j_TO_i
   while((j=i>>1))
      IF_data_j_LESS_THAN_(next)  MOVE_j_TO_i
      else  break;
   data[i] = next;
}
return;
}

compare_less_than (left,right)
int  left, right;
{  int  i, v;
if (bitsn[left] < bitsn[right])  return 1;
if (bitsn[left] > bitsn[right])  return 0;
if (denomn[left] > denomn[right])  return 1;
if (denomn[left] < denomn[right])  return 0;
for (i=0;i<bitsn[left];i++)

{   for (v=MAX_VARS-1;v>=0;v--)
       if (number[left][i][v] != number[right][i][v])  break;
    if (v>=0)
    {  if (!number[left][i][v])  return 1;
       if (!number[right][i][v])  return 0;
       return  number[left][i][v] < number[right][i][v];
    }
}
return 0;
}

Literaturverzeichnis

[1] B. Datta and A.N. Singh History of Hindu Mathematics V. 1 Bombay 1935, p. 76

[2] A.S. Saidan The Arithmetic of al-Uqlîdisî Dordrecht 1975, p. 341-342

[3] E. de Jonquiéres L’ Intermédiare des Mathématiciens V. 1 1894, 20, p. 162-164

[4] A. Scholz Jahresbericht der deutschen Mathematiker-Vereinigung, V. 47, Abt. II 1937, Aufgabe 253, p. 41-42

[5] W. Hansen “Zum Scholz-Brauer Problem”, Journal für reine und angewandte Mathematik, V. 202 1959, p. 129-136

[6] A.A. Gioia, M.V. Subbarao and M. Sugunamma “The Scholz-Brauer Problem in Addition Chains”, Duke Mathematical Journal, V. 29 1962, p. 481-487

[7] E.G. Thurber “The Scholz-Brauer Problem on Addition-Chains”, Pacific Journal of Mathematics, V. 49 1973, p. 229-242

[8] A. Schönhage “A Lower Bound for the Length of Addition Chains”, Theoretical Computer Science, V. 1 1975, p. 1-12

[9] D.E. Knuth The Art of Computer Programming V. 2 Seminumerical Algorithms, 2.edition Addison-Wesly 1981 (1.edition from 1969)

[10] Bronstein – Semendjajew Taschenbuch der Mathematik Verlag Harri-Deutsch 1981, 19. Auflage, p. 733-755

[11] Downey, Leony and Sethi “Computing Sequences with Addition Chains”, SIAM Journal of Computing, V. 3 1981, p. 103-121

[12] J. Bos, M. Coster “Addition Chain Heuristics”, Crypto’ 89 1989

[13] M. Elias and F. Neri “A Note on Addition Chains and Some Related Conjectures”, Sequences, Editor R.M. Capocelli, Springer-Verlag 1990, p. 166-181

Ergebnistabellen

Darstellbare Funktionen mit Additionsketten aus 2 Kurzschritten
1 1* @(p) ,p>=3
2 2* @(p)+@(q) ,p>=2
3 3* @(p)+@(q)+@(r)
4 4* @(p)+@(p-5)+@(p-6)+@(p-7)
5 4* @(p)+@(p-3)+@(q)+@(q-1)
6 4* @(p)+@(q)+@(r)+@(-p+q+r)
7 4* @(p)+@(q)+@(r)+@(-p+q+r+1)
Funktionenfolgen aus 2 Kurzschritten
1 1* @(p) ,p>=3
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, 1)  @(A+1)
2 2* @(p)+@(q) ,p>=2
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)
4( 3, 1)  @(A+1)+@(D)
3 3* @(p)+@(q)+@(r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4 4* @(p)+@(p-5)+@(p-6)+@(p-7)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)+@(A-1)
4( 3, D)  @(A+4)+@(A+2)

5( 4, 3)  @(A+4)+@(A+2)+@(A+1)+@(A-1)
6( 5, D)  @(A+5)+@(A+3)+@(A+2)+@(A)
7( 6, 5)  @(A+6)+@(A+1)+@(A)+@(A-1)
5 4* @(p)+@(p-3)+@(q)+@(q-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+2)+@(A+1)+@(C+1)
6( 5, 4)  @(A+3)+@(A)+@(C+1)+@(C)
6 4* @(p)+@(q)+@(r)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 3)  @(A+D+2)+@(A+1)+@(B+D+1)+@(B)
7 4* @(p)+@(q)+@(r)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)

Darstellbare Funktionen mit Additionsketten aus 3 Kurzschritten
1 1* @(p) ,p>=3
2 2* @(p)+@(q) ,p>=2,q>=1
3 2* @(p)+@(q) ,p>=3
4 3* @(p)+@(q)+@(r)
5 4* @(p)+@(q)+@(r)+@(s)
6 5* @(p)+@(p-8)+@(p-12)+@(p-13)+@(p-14)
7 5* @(p)+@(p-8)+@(p-10)+@(p-11)+@(p-14)
8 5* @(p)+@(p-7)+@(q)+@(q-1)+@(q-3) ,q>=4
9 5* @(p)+@(p-6)+@(p-9)+@(p-11)+@(p-12)
10 5* @(p)+@(p-6)+@(q)+@(q-2)+@(q-4)
11 5* @(p)+@(p-6)+@(q)+@(q-1)+@(q-3)
12 5* @(p)+@(p-6)+@(q)+@(q-1)+@(q-2)
13 5* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)

14 5* @(p)+@(p-5)+@(q)+@(q-2)+@(q-3)
15 5* @(p)+@(p-5)+@(q)+@(q-1)+@(q-2)
16 5* @(p)+@(p-3)+@(q)+@(q-1)+@(r)
17 5* @(p)+@(p-3)+@(q)+@(r)+@(r-1)
18 5* @(p)+@(p-1)+@(q)+@(r)+@(-p+q+r-1)
19 5* @(p)+@(q)+@(q-2)+@(q-3)+@(q-4) ,p>=6
20 5* @(p)+@(q)+@(q-2)+@(r)+@(r-1) ,p-q>=2
21 5* @(p)+@(q)+@(q-1)+@(q-2)+@(p-6)
22 5* @(p)+@(q)+@(q-1)+@(q-2)+@(p-5)
23 5* @(p)+@(q)+@(q-1)+@(r)+@(r-2) ,p-q>=3
24 5* @(p)+@(q)+@(q-1)+@(r)+@(-p+q+r+2)
25 5* @(p)+@(q)+@(-p+2q-2)+@(r)+@(-p+q+r-1)
26 5* @(p)+@(q)+@(r)+@(-p+2q-2)+@(-p+q+r-1)
27 5* @(p)+@(q)+@(r)+@(r-1)+@(-p+q+r+2)
28 5* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)
29 5* @(p)+@(q)+@(r)+@(-p+q+r-1)+@(-p+2r-2)
30 5* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)
31 5* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+1)
32 5* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+q+2r+1)
33 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)
34 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)
35 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+s)
36 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+s+1)
37 5* @(p)+@(q)+@(r)+@(s)+@(-p+r+s)
38 5* @(p)+@(q)+@(r)+@(s)+@(-p+r+s+1)
39 5  @(p)+@(q)+@(r)+@(s)+@(-q+r+s)
40 6* @(p)+@(p-7)+@(p-8)+@(p-11)+@(p-12)+@(p-13)
41 6* @(p)+@(p-7)+@(p-8)+@(p-9)+@(p-10)+@(p-13)
42 6* @(p)+@(p-7)+@(q)+@(q-3)+@(q-4)+@(q-5) ,q>=6
43 6* @(p)+@(p-7)+@(q)+@(q-2)+@(q-4)+@(q-5)
44 6* @(p)+@(p-7)+@(q)+@(q-2)+@(q-3)+@(q-4)
45 6* @(p)+@(p-7)+@(q)+@(q-1)+@(q-4)+@(q-5)
46 6* @(p)+@(p-7)+@(q)+@(q-1)+@(q-3)+@(q-4)
47 6* @(p)+@(p-7)+@(q)+@(q-1)+@(q-2)+@(q-3)
48 6* @(p)+@(p-6)+@(q)+@(q-3)+@(q-4)+@(q-5)
49 6* @(p)+@(p-6)+@(q)+@(q-2)+@(q-4)+@(q-6)
50 6* @(p)+@(p-6)+@(q)+@(q-2)+@(q-3)+@(q-5)
51 6* @(p)+@(p-6)+@(q)+@(q-1)+@(q-4)+@(q-5)
52 6* @(p)+@(p-6)+@(q)+@(q-1)+@(q-3)+@(q-4)
53 6* @(p)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
54 6* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-3)
55 6* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-2)
56 6* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)
57 6* @(p)+@(p-5)+@(q)+@(q-3)+@(q-4)+@(q-5)

58 6* @(p)+@(p-5)+@(q)+@(q-2)+@(q-4)+@(q-5)
59 6* @(p)+@(p-5)+@(q)+@(q-2)+@(q-3)+@(q-4)
60 6* @(p)+@(p-5)+@(q)+@(q-1)+@(q-3)+@(q-4)
61 6* @(p)+@(p-5)+@(q)+@(q-1)+@(q-2)+@(q-3)
62 6* @(p)+@(p-4)+@(p-7)+@(p-11)+@(p-12)+@(p-13)
63 6* @(p)+@(p-4)+@(p-7)+@(p-8)+@(p-9)+@(p-11)
64 6* @(p)+@(p-4)+@(p-6)+@(q)+@(q-2)+@(q-4) ,q>=5
65 6* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-3)
66 6* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-2) ,q>=3
67 6* @(p)+@(p-4)+@(p-5)+@(q)+@(q-2)+@(q-4)
68 6* @(p)+@(p-4)+@(p-5)+@(q)+@(q-1)+@(q-4)
69 6* @(p)+@(p-4)+@(p-5)+@(q)+@(q-1)+@(q-2)
70 6* @(p)+@(p-4)+@(q)+@(q-1)+@(q-2)+@(q-3)
71 6* @(p)+@(p-3)+@(p-5)+@(p-6)+@(q)+@(q-2)
72 6* @(p)+@(p-3)+@(q)+@(q-5)+@(-p+2q-3)+@(-p+2q-4)
73 6* @(p)+@(p-3)+@(q)+@(q-5)+@(-p+2q-2)+@(-p+2q-3)
74 6* @(p)+@(p-3)+@(q)+@(q-3)+@(r)+@(r-1)
75 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-3)
76 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)
77 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(-p+q+r)
78 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(-p+q+r+1)
79 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(-p+q+r+2)
80 6* @(p)+@(p-3)+@(q)+@(r)+@(r-1)+@(-p+q+r)
81 6* @(p)+@(p-3)+@(q)+@(r)+@(r-1)+@(-p+q+r+1)
82 6* @(p)+@(p-3)+@(q)+@(r)+@(r-1)+@(-p+q+r+2)
83 6* @(p)+@(p-2)+@(p-4)+@(q)+@(q-1)+@(q-2)
84 6* @(p)+@(p-2)+@(q)+@(q-4)+@(-p+2q-3)+@(-p+2q-4)
85 6* @(p)+@(p-2)+@(q)+@(q-4)+@(-p+2q-2)+@(-p+2q-3)
86 6* @(p)+@(p-1)+@(p-2)+@(p-3)+@(q)+@(q-3)
87 6* @(p)+@(p-1)+@(q)+@(q-3)+@(-p+2q-3)+@(-p+2q-4)
88 6* @(p)+@(p-1)+@(q)+@(q-3)+@(-p+2q-2)+@(-p+2q-3)
89 6* @(p)+@(q)+@(p-7)+@(q-3)+@(q-4)+@(q-5) ,q>=6
90 6* @(p)+@(q)+@(p-5)+@(q-3)+@(q-4)+@(q-5)
91 6* @(p)+@(q)+@(p-3)+@(q-3)+@(r)+@(r-1)
92 6* @(p)+@(q)+@(q-2)+@(r)+@(r-1)+@(-p+q+r+1) ,-p+q+r>=0
93 6* @(p)+@(q)+@(q-1)+@(p-7)+@(q-4)+@(q-5)
94 6* @(p)+@(q)+@(q-1)+@(q-4)+@(-p+2q-2)+@(-p+2q-3)
95 6* @(p)+@(q)+@(q-1)+@(q-2)+@(q-3)+@(p-7)
96 6* @(p)+@(q)+@(q-1)+@(q-2)+@(-p+2q)+@(-2p+3q-2)
97 6* @(p)+@(q)+@(q-1)+@(-p+2q+1)+@(-2p+3q+1)+@(-3p+4q+1)
98 6* @(p)+@(q)+@(q-1)+@(r)+@(r-2)+@(-p+q+r+1) ,-p+q+r>=0
99 6* @(p)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)
100 6* @(p)+@(q)+@(-p+2q)+@(-2p+3q-1)+@(-2p+3q-2)+@(-3p+4q-1)
101 6* @(p)+@(q)+@(-p+2q-2)+@(-p+2q-3)+@(-p+2q-4)+@(-2p+3q-4)

102 6* @(p)+@(q)+@(-p+2q-2)+@(r)+@(-p+q+r+1)+@(-2p+2q+r) ,q-r>=3
103 6* @(p)+@(q)+@(-p+2q-1)+@(-2p+3q-2)+@(-2p+3q-3)+@(-3p+4q-3)
104 6* @(p)+@(q)+@(r)+@(-p+2q-2)+@(-p+q+r+1)+@(-2p+2q+r)
105 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s)
106 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s+1)
107 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+r+s)
108 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+r+s+1)
109 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-p+2r-2)+@(-2p+q+2r)
110 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s)
111 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s+1)
112 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+r+s)
113 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+r+s+1)
114 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s)
115 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s+1)
116 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+r+s)
117 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+r+s+1)
118 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s)
119 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s+1)
120 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+r+s) ,p-q>=2
121 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+r+s+1) ,p-q>=2
122 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s)+@(-p+r+s)
123 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s)+@(-p+r+s+1)
124 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s+1)+@(-p+r+s)
125 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s+1)+@(-p+r+s+1)
126 7* @(p)+@(p-6)+@(p-7)+@(p-8)+@(p-10)+@(p-11)+@(p-12)
127 7* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-2)+@(q-6)
128 7* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)+@(q-4)
129 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-3)+@(q-4)+@(q-5)
130 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-2)+@(q-3)+@(q-4)
131 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-3)+@(q-4)
132 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
133 7* @(p)+@(p-4)+@(p-5)+@(p-6)+@(p-8)+@(p-9)+@(p-10)
134 7* @(p)+@(p-4)+@(p-5)+@(q)+@(q-2)+@(q-3)+@(q-5)
135 7* @(p)+@(p-4)+@(p-5)+@(q)+@(q-1)+@(q-2)+@(q-3)
136 7* @(p)+@(p-3)+@(p-4)+@(p-6)+@(p-7)+@(p-8)+@(p-10)
137 7* @(p)+@(p-3)+@(p-4)+@(p-5)+@(q)+@(q-2)+@(q-4)
138 7* @(p)+@(p-3)+@(q)+@(q-2)+@(q-4)+@(-p+2q-3)+@(-p+2q-4)
139 7* @(p)+@(p-3)+@(q)+@(q-2)+@(q-4)+@(-p+2q-2)+@(-p+2q-3)
140 7* @(p)+@(p-3)+@(q)+@(q-2)+@(q-4)+@(-p+2q-1)+@(-p+2q-2)
141 7* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)
142 7* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+2)
143 7* @(p)+@(p-2)+@(p-6)+@(q)+@(q-1)+@(q-3)+@(q-4)
144 7* @(p)+@(p-2)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
145 7* @(p)+@(p-2)+@(p-4)+@(q)+@(q-1)+@(q-3)+@(q-4)

146 7* @(p)+@(p-2)+@(p-4)+@(q)+@(q-1)+@(q-2)+@(q-3)
147 7* @(p)+@(p-2)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1) ,-p+q+r>=0
148 7* @(p)+@(q)+@(q-2)+@(r)+@(r-2)+@(-p+q+r)+@(-p+q+r-1)
149 7* @(p)+@(q)+@(q-1)+@(-p+2q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r+1)
150 7* @(p)+@(q)+@(q-1)+@(-p+2q-1)+@(r)+@(-p+q+r+1)+@(-2p+2q+r)
151 7* @(p)+@(q)+@(q-1)+@(r)+@(-p+2q)+@(-p+q+r+1)+@(-2p+2q+r+1) ,p-q>=2
152 7* @(p)+@(q)+@(q-1)+@(r)+@(-p+2q-1)+@(-p+q+r+1)+@(-2p+2q+r)
153 7* @(p)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+q+r)
154 7* @(p)+@(q)+@(-p+2q-2)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r-1)
155 7* @(p)+@(q)+@(-p+2q-1)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r)
156 7* @(p)+@(q)+@(r)+@(-p+2q-2)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r-1)
157 7* @(p)+@(q)+@(r)+@(-p+2q-1)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r)
158 7* @(p)+@(q)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+2r)+@(-2p+q+2r+1)
159 7* @(p)+@(q)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+2r-1)+@(-2p+q+2r)
160 7* @(p)+@(q)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-p+2r-2)+@(-2p+q+2r-1)
161 7* @(p)+@(q)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-p+2r-1)+@(-2p+q+2r)
162 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r)+@(-2p+q+2r)+@(-3p+2q+2r)
163 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r)+@(-2p+q+2r+1)+@(-3p+2q+2r+1)
164 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r+1)+@(-2p+q+2r)+@(-3p+2q+2r+1)
165 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r+1)+@(-2p+q+2r+1)+@(-3p+2q+2r+2)
166 7* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+1)+@(-2p+q+2r+1)+@(-3p+2q+2r+2)
167 7* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+1)+@(-2p+q+2r+2)+@(-3p+2q+2r+3)
168 7* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+2)+@(-2p+q+2r+1)+@(-3p+2q+2r+3)
169 8* @(p)+@(p-9)+@(p-10)+@(p-11)+@(p-12)+@(p-13)+@(p-14)+@(p-15)
170 8* @(p)+@(p-7)+@(p-9)+@(p-10)+@(p-11)+@(p-12)+@(p-13)+@(p-14)
171 8* @(p)+@(p-6)+@(p-7)+@(p-9)+@(p-10)+@(p-11)+@(p-12)+@(p-13)
172 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-5)+@(q-6)+@(q-7)
173 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-3)+@(q-5)+@(q-6)
174 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-2)+@(q-3)+@(q-5)
175 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)+@(q-3)+@(q-4)
176 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)+@(q-2)+@(q-3)
177 8* @(p)+@(p-3)+@(p-5)+@(p-6)+@(q)+@(q-2)+@(q-3)+@(q-5)
178 8* @(p)+@(p-3)+@(p-5)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
179 8* @(p)+@(p-3)+@(q)+@(q-3)+@(r)+@(r-1)+@(-p+q+r)+@(-p+q+r-1)
180 8* @(p)+@(p-3)+@(q)+@(q-3)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+q+r)
181 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-3)+@(-p+q+r)+@(-p+q+r-1)
182 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-3)+@(-p+q+r+1)+@(-p+q+r)
183 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r)+@(-p+q+r-1)
184 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+q+r)
185 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+2)+@(-p+q+r+1)
186 8* @(p)+@(q)+@(p-5)+@(p-6)+@(p-7)+@(q-5)+@(q-6)+@(q-7)
187 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s)
188 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+1)
189 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+1)

190 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s+1)+@(-p+r+s+1)+@(-2p+q+r+s+2)
191 8* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s+1)
192 8* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+2)
193 8* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+2)
194 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s)
195 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+1)
196 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+1)
197 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s+1)+@(-p+r+s+1)+@(-2p+q+r+s+2)
198 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s+1)
199 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+2)
200 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+2)

Funktionenfolgen aus 3 Kurzschritten
1 1* @(p) ,p>=3
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-1)
4( 3, 1)  @(A)+@(A-1)+@(A-2)
5( 4, 1)  @(A+1)
2 2* @(p)+@(q) ,p>=2,q>=1
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)
4( 3, 1)  @(A+1)+@(D)
5( 4, 1)  @(A+1)+@(D+1)
3 2* @(p)+@(q) ,p>=3
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, 1)  @(A+1)
5( 4, 1)  @(A+1)+@(E)
4 3* @(p)+@(q)+@(r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B+1)
4( 3, 1)  @(A)+@(B+1)+@(D)

5 4* @(p)+@(q)+@(r)+@(s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 1)  @(A)+@(B)+@(C)+@(D)
6 5* @(p)+@(p-8)+@(p-12)+@(p-13)+@(p-14)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A+1)+@(A-3)
4( 3, D)  @(A+7)+@(A+3)
5( 4, 2)  @(A+7)+@(A+3)+@(A)+@(A-3)
6( 5, D)  @(A+8)+@(A+4)+@(A+1)+@(A-2)
7( 6, 5)  @(A+8)+@(A+7)+@(A+4)+@(A+3)+@(A+1)+@(A)+@(A-2)+@(A-3)
8( 7, D)  @(A+10)+@(A+9)+@(A+6)+@(A+5)+@(A+3)+@(A+2)+@(A)+@(A-1)
9( 8, 7)  @(A+11)+@(A+3)+@(A-1)+@(A-2)+@(A-3)
7 5* @(p)+@(p-8)+@(p-10)+@(p-11)+@(p-14)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-6)
3( 2, 1)  @(A+1)+@(A-6)
4( 3, 2)  @(A+1)+@(A)+@(A-5)
5( 4, 3)  @(A+2)+@(A)+@(A-5)+@(A-6)
6( 5, D)  @(A+6)+@(A+4)+@(A-1)+@(A-2)
7( 6, 5)  @(A+6)+@(A+4)+@(A+2)+@(A)+@(A-1)+@(A-2)+@(A-5)+@(A-6)
8( 7, D)  @(A+7)+@(A+5)+@(A+3)+@(A+1)+@(A)+@(A-1)+@(A-4)+@(A-5)
9( 8, 7)  @(A+8)+@(A)+@(A-2)+@(A-3)+@(A-6)
8 5* @(p)+@(p-7)+@(q)+@(q-1)+@(q-3) ,q>=4
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, 3)  @(A+2)+@(A-1)+@(C+1)
6( 5, 4)  @(A+2)+@(A+1)+@(A)+@(A-1)+@(C+1)+@(C)
7( 6, D)  @(A+5)+@(A+4)+@(A+3)+@(A+2)+@(C+4)+@(C+3)
8( 7, 5)  @(A+6)+@(A-1)+@(C+4)+@(C+3)+@(C+1)
9 5* @(p)+@(p-6)+@(p-9)+@(p-11)+@(p-12)

0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-6)
4( 3, D)  @(A+3)+@(A+2)+@(A-3)
5( 4, 3)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(A-3)+@(A-6)
6( 5, 4)  @(A+4)+@(A+3)+@(A)+@(A-1)+@(A-2)+@(A-6)
7( 6, 5)  @(A+5)+@(A+2)+@(A+1)+@(A)+@(A-2)+@(A-3)+@(A-5)
8( 7, 6)  @(A+6)+@(A)+@(A-3)+@(A-5)+@(A-6)
10 5* @(p)+@(p-6)+@(q)+@(q-2)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-2)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D-1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A)+@(A-1)+@(A-2)
7( 6, 5)  @(A+D+3)+@(A+D+2)+@(A+D)+@(A)+@(A-1)+@(A-2)
8( 7, 6)  @(A+D+4)+@(A+D+1)+@(A+D)+@(A+D-1)+@(A+1)+@(A)+@(A-1)
9( 8, 7)  @(A+D+5)+@(A+D-1)+@(A+2)+@(A)+@(A-2)
11 5* @(p)+@(p-6)+@(q)+@(q-1)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-3)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-2)
5( 4, 3)  @(A+D+1)+@(A+D)+@(A+D-2)+@(A)+@(A-1)+@(A-3)
6( 5, 4)  @(A+D+2)+@(A+D-4)+@(A)+@(A-1)+@(A-3)
12 5* @(p)+@(p-6)+@(q)+@(q-1)+@(q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-2)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D-1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A)+@(A-1)+@(A-2)
7( 6, 5)  @(A+D+3)+@(A+D-3)+@(A)+@(A-1)+@(A-2)
13 5* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)
0(     )  1
1( 0, D)  @(A)

2( 1, 1)  @(A)+@(A-2)
3( 2, D)  @(A+3)+@(A+1)
4( 3, 2)  @(A+3)+@(A+1)+@(A)+@(A-2)
5( 4, 1)  @(A+3)+@(A+1)+@(A)+@(A-2)+@(D)
6( 5, 4)  @(A+4)+@(A+2)+@(A+1)+@(A-1)+@(D)
7( 6, 4)  @(A+5)+@(A)+@(A-1)+@(A-2)+@(D)
14 5* @(p)+@(p-5)+@(q)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-2)+@(A-3)
4( 3, D)  @(A+D+1)+@(A+D-1)+@(A+D-2)
5( 4, 3)  @(A+D+1)+@(A+D-1)+@(A+D-2)+@(A)+@(A-2)+@(A-3)
6( 5, 4)  @(A+D+2)+@(A+D-3)+@(A)+@(A-2)+@(A-3)
15 5* @(p)+@(p-5)+@(q)+@(q-1)+@(q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, 1)  @(A+1)+@(A-1)+@(A-2)
5( 4, D)  @(A+E+2)+@(A+E)+@(A+E-1)
6( 5, 3)  @(A+E+2)+@(A+E)+@(A+E-1)+@(A)+@(A-1)+@(A-2)
7( 6, 5)  @(A+E+3)+@(A+E-2)+@(A)+@(A-1)+@(A-2)
16 5* @(p)+@(p-3)+@(q)+@(q-1)+@(r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A)+@(A-1)+@(C)+@(D)
5( 4, 3)  @(A+1)+@(A)+@(C+1)+@(D)
6( 5, 3)  @(A+2)+@(A-1)+@(C+1)+@(C)+@(D)
17 5* @(p)+@(p-3)+@(q)+@(r)+@(r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A)+@(A-1)+@(D)+@(C)
5( 4, 3)  @(A+1)+@(A)+@(D)+@(C+1)
6( 5, 3)  @(A+2)+@(A-1)+@(D)+@(C+1)+@(C)

18 5* @(p)+@(p-1)+@(q)+@(r)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(B+D+2)+@(A+1)+@(B)
19 5* @(p)+@(q)+@(q-2)+@(q-3)+@(q-4) ,p>=6
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A+1)+@(A-2)
4( 3, D)  @(A+2)+@(A-1)
5( 4, 2)  @(A+2)+@(A)+@(A-1)+@(A-2)
6( 5, D)  @(A+3)+@(A+1)+@(A)+@(A-1)
7( 6, 4)  @(A+4)
8( 7, 6)  @(A+4)+@(A+G+3)+@(A+G+1)+@(A+G)+@(A+G-1)
20 5* @(p)+@(q)+@(q-2)+@(r)+@(r-1) ,p-q>=2
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)+@(A-1)
4( 3, 2)  @(A+2)
5( 4, D)  @(A+D+3)
6( 5, 3)  @(A+D+3)+@(A+1)+@(A-1)
7( 6, D)  @(A+D+E+4)+@(A+E+2)+@(A+E)
8( 7, 2)  @(A+D+E+4)+@(A+E+2)+@(A+E)+@(A)+@(A-1)
21 5* @(p)+@(q)+@(q-1)+@(q-2)+@(p-6)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A+1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+3)+@(A+2)+@(A+1)
6( 5, 3)  @(A+4)+@(A-2)
7( 6, 5)  @(A+4)+@(A+E+2)+@(A+E+1)+@(A+E)+@(A-2)
22 5* @(p)+@(q)+@(q-1)+@(q-2)+@(p-5)
0(     )  1
1( 0, D)  @(A)

2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, D)  @(A+2)+@(A+1)+@(A)
5( 4, 2)  @(A+3)+@(A-2)
6( 5, 4)  @(A+3)+@(A+E+1)+@(A+E)+@(A+E-1)+@(A-2)
23 5* @(p)+@(q)+@(q-1)+@(r)+@(r-2) ,p-q>=3
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 1)  @(A+1)+@(C)+@(B)
5( 4, 2)  @(A+1)+@(A)+@(C)+@(B+1)
6( 5, D)  @(A+2)+@(A+1)+@(C+1)+@(B+2)
7( 6, 4)  @(A+3)+@(C+1)+@(C)+@(B+2)+@(B)
24 5* @(p)+@(q)+@(q-1)+@(r)+@(-p+q+r+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A+1)+@(A-1)+@(C)
5( 4, 2)  @(A+2)+@(C)
6( 5, D)  @(A+E+3)+@(C+E+1)
7( 6, 3)  @(A+E+3)+@(A)+@(A-1)+@(C+E+1)+@(C)
25 5* @(p)+@(q)+@(-p+2q-2)+@(r)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(2A-B)+@(A)+@(A-B+C)
5( 4, 3)  @(2A-B)+@(A+1)+@(B)+@(A-B+C)+@(C)
26 5* @(p)+@(q)+@(r)+@(-p+2q-2)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(2A-B)+@(A)+@(A-B+C)
5( 4, 3)  @(2A-B)+@(A+1)+@(A-B+C)+@(B)+@(C)
27 5* @(p)+@(q)+@(r)+@(r-1)+@(-p+q+r+2)
0(     )  1

1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A+1)+@(A-1)+@(C)
5( 4, 2)  @(A+2)+@(C)
6( 5, D)  @(A+E+3)+@(C+E+1)
7( 6, 3)  @(A+E+3)+@(C+E+1)+@(A)+@(A-1)+@(C)
28 5* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(A+C+1)+@(B+C+1)
4( 3, 1)  @(A+C+1)+@(B+C+1)+@(D)
5( 4, 2)  @(A+C+1)+@(B+C+1)+@(A)+@(B)+@(D)
29 5* @(p)+@(q)+@(r)+@(-p+q+r-1)+@(-p+2r-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(2A-C)+@(A+B-C)+@(A)
5( 4, 3)  @(2A-C)+@(A+B-C)+@(A+1)+@(B)+@(C)
30 5* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 1)  @(A+D+2)+@(B+D+1)+@(E)
6( 5, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)+@(E)
31 5* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A-B+C)+@(-B+2C-1)+@(C)
6( 5, 3)  @(A-B+C)+@(A)+@(-B+2C-1)+@(C+1)+@(B)
32 5* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+q+2r+1)
0(     )  1

1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A-B+C)+@(-B+2C-1)+@(C)
6( 5, 3)  @(A-B+C)+@(-B+2C-1)+@(A)+@(C+1)+@(B)
33 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(A+C+1)+@(B+C+1)
4( 3, 1)  @(A+C+1)+@(B+C+1)+@(D)
5( 4, 2)  @(A+C+1)+@(B+C+1)+@(A)+@(D)+@(B)
34 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 1)  @(A+D+2)+@(B+D+1)+@(E)
6( 5, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(E)+@(B)
35 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, D)  @(A+D+1)+@(C+D+1)+@(B+D+1)
5( 4, 2)  @(A+D+1)+@(A)+@(C+D+1)+@(B+D+1)+@(B)
36 5* @(p)+@(q)+@(r)+@(s)+@(-p+q+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 1)  @(A+1)+@(C)+@(B)
5( 4, D)  @(A+E+2)+@(C+E+1)+@(B+E+1)
6( 5, 2)  @(A+E+2)+@(A)+@(C+E+1)+@(B+E+1)+@(B)
37 5* @(p)+@(q)+@(r)+@(s)+@(-p+r+s)
0(     )  1
1( 0, D)  @(A)

2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, D)  @(A+D+1)+@(C+D+1)+@(B+D+1)
5( 4, 2)  @(A+D+1)+@(C+D+1)+@(B+D+1)+@(A)+@(B)
38 5* @(p)+@(q)+@(r)+@(s)+@(-p+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 1)  @(A+1)+@(D)+@(B)
5( 4, D)  @(A+E+2)+@(D+E+1)+@(B+E+1)
6( 5, 2)  @(A+E+2)+@(D+E+1)+@(B+E+1)+@(A)+@(B)
39 5  @(p)+@(q)+@(r)+@(s)+@(-q+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 1, D)  @(A+C+1)
4( 3, 2)  @(A+C+1)+@(A)+@(B)
5( 4, D)  @(A+C+D+2)+@(A+D+1)+@(B+D+1)
6( 5, 2)  @(A+C+D+2)+@(A+D+1)+@(B+D+1)+@(A)+@(B)
40 6* @(p)+@(p-7)+@(p-8)+@(p-11)+@(p-12)+@(p-13)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A+1)+@(A-3)
4( 3, D)  @(A+6)+@(A+2)
5( 4, 2)  @(A+6)+@(A+2)+@(A)+@(A-3)
6( 5, D)  @(A+8)+@(A+4)+@(A+2)+@(A-1)
7( 6, 5)  @(A+8)+@(A+6)+@(A+4)+@(A+3)+@(A)+@(A-1)+@(A-3)
8( 7, D)  @(A+9)+@(A+7)+@(A+5)+@(A+4)+@(A+1)+@(A)+@(A-2)
9( 8, 7)  @(A+10)+@(A+3)+@(A+2)+@(A-1)+@(A-2)+@(A-3)
41 6* @(p)+@(p-7)+@(p-8)+@(p-9)+@(p-10)+@(p-13)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-5)
3( 2, 1)  @(A+1)+@(A-5)
4( 3, 2)  @(A+1)+@(A)+@(A-4)
5( 4, 3)  @(A+2)+@(A)+@(A-4)+@(A-5)
6( 5, D)  @(A+6)+@(A+4)+@(A)+@(A-1)
7( 6, 5)  @(A+6)+@(A+4)+@(A+2)+@(A+1)+@(A-1)+@(A-4)+@(A-5)

8( 7, D)  @(A+7)+@(A+5)+@(A+3)+@(A+2)+@(A)+@(A-3)+@(A-4)
9( 8, 7)  @(A+8)+@(A+1)+@(A)+@(A-1)+@(A-2)+@(A-5)
42 6* @(p)+@(p-7)+@(q)+@(q-3)+@(q-4)+@(q-5) ,q>=6
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A+1)+@(A-3)
4( 3, 2)  @(A+1)+@(A)+@(A-2)
5( 4, 3)  @(A+2)+@(A)+@(A-2)+@(A-3)
6( 5, D)  @(A+D+3)+@(A+D+1)+@(A+D-1)+@(A+D-2)
7( 6, 4)  @(A+D+3)+@(A+D+1)+@(A+D-1)+@(A+D-2)+@(A+1)+@(A)+@(A-2)
8( 7, D)  @(A+D+4)+@(A+D+2)+@(A+D)+@(A+D-1)+@(A+2)+@(A+1)+@(A-1)
9( 8, 7)  @(A+D+5)+@(A+D-2)+@(A+3)+@(A)+@(A-1)+@(A-2)
43 6* @(p)+@(p-7)+@(q)+@(q-2)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+3)+@(A+2)+@(C+3)
5( 4, 3)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+3)+@(C)
6( 5, 4)  @(A+4)+@(A+3)+@(A)+@(A-1)+@(C+4)+@(C)
7( 6, 5)  @(A+5)+@(A+2)+@(A+1)+@(A)+@(C+4)+@(C+3)+@(C+1)
8( 7, 6)  @(A+6)+@(A-1)+@(C+5)+@(C+3)+@(C+1)+@(C)
44 6* @(p)+@(p-7)+@(q)+@(q-2)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+3)+@(A+2)+@(C+2)
6( 5, 3)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+2)+@(C)
7( 6, 5)  @(A+4)+@(A+3)+@(A)+@(A-1)+@(C+3)+@(C)
8( 7, 6)  @(A+5)+@(A+2)+@(A+1)+@(A)+@(C+3)+@(C+2)+@(C+1)
9( 8, 7)  @(A+6)+@(A-1)+@(C+4)+@(C+2)+@(C+1)+@(C)
45 6* @(p)+@(p-7)+@(q)+@(q-1)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, 2)  @(A+1)+@(A-1)+@(B+1)

5( 4, D)  @(A+4)+@(A+2)+@(B+4)
6( 5, 3)  @(A+4)+@(A+2)+@(A)+@(A-1)+@(B+4)+@(B)
7( 6, D)  @(A+5)+@(A+3)+@(A+1)+@(A)+@(B+5)+@(B+1)
8( 7, 6)  @(A+6)+@(A-1)+@(B+5)+@(B+4)+@(B+1)+@(B)
46 6* @(p)+@(p-7)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A+1)+@(A-1)+@(C)
5( 4, D)  @(A+4)+@(A+2)+@(C+3)
6( 5, 3)  @(A+4)+@(A+2)+@(A)+@(A-1)+@(C+3)+@(C)
7( 6, D)  @(A+5)+@(A+3)+@(A+1)+@(A)+@(C+4)+@(C+1)
8( 7, 6)  @(A+6)+@(A-1)+@(C+4)+@(C+3)+@(C+1)+@(C)
47 6* @(p)+@(p-7)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-3)+@(B)
4( 3, 2)  @(A+1)+@(A-3)+@(B+1)
5( 4, 3)  @(A+1)+@(A)+@(A-2)+@(B+1)+@(B)
6( 5, 4)  @(A+2)+@(A)+@(A-2)+@(A-3)+@(B+2)+@(B)
7( 6, D)  @(A+3)+@(A+1)+@(A-1)+@(A-2)+@(B+3)+@(B+1)
8( 7, 6)  @(A+4)+@(A-3)+@(B+3)+@(B+2)+@(B+1)+@(B)
48 6* @(p)+@(p-6)+@(q)+@(q-3)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-3)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-2)
5( 4, 3)  @(A+D+1)+@(A+D)+@(A+D-2)+@(A)+@(A-1)+@(A-3)
6( 5, 4)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A)+@(A-1)+@(A-3)
7( 6, 5)  @(A+D+3)+@(A+D)+@(A+D-1)+@(A+D-2)+@(A+1)+@(A)+@(A-2)
8( 7, 6)  @(A+D+4)+@(A+D-2)+@(A+2)+@(A-1)+@(A-2)+@(A-3)
49 6* @(p)+@(p-6)+@(q)+@(q-2)+@(q-4)+@(q-6)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A+1)+@(A-3)
4( 3, 2)  @(A+1)+@(A)+@(A-2)

5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D-1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A+1)+@(A-3)
7( 6, D)  @(A+D+4)+@(A+D+3)+@(A+D+1)+@(A+3)+@(A-1)
8( 7, 6)  @(A+D+5)+@(A+D-1)+@(A+3)+@(A+1)+@(A-1)+@(A-3)
50 6* @(p)+@(p-6)+@(q)+@(q-2)+@(q-3)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A)+@(A-1)+@(A-3)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-2)
5( 4, 2)  @(A+D+1)+@(A+D)+@(A+D-2)+@(A)+@(A-3)
6( 5, D)  @(A+D+3)+@(A+D+2)+@(A+D)+@(A+2)+@(A-1)
7( 6, 5)  @(A+D+4)+@(A+D-2)+@(A+2)+@(A)+@(A-1)+@(A-3)
51 6* @(p)+@(p-6)+@(q)+@(q-1)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A+1)+@(A-3)
4( 3, 2)  @(A+1)+@(A)+@(A-2)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D-1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A+1)+@(A-3)
7( 6, 5)  @(A+D+3)+@(A+D+2)+@(A+D)+@(A+1)+@(A-3)
8( 7, 6)  @(A+D+4)+@(A+D+1)+@(A+D)+@(A+D-1)+@(A+2)+@(A-2)
9( 8, 7)  @(A+D+5)+@(A+D-1)+@(A+2)+@(A+1)+@(A-2)+@(A-3)
52 6* @(p)+@(p-6)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A)+@(A-1)+@(A-3)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-2)
5( 4, 2)  @(A+D+1)+@(A+D)+@(A+D-2)+@(A)+@(A-3)
6( 5, 4)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A)+@(A-3)
7( 6, 5)  @(A+D+3)+@(A+D)+@(A+D-1)+@(A+D-2)+@(A+1)+@(A-2)
8( 7, 6)  @(A+D+4)+@(A+D-2)+@(A+1)+@(A)+@(A-2)+@(A-3)
53 6* @(p)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-2)+@(B)
4( 3, 2)  @(A+1)+@(A-2)+@(B+1)

5( 4, 2)  @(A+1)+@(A)+@(A-2)+@(B+1)+@(B)
6( 5, D)  @(A+3)+@(A+2)+@(A)+@(B+3)+@(B+2)
7( 6, 5)  @(A+4)+@(A-2)+@(B+3)+@(B+2)+@(B+1)+@(B)
54 6* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-2)+@(C)
4( 3, 2)  @(A+1)+@(A-1)+@(C)
5( 4, 2)  @(A+1)+@(A)+@(A-1)+@(A-2)+@(C)
6( 5, D)  @(A+4)+@(A+3)+@(A+2)+@(A+1)+@(C+3)
7( 6, 5)  @(A+5)+@(A)+@(A-1)+@(A-2)+@(C+3)+@(C)
55 6* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A)+@(A-3)+@(C)
4( 3, 2)  @(A+1)+@(A-2)+@(C)
5( 4, 2)  @(A+1)+@(A)+@(A-2)+@(A-3)+@(C)
6( 5, D)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+2)
7( 6, 5)  @(A+4)+@(A-1)+@(A-2)+@(A-3)+@(C+2)+@(C)
56 6* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, D)  @(A+3)+@(A+1)
4( 3, 1)  @(A+3)+@(A+1)+@(D)
5( 4, 2)  @(A+3)+@(A+1)+@(A)+@(A-2)+@(D)
6( 5, D)  @(A+4)+@(A+2)+@(A+1)+@(A-1)+@(D+1)
7( 6, 5)  @(A+5)+@(A)+@(A-1)+@(A-2)+@(D+1)+@(D)
57 6* @(p)+@(p-5)+@(q)+@(q-3)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A)+@(A-1)+@(A-3)
4( 3, 2)  @(A+1)+@(A-1)+@(A-2)
5( 4, D)  @(A+D+2)+@(A+D)+@(A+D-1)
6( 5, 3)  @(A+D+2)+@(A+D)+@(A+D-1)+@(A)+@(A-1)+@(A-3)
7( 6, D)  @(A+D+3)+@(A+D+1)+@(A+D)+@(A+1)+@(A)+@(A-2)
8( 7, 6)  @(A+D+4)+@(A+D-1)+@(A+2)+@(A-1)+@(A-2)+@(A-3)

58 6* @(p)+@(p-5)+@(q)+@(q-2)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, D)  @(A+3)+@(A+2)+@(B+3)
6( 5, 3)  @(A+3)+@(A+2)+@(A+1)+@(B+3)+@(B)
7( 6, 5)  @(A+4)+@(A+3)+@(A+1)+@(B+4)+@(B)
8( 7, 6)  @(A+5)+@(A+3)+@(B+4)+@(B+3)+@(B+1)
9( 8, 7)  @(A+6)+@(A+1)+@(B+5)+@(B+3)+@(B+1)+@(B)
59 6* @(p)+@(p-5)+@(q)+@(q-2)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, D)  @(A+2)+@(A+1)+@(B+2)
5( 4, 2)  @(A+2)+@(A+1)+@(A)+@(B+2)+@(B)
6( 5, 4)  @(A+3)+@(A+2)+@(A)+@(B+3)+@(B)
7( 6, 5)  @(A+4)+@(A+2)+@(B+3)+@(B+2)+@(B+1)
8( 7, 6)  @(A+5)+@(A)+@(B+4)+@(B+2)+@(B+1)+@(B)
60 6* @(p)+@(p-5)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A)+@(A-2)+@(A-3)
4( 3, D)  @(A+D+1)+@(A+D-1)+@(A+D-2)
5( 4, 2)  @(A+D+1)+@(A+D-1)+@(A+D-2)+@(A)+@(A-3)
6( 5, D)  @(A+D+2)+@(A+D)+@(A+D-1)+@(A+1)+@(A-2)
7( 6, 5)  @(A+D+3)+@(A+D-2)+@(A+1)+@(A)+@(A-2)+@(A-3)
61 6* @(p)+@(p-5)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-3)+@(B)
4( 3, D)  @(A+2)+@(A-1)+@(B+2)
5( 4, 2)  @(A+2)+@(A)+@(A-1)+@(B+2)+@(B)
6( 5, D)  @(A+3)+@(A+1)+@(A)+@(B+3)+@(B+1)
7( 6, 5)  @(A+4)+@(A-1)+@(B+3)+@(B+2)+@(B+1)+@(B)

62 6* @(p)+@(p-4)+@(p-7)+@(p-11)+@(p-12)+@(p-13)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)
4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+8)+@(A+7)+@(A+6)+@(A+5)
6( 5, 4)  @(A+8)+@(A+7)+@(A+6)+@(A+5)+@(A+2)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+11)+@(A+10)+@(A+9)+@(A+8)+@(A+5)+@(A+4)+@(A+3)+@(A+2)
8( 7, 6)  @(A+12)+@(A+8)+@(A+5)+@(A+1)+@(A)+@(A-1)
63 6* @(p)+@(p-4)+@(p-7)+@(p-8)+@(p-9)+@(p-11)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-5)
4( 3, D)  @(A+2)+@(A+1)+@(A-3)
5( 4, 3)  @(A+2)+@(A+1)+@(A)+@(A-1)+@(A-3)+@(A-5)
6( 5, D)  @(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A)+@(A-2)
7( 6, 5)  @(A+6)+@(A+2)+@(A-1)+@(A-2)+@(A-3)+@(A-5)
64 6* @(p)+@(p-4)+@(p-6)+@(q)+@(q-2)+@(q-4) ,q>=5
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A+1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-1)
5( 4, 3)  @(A+2)+@(A)+@(A-1)+@(A-2)
6( 5, D)  @(A+D+3)+@(A+D+1)+@(A+D)+@(A+D-1)
7( 6, 4)  @(A+D+3)+@(A+D+1)+@(A+D)+@(A+D-1)+@(A+1)+@(A)+@(A-1)
8( 7, D)  @(A+D+4)+@(A+D+2)+@(A+D+1)+@(A+D)+@(A+2)+@(A+1)+@(A)
9( 8, 7)  @(A+D+5)+@(A+D+1)+@(A+D-1)+@(A+3)+@(A+1)+@(A-1)
65 6* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+2)+@(A+1)+@(C+1)
6( 5, 3)  @(A+2)+@(A+1)+@(A)+@(A-1)+@(C+1)+@(C)
7( 6, 5)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+2)+@(C)
8( 7, 6)  @(A+4)+@(A+2)+@(A)+@(C+3)
9( 8, 7)  @(A+5)+@(A+1)+@(A-1)+@(C+3)+@(C+2)+@(C)

66 6* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-2) ,q>=3
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, 3)  @(A+2)+@(A-1)+@(C+1)
6( 5, 4)  @(A+2)+@(A+1)+@(A)+@(A-1)+@(C+1)+@(C)
7( 6, D)  @(A+4)+@(A+3)+@(A+2)+@(A+1)+@(C+3)+@(C+2)
8( 7, 5)  @(A+5)+@(A+1)+@(A-1)+@(C+3)+@(C+2)+@(C+1)
67 6* @(p)+@(p-4)+@(p-5)+@(q)+@(q-2)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-1)
5( 4, 3)  @(A+D+1)+@(A+D)+@(A+D-1)+@(A)+@(A-1)+@(A-2)
6( 5, 4)  @(A+D+2)+@(A+D+1)+@(A+D)+@(A)+@(A-1)+@(A-2)
7( 6, 5)  @(A+D+3)+@(A+D+1)+@(A+D-1)+@(A+1)+@(A)+@(A-1)
8( 7, 6)  @(A+D+4)+@(A+D)+@(A+D-1)+@(A+2)+@(A)+@(A-2)
68 6* @(p)+@(p-4)+@(p-5)+@(q)+@(q-1)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-1)
5( 4, 2)  @(A+D+1)+@(A+D)+@(A+D-1)+@(A)+@(A-2)
6( 5, D)  @(A+D+3)+@(A+D+2)+@(A+D+1)+@(A+2)+@(A)
7( 6, 5)  @(A+D+4)+@(A+D)+@(A+D-1)+@(A+2)+@(A+1)+@(A-2)
69 6* @(p)+@(p-4)+@(p-5)+@(q)+@(q-1)+@(q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-1)
5( 4, 3)  @(A+D+1)+@(A+D)+@(A+D-1)+@(A)+@(A-1)+@(A-2)
6( 5, 4)  @(A+D+2)+@(A+D-2)+@(A+D-3)+@(A)+@(A-1)+@(A-2)
70 6* @(p)+@(p-4)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1

1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)
4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, 1)  @(A+3)+@(A-1)
6( 5, D)  @(A+E+4)+@(A+E)
7( 6, 4)  @(A+E+4)+@(A+E)+@(A+2)+@(A+1)+@(A)+@(A-1)
71 6* @(p)+@(p-3)+@(p-5)+@(p-6)+@(q)+@(q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-2)+@(C)
4( 3, 2)  @(A+1)+@(A-1)+@(C)
5( 4, 2)  @(A+1)+@(A)+@(A-1)+@(A-2)+@(C)
6( 5, D)  @(A+3)+@(A+2)+@(A+1)+@(A)+@(C+2)
7( 6, 5)  @(A+4)+@(A+1)+@(A-1)+@(A-2)+@(C+2)+@(C)
72 6* @(p)+@(p-3)+@(q)+@(q-5)+@(-p+2q-3)+@(-p+2q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(2A-C+2)+@(2A-C+1)+@(A+2)
5( 4, 3)  @(2A-C+2)+@(2A-C+1)+@(A+2)+@(A)+@(A-1)+@(C)
6( 5, D)  @(2A-C+3)+@(2A-C+2)+@(A+3)+@(A+1)+@(A)+@(C+1)
7( 6, 5)  @(2A-C+4)+@(2A-C+1)+@(A+4)+@(A-1)+@(C+1)+@(C)
73 6* @(p)+@(p-3)+@(q)+@(q-5)+@(-p+2q-2)+@(-p+2q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(2A-C+3)+@(2A-C+2)+@(A+2)
6( 5, 3)  @(2A-C+3)+@(2A-C+2)+@(A+2)+@(A)+@(A-1)+@(C)
7( 6, D)  @(2A-C+4)+@(2A-C+3)+@(A+3)+@(A+1)+@(A)+@(C+1)
8( 7, 6)  @(2A-C+5)+@(2A-C+2)+@(A+4)+@(A-1)+@(C+1)+@(C)
74 6* @(p)+@(p-3)+@(q)+@(q-3)+@(r)+@(r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)

4( 3, 2)  @(A+1)+@(B+1)+@(C)
5( 4, 2)  @(A+1)+@(A)+@(B+1)+@(B)+@(C)
6( 5, D)  @(A+2)+@(A+1)+@(B+2)+@(B+1)+@(C+1)
7( 6, 5)  @(A+3)+@(A)+@(B+3)+@(B)+@(C+1)+@(C)
75 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, 2)  @(A+1)+@(A)+@(C)+@(B+1)+@(B)
6( 5, D)  @(A+2)+@(A+1)+@(C+1)+@(B+2)+@(B+1)
7( 6, 5)  @(A+3)+@(A)+@(C+1)+@(C)+@(B+3)+@(B)
76 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A)+@(A-1)+@(C)+@(D)
5( 4, D)  @(A+1)+@(A)+@(C+1)+@(D+1)
6( 5, 4)  @(A+2)+@(A-1)+@(C+1)+@(C)+@(D+1)+@(D)
77 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(B+D+2)+@(A+1)+@(B)
7( 6, 5)  @(A+D+3)+@(A+D)+@(B+D+2)+@(B+D+1)+@(A+1)+@(B)
78 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, D)  @(A+D+1)+@(A+D)+@(B+D+1)
5( 4, 2)  @(A+D+1)+@(A+D)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+2)+@(A+D-1)+@(B+D+1)+@(B+D)+@(A)+@(B)
79 6* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(-p+q+r+2)

0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, 2)  @(A+2)+@(A-1)+@(C)
6( 5, D)  @(A+D+3)+@(A+D)+@(C+D+1)
7( 6, 3)  @(A+D+3)+@(A+D)+@(A)+@(A-1)+@(C+D+1)+@(C)
80 6* @(p)+@(p-3)+@(q)+@(r)+@(r-1)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, 3)  @(A+2)+@(A-1)+@(C+1)
6( 5, D)  @(A+D+3)+@(A+D)+@(C+D+2)
7( 6, 4)  @(A+D+3)+@(A+D)+@(C+D+2)+@(A+1)+@(A)+@(C)
81 6* @(p)+@(p-3)+@(q)+@(r)+@(r-1)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, D)  @(A+D+1)+@(A+D)+@(B+D+1)
5( 4, 2)  @(A+D+1)+@(A+D)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+2)+@(A+D-1)+@(A)+@(B+D+1)+@(B+D)+@(B)
82 6* @(p)+@(p-3)+@(q)+@(r)+@(r-1)+@(-p+q+r+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, 2)  @(A+2)+@(A-1)+@(C)
6( 5, D)  @(A+D+3)+@(A+D)+@(C+D+1)
7( 6, 3)  @(A+D+3)+@(A+D)+@(C+D+1)+@(A)+@(A-1)+@(C)
83 6* @(p)+@(p-2)+@(p-4)+@(q)+@(q-1)+@(q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-1)

5( 4, 3)  @(A+D+1)+@(A+D)+@(A+D-1)+@(A)+@(A-1)+@(A-2)
6( 5, 4)  @(A+D+2)+@(A+D)+@(A+D-2)+@(A)+@(A-1)+@(A-2)
84 6* @(p)+@(p-2)+@(q)+@(q-4)+@(-p+2q-3)+@(-p+2q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, D)  @(2A-B+4)+@(2A-B+2)+@(A+3)+@(A+2)
7( 6, 5)  @(2A-B+4)+@(2A-B+2)+@(A+4)+@(A)+@(B+1)+@(B)
85 6* @(p)+@(p-2)+@(q)+@(q-4)+@(-p+2q-2)+@(-p+2q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)+@(A-1)
4( 3, D)  @(A+D+2)+@(A+D)
5( 4, 2)  @(A+D+2)+@(A+D)+@(A)+@(A-1)
6( 5, 4)  @(A+D+3)+@(A+D+1)+@(A)+@(A-1)
7( 6, D)  @(A+2D+6)+@(A+2D+4)+@(A+D+3)+@(A+D+2)
8( 7, 5)  @(A+2D+6)+@(A+2D+4)+@(A+D+4)+@(A+D)+@(A)+@(A-1)
86 6* @(p)+@(p-1)+@(p-2)+@(p-3)+@(q)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, D)  @(A+3)+@(A+1)+@(B+2)+@(B+1)
7( 6, 5)  @(A+3)+@(A+2)+@(A+1)+@(A)+@(B+3)+@(B)
87 6* @(p)+@(p-1)+@(q)+@(q-3)+@(-p+2q-3)+@(-p+2q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+C+1)+@(A+C)
4( 3, 2)  @(A+C+1)+@(A+C)+@(A)+@(A-1)
5( 4, D)  @(A+2C+3)+@(A+2C+2)+@(A+C+2)+@(A+C+1)
6( 5, 4)  @(A+2C+3)+@(A+2C+2)+@(A+C+3)+@(A+C)+@(A)+@(A-1)
88 6* @(p)+@(p-1)+@(q)+@(q-3)+@(-p+2q-2)+@(-p+2q-3)

0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(2A-B+2)+@(A+1)
5( 4, 2)  @(2A-B+2)+@(A+1)+@(A)+@(B)
6( 5, D)  @(2A-B+3)+@(A+2)+@(A+1)+@(B+1)
7( 6, 5)  @(2A-B+3)+@(2A-B+2)+@(A+3)+@(A)+@(B+1)+@(B)
89 6* @(p)+@(q)+@(p-7)+@(q-3)+@(q-4)+@(q-5) ,q>=6
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+C+1)+@(A+C)
4( 3, 2)  @(A+C+1)+@(A+C)+@(A)+@(A-1)
5( 4, 3)  @(A+C+2)+@(A+C+1)+@(A)+@(A-1)
6( 5, 4)  @(A+C+3)+@(A+C)+@(A+1)+@(A)
7( 6, 5)  @(A+C+3)+@(A+C+2)+@(A+C+1)+@(A+C)+@(A+2)+@(A-1)
8( 7, D)  @(A+C+6)+@(A+C+5)+@(A+C+4)+@(A+C+3)+@(A+5)+@(A+2)
9( 8, 6)  @(A+C+7)+@(A+5)+@(A+C)+@(A+2)+@(A+1)+@(A)
90 6* @(p)+@(q)+@(p-5)+@(q-3)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+3)+@(A+2)
4( 3, 2)  @(A+3)+@(A+2)+@(A)+@(A-1)
5( 4, 3)  @(A+4)+@(A+1)+@(A)+@(A-1)
6( 5, 4)  @(A+5)+@(A)
7( 6, D)  @(A+E+6)+@(A+E+1)
8( 7, 5)  @(A+E+6)+@(A+4)+@(A+E+1)+@(A+1)+@(A)+@(A-1)
91 6* @(p)+@(q)+@(p-3)+@(q-3)+@(r)+@(r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+1)+@(A)
4( 3, 2)  @(A+2)+@(A-1)
5( 4, D)  @(A+D+3)+@(A+D)
6( 5, 2)  @(A+D+3)+@(A+D)+@(A)+@(A-1)
7( 6, 5)  @(A+D+3)+@(A+E+3)+@(A+D)+@(A+E)+@(A)+@(A-1)
92 6* @(p)+@(q)+@(q-2)+@(r)+@(r-1)+@(-p+q+r+1) ,-p+q+r>=0
0(     )  1

1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, 2)  @(A+1)+@(A-1)+@(B+1)
5( 4, 3)  @(A+2)+@(B+1)+@(B)
6( 5, D)  @(A+D+3)+@(B+D+2)+@(B+D+1)
7( 6, 4)  @(A+D+3)+@(A+1)+@(A-1)+@(B+D+2)+@(B+D+1)+@(B+1)
93 6* @(p)+@(q)+@(q-1)+@(p-7)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+3)+@(A+2)
4( 3, 2)  @(A+3)+@(A+2)+@(A)+@(A-1)
5( 4, 3)  @(A+4)+@(A+3)+@(A)+@(A-1)
6( 5, 4)  @(A+5)+@(A+2)+@(A+1)+@(A)
7( 6, 5)  @(A+6)+@(A-1)
8( 7, D)  @(A+E+7)+@(A+E)
9( 8, 5)  @(A+E+7)+@(A+4)+@(A+3)+@(A+E)+@(A)+@(A-1)
94 6* @(p)+@(q)+@(q-1)+@(q-4)+@(-p+2q-2)+@(-p+2q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, 4)  @(A+3)+@(B+2)+@(B)
7( 6, D)  @(2A-B+5)+@(A+4)+@(A+2)
8( 7, 5)  @(2A-B+5)+@(A+4)+@(A+3)+@(A)+@(B+1)+@(B)
95 6* @(p)+@(q)+@(q-1)+@(q-2)+@(q-3)+@(p-7)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+1)+@(A)
4( 3, 2)  @(A+2)+@(A-1)
5( 4, 3)  @(A+2)+@(A+1)+@(A)+@(A-1)
6( 5, D)  @(A+5)+@(A+4)+@(A+3)+@(A+2)
7( 6, 4)  @(A+6)+@(A-1)
8( 7, 6)  @(A+6)+@(A+F+3)+@(A+F+2)+@(A+F+1)+@(A+F)+@(A-1)
96 6* @(p)+@(q)+@(q-1)+@(q-2)+@(-p+2q)+@(-2p+3q-2)
0(     )  1

1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(2A-B+2)+@(A+1)
5( 4, 2)  @(2A-B+2)+@(A+1)+@(A)+@(B)
6( 5, D)  @(3A-2B+2)+@(2A-B+1)+@(2A-B)+@(A)
7( 6, 5)  @(3A-2B+2)+@(2A-B+2)+@(2A-B+1)+@(2A-B)+@(A+2)+@(B)
97 6* @(p)+@(q)+@(q-1)+@(-p+2q+1)+@(-2p+3q+1)+@(-3p+4q+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(2A-B+1)+@(A)
5( 4, 2)  @(2A-B+1)+@(A+1)+@(B)
6( 5, 4)  @(2A-B+2)+@(A+1)+@(A)+@(B)
7( 6, D)  @(4A-3B+3)+@(3A-2B+2)+@(3A-2B+1)+@(2A-B+1)
8( 7, 5)  @(4A-3B+3)+@(3A-2B+2)+@(3A-2B+1)+@(2A-B+2)+@(A+1)+@(B)
98 6* @(p)+@(q)+@(q-1)+@(r)+@(r-2)+@(-p+q+r+1) ,-p+q+r>=0
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, 2)  @(A+1)+@(A-1)+@(B+1)
5( 4, 3)  @(A+2)+@(B+1)+@(B)
6( 5, D)  @(A+D+3)+@(B+D+2)+@(B+D+1)
7( 6, 4)  @(A+D+3)+@(B+D+2)+@(B+D+1)+@(A+1)+@(A-1)+@(B+1)
99 6* @(p)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, 2)  @(A+1)+@(A-1)+@(B+1)
5( 4, 3)  @(A+2)+@(B+1)+@(B)
6( 5, D)  @(A+D+3)+@(B+D+2)+@(B+D+1)
7( 6, 3)  @(A+D+3)+@(A)+@(A-1)+@(B+D+2)+@(B+D+1)+@(B)
100 6* @(p)+@(q)+@(-p+2q)+@(-2p+3q-1)+@(-2p+3q-2)+@(-3p+4q-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2D-4)
3( 2, 1)  @(A+1)+@(A-2D-4)

4( 3, D)  @(A+D+2)+@(A-D-3)
5( 4, 2)  @(A+D+2)+@(A)+@(A-D-3)+@(A-2D-4)
6( 5, 4)  @(A+D+3)+@(A)+@(A-D-2)+@(A-2D-4)
7( 6, D)  @(A+2D+5)+@(A+D+2)+@(A)+@(A-D-2)
8( 7, 5)  @(A+2D+5)+@(A+D+3)+@(A+1)+@(A-D-2)+@(A-D-3)+@(A-2D-4)
101 6* @(p)+@(q)+@(-p+2q-2)+@(-p+2q-3)+@(-p+2q-4)+@(-2p+3q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(2A-B+2)+@(A+1)
5( 4, 2)  @(2A-B+2)+@(A+1)+@(A)+@(B)
6( 5, D)  @(3A-2B+4)+@(2A-B+3)+@(2A-B+2)+@(A+2)
7( 6, 5)  @(3A-2B+4)+@(2A-B+4)+@(A+2)+@(A+1)+@(A)+@(B)
102 6* @(p)+@(q)+@(-p+2q-2)+@(r)+@(-p+q+r+1)+@(-2p+2q+r) ,q-r>=3
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(2A-B+D+3)+@(A+D+2)+@(2A-B)+@(A)
8( 7, 5)  @(2A-B+D+3)+@(A+D+3)+@(B+D+1)+@(2A-B)+@(A+1)+@(B)
103 6* @(p)+@(q)+@(-p+2q-1)+@(-2p+3q-2)+@(-2p+3q-3)+@(-3p+4q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(3A-2B+2)+@(2A-B+1)
5( 4, 2)  @(3A-2B+2)+@(2A-B+1)+@(A)+@(B)
6( 5, D)  @(4A-3B+3)+@(3A-2B+2)+@(2A-B+1)+@(A+1)
7( 6, 5)  @(4A-3B+3)+@(3A-2B+3)+@(2A-B+2)+@(A+1)+@(A)+@(B)
104 6* @(p)+@(q)+@(r)+@(-p+2q-2)+@(-p+q+r+1)+@(-2p+2q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)

6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(2A-B+D+3)+@(A+D+2)+@(2A-B)+@(A)
8( 7, 5)  @(2A-B+D+3)+@(A+D+3)+@(2A-B)+@(B+D+1)+@(A+1)+@(B)
105 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(A+D+1)+@(B+D+1)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(A)+@(B+D+1)+@(B)+@(C+D+1)+@(C)
106 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 2)  @(A+1)+@(B+1)+@(C)
5( 4, D)  @(A+D+2)+@(B+D+2)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(A)+@(B+D+2)+@(B)+@(C+D+1)+@(C)
107 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(A+D+1)+@(B+D+1)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(B+D+1)+@(A)+@(B)+@(C+D+1)+@(C)
108 6* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 2)  @(A+1)+@(B+1)+@(C)
5( 4, D)  @(A+D+2)+@(B+D+2)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(B+D+2)+@(A)+@(B)+@(C+D+1)+@(C)
109 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-p+2r-2)+@(-2p+q+2r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)

5( 4, 2)  @(A+D+2)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+3)+@(A)+@(B+D+2)+@(B)
7( 6, D)  @(2A-B+D+3)+@(2A-B)+@(A+D+2)+@(A)
8( 7, 5)  @(2A-B+D+3)+@(2A-B)+@(A+D+3)+@(A+1)+@(B+D+1)+@(B)
110 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A+D+2)+@(C+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(A)+@(C+D+1)+@(C)+@(B+D+2)+@(B)
111 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 1)  @(A+1)+@(B)+@(C)
5( 4, D)  @(A+E+2)+@(B+E+1)+@(C+E+1)
6( 5, 3)  @(A+E+2)+@(A)+@(B+E+1)+@(B)+@(C+E+1)+@(C)
112 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A+D+2)+@(C+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(C+D+1)+@(A)+@(C)+@(B+D+2)+@(B)
113 6* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 1)  @(A+1)+@(B)+@(C)
5( 4, D)  @(A+E+2)+@(B+E+1)+@(C+E+1)
6( 5, 3)  @(A+E+2)+@(B+E+1)+@(A)+@(B)+@(C+E+1)+@(C)
114 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s)
0(     )  1
1( 0, D)  @(A)

2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(A+D+1)+@(B+D+1)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(A)+@(B+D+1)+@(C+D+1)+@(B)+@(C)
115 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 2)  @(A+1)+@(B+1)+@(C)
5( 4, D)  @(A+D+2)+@(B+D+2)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(A)+@(B+D+2)+@(C+D+1)+@(B)+@(C)
116 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(A+D+1)+@(B+D+1)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(B+D+1)+@(A)+@(C+D+1)+@(B)+@(C)
117 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 2)  @(A+1)+@(B+1)+@(C)
5( 4, D)  @(A+D+2)+@(B+D+2)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(B+D+2)+@(A)+@(C+D+1)+@(B)+@(C)
118 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A+D+2)+@(C+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(A)+@(C+D+1)+@(B+D+2)+@(C)+@(B)
119 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)

3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 1)  @(A+1)+@(B)+@(C)
5( 4, D)  @(A+E+2)+@(B+E+1)+@(C+E+1)
6( 5, 3)  @(A+E+2)+@(A)+@(B+E+1)+@(C+E+1)+@(B)+@(C)
120 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+r+s) ,p-q>=2
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A+D+2)+@(C+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(C+D+1)+@(A)+@(B+D+2)+@(C)+@(B)
121 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+r+s+1) ,p-q>=2
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 1)  @(A+1)+@(B)+@(C)
5( 4, D)  @(A+E+2)+@(B+E+1)+@(C+E+1)
6( 5, 3)  @(A+E+2)+@(B+E+1)+@(A)+@(C+E+1)+@(B)+@(C)
122 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s)+@(-p+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, D)  @(A+D+1)+@(B+D+1)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(B+D+1)+@(C+D+1)+@(A)+@(B)+@(C)
123 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s)+@(-p+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 2)  @(A+1)+@(B+1)+@(C)
5( 4, D)  @(A+D+2)+@(B+D+2)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(B+D+2)+@(C+D+1)+@(A)+@(B)+@(C)
124 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s+1)+@(-p+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)

3( 2, 1)  @(A)+@(C)+@(B)
4( 3, 2)  @(A+1)+@(C)+@(B+1)
5( 4, D)  @(A+D+2)+@(C+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(C+D+1)+@(B+D+2)+@(A)+@(C)+@(B)
125 6* @(p)+@(q)+@(r)+@(s)+@(-p+q+s+1)+@(-p+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(B)+@(C)
4( 3, 1)  @(A+1)+@(B)+@(C)
5( 4, D)  @(A+E+2)+@(B+E+1)+@(C+E+1)
6( 5, 3)  @(A+E+2)+@(B+E+1)+@(C+E+1)+@(A)+@(B)+@(C)
126 7* @(p)+@(p-6)+@(p-7)+@(p-8)+@(p-10)+@(p-11)+@(p-12)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A+1)+@(A-3)
4( 3, D)  @(A+5)+@(A+1)
5( 4, 2)  @(A+5)+@(A+1)+@(A)+@(A-3)
6( 5, D)  @(A+7)+@(A+3)+@(A+2)+@(A-1)
7( 6, 5)  @(A+7)+@(A+5)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)+@(A-3)
8( 7, D)  @(A+8)+@(A+6)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-2)
9( 8, 7)  @(A+9)+@(A+3)+@(A+2)+@(A+1)+@(A-1)+@(A-2)+@(A-3)
127 7* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-2)+@(q-6)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, D)  @(A+5)+@(A+3)+@(B+4)+@(B+3)
7( 6, 5)  @(A+5)+@(A+3)+@(A+2)+@(A)+@(B+4)+@(B+3)+@(B+1)+@(B)
8( 7, D)  @(A+6)+@(A+4)+@(A+3)+@(A+1)+@(B+5)+@(B+4)+@(B+2)+@(B+1)
9( 8, 7)  @(A+7)+@(A+2)+@(A+1)+@(A)+@(B+6)+@(B+4)+@(B)
128 7* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)

5( 4, D)  @(A+3)+@(A+2)+@(C+2)
6( 5, 3)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+2)+@(C)
7( 6, D)  @(A+5)+@(A+4)+@(A+2)+@(A+1)+@(C+4)+@(C+2)
8( 7, 6)  @(A+6)+@(A+1)+@(A)+@(A-1)+@(C+4)+@(C+3)+@(C)
129 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-3)+@(q-4)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)+@(A-1)
4( 3, D)  @(A+2)+@(A)
5( 4, 2)  @(A+2)+@(A+1)+@(A-1)
6( 5, 4)  @(A+3)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+F+4)+@(A+F+2)+@(A+F+1)+@(A+F)
8( 7, 5)  @(A+F+4)+@(A+F+2)+@(A+F+1)+@(A+F)+@(A+2)+@(A+1)+@(A-1)
9( 8, D)  @(A+F+5)+@(A+F+3)+@(A+F+2)+@(A+F+1)+@(A+3)+@(A+2)+@(A)
10( 9, 8)  @(A+F+6)+@(A+F+2)+@(A+F)+@(A+4)+@(A+1)+@(A)+@(A-1)
130 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-2)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+2)+@(A+1)+@(C+2)
5( 4, 3)  @(A+2)+@(A+1)+@(A)+@(A-1)+@(C+2)+@(C)
6( 5, 4)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+3)+@(C)
7( 6, 5)  @(A+4)+@(A+2)+@(A)+@(C+3)+@(C+2)+@(C+1)
8( 7, 6)  @(A+5)+@(A+1)+@(A-1)+@(C+4)+@(C+2)+@(C+1)+@(C)
131 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, 2)  @(A+1)+@(A-1)+@(B+1)
5( 4, D)  @(A+3)+@(A+1)+@(B+3)
6( 5, 3)  @(A+3)+@(A+1)+@(A)+@(A-1)+@(B+3)+@(B)
7( 6, D)  @(A+4)+@(A+2)+@(A+1)+@(A)+@(B+4)+@(B+1)
8( 7, 6)  @(A+5)+@(A+1)+@(A-1)+@(B+4)+@(B+3)+@(B+1)+@(B)
132 7* @(p)+@(p-4)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)

3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 1)  @(A+1)+@(A-1)+@(C)
5( 4, D)  @(A+3)+@(A+1)+@(C+2)
6( 5, 3)  @(A+3)+@(A+1)+@(A)+@(A-1)+@(C+2)+@(C)
7( 6, D)  @(A+4)+@(A+2)+@(A+1)+@(A)+@(C+3)+@(C+1)
8( 7, 6)  @(A+5)+@(A+1)+@(A-1)+@(C+3)+@(C+2)+@(C+1)+@(C)
133 7* @(p)+@(p-4)+@(p-5)+@(p-6)+@(p-8)+@(p-9)+@(p-10)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A+1)+@(A-1)
4( 3, D)  @(A+2)+@(A)
5( 4, 2)  @(A+2)+@(A+1)+@(A-1)
6( 5, 4)  @(A+3)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+7)+@(A+5)+@(A+4)+@(A+3)
8( 7, 5)  @(A+7)+@(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A-1)
9( 8, D)  @(A+8)+@(A+6)+@(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A)
10( 9, 8)  @(A+9)+@(A+5)+@(A+4)+@(A+3)+@(A+1)+@(A)+@(A-1)
134 7* @(p)+@(p-4)+@(p-5)+@(q)+@(q-2)+@(q-3)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A+1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D)+@(A+1)+@(A-2)
7( 6, D)  @(A+D+4)+@(A+D+3)+@(A+D+2)+@(A+3)+@(A)
8( 7, 6)  @(A+D+5)+@(A+D+1)+@(A+D)+@(A+3)+@(A+1)+@(A)+@(A-2)
135 7* @(p)+@(p-4)+@(p-5)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, 2)  @(A+1)+@(A-1)+@(B+1)
5( 4, 2)  @(A+1)+@(A)+@(A-1)+@(B+1)+@(B)
6( 5, D)  @(A+3)+@(A+2)+@(A+1)+@(B+3)+@(B+2)
7( 6, 5)  @(A+4)+@(A)+@(A-1)+@(B+3)+@(B+2)+@(B+1)+@(B)
136 7* @(p)+@(p-3)+@(p-4)+@(p-6)+@(p-7)+@(p-8)+@(p-10)
0(     )  1
1( 0, D)  @(A)

2( 1, 1)  @(A)+@(A-4)
3( 2, 1)  @(A+1)+@(A-4)
4( 3, 2)  @(A+1)+@(A)+@(A-3)
5( 4, 3)  @(A+2)+@(A)+@(A-3)+@(A-4)
6( 5, D)  @(A+4)+@(A+2)+@(A-1)+@(A-2)
7( 6, 5)  @(A+4)+@(A+3)+@(A)+@(A-1)+@(A-2)+@(A-3)+@(A-4)
8( 7, D)  @(A+5)+@(A+4)+@(A+1)+@(A)+@(A-1)+@(A-2)+@(A-3)
9( 8, 7)  @(A+6)+@(A+3)+@(A+2)+@(A)+@(A-1)+@(A-2)+@(A-4)
137 7* @(p)+@(p-3)+@(p-4)+@(p-5)+@(q)+@(q-2)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-2)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D-1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D-1)+@(A)+@(A-1)+@(A-2)
7( 6, D)  @(A+D+3)+@(A+D+2)+@(A+D)+@(A+1)+@(A)+@(A-1)
8( 7, 6)  @(A+D+4)+@(A+D+1)+@(A+D)+@(A+D-1)+@(A+2)+@(A)+@(A-2)
138 7* @(p)+@(p-3)+@(q)+@(q-2)+@(q-4)+@(-p+2q-3)+@(-p+2q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(2A-C-2)+@(2A-C-3)+@(A-2)
5( 4, 3)  @(2A-C-2)+@(2A-C-3)+@(A)+@(A-1)+@(A-2)+@(C)
6( 5, D)  @(2A-C-1)+@(2A-C-2)+@(A+1)+@(A)+@(A-1)+@(C+1)
7( 6, 5)  @(2A-C)+@(2A-C-3)+@(A+2)+@(A)+@(A-2)+@(C+1)+@(C)
139 7* @(p)+@(p-3)+@(q)+@(q-2)+@(q-4)+@(-p+2q-2)+@(-p+2q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(2A-C+1)+@(2A-C)+@(A+1)
5( 4, 3)  @(2A-C+1)+@(2A-C)+@(A+1)+@(A)+@(A-1)+@(C)
6( 5, D)  @(2A-C+2)+@(2A-C+1)+@(A+2)+@(A+1)+@(A)+@(C+1)
7( 6, 5)  @(2A-C+3)+@(2A-C)+@(A+3)+@(A+1)+@(A-1)+@(C+1)+@(C)
140 7* @(p)+@(p-3)+@(q)+@(q-2)+@(q-4)+@(-p+2q-1)+@(-p+2q-2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)

3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(2A-C+2)+@(2A-C+1)+@(A+1)
6( 5, 3)  @(2A-C+2)+@(2A-C+1)+@(A+1)+@(A)+@(A-1)+@(C)
7( 6, D)  @(2A-C+3)+@(2A-C+2)+@(A+2)+@(A+1)+@(A)+@(C+1)
8( 7, 6)  @(2A-C+4)+@(2A-C+1)+@(A+3)+@(A+1)+@(A-1)+@(C+1)+@(C)
141 7* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+D+1)+@(A+D)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(A+D)+@(C+D+1)+@(A)+@(A-1)+@(C)
6( 5, 4)  @(A+D+2)+@(A+D-1)+@(C+D+1)+@(C+D)+@(A)+@(A-1)+@(C)
142 7* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(C+D+1)+@(A)+@(A-1)+@(C)
7( 6, 5)  @(A+D+3)+@(A+D)+@(C+D+1)+@(C+D)+@(A)+@(A-1)+@(C)
143 7* @(p)+@(p-2)+@(p-6)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+3)+@(A+2)+@(C+3)
5( 4, 3)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+3)+@(C)
6( 5, D)  @(A+4)+@(A+3)+@(A+1)+@(A)+@(C+4)+@(C+1)
7( 6, 5)  @(A+5)+@(A+3)+@(A-1)+@(C+4)+@(C+3)+@(C+1)+@(C)
144 7* @(p)+@(p-2)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+3)+@(A+2)+@(C+2)
6( 5, 3)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+2)+@(C)

7( 6, D)  @(A+4)+@(A+3)+@(A+1)+@(A)+@(C+3)+@(C+1)
8( 7, 6)  @(A+5)+@(A+3)+@(A-1)+@(C+3)+@(C+2)+@(C+1)+@(C)
145 7* @(p)+@(p-2)+@(p-4)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A+1)+@(A-2)
4( 3, 2)  @(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(A+D)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A+D)+@(A+1)+@(A-2)
7( 6, D)  @(A+D+3)+@(A+D+2)+@(A+D+1)+@(A+2)+@(A-1)
8( 7, 6)  @(A+D+4)+@(A+D+2)+@(A+D)+@(A+2)+@(A+1)+@(A-1)+@(A-2)
146 7* @(p)+@(p-2)+@(p-4)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-1)+@(A-2)
4( 3, D)  @(A+D+1)+@(A+D)+@(A+D-1)
5( 4, 2)  @(A+D+1)+@(A+D)+@(A+D-1)+@(A)+@(A-2)
6( 5, D)  @(A+D+2)+@(A+D+1)+@(A+D)+@(A+1)+@(A-1)
7( 6, 5)  @(A+D+3)+@(A+D+1)+@(A+D-1)+@(A+1)+@(A)+@(A-1)+@(A-2)
147 7* @(p)+@(p-2)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1) ,-p+q+r>=0
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, D)  @(A+D+3)+@(A+D+1)+@(B+D+2)+@(B+D+1)
7( 6, 4)  @(A+D+3)+@(A+D+1)+@(B+D+2)+@(B+D+1)+@(A+1)+@(A)+@(B+1)
148 7* @(p)+@(q)+@(q-2)+@(r)+@(r-2)+@(-p+q+r)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, 4)  @(A+3)+@(B+2)+@(B)
7( 6, D)  @(A+D+4)+@(B+D+3)+@(B+D+1)
8( 7, 5)  @(A+D+4)+@(B+D+3)+@(B+D+1)+@(A+2)+@(A)+@(B+1)+@(B)

149 7* @(p)+@(q)+@(q-1)+@(-p+2q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(2A-B+1)+@(A)
5( 4, 2)  @(2A-B+1)+@(A+1)+@(B)
6( 5, 4)  @(2A-B+2)+@(A+1)+@(A)+@(B)
7( 6, D)  @(2A-B+F+3)+@(A+F+2)+@(A+F+1)+@(B+F+1)
8( 7, 5)  @(2A-B+F+3)+@(A+F+2)+@(A+F+1)+@(B+F+1)+@(2A-B+1)+@(A+1)+@(B)
150 7* @(p)+@(q)+@(q-1)+@(-p+2q-1)+@(r)+@(-p+q+r+1)+@(-2p+2q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(2A-B)+@(A)
4( 3, 2)  @(2A-B)+@(A+1)+@(B)
5( 4, 3)  @(2A-B+1)+@(A+1)+@(A)+@(B)
6( 5, D)  @(2A-B+E+2)+@(A+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 4)  @(2A-B+E+2)+@(A+E+2)+@(A+E+1)+@(B+E+1)+@(2A-B)+@(A+1)+@(B)
151 7* @(p)+@(q)+@(q-1)+@(r)+@(-p+2q)+@(-p+q+r+1)+@(-2p+2q+r+1) ,p-q>=2
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+3)+@(A)+@(B+D+2)+@(B)
7( 6, D)  @(A+2D+4)+@(A+D+1)+@(B+2D+3)+@(B+D+1)
8( 7, 5)  @(A+2D+4)+@(A+D+2)+@(A+D+1)+@(B+2D+3)+@(A)+@(B+D+2)+@(B)
152 7* @(p)+@(q)+@(q-1)+@(r)+@(-p+2q-1)+@(-p+q+r+1)+@(-2p+2q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(2A-B+D+2)+@(A+D+1)+@(2A-B)+@(A)
7( 6, 5)  @(2A-B+D+2)+@(A+D+2)+@(A+D+1)+@(2A-B)+@(B+D+1)+@(A+1)+@(B)
153 7* @(p)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+q+r)

0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(A+1)+@(B+1)
4( 3, 2)  @(A+1)+@(A)+@(B+1)+@(B)
5( 4, 1)  @(A+2)+@(B+1)+@(B)
6( 5, D)  @(A+E+3)+@(B+E+2)+@(B+E+1)
7( 6, 4)  @(A+E+3)+@(B+E+2)+@(B+E+1)+@(A+1)+@(A)+@(B+1)+@(B)
154 7* @(p)+@(q)+@(-p+2q-2)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(2A-B-1)+@(A-1)
4( 3, 2)  @(2A-B-1)+@(A)+@(A-1)+@(B)
5( 4, 3)  @(2A-B)+@(A+1)+@(B)
6( 5, D)  @(2A-B+E+1)+@(A+E+2)+@(B+E+1)
7( 6, 4)  @(2A-B+E+1)+@(A+E+2)+@(B+E+1)+@(2A-B-1)+@(A)+@(A-1)+@(B)
155 7* @(p)+@(q)+@(-p+2q-1)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(2A-B)+@(A-1)
5( 4, 2)  @(2A-B)+@(A)+@(A-1)+@(B)
6( 5, 4)  @(2A-B+1)+@(A+1)+@(B)
7( 6, D)  @(2A-B+F+2)+@(A+F+2)+@(B+F+1)
8( 7, 5)  @(2A-B+F+2)+@(A+F+2)+@(B+F+1)+@(2A-B)+@(A)+@(A-1)+@(B)
156 7* @(p)+@(q)+@(r)+@(-p+2q-2)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(2A-B+D+3)+@(A+D+2)+@(2A-B+1)+@(A+1)
7( 6, 5)  @(2A-B+D+3)+@(A+D+3)+@(2A-B+1)+@(B+D+1)+@(A+1)+@(A)+@(B)
157 7* @(p)+@(q)+@(r)+@(-p+2q-1)+@(-p+q+r)+@(-p+q+r-1)+@(-2p+2q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)

3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+3)+@(A)+@(B+D+2)+@(B)
7( 6, D)  @(A+2D+5)+@(A+D+2)+@(B+2D+4)+@(B+D+2)
8( 7, 5)  @(A+2D+5)+@(A+D+3)+@(B+2D+4)+@(A)+@(B+D+2)+@(B+D+1)+@(B)
158 7* @(p)+@(q)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+2r)+@(-2p+q+2r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(A+2D+4)+@(B+2D+3)+@(A+D+1)+@(B+D+1)
8( 7, 5)  @(A+2D+4)+@(B+2D+3)+@(A+D+2)+@(A+D+1)+@(B+D+2)+@(A)+@(B)
159 7* @(p)+@(q)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+2r-1)+@(-2p+q+2r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+2D+3)+@(B+2D+2)+@(A+D+1)+@(B+D+1)
7( 6, 5)  @(A+2D+3)+@(B+2D+2)+@(A+D+2)+@(A+D+1)+@(B+D+2)+@(A)+@(B)
160 7* @(p)+@(q)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-p+2r-2)+@(-2p+q+2r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+2D+4)+@(B+2D+3)+@(A+D+2)+@(B+D+2)
7( 6, 5)  @(A+2D+4)+@(B+2D+3)+@(A+D+3)+@(B+D+2)+@(B+D+1)+@(A)+@(B)
161 7* @(p)+@(q)+@(r)+@(-p+q+r)+@(-p+q+r-1)+@(-p+2r-1)+@(-2p+q+2r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)

5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(A+2D+5)+@(B+2D+4)+@(A+D+2)+@(B+D+2)
8( 7, 5)  @(A+2D+5)+@(B+2D+4)+@(A+D+3)+@(B+D+2)+@(B+D+1)+@(A)+@(B)
162 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r)+@(-2p+q+2r)+@(-3p+2q+2r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(A+C+1)+@(B+C+1)
4( 3, 2)  @(A+C+1)+@(B+C+1)+@(A)+@(B)
5( 4, D)  @(2A-B+2C+2)+@(A+2C+2)+@(2A-B+C+1)+@(A+C+1)
6( 5, 4)  @(2A-B+2C+2)+@(A+2C+2)+@(2A-B+C+1)+@(A+C+2)+@(B+C+1)+@(A)+@(B)
163 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r)+@(-2p+q+2r+1)+@(-3p+2q+2r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(B+2D+3)+@(-A+2B+2D+2)+@(B+D+1)+@(-A+2B+D+1)
7( 6, 5)  @(B+2D+3)+@(A+D+2)+@(-A+2B+2D+2)+@(B+D+2)+@(A)+@(-A+2B+D+1)+@(B)
164 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r+1)+@(-2p+q+2r)+@(-3p+2q+2r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(B+2D+3)+@(-A+2B+2D+2)+@(B+D+1)+@(-A+2B+D+1)
7( 6, 5)  @(B+2D+3)+@(-A+2B+2D+2)+@(A+D+2)+@(B+D+2)+@(-A+2B+D+1)+@(A)+@(B)
165 7* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(-2p+2q+r+1)+@(-2p+q+2r+1)+@(-3p+2q+2r+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(B+2D+4)+@(-A+2B+2D+3)+@(B+D+1)+@(-A+2B+D+1)
8( 7, 5)  @(B+2D+4)+@(-A+2B+2D+3)+@(A+D+2)+@(B+D+2)+@(-A+2B+D+1)+@(A)+@(B)

166 7* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+1)+@(-2p+q+2r+1)+@(-3p+2q+2r+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(2A-B+2D+4)+@(A+2D+3)+@(2A-B+D+2)+@(A+D+2)
7( 6, 5)  @(2A-B+2D+4)+@(A+2D+3)+@(2A-B+D+2)+@(A+D+3)+@(B+D+1)+@(A)+@(B)
167 7* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+1)+@(-2p+q+2r+2)+@(-3p+2q+2r+3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(2A-B+2D+5)+@(A+2D+4)+@(2A-B+D+2)+@(A+D+2)
8( 7, 5)  @(2A-B+2D+5)+@(A+2D+4)+@(2A-B+D+2)+@(A+D+3)+@(B+D+1)+@(A)+@(B)
168 7* @(p)+@(q)+@(r)+@(-p+q+r+2)+@(-2p+2q+r+2)+@(-2p+q+2r+1)+@(-3p+2q+2r+3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+3)+@(A)+@(B+D+2)+@(B)
7( 6, D)  @(2A-B+2D+5)+@(2A-B+D+2)+@(A+2D+4)+@(A+D+2)
8( 7, 5)  @(2A-B+2D+5)+@(2A-B+D+2)+@(A+2D+4)+@(A+D+3)+@(A)+@(B+D+1)+@(B)
169 8* @(p)+@(p-9)+@(p-10)+@(p-11)+@(p-12)+@(p-13)+@(p-14)+@(p-15)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)
4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+6)+@(A+5)+@(A+4)+@(A+3)
6( 5, 4)  @(A+6)+@(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+13)+@(A+12)+@(A+11)+@(A+10)+@(A+9)+@(A+8)+@(A+7)+@(A+6)
8( 7, 6)  @(A+14)+@(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)

170 8* @(p)+@(p-7)+@(p-9)+@(p-10)+@(p-11)+@(p-12)+@(p-13)+@(p-14)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)
4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+6)+@(A+5)+@(A+4)+@(A+3)
6( 5, 4)  @(A+6)+@(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+12)+@(A+11)+@(A+10)+@(A+9)+@(A+8)+@(A+7)+@(A+6)+@(A+5)
8( 7, 6)  @(A+13)+@(A+6)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)
171 8* @(p)+@(p-6)+@(p-7)+@(p-9)+@(p-10)+@(p-11)+@(p-12)+@(p-13)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)
4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+6)+@(A+5)+@(A+4)+@(A+3)
6( 5, 4)  @(A+6)+@(A+5)+@(A+4)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+11)+@(A+10)+@(A+9)+@(A+8)+@(A+7)+@(A+6)+@(A+5)+@(A+4)
8( 7, 6)  @(A+12)+@(A+6)+@(A+5)+@(A+3)+@(A+2)+@(A+1)+@(A)+@(A-1)
172 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-5)+@(q-6)+@(q-7)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)
4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+D+3)+@(A+D+2)+@(A+D+1)+@(A+D)
6( 5, 4)  @(A+D+3)+@(A+D+2)+@(A+D+1)+@(A+D)+@(A+2)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+D+6)+@(A+D+5)+@(A+D+4)+@(A+D+3)+@(A+5)+@(A+4)+@(A+3)+@(A+2)
8( 7, 6)  @(A+D+7)+@(A+D+2)+@(A+D+1)+@(A+D)+@(A+6)+@(A+1)+@(A)+@(A-1)
173 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-3)+@(q-5)+@(q-6)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A+1)+@(A-2)
4( 3, D)  @(A+D+2)+@(A+D-1)
5( 4, 2)  @(A+D+2)+@(A+D-1)+@(A)+@(A-2)
6( 5, D)  @(A+D+4)+@(A+D+1)+@(A+2)+@(A)
7( 6, 5)  @(A+D+4)+@(A+D+2)+@(A+D+1)+@(A+D-1)+@(A+2)+@(A+1)+@(A-2)
8( 7, D)  @(A+D+5)+@(A+D+3)+@(A+D+2)+@(A+D)+@(A+3)+@(A+2)+@(A-1)
9( 8, 7)  @(A+D+6)+@(A+D+1)+@(A+D)+@(A+D-1)+@(A+4)+@(A+1)+@(A-1)+@(A-2)

174 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-2)+@(q-3)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+2)+@(A+1)+@(C+2)
5( 4, 3)  @(A+2)+@(A+1)+@(A)+@(A-1)+@(C+2)+@(C)
6( 5, D)  @(A+5)+@(A+4)+@(A+3)+@(A+2)+@(C+5)+@(C+3)
7( 6, 5)  @(A+6)+@(A+1)+@(A)+@(A-1)+@(C+5)+@(C+3)+@(C+2)+@(C)
175 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)+@(q-3)+@(q-4)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-2)+@(C)
4( 3, D)  @(A+3)+@(A+1)+@(C+3)
5( 4, 3)  @(A+3)+@(A+1)+@(A)+@(A-2)+@(C+3)+@(C)
6( 5, D)  @(A+4)+@(A+2)+@(A+1)+@(A-1)+@(C+4)+@(C+1)
7( 6, 5)  @(A+5)+@(A)+@(A-1)+@(A-2)+@(C+4)+@(C+3)+@(C+1)+@(C)
176 8* @(p)+@(p-5)+@(p-6)+@(p-7)+@(q)+@(q-1)+@(q-2)+@(q-3)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-3)
3( 2, 1)  @(A)+@(A-3)+@(C)
4( 3, D)  @(A+1)+@(A-2)+@(C+1)
5( 4, 3)  @(A+1)+@(A)+@(A-2)+@(A-3)+@(C+1)+@(C)
6( 5, D)  @(A+3)+@(A+2)+@(A)+@(A-1)+@(C+3)+@(C+2)
7( 6, 5)  @(A+4)+@(A-1)+@(A-2)+@(A-3)+@(C+3)+@(C+2)+@(C+1)+@(C)
177 8* @(p)+@(p-3)+@(p-5)+@(p-6)+@(q)+@(q-2)+@(q-3)+@(q-5)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, 3)  @(A+2)+@(A)+@(B+1)+@(B)
6( 5, D)  @(A+4)+@(A+2)+@(B+3)+@(B+2)
7( 6, 5)  @(A+4)+@(A+3)+@(A)+@(B+3)+@(B+2)+@(B+1)+@(B)
8( 7, D)  @(A+5)+@(A+4)+@(A+1)+@(B+4)+@(B+3)+@(B+2)+@(B+1)
9( 8, 7)  @(A+6)+@(A+3)+@(A+1)+@(A)+@(B+5)+@(B+3)+@(B+2)+@(B)
178 8* @(p)+@(p-3)+@(p-5)+@(p-6)+@(q)+@(q-1)+@(q-2)+@(q-3)

0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-2)
3( 2, 1)  @(A)+@(A-2)+@(C)
4( 3, D)  @(A+2)+@(A)+@(C+2)
5( 4, 3)  @(A+2)+@(A+1)+@(A-2)+@(C+2)+@(C)
6( 5, D)  @(A+3)+@(A+2)+@(A-1)+@(C+3)+@(C+1)
7( 6, 5)  @(A+4)+@(A+1)+@(A-1)+@(A-2)+@(C+3)+@(C+2)+@(C+1)+@(C)
179 8* @(p)+@(p-3)+@(q)+@(q-3)+@(r)+@(r-1)+@(-p+q+r)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+D+1)+@(A+D)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(A+D)+@(A)+@(A-1)+@(C+D+1)+@(C)
6( 5, D)  @(A+D+2)+@(A+D+1)+@(A+1)+@(A)+@(C+D+2)+@(C+1)
7( 6, 5)  @(A+D+3)+@(A+D)+@(A+2)+@(A-1)+@(C+D+2)+@(C+D+1)+@(C+1)+@(C)
180 8* @(p)+@(p-3)+@(q)+@(q-3)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(A)+@(A-1)+@(C+D+1)+@(C)
7( 6, D)  @(A+D+3)+@(A+D+2)+@(A+1)+@(A)+@(C+D+2)+@(C+1)
8( 7, 6)  @(A+D+4)+@(A+D+1)+@(A+2)+@(A-1)+@(C+D+2)+@(C+D+1)+@(C+1)+@(C)
181 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-3)+@(-p+q+r)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, D)  @(A+D+1)+@(A+D)+@(C+D+1)
5( 4, 3)  @(A+D+1)+@(A+D)+@(C+D+1)+@(A)+@(A-1)+@(C)
6( 5, D)  @(A+D+2)+@(A+D+1)+@(C+D+2)+@(A+1)+@(A)+@(C+1)
7( 6, 5)  @(A+D+3)+@(A+D)+@(C+D+2)+@(C+D+1)+@(A+2)+@(A-1)+@(C+1)+@(C)
182 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-3)+@(-p+q+r+1)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)

3( 2, 1)  @(A)+@(A-1)+@(C)
4( 3, 2)  @(A+1)+@(A)+@(C)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(C+D+1)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(C+D+1)+@(A)+@(A-1)+@(C)
7( 6, D)  @(A+D+3)+@(A+D+2)+@(C+D+2)+@(A+1)+@(A)+@(C+1)
8( 7, 6)  @(A+D+4)+@(A+D+1)+@(C+D+2)+@(C+D+1)+@(A+2)+@(A-1)+@(C+1)+@(C)
183 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r)+@(-p+q+r-1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 2)  @(A+1)+@(A)+@(B+1)
5( 4, D)  @(A+D+2)+@(A+D+1)+@(B+D+2)
6( 5, 3)  @(A+D+2)+@(A+D+1)+@(B+D+2)+@(A+1)+@(B)
7( 6, D)  @(A+D+3)+@(A+D+2)+@(B+D+3)+@(A+2)+@(B+1)
8( 7, 6)  @(A+D+4)+@(A+D+1)+@(B+D+3)+@(B+D+2)+@(A+2)+@(A+1)+@(B+1)+@(B)
184 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+1)+@(-p+q+r)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A)+@(A-1)+@(B)
4( 3, D)  @(A+D+1)+@(A+D)+@(B+D+1)
5( 4, 2)  @(A+D+1)+@(A+D)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+2)+@(A+D+1)+@(B+D+2)+@(A+1)+@(B+1)
7( 6, 5)  @(A+D+3)+@(A+D)+@(B+D+2)+@(B+D+1)+@(A+1)+@(A)+@(B+1)+@(B)
185 8* @(p)+@(p-3)+@(q)+@(q-1)+@(r)+@(r-1)+@(-p+q+r+2)+@(-p+q+r+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, 1)  @(A+1)+@(A)+@(B)
5( 4, D)  @(A+E+2)+@(A+E+1)+@(B+E+1)
6( 5, 2)  @(A+E+2)+@(A+E+1)+@(B+E+1)+@(A)+@(B)
7( 6, D)  @(A+E+3)+@(A+E+2)+@(B+E+2)+@(A+1)+@(B+1)
8( 7, 6)  @(A+E+4)+@(A+E+1)+@(B+E+2)+@(B+E+1)+@(A+1)+@(A)+@(B+1)+@(B)
186 8* @(p)+@(q)+@(p-5)+@(p-6)+@(p-7)+@(q-5)+@(q-6)+@(q-7)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(A-1)
3( 2, D)  @(A+2)+@(A+1)

4( 3, 2)  @(A+2)+@(A+1)+@(A)+@(A-1)
5( 4, D)  @(A+5)+@(A+4)+@(A+3)+@(A+2)
6( 5, 4)  @(A+6)+@(A+1)+@(A)+@(A-1)
7( 6, D)  @(A+E+7)+@(A+E+2)+@(A+E+1)+@(A+E)
8( 7, 6)  @(A+E+7)+@(A+6)+@(A+E+2)+@(A+E+1)+@(A+E)+@(A+1)+@(A)+@(A-1)
187 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(A+C+1)+@(B+C+1)
4( 3, 2)  @(A+C+1)+@(B+C+1)+@(A)+@(B)
5( 4, D)  @(A+C+D+2)+@(B+C+D+2)+@(A+D+1)+@(B+D+1)
6( 5, 4)  @(A+C+D+2)+@(B+C+D+2)+@(A+D+1)+@(B+D+1)+@(A+C+1)+@(B+C+1)+@(A)+@(B)
188 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 5)  @(A+D+E+3)+@(A+D+2)+@(B+D+E+2)+@(B+D+1)+@(A+E+1)+@(A)+@(B+E+1)+@(B)
189 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 5)  @(A+D+E+3)+@(B+D+E+2)+@(A+D+2)+@(B+D+1)+@(A+E+1)+@(B+E+1)+@(A)+@(B)
190 8* @(p)+@(q)+@(r)+@(-p+q+r)+@(s)+@(-p+q+s+1)+@(-p+r+s+1)+@(-2p+q+r+s+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(A+D+F+4)+@(B+D+F+3)+@(A+F+1)+@(B+F+1)

8( 7, 5)  @(A+D+F+4)+@(B+D+F+3)+@(A+D+2)+@(B+D+1)+@(A+F+1)+@(B+F+1)+@(A)+@(B)
191 8* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 5)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)+@(A+D+2)+@(B+D+1)+@(A)+@(B)
192 8* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(A+D+F+4)+@(B+D+F+3)+@(A+F+1)+@(B+F+1)
8( 7, 5)  @(A+D+F+4)+@(B+D+F+3)+@(A+F+1)+@(B+F+1)+@(A+D+2)+@(B+D+1)+@(A)+@(B)
193 8* @(p)+@(q)+@(r)+@(-p+q+r+1)+@(s)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+3)+@(A)+@(B+D+2)+@(B)
7( 6, D)  @(A+D+F+4)+@(A+F+1)+@(B+D+F+3)+@(B+F+1)
8( 7, 5)  @(A+D+F+4)+@(A+F+1)+@(B+D+F+3)+@(B+F+1)+@(A+D+2)+@(A)+@(B+D+1)+@(B)
194 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, D)  @(A+C+1)+@(B+C+1)
4( 3, 2)  @(A+C+1)+@(B+C+1)+@(A)+@(B)
5( 4, D)  @(A+C+D+2)+@(B+C+D+2)+@(A+D+1)+@(B+D+1)
6( 5, 4)  @(A+C+D+2)+@(B+C+D+2)+@(A+D+1)+@(A+C+1)+@(B+D+1)+@(B+C+1)+@(A)+@(B)
195 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+1)

0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 5)  @(A+D+E+3)+@(A+D+2)+@(B+D+E+2)+@(A+E+1)+@(B+D+1)+@(A)+@(B+E+1)+@(B)
196 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 5)  @(A+D+E+3)+@(B+D+E+2)+@(A+D+2)+@(A+E+1)+@(B+D+1)+@(B+E+1)+@(A)+@(B)
197 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r)+@(-p+q+s+1)+@(-p+r+s+1)+@(-2p+q+r+s+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(A+D+F+4)+@(B+D+F+3)+@(A+F+1)+@(B+F+1)
8( 7, 5)  @(A+D+F+4)+@(B+D+F+3)+@(A+D+2)+@(A+F+1)+@(B+D+1)+@(B+F+1)+@(A)+@(B)
198 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s)+@(-p+r+s)+@(-2p+q+r+s+1)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, D)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(B+E+1)
7( 6, 5)  @(A+D+E+3)+@(B+D+E+2)+@(A+E+1)+@(A+D+2)+@(B+E+1)+@(B+D+1)+@(A)+@(B)
199 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s)+@(-p+r+s+1)+@(-2p+q+r+s+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)

3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(B+D+1)+@(A)+@(B)
6( 5, 4)  @(A+D+3)+@(B+D+2)+@(A)+@(B)
7( 6, D)  @(A+D+F+4)+@(B+D+F+3)+@(A+F+1)+@(B+F+1)
8( 7, 5)  @(A+D+F+4)+@(B+D+F+3)+@(A+F+1)+@(A+D+2)+@(B+F+1)+@(B+D+1)+@(A)+@(B)
200 8* @(p)+@(q)+@(r)+@(s)+@(-p+q+r+1)+@(-p+q+s+1)+@(-p+r+s)+@(-2p+q+r+s+2)
0(     )  1
1( 0, D)  @(A)
2( 1, 1)  @(A)+@(B)
3( 2, 1)  @(A+1)+@(B)
4( 3, D)  @(A+D+2)+@(B+D+1)
5( 4, 2)  @(A+D+2)+@(A)+@(B+D+1)+@(B)
6( 5, 4)  @(A+D+3)+@(A)+@(B+D+2)+@(B)
7( 6, D)  @(A+D+F+4)+@(A+F+1)+@(B+D+F+3)+@(B+F+1)
8( 7, 5)  @(A+D+F+4)+@(A+F+1)+@(B+D+F+3)+@(A+D+2)+@(B+F+1)+@(A)+@(B+D+1)+@(B)