% Copyright(c) 1998-2003 David B. Jaffe
% Permission to use, copy, modify, and distribute any document (including this
% one) which is part of the Split distribution is hereby granted without fee,
% for any noncommercial purpose, provided that this paragraph is copied,
% conspicuously referenced, that an explanation is included which 
% explains what portion of the Split distribution has been utilized, and that 
% no other person's copyright is thereby infringed.  
%
% The following materials in the distribution are owned by other people:
%    Brendan McKay (the graph isomorphism package nauty; in NOT_MINE)
%    Keith Briggs (double-double precision arithmetic; in NOT_MINE)
%    Victor Shoup (ntl: a library for doing number theory; in NTL)
%    Free Software Foundation (prevector<T>::sort; in CODE)
%    U. C. Berkeley (random.c; in NOT_MINE)
%    Hewlett-Packard (pair and make_pair; in CODE).

define(VERSION, `0.6alpha')

% Hints for selective recompilation:
% 
%     If you edit a class definition, you should probably recompile the
%     whole shebang.  For other changes, search backwards for the string
%     "set_com".  You will find the name of the file which needs to be
%     recompiled.

% Hints for debugging:
%
%     1. Go through and activate all "#define DEBUG" lines by deleting
%        the "// " which preceeds them.
%     2. Make SLList.h safer.
%        (a) Make a local copy.
%        (b) Modify "T& operator () (Pix p)" and the const version by adding
%            a line `if (!owns(p)) error("illegal Pix");'.
%        (c) Change #include <SLList.h> so it fetches local copy instead.

define(TEX_IN,`tex/code.tex')
define(DATA_IN,`inputs/code.data')
define(newresultcounter,9)
include(src/MACROS)
ifelse(UNAME,OPENSTEP,![DEFINE(UNAME,Openstep)]!)

|-> tex/t.ista

preamble
"\\begin{theindexa}\n"
postamble
"\n\n\\end{theindexa}\n"

|-> tex/t.istb

preamble
"\\begin{theindexb}\n"
postamble
"\n\n\\end{theindexb}\n"

|-> tex/t.istz

preamble
"\\begin{theindexz}\n"
postamble
"\n\n\\end{theindexz}\n"

|-> tex/code.tex

% \second
% [.stepanov lee.]
\hfuzz 10pt

% Create quote macros to sync with 5n character indentation in verbatim
% environment.  

\def\quotea{\list{}{\def\leftmargin{62pt}\advance\linewidth -26pt}\item[]}
\let\endquotea=\endlist

\def\quoteaneg{\vspace{-0.35in}\list{}{\def\leftmargin{62pt}\advance\linewidth 
-26pt}\item[]}
\let\endquoteaneg=\endlist

\def\quoteb{\list{}{\def\leftmargin{93pt}\advance\linewidth -29pt}\item[]}
\let\endquoteb=\endlist

\def\quotebneg{\vspace{-0.35in}\list{}{\def\leftmargin{93pt}\advance\linewidth 
-29pt}\item[]}
\let\endquotebneg=\endlist

\def\quotec{\list{}{\def\leftmargin{124pt}\advance\linewidth -32pt}\item[]}
\let\endquotec=\endlist

\def\quotecneg{\vspace{-0.35in}\list{}{\def\leftmargin{124pt}\advance\linewidth
-32pt}\item[]}
\let\endquotecneg=\endlist

\def\quoted{\list{}{\def\leftmargin{155pt}\advance\linewidth -35pt}\item[]}
\let\endquoted=\endlist

\def\quotee{\list{}{\def\leftmargin{186pt}\advance\linewidth -38pt}\item[]}
\let\endquotee=\endlist

% Set up a svb macro, which is like verbatim, but doesn't put
% vertical spacing at the beginning and end.

\catcode`\@=11
 
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xsvb#1\end{svb}[#1|end[svb]]
|gdef|@sxsvb#1\end{svb*}[#1|end[svb*]]
|endgroup

\def\@svb{
\leftskip\@totalleftmargin\rightskip\z@
\parindent\z@\parfillskip\@flushglue\parskip\z@
\@tempswafalse \def\par{\if@tempswa\hbox{}\fi\@tempswatrue\@@par
\penalty\interlinepenalty}%
\obeylines \tt \catcode``=13 \@noligs \let\do\@makeother \dospecials}
 
\def\svb{\@svb \frenchspacing\@vobeyspaces \@xsvb}
\let\endsvb=\relax

\def\mindex{\@bsphack\begingroup\@sanitize\@wrindexa}
\catcode`\@=12

\pagestyle{empty}
\vspace*{0.8in}
\widepost{40}{40}{/Times-Roman findfont 40 scalefont setfont
(Binary linear codes:)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\vspace{0.1in}
\widepost{40}{40}{/Times-Roman findfont 40 scalefont setfont
(new results on nonexistence)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\vspace{0.4in}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(Draft, March 21, 2000)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\vspace{-0.05in}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(\(Version 0.6beta\))
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\vspace{0.5in}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(David B. Jaffe)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\vspace{0.3in}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(Department of Mathematics and Statistics)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(University of Nebraska)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(Lincoln, NE 68588-0323)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\widepost{28}{28}{/Times-Roman findfont 28 scalefont setfont
(e-mail: jaffe@cpthree.unl.edu)
dup stringwidth pop 2 div neg 0 moveto 50 0 rmoveto true charpath StrokeFill}
\newpage
%% \ \newpage  %% Insert to get even number of pages if needed.
\pagestyle{plain}

\def\GAPref{\protect{[.groups algorithms programming.]}}

\vspace*{-0.4in}
\begin{center}
\LARGE\bf Preface
\end{center}
\addcontentsline{toc}{special}{Preface}
\def\classbreak{\par\noindent\kern32pt%
\hbox to 6.35in{\leaders\hbox{\vbox{\hrule width1mm height 0.5pt}}\hfil}}
\newenvironment{classboxedquote}%
    {\vskip0.065in\par\noindent\kern31pt\begin{Sbox}\begin{minipage}{6in}}%
    {\end{minipage}\end{Sbox}\fbox{\TheSbox}\vskip0.065in}
\def\classtext#1{\begin{classboxedquote}#1\end{classboxedquote}}
\newenvironment{classboxedquotet}%
    {\vskip0.065in\par\noindent\kern31pt\begin{Sbox}\begin{minipage}{6in}%
    \begin{tabbing}}%
    {\end{tabbing}\end{minipage}\end{Sbox}\fbox{\TheSbox}\vskip0.065in}
\def\classtextt#1{\begin{classboxedquotet}#1\end{classboxedquotet}}
\newenvironment{classboxedquotefour}%
    {\vskip0.065in\par\noindent\begin{Sbox}\begin{minipage}{4in}}%
    {\end{minipage}\end{Sbox}\fbox{\TheSbox}}

\vspace{0.25in}

{\large This is a working draft of a report which describes a new language
for proving results about binary linear codes, and moreover exhibits a program
in this language which proves many new results.  Source code ({\tt C++})
for the language is included.

The author gratefully acknowledges partial support under NSF grants
DMS-9100983 and DMS-9623205, and as well wishes to thank the NSF-sponsored 
Geometry Center for supercomputer access, which facilitated exploratory 
calculations.  John Gregory, Spyros Magliveras, Eric Rains, and
Neil J.\ A.\ Sloane provided helpful comments and suggestions.

I thank Juriaan Simonis (and TU Delft) for supporting a stimulating visit 
during the second half of May 1996, for introducing me to the
work of [.brouwer van eupen 1997.], and for several enlightening converations
which led to the work of \S\ref{menagerie-section}.

The language employs the graph isomorphism package {\tt nauty} of Brendan
McKay, the double-double precision floating point arithmetic package 
{\tt doubledouble} of Keith Briggs [.briggs doubledouble.], and the 
number theory library of Victor Shoup [.shoup ntl.].

The routines {\tt prevector<T>::sort} are in effect copyrighted by the
Free Software Foundation.  The definitions of {\tt pair} and \verb|make_pair|
are copyrighted by Hewlett-Packard.  

A number of unpublished codes discovered by J.\ B.\ Shearer are included in
this document, as well as one code discovered by M.\ Morii.

The material on designs in \S\ref{some-unital-section}, the associated 
% Using {\it options} below had weird unintended consequences when using xdvi.
``options'' field in the {\tt type} command, and the implementation of the 
latter arose as part of joint work with Tonchev [.jaffe tonchev rank 20.].

\vspace{0.05in}
To obtain this draft or the source code itself, see the
World Wide

\vspace{0.01in}
\par\noindent
Web at ``\verb|http://www.math.unl.edu/~djaffe/#coding|''.
For a more leisurely introduction, see [.brief tour split main.].
}

\newpage

\vspace*{-0.3in}

\par\noindent{\LARGE\bf Contents}
\vspace{0.15in}
{\footnotesize\
\catcode`\@=11
\@starttoc{toc}
\catcode`\@=12}

\newpage

% Set up for indices.
\def\indexnamez{Index of C++ classes}
\def\indexnamea{Index of C++ methods}
\def\indexnameb{Index of commands}
\catcode`\@=11

\def\theindexz{\@restonecoltrue\if@twocolumn\@restonecolfalse\fi
\columnseprule \z@
\addcontentsline{toc}{special}{\indexnamez}
\columnsep 35\p@\twocolumn[{\Large\bf Index of C++ classes}\\ \\ ]%
    \@mkboth{\uppercase{\indexnamez}}{\uppercase{\indexnamez}}%
    \thispagestyle{plain}\parindent\z@
    \parskip\z@ plus.3\p@\relax\let\item\@idxitem}

\def\theindexa{\@restonecoltrue\if@twocolumn\@restonecolfalse\fi
\columnseprule \z@
\addcontentsline{toc}{special}{\indexnamea}
\columnsep 35\p@\twocolumn[{\Large\bf Index of C++ methods}\\ \\
This list should index all C++ methods and macros defined in the source code, 
except that
not all constructors, destructors, and operators are included.  We
also do not include the {\tt execute\string_}$\ldots$ commands from
\S\ref{main-program-section}, which execute particular commands.  These may
be found from the index of commands.  \\ \\ ]%
    \@mkboth{\uppercase{\indexnamea}}{\uppercase{\indexnamea}}%
    \thispagestyle{plain}\parindent\z@
    \parskip\z@ plus.3\p@\relax\let\item\@idxitem}

\def\theindexb{\@restonecoltrue\if@twocolumn\@restonecolfalse\fi
\columnseprule \z@
\addcontentsline{toc}{special}{\indexnameb}
\columnsep 35\p@\twocolumn[{\Large\bf Index of commands}\\ \\
For each command, we give first the page on which the command is defined,
and then the corresponding page in the source code.  If the body of the
command is executed as a separate subroutine, a page number is also given
for that, intermediate between the first two numbers.  \\ \\ ]%
    \@mkboth{\uppercase{\indexnameb}}{\uppercase{\indexnameb}}%
    \thispagestyle{plain}\parindent\z@
    \parskip\z@ plus.3\p@\relax\let\item\@idxitem}
\def\endtheindexa{\if@restonecol\onecolumn\else\clearpage\fi}
\def\endtheindexb{\if@restonecol\onecolumn\else\clearpage\fi}
\catcode`\@=12

\part{Introduction}

\block{Synopsis}

A basic problem in coding theory is to determine the maximum number 
$B(n,d)$ of codewords in a binary linear code in $\F_2^n$ having minimum
weight $d$.  While the original motivation for this problem came from
practical problems of data transmission, continuing interest is due also
to the fact that binary linear codes are such basic combinatorial structures.

Many proofs of bounds for specific $B(n,d)$ have as
input statements of bounds for $B(n',d')$, where $n' < n$.  Proofs thus
have a hierarchical nature, and if one wants specific results about the 
$B(n,d)$, one is naturally lead to
construct tables.  This has been done by Helgert and Stinaff 
[.helgert stinaff.], Verhoeff [.verhoeff 1987.], Brouwer and 
Verhoeff [.brouwer verhoeff 1993.], and Bierbrauer and Edel
[.bierbrauer edel parameters binary.].  But the numbers $B(n,d)$ are extremely 
difficult to compute and there remain gaps even for small $n$ and $d$.  

The problem of finding lower bounds has been addressed by a vast array of
fascinating constructions.  These are of ongoing interest but do not form the 
subject matter of this report.  Rather, we address the problem of how one may 
find {\it upper\/} bounds.

Some of the major general contributions to
this problem have been (in approximate historical order) Griesmer's bound
[.griesmer 1960.], Johnson's bound [.johnson unrestricted.],
Delsarte's linear programming method [.delsarte bounds unrestricted.],
Hill and Traynor's examples [.hill traynor.],
Brouwer's generalized parity type argument
[.brouwer linear programming bound.], and Simonis's use of coordinate
partitions [.simonis partitions.].  In addition, many people have contributed
specific results, and thus methods, more often than not.

A number of software packages have been developed for computing upper (and 
lower) bounds for $B(n,d)$.  These packages include [.code buster.],
[.guava.], LINCOR [.manev lincor 1987.], [.manev petkova golemanova.], and the 
system used by Brouwer and Verhoeff to generate
[.brouwer verhoeff 1993.].  In addition, there exists software for computing
automorphism groups of codes and for determining if two codes are isomorphic.
We defer discussion of this to \S\ref{automorphismisomorphismsection}.

In this report\footnote{This refers not only to this document, but also
to [.jaffe optimal binary 30.], which contains results for length $\leq 30$.},
we give improved upper bounds for the $B(n,d)$, in total
\ref{NewResultCount} improvements.  This is actually quite modest progress: 
whereas before the first unknown case occurred when $n = 28$, now the first 
unknown case occurs when $n = 32$.  As an example we establish that 
$B(28,9) = 2^{10}$ by showing that there is no $[28,11,9]$ binary linear code.%
\footnote{General background on coding theory may be found in
[.macwilliams sloane book.].  Another good reference is [.lint coding theory.].
In this paper we make the slightly non-standard 
convention that an $[n,k,d]$ binary linear code is a sub-vector space $C$ of 
$\F_2^n$ having dimension $k$, such that no non-zero element of $C$ has weight 
$< d$.  Also, by {\bf code}, we shall always mean {\bf binary linear code}.}

The vehicle for these improvements is a computer language which we present.
Its general purpose is to investigate binary linear codes.  We exhibit a
program (written in the language) which yields the aforementioned improvements
to the $B(n,d)$.  This program is completely self-contained, in the sense that 
all needed results about specific codes are proved within the confines of the 
program.  We do this to complement rather than supplant the 
``pencil and paper'' proofs which exist in some cases.  

This report also includes (with proof) a complete table of all known specific 
upper bounds, for codes of length $85$ or less, and extensive information
about the weight enumerators of codes which may or may not exist.

The first part of this paper is the introduction.
The second part is a description of the language and its
theoretical basis.  The third part is a program, written in
the language, which yields specific results about binary linear codes.
The forth part of the paper is C++ source code for an implementation of the
language.  These are also available electronically from the author.%
\footnote{The program should be easy to install on any Unix-based machine.  The
current implementation includes a provisional implementation of the simplex 
method, and as an alternative also includes support for a much faster 
commercial linear programming package,
CPLEX.  As of October 1995, the cost to academic users of a CPLEX 
``Linear Optimizer Single CPU License'' is \$495.
Mail to \verb|info@cplex.com| for more information.}
Both the language and the program are ongoing projects, to which 
contributions are invited.

\block{Basic data structures and definitions}\label{definitions-section}

We describe the basic data structures of the language, in a somewhat 
idealized fashion.  For practical reasons the actual data structures
differ slightly from the descriptions we give here; most of these differences 
are mentioned in \S\ref{variable-section} and \S\ref{proof-command-section}.

The top-level structure in the language is a {\bf code type}.  It is a triple 
$(n,k,\cal S)$ consisting of a positive integer $n$, an integer $k$ 
($1 \leq k \leq n$), and a finite set $\cal S$ of inequalities (called
{\bf assumed constraints}) having the form
$$a_0 y_0 \many+ a_n y_n \leq r,$$%
where $\VEC a0n,r$ are integers.  The variables $y_i$ (for computer input
written \verb|y|$i$) are called {\bf basic global variables}.
The {\bf dimension} of a code type is $k$.

The {\bf realization} of a code type
$(n,k,\cal S)$ is the set of all codes $C \IN \F_2^n$ of dimension $k$ 
such that if $y_i$ denotes the number of words of weight $i$ in $C$, then
all inequalities in $\cal S$ are satisfied.  (We refer to this general
sort of operation as {\bf evaluation} on a code.)  A code type is
{\bf unrealizable} if its realization is empty, otherwise it is
{\bf realizable}.  A {\bf global variable} is a $\Q$-linear combination of
basic global variables, whose evaluation on every $[n,k]$ code is an
integer.

Below each code type $(n,k,\cal S)$ lives a family of structures called 
{\bf configurations}.  Each such structure is a quadruple 
$(p, D, D', \cal T\kern2pt)$ consisting of a partition%
\footnote{We mean by this that $\VEC p1r \in \N$ and that 
$p_1 \many+ p_r = n$.}
$p = (\VEC p1r)$ of $n$, two subcodes $D, D'$ of $\F_2^r$, and a finite set
$\cal T$ of inequalities (again called {\bf assumed constraints}) having the 
form
$$a_0 y_0 \many+ a_n y_n + \sum_I a_I x_I \leq r,$$%
where $I = (\VEC i1r)$ is a {\bf multi-index\/} (or more precisely a
{\it multi-index for $p$}, meaning that $0 \leq i_j \leq p_j$ for 
each $j$), and $\VEC a0n, a_I, r \in \Z$.  
The variables $x_I$ (for computer input written
\verb|x_|$i_1$\verb|_|$\ldots$\verb|_|$i_r$)
are called {\bf basic local variables}; the {\bf trivial}
basic local variable is $x_{(0,\ldots,0)}$.
We say that $D$ is the {\bf small code} of the configuration, and that
$D'$ is the {\bf dual small code} of it.
The {\bf dimension} of a configuration is defined to be $\dim(D)$.

For the duration of the introduction, we fix the above notations for
code types and configurations.

Supposing for simplicity that $D' = 0$ and that $\cal T = \emptyset$,
we may visualize the configuration by exhibiting a basis for $D$.  By way 
of an example, let us reverse this process.
Suppose we wish to study codes $C \IN \F_2^{25}$ which contain
a word of weight $10$ and a word of weight $12$, intersecting along $4$ bits:
\widepost{70}{35}{
{{100 26 Box {(6) BigCenterPrint} 50 6 xyput} -150 4 xyput
{100 26 Box {(4) BigCenterPrint} 50 6 xyput} -50 4 xyput
{100 26 Box {(4) BigCenterPrint} 50 6 xyput} -50 -30 xyput
{100 26 Box {(8) BigCenterPrint} 50 6 xyput} 50 -30 xyput} 50 xput}
\par\noindent We would be led to consider the partition $(6,4,8,7)$ of $25$
and the small code $D$ with basis \setof{1100,0110}.  It is the picture which
justifies the term {\it configuration}: it conforms to the dictionary 
definition as it is a {\it relative arrangement of parts}.

We return to the general situation.\label{action-def}
Given $d \in D$, and a multi-index $I$, define a multi-index $d(I)$ by
$$d(I)_j\ =\ \cases{i_j,&if $d_j = 0$;\cr
                    p_j - i_j,&if $d_j = 1$.}$$%
Then $D$ acts on the set of multi-indices, and accordingly on basic local 
variables.  We regard two basic local variables as {\bf equivalent} if they lie
in the same orbit
\WRT\ this action.  We define two configurations to be
{\bf equivalent} if they differ only in changing $\cal T$ by replacing some
occurrences of basic local variables by equivalent ones.

Given a partition $p = (\VEC p1r)$, we shall say that a partition
$\loP = (\loP_1,\ldots,\loP_s)$ {\bf refines} $p$ if there exist
$$0 = \beta_0 < \beta_1 < \cdots < \beta_r = s$$%
such that
$$p_j\ =\ \loP_{\beta_{j-1}+1} \many+ \loP_{\beta_j}$$%
for all $j = 1,\ldots,r$.  There is an induced map 
\mp[[ \varphi || \F_2^r || \F_2^s ]] given by
$\varphi(e_j) = e_{\beta_{j-1}+1} \many+ e_{\beta_j}$.

Now given a configuration $c = (p,D,D',{\cal T})$ as before, and given a
refinement $\loP$ of $p$ as above, we define the 
{\bf refinement $\loC$ of $c$ induced by $\loP$} to be
$\loC = (\loP,\varphi(D),\varphi(D'),\ol{\cal T})$, where $\ol{\cal T}$
is yet to be defined.  First define a {\bf pullback} map
\mp[[ \Psi || \setofh{multi-indices of $\loP$} 
   || \setofh{multi-indices of $p$} ]] by
$$\Psi(\oI)_j = \oI_{\beta_{j-1}+1} \many+ \oI_{\beta_j}.$$

Now given $f \in \cal T$, define $\loF$ by replacing each basic local 
variable $x_I$ by $\sum x_{\oI}$, where $\oI$ ranges over the multi-indices
of $\loP$ with $\Psi(\oI) = I$.  Then $\ol{\cal T}$ is defined to be
\setof{\loF: f \in \cal T}.

Given the configuration $c$, and a basic local variable $x_I$ of $c$, we 
define a new configuration $c|x_I$, called the
{\bf subdivision of $c$ along $x_I$}, as follows.  First define a partition
$\loP$ by
$$q_j\ =\ \cases{(p_j),&if $i_j \notin \setof{0,p_j}$;\cr
                 (i_j, p_j - i_j),&otherwise,}$$%
and $\loP = (\VEC q1r)$ (with internal parentheses removed).
Let $s$ be the length of $p$.  Define $v$ by
$$v_j\ =\ \cases{(0),&if $i_j = 0$;\cr
                 (1),&if $i_j = p_j$;\cr
                 (1,0),&otherwise,}$$
$$v\ =\ (\VEC v1r)\ \ \hbox{(with internal parentheses removed)}.$$%

Let $\loC = (\loP,\oD,\ol{D'},\ol{\cal T})$ be the refinement of $c$ induced
by $\loP$.  Then $c|x_I = (\loP, \oD + \inn{v}, \ol{D'}, \ol{\cal T})$,
where $\oD + \inn{v}$ is the subspace of $\F_2^s$ generated by $\oD$ and $v$.

An element of $\F_2^r$ is a {\bf small word}.  Let 
\mp[[ \pi_i || \F_2^n || \F_2^{p_i} ]] be the ``\th{i} projection map''.  A 
{\bf basic word} is an element $x \in \F_2^n$ such that for each $i$, 
$\pi_i(x)$ is either $0\ldots0$ or $1\ldots1$.  Evidently there is a bijective 
correspondence between small words and basic words.  A {\bf basic code}
is a code in $\F_2^n$ consisting entirely of basic words.  For any code
in $\F_2^r$, there is an {\bf associated} basic code in $\F_2^n$.

If $w \in \F_2^n$, the \th{i}\ weight $\abs{w}_i$ of $w$ is the weight of 
$\pi_i(w)$.  The {\bf multiweight} of $w$ is the $r$-tuple 
$(\abs{w}_1,\ldots,\abs{w}_r)$; its {\bf weight} $\abs{w}$ is
$\abs{w}_1 \many+ \abs{w}_r$.

The {\bf realization} of the configuration is the set of all codes $C$ in the 
code type, which, after permuting coordinates if need be, have all of the
following properties:
\begin{itemize}
\item for each small word in $D$, the associated basic word lies in $C$;
\item for each small word in $D'$, the associated basic word lies in $C^\perp$;
\item if $y_i$ denotes the number of words of weight $i$ in $C$ and
      $x_I$ denotes the number of words in $C$ which have multiweight $I$,
      then all inequalities in $\cal T$ are satisfied.
\end{itemize}
For $c$ a configuration, we let ${\cal R}(c)$ denote its realization, and
we let $\ol{\cal R}(c)$ denote the set of isomorphism classes in
${\cal R}(c)$.
The same terminology {\bf unrealizable}, {\bf realizable} applies to 
configurations.

A {\bf local variable} is a $\Q$-linear combination of basic local variables,
whose evaluation on every code in the realization of the code type is an 
integer.  Since basic global variables are expressible as linear combinations of
basic local variables (upon evaluation), the inclusion of basic global variables
in the definition of assumed constraints (for a configuration) is formally 
superfluous.  However, it turns out to be convenient and economical to formally 
distinguish between local and global variables in constraints.

To each configuration, the language associates a list of {\bf known}
constraints.  Initially, this list consists of the assumed constraints for
the code type and the assumed constraints for the configuration.  But as
a program is executed, various commands may be used to prove that other
constraints hold for the configuration: these constraints are also considered
to be known.

For every code type, there is the {\bf base} configuration, which by
definition has the trivial partition $(n)$, $D = 0$, $D' = 0$, and 
$\cal T = \emptyset$.  Obviously the realization of the base configuration
is the same as the realization of the code type.  We also refer to a
{\bf basal} configuration, by which we mean a configuration with the properties
of a base configuration, except that $\cal T$ may be arbitrary.

Call a configuration {\bf full} if its dimension equals the dimension of
the code type.  A {\bf terminal} configuration is a full configuration having
$D' = 0$, and whose assumed constraints involve only
global variables.  Obviously a terminal configuration admits (up to isomorphism)
at most one realization, and if there is one, it is the basic code associated to
$D$.  We refer to $D$ as the code {\bf corresponding} to the given terminal 
configuration.  If a realizable terminal configuration has assumed constraints,
these constraints simply give facts which are deducible 
from the weight enumerator of $D$.

A complete classification for a code type might be construed as being an
exhibition of realizable terminal configurations $\VEC c1m$ such that
$${\cal R}(\hbox{base})\ =\ {\cal R}(c_1) \sqcup \cdots \sqcup {\cal R}(c_m)
  \ \ \hbox{(disjoint union)}.$$%
As this is a desirable goal and a feasible one so long as
$\abs{\ol{\cal R}(\hbox{base})}$ is small, the language facilitates logical 
statements holding between the sets ${\cal R}(c)$, where $c$ 
ranges over the configurations associated to the code type.  In brief, we 
refer to such statements as {\it logical statements holding between the 
configurations}.  Even in lieu of a complete classification, such statements 
permit partial classification, for instance up to weight enumerator.

A configuration is {\bf fully refined} if its partition has the form
$1,\ldots,1$.

An {\bf automorphism} of a configuration $c$ is a permutation $\sigma$ of
$1,\ldots,r$ such that $\sigma(c)$ is equivalent to $c$.  We let $\Aut(c)$ 
denote the group of all automorphisms of $c$.  In case $c$ is realizable and 
terminal, and $p_i = 1$ for all $i$, we have $\Aut(c) = \Aut(D)$.

\block{Method: finding automorphisms and isomorphisms of codes}%
\label{automorphismisomorphismsection}

The problem is to find generators for the automorphism group of a code $C$,
and to determine if two given codes are isomorphic.  There are two 
established schemes for solving such problems.

For both schemes, one must start with a subset $S$ of $C$ which is
stable under the action of $\Aut(C)$, and which is ``sufficiently large''.
Here we take this to mean that $S$ generates $C$ as a vector space.
In practice, one should expect the size of $S$ to grow exponentially as a
function of $\dim(C)$.  Thus both schemes will yield algorithms whose 
execution 
time grows exponentially, and not just for the worst cases.  It remains an open 
problem to find algorithms whose execution time (on average, at least) is 
polynomial in $n$ (the length) and $k$ (the dimension).  

The first scheme proceeds by reducing to the analogous problems for graphs.%
\footnote{This approach seems to be well-known but the author is indebted to
D.\ Stinson and V.\ Tonchev for independently pointing it out to him.}
One may form a zero-one matrix, with one row for each $x \in S$, by writing
out $x$ as an element of $\F_2^n$.  This matrix may be regarded as defining
a bipartite graph $G$, and clearly $\Aut(G) = \Aut(C)$.  If $C'$ is another
code of length $n$, and a bipartite graph $G'$ is constructed in the same way,
then $C \iso C'\ \Longleftrightarrow\ G \iso G'$.  

The complexity of the graph isomorphism problem is not well understood; more
specifically, it is not known if the problem admits a polynomial-time
algorithm, nor is it known if it is NP-complete.  There do exist algorithms
whose reported average running time is quadratic as a function of the
number of vertices.  McKay has implemented such an algorithm
([.practical graph isomorphism.], [.nauty guide onepointfive.]) and we 
employ his program {\tt nauty} here.

The second scheme is that of Leon [.leon computing automorphism groups 1982.],
[.leon computing automorphism groups 1984.].  It has the advantage of working
with all linear codes, not just binary ones.  The implementation
[.leon partition backtrack manual.], [.leon partition backtrack source.], 
[.leon partition backtrack examples.] is a very impressive piece of work,
over $25,000$ lines of code, the accessibility of which would be greatly
enhanced by additional documentation.

\block{Method: split linear programming}\label{split-intro-section}

Now we turn to a method which we call {\bf split linear programming}.  While
the author came to this independently by combining the notion of 
split weight enumerator ([.macwilliams sloane book.]\ pp.\ 149-150)
with Delsarte's linear programming method [.delsarte bounds unrestricted.],
credit for the concept is due to Simonis [.simonis partitions.], and in fact 
the idea had been used successfully prior to the author by Heijnen [.heijnen.].

Having fixed a partition $(\VEC p1r)$ of $n$, let $C \IN \F_2^n$ be a code.
For $I = (\VEC i1r)$ a multi-index, let $t^I$ denote
$t_1^{i_1} \manycdot t_r^{i_r}$, where $\VEC t1r$ are indeterminates.
An {\bf $I$-word\/} is a word of multiweight $I$; we let $x_I$ denote the
number of $I$-words in $C$.  Then the {\bf split weight enumerator} of $C$ is
$$\sum_I x_I t^I,$$%
where $I$ ranges over all multi-indices.  We will show that the
split weight enumerator of $C^\perp$ is
$${1 \over \abs{C}} \sum_{I = (\VEC i1r)} x_I
  \prod_{j=1}^r (1+t_j)^{p_j - i_j} (1-t_j)^{i_j}.$$%
This is not difficult to prove, and in fact the case where the partition
is $(m,m)$ for some $m$ may be found as an exercise in 
[.macwilliams sloane book.], on p.\ 150.

Regard this expression as a polynomial in $\VEC t1r$; its coefficients 
(say $m_I$) are $\Q$-linear combinations of the variables $x_I$.  
As these coefficients are evidently nonnegative, we arrive immediately at a 
linear programming problem, just as one would arrive at such a problem via
Delsarte's original linear programming method.

To actually use this method, one should start with a configuration, and not
just a partition.  Now if two basic local variables are equivalent, they will
have the same evaluation on any realization of the configuration.  Therefore
we may select one basic local variable from each equivalence class, and modify
the linear programming problem so that only these selected variables occur.

This greatly reduces the complexity of the problem.  
As an example, in investigating $[31,13,10]$ codes
(discussed below), we arrive at a configuration with partition $(10,10,11)$.
This would (a priori) give rise to a system having $1452$ variables and
$1452$ constraints.  But by using equivalence of basic local variables
(and other ideas, to be discussed next), we reduce this to a problem
involving $136$ variables and $245$ constraints.  This reduction is of
paramount importance.

There is a second way one can reduce the number of variables.  A basic local
variable $x_I$ (for a configuration $c$) is {\bf inadmissible} if at least one 
of the following three things happens:
\begin{romanlist}
\item For some equivalent basic local variable $x_J$ which is equivalent to
      $x_I$, the constraint $x_J = 0$ is known for the configuration.
\item $x_I$ is not equivalent to the trivial basic local variable, and if $d$
      is the subdivision of $c$ along $x_I$, then the
      weight enumerator of the basic code associated to the small code of $d$
      contradicts a known constraint of the form $y_i \leq r$.  
\item For some equivalent basic local variable $x_J$ which is equivalent to
      $x_I$, there exists some $d' \in D'$ such that $d' \cdot J$ (dot product)
      is odd.
\item It would violate the zeroness of a joint variable which is known to be
      zero.
\end{romanlist}
In any realization of the configuration, the inadmissible basic local variables
will evaluate to zero.  Therefore we may delete the inadmissible variables from
the linear programming problem.

A priori we get one constraint for each multi-index $I$.  In fact, no
information is lost if we use only some of the constraints, as follows.  First, 
if $I \cdot d \not= 0$ (in $\F_2$) for some $d \in D$, then the constraint
associated to $I$ is identically zero, and we may omit it.
Second, for $d' in D'$, we can define $d'(I)$ just as we defined 
$d(I)$ (p.\ \pageref{action-def}), and we arrive
thusly at a notion of {\bf dual equivalence} for the variables $m_I$.  It
is then sufficient to use one constraint from each equivalence class.  In
practice, one can do better by using (in place of $D'$) an enlarged version
of it (say $(D')^+)$, which includes words known by the language to be dual.  
Thus if the constraint $y_j = 0$ is known for every odd $j$, then the
word $1\ldots1$ is in $(D')^+$, and if the constraint $y_j = 0$ is known
for every $j$ not divisible by four, then all of $D$ is in $(D')^+$ as well.

Now we illustrate the application of the split linear programming method by 
means of a real example: we show that there is no $[31,13,10]$ code.  In the 
program we will prove the stronger statement that there is no $[29,11,10]$ 
code, but this is more involved.

In the course of the argument we will consider three configurations, and
correspondingly apply the method three times.  Only the last application
will be nontrivial, as the conclusion of the first two may easily be
recovered by other means.

The split linear programming method gets applied three times:
\begin{itemize}
\item There is a word of weight $20$.  This calculation corresponds to 
      considering the trivial partition $(31)$ of $31$.  One finds that
      \verb|x_20| is nonzero.  In other words, the code has a word of weight 
      $20$.  Thus far the method is a mere rephrasing of Delsarte's linear 
      programming method.  
\item Use the word of weight $20$ to subdivide the original partition, yielding 
      the partition $(20,11)$.  Show that \verb|x_10_0| $\not= 0$.  That is,
      show that there is a word of weight $10$ in the code which is contained 
      in the word of weight $20$.  This statement is also obvious.
\item Subdivide again, yielding the partition $(10,10,11)$.  A final 
      application of the method yields a contradiction.
\end{itemize}

In this example, $D'$ is always zero.  In succession, $D$ consists of the zero 
code (in $\F_2^1$), then the code with basis \setof{10} (in $\F_2^2$), and 
finally the code with basis \setof{110,100} (in $\F_2^3$).

Although there are in principle oodles of configurations, only certain
ones are known to the program as it executes.  These get created in various
ways, for instance by explicit declaration in a ``{\tt config}'' command.
(See the worked example below.)  Also, the program automatically knows 
about the base configuration.

The configurations are also the vertices of a directed 
multigraph\label{first-multigraph-occurrence}, whose
connected components correspond to logical equivalence classes: if two
configurations lie in the same connected component, then they have the same
realization.  There are two types of edges.  The first type
(which we call {\bf constructive}) corresponds to a basic local variable; a 
nontrivial variable is used to subdivide a given configuration, yielding
another (the target of the edge).  The second type of edge (which we call
{\bf logical}) merely establishes that the source and target configurations
have the same realization.  

We give here a taste of what the language is like by explaining in detail
the formal code for the $[31,13,10]$ example.  The following code is one way
(not the shortest) or writing it in our language:

\begin{verbatim}
??no [25,8,10];
type [31,13,10_2];
show x_20 != 0;
config 20,11 : {10};
show x_10_0 != 0;
!config 10,10,11 : {110,100};
no [31,13,10];
\end{verbatim}

The first command tells the program to accept without proof the fact that
there is no $[25,8,10]$ code.  The proof of this (previously known) fact may
also be exhibited in our language, and we do so in [.jaffe optimal binary 30.].
In a complete proof one would not have such a {\tt??no} command.

The third command ({\tt type}$\ldots$) declares that our code type consists
of even codes $C$ in $\F_2^{31}$ of dimension $13$, having minimum
weight $\geq 10$.  To conform to the description of code type given earlier, we 
could say the type consists of all codes in $\F_2^{31}$ of dimension $13$,
satisfying the constraints 
$$y_1 = 0,y_2=0,\ldots,y_8=0,y_9=0,y_{11}=0,y_{13}=0,\ldots,y_{31}=0,$$%
but this would be cumbersome.  Given the knowledge that there is no
$[25,8,10]$ code, the program automatically infers that
the minimum weight of $C^\perp$ is $\geq 7$.  

The command ``\verb|show x_20 != 0|'' is self-explanatory.  As it executes
the \verb|show| command, the program automatically creates a configuration,
which is then (it so happens) made the current configuration via the 
following \verb|config| command.  Also, when the program executes the first
\verb|show| command, it creates a constructive edge from the base configuration
to the new configuration.

The next \verb|show| and \verb|config| commands are similar.  Again, the
show command actually creates the configuration prior to it being made
current by the \verb|config| command.  Thus, after executing the
second \verb|show| command, the configurations form a graph
$$\begin{array}{c}
  \rnode{a}{\psframebox{\hbox{$\vcenter{\hbox{\kern30pt(base)}\vskip3pt%
\hbox{\tt 31 : \{ \} : \{ \}}}$}}}\\[1.3cm]
  \rnode{b}{\psframebox{\hbox{\tt 20,11 : \{10\} : \{ \}}}}\\[1cm]
  \rnode{c}{\psframebox{\hbox{\tt 10,10,11 : \{110,100\} : \{ \}}}}
  \end{array}
  \arrow(a,b)\arrow(b,c)$$%
where we use the format partition : small basis : dual small basis.
The ``\verb|!config|'' command makes the bottom configuration current, and
instructs the language to try to find a contradiction.  That is, 
the bottom configuration is unrealizable.  Following the arrows back to the
base configuration, we conclude that it is unrealizable,
and hence that the code type is unrealizable.  As there is no {\it even\/}
$[31,13,10]$ code, we conclude that there is no $[31,13,10]$ code at all,
thereby justifying the final command.

\block{Method: split linear programming + symmetry}

Sometimes symmetry of a configuration can be
employed to strengthen the split linear programming method.  Let $v$ be
an admissible basic local variable.  Suppose we have a subgroup $G$ of the
automorphism group of the configuration.  Then
$G$ acts on the admissible basic local variables.  Use split linear programming
to show that the sum over $g \in G$ of $gv$ is nonzero.
Then the current configuration
can be subdivided (along $v$), and a logical edge can be constructed from the
current configuration to the new configuration.

\block{Method: passing constraints between configurations}

\def\lconfig{{\tt[}$\ell$\kern1pt{\tt]}}
\def\hconfig{{\tt[}$h$\kern1pt{\tt]}}
\def\lorconfigs{{\tt[}$\ell_1${\tt]}\kern5pt{\tt or}\kern5pt$\ldots$\kern5pt%
     {\tt or}\kern5pt{\tt[}$\ell_r${\tt]}}
\def\rconfig{{\tt[}$r${\tt]}}
\def\rpconfig{{\tt[}$r'$\kern1pt{\tt]}}
\def\sconfig{{\tt[}$s${\tt]}}
\def\spconfig{{\tt[}$s'$\kern1pt{\tt]}}
\def\lconfigs{{\tt[}$\ell_1${\tt]}, $\ldots$, {\tt[}$\ell_r${\tt]}}
\def\mconfig{{\tt[}$m${\tt]}}
\def\miconfig{{\tt[}$m_i${\tt]}}
\def\mconfigs{{\tt[}$\m_1${\tt]}, $\ldots$, {\tt[}$\m_r${\tt]}}

Suppose we have a constructive edge \lconfig\ $\longrightarrow$ \mconfig\ of
configurations.  Let $x_J$ be a basic local variable for \lconfig, and let 
$x_{J_1},\ldots,x_{J_r}$ be the basic local variables of \mconfig\ which pull
back to $x_J$.  In an appropriate sense (which we leave to the reader to
make precise),
$$x_J\ =\ x_{J_1} \many+ x_{J_r}.$$%
Therefore some known constraints of \mconfig\ will induce known constraints
of \lconfig, and conversely.  For example, if $x_{J_i} \geq c$ is a known
constraint of \mconfig (for some $i$), then the constraint
$x_J \geq c$ holds for \lconfig.

One could have full and automatic propagation of constraints along 
constructive edges, but at present this feature is only partially
implemented in the language.

\block{Method: joint linear programming}

The joint weight enumerator ${\cal J}_{C,C}$ of a code $C$ with itself gives 
rise to a linear programming problem because the coefficients of 
${\cal J}_{C, C^{\perp}}$ are nonnegative.  More information can be obtained
from the fact that the coefficients of ${\cal J}_{C^{\perp}, C^{\perp}}$ 
are as well nonnegative, but this information comes at a great cost, as the
resulting linear programming problem is much larger than that which one
would get by using ${\cal J}_{C, C^{\perp}}$ alone.  

We define a {\it basic joint variable\/} to be a variable of the form
{\tt jy}$r${\tt y}$s${\tt y}$t$, which represents
$\abs{\setof{(v,w) \in C \times C: \abs{v} = r, \abs{w} = s, \abs{v+w} = t}}$.
Note that $r$, $s$, and $t$ may be permuted without affecting the value
on any realization.  A basic joint variable is {\it minimal\/} if
$r \leq s \leq t$.  A basic joint variable is {\it inadmissible\/} if it is
known to be zero (on any realization) for one of the following reasons:
\begin{itemize}
\item There is no word in the code of weight $p$, $q$, or $r$.
\item We have $d \leq p < 2d$ (where $d$ is the minimum distance of the codes
     under consideration), and we know that an $[n-p, k-1, d-p/2]$ code cannot
     have a word of weight $(q+r-p)/2$.  Thus the variable is inadmissible by
     the method of residual codes.  With obvious modifications this also 
     applies with $p$ replaced by $q$ or $r$.
\end{itemize}
To reduce the size of the linear programming problem this method gives rise
to, one should first use split linear programming to kill as many as possible
of the weights in the code.

For more details, see the comments in the code for the C++ method\\
\verb|generate_joint_constraints|.

\block{A canned procedure for table-building}\label{canned-section}

In this section we describe an automated procedure for proving the 
nonexistence of $[n,k,d]$ codes.  As such, the procedure has as input
a triple $[n,k,d]$ and as output {\tt true} if it can show there is no
$[n,k,d]$ code, else {\tt false}.  The procedure is allowed to access all
specific results known to the program at the time of its execution.

The goodness of the procedure can be measured in two ways.  On the one
hand, the more often it returns {\tt true}, the better it is.  On the other
hand, faster is better.  These two criteria compete, and we have done our
best to find a compromise which runs reasonably fast and yields reasonably
many results.\footnote{For experimental purposes, it makes sense to deemphasize
speed.  See the description of the {\tt no} command for modifications to
this procedure which allow for this.}

Almost any general nonexistence method can be evaluated in
terms of how it could contribute to the goodness of this procedure.  The
less computationally intense the method, the better it can make the procedure.  
Thus a ``traditional theorem'' which yielded new general consequences would
have great merit as a new ingredient of the procedure.

The body of the procedure has three stages, but before starting it, we note 
that by replacing $[n,k,d]$ by $[n+1,k,d+1]$ if need be, we may reduce to the 
case where $d$ is even.

The goal of the first stage is to simultaneously check general criteria (which 
would yield the nonexistence of $[n,k,d]$ codes) and to similarly derive 
inequalities involving the global variables.  Thus the first stage is very
fast; it proceeds as follows:
\begin{itemize}
\item If $\nexists [n,k,d]$ or $\nexists [n-1,k-1,d]$, return {\tt true}.
\item We may assume that $\verb|y|_i = 0$ for $i$ odd.  Also deduce 
      $\verb|y|_i = 0$ for specific $i$ by the method of residual codes.
\item If the Griesmer bound is violated, return {\tt true}.
\item From known nonexistence results, deduce that $\verb|mu|_i = 0$ for 
      $i < r$, where $r$ is as large as possible.
\item If $\nexists [n,n-k,r]$, return {\tt true}.
\item Use known nonexistence results in conjunction with Brouwer's results to
      bound the number of doubly even words in the code.
\end{itemize}

The goal of the second stage is to show that for various $i$, we have 
$\verb|y|_i = 0$, by using split linear programming applied to the 
configuration associated to the existence of a word of weight $i$.  It is 
this stage which usually consumes the lion's share of the execution time:
\begin{romanlist}
\item If it is not known that $4 \nmid i \Longrightarrow y_i = 0$, use ordinary 
      linear programming to try to show that
      $y_0 + y_4 + y_8 + \cdots > {3\over4}(2^k)$.  In that case, we may by
      Brouwer's results delete those words whose weights are not divisible by
      $4$.
\item Use ordinary linear programming to try to show that the system of 
      inequalities is infeasible.  If so, return {\tt true}.
\item Let $i$ be the highest weight which the code might have, and which
      has not already been tested for.  Attempt to show by split 
      linear programming that there can be no word of weight $i$.  If this
      succeeds, go back to step (i).  If it fails, repeat this step again,
      but on a second consecutive failure, go on to the third stage.
\end{romanlist}
In the case where $k < n$, we stop now, as the third stage seems never to
help.

The goal of the third stage is to show that for various $i$, we have
$\verb|mu|_i = 0$, by using split linear programming applied to the
configuration associated to the existence of a dual word of weight $i$:
\begin{romanlist}
\item Let $i$ be the lowest weight which the dual code might have, which
      has not already been tested for.  Attempt to show by split linear
      programming that there can be no dual word of weight $i$.  If this
      fails, repeat with the next lowest weight.  On a second consecutive
      failure, return {\tt false}.
\item If at this point we know that there is no nonzero dual word of weight
      $\leq i$, check to see if we also know that there is no
      $[n,n-k,i+1]$ code.  If so, return {\tt true}.
\item Use ordinary linear programming to try to show that the system of 
      inequalities is infeasible.  If so, return {\tt true}.  Otherwise,
      go to (i).
\end{romanlist}

Some technical details regarding this procedure will be given when we
describe the {\tt no} command.

\block{Method: finding extensions of a code}\label{extension-section}

We describe how to classify extensions of a given code.  First we give an 
example of how this comes up.  We will prove $(*)$ that there
is no $[29,11,10]$ code.  This of course supersedes the result
(described in \S\ref{split-intro-section})
that there is no $[31,13,10]$ code.  Now $(*)$ works by showing that
a $[29,11,10]$ code must contain a dual word $w$ of weight $5$, 
and thus must contain a $[24,7,10]$ subcode, disjoint from $w$.
We classify the $[24,7,10]$ codes (itself a new result); there are six of 
them.  For each of these we then show that there is no extension to
a $[31,13,10]$ code, thereby proving $(*)$.

Here is the main idea behind the extension classifier, 
which is based on ideas the author gleaned from Simonis 
[.simonis 1987 25_15_6.].
For the above example, we would have to first add a zero bit to make
a $[25,7,10]$ code.  In general, starting from an $[n-r,s]$ code $D$
(here $n = 29$, $r = 4$, $s = 7$), you look 
for extensions to an $[n-r+1,s+1]$ code $D_1$, thence to an $[n-r+2,s+2]$ code 
$D_2$, and ultimately to an $[n,s+r]$ code $D_r$, hoping (in the above example) 
that the process fails at some point.  But there is a neat trick for doing this.
Form a matrix $M$ ($n-r-s \times n-r)$ whose rows form a basis for $D^\perp$.  
Extending from $D$ 
to $D_1$ corresponds to adding a column to $M$, yielding a matrix $M_1$.  Then 
to get to $D_2$, you add another column, yielding a matrix $M_2$.  These 
columns lie in $V := \F_2^{n-r-s}$.  Choose a total order on $V$.

Let $\Lex^j(V)$ denote the set of lexicographically ordered $j$-element 
sequences of $V$.  Call such a sequence {\it admissible\/} if the 
corresponding code $D_j$ is ``consistent'' with the larger code type.  In the 
example, we can require that $D_j$ is even and has no word of weight smaller 
than $10$.  Without loss of generality, we can also assume that the word of 
weight $j+1$ whose last $j+1$ bits are $1$ is in $D_j^\perp$.  This corresponds
to the disjointness of $D$ from $w$.

Suppose you have a subgroup $G$ of $\Aut(D)$.  (In practice it is
sometimes convenient to let $G$ be a mere subset of $\Aut(D)$, and what follows
will make sense in this setting.)  There is an induced contravariant action of
$G$ on $V$, as follows.  For $\sigma \in \Aut(D)$, let $P$ be the associated
permutation matrix ($n-r \times n-r$).  Let $Q$ be the unique invertible
$n-r-s \times n-r-s$ matrix such that $QMP = M$.  Let $v \in V$.  Then we
define $\sigma(v)$ to be $Qv$.  For the moment letting $|$ denote horizontal
concatenation of matrices, we see that $M|v \sim MP|v \sim QMP|Qv = M|Qv$,
where these matrices are equivalent in the sense that they define isomorphic
codes.

From the action of $G$ on $V$ we get an action of $G$ on $\Lex^j(V)$, by
acting individually on the elements of a sequence, and then sorting.  For
$g \in G$, $M|x \sim M|gx$.  Call an element $x$ of
$\Lex^j(V)$ {\it $G$-minimal\/} if $gx \geq x$ for all $g \in G$.  Then it is 
enough to find
$$\Gamma_j\ :=\ \setof{G\hbox{-minimal, admissible elements of\ }\Lex^j(V)}.$$%
Fortunately, if you take some $x \in \Gamma_j$, and discard its rightmost 
element, you get an element of $\Gamma_{j-1}$.  Therefore the ``extension'' 
algorithm boils down to computing in succession 
$\Gamma_1,\Gamma_2,\ldots,\Gamma_r$.  However, exactly how to compute
$\Gamma_j$ from $\Gamma_{j-1}$ in an efficient way is an interesting problem
open to further investigation.

In the case where $\Gamma_r$ is nonempty, the user needs to provide in advance
a list of configurations which the elements of $\Gamma_r$ can be tested
against.  Thus (for example) when we classify $[24,7,10]$ codes, we classify
the extensions of one of the two $[21,5,10]$ codes by means of the command
\begin{verbatim}
     via extension [21_5_10.a] implies [c], [d], [e0], [f];
\end{verbatim}
To make full sense out of this one has to see the configurations labelled
{\tt[c]}, and so forth.  

The method of this section is limited by the exponential growth of 
its execution time.  In the
present implementation, it takes roughly a small constant times
$(2^{n-r-s})(n-r+1)(s)$ operations to find $\Lex^1(V)$.  Thus for example,
whereas it is practical to find extensions from $[24,7,10]$ to
$[29,11,10]$, it is not practical to find extensions from $[35,4,18]$ to
$[38,6,18]$, which would require almost 60,000 times the execution
time of the $[24,7,10]$ case.  Although one could almost certainly make the
$\Lex^1(V)$ calculation much faster, it is not clear that the method can
be made acceptably fast as a whole.

\block{Method: finding the minimum weight of a code}

In our extension algorithm, we have to repeatedly check partial
extensions, with the goal of ruling out those whose minimum weight is too
small.  At present we do this by literally checking every element in the
partial extension.  This is almost certainly not optimal.  Much faster
probabilistic methods have been invented by Leon
[.leon probabilistic algorithm.] and Stern [.stern codewords small weight.];
an analysis of these has been given by Chabaud [.chabaud asymptotic analysis.].
Since no harm will come if an occasional partial extension squeaks past this 
checker, such a method would probably speed up our algorithm.

\newpage

\part{Background and language structure}

\block{The split weight enumerator of the dual code}

We establish the formula for the split weight enumerator of 
$C^\perp$.  This is just an elaboration on an exercise in 
[.macwilliams sloane book.].  

Let $(\VEC p1r)$ be a partition of $n$.
Define \mp[[ f || \F_2^n || \Z[\VEC t1r] ]] by
$f(v) = \prod_{i=1}^r t_i^{\abs{v}_i}$.  Let
\mp[[ \lhF || \F_2^n || \Z[\VEC t1r] ]] be the Hadamard transform of $f$
([.macwilliams sloane book.]\ pp.\ 54, 127) defined by
$$\lhF(w) = \sum_{v \in \F_2^n} (-1)^{w \cdot v} f(v).$$%
By (op.\ cit.\ Ch.\ 5, \S2, Lemma 2) we know that
$$\sum_{w \in C^\perp} f(w)\ =\ {1 \over \abs{C}} \sum_{w \in C} \lhF(w).$$%
So to prove the split weight enumerator formula, it is enough to show that
$$\lhF(w) = \prod_{i=1}^r (1+t_i)^{p_i - \abs{w}_i} (1-t_i)^{\abs{w}_i}.$$%
We proceed to prove this:
\begin{eqnarray*}
\lhF(w) & = & \sum_{v \in \F_2^n} (-1)^{w_1 v_1 \many+ w_n v_n} 
              \prod_{i=1}^r t_i^{\abs{v}_i}\\
        & = & \sum_{v \in \F_2^n} (-1)^{w_1 v_1 \many+ w_n v_n} 
              \left( \prod_{i=1}^{p_1} t_1^{v_i} \right)
              \left( \prod_{i=p_1+1}^{p_1+p_2} t_2^{v_i} \right)
              \manycdot
              \left( \prod_{i=p_1 \many+ p_{r-1} +1}^n t_r^{v_i} \right)\\
        & = & \sum_{v_1=0}^1 \sum_{v_2=0}^1 \cdots \sum_{v_n=0}^1
              \left( \prod_{i=1}^{p_1} (-1)^{w_i v_i} t_1^{v_i} \right)
              \left( \prod_{i=p_1+1}^{p_1+p_2} (-1)^{w_i v_i} t_2^{v_i} \right)
              \manycdot
              \left( \prod_{i=p_1 \many+ p_{r-1} +1}^n (-1)^{w_i v_i} t_r^{v_i}
              \right)\\
        & = & \left( \prod_{i=1}^{p_1} \sum_{u=0}^1 (-1)^{w_i u} t_1^u \right)
              \left( \prod_{i=p_1+1}^{p_1+p_2} \sum_{u=0}^1 (-1)^{w_i u} t_2^u 
              \right)
              \manycdot
              \left( \prod_{i=p_1 \many+ p_{r-1} +1}^n \sum_{u=0}^1 
              (-1)^{w_i u} t_r^u \right)\\
        & = & \left( \prod_{i=1}^{p_1} \left[ 1 + (-1)^{w_i} t_1 \right] \right)
              \left( \prod_{i=p_1+1}^{p_1+p_2} \left[ 1 + (-1)^{w_i} t_2 
              \right] \right)
              \manycdot
              \left( \prod_{i=p_1 \many+ p_{r-1} +1}^n \left[ 1 + 
              (-1)^{w_i} t_r \right] \right)\\
        & = & \prod_{i=1}^r (1+t_i)^{p_i - \abs{w}_i}(1-t_i)^{\abs{w}_i}.
              \kern1in \square
\end{eqnarray*}

\block{Exact linear programming}

The split linear programming method leads to a system of linear 
inequalities, which we may write in the form $Ax \geq b$, where for
some $r,s$ we have
$A \in \Mat_{r \times s}(\Z)$ and $b \in \Z^r$; the solution set is
$${\cal S}\ =\ \setof{x \in \Z^s: x \geq 0 \hbox{\ and\ } Ax \geq b}.$$%
The basic problem is to prove that $\cal S$ is empty.  This is because 
solutions have integer components, and thus to show that all solutions satisfy 
some inequality (e.g. $x_3 \geq 53$), we can always proceed by adjoining an
additional constraint to the original system (e.g.\ $x_3 \leq 52$), and then
showing that the new system has no solutions.  While in practice this may not be
efficient, it seems reasonable for purposes of discussion to consider only the 
case of showing ${\cal S} = \emptyset$.

Beyond aiding in this simplification, the constraint that solutions have
integer coefficients is not as useful as it might look: the analysis of
integer solutions ({\it integer linear programming}) is computationally
much more complex than the analysis of rational solutions.

The simplex algorithm can in principle be used to directly show that a
system has no solutions.  But to actually get a proof from the algorithm,
one would have to do exact arithmetic, rather than floating point calculation.  
As such, we do not know of an implementation which is acceptably fast.  
Indeed, we doubt it is possible, and offer the following heuristic argument as 
an explanation.  Consider a random $n \times n$ matrix $M$ whose entries are 
$d$-digit (or less) integers, i.e.\ whose entries are chosen uniformly from
$[-(10^d - 1), 10^d - 1]$.  One would expect $\det(M)$ to have about $nd$ 
digits.  Similarly, if one tries to compute $M^{-1}$ or an $LU$ decomposition of
$M$, one would expect the average number of digits%
\footnote{Define the {\it number of digits\/} in a rational number $a/b$ to be
the maximum of the number of digits in $a$ and $b$, supposing of course that
$\gcd(a,b) = 1$.  Generally, we use base $10$ just for illustration.}
in the entries of these matrices to have a comparable growth rate.  Now fixing
the number of digits, one should expect (for example) that computing the
``floating-point inverse'' of an $n \times n$ integer matrix will require
$O(n^3)$ operations, but computing its exact inverse will require $O(n^4)$ 
operations; the extra $n$ comes from the $n$ in $nd$.  But it may be difficult
to make such statements precise, since (e.g.) $O(n^3)$ is not optimal for
matrix inversion.  The remarks of this paragraph are obviously provisional.

A lemma of Farkas [.farkas 1902.] (see e.g.{\ }[.schrijver.] Corollary 7.1f)
asserts that 
$${\cal S}_\Q\ :=\ \setof{x \in \Q^s: x \geq 0 \hbox{\ and\ } Ax \geq b}.$$%
is empty \IFF\ there exists a $y \geq 0$ such that $A^T y \geq 0$ and 
$y \cdot b < 0$.  Otherwise said, if the system is inconsistent, then one can 
find a 
nonnegative linear combination of the constraints which is in and of itself 
contradictory.  (This may also be viewed as a consequence of duality.)  
Moreover,
the simplex algorithm produces such a $y$.  If an algorithm (via floating point 
calculations) can produce a $y$ as above, then we can form the corresponding 
{\it exact\/} linear combination of constraints and try to show (independently) 
that it gives rise to a contradiction.  This turns out to work very nicely in 
practice. 

Here then is our approach.  Given the original system (with integer 
coefficients), find a floating point $y$ which numerically appears to
satisfy $A^T y \geq 0$ and $y \cdot b < 0$.  Let $\loY$ be the best
rational approximation to $y$.  If $\VEC c1r$ are the original constraints, 
then we get a new constraint $\loY_1 c_1 \many+ \loY_r c_r$, which although
perhaps not inherently contradictory, can be used to deduce a contradiction.
Indeed the negative coefficients of variables (if any) on the \LHS\ will be 
small (close to $0$), and we
have a priori upper bounds on the variables, so (barring misfortune) we 
will be able to prove that the original system is infeasible.  The worst
that can happen is that we will be forced to report that the calculation
is inconclusive.  Note too that the proof step is simple and moreover 
thoroughly insulated from the intricacies of linear programming calculation.

The current implementation of the program contains both a provisional 
implementation of the simplex algorithm, and the ability as well to use a 
commercial solver, CPLEX, which is both faster and more robust.  The included
implementation however has the advantage of being able to use higher precision
floating point arithmetic, which becomes critical when investigating codes
of length about $70$ or greater.  Aside from being slow, the included
implementation has the disadvantage that it handles ``numerical anomalies''
poorly, and thus (depending on the state of an internal random number
generator) will sometimes (but very infrequently) stop in the middle of
a simplex calculation, and issue an error message indicating that the
calculation has failed.

For further information, we refer to a small subset the vast literature on 
linear programming: [.chvatal.], [.goldfarb todd.], [.gregory faq.],
[.karloff linear programming.], [.more wright.], and [.murtagh advanced.]

\block{Variables and constraints}\label{variable-section}

There are three kinds of variables in the language: {\it local}, {\it global},
and {\it joint}.  The first two have already been discussed in 
\S\ref{definitions-section}.
In the language, a {\bf variable} will always mean a specific, predefined
variable, global, local, or joint, and these are exhibited below.  In discussing
these, we refer to a code $C$, which is to be a code in the realization of the
particular configuration one is working with.

The basic global variables are
\begin{center}
{\tt y0},\ {\tt y1},\ $\ldots$,\ {\tt y}$n$
\end{center}
where $n$ is the length of $C$; {\tt y}$i$ gives the number of words
of weight $i$ in $C$.  Other global variables are
\begin{center}
{\tt mu0},\ {\tt mu1},\ $\ldots$,\ {\tt mu}\kern1pt$n$
\end{center}
which give the number of words of given weight in $C^\perp$. 
The last global variables are
\begin{center}
{\tt div2},\ {\tt div4},\ {\tt div8},\ $\ldots$,
\end{center}
which give the number of words in $C$ whose weight is divisible by
the given power of $2$.

Now we come to {\it local\/} variables.  For a given configuration, the
basic local variables have the form
\begin{center}
\verb|x_|$a_1$\verb|_|$\ldots$\verb|_|$a_r,$
\end{center}
where $r$ is the number of parts in the partition of the configuration.
Such a basic local variable must be {\it admissible}.

If $\VEC a1r$ are all single digits, such a basic local variable may
also be written as
\begin{center}
\verb|x|\kern1pt$a_1a_2 \ldots a_r$.
\end{center}
In addition to this formatting choice, each basic local variable has a
number of equivalent forms, since the smallcode acts on wordtypes.  
For internal purposes, we select a canonical form for each basic local
variable, which we call {\bf minimal}.  Of course we could take minimal
to mean lexicographically minimal, but this turns out to be computationally
inconvenient.  The actual definition is somewhat technical and of limited
significance.  \label{minimal-promise}We defer the details to 
\S\ref{partition-wordtype-mawhome-section}.

Again for internal purposes, the minimal form is further translated to 
{\tt v}$i$, for some $i$, so that the basic local variables are (up to 
equivalence)
\begin{center}
{\tt v1}, {\tt v2}, $\ldots$, {\tt v}$t$.
\end{center}
To discourage reliance on the internal ordering scheme used for these
variables, their use in the language is not permitted.  By convention,
{\tt v1} is the trivial basic local variable.  See also the discussion
of {\it basic joint variables}, below.

There are various local variables which are derived from the basic local
variables.  The variable
\begin{center}
\verb|z_|$a_1$\verb|_|$\ldots$\verb|_|$a_r$
\end{center}
denotes the number of words of multiweight $(\VEC a1r)$ in $C^\perp$.
As with basic local variables, there is an abbreviated form without underscores.

Now for each $i$ ($1 \leq i \leq r$), let $a_i$ be either an integer (between
$0$ and $p_i$) or else the character {\tt z}.  Then
\begin{center}
\verb|q_|$a_1$\verb|_|$\ldots$\verb|_|$a_r$
\end{center}
is a local variable.  To see what it represents, consider the subcode $D$ of 
$C$ consisting of words having zeroes in at least the positions marked by 
{\tt z} in the variable.  (We regard $D$ as a code of length shorter than $C$ 
-- it is supported on the non-{\tt z} positions.)  Let
$I = (\VEC a1r)|_{\hbox{\small\tt z} \mapsto 0}$: each {\tt z} is replaced
by a $0$.  Then \verb|q_|$a_1$\verb|_|$\ldots$\verb|_|$a_r$ represents
$\abs{D} \cdot \abs{\setofh{$I$-words in $D^\perp$}}$.  
Such variables arise during the processing of {\tt incorporate} commands.
There is also an abbreviated form without underscores.

Note that if $\VEC a1r$ are all integers, then
\verb|q_|$a_1$\verb|_|$\ldots$\verb|_|$a_r$ =
$\abs{C} \cdot$ \verb|z_|$a_1$\verb|_|$\ldots$\verb|_|$a_r$
in any realization.  This introduces an apparent redundancy, which is needed
because (in general) we do not know the value of $\abs{D}$, and we want
every variable to take on only integer values.

Relative to the current configuration, if $w$ is a small word 
(represented by a string of {\tt0}'s and {\tt1}'s), then 
\begin{center}
{\tt sub}$w$ \hbox{\ \ and\ \ } {\tt sub}$w$\verb|_|$k$
\end{center}
denote respectively the number of words in the subcode of $C$ supported on 
$w$, and the number of words of weight $k$ in that subcode.
For a configuration whose partition has only one part, the basic local
variable \verb|x_|$i$ will have the same evaluation as the basic global
variable \verb|y|$i$.  While this does not mean that \verb|x_|$i$ and
\verb|y|$i$ may be used interchangeably, we have tried to minimize the
number of places where the use of one variable as opposed to the other 
will make a difference.

We have already defined basic joint variables.  The minimal admissible basic 
joint variables are represented internally as
as {\tt v1}, {\tt v2}, and so forth.

Another joint variable is
{\tt jy}$r${\tt d}$s${\tt i}$t$, which represents
$$\abs{\setof{(v,w) \in C \times C^\perp: \abs{v} = r, \abs{w} = s, 
\abs{v \cap w} = t}}.$$%
We also allow
{\tt jy}$r${\tt d}$s$, which equals {\tt jy}$r${\tt d}$s${\tt i}$0$.

The variable {\tt co}$r$ is defined to be equal to 
{\tt jy}$r${\tt d}$r${\tt i}$r$, and the variable {\tt co} is defined to be 
equal to $\sum_{j=0}^n \verb|co|j$, so $\verb|co| = \abs{C \cap C^\perp}$.

The joint variable {\tt jd}$r${\tt d}$s${\tt d}$t$ represents
$\abs{\setof{(v,w) \in C^\perp \times C^\perp: \abs{v} = r, \abs{w} = s, 
\abs{v + w} = t}}$.  

The joint variable {\tt jdiv2} represents
$\abs{\setofh{$(v,w) \in C^2$: $v$,  $w$, and $v \cap w$ all have even
     weight}}$.

For purposes of data entry, a {\bf constraint} is a linear inequality or
equality involving any of the above variables, with $\Z$-coefficients.  
Examples of the allowed forms are:

\vspace{0.1in}

\leavevmode\kern0.5in\begin{tabular}{ll}
\verb|4y3 + 6x_2_5 >= 9| \\
\verb|-8y3 + y10 - 2y4 <= 40| \\
\verb|y32 = 1| \\
\verb|5y10 < 100| & (equivalent to \verb|5y10 <= 99|) \\
\verb|5y10 > 100| & (equivalent to \verb|5y10 >= 101|) \\
\verb|y6 != 0| & (equivalent to \verb|y6 >= 1|; \\
& \LHS\ must be a variable).
\end{tabular}

\vspace{0.1in}

Note that the \RHS\ is always an integer, and you can't put an integer on the 
\LHS, unless it is used as a coefficient of a variable.  We call a constraint
{\bf simple} if its \LHS\ is a variable.
Local and joint variables may not appear in the same constraint.

Constraints are stored as is, and not converted to constraints involving
only basic global and local variables, as would appear to be the case from
the definitions in \S\ref{definitions-section}.  Moreover, the order in
which the terms are entered matters.  Thus if {\tt y10 + y12 <= 20} is
known, it does not follow that {\tt y12 + y10 <= 20} is known.  This is a
dorky ``feature'', but is unlikely to cause problems.

A {\bf constraint list} is a list of zero or more constraints, separated by
commas.  However, certain compound forms are allowed, as in
\par\noindent\kern0.5in\verb|5 <= y10 + y12 <= 20|;
\par\noindent one or both of the inequalities may be replaced by strict
inequalities, with the expected effect.

\block{Language structure}\label{proof-command-section}

Statements in the language could be divided into two general classes:
{\bf proof} statements and {\bf exploratory} statements; in a finished proof
one should have only proof statements.

There are three main functions of proof statements: (1) establish a logical 
statement between configurations; (2) establish that a given configuration must 
satisfy a particular constraint; (3) 
establish that a given permutation is an automorphism of a given configuration.
In addition the language permits the definition of constructive connections
between configurations, as discussed in \S\ref{split-intro-section}.

Before considering the commands themselves, we describe more carefully the data
kept by the program.  The abstract notion of {\it code type} is realized by the 
class {\tt codehome} and the abstract notion of {\it configuration} is realized
by the class {\tt config}.

Part of the {\tt codehome} definition is an {\bf assumed weight list}, a list of
nonnegative integers which the weight sets of the codes are supposed to form
subsets of.  This would be formally equivalent to including assumed constraints 
of the form $y_i = 0$, but it is more efficient and convenient to keep track of 
weights instead.  However, for the remainder of this report, 
if we say that a codehome has ``no assumed 
constraints'', we do not by this imply anything about its assumed weight list.

Similarly, for each configuration, there is a {\bf working weight list},
which is a possibly smaller list of weights, such that each code realizing
the configuration has weights in the smaller list.

The {\tt codehome} definition also includes a directed multigraph 
as discussed on p.\ \pageref{first-multigraph-occurrence};
the graph structure is realized by a
{\tt ShareGraph} object.  Path components in this graph are realizability
equivalence classes.  To facilitate sharing, each path component has associated
to it a \verb|config_share| object, which carries various pieces of 
information known about the configurations.  For example, each 
\verb|config_share| object has a \verb|realizable| flag which indicates if
the configurations are known to be realizable or unrealizable.

Logical edges in the digraph are not explicitly recorded as data items.  
Rather, if we wish to ``add a logical edge'' from one configuration to
another, we merge their \verb|config_share| objects.  Constructive edges are 
labelled by the corresponding basic local variable (which is known to
be nonzero); going from head to tail of the edge corresponds to subdivision.

Labels may be associated by the user to code types, configurations, 
automorphisms, and {\tt incorporate} commands, to be described later.  The 
latter command also creates new labels.  When created by the user, a label is 
allowed to be any non-null sequence of letters, digits, and underscores, 
enclosed in square brackets.

It is also permissible to use a configuration label of the form
{\tt[}$a${\tt:}$b${\tt]}, where {\tt[}$a${\tt]} is the name of a code type
(of the same length as the current code type)
and {\tt[}$b${\tt]} is the name of a configuration of {\tt[}$a${\tt]}.  The
first time this is used, configuration {\tt[}$b${\tt]} is copied to the
current code type.  (Known facts cannot be copied.)  In usage thereafter, the
configuration {\tt[}$a${\tt:}$b${\tt]}, will be treated just like any other 
configuration of the current code type.

A {\it\bf configuration-list} is a comma-separated sequence of zero or more
configuration labels, except that amongst these, some configuration labels
may be replaced by certain compound constructions, which we illustrate by
examples:
\begin{itemize}
\item \verb|[xy*]| expands to all user-defined configuration labels which 
      start with {\tt xy}.  
\item \verb|[21{r,s,tt}]| expands to \verb|[21r]|, \verb|[21s]|, \verb|[21tt]|.
\item \verb|[21_8.{x*,y*,z}]| expands to \verb|[21_8.z]| and all user-defined
      configuration labels which start with either \verb|[21_8.x| or 
      \verb|[21_8.y|.
\item \verb|a2..15| expands to \verb|[a2]|, \verb|[a3]|, \ldots, \verb|[a15]|.
\end{itemize}
The {\tt*} construction never matches {\tt[base]} or {\tt[current]}, nor
does the {\tt*} part ever match a string containing ``{\tt!}''.

In the description of commands that follows, $n$ will always denote the
dimension of the ambient space (i.e.\ the length of the codes under 
consideration), and $k$ will denote the dimension of the codes.

All commands are terminated by a semicolon.  White space is always irrelevant.

Any command preceeded by ``??'' will be accepted without verification, as
if a ``{\tt set gullible}'' command had been used.

Any block of commands may bracketed as in the following example:
\begin{verbatim}
...
config 8,10,4,5 : {1100,1010} :: {y12 >= 31, y13 = 0, y14 >= 1};
{    show div4 >= 44;
     ...
     show x1524 = 0, x2415 = 0, x2433 = 0, x2514 = 0, x2525 = 0, x3324 = 0,
          x3405 = 0, x3423 = 0, x3425 = 0, x3434 = 0, x3443 = 0, x3504 = 0    };
config from x4422;
via building [current] implies ;
...
\end{verbatim}
The bracketed code is treated in the following way.  In gullible mode,
it is completely ignored.  Otherwise, the code is executed as usual.
In this way, code which executes slowly in gullible mode can be completely
skipped over.

Any command may be postfixed (before the semicolon) with
``{\tt<}{\it parameters}{\tt>}'', where {\it parameters\/} is a 
comma-separated list of parameters as in (for example)
\begin{verbatim}
     no [43,20,12]<auto joint test, use dual dual for joint = 7>;
\end{verbatim}
The given parameters are set prior to execution of the command and then
restored to their original value at the end.  
See the {\tt set} command for the list of allowed parameters; one may not
use {\tt gullible}, {\tt gullible commands}, or {\tt test mask} in this way.
Do not use this option with a command which is expanded into a list of other
commands, such as {\tt n =}.

\def\config#1{{\tt[}$#1${\tt]}}
\def\cconfig{{\tt[}$c${\tt]}}
\def\mconfig{{\tt[}$m${\tt]}}
\def\czconfig{{\tt[}$c_0${\tt]}}
\def\coconfig{{\tt[}$c_1${\tt]}}
\def\ctconfig{{\tt[}$c_2${\tt]}}
\def\ciconfig{{\tt[}$c_i${\tt]}}

\block{How to define a code type}

A code type is defined with the {\tt type} command, as follows:

\newenvironment{commanddeclaration}%
{\vspace{0.1in}\begin{center}\begin{Sbox}\kern2pt}%
{\end{Sbox}\psshadowbox{\TheSbox}\end{center}\vspace{0.1in}}

\def\superopt#1{$\displaystyle{\overbrace{#1}^{\hbox{optional}}}$}
\def\subopt#1{$\displaystyle{\underbrace{#1}_{\hbox{optional}}}$}

\indexb{type}
\begin{commanddeclaration}
\subopt{\hbox{\lconfig}}
{\tt type[}\kern2pt{\it length}{\tt, }{\it dimension}{\tt, }{\it weights}%
\superopt{{\tt, }{\it dual weights}}\kern2pt{\tt]}
\subopt{{\tt\{}\kern5pt{\it constraint list}\kern5pt{\tt\}}}
\superopt{{\tt/}\kern5pt{\it options}\kern5pt{\tt/}}{\tt;}
\end{commanddeclaration}

Here {\it length\/} is the length of the code, i.e.\ $n$ if the code lives in 
$\F_2^n$; the {\it dimension\/} is the dimension $k$ of the code;
{\it weights\/} represents a list $w$ of weights, and has several allowed
formats:
\vspace{0.05in}

\begin{tabular}{lll}
\verb|{|$w_1$\verb|,|$\ldots$\verb|,|$w_m$\verb|}|& -- & all weights in the
                        given set, which should be in increasing order\\
                &       & (also $0$, which should not be listed)\\
$d$ &          --   & $0$ and all weights $\geq d$\\
$d$\verb|_|$r$ & --   & $0$ and all weights $\geq d$ which are divisible by 
                        $r$\\
$d$ \verb| - {|$w_1$\verb|,|$\ldots$\verb|,|$w_m$\verb|}|& --   
                    & $0$ and all weights $\geq d$, except $\VEC w1m$\\
$d$\verb|_|$r$ \verb| - {|$w_1$\verb|,|$\ldots$\verb|,|$w_m$\verb|}|& --   
                    & $0$ and all weights $\geq d$ which are divisible by $r$,\\
               & &     except $\VEC w1m$
\end{tabular}
\vspace{0.05in}
Dual weights has the same format, defaulting to all weights.

It is permissable to use ellipsis in the above situations, for example
\begin{center}
``\verb|66_2 - {98,114,118..138}|'' 
\end{center}
denotes all even weights $\geq 66$,
except $98$, $114$, and those numbers lying between $118$ and $138$.

\vspace{0.05in}

As an example of a {\tt type} command, ``\verb|type [29,11,6_2]|'' would cause
the program to think about even codes of dimension $11$ in
$\F_2^{26}$, having minimum weight $\geq 6$.

The program will automatically use the method of residual codes to infer that 
certain weights cannot occur.  Let $d$ be the minimum weight in the weightlist.
Suppose that $i$ satisfies $d \leq i < 2d$.  Suppose that we know there is
no code of type $[n-i,k-1,d - \floor{i/2}]$.  Then weight $i$ does not occur.
If the code is at the Griesmer bound, and its minimum weight is even, all its 
words have even weight
([.tilborg griesmer 1980.] 1.11).  This is automatically known to the program.

In the case of an even code, we automatically include lower and upper bounds
on the number of words whose weights are divisible by $4$, in accordance
with the results of Brouwer [.brouwer linear programming bound.].

If for a given $d'$, it is known that there is no
$[n-(d'-1),k-(d'-1)+1,w]$ code, then it is automatically inferred that
the minimum weight of the dual code is at least $d'$.

The optional {\it constraint list\/} is a list of constraints, which 
all codes $C$ in the type are to satisfy.  
The optional argument \lconfig\ if present assigns the label \lconfig\ to
the code type for future reference.  The same label may not be used for two
code types.

The {\it options} field is a comma-separated list of fields.  At this point
there are five allowed fields, each of which may appear only once. The first
field is:
\par\noindent\kern0.5in\verb|dual_may_be_code_of_design(t = 2, k = |$\kappa$%
\verb|, lambda = |$\lambda$\verb|)|.
\par\noindent
The effect of this option is to check that $C^\perp$ satisfies certain
conditions which are necessary (but not sufficient) for it to be generated by a
$t$-design $D$ with the given parameters.  (We use $\kappa$ to avoid conflict
with our convention that $k$ is the dimension of the code.)

To explain these conditions, let $S(2)$ denote the set of all $2$-words in
$\F_2^n$, and let $T(\kappa)$ denote the set of all $\kappa$-words in 
$C^\perp$.

If $\lambda > 1$, we check only that every element of $S(2)$ is contained
in at least $\lambda$ elements of $T(\kappa)$.  In the case where
$\lambda = 1$, we check the following more elaborate 
condition\label{elaborate-design-condition}:

\vspace{0.1in}

\par\noindent
$A := S(2)$;\\
$B := T(\kappa)$;\\
$E := \emptyset$;\\
   \begin{tabular}{ll}
   \kern-6pt repeat \{\ \ \ \ & (At this point every $a \in A$ lies in some
        element of $D \cap B$.)\\
   & if $(\kern4pt \exists\kern1pt a \in A
        \hbox{\ not contained in any\ } b \in B\kern4pt )$ return false;\\
   & $U := \setof{a \in A: \exists! \kern4pt b \in B 
     \hbox{\ containing\ } a}$;\\
   & if $( \kern4pt U = \emptyset \kern4pt )$ return 
     (($\abs{E} \not= {n \choose 2}/{\kappa \choose 2}$) or
     ($E$ generates $C^\perp$));\\
   & $F := \setof{b \in B \hbox{\ which contains an element\ } u \in U}$;\\
   & (Note that $F \IN D$.)\\
   & $E := E \cup F$;\\
   & if $(\kern4pt  \exists f_1, f_2 \in F \hbox{\ such that\ } 
       \abs{f_1 \cap f_2} \geq 2\kern4pt )$ return false;\\
   & $A_0 := \setof{a \in A: a \hbox{\ is contained in some\ } f \in F}$;\\ 
   & $A := A - A_0$;\\
   & $B := \setof{b \in B: b \hbox{\ contains no element of\ } A_0}$;
       \kern0.9cm\}
   \end{tabular}

\vspace{0.1in}
\par\noindent
The second condition is
\par\noindent\kern0.5in\verb|partition_of_word_by_dual_words(weight = |$w$%
\verb|, dual_weight = |$d$\verb|)|.
\par\noindent For this condition to be satisfied, every word of weight $w$ in
$C$ must admit a nonoverlapping cover by words of weight $d$ in $C^\perp$.

If both conditions (\verb|partition_of_word_by_dual_words|,
\verb|dual_may_be_code_of_design|) are employed, $\lambda = 1$, and 
$d = \kappa$, the meaning of the two conditions is modified
and the above tests are combined and strengthened, as follows.  First, the
change in meaning is that now we require that there exists a $t$-design $D$ with
the given parameters, generating $C^\perp$, such that moreover every word of
weight $w$ in $C$ admits a nonoverlapping cover by elements of $D$.  As for
the change in tests, make the following definition.
A {\it covering plan\/} is a choice, for each 
word of weight $w$ in $C$, of a nonoverlapping cover by words of weight 
$\kappa$ in $C^\perp$, in such a way that no two words in the covering
plan meet at more than one position.  We cycle through all covering 
plans $\cal D$,
and for each, we execute the condition outlined above, except that the
initial choices for $A$, $B$, and $E$ are modified as follows:
\begin{itemize}
\item $A = \setof{w \in S(2):\ w 
     \hbox{\ is not contained in any\ } d \in \cal D}$;
\item $B = \setofh{words in $T(\kappa)$ not meeting any $d \in {\cal D}$ along 
     more than one bit}$;
\item $E = \cal D$.
\end{itemize}
In the above, we have used ${\cal D}$ to denote the set of all dual words
appearing in the given covering plan.

The third field is 
\par\noindent\kern0.5in\verb|doubly_even_part_is_subcode|.
\par\noindent This condition says that the set $D$ of words in the code whose
weight is divisible by four must constitute a subcode of $C$.  This is 
equivalent to saying that $D \IN C^\perp$.

The fourth field is
\par\noindent\kern0.5in\verb|dual covering radius <= |$r$,
\par\noindent where $r$ is a positive integer.  This condition says that
the covering radius of the dual code must not exceed $r$.

The fifth field is
\par\noindent\kern0.5in\verb|maybe subcode of |\lconfig,
\par\noindent
where \lconfig\ is a code type which has been defined already.  The effect of
this is to draw certain conclusions which would be known for subcodes of
codes realizing type \lconfig.  (Here {\it subcode\/} allows both for smaller
dimension and shorter length.)  Specifically, any constraints from 
\lconfig\ which set a basic local variable or basic global variable to zero
are copied (and treated as assumed constraints) for the current type.  If
\verb|dual covering radius <= |$r$ was chosen for \lconfig, appropriate 
deductions are made for the current type.  The possibility of drawing other 
conclusions is left open for future versions of the program.

\vspace{0.1in}

If at some point it is found that the code type is unrealizable, the language 
interpreter will discard all information about the code type except this fact.

After a {\tt type} command is entered, that type remains in effect until
the next {\tt type} command (or some other command which changes the type,
such as ``{\tt no}'').  See also the ``{\tt at}'' command.

\block{Expressions}\label{matrix-descriptor-section}

In this section, we define an {\it expression}.  This is a string which can
be evaluated to yield a mathematical object, subject to certain rules we shall
give.  All of this is in flux!

Warning!  See the directory {\tt functions} for more information about
operators on expressions.  The documentation to be found there will
ultimately appear in this document.

The following table presents the currently extant object types, along 
with the internal types which represent them:

\def\dtext#1#2{\vbox{\hbox{\tt #1}\kern3pt\hbox{\tt #2}}}
\def\dtextp#1#2{\vbox{\kern5pt\hbox{\tt #1}\kern3pt\hbox{\tt #2}}}
\def\ttext#1#2#3{\vbox{\hbox{\tt #1}\kern3pt\hbox{\tt #2}\kern3pt\hbox{\tt #3}}}
\def\ttextp#1#2#3{\vbox{\kern5pt\hbox{\tt #1}\kern3pt\hbox{\tt #2}\kern3pt%
\hbox{\tt #3}}}
\def\ftext#1#2#3#4{\vbox{\hbox{\tt #1}\kern3pt\hbox{\tt #2}\kern3pt%
\hbox{\tt #3}\kern3pt\hbox{\tt #4}}}

\begin{center}
\begin{tabular}{|l|l|}\hline
{\bf name} & {\bf meaning}\\ \hline\hline

{\tt F2} & an element of $\F_2$\\ \hline

{\tt MatF2} & a matrix over $\F_2$\\ \hline

{\tt PVSF2}
     & \ttext{a partitioned vector space over $\F_2$,}%
       {represented by a list of lists of elements of $\F_2^n$,}%
       {which define a partition of it}\\ \hline

{\tt Group} &\dtext{a finite group, given by generators}%
{and transformation rules}\\ \hline

{\tt Int} & an integer\\ \hline

{\tt MatInt} & a matrix of integers\\ \hline

{\tt Rat} & a rational\\ \hline

{\tt MatRat} & a matrix of rationals\\ \hline

{\tt Bool} & {\tt true} or {\tt false}\\ \hline

{\tt LinearProgram} & a system of inequalities with integer
     coefficients\\ \hline

{\tt String} & a string\\ \hline

\end{tabular}
\end{center}

In addition, if $\alpha$ is an object type, $\verb|List(|\alpha\verb|)|$
denotes an ordered list (i.e.\ vector) of objects of type $\alpha$.  

There are as well attributes assigned to some types: for {\tt MatF2} there are
potential attributes {\tt reduced} (meaning in \RREF, and having no zero rows) 
and {\tt invertible}.  A {\tt List} of {\tt MatF2}'s has the potential
attribute {\tt homogeneous}, meaning that the list is nonempty and all the
matrices have the same size.

The way that attributes may be indicated is illustrated by the following
examples, both of which are so frequently used that we give an abbreviation:

\vspace{0.1in}

\par\noindent abbreviation: {\tt MatrixGroup(F2)}
\par\noindent type name: \verb|List(MatF2{invertible}){homogeneous}|
\par\noindent what it is: A nonempty list of invertible matrices (over $\F_2$) 
having the same size.

\vspace{0.1in}

\par\noindent abbreviation: {\tt HList(MatF2)}
\par\noindent type name: \verb|List(MatF2){homogeneous}|
\par\noindent what it is: A nonempty list of matrices (over $\F_2$) having the 
same size.

\vspace{0.1in}

There are a number of binary operators, and as a rule, there is no
guarantee how ambiguous expressions (like
$\alpha \kern5pt {\tt\#} \kern5pt \beta \kern5pt {\tt\-} \kern5pt \gamma$)
are handled.  Use parentheses.  There is one exception: the \verb=|= operator
has lowest precedence.  Otherwise, evaluation tends to be from left to right.

By {\it reducing\/} a matrix, we mean that it is converted to \RREF\ and
moreover that its zero rows are removed.

Some of the operators appear to return a finite graph.  In such cases
what we really mean is that a matrix having only weight two columns
(one for each edge in the graph) is returned.

We make the convention that when we refer to a column number of a matrix 
with $n$ columns, the number will be between $1$ and $n$.  (And not between $0$ 
and $n-1$.)  

\vspace{0.1in}
\par\noindent{\Large\bf Expression list \circno1}
\vspace{0.1in}

The following expressions are functions of one or more variables, but
the arguments are not themselves objects.  All the functions in this list
yield as output an object of type {\tt MatF2}.

\begin{itemize}
\item $\verb|Choose|(n,\setof{\VEC k1r})$, representing the horizontal 
      concatenation of 
      $$\verb|Choose|(n, k_1), \verb|Choose|(n, k_2), \ldots, 
          \verb|Choose|(n, k_r).$$
\item $\verb|AntiCode(|k,\vec T1r\verb|)|$, where 
      $T_i \IN {\cal P}(\setof{1,\ldots,k})$ for all $i$.  This represents the
      horizontal concatenation of certain matrices, one for each $i$.  For a
      given $i$, first form the matrix which has all nonzero columns of length
      $k$, with entries in $\F_2$.  Then for each $T_{ij}$ in $T_i$, delete 
      those columns which lie in $\SPAN\setof{e_\ell : \ell \in T_{ij}}$.
      The codes having generator matrices of this type are modelled after the 
      codes of Solomon and Stiffler [.solomon stiffler.].
\item $\verb|BCH(|r\verb|, |n\verb|, |${\it first}\verb|..|{\it last}%
      \verb|)|,
      representing the matrix of the BCH code of length $n$ over $\F_2$,
      associated to the powers $\hbox{\it first},\ldots,\hbox{\it last}$ of
      a primitive element in $\F_{2^r}$.
\item $\verb|Coset(2^|m\verb|, |r\verb|, n = |n\verb|)|$, representing the 
      matrix associated to the cyclic code of length $n$ associated to the 
      union of $\setof{0}$ and the cyclotomic coset mod $2^m - 1$ generated by 
      $r$.
\item $\verb|Col(|i_1\verb|,|\ldots\verb|,|i_r\verb|)|$, representing a column
      vector having nonzero entries in positions $\VEC i1r$, where $1$
      represents the top position.  Here $\VEC i1r$ should be distinct, positive
      integers.  The length of the column vector will equal
      $\max\setof{\VEC i1r}$.
\item $\verb|MulMod(|f\verb|,|g\verb|)|$, representing the matrix of 
     multiplication by $g$, in the ring $\F_2[t]/(f)$, relative to the standard
     basis $t^0, t^1, \ldots, t^{d-1}$, where $d$ is the degree of $f$.
\end{itemize}

\par\noindent{\Large\bf Expression list \circno2}
\vspace{0.1in}

The following expressions are irregular.  They do not have objects as 
arguments.  Except as noted, they yield as output an object of type {\tt MatF2}.

\begin{itemize}
\item \verb|{|$\VEC r1k$\verb|}|, where $\VEC r1k$ are
     zero-one vectors (e.g.\ $010001110$) which comprise the rows of the
     matrix to be defined.
\item a nonnegative integer, yielding an {\tt Int} (note unresolved ambiguity 
     with the previous item)
\item {\tt[}$c.m${\tt]}, where \cconfig\ is a code type and \mconfig\ is a 
     configuration for \cconfig\ having the same dimension as it.  The 
     associated matrix is the reduced generator matrix for the basic code
     associated to \mconfig.  Some facility for lists of configurations is
     implemented in a similar way to the definition of configuration-list.
     Output type: {\tt HList(MatF2)}.
\item {\tt[}$c.m${\tt-}$r${\tt]}, shorthand for
     {\tt[}$c.m${\tt] - column}\kern5pt$r$.
\item $p$, a permutation, which represents the corresponding permutation
      matrix.  The permutation $p$ is to be given as a product of cycles,
      e.g.\ as ``\verb|(1,4,5)(2,3)(6,8,7)|''.  The size of the matrix is
      $r \times r$, where $r$ is the largest integer appearing in $p$.
      To avoid notational ambiguities, a permutation must be presented as
      the product of at least two cycles.
\end{itemize}

\par\noindent{\Large\bf Expression list \circno4}
\vspace{0.1in}

All the expressions in this list are binary operators, whose operands (labelled 
here $M$ and $N$) have type {\tt MatF2} and whose output has type {\tt MatF2}.

\begin{itemize}

\item {\bf[sharp]}
$M \verb|#| N$ is defined in the following
way.  First let $A$ be the horizontal concatenation of $N\verb|.ncols|$
copies of $M$.  Then let $B$ be obtained from $N$ by replicating each column
$M\verb|.ncols|$ times.  Finally $M \verb|#| N$ is the vertical concatenation
of $A$ and $B$.

\item {\bf[horizontal concatenation]}
$M \verb=|= N$ is the horizontal concatenation of $M$ and $N$.  If necessary, 
zero rows are first added to be bottom of $M$ (or $N$) to equalize the number 
of rows.  

\item {\bf[column complement]}
Assume that $M$ and $N$ have the same number of rows.  Then $M \verb|-| N$ is 
obtained from $M$ by deleting every column which appears in $N$.

\end{itemize}

\par\noindent{\Large\bf Expression list \circno5}
\vspace{0.1in}

All the expressions in this list are special binary operators.  The left
operand is an object of type {\tt MatF2} (which we label here $M$).  The right 
operand does not have any objects in it.  The output type is {\tt MatF2}.

\begin{itemize}

\item {\bf[parity check]} Let $C$ be the rowspace of $M$.  Assume that $C$ has 
a word of odd weight.  Then $M\verb| + check|$ is obtained from $M$ by 
adjoining a parity check as the last column. 

\item {\bf[column duplication]} Let $r$ be an integer between $1$ and 
$M\verb|.ncols|$.  Then $M\verb| + column |r$ is obtained from $M$ by 
duplicating column $r$.

\item {\bf[column deletion]}
Let $r$ be an integer between $1$ and $M\verb|.ncols|$.  Then 
$M\verb| - column |r$ is obtained from $M$ by deleting column $r$.  Similarly, 
if $\VEC r1s \in \setof{1,\ldots,n}$, then 
$M\verb| - columns {|r_1\verb|,|\ldots\verb|,|r_s\verb|}|$ is obtained from $M$ 
by deleting columns $\VEC r1s$.  It is also permissable to use {\tt..} to 
abbreviate a consecutive sequence, as in \verb|{1..4,9..12}|, which is 
equivalent to \verb|{1,2,3,4,9,12}|.

\item {\bf[subcode disjoint from a bit]}
Let $r$ be an integer between $1$ and $M\verb|.ncols|$.  Then 
$M\verb| ~ column |r$ is obtained from $M$ by forming the reduced matrix 
spanning the subspace of the rowspace which is zero along column $r$; this 
column is deleted.

\end{itemize}

\par\noindent{\Large\bf Expression list \circno6}
\vspace{0.1in}

All the expressions in this list are special binary operators.  The left
operand is an object of type {\tt MatF2} (which we label here $M$).  The right 
operand does not have any objects in it.  The output type is {\tt HList(MatF2)}.

\begin{itemize}

\item {\bf[dual word deletion]}
Let $r$ be an integer between $1$ and $M\verb|.ncols|$.  Then 
\begin{center}
$M\verb| - dual word of weight |r$ 
\end{center}
represents the list of isomorphism classes of matrices obtainable from $M$ by 
deleting the columns corresponding to a word of weight $r$ dual to the rowspace 
of $M$, and then reducing.  You can also do this with $M$ of type 
{\tt List(MatF2)}.

\item {\bf[subcode disjoint from a dual word]}
Let $r$ be an integer between $1$ and $M\verb|.ncols|$.  Then 
$M\verb| ~ dual word of weight |r$ is obtained from $M$ by forming the reduced 
matrix spanning the subspace of the rowspace which is disjoint from a dual word 
$w$ of weight $r$; the corresponding columns are deleted.  As $w$ varies,
one obtains a list of matrices; a sublist of isomorphism class representatives
is returned.  You can also do this with $M$ of type {\tt List(MatF2)}.

\item {\bf[dual word addition]}
First reduce $M$.  Let $r \in \setof{3,4}$.  Then 
\begin{center}
$M\verb| + dual word of weight |r$  
\end{center}
represents the list of isomorphism classes of matrices $M^+$ obtainable from 
$M$ by adding $r$ columns to it (and reducing), in such a way that the new codes
$D := \Rowspace(M^+)$ have minimum distance two greater than $\Rowspace(M)$, and
such that the weight $r$ word corresponding to the $r$ columns lies in 
$D^\perp$.  You can also do this with $M$ of type {\tt List(MatF2)}.

\end{itemize}

\par\noindent{\Large\bf Expression list \circno7}

\begin{itemize}

\item{\bf[LinearProgram]}  Let $f$ be of type \verb|String|, naming a file which
contains a linear program, with integer coefficients.  Then
$\verb|LinearProgram($f\verb|)|$ is an internal representation of that
linear program.

\item{\bf[Bound]}  Let $P$ be a {\tt LinearProgram}.  Let $v$ be a variable
which appears in $P$.  Then $\verb|Bound(|P\verb|,|v\verb|)|$ returns
{\it unverified\/} bounds (type \verb|List(Rat)|) on $v$ obtained by applying 
the simplex method to $P$.

\item{\bf[{.}{.}]} Let $a$ and $b$ be of type {\tt Int}, $a \leq b$.  Then
$a\verb|..|b$ expands to $a,a+1,\ldots,b$.

\item{\bf[-]} Let $n$ be of type {\tt Int}.  Then $\verb|-|n$ is its
negation.

\item{\bf[AsConfig]} Let $M$ be of type {\tt MatF2}.  Then APPLY1(AsConfig,M) 
is a {\tt String} which indicates how $M$ might be defined by a {\tt config} 
command.  The columns are sorted and repeated columns are contracted.

\item{\bf[WeightEnumerator]} Let $M$ be of type {\tt MatF2}.  Then
APPLY1(WeightEnumerator,M) is the weight enumerator of the rowspace of $M$,
as a list of integers.  This may also be applied to an object of type 
{\tt List(MatF2)}.

\item{\bf[AsPoly]} Convert an object of type {\tt List(Int)} into a
polynomial in $t$, returning an object of type {\tt String}.  Similarly
convert {\tt List(List(Int))} to {\tt List(String)}.

\item{\bf[WE]} Equivalent to $\verb|AsPoly| \circ \verb|WeightEnumerator|$.

\item{\bf[Build]} Let \hconfig\ be a code type.  Let \lconfig\ be a 
configuration for \hconfig.  Then \verb|Build( |\hconfig, \lconfig\verb| )| 
returns the matrices that would have been obtained if a command of the form
{\tt via building }\lconfig\ $= \ldots$ had been used from type \hconfig.

\item{\bf[Random]} The syntax is
\verb|Random( |{\it type}\verb|, |{\it size}\verb|, |{\it range}\verb|, |%
{\it seed}\verb| )| where
\begin{itemize}
\item {\it type\/} is {\tt List(Int)} or {\tt MatInt}
\item {\it size\/} is a single integer (if {\it type\/} $=$ {\tt List(Int)}) or
      two integers (separated by a comma) (if {\it type\/} $=$ {\tt MatInt})
\item {\it range\/} is two integers (separated by a comma), indicated low and
      high values for the random entries
\item {\it seed\/} is a number to be used as a seed for the random number
      generator.
\end{itemize}

\item{\bf[A\_inverse\_b]} Let $A$ be of type {\tt MatInt}, which we assume is
invertible.  Let $b$ be of type {\tt List(Int)}.  Then
$\verb|A_inverse_b( |A\verb|, |b\verb| )|$ returns $A^{-1}b$, which is of
type \verb|List(Rat)|.  (This is experimental.  Currently there is a
third argument, the version number, which may be $0$ or $1$.)

\item {\bf[Read]}  The syntax is 
\verb|Read( |{\it type}\verb|, |{\it file name}\verb| )|, where {\it type\/}
is the type of the object to be read and {\it file name\/} is the name of
the file it is in.  It must be at the beginning of the file.  The only types
which are currently allowed are {\tt List(Int)} and {\tt MatInt}.
\item {\bf[Cyclic]}  The syntax is
$\verb|Cyclic(|c\verb|, |n\verb|, |k\verb|, |%
{\it generator}\verb|, |{\it extra word}\verb|)|$.  This yields a
{\tt MatF2} $M$ of size $k \times n$, as follows.  First one can define the 
{\it standard permutation\/} on $n$ of cycle type $(a_1,\ldots,a_r)$.  
By way of example, the standard permutation on $10$ of cycle type $(3,2)$
is given as a product of disjoint cycles by $(1,2,3)(4,5)$.  Now the 
argument $c$ describes a permutation $\sigma$.   It is the standard
permutation on $n$ of a certain cycle type.  First, if $c$ is a positive 
integer dividing $n$, the cycle type is $(n/c, \ldots, n/c)$, with $n/c$ 
appearing $c$ times.  Otherwise, $c$ must itself be the cycle type.  
The generator and the extra word (if present) are to be zero-one vectors of 
length $\leq n$.  Pad on the right with zeros to form vectors $v$ and $w$
of length $n$.  If the extra word is not present, let $M$ have rows 
$\setof{v, \sigma(v), \ldots, \sigma^{k-1}(v)}$.  Otherwise let the rows
be $\setof{v, \sigma(v), \ldots, \sigma^{k-2}(v),w}$.  Note that there
is no guarantee that $\sigma$ is an automorphism of $M$.

\item {\bf[OrbitCount]} If $G$ is a {\tt MatrixGroup(F2)}, then 
APPLY1(OrbitCount,G) returns the number of orbits of $G$ under its natural 
action on $\F_2^n$.  In fact, \verb|OrbitCount| does more: it finds a system of 
orbit representatives.  This information is not returned.

\item {\bf[OrbitReps]} If $G$ is a {\tt MatrixGroup(F2)}, then 
APPLY1(OrbitReps,G) returns a matrix whose rows form a system of orbit 
representatives for $G$ under its natural action on $\F_2^n$. 

\item {\bf[DelsartePair]}
$\verb|DelsartePair(|n\verb|,|k\verb|,|w\verb|,|r\verb|,{|c\verb|})|$ is the 
linear program associated to a the pair of linear codes consisting of an
$[n,k,w]$ code, where $w$ is a list of integers,
containing an $[n,k-1,r]$ code (where $r$ is a list of integers), subject to the
constraint list $c$, involving global variables $Y_i$ for the larger code
and $y_i$ for the smaller code.  

\item {\bf[Realizable]} Let $L$ be a list of matrices.  Let \hconfig\ be a code
type.  Then $\verb|Realizable(|\hconfig\verb|, |L\verb|)|$ selects those 
matrices $L_i$ which realize the code type $L$.  (In particular, their 
rowspaces must have the right dimension.)

\item {\bf[Unresidue]}
Let $L$ be a list of matrices.  Let \hconfig\ be a code type and let 
\cconfig\ be a basal configuration for it.  Then
$\verb|Unresidue(|\hconfig\verb|, |\cconfig\verb|, |L\verb|)|$ returns a list 
of generator matrices for those codes (up to isomorphism) in \hconfig\ which 
satisfy the constraints of \cconfig and could have a residual code generated by 
a matrix in $L$.  There is an optional fourth argument, a positive integer $r$,
which causes computation to stop after $r$ codes, for each matrix in $L$.  See 
also the parameters \verb|unresidue ! show all configs| and 
\verb|unresidue ! show extra info|.

\item {\bf[Select]}
Let $L$ be a list of matrices.  Let $f$ be a constraint, or set-bracket-enclosed
list of constraints, whose \LHS's are integer linear combinations of global 
variables, and whose \RHS's are integers.  Then 
$\verb|Select(|L\verb|, |f\verb|)|$ selects
those matrices $L_i$ whose rowspace (as a code) satisfies $f$.

\item {\bf[subcodes disjoint from a bit]}
If $M$ is of type {\tt MatF2}, then
$M\verb| ~ column|$ is the list obtained by choosing isomorphism class members 
from $M\verb| ~ column |r$, as $r$ varies.  Alternatively, $M$ may be of
type {\tt List(MatF2)}, in which case $M_i\verb| ~ column|$ is computed and the 
lists are merged (taking only isomorphism class members).

\item {\bf[Group]}
Define an object of type {\tt Group}.
given by generators and relations.  We illustrate by examples.

\begin{verbatim}
Group( x, y : x^21, y^3, yx -> xy )
Group( x : x^65 )
Group( x, y, z : x^3, y^3, z^7, yx -> xy, zx -> xz, zy -> yz^2 )
\end{verbatim}

Note the following.  The generators must be letters.  Positive powers of each 
generator (to be set equal to the identity) must always be given, immediately
after the generators and in the same order.  The other relations are given
as replacement rules, as shown.  These rules operate on words in the generators.
It is the users responsibility to be sure that they work in the following sense:
\begin{itemize}
\item There are no infinite sequences of transformations.
\item If $\alpha\verb| -> ... -> |\beta_1$ and
$\alpha\verb| -> ... -> |\beta_2$, and $\beta_1$, $\beta_2$ are terminal
(admitting no further transformations), then $\beta_1 = \beta_2$.
\item The group is finite.
\end{itemize}
An error will be issued (perhaps later) if the group is larger than $1000$ or 
``too many'' transformations seem to have occurred.

\item {\bf[RegularRep]}
For an object $G$ of type {\tt Group},
This generates the regular representation (over $\F_2$) of a finite group,
given by generators and relations.  We illustrate by examples.

\begin{verbatim}
RegularRep( x, y : x^21, y^3, yx -> xy )
RegularRep( x : x^65 )
RegularRep( x, y, z : x^3, y^3, z^7, yx -> xy, zx -> xz, zy -> yz^2 )
\end{verbatim}

Note the following.  The generators must be letters.  Positive powers of each 
generator (to be set equal to the identity) must always be given, immediately
after the generators and in the same order.  The other relations are given
as replacement rules, as shown.  These rules operate on words in the generators.
It is the users responsibility to be sure that they work in the following sense:
\begin{itemize}
\item There are no infinite sequences of transformations.
\item If $\alpha\verb| -> ... -> |\beta_1$ and
$\alpha\verb| -> ... -> |\beta_2$, and $\beta_1$, $\beta_2$ are terminal
(admitting no further transformations), then $\beta_1 = \beta_2$.
\item The group is finite.
\end{itemize}
An error will be issued if the group is larger than $1000$ or ``too many''
transformations seem to have occurred.

\item {\bf[For]}
Let $\verb|[|i\verb|]|$ be an indeterminate.  This means that $i$ is a string 
that starts with a letter and is followed by zero or more alphanumeric 
characters (or underscores), and that $\verb|[|i\verb|]|$ is not already 
defined.  Let $L$ be some sort of list.  [So its type is 
$\verb|List(|\ldots\verb|)|$.]  Let $s$ be any expression.  Then
$\verb|For( [|i\verb|], |L\verb|, |s\verb| )|$ is 
$\verb|{| s|_{[i] \mapsto L_1}, \ldots, s|_{[i] \mapsto L_n} \verb|}|$.

\item {\bf[Transpose]}
Assuming that $x$ has type $\verb|List(List(|\ldots\verb|)|$, 
APPLY1(Transpose,x) returns its transpose, assuming that it makes sense.

\item {\bf[Reduce]} Let $M$ be of type {\tt MatF2}.  Then APPLY1(Reduce,M) is 
the {\tt MatF2} obtained from $M$ by converting to \RREF\ and removing any zero 
rows.  Also {\tt Reduce} may be applied to a {\tt List(MatF2)}, yielding 
another {\tt List(MatF2)}.

\item {\bf[Orbits]}
Let $L$ be of type {\tt MatrixGroup(F2)}, generating a group of $n \times n$
matrices $G$.  Then $\verb|Orbits(|L\verb|)|$ is the set of orbits
of $\F_2^n$ under the action of $G$.  The output type is {\tt PVSF2}.
Alternatively, if $L$ is of type {\tt List(MatrixGroup(F2))},
$\verb|{ Orbits(|L_1\verb|), |\ldots\verb|, Orbits(|L_n\verb|) }|$
is returned, which is of type {\tt List(PVSF2)}.

\item {\bf[Diag]} If $\vec M1n$ are matrices (type {\tt MatF2}), then
$\verb|Diag(|\vec M1n\verb|)|$ is their direct sum, i.e.\ the matrix
(type {\tt MatF2}) associated to the direct sum of the associated linear 
maps, \WRT\ the standard bases.  If $\vec M1n$ instead have type
{\tt List(MatF2)}, and each list has the same length, apply \verb|Diag|
to their members in parallel, yielding a {\tt List(MatF2)}).

\item {\bf[Length]} Let $L$ be a list (of some sort).  Then APPLY1(Length,L)
is the number of elements in the list, an object of type {\tt Int}.

\item {\bf[P]} Let $M$ be of type {\tt MatF2}, which is replaced by its 
reduction.  Let $\Simp$ be short for $\Simp({\tt M.nrows} - 1)$.  Then 
APPLY1(P,M) is the reduction of $\BRMAT{1&0\cr\Simp&M}$.  Also {\tt P} may be 
applied to an object of type {\tt HList(MatF2)}.

\item {\bf[column deletion (without the column number)]}
Let $M$ be of type {\tt MatF2}.  Then $M\verb| - column|$ is obtained from $M$ 
by considering the list of all matrices obtainable from $M$ by deleting a 
column, and then choosing a sublist of isomorphism class representatives.  In 
place of $M$, one may give a list of matrices, in which case the corresponding 
lists are merged, and again a sublist of isomorphism class representatives is
returned.  The output type is {\tt HList(MatF2)}.

\item {\bf[perturbation]}
For purposes of this paragraph, call one matrix a {\it perturbation\/} of 
another matrix if they have the same size and having differing entries in at 
most one column.  Now let $M$ be of type {\tt MatF2}.  Let $d$ be the minimum 
distance of the row space of $M$.  For purposes of this paragraph, call a 
perturbation of some matrix {\it good\/} if its row space has minimum distance 
at least $d$.  Then $\verb|Pert(|M\verb|)|$ is the list of all matrices (up to 
isomorphism) which are obtainable from $M$ via a sequence of good perturbations.
The output type is {\tt HList(MatF2)}.

There is an optional argument ``\verb|mu filter|'' which if used has the
following effect.  A perturbation $N$ is not used unless the code dual
to its rowspace has a word of weight one or two.

The input to $\verb|Pert|$ may be a list of matrices (generated by another 
operator).  

\item {\bf[double perturbation]}
For $M$ of type {\tt MatF2}, $\verb|PertTwo(|M\verb|)|$ is defined in the same 
way as $\verb|Pert(|M\verb|)|$, except that here we use a different notion
of perturbation: A matrix $N$ is a {\it perturbation\/} of a matrix $M$
if they have the same size, have differing entries in at most two columns
(say $i$, $j$), and moreover $N^i - M^i = N^j - M^j$, where superscripts
select columns.  

The optional argument ``\verb|mu filter|'' works the same way as it does
for \verb|Pert|.  There is also an optional argument ``\verb|ex triples|'' which
if used has the following effect.  Each time we consider making a perturbation a
long columns $i$ and $j$, we check to see if there exists a dual word of weight
$3$ whose support contains $i$ and $j$.  If so, we do not make the 
perturbation.  Usually when this option is used, one gets the same list of
codes, but in a different order, and faster.

There is also an optional argument of the form
``$\verb|stop after |r\verb| codes|$'', where $r$ is a positive integer, which
will cause the perturbations to stop after a total of $r$ nonisomorphic matrices
have been found.  Example: $\verb|PertTwo(|M\verb|, stop after 10 codes)|$.  

The input to $\verb|PertTwo|$ may be a list of matrices (generated by another 
operator).  A last option of the form {\tt start = }$r$ is allowed, which
instructs the program to assume that perturbations of the first $r-1$ matrices
are already included in the list.

Note the following equivalent version of the perturbation employed by
\verb|PertTwo|, provided that the rowspace of $M$ is an even code.  In
effect, you delete two columns from $M$, add a completely arbitrary column,
and then add a parity check column.

\item {\bf[macro substitution]}
An expression of the type
\begin{center}
$\verb|Sub( {|\hbox{\it definition}_1,\ldots,\hbox{\it definition}_n\verb|}, |%
\hbox{\it body}\verb| )|$ 
\end{center}
is processed by substituting the given definitions
into the body.  A definition takes either the constant form
\par\noindent \kern0.5in \hbox{\it name}\verb| := |{\it definition-body}
\par\noindent or the variable form
\par\noindent \kern0.5in \hbox{\it name}$\verb|(%1|,\ldots,\verb|%|n%
     \verb|) := |$\hbox{\it definition-body}
\par\noindent where in the second case, the definition body may include the
$\verb|%|i$'s.  A {\it name\/} is to be an alphanumeric string (allowing
underscores), which starts with a letter.  Up to nine parameters are allowed.
The output of a substitution is automatically enclosed in parentheses.

\item {\bf[Isomorphic]} Let $A$ and $B$ be of type {\tt MatF2}.  Then 
$\verb|Isomorphic(|A\verb|,|B\verb|)|$ is of type {\tt Bool}.  It is {\tt true}
\IFF\ $A \iso B$, meaning that after applying some permutation to the 
columns of $A$, it has the same rowspace as $B$.

\item {\bf[Isomorphic]}
Let $G$ and $H$ be of type {\tt MatrixGroup(F2)}.  Then 
$\verb|Isomorphic(|G\verb|,|H\verb|)|$ is of type {\tt Bool}.  It is {\tt true}
\IFF\ $A \iso B$, meaning that the representations defined by $G$ and $H$
are isomorphic.  However, this only works with semisimple representations
$G$ and $H$.  Otherwise an error will be issued.

\item {\bf[Classify]} Let $L$ be of type {\tt List(MatrixGroup(F2))}.  Then
APPLY1(Classify,L) is of type {\tt List(Int)}.  It is a list $v$
of positive integers, such that $\setof{A_i}_{i \in v}$ comprise a complete 
set of isomorphism class representatives (for the $L_i$, viewed as
representations).  The $L_i$ must all be semisimple.

\item {\bf[Isomorphic]}
Let $A$ and $B$ be of type {\tt PVSF2}.  Then 
$\verb|Isomorphic(|A\verb|,|B\verb|)|$ is of type {\tt Bool}.  It is {\tt true}
\IFF\ $A \iso B$, meaning that both $A$ and $B$ are partitions of $\F_2^n$
and there exists a linear automorphism of $\F_2^n$ moving one partition to
the other.

\item {\bf[Classify]} Let $A$ be of type {\tt List(PVSF2)}.  Then 
APPLY1(Classify,A) classifies $\vec A1n$ up to isomorphism, returning a 
{\tt List(Int)} $v$ of positive integers, such that $\setof{A_i}_{i \in v}$ 
comprise a complete set of isomorphism class representatives.

\item {\bf[list]} Let $\vec A1n$ be objects of type $\alpha$.  Then 
$\verb|{|A_1\verb|,|\ldots\verb|,|A_n|\verb|}|$ is of type
$\verb|List(|\alpha\verb|)|$, provided that the latter type has been
defined in the class \verb|generic_object|.

\end{itemize}

\par\noindent{\Large\bf Expression list \circno8}

\midhead{The dual transform}

Let $M$ be of type {\tt MatF2}, which is first reduced.
The syntax of this operator is 
\begin{center}
$M$\verb|^T using|\kern5pt$\setof{\VEC w1r}$,
\end{center}
where the $w_i$ are yet to be defined.  Let $C$ be $M$'s row space.  Each $w_i$ 
defines a certain subset $S_i$ of $C$, as follows.  If $w_i$ is a nonnegative
integer, then
$S_i$ is the set of words of weight $w_i$ in $C$.  If $w_i$ has the form 
``$a$\verb|_{|$\VEC b1t$\verb|}|'', where each $b_i$ is a nonzero integer, then 
$S_i$ is the set of words of weight $a$ which for each $j$ have a $1$ in 
position $b_j$ (if $b_j > 0$), and a $0$ in position $-b_j$ (if $b_j < 0$).

\par\noindent{\sc Note.}\ For purposes of display in the program part of this
report, we will write (e.g.) $\ldots$\ {\tt using}
$\{10,12_{\ol{1},2,\ol{5}},20\}$ instead of
$\ldots$\ {\tt using} \verb|{10,12_{-1,2,-5},20}|.

Let $S$ be the multiset $\bigcup_{i=1^r} S_i$.  For $s \in S$, let $\lambda(s)$
denote its coordinate vector \WRT\ the ordered basis given by the rows of $M$.
The value of the dual transform operator is the reduction of the matrix whose 
columns are $\setof{\lambda(s)}_{s \in S}$, in lexicographical order (for 
definiteness).  The output type is {\tt MatF2}.

\midhead{The dual orbit transform}

Let $M$ be of type {\tt MatF2}.  The syntax of this operator is 
\begin{center}
$M$\verb|^T using {|\kern5pt%
$\VEC g1r$\kern5pt\verb|:|\kern5pt$\VEC c1m$\verb|}|,
\end{center}
where $M$ is of type {\tt MatF2}; the $g_i$ and $c_i$ are yet to be defined.  
Let $C$ be $M$'s row space.  Each $g_i$ is to have the form $\verb|$|r$,
where $r \in \N$; it represents the \th{r}\ generating automorphism of
$\Aut(M)$, as computed by {\tt Split}.  As such these automorphisms are
perilously dependent on slight changes to internal routines which might appear
in a future version of {\tt Split}.

Let $\VEC c1m$ be coordinate vectors for elements $\VEC w1m \in C$, relative 
to the rows of $M$.  Let $S$ be the orbit of
$\VEC w1m$ under the given automorphisms, viewed as a subset of $C$ (or a
multiset in $C$ if there is repetition amongst $\VEC w1m$).  Then proceed
as with the dual transform.

\block{More expressions}

This section contains a collection of functions.  We show the source code
here, in a slightly prettified form.  The actual source code is generated
from the prettified source via a program \verb|parse_fun.cc|, which is
included in {\tt CODE}.

\input functions.tex

\block{How to define a configuration}

There are two main ways to define a configuration: the {\tt config} command, 
and the {\tt :=} command.  We describe these first.  Then we describe some
other commands which can be used to define a configuration: {\tt config from},
{\tt incorporate}, and {\tt subdivide along}.

\indexb{config}
\begin{commanddeclaration}
\vbox{\hbox{%
$\displaystyle{\overbrace{\hbox{\tt=}}^{\hbox{optional}}}
\displaystyle{\underbrace{\hbox{\lconfig}}_{\hbox{optional}}}$
{\tt config}\ \ {\it partition} {\tt:} {\it \{basis\}\/} 
$\displaystyle{\overbrace{\hbox{{\tt:} {\it \{dual basis\}}
$\displaystyle{\underbrace{\hbox{{\tt:}\kern5pt{\tt\{}%
\ {\it constraint list\/}\ {\tt\}}}}%
_{\hbox{optional}}}$
}}^{\hbox{optional}}}$ {\tt;}%
}%
\hbox{\footnotesize{\ \ }}%
\hbox{\footnotesize{\sc Note:}\ You never have to write ``{\tt\{\}}'' as
part of this command -- replace it by the null string.}}
\end{commanddeclaration}

This command defines a {\it configuration}.  We illustrate by an example:
\begin{verbatim}
    type [32,14,10_2];
    config 10,10,12 : {110,100};
\end{verbatim}
These two commands tell us that we are looking at even codes of dimension $14$
in $\F_2^{32}$, which contain the following two words: 
\begin{verbatim}
                    1111111111 1111111111 000000000000
                    1111111111 0000000000 000000000000.
\end{verbatim}
(The spaces have been inserted to enhance readability.)  If a dual basis
is given, the dual code is expected to contain the given words.  The elements
of the ``basis'' are expected to be \LI, and likewise for the elements of
the ``dual basis''.  Use of the command 
\par\noindent\kern0.5in{\tt type [}$n${\tt, ...];}
automatically generates the base configuration, as if the 
command ``{\tt config}\ $n$\ \verb|: { };|'' had been executed.

If the {\it constraint list\/} is present, attention is restricted to those
codes which satisfy the given constraints.  A weight enumerator
(e.g.\ \verb|1 + 6t^10 + t^20|) may be given as a ``constraint''.
If a configuration is listed in the constraint list, it is expanded out to
the list of all known global and joint constraints for the given 
configuration.

The optional \lconfig\ is a label which is associated to the 
configuration for future reference.  Within a given code type, a configuration 
label may not be defined more than once.
The labels {\tt[base]} and {\tt[current]} are reserved for reference to
the base and current configurations of the current code type.  More complicated
labels are created by the ``{\tt incorporate}'' ``{\tt:=}'' commands.

The optional ``{\tt=}'' will cause the ``{\tt=}'' command to be automatically
invoked on the configuration defined by this command and the configuration
that was current prior to it.

When a {\tt config} command is entered, aside from syntax, not much is
checked.  The language reserves the right to flag as errors certain things
that no one would do deliberately.  For example, for every word
in the small code, the weight of the associated basic word should be in
the working weight list for the base configuration.

If at the some point it is found that a configuration is unrealizable,
the language interpreter will discard all information about
the configuration except this fact.

\indexb{:=}
\begin{commanddeclaration}
{\it configuration-list\/}\kern5pt\verb|:= |{\it expression}\kern5pt%
$\displaystyle{\underbrace{\hbox{{\tt::}\kern5pt{\tt\{}%
\ {\it constraint list\/}\ {\tt\}}}}%
_{\hbox{optional}}}${\tt;}
\end{commanddeclaration}

Usually the {\it configuration-list\/} consists of a single configuration
\lconfig.  In that case,
create a fully refined configuration named \lconfig\ whose
associated code has the generator matrix given by the expression.
If \lconfig\ is terminal, is expected to be realizable.
If {\it constraint list\/} is supplied, this command also automatically creates
a configuration labelled {\tt[}$\ell${\tt!]} which is basal and has
{\it constraint list\/} for its assumed constraints.  As well, the
implication ${\cal R}(\ell) \IN {\cal R}(\ell\hbox{\tt!})$ is noted.

If the constraint list is ``\verb|{!}|'', it will automatically be replaced
by the list of constraints which defines the weight enumerator of the code.

If {\it configuration-list\/} has more than one configuration in it,
then proceed as above, but the given expression should expand out
to the same number of matrices, and the {\it constraint list\/} is not
allowed (except for the ``\verb|{!}|'' format).

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\def\parwa{3.3in}

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{:= !}{ingredient tracking} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, turn off a safety feature
     which causes a record to be made (in the {\tt hints} directory) of all
     configurations used as ingredients by the {\tt :=} command.  If there
     are a huge number of these, you may want to turn off ingredient tracking.
     \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{config from}
\begin{commanddeclaration}
$\displaystyle{\underbrace{\hbox{\lconfig}}_{\hbox{optional}}}$
{\tt config from }$v_1${\tt|}$\ldots${\tt|}$v_r${\tt;}
\end{commanddeclaration}

Let $v_1$ be a basic local variable for {\tt[current]}.  Show that it is
nonzero, and subdivide along it to obtain a new configuration, which $v_2$
should be a basic local variable for.  Show that $v_2$ is nonzero, and 
subdivide along it.  Continue in this manner.  The last configuration is
made current, and is named \lconfig\ if the optional label is present.

\def\nconfig{{\tt[}$n${\tt]}}

\indexb{incorporate}
\begin{commanddeclaration}
\nconfig\kern5pt{\tt incorporate}\kern5pt\lconfig\kern5pt{\tt below}%
\kern5pt\mconfig\kern5pt{\tt via sub}$w${\tt;}
\end{commanddeclaration}

\par\noindent{\sc Idea:}
\ The fact that one code is known to contain another code may be used to
copy configurations from one code type to another.

\vspace{0.05in}\par\noindent{\sc Requirements:}
\begin{itemize}
\item \lconfig\ is an existing code type, which has no joint variables in its
      assumed constraints, and such that none of its configurations have
      joint variables in their assumed constraints\footnote{Constraints
      which set a basic joint variable to zero are however allowed.};
\item \mconfig\ is a configuration of the current code type, which may not
      have local variables in its assumed constraints, except that it may have
      a constraint {\tt sub}$w$ {\tt=}$g$, for some $g$ (see below);
\item \nconfig\ identifies the given {\tt incorporate} command; it may not be
      used to label any other {\tt incorporate} command within the current
      code type;
\item $w$ is a small word (relative to \mconfig), which has weight $1$
      (as a small word);
\item it must be known that $\verb|sub|w \geq 2^d$, where $d$ is the 
      dimension of the code type referred to by \lconfig;
\item Let $r$ be the part of the partition corresponding to the $1$ in $w$.
      Then the code type referred to by \lconfig\ must have length $r$ and
      dimension $\log_2($\verb|sub|$w)$.  Its assumed weight list must contain
      \mconfig's working weight list.  (Weights greater than $r$ are ignored.)
      Its assumed constraints must lift to known constraints for
      \mconfig, as in the following example:
\begin{verbatim}
     [c] type [30,10,10]{y14 >= 10};
     ...
     [d] type [36,15,10];
     ...
     show mu6 != 0;
     [x] config 30,6 :: {01};
     ...
     show x_14_0 >= 10;
     infer sub10 = 1024;
     [u] incorporate [c] below [x] via sub10;
\end{verbatim}
\end{itemize}

\vspace{0.05in}\par\noindent{\sc Action:}
\ The {\tt incorporate} command causes more or less the entire body of 
information for \lconfig\ to be imported into the current code type, sort of 
below \mconfig.  In particular, each configuration \sconfig\ of \lconfig\ is 
used to generate a configuration \spconfig\ of the current code type.  To do
this it is necessary to carry out a number of conversions:
\begin{itemize}
\item All variables which appear in assumed or known constraints of 
      \sconfig\ are reconstituted in terms of appropriate variables for
      \spconfig.  Global variables are translated into {\tt sub} variables
      or linear combinations of them.  Known constraints involving joint
      variables are lost.
\item Words in the dual small code of \sconfig\ do not induce words in the
      dual small code of \spconfig.  So instead such words are converted into
      assumed constraints involving {\tt q} variables.
\item \spconfig\ has the label {\tt[}$n${\tt->}$s${\tt]}.  Iterative use of 
      incorporate will lead to configurations whose labels have more than one 
      {\tt->} in them.
\end{itemize}
Automorphism labels are unchanged in the process.

Continuing the preceeding example, if code type \verb|[c]| has a configuration
defined via
\begin{verbatim}
    [a] config 8,10,12 : {110,001} :: {y6 <= 4, x_0_1_0 = 0};
\end{verbatim}
then after the {\tt incorporate} command, code type \verb|[d]| will have a
configuration defined as if via
\begin{verbatim}
    [u->a] config 8,10,12,6 : {1100,0010} : {0001} :
                              {sub1110_6 <= 4, x_0_1_0_0 = 0};
\end{verbatim}
although it would not be permissable to make such a definition, since the
label would not be accepted.

\indexb{subdivide along}
\begin{commanddeclaration}
$\displaystyle{\underbrace{\hbox{\lconfig}}_{\hbox{optional}}}$
{\tt subdivide along}\kern5pt$v${\tt;}
\end{commanddeclaration}

Forcibly subdivide {\tt[current]} along the given basic local variable,
passing all known constraints for {\tt[current]} to it.  Label the new
configuration \lconfig, and make it current.

\block{Group manipulation commands}

To each configuration, there is associated a data item which relates
to automorphisms: the list of {\bf known} automorphisms.  These are to be 
viewed as generators.  Some of the automorphisms have labels.

Note that whenever a constraint which sets a basic local variable $v$ to zero
is proved, the program automatically computes the orbit of $v$ under the
group of known automorphisms, and sets all these variables equal to zero.

Here are the commands:

\indexb{automorphism}
\begin{commanddeclaration}
$\displaystyle{\underbrace{\hbox{\lconfig}}_{\hbox{optional}}}$
{\tt automorphism }$\VEC a1r${\tt;}
\end{commanddeclaration}

Verify that the given permutation defines an automorphism of the
current configuration.  Append it to the list of known automorphisms for
the current configuration.  A label \lconfig\ may be given.  Within
a given configuration, automorphism labels may not be repeated.

\indexb{group size}
\begin{commanddeclaration}
{\tt group size = }$m${\tt;}
\end{commanddeclaration}

Verify that the group generated by the list of known automorphisms has $m$ 
elements.  The implementation is very inefficient.

\indexb{full group size}
\begin{commanddeclaration}
{\tt full group size = }$m${\tt;}
\end{commanddeclaration}

Verify that the automorphism group of {\tt[current]} has $m$ elements.  For 
this command, {\tt[current]} may not have local variables in its assumed 
constraints.

\indexb{report group size}
\begin{commanddeclaration}
{\tt report group size [}$\ell_1${\tt]}, $\ldots$\kern2pt, {\tt[}$\ell_r${\tt];}
\end{commanddeclaration}

This is a purely exploratory command.  Given automorphisms
{\tt[}$\ell_1${\tt]}, $\ldots$, {\tt[}$\ell_r${\tt]}, this command reports
in order the size of the group generated by {\tt[}$\ell_1${\tt]}, then
the size of the group generated by {\tt[}$\ell_1${\tt]}, {\tt[}$\ell_2${\tt]},
and so forth, lastly reporting the size of the group generated by
{\tt[}$\ell_1${\tt]}, $\ldots$, {\tt[}$\ell_r${\tt]}.  However, if one of these 
groups turns out to be very large, the command may never finish.  The
implementation is very inefficient.

\indexb{reduce variable set}
\begin{commanddeclaration}
{\tt reduce variable set;}
\end{commanddeclaration}

Compute the automorphism group of the configuration.
From the list of minimal admissible basic local variables $v$ (for
{\tt[current]}), find those which are carried by an automorphism to an 
inadmissible basic local variable, and adjoin the corresponding constraints 
$v = 0$ to the list of known constraints.  Ideally this would be done 
automatically as needed.

\block{Configuration relation makers}

Many of the commands of the language create logical relationships between
configurations.  All of the commands of this section do this.  The
{\tt !config} command does too.  In addition, certain logical relationships
come for free and are automatically known to the language:
\begin{itemize}
\item every configuration \lconfig\ implies the base configuration, 
i.e.\ ${\cal R}(\ell) \IN {\cal R}(\hbox{\tt base})$.
\end{itemize}
All commands in this section leave the current configuration undefined upon 
termination.  

\indexb{via dual nonexistence infer}
\begin{commanddeclaration}
\verb|via dual nonexistence infer [base] = ;|
\end{commanddeclaration}

Assume that the code type has no assumed constraints.  Let $d$ be the
minimum weight in the working weight list $w$ for {\tt[base]}.  Suppose the
minimum weight of the dual code is known to be $\geq d'$.  Suppose we know
that no
\par\noindent\kern0.5in
\verb|[n, n-k, d']{mu1 = 0,|\kern5pt$\ldots$\verb|, mu|$(d-1)$\verb| = 0}|
\par\noindent
code exists.  Then one may infer that {\tt[base]} is unrealizable.  In the
case where $w$ has no odd weights, it is enough to know that no
\par\noindent\kern0.5in
\verb|[n, n-k, d']{mu1 = 0,|\kern5pt$\ldots$\verb|, mu|$(d-1)$\verb| = 0, y|%
\kern1pt$n$\verb| = 1}|
\par\noindent
code exists.

The intended purpose of this command is to bypass numerical instability of
linear programming problems arising from the split linear programming method.
It is useful when $k > n/2$.

\indexb{implies}\indexb{=}
\begin{commanddeclaration}
\vbox{%
\hbox{\lconfig\kern5pt{\tt implies}\kern5pt\mconfig{\tt;}}%
\hbox{\lconfig\kern5pt{\tt =}\kern5pt\mconfig{\tt;}}}
\end{commanddeclaration}

\def\ttvec#1#2#3{$#1_#2${\tt,}$\ldots${\tt,}$#1_#3$}

Let \lconfig, \mconfig\ be configurations.  These commands are placeholders for
the most trivial of trivial implications, whose conclusion in the first
case is that ${\cal R}(\ell) \IN {\cal R}(m)$ and in the second case that
${\cal R}(\ell) = {\cal R}(m)$.  The following cases are handled at present:
\begin{itemize}
\item (for {\tt implies})\ \mconfig\ has the form\\
      \verb|     config |$n$\verb| ::: {|%
      \kern3pt{\it constraint list}\kern3pt\verb|}|\\
      and each of its assumed constraints are known to \lconfig.
\item (for {\tt implies})\ \lconfig, \mconfig\ differ only in their assumed 
      constraints, and every assumed constraint of \mconfig\ is a known 
      constraint of \lconfig.
\item (for {\tt =})\ \lconfig\ has the form\\
      \verb|     config |\ttvec p1r\verb| ::: |$\cal S$\\
      and \mconfig\ has the form\\
      \verb|     config |$n-i$\verb|, |$i$\verb| :: {01} : |$\cal T$,\\
      where $\cal S$ and $\cal T$ contain only global constraints,
      every constraint in $\cal T$ as well as the constraint 
      \verb|mu|\kern1pt$i$\verb| != 0| is known for \lconfig, and every
      constraint in $\cal S$ is either known for \mconfig\ or else is the
      constraint \verb|mu|\kern1pt$i$\verb| != 0|; one may reverse the roles
      of \lconfig\ and \mconfig.  
\item (for {\tt =})\ \lconfig\ has the form\\
      \verb|     config |\ttvec p1r\verb| ::: |$\cal S$\\
      and \mconfig\ has the form\\
      \verb|     config |$i$\verb|, |$n-i$\verb| : {10} :: |$\cal T$,\\
      where $\cal S$ and $\cal T$ contain only global constraints,
      every constraint in $\cal T$ as well as the constraint 
      \verb|y|\kern1pt$i$\verb| != 0| is known for \lconfig, and every
      constraint in $\cal S$ is either known for \mconfig\ or else is the
      constraint \verb|y|\kern1pt$i$\verb| != 0|; one may reverse the roles
      of \lconfig\ and \mconfig.
      The obvious variant when $i = n$ is also allowed.
\item (for {\tt =})\ \mconfig\ is some refinement of
      \lconfig.  For example, one could use:
      \begin{verbatim}
      [l] config 5,4,6 : {100,010} : {001};
      [m] config 5,1,3,6 : {1000,0110} : {0001};
      \end{verbatim}
      No local variables are permitted in the assumed constraints of the 
      configurations.
\item (for {\tt=})\ \lconfig\ and \mconfig\ are realizable full configurations, 
      and their associated basic codes are isomorphic.
\end{itemize}

A large number of the commands in this section have the following general form:

\begin{commanddeclaration}
{\tt via}\kern5pt{\it method}\kern5pt\lconfig\kern5pt{\tt=}\kern5pt%
{\it configuration-list}{\tt;}
\end{commanddeclaration}

Let the configuration-list expand out to \lconfigs.
By the given method, show that the class of codes corresponding to
configuration \lconfig\ equals the union of the classes of codes
corresponding to configurations labelled \lconfigs.
In the degenerate case ``\lconfig\ {\tt=}\ {\tt;}'' one in effect shows that
no codes have configuration \lconfig.  The case
``\lconfig\ {\tt=}\ {\tt[}$\ell_1${\tt];}'' is also in general permissable.  
Note however that you cannot in general replace this by 
``{\tt[}$\ell_1${\tt]}\ {\tt=}\ \lconfig'': the conclusion would be the same, 
but the method may not be smart enough to handle the reversal.

\indexb{via lp}
\begin{commanddeclaration}
{\tt via lp}\kern5pt\superopt{{\tt(}\it lp-specifier{\tt)}}\kern5pt%
     {\it configuration-list}\kern5pt{\tt= ;}
\end{commanddeclaration}

The optional {\it lp-specifier\/} should be a comma-separated list
of one or more of the following optional arguments:
\begin{itemize}
\item ``{\tt joint}'' or ``{\tt joint:}$r$'', where $r \geq 0$
\item ``{\tt common}''
\item ``{\tt iterate<}{\it variable list}{\tt>}'', where {\it variable list}
      is a comma-separated list of variables, allowing for the abbreviation
      {\tt y*}.
\end{itemize}

For each configuration \lconfig\ in the expansion of the configuration-list, 
proceed as follows.

If the optional joint argument is present, use joint linear programming to 
deduce (if possible) that \lconfig\ leads to a contradiction.  (If the second
form of the joint argument is used, the parameter
``{\tt use dual dual for joint}'' is set to $r$ prior to executing the
{\tt show}, and then restored to its original value afterwards.)
Otherwise, try to do this with split linear programming.  However,
to save time, the program will first attempt to determine if some known 
constraints are ``blatantly'' contradictory.  Thus if we know that
$y_{10} \geq 80$ and $y_{10} \leq 79$, then no calculation is required.  For
example, one might use a command sequence of the form
\begin{verbatim}
     config ... ;
     show 79 < y10 < 80;
     via lp [current] = ;
\end{verbatim}
to exploit the fact that a variable does not take on an integer value.
Similarly, if there is a known constraint of the form {\tt y}$i$ {\tt != 0},
where $i$ is not in the working weight list of {\tt[current]}, then no 
calculation is required.

If the optional iterate argument is present, use integer linear programming
to get a contradiction, by successively bounding the given variables.  If
the {\tt common} option is used, use both joint and split linear programming.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt via lp ! quiet} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, show information about what
     is happening during execution of the command.  \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{via lp}
\begin{commanddeclaration}
{\tt !via lp}\kern5pt\lconfig\kern5pt{\tt= ;}
\end{commanddeclaration}

Run ``{\tt via lp}\kern5pt\lconfig\kern5pt{\tt= ;}'' with the expectation
that it will fail, and confirm that failure, by temporarily turning on
the parameter ``{\tt verify feasibility}''.

\def\lpconfig{{\tt[}$\ell'${\tt]}}

\indexb{via variable split}
\begin{commanddeclaration}
{\tt via variable split}\kern5pt\lconfig\kern5pt{\tt =}\kern5pt%
{\tt[}$\ell_1${\tt]}\kern5pt{\tt or}\kern5pt$\ldots$\kern5pt{\tt or}%
\kern5pt{\tt[}$\ell_r${\tt];}
\end{commanddeclaration}

\def\liconfig{{\tt[}$\ell_i${\tt]}}
\def\ljconfig{{\tt[}$\ell_j${\tt]}}

\par\noindent{\sc Idea:}
\ A given configuration \lconfig\ may be broken up into several cases by
making assumptions about the values of specified variables.

\vspace{0.05in}\par\noindent{\sc Requirements:}
\ The given configurations \lconfig, \lconfigs\ may differ only in their
assumed constraints.  Every assumed constraint of \lconfig\ must also
be an assumed constraint of \liconfig, for each $i$.  Apart from these shared
constraints, all assumed constraints must be simple.

\vspace{0.05in}\par\noindent{\sc Action:}
\ Analyze the constraints not shared by all of \lconfig, \lconfigs, and 
deduce from these that 
${\cal R}(\ell) = {\cal R}(\ell_1) \manycup {\cal R}(\ell_r)$.

\def\clabel{{\tt[}$c${\tt]}}
\def\yieqr{{\tt y}$i${\tt\ = }$r$}

\indexb{via configuration search}
\begin{commanddeclaration}
{\tt via configuration search}\kern5pt\lconfig\kern5pt{\tt implies}%
\kern5pt\mconfig{\tt;}
\end{commanddeclaration}

\par\noindent{\sc Idea:}\ One can check to see if a code realizes a
particular $r$-dimensional configuration by explicitly checking each
$r$-tuple of elements of the code.

\vspace{0.05in}\par\noindent{\sc Requirements:}\ The configuration 
\lconfig\ must be terminal.  The configuration \mconfig\ must have zero dual
small code, and each of its assumed constraints must be known to
\lconfig.

\vspace{0.05in}\par\noindent{\sc Action:}\ Let $C$ be the code associated to
\lconfig.  Let $\VEC w1r$ be the basic words associated to the basis elements
for the small code of \mconfig.  Call an $r$-tuple $\VEC v1r \in C$ an
\mconfig-{\it configuration\/} if for all subsets $S \IN \setof{1,\ldots,r}$,
we have $\abs{\cap_{i \in S} v_i} = \abs{\cap_{i \in S} w_i}$.  By an explicit
search, determine if $C$ has an \mconfig-configuration.  If it does, conclude
that ${\cal R}(\ell) \IN {\cal R}(m)$.  Otherwise
${\cal R}(\ell) \notIN {\cal R}(m)$ and the command fails.  The current
implementation is deathly slow if $r$ is large.

\vspace{0.05in}\par\noindent{\sc Notes:}\ Let $\lambda_C(m) = $ the number of
\mconfig-configurations in $C$.  As \mconfig\ ranges over all one-dimensional
configurations, the information carried by $\lambda_C(m)$ is equivalent to
the information carried by the weight enumerator of $C$.  As \mconfig\ ranges
over two-dimensional configurations, we similarly obtain the information
carried by the joint weight enumerator of $C$ with itself (see 
[.macwilliams sloane book.]\ p.\ 147 for the definition
of joint weight enumerator).

This command will utilize the ordered basis given explicitly for \mconfig,
if possible, instead of the \RREF\ basis which is automatically computed
for each configuration.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\ttext{via configuration}{search !}{go to end} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, do not stop after finding
     a single configuration.  \vskip 0.05in}\\ \hline
\ttext{via configuration}{search !}{group level} & $\geq 0$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in This governs the extent to which 
     automorphisms will be used to prune the search.  If set to $0$, not at
     all.  If set to $1$, generators for the automorphism group are computed
     and used at the first stage.  If set to $\geq 2$, the full automorphism
     group is computed and used up to the indicated stage.  
     \vskip 0.05in}\\ \hline
\ttext{via configuration}{search !}{group size cap} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value, when computing
     the full automorphism group, stop after the given number of elements.
     \vskip 0.05in}\\ \hline
\ttext{via configuration}{search !}{show example} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, exhibit an example of
     the configuration, if it exists.  \vskip 0.05in}\\ \hline
\ttext{via configuration}{search !}{expand final count} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, compute the total number
     of subcodes of \lconfig\ which are isomorphic to \mconfig.  You must
     use ``{\tt go to end}'' (see above) for this to take effect.  In
     addition, you should have a positive value set for 
     ``{\tt group level}'' (see above), as otherwise the expansion would not
     have any effect.  \vskip 0.05in}\\ \hline
\ttext{via configuration}{search !}{print final list} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, print the final list,
     expanded if ``{\tt expand final count}'' (see above) was used.
     \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{via unique wordtypes}
\begin{commanddeclaration}
{\tt via unique wordtypes}\kern5pt\lconfig\kern5pt{\tt implies}\kern5pt%
\mconfig{\tt;}
\end{commanddeclaration}

The conclusion is that ${\cal R}(\ell) \IN {\cal R}(m)$.  The configuration
\mconfig\ must be terminal and realizable, and it must be known already that
${\cal R}(m) \IN {\cal R}(\ell)$.  It must be known that the basic code
associated to \lconfig\ contains all possible codewords, except for words of
one weight.  The justification for this command is:

\begin{lemma}
Let $C$ be a code in $\F_2^n$.  Then for fixed $k$ and $q$, there exists (up to
isomorphism) at most one $k$-dimensional code $D$ in $\F_2^n$ which contains
$C$ and which has the property that $\abs{v} = q$ for all $v \in D - C$.
\end{lemma}

\begin{proof}
First consider a projective code $E \IN \F_2^r$ of dimension $m$.  Form the 
zero-one matrix $M$ whose rows are the nonzero elements of $E$.  I claim that 
if one regards the columns of $M$ as vectors over $\Q$, they are independent.  
To see this, let $B$ be a generator matrix for $E$.  By adding columns to $B$, 
we obtain a matrix $B'$ in which each nonzero element of $\F_2^m$ appears as a
column exactly once.  Let $M'$ be the zero-one matrix whose rows are the nonzero
elements of the row space of $B'$.  It is enough to show that the columns of 
$M'$ are $\Q$-independent.  But $M'$ is square, so it is enough to show that 
its rows are $\Q$-independent.

Now consider the set $S$ of functions \mapx[[ \F_2^m - \setof{0} || \F_2 ]] 
which are given by a nonzero, homogeneous, degree one element of 
$\F_2[\VEC x1m]$.  Form the zero-one matrix $N'$ whose rows correspond to 
the elements of $S$.  (One has to choose an order for the elements of 
$\F_2^m - \setof{0}$.)  As an $\F_2$-basis for $S \cup \setof{0}$ is given by 
$\VEC x1m$, we see the rows of $N'$ corresponding to this basis are the same 
(up to permutation of columns) as the rows of $B'$, and hence $N' = M'$, modulo
permutation of columns.

Thinking in characteristic zero, view $\setof{0,1}$ as a subset of $\Q$, and 
regard the elements of $S$ as functions
\mapx[[ \setof{0,1}^m - \setof{0} || \setof{0,1} ]].  I claim that these
functions are $\Q$-linearly independent.  The idea is as follows.  The
function $x_1$ over $\F_2$ is also represented by $x_1$ over $\Q$.  The
function $x_1+x_2$ over $\F_2$ is represented by $x_1+x_2-2x_1x_2$ over $\Q$.
The function $x_1+x_2+x_3$ over $\F_2$ is represented by
$x_1+x_2+x_3-2x_1x_2-2x_2x_3-2x_1x_3+4x_1x_2x_3$ over $\Q$.  The function
$x_1+x_2+x_3+x_4$ over $\F_2$ is represented by
$x_1+x_2+x_3+x_4-2x_1x_2-2x_1x_3-2x_1x_4-2x_2x_3-2x_2x_4-2x_3x_4
+4(x_1x_2x_3 + x_1x_3x_4 + x_1x_2x_4 + x_2x_3x_4 ) - 8x_1x_2x_3x_4$ over $\Q$. 
Let $V$ be the subspace of $\Q[\VEC x1m]$ having as a basis the monomials of
degree $d$ ($1 \leq d \leq m$) in which no exponent greater than $1$ appears.
Note that if $f \in V$ induces the zero function
\mapx[[ \setof{0,1}^m - \setof{0} || \setof{0,1} ]], then $f = 0$.  Thus 
we see that the elements of the $\Q$-linear span of $S$ may be identified with 
the elements of $V$.  But $\dim(V) = \abs{S}$, so it follows that the 
elements of $S$ are $\Q$-linearly independent.  Hence the rows of $M'$ are 
independent over $\Q$, and so the columns of $M$ are $\Q$-independent.

Now choose an ordered basis for $C$ and use it to define a configuration, whose 
small code $E$ is projective.  I claim that this configuration has at most one 
nontrivial wordtype, up to equivalence.  Indeed, a nontrivial wordtype
for this configuration [say $(\VEC w1r)$] must satisfy one equation for
each nonzero element $x$ of $E$: $\sum_{i=1}^r x_i w_i = \abs{x}/2$, where
$\abs{x}$ is the weight of the basic word associated to $x$.  The
coefficient matrix of this system of equations is $M$, which we have shown
has $\Q$-independent columns.  Hence the system has at most one solution,
which proves the lemma in the case where $k = \dim(C) + 1$.  The general
case follows by induction.  \qed
\end{proof}

\indexb{via extension}
\begin{commanddeclaration}
{\tt via extension}\kern5pt$\hbox{\it configuration-list}_1$%
\kern5pt{\tt implies}\kern5pt$\hbox{\it configuration-list}_2${\tt;}
\end{commanddeclaration}

The program expands $\hbox{\it configuration-list}_1$ and runs the command
once with \lconfig\ set to an element of this list.
Let $\hbox{\it configuration-list}_2$ expand to \lconfigs.
The last configuration {\tt[}$\ell_r${\tt]} may have the form 
{\tt[}$\alpha$\verb|#]|, which is explained below.

Let $D$ be the subcode associated to the small code of \lconfig.
Search for all extensions of $D$ to codes which realize the code
type, and using this information, attempt to show that
$${\cal R}(\ell) \IN {\cal R}(\ell_1) \manycup {\cal R}(\ell_r).$$%
However, in the special case where {\tt[}$\ell_r${\tt]} has the form
{\tt[}$\alpha$\verb|#]|, any codes in ${\cal R}(\ell)$ which do not lie in 
${\cal R}(\ell_1) \manycup {\cal R}(\ell_{r-1})$ are placed in 
(newly created) terminal configurations
{\tt[}$\alpha${\tt1]}, {\tt[}$\alpha${\tt2]}, $\ldots$.  (One should not
rely on the ordering of these.)

To use this command, the partition of \lconfig\ must have the
form $1,\ldots,1,r$, for some $r$, and the smallcode of \lconfig\ must be 
confined to the first $n-r$ bits.  Also it must be the case that
$$r + \dim(\hbox{\lconfig}) \geq k.\eqno(*)$$%

When the extensions have been found, their weight enumerators are computed,
and the extensions are matched against
the given configurations, according to the following scheme:
\begin{itemize}
\item Any of the extensions which match a given basal configuration are
      checked off.
\item If there are any configurations which are neither basal or terminal,
      we determine if any of the extensions match them by means of a
      configuration search.
\item The terminal configurations in \lconfigs\ are then compared with the 
      remaining extensions.
\end{itemize}

The right hand side of the command could be empty, in which case it is
expected that no extensions will be found.  

If the inequality in $(*)$ is strict, refine
to get a partition $1,\ldots,1,r-1$ or $1,\ldots,1,r-2$, etc.  Then after
adjusting $r$, \WMAT\ $(*)$ is an equality.  We then apply the method of
\S\ref{extension-section}.  Note that to be admissible,
the weight list of $D_j$ must be contained in the working weight list 
\lconfig.

We do not know of any practical rules to help pick the group $G$, beyond the 
obvious comment that it is advantageous for it to be large, but not too large.
In the current version of the program, if ``{\tt alternate extension method}''
is set, we use the known automorphism group for $G$.  Otherwise, we use
$200$ elements of it (after the first step), and we also use a slightly 
different method for determining minimality.

\par\noindent{\sc Note.}\ To use this command as an exploratory tool, first
``{\tt unset warnings are fatal}'', and then use
\par\noindent\kern0.5in
{\tt via extension}\kern5pt\lconfig\kern5pt{\tt implies ;}
\par\noindent
if you only want to know the weight enumerators of the extensions, or
\par\noindent\kern0.5in
{\tt via extension}\kern5pt\lconfig\kern5pt{\tt implies [base];}
\par\noindent if you want to see all the extensions.

\indexb{via building}
\begin{commanddeclaration}
{\tt via building}\kern5pt$\hbox{\it configuration-list}_1$%
\kern5pt{\tt implies}\kern5pt$\hbox{\it configuration-list}_2${\tt;}
\end{commanddeclaration}

The command is repeated with \mconfig\ ranging over the elements of
$\hbox{\it configuration-list}_1$.

Let $\hbox{\it configuration-list}_2$ expand to \lconfigs.  The last 
configuration {\tt[}$\ell_r${\tt]} may have the form {\tt[}$\alpha$\verb|#]|, 
as in the \verb|via extension| command.  In that case the newly created 
configurations will always be converted to refined configurations.

\vspace{0.05in}\par\noindent{\sc Goal:}\ Show that 
$${\cal R}(m) \IN {\cal R}(\ell_1) \manycup {\cal R}(\ell_r).$$%
Do this by constructing a complete set $S$ of isomorphism class representatives
for configurations which can be obtained by iterated subdivision of
{\tt[current]}.  (Obviously, if $S$ is gargantuan, the program will run out
of memory.) For those configurations which are terminal, proceed as in
the ``{\tt via extension}'' command to match them with \lorconfigs.  

In outline, here is the algorithm used to find the set of isomorphism class
representatives:

\begin{verbatim}
list := { ( [m], {nontrivial minimal admissible wordtypes for [m]}, 
          true ) };
repeat {  pick p from those members of list whose 3rd member is true;
          (Exit if there isn't one.)
          wt := p.2nd, modulo the action of Aut( p.1st );
          loop over w in wt
          {    c := subdivision of p.1st along w;
               s := {nontrivial minimal admissible wordtypes for c};
               (Obtained by considering those wordtypes of c which subdivide 
                    an element of p.2nd.)
               if ( c is not isomorphic to any config in list )
                    append (c, s, false) to list;    }
          p.3rd = false;    }
\end{verbatim}

\vspace{0.1in}
\par\noindent 
Each configuration is printed as it is encountered.  Known assumed and 
local constraints for \mconfig\ are ignored, except at the first step.  

In case $r = 1$ and the single configuration \config{\ell_1} is basal with
a single assumed constraint of the form $y_i \leq m$, the procedure is modified,
as follows.  When we first compute {\tt list}, instead of using all
nontrivial minimal admissible wordtypes for \mconfig, we use only those which
are equivalent to a wordtype of weight $i$.  As a result, {\tt s} gets
modified in the same way.  If we ever encounter a configuration with
$y_i > m$, exit with error.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{via building !}{show terminals} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, show terminal configurations
     as they are encountered.  \vskip 0.05in}\\ \hline
\dtext{via building !}{show all configs} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, show all configurations
     as they are encountered.  \vskip 0.05in}\\ \hline
\dtext{via building !}{show extra info} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, issue various informative
     messages as configurations are processed.  Verbose. \vskip 0.05in}\\ \hline
\dtext{via building !}{auto macaulay} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, terminal configurations
     will be piped to the {\tt macaulay} command.  This option turns on
     the ``{\tt show terminals option}''.  \vskip 0.05in}\\ \hline
\dtext{via building !}{depth first} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, always process the highest 
     dimensional outstanding configuration first.  This conceivably could be
     useful for finding examples.  \vskip 0.05in}\\ \hline
\dtext{via building !}{use joint variables} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, use information about joint
     variables to prune the search.  \vskip 0.05in}\\ \hline
\dtext{via building !}{max create} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value, do not allow
     the creation of more than the given number of configurations, as in
     the {\tt[}$\alpha${\tt\#]} form.  \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{via varying}
\begin{commanddeclaration}
{\tt via varying y}$i$\kern5pt{\tt[current] implies}\kern5pt
{\tt[}$\ell_1${\tt]}\kern5pt{\tt or}\kern5pt$\ldots$\kern5pt{\tt or}%
\kern5pt{\tt[}$\ell_r${\tt];}
\end{commanddeclaration}

This is an extremely primitive facility for analyzing the integer solutions of 
the system of inequalities associated by split linear programming to 
{\tt[current]}.  Each \ljconfig\ must
be basal.  Each must have an assumed constraint of the form
$\hbox{\tt y}_i = m_j$.  The $m_j$'s must all be distinct, and must form
a list of consecutive integers (after reordering if necessary).  For purposes
of explanation, assume that they are already in order.  First show that
$m_1 \leq \hbox{\tt y}_i \leq m_r$.  Then show that for each $j$, if one assumes
that $\hbox{\tt y}_i = m_j$, then all the other assumed constraints of
\ljconfig\ are satisfied.  In total, the calculation is equivalent to
$r+1$ {\tt show} commands.

\indexb{disjoint}
\begin{commanddeclaration}
{\tt disjoint }{\it configuration-list}{\tt;}
\end{commanddeclaration}

Let {\it configuration-list\/} expand out to \lconfigs.  Verify that for each 
$i \not= j$, ${\cal R}(\ell_i) \cap {\cal R}(\ell_j) = \emptyset$, using the 
following procedure:
\begin{itemize}
\item Attempt to show that known constraints of \liconfig\ contradict
      known constraints of \ljconfig.  The program will only find
      explicit single variable contradictions, e.g.\ if \liconfig\ has
      \verb|y10 = 4| but \ljconfig\ has \verb|y10 >= 11|.  If a contradiction
      is found, we're done.  (A better way to do this would be to merge
      the known constraints from the two configurations, and apply 
      linear programming, expecting a contradiction.)
\item In case both configurations are terminal, show that they are not
      isomorphic.
\item Assuming that one of the two configurations (\WLOG\ \liconfig) is 
      terminal, by explicit search obtain a contradiction from the small code 
      of \ljconfig.  This is only practical if the dimension of 
      \ljconfig\ is very small.  The current implementation is very inefficient.
\end{itemize}
The command will fail if a contradiction is not obtained by one of the
above steps.

\indexb{classification of}
\begin{commanddeclaration}
{\tt classification of }\mconfig{\tt:}\kern7pt%
\superopt{\hbox{{\it justification}\kern5pt$\Longrightarrow$}}%
\kern5pt{\it configuration-list}{\tt;}
\end{commanddeclaration}

The configuration-list is expanded out to \lconfigs.
We first describe what the command does when the optional part is absent.  It 
will make a logical deduction from known facts, by verifying that ${\cal R}(m)$ 
is the disjoint union of ${\cal R}(\ell_1),\ldots {\cal R}(\ell_r)$ and 
moreover that each ${\cal R}(\ell_i)$ is nonempty.  If needed, this command 
will invoke {\tt disjoint} for 
{\tt[}$\ell_1${\tt]}, $\ldots$, {\tt[}$\ell_r${\tt]}, and moreover try to
show that they are all realizable.

The classification command (as implemented) does not generally add logical
data to the current configuration.  However, in the special case where
$r = 0$, the command will set configuration \mconfig\ to unrealizable, and
in the special case where $r = 1$, the command will take note of the
corresponding implication.

Any elements of the working weightlist of \mconfig\ which do not appear in
any of the working weightlists of 
{\tt[}$\ell_1${\tt]}, $\ldots$, {\tt[}$\ell_r${\tt]}
are deleted from the working weightlist of \mconfig.

Now suppose that the optional part is present, and the 
{\it justification\/} has the form ``$v_1${\tt|}$\ldots${\tt|}$v_r$''.
Then the command is expanded to:
\par\noindent\kern0.5in{\tt at }\mconfig{\tt;}
\par\noindent\kern0.5in{\tt config from }$v_1${\tt|}$\ldots${\tt|}$v_r${\tt;}
\par\noindent\kern0.5in{\tt via building [current] implies }\lconfigs{\tt;}
\par\noindent\kern0.5in{\tt classification of }\mconfig{\tt:}\kern5pt%
\lconfigs{\tt;}
\par\noindent For input to {\tt Split}, the symbol $\Longrightarrow$ should be 
encoded as the ascii sequence ``{\tt -->}''.

Now suppose that the optional part is present, and the 
{\it justification\/} has the form 
{\tt[}{\it type}{\tt->}{\it config list}{\tt]}, where {\it type\/} is the name 
of a preexisting code type with parameters $[n0, k0]$, and {\it config list\/} 
is a list of configurations for it; the following are examples of the allowed 
formats: \verb|[17_5_8->a]|, \verb|[17_5_8->{a,b,c}]|, \verb|[28_10_10->g*]|,
\verb|[28_10_10->{g*.a}]|.

In this case, \mconfig\ must be basal; let $\cal T$ be its assumed constraints.
Let $r = n-n0$; we require that $r = k-k0$ or $r = k-k0+1$.
Then the command is expanded to:

\par\noindent\kern0.5in\verb|at|\kern5pt\mconfig;
\par\noindent\kern0.5in\verb|show mu|$r$\kern5pt\verb|!= 0;|%
\kern1in(if $r = k - k0 + 1$)
\par\noindent\kern0.5in\verb|=config n0, n - n0 ::: {|$\cal T$\verb|};|%
\kern1in(if $r = k - k0$)
\par\noindent\kern0.5in\verb|=config n0, n - n0 :: {01} : {|$\cal T$\verb|};|%
\kern1in(if $r = k - k0 + 1$)
\par\noindent\kern0.5in{\tt[}{\it type}{\tt] incorporate [}{\it type}%
{\tt] below [current] via sub10;}
\par\noindent\kern0.5in{\tt via extension [}{\it type}{\tt->}{\it config list}%
{\tt] implies}\kern5pt\lconfigs{\tt;}
\par\noindent\kern0.5in{\tt classification of }\mconfig{\tt:}\kern5pt%
\lconfigs{\tt;}

Finally suppose that the optional part is present, that the 
{\it justification\/} has the form $\verb|Unresidue(|\ldots\verb|)|$, and that
{\it configuration-list\/} is empty.  The the program will attempt to show
that the expression $\verb|Unresidue(|\ldots\verb|)|$ is an empty list of 
matrices and attempt to thereby deduce that \mconfig is unrealizable.

Here is a special situation which the ``{\tt classification of}'' command
checks for.  Suppose it is known (or can be shown easily) that codes in the 
code type are projective and that they all have a word of weight $2^{k-1}$.
Let $d$ be the minimum weight appearing in the weightlist of the codetype's
definition.  Suppose that $[n - 2^{k-1}, k - 1, d - 2^{k-2}]$ codes have been
classified: $\VEC C1r$.  Then a complete classification for the base
configuration of the current codetype 
is obtained from the list $\verb|P(|C_1\verb|)|, \ldots, \verb|P(|C_r\verb|)|$
by dropping isomorphic codes and dropping unrealizable codes.

The command also checks for certain $[n,k,d]$ Griesmer codes (i.e.\ codes at 
the Griesmer bound) which are known to be unique:
\begin{itemize}
\item $d = 2^{k-2} + 2$, where $k \geq 3$ and $k \not= 5$.  Uniqueness was
      proved by van Tilborg [.tilborg griesmer 1980.].  This code can be 
      described in {\tt Split} by $\verb|P(Even(|k-1\verb|))|$.
\item $d = 2^{k-1} - 2^{u-1}$, where $1 \leq u \leq k-1$.  Uniqueness was
      proved by van Tilborg [.tilborg griesmer 1980.].
\item $d = 2^{k-1} - 2^{a-1} - 2^{b-1}$, where $a > b > 0$, $k \geq a + b$, 
      and $(a,b) \not= (3,2)$.  Then 
      there is a unique such code.  This code is a very simple sort of 
      Solomon-Stiffler code, which can be described in {\tt Split} by
\par\noindent\kern0.5in%
$\verb|P(|\cdots\verb|P( Simp(|a\verb|) # Simp(|b\verb|) )|\cdots\verb|)|$
\par\noindent where there are $k - a - b$ \verb|P|'s or
$\verb|Off(Diag(Proj(|a\verb|),Proj(|b\verb|),{0},|\ldots\verb|,{0}))|$,
\par\noindent where there are $k - a - b$ copies of \verb|{0}|.
\end{itemize}

If {\it configuration-list\/} has the form
{\tt[}$\alpha${\tt1..}$r${\tt]} for some alphabetic string $\alpha$, and
some $r > 1$, and exactly this configuration-list has been previously
defined via a {\tt :=} command to be something of the form
$\verb|Unresidue(| \ldots \verb|)|$, or
$\verb|Build(| \ldots \verb|)|$, or
$\ldots \verb| - column|$, and if one should be able to deduce
the classification from this, then one can.  

\indexb{$\Longleftrightarrow$}
\begin{commanddeclaration}
\lconfig\ $\Longleftrightarrow$\ \mconfigs\ {\tt :=}\ {\it stuff\/}{\tt;}
\end{commanddeclaration}

This is an abbreviation, which expands into

\vspace{0.1in}

\par\noindent\mconfig\ {\tt :=}\ {\it stuff\/}{\tt;}
\par\noindent\verb|classification of |\lconfig\verb|: |\mconfigs{\tt;}

\vspace{0.1in}

The $\Longleftrightarrow$ is actually ``{\tt <-->}''.

\block{Constraint generators and weight killers}

The commands of this section use various methods to prove that certain 
constraints hold for the current configuration.  Some also create other 
configurations, and create edges from the current configuration to these
new ones.  The current configuration is still current upon completion.

When a command from this section shows that a basic local variable is nonzero,
the current (parent) configuration is subdivided, and thus a new (child)
configuration is created.  A constructive edge is created from the parent
configuration to the child configuration.

To a very limited extent, constraints involving local variables are translated
from the parent configuration to the child configuration.  Specifically, any
constraint of the form $v = 0$ ($v$ a basic local variable), which is known
at the time the child configuration is created, gets passed to it, and is
used to reduce the number of admissible basic local variables for the child
configuration.

\def\constraintor{$\hbox{\it constraint}_1, \ldots, 
     \hbox{\it constraint\kern1pt}_r$}
\def\constrainti{$\hbox{\it constraint\kern1pt}_i$}

\indexb{show}
\begin{commanddeclaration}
{\tt show}\kern5pt\superopt{{\tt(}{\it optional\ arguments}{\tt)}}%
\kern5pt\constraintor{\tt;}
\end{commanddeclaration}

The optional arguments are to be a comma-separated list of items, selected from
``{\tt iterate}'', ``{\tt common}'',
``{\tt joint}'', and ``{\tt joint:}$r$'', where $r \geq 0$.

This command causes the program to attempt to simultaneously verify
the given constraints by split linear programming (or joint linear programming,
if the joint argument is present).  In the joint case, if the second
form of the joint argument is used, the parameter
``{\tt use dual dual for joint}'' is set to $r$ prior to executing the
{\tt show}, and then restored to its original value afterwards.

The order of the constraints is irrelevant; one may use separate ``{\tt show}''
commands if the verification of one constraint depends on knowledge of another.
(This will be slower.)  Assuming that verification succeeds, the constraints 
are then added to the list of constraints known for the current configuration.
If verification fails, execution is terminated.

Some short cuts are employed to avoid linear programming. First, if 
{\tt[current]} has up to equivalence exactly one admissible basic local 
variable $v$ aside from the trivial basic local variable, and the dimension of 
{\tt[current]} is less than the dimension of the code type, then a constraint 
of the form $v != 0$ will be accepted without split linear programming, since 
it is true.

Second, suppose that every admissible local variable of weight $i$ except one
(say $v$) is equivalent to the trivial basic local variable, and it is known
that $y_i$ exceeds the number of words of weight $i$ in the basic code 
associated to the small code.  Then $v != 0$ will be accepted without split
linear programming.

Third, suppose that there are $r$ words of weight $i$ in the basic code 
associated to the small code, and that every admissible basic local variable of 
weight $i$ is equivalent to the trivial basic local variable.  Then the 
constraint {\tt y}$i$\verb| <= |$r$ will be accepted without split linear 
programming.  (If $r = 0$, one can write ``\verb|=|'' instead of ``\verb|<=|''.)

If the optional argument ``{\tt iterate}'' is present, the program will
attempt to arrive at the given constraints by a sequence of steps, 
yielding successively stronger bounds on the variables (appearing in the
given constraints) until the given constraints are arrived at.

If the optional argument ``{\tt common}'' is present, the ``{\tt iterate}''
option is automatically invoked, but in doing its iterations, the program
will attempt to use both joint and split linear programming.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt show ! quiet} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, show information about what
     is happening during execution of the command.  \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{check secondary residuals}
\begin{commanddeclaration}
{\tt check secondary residuals;}
\end{commanddeclaration}

This does nothing unless the parameter ``{\tt secondary plus}'' is set.
In that case, let $v$ be a basic local variable for {\tt[current]}.
Let \lconfig\ be the subdivision of {\tt[current]} along $v$.  Form
a list $L$ of all admissible basic local variables for \lconfig.  

Let $r$ be the number of parts in the partition of \lconfig.  For each 
$w \in \F_2^r$, consider the subcode $S$ of $C$ supported on $w$, and the 
projection $P$ of $C$ onto the complement of $w$.  Find all variables in
$L$ supported on $S$, and use this to get a lower bound on the minimum distance
of $S$.  Then use known nonexistence results for codes with particular
parameters to obtain an upper bound for $\dim(S)$.

This gives a lower bound (say $k_P$) on $\dim(P)$.  Again look through $L$ to 
get a lower bound $d_P$ on the minimum distance of $P$.  Let $n_P$ denote
the length of $P$.  If we know that there is no $[n_P,k_P,d_P]$ code, we 
deduce that $v = 0$.

The process of the preceding paragraph is carried out for each $v$, and in
the event of a single success, it is repeated (over and over if need be).
This is necessary in the interest of robustness, as otherwise the ordering
of the basic local variables for {\tt[current]} could effect the outcome.
Note also that in the interest of efficiency, we do not actually compute 
\lconfig, and instead work with a set of basic local variables for it which may 
include some inadmissible ones.

\indexb{infer}
\begin{commanddeclaration}
\subopt{\hbox{{\tt@}\lconfig}}\kern5pt{\tt infer}\ \constraintor{\tt;}
\end{commanddeclaration}

If {\tt@}\lconfig\ is used, first set the current configuration to \lconfig.
Then use accumulated data on nonexistence of codes or configurations to deduce 
that ${\it constraint}_i$ holds for {\tt[current]}, for each $i$.  Various 
methods of deduction are known to this program:
\begin{itemize}
\item Suppose that the constraint $\alpha \geq r$ is known for {\tt[current]},
      for some variable $\alpha$ and some integer $r$,
      and that the configuration obtained from {\tt[current]} by adjoining the
      constraint $\alpha = r$ is known to be unrealizable.  Then one may infer
      the constraint $\alpha \geq r + 1$.
\item Suppose that the constraint $\alpha \leq r$ is known for {\tt[current]},
      for some variable $\alpha$ and some integer $r$,
      and that the configuration obtained from {\tt[current]} by adjoining the
      constraint $\alpha = r$ is known to be unrealizable.  Then one may infer
      the constraint $\alpha \leq r - 1$.  A similar inference is possible
      when $\leq$ is replaced by $\geq$.
\item Let $d' \in \N$.  If the configuration 
      $n-d'${\tt, }$d'$\verb| :: {01}| is known to be unrealizable,
      then one can infer \verb|mu|\kern1pt$d'\verb| = 0|$.
\item If the configuration $i$\verb|,|\kern5pt$n-i$\verb| : {10}| is 
      known to be unrealizable, then one can infer \verb|y|$i$\verb| = 0|.
\item You can infer that $\verb|div2| \geq 2^{k-1}$.  If you know that 
      $\verb|div2| > 2^{k-1}$, then you can infer that $\verb|div2| = 2^k$.
\item Let $S$ be the working weight list for the current configuration.  
      Suppose that $S \IN 2\Z$.  A result of Brouwer
      ([.brouwer linear programming bound.], IV, Proposition) gives us
      information about {\tt div4}.  First, {\tt div4} must lie in the set
      $$2^{k-1} - 2^{k-2}, 2^{k-1} - 2^{k-3}, \ldots, 2^{k-1} - 2^0,
      2^{k-1}, 2^{k-1} + 2^0, 2^{k-1} + 2^1, \ldots, 2^{k-1} + 2^{k-1}.$$%
      If we know that there is no $[n,k,S \cap 4\Z]$ code, then of course the
      last possibility may be ruled out.  Further, if for some $r \leq k-1$
      we know that there is no $[n,r,S \cap 4\Z]$ code, it follows that
      {\tt div4} must lie in the set
      $$2^{k-1} - 2^{r-1}, 2^{k-1} - 2^{r-2}, \ldots, 2^{k-1} - 2^0,
      2^{k-1}, 2^{k-1} + 2^0, 2^{k-1} + 2^1, \ldots, 2^{k-1} + 2^{r-2}.$$%
      Any constraint whose \LHS\ is {\tt div4} and which follows from these
      restrictions (and/or from known constraints on {\tt div4}) may be 
      inferred.
\item If $\verb|div8| > 2^k - 2^{k-3}$, by a result of Brouwer one may
      infer that $\verb|div8| = 2^k$.
\item Let the working weight list for the current configuration be
      (in order) $0, d_1, d_2, \ldots$.  Suppose that 
      $\sum_{i=0}^{k-1} \ceiling{d_2/2^i} > n$.  Then by the Griesmer bound,
      one may infer the constraint $y_{d_1}$ {\tt != 0}.
\item Let $v$ be a basic local variable for the current configuration.
      Suppose that subdividing along $v$ would yield a configuration which
      is known to be unrealizable.  Then one may infer the constraint
      $v$\kern5pt{\tt = 0}.
\item Let $v$ be a basic local variable for \verb|[current]|.  Suppose there
      is a constructive edge \verb|[current]| $\rightarrow$ \lconfig, that $w$
      is a basic local variable for \lconfig, and that $w$ pulls back to $v$.
      (This pull back is verbatim, and does not take into account equivalence
      of basic local variables.)
      Suppose that the constraint $w \geq r$ is known for \lconfig.  Then one
      can infer the constraint $v \geq r$ for \verb|[current]|.
\item For any $w$, {\tt sub}$w$ is a power of $2$.  If the complement $\loW$
      of $w$ lies in the dual small code, then 
      $\log_2(\hbox{\tt sub}w) \geq n - \abs{v} + 1$.  On the other hand, if we
      know that codes of a particular type do not exist, we get an
      inequality going the other way.  Suppose $w$ lies in the small code 
      and that by weight considerations,
      no nonzero word of the code can be properly contained in the basic word 
      associated to $w$.  Then one may infer that \verb|sub|$w = 2$.
\item If \verb|sub|$w$\verb|_|$k \geq r$ is known (for some $w$, $k$, $r$),
      one may infer \verb|y|$k \geq r$.
\end{itemize}

\indexb{up to isomorphism show}
\begin{commanddeclaration}
{\tt up to isomorphism show}\kern5pt$v$\kern5pt{\tt != 0;}
\end{commanddeclaration}

Let $v$ be an admissible basic local variable.  Consider its orbit under the 
automorphism group of {\tt[current]}.  Use split linear programming to show that
the sum of the variables in the orbit is nonzero.  This implies that if $v$ 
is used to subdivide the current configuration, then all codes of 
the given type have the current configuration \IFF\ they have the new 
configuration.  Therefore a {\it logical\/} link is created between the current 
configuration and the new configuration.

The following special case is handled without linear programming.  Suppose that 
the dimension of {\tt[current]} is less than the dimension of the code type.  
Suppose that under the action of the known automorphisms of {\tt[current]} on 
admissible basic local variables, there are exactly two orbits.  Then if $v$ is 
any admissible basic local variable (that is not equivalent to the trivial 
basic local variable), no calculation is required.

\indexb{kill}
\begin{commanddeclaration}
{\tt kill}\kern5pt$v_1$\kern5pt%
$\displaystyle{\overbrace{\hbox{by {\it local-variable-sequence}}_1}%
^{\hbox{optional}}}${\tt,}$\ldots${\tt,}\kern5pt$v_s$\kern5pt%
$\displaystyle{\overbrace{\hbox{by {\it local-variable-sequence}}_s}%
^{\hbox{optional}}}${\tt;}
\end{commanddeclaration}

\par\noindent{\sc Syntax:}\ Let \czconfig\ denote the current configuration.
Each $v_i$ is a basic joint, global, a local variable for \czconfig,
``{\tt ndiv4}'', ``{\tt ndiv8}'', ``$\verb|co|r$'' for some $r$, or a 
configuration label.  Each $\hbox{\it local-variable-sequence}_i$ has the form
\vspace{0.05in}
\par\noindent\kern0.5in\verb|(|$w_1${\tt|}$\ldots${\tt|}$w_r$\verb|)| or
\par\noindent\kern0.5in\verb|(|$w_1${\tt,}$\ldots${\tt,}$w_r$\verb|)| or
\par\noindent\kern0.5in$w_1$ (equivalent to ``{\tt(}$w_1${\tt)}'')
\vspace{0.05in}
\par\noindent where $\VEC w1r$ are basic local variables for certain
configurations described below.

\vspace{0.05in}\par\noindent{\sc Goal:}\ By one or more subdivisions and
applications of split linear programming, show in succession that
$v_1 = 0, \ldots, v_s = 0$, or in the case where $v_i$ is a configuration,
show that it is unrealizable.

\vspace{0.05in}\par\noindent{\sc Action:}\ It depends!  Read what follows.

\vspace{0.05in}\par\noindent\circno1\ The cases where $v_i$ is \verb|ndiv4| or
\verb|ndiv8| are special.  The optional {\tt by}$\ldots$ stuff may not be
used.  If $v_i = \verb|ndiv4|$,  we show that $\verb|div4| > {3\over4}2^k$ and 
deduce (via a theorem of Brouwer) that all words have doubly even weight.
Similarly if $v_i = \verb|ndiv8|$,  we show that $\verb|div8| > {7\over8}2^k$ 
and deduce that all words have weight divisible by $8$.

\vspace{0.05in}\par\noindent\circno2\ Otherwise, we first use $v_i$ to create 
one or more new configurations \coconfig.  There are several cases:
\begin{itemize}
\item If $v_i$ is a basic local variable, subdivide \czconfig\ along $v_i$ to 
      obtain \coconfig.
\item If $v_i$ is a basic global variable (say $= y_t$), find all 
      basic local variables of weight $t$ and subdivide \czconfig\ along them 
      to obtain various configurations \coconfig.
\item If $v_i$ is a basic joint variable, let \coconfig\ be the configuration
      associated to $v_i$ (which is usually two-dimensional), which has
      all global and joint constraints for \czconfig\ adjoined to it as
      assumed constraints.
\item If $v_i$ is $\verb|co|r$, let \coconfig\ be the configuration
      associated to $v_i$ (which is usually one-dimensional), which has
      all global and joint constraints for \czconfig\ adjoined to it as
      assumed constraints.
\item If $v_i$ is itself a configuration label, \coconfig is set equal to it.
\end{itemize}

\vspace{0.05in}\par\noindent\circno3\ If ``{\tt by }$\ldots$'' is absent, kill 
the configuration(s) \coconfig\ by split linear programming.  In any case, we 
first attempt to reduce the number of basic local variables as if via
``{\tt check secondary residuals}''.

\vspace{0.05in}\par\noindent\circno4\ Otherwise suppose
$\hbox{\it local-variable-sequence}_i$ =
\verb|(|$w_1${\tt|}$\ldots${\tt|}$w_r$\verb|)|.  Let \config{c_1} $=$ \coconfig.
Let $w_1$ be a basic local variable for
\config{c_1}.  Show by split linear programming that $w_1 \not= 0$.  Let \config{c_2} be obtained by subdividing \config{c_1} along $w_1$.  If
$r = 1$, use split linear programming to show that \config{c_2} is
unrealizable.  If $r > 1$, $w_2$ should be a basic local variable for
\config{c_2}.  One then shows by split linear programming that
$w_2 \not= 0$, and continues as above, constructing configurations
\config{c_3},$\ldots$,\config{c_{r+1}}.  From the ultimate finding that
\config{c_{r+1}} is unrealizable, one deduces that \coconfig is unrealizable.

\vspace{0.05in}\par\noindent\circno5\ Otherwise we have
$\hbox{\it local-variable-sequence}_i$ =
\verb|(|$w_1${\tt,}$\ldots${\tt,}$w_r$\verb|)|.  Let $\VEC w1r$ be basic local 
variables for \coconfig.  For $j = 1,\ldots,r$, show in succession by split linear
programming that the configuration obtained from \coconfig by subdividing along 
$w_j$ is unrealizable.  Then show by split linear programming that \coconfig is 
unrealizable.

The current configuration is restored to what it was prior to the command.

\indexb{bound}
\begin{commanddeclaration}
{\tt bound}\kern5pt\superopt{{\tt(}\it lp-specifier{\tt)}}%
\kern5pt\ttvec f1r{\tt;}
\end{commanddeclaration}

The optional {\it lp-specifier\/} should be a comma-separated list
of one or more of ``{\tt joint}'', ``{\tt common}'', or ``{\tt iterate}''.

For each $i$, $f_i$ must have one of the following forms:
\begin{itemize}
\item a homogeneous $\Z$-linear combination of variables (but you can't
      have both local and joint variables in the same combination);
\item {\tt y*}, which expands to the list of all basic global variables 
      {\tt y}$i$ ($i > 0$) which are not known to be zero;
\item {\tt x*}, which expands to the list of all nonzero minimal admissible
      basic local variables, modulo the action of $\Aut(\hbox{\tt[current]})$,
      if it can be computed;
\item \verb|~x*|, same as {\tt x*}, but instead expand to the sums over the
      orbits of the {\tt x}'s, under the action of the configuration's
      automorphism group\footnote{For this, the assumed constraints of 
      {\tt[current]} should not have any local variables in them.};
\item {\tt mu*}, which expands to {\tt mu1}, {\tt mu2}, $\ldots$;
\item {\tt j*}, which expands to the list of all minimal basic joint variables;
\item {\tt jyd*}, expands to the list of all variables of the form
      \verb|jy|$r$\verb|d|$s$;
\item Any of the above, but enclosed in brackets ({\tt[}, {\tt]}).
\end{itemize}

This command gets numerical bounds on the given variables, \WRT\ the current 
configuration.  If the bracket form is used, do not report anything unless the 
variable is found either to be zero or nonzero.  (We use $10^{-6}$ as
a threshold.)  If the optional ``{\tt(joint)}'' is present, joint linear
programming will be used instead of split linear programming.

If ``{\tt iterate}'' is present, iteratively bound variables until no
further improvement can be achieved.  The argument ``{\tt common}'' implies
{\tt iterate} and moreover that both split and joint linear programming
should be used.

\par\noindent{\sc Note.}\ This is an exploratory command, and is not intended
to prove anything.  Do not rely on its results!  The implementation of this
command which runs with the ``{\tt homebrew}'' option on is tentative and
provisional.  It can be extremely slow, and is useless in situations where
there are a small number of variables and a large number of constraints.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt bound ! quiet} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, show information about what
     is happening during execution of the command.  Not fully implemented.
     \vskip 0.05in}\\ \hline
{\tt bound ! verify} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, verify bounds computed with
     the {\tt iterate} option.  \vskip 0.05in}\\ \hline
\dtext{bound !}{dual search} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, bounds are carried out by
     a completely different procedure, which involves gradually trapping
     the argument (and using dual simplex).  This can be very slow, but will
     work sometimes when the ordinary use of {\tt bound} fails.
     \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{load constraints by parity check from}
\begin{commanddeclaration}
{\tt load constraints by parity check from }\cconfig{\tt;}
\end{commanddeclaration}

\par\noindent{\sc Idea:}
\ Any constraint on $[n,k,d]$ codes, where $d$ is even, induces a
constraint on $[n-1,k,d-1]$ codes.

\vspace{0.05in}\par\noindent{\sc Requirements:} 
\ The current code type should not have any assumed constraints,
nor should the code type \cconfig.  The current configuration should be the 
base configuration.  The code type \cconfig\ should have the same dimension as 
the current code type, and should be exactly one bit longer.  For each weight 
$w$ in the working weight list for the base configuration of the current code 
type, $w'$ must be in the assumed weight list for \cconfig, where $w'$ is 
obtained by rounding $w$ up to the nearest even integer.

\vspace{0.05in}\par\noindent{\sc Action:} 
\ For each known constraint of the base configuration of \cconfig, a translated 
constraint is inferred for the base configuration of the current code type.  
This translation is accomplished by 
$$y_i\ \mapsto\ \cases{0,&if $i$ is odd;\cr
                       y_0,&if $i = 0$;\cr
                       y_{i-1} + y_i,&if $i$ is even and positive.}$$
If for $i$ even, $i$ is not in the working weight list for the base 
configuration of \cconfig, it is inferred that neither $i$ nor $i-1$ is in
the working weight list for the base configuration of the current code type.

\block{Other commands}

\indexb{credit}
\begin{commanddeclaration}
{\tt credit: }{\it thing\/}\kern5pt{\tt due to} {\it name or reference}{\tt;}
\end{commanddeclaration}

Associate some credit to the current configuration.
Here {\it thing\/} is {\tt existence}, {\tt nonexistence}, {\tt uniqueness}, or
{\tt classification}.  In the case of {\tt existence}, give credit for the 
existence of a particular configuration.  If associated to {\tt[base]}, this 
indicates credit for the realizability of the code type.  All the remaining
{\it things\/} must be associated to the base configuration.  In the case of 
{\tt uniqueness}, give credit for there being a unique code in the code type.  
In the case of {\tt classification}, give credit for the classification of the 
codes in the code type.  In the case of {\tt nonexistence}, give credit for
the nonexistence of the code type.

One can also give credit for multiple things as in
\par\noindent{\tt credit: }{\it thing1\/}\kern5pt{\tt due to}%
{\it name or reference}
{\tt,} {\it thing2\/}\kern5pt{\tt due to} {\it name or reference}{\tt;}

\indexb{note}
\begin{commanddeclaration}
{\tt note:} {\it text}{\tt;}
\end{commanddeclaration}

Assign a note to particular configuration.  Such a note may be utilized
by the ``{\tt build web directory}'' command.

\indexb{flags}
\begin{commanddeclaration}
{\tt flags: }${\it flag}_1,\ldots,{\it flag}_n${\tt;}
\end{commanddeclaration}

Associate certain flags to the current configuration, which must be {\tt[base]}:
\begin{itemize}
\item {\tt find no more}: tell {\tt Split} that when it is looking for
     new codes, it should not look for any new ones in this code type.  In the
     current version, only the parameters of the code are looked at.
\item {\tt no automorphism group computation}: inhibits automatic computation
     of the automorphism group (under certain circumstances).
\end{itemize}

\indexb{at}
\begin{commanddeclaration}
{\tt at}\kern5pt\superopt{type}\kern5pt\lconfig{\tt;}
\end{commanddeclaration}

If ``{\tt type}'' is present, reenter the code type \lconfig.  Otherwise,
set the current configuration to \lconfig.

\indexb{help}
\begin{commanddeclaration}
{\tt help}\kern5pt{\it command name}{\tt;}
\end{commanddeclaration}

This command will only work if you have {\tt xdvi} installed.  Search
the LaTeX index file for the given command name.  Then use {\tt xdvi}
to open this document at the appropriate page.

\indexb{status}
\begin{commanddeclaration}
{\tt status:}\kern5pt$\hbox{\it fact}_1, \ldots, \hbox{\it fact}_r${\tt;}
\end{commanddeclaration}

This command asserts certain facts about the base configuration.  If the
command is encountered while the program is in {\tt gullible} mode, these
facts are accepted as true.  This is particularly useful in connection with
the {\tt tables only} parameter.

We describe now the allowed fact types, and how they are treated if 
encountered when the program is not in {\tt gullible} mode.
\begin{itemize}
\item {\tt realizable} -- Check that the code type is known to be realizable.
\item {\tt classified} -- Check that the code type is realizable and that the
     codes in the realization of the code type have been classified up to 
     isomorphism; this is established
     by the ``{\tt classification of}'' command.
\item {\tt unique} -- Check that the code type has (up to isomorphism) exactly
     one realization.
\item {\tt weights =}\kern5pt$w$ -- Here $w$ is formatted as with a list of
     weights for the type command.  Let $\lambda$ be the 
     working weight list of {\tt[base]}.  If $w \notIN \lambda$, issue a
     warning.  If $\lambda \notIN w$, issue a {\tt kill} command for the 
     weights in $\lambda - w$, in descending order.  If that doesn't work,
     use joint linear programming, with {\tt use dual dual for joint} = 5.
\item {\tt enumerator =}\kern5pt{\it weight enumerator} -- Here the 
     {\it weight enumerator\/} is to be the weight enumerator of all codes
     (if any) in the realization of the code type, e.g.
     $$\hbox{``\verb|1 + 190t^12 + 255t^16 + 66t^20|''}.$$%
     In this report, we display the exponents using superscripts.
     If the weight enumerator is not known to be {\it weight enumerator},
     first try to kill (in descending order) any weights which have zero
     coefficient in {\it weight enumerator}.  Then try to show that each
     of the nonzero coefficients are correct, as if via ``{\tt show}''.
     First use split linear programming, and if that doesn't work, use 
     iterative joint linear programming.
\item \verb|constraints = {|$\VEC h1r$\verb|}| -- Check that the given 
     constraints $\VEC h1r$ (involving only global and joint variables) are 
     known to hold for the base configuration.  If not, try to prove by
     iterated joint linear programming.
\end{itemize}

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt status ! quiet} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, show information about what
     is happening during execution of the command.  \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{build tables}
\begin{commanddeclaration}
{\tt build tables for}\kern5pt$n_0$\kern5pt{\tt<= n <=}\kern5pt$n_1$%
{\tt,}\kern5pt$k_0$\kern5pt{\tt<= k <=}\kern5pt$k_1${\tt;}
\end{commanddeclaration}

For the given range, build minimum distance tables of {\it upper bounds\/} for 
$[n,k]$ codes, writing the output in the form of an {\tt n = } command, 
prefixed by an exclamation point.  Some {\tt status} commands may be written
out first, also prefixed by exclamation points.

\indexb{build web directory}
\begin{commanddeclaration}
{\tt build web directory for}\kern5pt$n_0$\kern5pt{\tt<= n <=}\kern5pt$n_1$%
{\tt,}\kern5pt$k_0$\kern5pt{\tt<= k <=}\kern5pt$k_1${\tt;}
\end{commanddeclaration}

This is provisional implementation.  For the given range of $[n,k]$, generate
some information about $[n,k]$ codes, and put this in files in the
{\tt web} directory.  The file {\tt webcodes/install} installs this in a
publicly accessible location.

\indexb{alias}
\begin{commanddeclaration}
{\tt alias}\kern5pt{\it short-form}\kern5pt{\tt=}\kern5pt{\it long-form}{\tt;}
\end{commanddeclaration}

After using this command, any subsequently entered command starting with
the string {\it short-form\/} will have that string replaced by
{\it long-form}.

\indexb{print}
\begin{commanddeclaration}
{\tt print}\kern5pt{\it print-item}{\tt;}
\end{commanddeclaration}

The allowed choices for {\it print-item\/} are given in the following table.
We let $C$ denote the basic code associated to the small code of the current
configuration.

\begin{center}
\begin{longtable}{|l|l|}\hline
{\bf print-item} & {\bf effect} \\ \hline\hline
{\tt dual weight enumerator} &
     \parbox{4.2in}{\vskip 0.05in Print the weight enumerator of $C^\perp$.
     \vskip 0.05in}\\ \hline
{\tt intersection weight enumerator} &
     \parbox{4.2in}{\vskip 0.05in Print the weight enumerator of 
     $C \cap C^\perp$.  \vskip 0.05in}\\ \hline
{\tt joint weight enumerator} &
     \parbox{4.2in}{\vskip 0.05in What this actually does is print the
     values of the nonzero joint variables.
     \vskip 0.05in}\\ \hline
{\tt config} &
     \parbox{4.2in}{\vskip 0.05in Print some information about the current
     configuration.  \vskip 0.05in}\\ \hline
{\tt time used} & \parbox{4.2in}{\vskip 0.05in Print the total elapsed real
     time in minutes since execution started.  \vskip 0.05in}\\ \hline
{\tt memory usage} & \parbox{4.2in}{\vskip 0.05in Print the estimated total 
     memory in use by the process, in kilobytes.  \vskip 0.05in}\\ \hline
{\tt basis} &
     \parbox{4.2in}{\vskip 0.05in Print a basis for $C$. \vskip 0.05in}\\ \hline
{\tt reduced basis} &
     \parbox{4.2in}{\vskip 0.05in Remove duplicated columns from a generator
     matrix for $C$, and print it.  \vskip 0.05in}\\ \hline
{\tt dual basis} & \parbox{4.2in}{\vskip 0.05in Print a basis for
     $C^\perp$. \vskip 0.05in}\\ \hline
{\tt intersection basis} & \parbox{4.2in}{\vskip 0.05in Print a basis for
     $C \cap C^\perp$. \vskip 0.05in}\\ \hline
{\tt even subcode basis} & \parbox{4.2in}{\vskip 0.05in Print a basis for 
     the subcode of $C$ consisting of all even words.  \vskip 0.05in}\\ \hline
{\tt variable classes} & \parbox{4.2in}{\vskip 0.05in List the equivalence 
     classes of minimal admissible basic local variables, where the equivalence
     relation is induced by the automorphisms known for {\tt[current]}.
     \vskip 0.05in}\\ \hline
{\tt variables of weight} $m$& \parbox{4.2in}{\vskip 0.05in List all admissible
     basic local variables of weight $m$.  Equivalent variables are shown as 
     such in the printout.  \vskip 0.05in}\\ \hline
{\tt dual words of weight} $m$& \parbox{4.2in}{\vskip 0.05in List all words of
     weight $m$ dual to the small code.  \vskip 0.05in}\\ \hline
{\tt codeword orbits}& \parbox{4.2in}{\vskip 0.05in Compute the orbits of
     the codewords (elements of small code) under the known automorphisms.
     \vskip 0.05in}\\ \hline
{\tt punctured codes}& \parbox{4.2in}{\vskip 0.05in Classify up to 
     isomorphism the codes which can be obtained by deleting a column from 
     $C$.  \vskip 0.05in}\\ \hline
\dtext{projections onto}{words of weight $m$} & \parbox{4.2in}{\vskip 0.05in 
     Classify, up to isomorphism, the codes obtained by projecting onto a
     codeword of weight $m$.  \vskip 0.05in}\\ \hline
{\tt automorphism group generators}& \parbox{4.2in}{\vskip 0.05in 
     Print generators for the automorphism group of the current configuration.  
     Also report the group size.  For this print-item, {\tt[current]} may not 
     have local variables in its assumed constraints.  \vskip 0.05in}\\ \hline
{\tt automorphism group}& \parbox{4.2in}{\vskip 0.05in 
     Find and print all the elements of the automorphism group of the current 
     configuration.  For this print-item, {\tt[current]} may not have local 
     variables in its assumed constraints.  \vskip 0.05in}\\ \hline
\ttext{dimension of code}{spanned by dual}{words of weight $r$} &
     \parbox{4.2in}{\vskip 0.05in Self-explanatory! \vskip 0.05in}\\ \hline
\dtext{words of weight $m$,}{showing orbit groups} &
     \parbox{4.2in}{\vskip 0.05in List all words of weight $m$ in the
     small code, but permute the columns so that they are grouped into
     orbits under the action of the automorphism group. \vskip 0.05in}\\ \hline
\dtext{split variables}{for weight $m$} &
     \parbox{4.2in}{\vskip 0.05in For each word $w$ of weight $m$ in $C$, 
     determine the values the variables $\verb|x\_|i\verb|\_|j$, which 
     represent the number of words of weight $i + j$ meeting $w$ along $i$ ones.
     Print out one line for each possible collection of values of these 
     variables.  (For example, if $\Aut(C)$ acts transitively on the words of 
     weight $m$, there will be only one line.) \vskip 0.05in}\\ \hline
\end{longtable}
\end{center}

\indexb{eval}
\begin{commanddeclaration}
{\tt eval}\kern5pt{\it expression}{\tt;}
\end{commanddeclaration}

Evaluate an expression, as in \S\ref{matrix-descriptor-section}.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt eval ! input form} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, the output of eval is given
in a form that is itself an expression.  Only partially implemented.
     \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{!config}
\begin{commanddeclaration}
{\tt!config} $\ldots$ {\tt;}
\end{commanddeclaration}

This is expanded out to:
\par\noindent\kern0.5in{\tt config} $\ldots$ {\tt;}
\par\noindent\kern0.5in{\tt via lp [current] = ;}

\indexb{no}
\begin{commanddeclaration}
{\tt no [}\kern3pt$n${\tt,}\kern4pt$k${\tt,}\kern4pt$d$\kern3pt{\tt];}
\end{commanddeclaration}

This command implements approximately the procedure described in 
\S\ref{canned-section} for showing that there is no $[n,k,d]$ code.  Here
we describe some technical details and differences between what we actually
do and what was described in \S\ref{canned-section}.  Not all of the 
differences are mentioned here, and it is (at this point) necessary to refer
to the code to see exactly what is done.

The parameter $d$ may either be an integer, or else it may have the form
$s$\verb|_4|, in which case attention is restricted to doubly even codes.

In the second stage, when we attempt to show that there is no
word of weight $i$ by split linear programming, we proceed as if via
the command ``{\tt kill y}$i$'', except that code equivalent to
``{\tt check secondary residuals}'' is used in executing the
{\tt kill} if $k \leq n/2$.

In the third stage, when we try to show that there is no dual word of weight
$i$, we do this by trying to show that the configuration 
``$n-i${\tt, }$i$\verb| : { } : {01}|'' gives a contradiction by split linear 
programming.  

A more intensive attempt to prove the nonexistence of $[n,k,d]$ codes may be 
invoked by using a larger value for the {\tt allowed failures} parameter.  
(The default is $2$.)

For all of the linear programming calculations, if $k > n/2$, we convert the
problem to a problem about the dual code, and work with that instead, because
it is numerically more stable.

The code type is left undefined at the completion of the command.

\indexb{test}
\begin{commanddeclaration}
{\tt test [}\kern3pt$n${\tt,}\kern4pt$k${\tt,}\kern4pt$d$\kern3pt{\tt];}
\end{commanddeclaration}

This exploratory command proceeds as with
``{\tt no [}\kern3pt$n${\tt,}\kern4pt$k${\tt,}\kern4pt$d$\kern3pt{\tt];}''
but interprets the outcome differently.  If ``{\tt no}'' would succeed, issue
a warning message.  Otherwise, take no action.  Also, the command is treated
as a null command if it is not known that there is no $[n-1,k,d]$ command.
In any case, the code type is left undefined upon completion.

\indexb{test yes}
\begin{commanddeclaration}
{\tt test yes [}\kern3pt$n${\tt,}\kern4pt$k${\tt,}\kern4pt$d$\kern3pt{\tt];}
\end{commanddeclaration}

This exploratory command proceeds as with
``{\tt yes [}\kern3pt$n${\tt,}\kern4pt$k${\tt,}\kern4pt$d$\kern3pt{\tt];}''
but interprets the outcome differently.  If ``{\tt yes}'' would succeed, issue
a warning message.  Otherwise, take no action.  
The code type is left undefined upon completion.

\indexb{yes}
\begin{commanddeclaration}
{\tt yes [}\kern3pt$n${\tt,}\kern4pt$k${\tt,}\kern4pt$d$\kern3pt{\tt];}
\end{commanddeclaration}

This command implements a primitive facility for showing that an $[n,k,d]$ code 
exists.  All it will do is use known results together with the following
rules of inference:
\def\existsk{\exists\kern1pt}
\begin{itemize}
\item $\existsk [n,n,1]$ 
\item $\existsk [n,k,d]$, $d$ odd $\Longrightarrow \existsk [n+1,k,d+1]$
\item $\existsk [n,k,d] \Longrightarrow \existsk [n-a,k-b,d-\max(a-b,0)]$ for
      all $a \in \Z$ and all $b \geq 0$
\item $\existsk [n_1,k,d_1], [n_2,k,d_2] \Longrightarrow \existsk
      [n_1 + n_2, k, d_1 + d_2]$
\item $\existsk [n,k_1,d_1], [n,k_2,d_2] \Longrightarrow \existsk
      [2n, k_1 + k_2, \min\setof{2d_1,d_2}]$
\item $\existsk [n,k,d] \Longrightarrow \existsk
      [n + 2^k, k + 1, \min( d + 2^{k-1}, 2^k )]$.
\end{itemize}
The next to the last rule comes from the ``$|u|u+v|$'' construction
([.macwilliams sloane book.]\ p. 76).  The last rule comes from construction
{\tt P} (see matrix-descriptor section).  In fact, we only make partial
use of these inferences, so some valid deductions may not be known to the
command.

\indexb{n =}
\begin{commanddeclaration}
{\tt n = $n$, k >= $k$: $I_k$, $I_{k+1}$, $\ldots$, $I_r$;}
\end{commanddeclaration}

\vspace{0.05in}\par\noindent{\sc Requirements:}\ One must have $r < n$.
Each $I_k$ is to be $a${\tt-}$b$ (or an abbreviated form; see below), where
$a \leq b$ are positive integers.  The abbreviated forms are
$b$ (abbreviating $b${\tt-}$b$), {\tt-}$b$ (abbreviating $1${\tt-}$b$), 
and $a${\tt-} (abbreviating $a${\tt-}$n$).

\vspace{0.05in}\par\noindent{\sc Action:}\ For
$i = 0, \ldots, r - k$ in succession, invoke the commands
\par\noindent\kern1.5cm
   {\tt no [}\kern3pt$n${\tt,}\kern4pt$k+i${\tt,}\kern4pt$d_{k+i}+1$%
\kern3pt{\tt];} and
\par\noindent\kern1.5cm
   {\tt yes [}\kern3pt$n${\tt,}\kern4pt$k+i${\tt,}\kern4pt$d_{k+i}$%
\kern3pt{\tt];}.  
\par\noindent Follow each of the above pairs for which $d_{k+i}$ is even with
``{\tt test [}\kern3pt$n${\tt,}\kern4pt$k+i${\tt,}\kern4pt$d_{k+i}$%
\kern3pt{\tt];}'' and follow each pair with
``{\tt test yes [}\kern3pt$n${\tt,}\kern4pt$k+i${\tt,}\kern4pt$d_{k+i}+1$%
\kern3pt{\tt];}''.  Leave the code type undefined upon completion.

\vspace{0.05in}\par\noindent{\sc Effect of parameters:}\ If the parameter
``{\tt optimal}'' is not set, the ``{\tt test}'' and ``{\tt test yes}'' commands
will not be carried out.  If the parameter ``{\tt lower bound check}'' is not
set, the ``{\tt yes}'' and ``{\tt test yes}'' commands will not be carried out.
The {\tt test mask} parameter may be used to restrict the scope of these tests.

\indexb{set}\indexb{unset}
\begin{commanddeclaration}
\vbox{%
\hbox{{\tt set}\kern5pt{\it parameter}\kern5pt$=$\kern5pt{\it value}{\tt;}}%
\hbox{{\tt set}\kern5pt{\it parameter}{\tt;}}%
\hbox{{\tt unset}\kern5pt{\it parameter}{\tt;}}}
\end{commanddeclaration}

The first form sets the given {\it parameter\/} to {\it value}.  The second
form sets it to $1$, and the third form sets it to $0$.  Most of the allowed 
parameters are shown below.  A few others (of the form
{\it command name\/} {\tt!} {\it something-or-other}) are included in the
documentation for the corresponding commands.  The remaining parameters are 
shown in \S\ref{identify-find-section}.
\begin{center}
\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt secondary echo} & $0$, $1$ & $1$ & 
      \parbox{\parwa}{\vskip 0.05in If set to $0$, and a command 
      (e.g.\ {\tt n=}) causes other commands to be executed, they will
      not be echoed to standard output\vskip 0.05in}\\ \hline
{\tt optimal} & $0$, $1$ & $0$ & See ``{\tt n=}'' command.\\ \hline
{\tt warnings are fatal} & $0$, $1$ & $0$ &
      \parbox{\parwa}{\vskip 0.05in If set to $0$, recoverable errors will
      not be regarded as fatal.  Use with caution.\vskip 0.05in}\\ \hline
{\tt gullible} & $0$, $1$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in If set to $1$, commands that follow are
     accepted without verification.  This facilitates incremental verification
     of results.\vskip 0.05in}\\ \hline
{\tt gullible commands} &
\vbox{\hbox{\tt list of}\kern3pt\hbox{\tt strings}} & {\tt null} &
     \parbox{\parwa}{\vskip 0.05in Those commands which (aside from a label
     or labels) start with one of the given strings are executed in gullible 
     mode.  Thus one might use ``{\tt set gullible commands = no}'' or
     ``{\tt set gullible commands = via ext, via build}''.
     \vskip 0.05in}\\ \hline
\vbox{\hbox{\tt show terminals}\kern3pt\hbox{\tt only}} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in
     If set to $0$, when a ``{\tt via building}'' command is invoked, all
     configurations (and not just terminal ones) will be printed out as they
     are encountered.  \vskip 0.05in}\\ \hline
{\tt allowed failures} & $\geq 0$ & $2$ &
     \parbox{\parwa}{\vskip 0.05in
     If set to a number $> 2$, certain steps in the {\tt no} command are 
     allowed to fail more than twice.  If set to $0$, there is no limit on
     failures.  If set to $-1$, there is no limit on failures and {\tt no}
     will try again too (under certain circumstances).  This is an exploratory 
     feature.  \vskip 0.05in}\\ \hline
{\tt repeat loop} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in
     If set to $1$, the {\tt no} command will keep trying to kill weights
     after killing some but failing (as in {\tt allowed failures}).  Starts
     over a top of kill list.  \vskip 0.05in}\\ \hline
{\tt verify feasibility} & $0$, $1$, $2$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in
     If set to $1$ or $2$, failed attempts to prove infeasibility will be
     {\it verified\/} by confirming that in fact the given linear program
     is feasible.  If set to $2$, when verification fails, the calculation
     will be repeated using higher precision arithmetic.  
     \vskip 0.05in}\\ \hline
{\tt nauty vocal} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, print a message whenever 
     Brendan McKay's graph isomorphism program {\tt nauty} is invoked.
     \vskip 0.05in}\\ \hline
{\tt sort} & $0$, $1$ & $1$ & 
     \parbox{\parwa}{\vskip 0.05in If set to $0$, the constraints generated
     by split linear programming will not be piped through a unique sort.
     \vskip 0.05in}\\ \hline
{\tt secondary plus} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See the ``{\tt check secondary residuals}''
     command.  This option indirectly affects the ``{\tt kill}'', ``{\tt no}'',
     and ``{\tt test}'' commands.
     \vskip 0.05in}\\ \hline
{\tt auto round} & $0$, $1$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in If set to $1$, automatically invoke the
     command {\tt round local variables} prior to attempting to prove
     infeasibility by split linear programming.  For experimental use only.
     In the current version, CPLEX will be used, and so this option will only
     have an effect if ${n \choose k}$ is small enough to allow CPLEX to be
     invoked reliably.  \vskip 0.05in}\\ \hline
{\tt tables only } & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, only {\tt n=}, {\tt no},
     {\tt yes}, {\tt type}, {\tt at type}, {\tt status}, {\tt set}, 
     {\tt unset}, and {\tt exit} commands will be executed; {\tt no}, {\tt yes},
     and {\tt status} commands will be executed in the
     gullible mode.  This option can be used to test just the tables defined
     by the {\tt n=} command.  To use it, be sure that each calculation which
     proves the (non)existence of a code type or limits its weights is followed
     by an appropriate ``{\tt no}'' or ``{\tt status}'' command.
     \vskip 0.05in}\\ \hline
{\tt homebrew} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, a preliminary built-in
     simplex routine will be used for proofs.  Independent of whether this
     parameter is set, the built-in routine will automatically be used if
     ${n \choose k} > 3 \times 10^{18}$.  \vskip 0.05in}\\ \hline
\dtext{homebrew full}{report} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, and {\tt homebrew} is set,
     it will print out simplex iterations in excruciating detail.  For
     debugging and optimization.  \vskip 0.05in}\\ \hline
{\tt homebrew dump} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when {\tt homebrew} simplex
     calculations are performed, $A_B$ and $c_B$ are dumped to files in
     the directory {\tt calculations}.  They are first scaled by a power of 
     two so that all entries are integers.  \vskip 0.05in}\\ \hline
{\tt dump cost} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when {\tt homebrew} simplex
     calculations are performed, dump minus the cost vector to
     {\tt calculations/minus\_cost}.  This is presumably the optimum of the
     linear program, if feasible.  Useful in conjunction with the option
     {\tt verify feasibility}.  \vskip 0.05in}\\ \hline
{\tt precision} & $\geq 1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in This parameter sets a minimum for the 
     precision used of floating point calculations made when employing the 
     simplex method for linear programming.  If the program thinks it is
     needed, higher precision will automatically be used.  The meaning of
     the precision values is indicated by the following table:
     \begin{tabular}{|l|l|}\hline
     {\tt precision} & {\bf bits in mantissa}\\ \hline
     $1$ & $53$\\ \hline
     $2$ & $106$\\ \hline
     $3$ & $160$\\ \hline
     $4$ & $224$\\ \hline
     $\geq 3$ & $64 * \verb|precision| - 32$\\ \hline
     \end{tabular}
     If {\tt precision} is $\geq 2$, the built-in simplex routine is 
     employed (see the {\tt homebrew} option).  If {\tt precision} is
     $\geq 3$, more bits are allocated for the exponent, and hence if
     floating point overflow occurs, you may be able to circumvent it
     by setting {\tt precision} to $3$.  \vskip 0.05in}\\ \hline
{\tt precision lock} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value, this functions
     like {\tt precision}, but it {\it forces\/} the precision to be a
     particular value.  However, if the built-in simplex routine reports that
     it is confused, the precision value is raised.  \vskip 0.05in}\\ \hline
\dtext{full}{reduction} & $0, 1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, each time the simplex
     method is to be used, a special presolve routine is invoked first in
     an attempt to eliminate some constraints.  \vskip 0.05in}\\ \hline
\dtext{refactorization}{rate} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value $r$, the basis
     matrix for the simplex method will be refactored every $r$ iterations.
     \vskip 0.05in}\\ \hline
\dtext{dual constraint}{bound} & $\geq -1$ & $-1$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonnegative value $r$, only 
     constraints corresponding to wordtypes whose {\it first\/} part is 
     $\leq r$ will 
     be used in split linear programming.  \vskip 0.05in}\\ \hline
\dtext{total dual constraint}{bound} & $\geq -1$ & $-1$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonnegative value $r$, only 
     constraints corresponding to wordtypes whose parts are $\leq r$ will 
     be used in split linear programming.  \vskip 0.05in}\\ \hline
\dtext{dcb depth}{limit} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value $r$, the
     ``{\tt dual constraint bound}'' restriction will only apply to 
     configurations whose partitions have length $\leq r$.
     \vskip 0.05in}\\ \hline
\ttextp{alternate}{extension}{method} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, an alternate (conceivably 
     faster) method will be used by the ``{\tt via extension}'' command.
     \vskip 0.05in}\\ \hline
\dtext{auto group}{computation} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when a ``{\tt config}''
     command is encountered (having no local variables in its assumed
     constraints), automatically compute the automorphism group
     of the configuration, and associate generators for the group to the
     configuration, as if via the ``{\tt automorphism}'' command.
     \vskip 0.05in}\\ \hline
{\tt smart dual} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, every split linear programming
     calculation will include certain constraints of the form
     \verb|z\_|$a_1$\verb|\_|$\ldots$\verb|\_|$a_r <= 1$, when 
     $\sum_{i=1}^r 2\min(a_i, p_i - a_i)$ is less than the known lower bound
     for the minimum distance of the dual code.  (Here $(\VEC p1r)$ is the
     partition of the configuration.) \vskip 0.05in}\\ \hline
\dtext{adjoin extra}{brouwer constraints} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, every split linear programming
     calculation will include certain constraints which are obtained by
     applying Brouwer's lower bound to subcodes.  \vskip 0.05in}\\ \hline
{\tt silent} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, most output will be
     suppressed.  \vskip 0.05in}\\ \hline
\dtext{limited secondary}{kill} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when the
     {\tt no} command is executed, and $k < n/2$, and an attempt to prove
     $\verb|y|_i = 0$ by split linear programming fails, try again, but this
     time first try to kill those basic local variables for the configuration
     $i,n-i$ {\tt:}\kern6pt{\tt\{10\}} (or $i$ {\tt:}\kern6pt{\tt\{1\}} if 
     $i = n$) which have only
     one nonzero component (e.g.\ \verb|x\_12\_0|).  \vskip 0.05in}\\ \hline
\dtextp{full secondary}{kill} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in Same as {\tt limited secondary kill}, but
     tries to kill all basic local variables.  \vskip 0.05in}\\ \hline
\vbox{\hbox{\tt secondary kill}\kern3pt\hbox{\tt maxvars}} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If positive, {\tt limited secondary kill}
     and {\tt full secondary kill} will only be applied in situations where
     one has $\leq$ the given number of basic local variables.
     \vskip 0.05in}\\ \hline
{\tt test mask} & \vbox{\hbox{\tt a list of}\kern3pt\hbox{\tt constraints}}
     & null &
     \parbox{\parwa}{\vskip 0.05in The given linear constraints may involve 
     only the variables $n$, $k$, and $d$.  Whenever a 
     {\tt test [n,k,d]} command is encountered, the constraints
     are checked, and if one fails, the {\tt test} command is ignored.
     \vskip 0.05in}\\ \hline
{\tt lower bound check} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in See the {\tt n=} command.
     \vskip 0.05in}\\ \hline
{\tt homebrew speedy} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, when doing homebrew simplex
     calculations, do some extra error checking.  Slower but safer.
     \vskip 0.05in}\\ \hline
{\tt show variables} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when computing the list
     of admissible basic local variables for the current configuration, print
     them out as found.  \vskip 0.05in}\\ \hline
{\tt doubly even test} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, whenever a
     ``{\tt test[n,k,d]}'' command is invoked, only process it if $4 \mid d$,
     and instead check for the existence of a doubly even 
     $[n,k,d]$ code.  Even so, do nothing is nonexistence follows immediately
     from known results.  \vskip 0.05in}\\ \hline
{\tt fill weight} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $w$, and 
     {\tt[current]} has less words of weight $w$ than the known lower bound
     for $y_w$, ignore configurations that have not achieved this lower bound
     and do not increase the number of words of weight $w$.
     \vskip 0.05in}\\ \hline
\dtext{show config}{creation} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, do not automatically
     subdivide when a variable is found to be nonzero by a show command.
     \vskip 0.05in}\\ \hline
\dtext{low memory}{joint generation} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, use less memory but more
     time when generating constraints for joint linear programming.
     \vskip 0.05in}\\ \hline
\dtext{auto joint}{search} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $r$, do joint 
     linear programming (to bound global variables)
     at the end of the execution of each {\tt no} (and
     {\tt test}) command, if the code type has not been shown unrealizable,
     provided that the number of minimal basic joint variables is $\leq r$.
     This option is exploratory.  \vskip 0.05in}\\ \hline
\dtext{auto joint}{test} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $r$,
     at the end of the execution of each {\tt no} (and
     {\tt test}) command, if the code type has not been shown unrealizable, and
     if $r=1$ or the number of minimal basic joint variables is $\leq r$, 
     attempt to show by joint linear programming that the code type is 
     unrealizable.  \vskip 0.05in}\\ \hline
\dtext{auto try to}{kill jvars} & $0, 1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, and 
     {\tt auto joint search} or {\tt auto joint test} has been selected,
     before carrying either one out, attempt to kill joint variables as in
     {\tt try to kill jy*}.  \vskip 0.05in}\\ \hline
\dtext{use dual}{dual for joint} & $\geq 0$ & $5$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value $r$, when doing 
     joint linear programming, also use the constraints arising from the fact 
     that the coefficients of the joint weight enumerator of $C^\perp$ with
     itself are nonnegative, but use only those constraints coming from dual
     words of weight $\leq r + {\tt dl}$, where {\tt dl} is the known lower
     bound for the minimum weight of the dual code.  \vskip 0.05in}\\ \hline
\dtext{no test}{if classified} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, do not run the {\tt test}
     command on code types which have been classified or for which the
     weight enumerator is known, because of a ``{\tt status: enumerator = }
     $\ldots$'' command. \vskip 0.05in}\\ \hline
{\tt partial pricing} & $\geq 0$ & $50$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $r$, when using
     the homebrew simplex method, do {\it partial pricing}, by (roughly) only 
     looking at $r$ candidates for an entering variable. \vskip 0.05in}\\ \hline
{\tt iteration limit} & $\geq 1000$ & $1000000$ &
     \parbox{\parwa}{\vskip 0.05in Set the maximum number of iterations 
     attempted by the simplex algorithm before giving up.
     \vskip 0.05in}\\ \hline
{\tt auto mu1} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, whenever a {\tt type}
     command with no assumed constraints or options is encountered, say (in
     effect) ``{\tt type[}$n${\tt,}$k$\verb|,\{|$d,\ldots$\verb|\}];|'',
     first (in effect) execute the command 
     ``{\tt no [}$n-1${\tt,}$k${\tt,}$d${\tt]}''.  \vskip 0.05in}\\ \hline
{\tt debug} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, do extra checks for
     internal errors and print some tracing messages.  \vskip 0.05in}\\ \hline
{\tt gullible silent} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, do not display commands
     which are executed in {\tt gullible} mode.  \vskip 0.05in}\\ \hline
\dtext{residual check}{for kill} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when executing {\tt no} and
     {\tt test} commands with the {\tt limited secondary kill} or 
     {\tt full secondary kill} options turned on, do some addtional checking,
     as if via the ``{\tt check secondary residuals}'' command.
     Very slow at present.
     \vskip 0.05in}\\ \hline
{\tt auto projection} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when doing split linear
     programming, automatically adjoin certain constraints coming from the
     known constraints of residual codes.  If 
     ``{\tt auto projection ! show constraints}'' is set, these are printed 
     out as they are adjoined.  If 
     ``{\tt auto projection ! show parameters}'' is set, show the parameters
     of codes for which the program looks for constraints about.
     \vskip 0.05in}\\ \hline
\dtext{auto projection !}{show constraints} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See {\tt auto projection}.  
     \vskip 0.05in}\\ \hline
\dtext{auto projection !}{show parameters} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See {\tt auto projection}.  
     \vskip 0.05in}\\ \hline
{\tt save bounds} & $0,1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, at the end
     of each ``{\tt test}'' command, assume that the bounds on global variables
     arising from the {\tt auto joint search} option are correct, and save 
     them.  Because these numerical results are not verified, incorrect bounds
     may be saved!  This experimental option is conceivably useful in 
     connection with the ``{\tt auto projection}'' option.  
     \vskip 0.05in}\\ \hline
\dtext{generate}{noneven bounds} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $r$, at the end
     of each ``{\tt test}'' command, proceed as if with {\tt save bounds}, but
     work with all codes, not just even ones.  Use the given parameter $r$
     in place of {\tt auto joint search}.
     \vskip 0.05in}\\ \hline
\dtext{price}{refinement count} & $\geq 0$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in Set the number of times which the
     homebrew simplex calculator refines the price vector.  This choice will 
     presumably be automated in a later version.
     \vskip 0.05in}\\ \hline
{\tt toldj percent} & $\geq 0$ & $70$ &
     \parbox{\parwa}{\vskip 0.05in Set the simplex optimality tolerance,
     as a percent.  \vskip 0.05in}\\ \hline
{\tt tolpiv percent} & $\geq 0$ & $87$ &
     \parbox{\parwa}{\vskip 0.05in Set the simplex pivot tolerance,
     as a percent.  \vskip 0.05in}\\ \hline
\dtext{matrix isomorphism}{silent} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, the isomorphism and
     automorphism routines for matrices (except in trivial cases) print some 
     information. \vskip 0.05in}\\ \hline
{\tt auto joint list} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, do not automatically compute
     a list of joint variables for each code type.  \vskip 0.05in}\\ \hline
\dtext{find regular}{group element} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value, when a terminal
     configuration is encountered, look for automorphisms which are a product
     of $n/r$ disjoint $r$-cycles.  If the parameter value is $1$, look for
     each $r$, otherwise, use the parameter value as $r$.
     \vskip 0.05in}\\ \hline
{\tt load limit} & $\geq 1$ & $20$ &
     \parbox{\parwa}{\vskip 0.05in A limit, in millions, on the number of
     constraints times the number of basic local variables, which can occur
     in a linear programming problem without triggering an error.
     \vskip 0.05in}\\ \hline
{\tt auto cyclic test} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in When the {\tt build web directory} command
     is executed, if the size of the automorphism group of a code is less than
     the value of the parameter, and it is not known to be cyclic, try to
     determine if it is cyclic.  \vskip 0.05in}\\ \hline
{\tt show residual data} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, whenever the command
     ``{\tt check secondary residuals}'' is invoked (perhaps indirectly by
     another command), messages are printed out.  These messages
     give data about certain hypothetical codes which exist if the current
     configuration is realizable.  It is possible that by getting additional
     data about these codes (especially restrictions on the weights they
     may have), some basic local variables may be found to be zero.
     \vskip 0.05in}\\ \hline
\dtext{unresidue !}{show all configs} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when evaluating an
     expression {\tt Unresidue( ... )}, show all configurations
     as they are encountered.  \vskip 0.05in}\\ \hline
\dtext{unresidue !}{show extra info} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when evaluating an
     expression {\tt Unresidue( ... )}, issue various informative
     messages as configurations are processed.  Verbose. \vskip 0.05in}\\ \hline
{\tt purge joints on type exit} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, whenever a code type is
     exited, the tables of joint variables associated to the code type's
     configurations are purged.  This is sometimes 
     desirable because these tables can occupy a huge amount of memory.
     \vskip 0.05in}\\ \hline
\end{longtable}
\end{center}

\indexb{try to kill}
\begin{commanddeclaration}
{\tt try to kill}\kern5pt{\it variable-list}{\tt;}
\end{commanddeclaration}

This is an exploratory command, whose behavior depends on the parameter
{\it variable-list}.  The currently allowed possibilities are
``{\tt x*}'', ``{\tt jy*}'', and ``$\verb|jy|r\verb|*|$''.

In case the parameter is {\tt x*}, the goal is to find a proof that
{\tt [current]} is unrealizable.  First try split linear programming.
Then make a list of all nontrivial minimal admissible basic local variables for 
{\tt [current]}.  For each such variable $v$, compute the number $\varphi(v)$ 
of minimal admissible basic local
variables in the subdivision of {\tt [current]} along $v$.  Put the nontrivial
basic local variables for {\tt [current]} in increasing order according to
the values taken by $\varphi$.  One-by-one, attempt to show (as in
``{\tt kill} $v$'') that each of these variables $v$ is $0$.
Whenever a success occurs, try split linear programming again on 
{\tt [current]}.  Note that successes may cause the number of basic local
variables in the subdivisions to decrease.

In case the parameter is {\tt jy*}, to each joint variable, associate the
corresponding configuration, say \lconfig, which is usually two-dimensional.  
All known constraints for {\tt[current]} (involving no local variables) are 
taken as assumed constraints for \lconfig.  Then try to kill \lconfig\ by split 
linear programming.  In this way accumulate known facts about joint variables 
(i.e.\ that some are zero) for the current configuration.

The case $\verb|jy|r\verb|*|$ is similar, except that only joint variables
involving $\verb|y|r$ are used.

If the {\tt try to kill} command is run in {\tt gullible} mode, no linear
programming calculations will be made.

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are associated to this command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{try to kill !}{vocal} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, some more information
     may be printed out as the command executes.  \vskip 0.05in}\\ \hline
\dtext{try to kill !}{maxvars} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value,
     {\tt try to kill jy*} will never set up a linear programming problem
     with more than the given number of variables.  \vskip 0.05in}\\ \hline
\end{longtable}

\indexb{(* ... *)}
\begin{commanddeclaration}
{\tt (* ... *);}
\end{commanddeclaration}

Comment.  Also lines starting with {\tt %} are treated as
comments so long as they are not in the middle of a command.

\indexb{random weight enumerator}
\begin{commanddeclaration}
{\tt random weight enumerator( n = }$n${\tt, k = }$k${\tt, div = }$d$
{\tt, modulus = }$m${\tt, count = }$c${\tt\ );}
\end{commanddeclaration}

The approximate function of this command is to find $c$ ``random'' codes of 
type $[n,k]$ and print out their weight enumerators.  To explain more carefully
what the command does, we have to explain the parameters $d$ and $m$.  First,
$d$ must be in \setof{1,4}, and if $d = 4$, we look only for ``random''
doubly even codes.  Second, the weight enumerators are not literally printed
out.  Rather, for each code we print the list
$$y_0 + y_m + y_{2m} + \cdots, y_1 + y_{m+1} + y_{2m+1} + \cdots, \ldots,
  y_{m-1} + y_{m+(m-1)} + y_{2m+(m-1)} + \cdots.$$%
If you want the actual coefficients of the weight enumerator, use $m = n+1$.

\indexb{dump}
\begin{commanddeclaration}
{\tt dump;}
\end{commanddeclaration}

Print information about all the configurations known for the current code type.

\indexb{round local variables}
\begin{commanddeclaration}
{\tt round local variables;}
\end{commanddeclaration}

This is an exploratory command.  First use floating point linear programming 
(without exact verification) to get bounds on all the admissible basic local 
variables.  Whenever one of the bounds appears to not be an integer, adjoin
and print a constraint corresponding to rounding the bound (up for lower bound,
down for upper bound) to an integer.  The output of this command could be
modified slightly to create a {\tt show} command, which could then be 
tentatively included in a proof.  

\indexb{accept}
\begin{commanddeclaration}
{\tt accept} 
$\displaystyle{\underbrace{{\tt (tables\ only)}}_{\hbox{optional}}}$%
\kern5pt{\it file}{\tt;}
\end{commanddeclaration}

Read in the given file of commands, as if in gullible mode, and do so as
quietly as possible.  If the {\tt(tables only)} option is included, only
read in the following commands: {\tt n =}, {\tt no}, {\tt yes}, {\tt type},
{\tt status}, {\tt set lower bound check}, and {\tt unset lower bound check}.

\indexb{go to}
\begin{commanddeclaration}
{\tt go to}\kern5pt{\it string\/}{\tt;}
\end{commanddeclaration}

The given {\it string\/} may be any character string which does not 
contain semicolons; white space is ignored.  Read downward in the command
file until a command which starts with {\it string\/} is 
encountered, and continue execution from there.  

\indexb{exit}
\begin{commanddeclaration}
{\tt exit;}
\end{commanddeclaration}

Terminate execution.

\indexb{find cyclic codes}
\begin{commanddeclaration}
{\tt find}\kern5pt%
$\displaystyle{\overbrace{\hbox{$r${\tt-}}}^{\hbox{optional}}}$%
{\tt cyclic codes;}
\end{commanddeclaration}

If ``$r${\tt-}'' is omitted, $r$ is assumed to be $1$.  It must be the case
that $r|n$.  Let $\sigma$ be the permutation of $n$ given by $x \mapsto x+r$.
Consider all binary vectors $v$ of length $n$, having zeroes in (at least) the 
rightmost $k-1$ positions.  If the code with basis 
$v,\sigma(v), \ldots,\sigma^{k-1}(v)$ realizes the code type, and has not
(up to isomorphism) already been printed out, print it out, giving a definition
for it using the ``{\tt Cyclic}'' operator.  The codes generated by this
command are not necessarily cyclic!

\indexb{is cyclic?}
\begin{commanddeclaration}
{\tt is cyclic?}\kern5pt\superopt{\hbox{\tt(use extra)}}{\tt;}
\end{commanddeclaration}

The current configuration must be terminal.  Determine if it could be described 
by a ``{\tt Cyclic}'' operator.  If the ``{\tt(use extra)}'' is present, the 
{\it extra word\/} form of the ``{\tt Cyclic}'' operator is used; otherwise it 
is not.  The implementation is horrible.

\par\noindent{\sc Note.}\ The command will not in fact find all codes that
could be described by the ``{\tt Cyclic}'' operator, because the permutation
$\sigma$ defined by that command is not necessarily an automorphism of the
code it generates, and the ``{\tt is cyclic?}'' command restricts attention
to $\sigma$'s lying in the automorphism group of the code.

\block{Identifying codes and finding new ones}\label{identify-find-section}

This section contains various tools for identifying codes and finding new ones.
There are two commands and many parameters.
More explanation will be added later.

\indexb{display}
\begin{commanddeclaration}
\verb|matrix |$M$\verb| := |{\it matrix-descriptor}\verb|;|
\end{commanddeclaration}

Declare a globally defined symbol $M$ (which is to 
be any non-null sequence of letters, digits, and underscores) which stands
for the matrix defined by {\it matrix-descriptor}.  To subsequently refer
to this matrix, one uses ``\verb|matrix(|$M$\verb|)|''.

\indexb{alt}
\begin{commanddeclaration}
\verb|alt |{\it matrix-descriptor}\verb|;|
\end{commanddeclaration}

Give an alternate description (up to isomorphism) for the current
configuration, which must be terminal.

\indexb{process}
\begin{commanddeclaration}
\verb|process |{\it matrix-descriptor}\verb|;|
\end{commanddeclaration}

Attempt to make good codes from the given matrix-descriptor, doubling or 
deleting columns if that helps.  If the string ``\verb|@1|'' appears,
it will be replaced by each code known to the program.  If
``\verb|@2|'' also appears, it will be replaced by each code known to the
program, and $\geq$ the code substituted for ``\verb|@1|'', \WRT\ some
internal ordering scheme.  If the string ``\verb|@w1|'' appears, it will be
replaced by each codeword for the code of \verb|@1|, except that only one
codeword is used for each orbit of the codewords under the action of the
automorphism group.  If the string ``\verb|@i1|'' appears, it will be
replaced by each integer between the parameters \verb|i1low| and 
\verb|i1high|.  One may similarly use ``\verb|@i2|''.

There is a special format.  If the expression has the form
$$\verb#Act( #X\verb#, @v )# \hbox{ or }
M\verb# | Act( #X\verb#, @v )#,$$%
where $X$ is an expression which evaluates to an object of type
{\tt MatrixGroup(F2)}, generating a group $G$ of $s \times s$ matrices,
then \verb|@v| will (in effect) be replaced 
by (in succession) each subset $S$ of $\F_2^s$ which meets each orbit of $G$
at most once.  (But if $GS_1 = GS_2$, we don't use both $S_1$ and $S_2$.)
If the parameter ``\verb|min vector weight|'' is set
to a nonzero value, then \verb|@v| will be replaced only by sets of vectors
each having weight equal to at least the given value.

\midhead{Parameters which govern the behavior of the {\tt process} command}

\begin{center}
\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{double}{column pairs} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, consider doubling pairs of 
     columns when this may lead to a good code. \vskip 0.05in}\\ \hline
\dtext{double}{column triples} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, consider doubling triples of 
     columns when this may lead to a good code.  Unusably slow. 
     \vskip 0.05in}\\ \hline
\dtext{double}{column groups} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, consider doubling groups of 
     columns when this may lead to a good code.  \vskip 0.05in}\\ \hline 
{\tt delete pairs} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in Consider deleting up to the given number of
     pairs of bits if (in a given case) it will only lower the minimum distance
     of the code by $1$.  \vskip 0.05in}\\ \hline 
{\tt delete triples} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in Consider deleting up to the given number of
     triples of bits if (in a given case) it will only lower the minimum 
     distance of the code by $2$.  \vskip 0.05in}\\ \hline 
{\tt show even if known} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when a new code is generated
     which has optimal parameters, show it even if it is isomorphic to a
     known code, and give the name of the known code, if it had one.  
     \vskip 0.05in}\\ \hline
{\tt i1low} & $ \geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See {\tt process}.  \vskip 0.05in}\\ \hline
{\tt i1high} & $ \geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See {\tt process}.  \vskip 0.05in}\\ \hline
{\tt i2low} & $ \geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See {\tt process}.  \vskip 0.05in}\\ \hline
{\tt i2high} & $ \geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See {\tt process}.  \vskip 0.05in}\\ \hline
\dtext{show distance}{optimal} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, show codes if they are
     merely distance-optimal, and not necessarily optimal in the strong
     sense.  \vskip 0.05in}\\ \hline 
{\tt show matrix} & $0$, $1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in If set to $0$, don't display the generator
     matrix of a newly discovered code.  \vskip 0.05in}\\ \hline
\dtext{find parameters}{only} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, once a code with given
     parameters has been found, ignore all others with the same parameters.
     \vskip 0.05in}\\ \hline 
\dtext{no column}{deletion} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, don't try to improve a code
     by deleting columns.  \vskip 0.05in}\\ \hline 
\dtext{limited}{deletion} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, don't try as hard to improve
     a code by deleting columns.  \vskip 0.05in}\\ \hline 
\dtext{min vector}{weight} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in See the documentation for the 
     \verb|process| command. \vskip 0.05in}\\ \hline 
\end{longtable}
\end{center}

\midhead{Parameters which cause automatic computation of residual codes}

The following parameters cause certain actions to be taken whenever
a full configuration is encountered via a {\tt config} or {\tt :=} command.
Let $C$ be the associated code.  Certain residual codes of $C$ are computed, 
and in effect piped through a {\tt process} command.

\begin{center}
\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{auto group}{residual transform} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, for each automorphism 
     $\sigma$ of $C$, try projecting onto a union of some of the sets
     $S_r := \setof{i: 1 \leq i \leq n, \sigma^r(i) = i,
          \sigma^j(i) \not= i \hbox{\ for all\ }j\hbox{\ with\ } 
          1 \leq j < i}$, for $1 \leq r \leq n$,
     This command is not
     carried out if the automorphism group is too big.  \vskip 0.05in}\\ \hline
\ttext{auto group}{residual}{transform alt} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, for each $\sigma \in \Aut(C)$,
     try projecting onto a union of some of the orbits of the bits under 
     $\sigma$.  This command is not
     carried out if the automorphism group is too big.  \vskip 0.05in}\\ \hline
\dtext{auto puncture}{transform} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, sort the bits into piles 
     according to the weight enumerator of the corresponding punctured code,
     and then project onto a union of some of the piles.
     \vskip 0.05in}\\ \hline
\dtext{auto residual}{transform} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, for each $w \in C$, form the 
     residual code.  To reduce execution time, only one codeword for each orbit 
     (under the action of the automorphism group of the code) is used.
     \vskip 0.05in}\\ \hline
\dtext{auto dual residual}{transform} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $r$,
     find up to $r$ minimum weight words of $C^\perp$, and form the
     residual code of $C$ \WRT\ each of them.  \vskip 0.05in}\\ \hline
\end{longtable}
\end{center}

The following parameters cause certain actions to be taken whenever
a full configuration is encountered via a {\tt config} or {\tt :=} command.
Let $C$ be the associated code.  Certain transforms of $C$ are computed,
and in effect piped through a {\tt process} command.

The first two parameters are the main ones -- defining two types of 
transforms.  The remaining parameters modify the effect of these.

\begin{center}
\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{auto dual}{transform} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when a {\tt config}
     command is encountered (or when some other command is encountered which 
     invokes a {\tt config} command),
     and if the dimension of the configuration is the same as that of the
     code type, do a search for dual transform codes from the code
     defined by the configuration.  (See \S\ref{matrix-descriptor-section} for
     the definition of dual transform.) \vskip 0.05in}\\ \hline
\dtext{auto orbit}{transform} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in Like ``{\tt auto dual transform}'', but
     looks for ``{\tt dual orbit}'' codes instead.
     \vskip 0.05in}\\ \hline
\dtext{auto transform}{depth} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in Let $r$ be the given value.  When invoking
     the ``{\tt auto dual transform }'' option, sort codewords into piles 
     according to their weight and according to how they meet $r$ fixed bits.
     All possible choices of $r$ bits (up to isomorphism) will be cycled over,
     except that we quit after ``{\tt tuple orbit max}'' choices.
     \vskip 0.05in}\\ \hline
\dtext{auto dual}{column deletion} & $0$, $1$, $2$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, when using the 
     ``{\tt auto dual transform}'' or ``{\tt auto orbit transform}'' option, 
     also try deleting columns from
     the generator matrix of the code defined by the {\tt config} command.
     If set to $2$, only do this.  \vskip 0.05in}\\ \hline
{\tt tuple orbit max} & $\geq 1$ & $5$ &
     \parbox{\parwa}{\vskip 0.05in See ``{\tt auto transform depth}''.
     \vskip 0.05in}\\ \hline
{\tt nzv length max} & $\geq 1$ & $18$ &
     \parbox{\parwa}{\vskip 0.05in This governs the extent of the code search
     carried out when the ``{\tt auto dual transform }'' or
     ``{\tt auto orbit transform}'' option is invoked.  \vskip 0.05in}\\ \hline
{\tt nzv length max2} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value, this causes
     ``{\tt auto dual transform }'' to carry out a second tier of searches,
     when a code within ``{\tt transform pass level}'' of the best $d$ is
     found.  \vskip 0.05in}\\ \hline
\dtext{search vector}{weight max} & $\geq 0$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to a positive value,
     searches will only look at search vectors of weight $\leq$ the given
     value.  \vskip 0.05in}\\ \hline
\dtext{transform}{pass level} & $\geq 0$ & $5$ &
     \parbox{\parwa}{\vskip 0.05in See ``{\tt nzv length max2}''.
     \vskip 0.05in}\\ \hline
\dtext{dual transform}{length limit} & $\geq 1$ & $255$ &
     \parbox{\parwa}{\vskip 0.05in When using the ``{\tt auto dual transform}''
     option, only look for codes of length at most the given value.
     \vskip 0.05in}\\ \hline
\dtext{crazy code}{search} & $0$, $1$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in If set to $1$, searches for good dual and
     orbit transforms are handled in a different (and strange) way.
     \vskip 0.05in}\\ \hline
\dtext{starting}{tuple orbit} & $\geq 1$ & $1$ &
     \parbox{\parwa}{\vskip 0.05in The {\tt auto dual transform} command
     will start with the indicated tuple orbit, and then reset the parameter
     to $1$.  \vskip 0.05in}\\ \hline
{\tt random search} & $0$, $1$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in If set to $1$, both dual transforms and
     orbit transforms are implemented in a different way, using a primitive
     form of simulated annealing.  This is highly experimental.  There are
     various parameters (given below) which effect how it works, as well as 
     some internal parameters which can be adjusted by modifying the source 
     code.  \vskip 0.05in}\\ \hline
{\tt seed count} & $\geq 0$ & $10000$ & 
     \parbox{\parwa}{\vskip 0.05in See {\tt random search}.
     \vskip 0.05in}\\ \hline
{\tt perturbation count} & $\geq 0$ & $100000$ & 
     \parbox{\parwa}{\vskip 0.05in See {\tt random search}.
     \vskip 0.05in}\\ \hline
{\tt starting length} & $\geq 0$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in If set to a nonzero value $l$, always
     begin a random search by starting with a code of length $l$.
     \vskip 0.05in}\\ \hline
\dtext{random doubling}{probability} & $\geq 0, \leq 100$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in When doing a random code search,
     when randomly adding a column group, add one that already is in
     use, with the given probability.  \vskip 0.05in}\\ \hline
{\tt max doubles} & $\geq 0$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in This defines the maximum number of 
     doubled column groups.  \vskip 0.05in}\\ \hline
{\tt level two search} & $0$, $1$ & $0$ & 
     \parbox{\parwa}{\vskip 0.05in If set to $1$, periodically do a complete
     search in the distance two neighborhood of the current point in the
     parameter space.  \vskip 0.05in}\\ \hline
\end{longtable}
\end{center}

Other parameters which effect the search for codes:

\begin{center}
\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
{\tt input mask} & \vbox{\hbox{\tt a list of}\kern3pt\hbox{\tt constraints}}
     & null &
     \parbox{\parwa}{\vskip 0.05in The given linear constraints may involve 
     only the variables $n$ and $k$.  Whenever a {\tt config} or {\tt :=}
     command gives rise to a full configuration, and a post-processing
     parameter such as
     {\tt auto dual transform} has been set, the code type will first be
     tested to see if it satisfies the given constraints.  If one of the
     constraints fails, the post-processing parameter is ignored.
     \vskip 0.05in}\\ \hline
{\tt output mask} & \vbox{\hbox{\tt a list of}\kern3pt\hbox{\tt constraints}}
     & null &
     \parbox{\parwa}{\vskip 0.05in This is similar to {\tt input mask},
     but is applied to a code generated by a post-processing routine.
     It is inconsistently implemented.
     \vskip 0.05in}\\ \hline
\dtext{group size}{limit} & $\geq 0$ & $10000$ &
     \parbox{\parwa}{\vskip 0.05in Various post-processing options will
     not be carried out if a code's automorphism group has size in excess
     of this parameter.  \vskip 0.05in}\\ \hline
\dtext{auto enlarge by}{dual word} & $0$, $3$, $4$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to one of the allowed nonzero values
     (say $r$), attempt to find new codes as with the expression operator
     ``\verb|+ dual word of weight| $r$''.  \vskip 0.05in}\\ \hline
\end{longtable}
\end{center}

\vspace{0.05in}\par\noindent{\sc Parameters:}\ The following parameters
are also associated to the {\tt process} command:

\begin{longtable}{|l|l|l|l|}\hline
\parbox{1.6in}{\bf parameter} & \parbox{1.0in}{\vskip 0.05in {\bf allowed}\\ 
      {\bf values}\vskip 0.05in } & {\bf default} & \parbox{\parwa}{\bf meaning}
      \\ \hline\hline \endhead
\dtext{\tt process !}{clear newcodes} & $0$, $1$ & $0$ &
     \parbox{\parwa}{\vskip 0.05in If set to $1$, each new {\tt process}
     command clears the list of codes kept by the routine 
     {\tt process\string_new\string_matrix}.  \vskip 0.05in}\\ \hline
\end{longtable}

\block{Experimental commands}

The commands of this section are not guaranteed to do what they claim to do.

\indexb{macaulay}
\begin{commanddeclaration}
{\tt macaulay;}
\end{commanddeclaration}

The current configuration must be terminal, and the associated code $C$ must
not have any dual words of weight one or two.  Then $C$ corresponds to
a set $S$ of $n$ points in $\PP^{k-1}$.  Use the program {\tt Macaulay} to
find generators for the homogeneous ideal defining $S$, modulo the 
obvious generators of the form $a^2b + ab^2$, which are always present.
To use this command, {\tt Macaulay} must be executable via a command of the
same name.

\indexb{random macaulay}
\begin{commanddeclaration}
{\tt random macaulay( n = }$n${\tt, k = }$k${\tt, minimum distance >= }$d$%
{\tt, count = }$c${\tt\ );}
\end{commanddeclaration}

Find $c$ ``random'' projective codes of type $[n,k,d]$ and pipe the output to
the {\tt macaulay} command.

\indexb{clean}
\begin{commanddeclaration}
{\tt clean <}\kern5pt{\it input file\/}\kern5pt{\tt>}\kern5pt%
{\it output file}\kern5pt%
$\displaystyle{\underbrace{\hbox{{\tt(}$\VEC v1s${\tt)}}}%
_{\hbox{optional}}}${\tt;}
\end{commanddeclaration}

The {\it input file\/} is to be a file of constraints.  Read it in, try
to simplify, and write the resulting system to {\it output file}.
If the input file contains equality constraints, they will be used to 
eliminate variables, preferentially avoiding $\VEC v1s$ if they are present.
Constraints in the input file should not have repeated variables in them.

\block{Implementation notes}\label{implementation-section}

The source code is written in the language C++.  Although a standard for 
C++ is nearing completion [.C++ working paper.], implementations have naturally
lagged behind, and thus the behavior of existing compilers varies.  For this
reason, at this time the source code will compile only under a single 
compiler, the GNU (Free Software Foundation) compiler, called {\tt g++}.  We 
also use the GNU library {\tt libg++}.  Fortunately, {\tt g++} and {\tt libg++}
are freely available over the network and generally easy to install.

This source code should compile and run on almost any Unix machine.%
\footnote{If you want to use CPLEX, obviously you are restricted
to those platforms for which it is available.}
We would like to say exactly how much memory the program needs, but we do
not know how to compute this at present.  The results were obtained
on a machine with $192$ megabytes of RAM and about $270$ megabytes of swap
space; it is hard to say how much of this was really used by the program.
Much can be done on a machine having only $32$ megabytes of RAM.

As references both for the 
C++ language and the GNU implementation, we refer to Stroustrup's book
[.stroustrup.], the libg++ manuals [.lea users guide.], [.bothner pesch.],
[.regex manual.], and the help guides [.buck faq.],
[.cline faq.].  Other relevant sources are [.stallman compiler manual.],
[.C++ working paper.], and [.stepanov lee.].

We make use of Brendan McKay's graph isomorphism package {\tt nauty} and
Keith Briggs double-double precision package {\tt doubledouble}
[.briggs doubledouble.].

For installation of the source code, we refer to the script ``{\tt INSTALL}''.
It is not possible at present to compile a  working TeX file for this document
from the distribution.

If all goes well, you can now execute with {\tt Split < prog}, where {\tt prog} 
is a program file.  The author will be happy to assist if there are any 
problems!  

A primitive interactive mode may be entered with {\tt Split -i}.  This 
automatically turns off the option ``warnings are fatal''.

|-> prep
#!/bin/csh
# Usage: "prep all" (for first compilation) or "prep" or "prep main" or e.g. 
# "prep simplex".
#
# The -O1 option causes some optimization which greatly speeds up some parts of
# the program.  Deleting it will however cut the compilation time in half.  
#
# The -s option reduces the size of the binary executable file.
#
# The -pipe option slightly speeds up compilation, but should be removed
# for a machine which does not have lots of memory.
#
# To insure compatibility with other systems in which "char"s are by default
# unsigned, it is advisable to test that the program will still compile when
# the option "-funsigned-char" is used.

|-> prep
set DEMO=
set SPLIT=Split
|-> doc/dprep
#!/bin/csh
# "dprep all" compiles demo --> DSplit.
set DEMO=-DDEMO
set SPLIT=DSplit

ifelse(UNAME,Linux,
    ![ifelse(UNAMEM,i386,![DEFINE(SFLAG,-m486 -Dx86)]!,![DEFINE(SFLAG,)]!)]!,
    ![ifelse(UNAME,Openstep,![DEFINE(SFLAG,-DNeXT)]!,![DEFINE(SFLAG,-DSun)]!)]!)
ifelse(UNAME,Openstep,![DEFINE(STRIPFLAG,-x)]!,![DEFINE(STRIPFLAG,-s)]!)
ifelse(UNAME,Openstep,![DEFINE(WFLAG,-w)]!,![DEFINE(WFLAG,)]!)
ifelse(UNAME,Openstep,![DEFINE(LFLAG,-lg++)]!,![DEFINE(LFLAG,)]!)

|-> prep, doc/dprep
if ($1 == "all") then
     gcc -c -O3 -funroll-all-loops -DMAXN=8192 SFLAG cc/nauty.c -Iinc \
          -o obj/nauty.o
     gcc -c -O3 -funroll-all-loops -DMAXN=8192 SFLAG cc/nautil.c -Iinc \
          -o obj/nautil.o
     g++ -c -O3 -DDD_INLINE SFLAG cc/doubledouble.cc -Iinc -o obj/doubledouble.o
     g++ -c -O3 -DDD_INLINE SFLAG cc/math.cc -Iinc -o obj/math.o
     gcc -c cc/random.c -w -Drandom=randomx -Dsrandom=srandomx -o obj/random.o
     g++ cc/parse_fun.cc -pipe -Iinc -I. -O1 -L. -Lobj -lg++ -lgmp_local -lm \
          -s -o doc/parse_fun |& c++filt -sgnu
endif

if ($1 != "all" && $1 != "main" && $1 != "") goto component
set objs = ""
foreach i (permutation constraint matgf2 matreal simplex graph process \
           wordtype split extensions codetable op0 op1 op2 op3 opAI opJZ op \
           execute1 execute2 execute3 config codehome opt mawhome prevec1 \
           sort misc woof woof2 finite codesearch web generic solve)
     if ($i == "opAI" && $1 != "main") then
          echo "parsing functions"
          doc/parse_fun
     endif
     if ($1 != "main") then
          echo compiling $i.cc
          g++ -c cc/$i.cc SFLAG $DEMO -pipe -Iinc -I. -O1 -s -o obj/$i.o
     endif
     set objs = "$objs obj/$i.o"
end

echo "compiling main program"
g++ cc/code.c $objs obj/nauty.o obj/nautil.o obj/doubledouble.o obj/math.o \
     obj/random.o obj/ntl.a SFLAG WFLAG $DEMO -pipe -Iinc -I.  -O1 -L. -Lobj \
     -lg++ -lgmp_local -lm LFLAG -o $SPLIT STRIPFLAG |& c++filt -sgnu
exit
component:
if ($1 == "opAI" || $1 == "opJZ" ) then
     echo "parsing functions"
     doc/parse_fun
endif
g++ -c cc/$1.cc SFLAG -pipe -Iinc -I. -O1 -s -o obj/$1.o

|-> tex/code.tex

\midhead{Execution of the proofs in this report}

I describe here a battery of tests for {\tt Split}, which are carried out
(on my hardware) each time a new version of {\tt Split} is released, and which
you can test on your hardware.  For the steps which require a significant
amount of execution time, I put the location of a log file and the running
time.\footnote{The calculations were performed on a
Sun Ultra 1 Model 140, with 192MB of RAM.  For speed comparisons with other 
hardware, see {\tt http://open.specbench.org}.  Note that since a test of this 
paper's results can be divided into several smaller computations, as via the 
``{\tt set gullible}'' and ``{\tt unset gullible}'' commands, any program file 
can be executed in segments.}

\vspace{0.1in}

\par\noindent\circno1\ The file {\tt inputs/code.data1} is a {\tt Split} 
program file 
for the results which appear in [.jaffe optimal binary 30.].  You can execute 
these results with ``{\tt Split < inputs/code.data1}''.  There is one line 
which takes
a very long time to execute on my machine, and so I put a ``{\tt??}'' in front 
of it to circumvent its execution.
\par\noindent[logfile: {\tt log/code.data1.out}; running time: 11 hours]

\vspace{0.1in}

\par\noindent\circno2\ Edit {\tt inputs/code.data1} as follows, to execute the
line mentioned in \circno1\kern2pt.  Put 
\par\noindent ``\verb|set gullible; set silent;|''
at the beginning.  Before the key line, put
``\verb|unset gullible; unset silent;|''.
This line has been properly carried out only once,
using an unreleased version of {\tt Split} slightly preceding version 0.5.
\par\noindent[logfile: {\tt log/code.data1.hard.out}; running time: 115 hours]

\vspace{0.1in}

\par\noindent\circno3\ To execute the results contained in this
document, type ``{\tt Split < inputs/code.data}''.  This will automatically 
accept (without proof) the results of [.jaffe optimal binary 30.].
\par\noindent[logfile: {\tt log/code.data.out}; running time: 46 hours]

\vspace{0.1in}

\par\noindent\circno4\ You might also wish to type ``{\tt Split -i}'' 
(interactive), and then enter ``{\tt accept inputs/code.data1;}'' followed by 
``{\tt exit;}''.

\vspace{0.1in}

\par\noindent\circno5\ The command ``{\tt Split < doc/code.misc.test}'' will 
test some exploratory commands (and miscellaneous strange things).

\vspace{0.1in}

\par\noindent\circno6\ Add the lines
\begin{verbatim}
     set tables only;
     set optimal;
     set gullible commands = no, yes;
\end{verbatim}
to the beginning of {\tt inputs/code.data1} and again execute it.
\par\noindent[logfile: {\tt log/code.data1.test.out}; running time: 5 minutes]

\vspace{0.1in}

\par\noindent\circno7\ Add the same lines to the beginning of 
{\tt inputs/code.data} (after the {\tt accept} line), and again execute it.
\par\noindent[logfile: {\tt log/code.data.test.out}; running time: 9 hours]

\vspace{0.1in}

\par\noindent\circno8\ Run {\tt Split} on {\tt webcodes/script}.
|-> doc/code.misc.test

type [12,4,6];
bound y*;
show y6 != 0;
bound y*, [x*] <homebrew>;
config 6,6 : {10};
show x24 != 0;
config 2,4,4,2 : {1100,1010};
bound y*, [x*] <homebrew>;

set optimal;
set lower bound check;
n=3,k>=2:2;    n=4,k>=2:2,2;    n=5,k>=2:3,2,2;    n=6,k>=2:4,3,2,2;
n=7,k>=2:4,4,3,2,2;
n=8, k >= 2:   5-5,  4,  4,  2,  2,  2; 
unset optimal;
n=8, k >= 2:   5-5,  2-4,  4-,  2,  2,  2; 

set gullible;
n=9,k>=2:6,4,4,3,2,2,2;                  n=10,k>=2:6,5,4,4,3,2,2,2;
n=11,k>=2:7,6,5,4,4,3,2,2,2;             n=12,k>=2:8,6,6,4,4,4,3,2,2,2;
n=13,k>=2:8,7,6,5,4,4,4,3,2,2,2;         n=14,k>=2:9,8,7,6,5,4,4,4,3,2,2,2;
n=15,k>=2:10,8,8,7,6,5,4,4,4,3,2,2,2;    n=16,k>=2:10,8,8,8,6,6,5,4,4,4,2,2,2,2;
unset gullible;

type [21,8,8_2];
[b] := {011110000011110000000,110010110001101000000,101011010010100100000,
      100111100011000010000,111111111100000000000,000100011011100001100,
      001001111001000001010,010011010011000001001} ::
     {y8 = 89, y10 = 41, y12 = 98, y14 = 22, y16 = 4, y18 = 1, y20 = 0};
is cyclic?;

type [16,8,4];
[a] := Cyclic(1, 16, 8, 000100111) :: 
     {y4 = 55, y6 = 96, y8 = 87, y10 = 16, y12 = 1};
full group size = 3456;
print automorphism group;

[woof] type [12,4,6];
find 2-cyclic codes;
[a] config 6,6 :: {01} : {q_z_6 = 1};
bound q_z_4, q_6_z;
type [16,7,6];
show mu4 != 0;
[mu4] config 12,4 :: {01};
infer sub10 = 16;
[woof] incorporate [woof] below [mu4] via sub10;
dump;
at [woof->a];
bound y*, [x*];

accept (tables only) inputs/code.data1;
accept (tables only) inputs/code.data;
accept inputs/code.data1;
type [24,7,10];
show mu1 = 0;
print config;;print config;print config;printconfig; print time used;
set homebrew;
type [72,36,16_4];
bound y*, [x*];
(* Each line should look like y_i = nonnegative integer. *);
random weight enumerator(n = 20, k = 8, div = 4, modulus = 8, count = 100);
goto (*next*);
This line does not get executed!;
(* next *);
type [3,1,2_2];

|-> tex/code.tex

\block{Plans}

As should be obvious, there are many ways in which the program could be
improved.  We list first some of the most obvious, with comments.
\begin{itemize}
\item The program could be revised to allow for an arbitrary finite base field 
(or ring).  Although worthwhile, this is likely to be a stupendous project, as
almost every aspect of the program would have to be revised.  The author is
interested in collaboratively pursuing this expansion with one or more other
persons.  A good first step would be to write just enough code to see if
something new can be proved about ternary codes using split linear programming.
\item Finish the included provisional implementation of the simplex algorithm
and eliminate the use of CPLEX.  It is not clear how hard this will be.
\item Find new methods.  For example, for partitions with two parts,
can one use the split weight enumerator to get closed-form inequalities
involving the variables $y_i$?
\item Rationalize, restructure, and simplify the language and code so as 
to make it more readable.  The importance of this should not be underestimated,
as it is the readability of the code which governs the ability of other people
to verify the correctness of the claims made in this report.
\end{itemize}

\midhead{Other projects}

\par\noindent
\circno1\ Simonis has pointed out that the automorphism group of 
a configuration can be used to reduce the size of the associated linear
programming problem.  Implementing this would have significant benefits.

\vspace{0.1in}

\par\noindent
\circno2\ Within reason, convert to ``generic C++''.  In particular, reduce
reliance on the GNU C++ Library, and make use 
of the Standard Template Library (STL) where possible.  Don't copy sort code 
from the GNU C++ Library.  Use private member functions where appropriate.
Do not use \verb|const_cast|.  

\vspace{0.1in}

\par\noindent
\circno3\ For codes whose dimension exceeds half their length, split
linear programming problems should be automatically translated into problems
about the dual code, because this greatly improves the numerical conditioning
of the problem.  This is at present done only for the {\tt no} and
{\tt test} commands.

\vspace{0.1in}

\par\noindent
\circno4\ At present we do a unique sort on the list of main constraints 
generated by the split linear programming method.  In some cases this
significantly reduces the length of the constraint file.  Why?  This is
a rather fundamental question.  Would it be better to turn off the sort most 
of the time?  This is a minor practical question.

\vspace{0.1in}

\par\noindent
\circno5\ Unnamed configurations should not be saved when a code type is
left, but to implement this one has to keep track of logical relationships
which use unnamed intermediaries.

\vspace{0.1in}

\par\noindent
\circno6\ Systematically propagate constraints.  The current approach
is haphazard and poorly documented.

\vspace{0.1in}

\par\noindent
\circno7\ Clean up the god-awful messes necessitated by the
compiler's flaky template instantiation.  These have gotten worse and worse.

\vspace{0.1in}

\par\noindent
\circno{8}\ Check the correctness of the two key routines {\tt Isomorphic} and
\verb|find_automorphism_group| (for \verb|vertex_colored_graph|'s) which
invoke {\tt nauty}.

\vspace{0.1in}

\par\noindent
\circno{9}\ Use decent algorithms for working with permutation groups.

\vspace{0.1in}

\par\noindent
\circno{10}\ Add the capability of subdividing along dual local ({\tt z})
variables.

\vspace{0.1in}

\par\noindent
\circno{11}\ I had planned to rewrite {\tt disect} according to the
following plan:
\begin{alphalist}
\item Invoke m4 as before to get .infile.
\item Read .infile into memory (x).
\item Read through x, to compile a list of all files and compute their lengths.
    Allocate space (y) in memory for them. 
\item Build y from x.  Delete x.
\item For each file f, open and ask OS for length(f).  If length(f) has changed,
    simply write y.f to f.  Otherwise, do a side-by-side comparison, y.f vs. f,
    block by block.  If identical, make no change to f.  Otherwise, start
    writing f at the changed block.
\item Disect should create directories and subdirectories as needed.
\end{alphalist}

\midhead{Minor issues and proposed changes}

\par\noindent
\circno{A}\ Program output should be automatically folded to split long lines.

\vspace{0.1in}

\par\noindent
\circno{B}\ Make it impossible to crash the program by entering
anomalous commands.

\vspace{0.1in}

\par\noindent
\circno{C}\ Investigate memory usage by the program.  Some modest changes 
should substantially reduce memory usage.  

\vspace{0.1in}

\par\noindent
\circno{D}\ The {\tt bound} command will not print out values using the maximum 
available accuracy.  To fix this, the class \verb|opt_card| should somehow allow
for {\tt Quad} precision min and max.

\vspace{0.1in}

\par\noindent
\circno{E}\ One could easily add a ``{\tt verify bound}'' command to verify
the assertion of the last {\tt bound} command.

\vspace{0.1in}

\par\noindent
\circno{F}\ Check for two {\tt Split} processes running concurrently in the
same directory.  This can cause strange results and should not be allowed.

\vspace{0.1in}

\par\noindent
\circno{G}\ Implement configuration-list versions of 
{\tt via variable split}, {\tt via varying}, and {\tt deduce}.
\vspace{0.1in}

\par\noindent
\circno{H}\ The following bug in {\tt libg++} has been reported to
\verb|bug-lib-g++@prep.ai.mit.edu|, however {\tt libg++} is no longer
supported.  This bug calls into question the reliability of 
all code which uses the ``{\tt contains}'' method.

\begin{verbatim}
// The following program prints 1.  Shouldn't it print 0?

#include <String.h>
#include <fstream.h>
main( )
{    String swine = "y=5";
     String op = "=";
     cerr << swine.contains(Regex(op), 0) << "\n";    }
\end{verbatim}

\par\noindent Similarly, the following code prints 0:

\begin{verbatim}
#include <String.h>
#include <fstream.h>
main( )
{    static Regex pound_config( "\\[[a-zA-Z_0-9]+#\\]" );
     String commandx = "[x#]";
     cerr << commandx.contains( pound_config, -1 ) << "\n";    }
\end{verbatim}

\par\noindent Another example:

\begin{verbatim}
#include <String.h>
#include <fstream.h>

main( )
{    static Regex brack( "\\[" );
     String s = "P([3_2_2.a])";
     cerr << s.contains( brack, 0 ) << "\n"; 
     cerr << s.contains( brack, 1 ) << "\n"; 
     cerr << s.contains( brack, 2 ) << "\n"; 
     cerr << s.contains( brack, 3 ) << "\n";    }
\end{verbatim}

\par\noindent The following bug has been reported to
\verb|bug-g++@prep.ai.mit.edu| (8/22/96).  The following code yields internal
compiler error $107$.  

\begin{verbatim}
#include <String.h>

main( )
{    static int noptions = 3;
     static Regex option_pats[noptions] = {"a", "b", "c"};    };
\end{verbatim}

\newpage

\part{Results on specific codes}

This part is a program which proves many specific results about codes.  There
are seven places (sections \ref{some-unital-section}, 
\ref{38-27-section}, \ref{40-11-16-section}, \ref{73-12-32}, 
\ref{section-56-71}, \ref{section-72-80}, 
\ref{menagerie-section}) where we use arguments which have not yet been 
completely formalized in the language.  These have to be checked by hand.
(Also, due to an undiagnosed problem with the 
``{\tt auto projection}'' option, one line under \verb|type [142,7,70_2]| must
also be checked by hand.)

The paper [.jaffe optimal binary 30.] naturally precedes this part of the
paper.

We include a number of tables which give upper bounds for the minimum
distance of codes.  These were constructed by first copying the tables
of Brouwer and Verhoeff, adjoining a few other previously known results,
and then adjoining our new results.  

For the tables through $n = 36$, we check the lower bounds as well as the upper 
bounds.  We have not included references for the lower bounds.  Note that
Brouwer and Verhoeff's table gives both upper and lower bounds (with
references). 

All of the tables given here are part of the program, and so each result is 
independently verified.  

For display in this paper, certain informational subscripts and superscripts 
have been added to the entries of the table.  These do not in any way effect
execution, and correspondingly may not be completely reliable.  They in general 
do not reflect any results of other people obtained after about January 1995 or
results of other people obtained before then but unknown to the author.
Corrections will be gratefully accepted.

A question mark as a pre-superscript indicates that the given upper bound is not
known to be sharp.  References are given as post-superscripts.  These have been 
copied from [.brouwer verhoeff 1993.], and reflect only ``main results''.  
Often a single such result yielded many corollaries, but we do not
cite the reference for each such corollary, although credit is in fact due.

A diamond as a pre-subscript indicates that the bound is new.  In most cases
the new bound is just one better than the old bound, but in several cases
$$(n,k) = (42,20), (53,12), (102,13), (168,12), (168,14),$$%
the minimum distance $d$ has been improved by two.

\newpage
\begin{svb}

data_comment( ![ \block{Some doubly even codes that do not exist}

The results of this section are curiously independent of the rest of
the program.  In all cases (except those listed in this section), where
we know that a doubly even $[n,k,d]$ code does not exist, and $4 \mid d$,
we know that there are no $[n,k,d]$ codes at all.  (This statement does
not take account of trivial cases -- 
cf.\ \verb|codetable::not_exist(int, int, weightlist)|). ]! )

accept inputs/code.data.eights;

no [11, 5, 4_4];               no [13, 6, 4_4];          no [27, 13, 8_4];
no [29, 14, 8_4];              no [35, 13, 12_4];        no [34, 17, 8_4];
no [38, 15, 12_4];             no [43, 13, 16_4];        no [46, 15, 16_4];
no [50, 25, 12_4]<homebrew>;   no [51, 19, 16_4];        no [53, 20, 16_4];
no [54, 15, 20_4];             no [51, 25, 12_4];        no [59, 19, 20_4];
no [61, 20, 20_4];             no [65, 18, 24_4];        no [67, 19, 24_4];
no [69, 20, 24_4];             no [59, 25, 16_4];        no [66, 24, 20_4];
no [69, 34, 16_4];             no [73, 18, 28_4];        no [75, 19, 28_4];
no [77, 20, 28_4];             no [81, 18, 32_4];        no [84, 20, 32_4];
no [73, 23, 24_4]<precision = 3>;             
no [74, 31, 20_4];             no [79, 28, 24_4];
no [82, 24, 28_4];             no [83, 39, 20_4];        no [84, 25, 28_4];

data_comment( ![ \def\simonis1896ref{\protect{[.simonis 1896 unique.]}}
     \def\enchevareference{\protect{[.encheva 1992 report.]}}
     \def\dodunekovenchevareference{\protect{[.golay subcodes 1993.]}}
     \def\tilborgreference{\protect{[.tilborg griesmer 1980.]}}
\block{Classification of various codes at the Griesmer bound (most due to 
van Tilborg \tilborgreference)}

In this section we classify codes with various parameters at the Griesmer 
bound: $[35,4,18]$, $[38,4,20]$, and $[42,4,22]$.  
All of these (except the $[35,4,18]$, $[38,4,20]$, and $[42,4,22]$) results are 
special cases of more general results which may be found in 
[.tilborg griesmer 1980.]. ]! )

type [35,4,18];
[1] config 1,3,2,3,1,3,2,3,3,2,3,1,3,2,3 : {100101101001011,010101011010101,
     001100111100110,000011111111000} :: {y18 = 12, y20 = 2, y24 = 1};
[2] config 1,3,2,3,2,2,2,3,3,2,2,2,3,2,3 : {100101101001011,010101011010101,
     001100111100110,000011111111000} :: {y18 = 11, y20 = 3, y22 = 1};
[3] config 2,2,2,3,2,2,2,3,2,3,2,2,3,2,3 : {100101101001011,010101011010101,
     001100111100110,000011111111000} :: {y18 = 10, y20 = 5};

CLASSIFICATION_OF([base], x_18|x99|x4455, ![[1], [2], [3]]! )
status: classified, weights = {18,20,22,24};

type [38,4,20];
config from x_20|x_10_10;
show y20 = 14, y24 = 1;
[a] config from x5555|x22223333;
classification of [base]: [a];
STATUS_UNIQUE_WE(1 + 14t^20 + t^24)

no [41,4,22];
type [42,4,22];
config from x_22;
show y22 = 12, y24 = 3, y28 = 0;
[a] config from x_10_12|x4666|x23333332;
classification of [base]: [a];
STATUS_UNIQUE_WE(1 + 12t^22 + 3t^24)

[23_7_9] type [23,7,9];
load constraints by parity check from [24_7_10];
data_comment( ![ \def\simonis1987ref{\protect{[.simonis 1987 25_15_6.]}} 
\def\simoniswagnerref{\protect{[.simonis wagner unique.]}}
\block{Classification of projective $[27,6,12]$ codes} ]! )

[15_5_6proj] type [15,5,6]{mu1 = 0, mu2 = 0};
[8] config from x8;
[base] <--> [x1..22] := Build( [15_5_6proj], [8] );

[27_6_12proj] type [27,6,12]{mu1 = 0, mu2 = 0};
kill y27, y25;

[24] config 27 ::: {y24 != 0};
[24x] config from x_24|x_12_0|x660;
[24x] <--> [x1..3] := Build( [27_6_12proj], [24x] );

[26] config 27 ::: {y26 != 0};
[26x] config from x_26|x_11_1|x471;
[x4] := Build( [27_6_12proj], [26x] );
via building [26x] implies [x4];

[else] config 27 ::: {y24 = 0, y26 = 0};
[else] <--> [x5..60] := Unresidue( [27_6_12proj], [else], [15_5_6proj.x1..22] );

via variable split [base] = [24] or [26] or [else];

classification of [base]: [x1..60];

data_comment( ![ \block{Some unital $[28,\geq 7,10]$ codes whose dual codes 
may contain designs}
\label{some-unital-section}

This section contains a partial classification of the codes which are the
codes of $2-(28,4,1)$ designs of rank $20$ or $21$.  The classification is
partial because of the following:
\begin{itemize}
\item There may be some codes listed which are not the codes of such designs.
\item There are some forced gullibilities (``{\tt ??}''), although the
     validity of the forced commands is trivially checked.
\item We rely on facts from design theory.
\end{itemize}
This material is part of joint work with Tonchev [.jaffe tonchev rank 20.], 
which contains a classification of all $2-(28,4,1)$ designs of rank $20$ and 
$21$. ]! )

[28_5_10deu] type [28,5,10_4]{y28 = 1};

[1] config 1,3,1,2,3,2,1,2,3,2,2,3,2,1 : 
{10001100111100,01001100110011,00101001010101,00010101011010,00000011111111};
[2] config 1,1,2,1,2,2,3,1,2,2,3,4,1,1,2 : 
{100001100111100,010010101011010,001011001101001,000111100001111,
000000011111111};
[3] config 1,2,1,2,1,2,1,2,1,2,1,2,1,2,5,2 : 
{1001011001101001,0101010101010101,0011001100110011,0000111100001111,
0000000011111111};
[4] config 4,2,2,2,2,2,2,2,2,2,2,2,2 : 
{1000000001111,0100101101001,0010101011010,0001100111100,0000011111111};
[5] config 1,1,1,1,1,1,3,3,1,3,1,3,1,3,3,1 : 
{1001011001101001,0101010101010101,0011001100110011,0000111100001111,
0000000011111111};

CLASSIFICATION_OF([base], x_28|x_12, ![[1], [2], [3], [4], [5]]!)

[28_6_10deu] type [28,6,10_4]{y28 = 1};

[1] config 1,3,1,1,1,2,1,1,1,1,1,1,2,1,1,1,1,1,1,2,1,1,1 : 
{10000111100011111111000,01000111100011110000111,00100110001100110011001,
00010101001010101010101,00001100100110010110011,00000000011111111111111};
[2] config 1,1,2,1,2,1,2,2,1,1,1,1,2,1,1,1,1,2,1,1,1,1 : 
{1000011100011111111000,0100010101010101010101,0010001001001011010010,
0001011001100110011001,0000100101100111100110,0000000011111111111111};
[3] config 1,1,2,1,2,2,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,1 : 
{1000011110001111111100,0100010100101010101010,0010001010100101101001,
0001011000110011001101,0000100110110011110010,0000000001111111111111};
[4] config 1,1,1,1,1,1,2,1,2,1,1,2,1,1,2,1,1,2,1,2,1,1 : 
{1001010110001110110101,0101010011011011011001,0011000101010101010011,
0000110101010010101011,0000001010010010010100,0000000000111111111111};
[5] config 1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 : 
{1001011000011110011000011,0101010010110011001100110,0011001010101101001011010,
0000111010101010110101010,0000000100101010101010101,0000000001111111111111111};

CLASSIFICATION_OF([base], x_28|x_12|x_4_8, ![[1], [2], [3], [4], [5]]!)

[28_7_10deu] type [28,7,10_4]{y28 = 1};


[1] := {1000010110110001011000101100,0100010101000010100111011100,
     0010000011100100110001110011,0001000011010110101101001010,
     0000110011000001101100110110,0000001111110000001111111111,
     0000000000001111111111111111};
[2] := {1000010110110001011000100011,0100010101000010100111010011,
     0010000011100100110001110011,0001000011010110101101001010,
     0000110011000001101100110110,0000001111110000001111111111,
     0000000000001111111111111111};
[3] := {1000010110110101001010100100,0100010101000110110101010100,
     0010000011100100110001110011,0001000011010110101101001010,
     0000110011000001101100110110,0000001111110000001111111111,
     0000000000001111111111111111};
[4] := {1000010111100111100011101101,0100010100010100011100011101,
     0010010010010010011101100011,0001010001010001011011011010,
     0000110000110000110110110110,0000001111110000001111111111,
     0000000000001111111111111111};

CLASSIFICATION_OF([base], x_28|x_12|x_6_6|x2226, ![[1], [2], [3], [4]]!)

type [28,8,10_2]{y28 = 1}
     /partition_of_word_by_dual_words(weight = 12, dual_weight = 4), 
     dual_may_be_code_of_design(t = 2, k = 4, lambda = 1),
     doubly_even_part_is_subcode/;

[128] config 28 ::: {div4 = 128};
via building [28_7_10deu:{1,2,3,4}] implies ;
??classification of [128]: ;

[64] config 28 ::: {div4 = 64};
via building [28_6_10deu:{1,2,3,4,5}] implies ;
??classification of [64]: ;

??classification of [base]: ;

type [28,7,10_2]{y28 = 1}
     /partition_of_word_by_dual_words(weight = 12, dual_weight = 4), 
     dual_may_be_code_of_design(t = 2, k = 4, lambda = 1),
     doubly_even_part_is_subcode/;

[a] := {1000010111100111100011101101,0100010100010100011100011101,
0010010010010010011101100011,0001010001010001011011011010,
0000110000110000110110110110,0000001111110000001111111111,
0000000000001111111111111111} :: {y12 = 63, y16 = 63, y28 = 1};

[b] config 1,1,1,1,2,1,1,1,1,2,2,1,1,2,1,1,2,2,1,1,1,1 : 
{1001001010001001101010,0101001010001110111001,0011000000000111101100,
0000100001011100100011,0000011001011011101100,0000000111000111110000,
0000000000111111111111} :: 
     {y10 = 24, y12 = 15, y14 = 48, y16 = 15, y18 = 24, y28 = 1};

[c] config 1,3,2,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2 : 
{10000001000010110011101,01000001000010111100010,00100001101111001100001,
00010011101011010101111,00001010000111101001001,00000111100011111111000,
00000000011111111111111} ::
     {y10 = 24, y12 = 15, y14 = 48, y16 = 15, y18 = 24, y28 = 1};

[d] config 2,2,2,2,1,1,1,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1 : 
{1000001100101000111010,0100001100101011000101,0010001101110011000011,
0001001101001111001100,0000101001011010101010,0000010101100101011010,
0000000011111111111111} ::
     {y10 = 24, y12 = 15, y14 = 48, y16 = 15, y18 = 24, y28 = 1};

[e] config 2,2,1,1,1,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 : 
{100000010000101000111010,010000010000101011000101,001001010110101010011111,
000101000101011001011100,000011010011001111001100,000000110000111111110000,
000000001111111111111111} ::
     {y10 = 20, y12 = 15, y14 = 56, y16 = 15, y18 = 20, y28 = 1};

[f] config 2,2,1,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 : 
{100000000010101100101011,010000000010101111010100,001000100111000101101001,
000100010100110110101010,000010110011001111001100,000001110000111111110000,
000000001111111111111111} ::
     {y10 = 20, y12 = 15, y14 = 56, y16 = 15, y18 = 20, y28 = 1};

[g] config 4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 : 
{1000000000000000011111111,0100100110110100101010000,0010100000101010110010011,
0001100110011001111001100,0000010100011101010101010,0000001010011010101011010,
0000000001111111111111111} ::
     {y10 = 24, y12 = 15, y14 = 48, y16 = 15, y18 = 24, y28 = 1};

[h] config 1,1,1,1,1,1,2,1,2,1,1,2,1,1,2,1,1,2,1,2,1,1 : 
{1001010100001100011010,0101010001011001110110,0011000101010101010011,
0000110101010010101011,0000001000010000111011,0000000010000010101111,
0000000000111111111111} ::
     {y10 = 20, y12 = 31, y14 = 24, y16 = 31, y18 = 20, y28 = 1};


[128] config 28 ::: {div4 = 128};
CLASSIFICATION_OF([128], x_28|x_12|x_6_6|x2226, [a])

[64] config 28 ::: {div4 = 64};
{    via building [28_6_10deu:{1,2,3,5}] implies ;
     via building [28_6_10deu:4] implies [a], [h]    };
??classification of [64]: [h];

[32] config 28 ::: {div4 = 32};
via building [28_5_10deu:{1,2,3}] implies ;
via building [28_5_10deu:4] implies [a], [b], [c], [d], [e], [f], [g], [h];
via building [28_5_10deu:5] implies [a], [h];
??classification of [32]: [b], [c], [d], [e], [f], [g];

??classification of [base]: [a], [b], [c], [d], [e], [f], [g], [h];

data_comment(![\def\heijnenref{\protect{[.heijnen.]}}
\def\hyttref{\protect{[.helleseth ytrehus 33_8_14.]}}]!)

no [31,7,14];

[33_8_14] type [33,8,14];
CREDIT(existence due to Said and Palazzo, said palazzo)
DHIDE( ![ Neither [a] nor [b] is cyclic. ]! )
[a] := {100000000111101100011100101101000,010000000100111011010110010100011,
001000001100010101001101010010111,000100001110110110000000100111110,
000010001101110010111011101110011,000001000011110001100111100001110,
000000100000001111100000011111111,000000010000000000011111111111110};
[b] := Act( { (1,2)(3,5)(7,9), (1,3)(2,5)(6,8), (1,2)(3,9)(4,6)(5,7) },
     {000010011,000010100,000100101,000111110,001010111,010011111,111011111});
disjoint [a], [b];
status: realizable, weights = 14_2 - {28..33}, constraints = {89 <= y14 <= 99, 
     62 <= y16 <= 95, 6 <= y18 <= 44, 20 <= y20 <= 52, 9 <= y22 <= 30,
     y24 <= 5, y26 <= 2, mu3 = 0, 96 <= div4 <= 136};

[29_6_13] type [29,6,13];
load constraints by parity check from [30_6_14];

data_block(There is no $[34,9,14]$ code (Heijnen \heijnenref))
type [34,9,14_2];
{    config from x_14;
     show y34 = 0, y22 != 0;
     at [base];
     =config 22,12 : {10};
     config from x_11_3;
     show mu4 != 0;
     [mu4] config 30,4 :: {01};
     [30_6_14] incorporate [30_6_14] below [mu4] via sub10;
     @[30_6_14->base] infer y30 != 0;
     via lp [base] =     };
no [34,9,14];

type [36,10,14_2];
status: constraints = {176 <= y14 <= 247, 125 <= y16 <= 321, 45 <= y18 <= 336,
     72 <= y20 <= 364, 63 <= y22 <= 243, y24 <= 68, y26 <= 24, y28 <= 10,
     y30 <= 4, y32 <= 2, y34 <= 1};

data_comment( ![ \def\dodunekovref{\protect{[.dodunekov ytrehus 1987.]}}
\block{Classification of $[36,8,16]$ codes}

These have been classified up to weight enumerator by
Dodunekov et.\ al.{\ }\dodunekovref. ]! )
 
[32_5_16] type [32,5,16];
[1] config 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2 : {1001011001101001,
     0101010101010101,0011001100110011,0000111100001111,0000000011111111} ::
     {1 + 30t^16 + t^32};
[2] config 2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2 : 
     {100101011010101001010110,010101010101101010101010,
      001100001111111100001100,000011001100110011001111,
      000000110011001100111111} :: {1 + 29t^16 + 2t^24};
[3] config 2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2 : 
     {1001010101101010100101010110,0101010101010110101010101010,
     0011000011001100110011110011,0000110011110011000011001111,
     0000001111111111111111000000} :: {1 + 27t^16 + 4t^20};
[4] config 1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1 : 
     {100001100111100110000110011110,010010101011010101001010101101,
     001011001101001011010011001011,000111100001111111100001111000,
     000000011111111111111110000000} :: {1 + 23t^16 + 8t^18};
[5] config 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1 : 
     {1001011001101001011010011001011,0101010101010101101010101010101,
     0011001100110011110011001100110,0000111100001111111100001111000,
     0000000011111111111111110000000} :: {1 + 15t^16 + 16t^17};
[6] config 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 : 
     {10010110011010010110100110010110,01010101010101011010101010101010,
     00110011001100111100110011001100,00001111000011111111000011110000,
     00000000111111111111111100000000} :: {1 + 31t^16};
at [base];
config from x_16|x88;
reduce variable set;
show x3337 = 0;
config from x4444;
via building [current] implies [1..6];
classification of [base]: [1..6];

type [36,8,16];
CREDIT(![existence due to Dodunekov, Helleseth, Manev, and Ytrehus]!,
     dodunekov ytrehus 1987)

[a] := Cyclic( {12,6,6,12}, 36, 8, 01010100111000100011111011011 );
[b] := Cyclic( {12,12,6,6}, 36, 8, 0001011010000011101000110111111 );
disjoint [a], [b];

at [base];
show y16 = 153, y20 = 72, y24 = 30;
show (joint:0) jy24d4 != 0;
show mu4 != 0;
[mu4] config 32,4 :: {01};
[32_5_16] incorporate [32_5_16] below [mu4] via sub10;
via building [32_5_16->2] implies [a], [b];
??classification of [base]: [a], [b];
(* This is justified, since jy24d4 != 0, and [32_5_16->2] is the only
   [32,5,16] code having a word of weight 24. *);

STATUS_RE_CLASS_WE(1 + 153t^16 + 72t^20 + 30t^24)

data_block(Table for codes of length $32$ through $36$)

type [31,25,4_2]; status: weights = 4_2 - {30};

type [36,17,10_2];
=[mu8] config 28,8 :: {01};
[28_10_10] incorporate [28_10_10] below [mu8] via sub10;
via extension [28_10_10->{a,b,c,d*,e*,f,g*}] implies ;
classification of [mu8]: ;
no [36,17,10];

type [37,5,18_2]; status: weights = 18_2 - {34,36};

DHIDE( ![ Not cyclic: ]! )
[39_12_14] type [39,12,14];
CREDIT(existence due to Bierbrauer and Edel, bierbrauer edel reed solomon)
[a] := {
111100101000011111011010011000000000000,
000110111001101100110111010100000000000,
110101111101100011000001110010000000000,
010110011111010010111010100001000000000,
001011001111000111011101010000100000000,
101101000011111010110100110000010000000,
100010010101100001110011100000001000001,
001011110110110010111101100000000100001,
011111010001000010001100110000000010001,
100100011111110111010110010000000001001,
011010001000111001100011010000000000101,
101010100101101110011110110000000000011};
CREDIT(existence due to Bierbrauer and Edel, bierbrauer edel reed solomon)
status: realizable;

unset auto group computation;
type [33,23,5];
credit: existence due to J. B. Shearer;
[a] := {010100101010000000000000000000000,
110001110000000000000000000000000,011001000001100000000000000000000,
110100100001010000000000000000000,110101001001001000000000000000000,
111110000000000000000000000000000,111001000000000110000000000000000,
100100100000000101000000000000000,111100101000000100100000000000000,
101101000001000100010000000000000,110000101001000100001000000000000,
101001001100000000000000000000000,001101000000000000000110000000000,
100000101000000000000101000000000,111101101000000000000100100000000,
000001100001000000000100010000000,001100101001000000000100001000000,
110101100000000100000100000100000,101100001000000100000100000010000,
001000000001000100000100000001000,011101100001000100000100000000100,
010001001001000100000100000000010,101001101001000100000100000000001};
credit: existence due to J. B. Shearer;
status: realizable;

type [37,22,7];
credit: existence due to J. B. Shearer;
[a] :=
{1110000111100000000000000000000000000,1101010110000001100000000000000000000,
1111111000000000000000000000000000000,1000110101000000011000000000000000000,
1001100110011000000000000000000000000,0110100100010000000110000000000000000,
0111000000000001010101000000000000000,0100000111010001010100100000000000000,
0101010101010100000000000000000000000,0100110110000000000000011000000000000,
1110000100000001010000010100000000000,0110010011010001010000010010000000000,
0101110000000001000100010001000000000,1010110100010001000100010000100000000,
0001100010000000010100010000010000000,0010000111000000010100010000001000000,
0010110011010010000000000000000000000,0011010110000000000000000000000110000,
0000110100000001000100000000000101000,1011100101000001000000010000000100100,
0001110001010001000000010000000100010,1101000110010000000100010000000100001};
credit: existence due to J. B. Shearer;
status: realizable;

type [47,36,5];
credit: existence due to J. B. Shearer;
[a] :=
{10010100001100000000000000000000000000000000000,
10010010101010000000000000000000000000000000000,
11111000000000000000000000000000000000000000000,
11010010000001100000000000000000000000000000000,
00110110100001010000000000000000000000000000000,
11110110001001001000000000000000000000000000000,
00100100101001000100000000000000000000000000000,
01010110101001000010000000000000000000000000000,
10100110110000000000000000000000000000000000000,
11100100000000000001100000000000000000000000000,
10110100100000000001010000000000000000000000000,
11010010001000000001001000000000000000000000000,
11100000101000000001000100000000000000000000000,
00000010101000000001000010000000000000000000000,
01100000000001000001000001000000000000000000000,
01010000100001000001000000100000000000000000000,
11100010100001000001000000010000000000000000000,
10100000001001000001000000001000000000000000000,
10000110001001000001000000000100000000000000000,
10010100101001000001000000000010000000000000000,
11000111000000000000000000000000000000000000000,
10100100000000000000000000000001100000000000000,
01010010000000000000000000000001010000000000000,
01110000100000000000000000000001001000000000000,
00010100100000000000000000000001000100000000000,
01000100001000000000000000000001000010000000000,
00100010001000000000000000000001000001000000000,
11100010000001000000000000000001000000100000000,
10010000001001000000000000000001000000010000000,
11000100101001000000000000000001000000001000000,
01110100000000000001000000000001000000000100000,
10000110100000000001000000000001000000000010000,
00110100101000000001000000000001000000000001000,
10010100000001000001000000000001000000000000100,
00100110100001000001000000000001000000000000010,
00110110001001000001000000000001000000000000001};
credit: existence due to J. B. Shearer;
status: realizable;

type [35,16,9];
credit: existence due to J. B. Shearer;
[a] :=
{01010101001010010101000000000000000,11110000011111000000000000000000000,
01010110001100100000110000000000000,11001100011000111000000000000000000,
01100111000110100000001100000000000,01110010010000010000101010000000000,
10000001011100110100101001000000000,11111111100000000000000000000000000,
00011111001100110100000000110000000,01001111010100010000001000101000000,
11111010001110100100101000100100000,10101010010100100110000000000000000,
10010111011100000100100000000011000,01000100010110110100001000000010100,
00110001010010100000100000100010010,10000000010010000100101000100010001};
credit: existence due to J. B. Shearer;
status: realizable;

type [33,12,11];
credit: existence due to J. B. Shearer;
[a] :=
{001101101001101001001100000000000,101011010101010100101010000000000,
111110000001111110000000000000000,100111011001011001000001100000000,
110001110001110001110000000000000,011010111000111001000000011000000,
110001001101010100000001010100000,111111111110000000000000000000000,
000111101100100100101000000011000,000010101001110101000001000010100,
000001000001111100101000010010010,101001000101001001001001010010001};
credit: existence due to J. B. Shearer;
status: realizable;

[35_9_14] type [35,9,14];  (* to be continued later *);
CREDIT(existence due to Piret, piret good block codes)
[a] := Cyclic( {17,17}, 35, 9, 01111000000111101000001101001011001 );
status: realizable;

type [45,16,13];
CREDIT(existence due to Dougherty and Janwa, dougherty janwa radius)
[a] := Cyclic(1, 45, 16, 10110000111000100011100001101,
     111110011100000010001000100000000000000000011);
CREDIT(existence due to Dougherty and Janwa, dougherty janwa radius)
status: realizable;

type [36,14,11];
credit: existence due to Masakatu Morii;
[a] :=
{100000000000001111111111000000000000,010000000000000110000001101110010011,
001000000000000010011110000010011011,000100000000001100001000000111101011,
000010000000000011010011010101100100,000001000000000100010100101010101110,
000000100000001111000100100101000110,000000010000001110010000011000111011,
000000001000001011001010100110110000,000000000100000101101001101001001010,
000000000010000100101110001100000111,000000000001001010000111001000110110,
000000000000100001101000011110101100,000000000000010111100101010110000101};
credit: existence due to Masakatu Morii;
status: realizable;

no [33,12,12];
no [35,13,12]<homebrew, auto joint test>;

no [33,12,12];
type [34,12,12_2];
show (joint:5) y34 = 0 <precision=2>;
status: weights = {12,14,16,18,20,22,24,26,28,30,32};

type [35,7,16];
kill jy20y20y28 <adjoin extra brouwer constraints>;

psheadx(90)
// k =         2   3   4   5   6   7   8   9  10     11     12  13  14     15     16
psnext
n=31, k >= 2: 20, 17, 16, 16, 15, 13coderef(tilborg 1981 discrete), 12, 12, 12,    11,    10,  9coderef(prins thesis),   8,   8,     8; sn
n=32, k >= 2: 21, 18, 16, 16, 16, 14, 13, 12, 12,    12,    10, 10, 8-9,   8,     8; sn
n=33, k >= 2: 22, 18, 16, 16, 16, 14, 14, 12coderef(heijnen), 12,    12,    11coderef(hill traynor), 10, 9-10,  8-9,   8; sn
n=34, k >= 2: 22, 19, 17, 16, 16, 15coderef(tilborg 1981 discrete), 14, 13, 12,    12,    12,    newd1()10, 10,    9-10,  8-9; sn
n=35, k >= 2: 23, 20, 18, 16, 16, 16, 15, 14, 12-13, 12,    12,    newd1()11,    newd1()10,    10,    9-10; sn
n=36, k >= 2: 24, 20, 18, 17, 16, 16, 16, 14, 13-14, 12-13, 12, 12,       newd1()11,       newd1k(16)10,    10;
pstail

pshead(90)
// k =        17     18     19    20    21    22   23  24   25   26   27  28  29  30
psnext
n=31, k >=17:  newd()7,      newd1k(21)6,     6,    6,    5,    4,   4,  4,   4,   3,   2,  2,  2,  2; sn
n=32, k >=17:  8,     6-newd1()7,    newd()6,    6,    6,    5,   4,  4,   4,   4,   2,  2,  2,  2; sn
n=33, k >=17:  8,     7-8,   6-newd1()7,  newd()6,   6,    6,   5,  4,   4,   4,   3,  2,  2,  2; sn
n=34, k >=17:  8,     8,     7-8,  6-newd1()7, 6,    6,   6,  4-5, 4,   4,   4,  3,  2,  2; sn
n=35, k >=17:  newd()8,     8,     8,    7-8,  6-7coderef(brouwer linear programming bound),  6,   6,  5-6, 4-5, 4,   4,  4,  3,  2; sn
n=36, k >=17:  8-newd1()9, newd()8,     8,    8,    7-8,  6-7, 6,  6,   5-6, 4-5, 4,  4,  4,  3;
pstail

pshead(80)
// k =        31  32  33  34  35
psnext
n=32, k >=31:  2; sn
n=33, k >=31:  2,  2; sn
n=34, k >=31:  2,  2,  2; sn
n=35, k >=31:  2,  2,  2,  2; sn
n=36, k >=31:  2,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}

|-> tex/code.tex, inputs/code.data
unset lower bound check;

data_comment(![\def\tonchevquadricsref{\protect{[.tonchev designs codes 
quadrics.]}}
\block{Classification of self-complementary $[36,7,16]$ codes
(Tonchev \tonchevquadricsref)} ]! )

type [36,7,16]{y36=1};

[1] := Cyclic( {7,7,7,7,7}, 36, 7, 000111000101100101010011011101011111 );
[2] := {100001000110010101111101000101010001,
     010001000101101001110010111010100001,001000011100001100110001111110001100,
     000100010011001101010110010110010101,000011001100111101101000011000010110,
     000000111111111100000000001111111111,000000000000000011111111111111111111};
[3] := Cyclic( {14,14,7}, 36, 7, 001011011001000101111101110100110101 );
[4] := {100001000100111000010011100011101101,
     010001000111000100011100011100011101,001001011000100101100010011101100011,
     000101010110110101011011011011011010,000011001101101100110110110110110110,
     000000111111111100000000001111111111,000000000000000011111111111111111111};

{    at [base];
     =config 36 : {1};
     show y17 = 0, y18 = 0, y19 = 0;
     config from x_16|x_6_10|x2446;
     via building [current] implies [1], [2], [3], [4];
     disjoint [1], [2], [3], [4]    };
classification of [base]: [1], [2], [3], [4];

data_comment(\block{There is no $[38,27,6]$ code}\label{38-27-section}

This section contains an informal argument which has not yet been
formalized in the language.)

type [38,27,6_2];
show mu14 >= 2;

data_comment(![ Let $C$ be an even $[38,27,6]$ code.
Consider $w \in C^\perp$ of weight $14$.  The subcode of $C$ disjoint from it
is a $[24,14,6]$ code, which we know [.jaffe optimal binary 30.] must have a
word of weight $24$.  Thus for each such $w$, we can find some word of weight 
$24$ which is in $C \cap C^\perp$.  In particular, we see that
$C \cap C^\perp$ has at least two words of weight $24$.  There are exactly
three plausible ways in which these two words may intersect.  We proceed to 
show that none of these may happen, and hence that no such code $C$ exists.  ]!)

!config 12,12,12,2 : {1100,0110} : {1100,0110};
!config 10,14,10,4 : {1100,0110} : {1100,0110};
!config 8,16,8,6 : {1100,0110} : {1100,0110};

??classification of [base]: ;

data_comment(\block{There is no $[40,11,16]$ code}\label{40-11-16-section})

[32_5_16x20x24] type [32,5,{16,20,24}];

[a] config 2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2 : 
     {100101011010101001010110,010101010101101010101010,
     001100001111111100001100,000011001100110011001111,
     000000110011001100111111} :: {y16 = 29, y20 = 0, y24 = 2};

[b] config 2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2 : 
     {1001010101101010100101010110,0101010101010110101010101010,
     0011000011001100110011110011,0000110011110011000011001111,
     0000001111111111111111000000} :: {y16 = 27, y20 = 4, y24 = 0};

[c] config 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 : 
     {10010110011010010110100110010110,01010101010101011010101010101010,
     00110011001100111100110011001100,00001111000011111111000011110000,
     00000000111111111111111100000000} :: {y16 = 31, y20 = 0, y24 = 0};

CLASSIFICATION_OF([base], x_16|x88|x4444, ![[a], [b], [c]]!)

type [32,6,{16,20,24}];
via lp [current] = ;

[36_8_16x20x24] type [36,8,{16,20,24}];

at [base];
show mu4 != 0;
[mu4] config 32,4 :: {01};
[32] incorporate [32_5_16x20x24] below [mu4] via sub10;

at [base];
show y24 != 0;
config 24,12 : {10};
show z_0_4 != 0;

data_comment( The above calculation shows that there is a word of weight $24$ 
disjoint from a dual word of weight $4$.  This justifies the following line: )

??[base] = [32->a];

[1] := {100000100001000111001111100110101010,
     010000010100010000111111100110100101,001001110000010101011111111001110011,
     000101000101000011110101001010110011,000011110000000010100101110011001111,
     000000001100001110011001110000111111,000000000011001100110011111111110000,
     000000000000111101010101001111001111};
[2] := {100001110000010100100111100101010101,
     010001000101000010111110100110101010,001000100000010111010111101010101100,
     000100010101000001111101011001101100,000011110000000011001100110000111111,
     000000001100001111110000110011001111,000000000011001100110011111111110000,
     000000000000111100111100001100111111};

via building [32->a] implies [1], [2];

disjoint [1], [2];
classification of [base]: [1], [2];

type [40,11,16_2];
{    kill y38, ndiv4, y36, y32, y28;
     show (joint:0) mu4 != 0;
     [mu4] config 36,4 :: {01};
     [36] incorporate [36_8_16x20x24] below [mu4] via sub10;
     via building [36->1] implies ;
     via building [36->2] implies ;
     classification of [base]:    };
no [40,11,16];

data_comment( ![ We give some information about $[39,10,16]$ codes, whose
existence is unknown. ]! )

type [39,10,16_2];
show (joint, iterate) y30 = 0, y32 = 0, y34 = 0, y36 = 0, y38 = 0, div4 = 1024;
status: weights = {16,20,24,28};

type [39,10,16]; status: weights = {16,20,24,28};

data_comment( ![ There is a word of weight $28$, as otherwise (by adjoining 
the all-ones word) one would obtain a $[39,11,15]$ code, and thence a 
$[40,11,16]$ code. ]! )

??show y28 >= 1;

show (joint:7) y28 = 2;
show y16 = 367, y20 = 414, y24 = 240, y28 = 2, mu4 = 14;

config 33,2,2,2 :: {0110,0011}; 
show x_24_0_2_2 = 0, x_24_2_0_2 = 0, x_24_2_2_0 = 0, x_25_1_1_1 = 0,
     x_26_0_0_2 = 0, x_26_0_2_0 = 0, x_26_2_0_0 = 0, x_28_0_0_0 = 0 
     <precision=3>;
kill [current] by x_10_2_2_2 <precision=2>;

data_comment(![ Thus two dual words of weight $4$ can't meet along $2$ bits. ]!)

at [base];
??show jd4d4d4 = 0;
STATUS_WE(1 + 367t^16 + 414t^20 + 240t^24 + 2t^28)

data_block(Table for codes of length $37$ through $39$)
no [38,27,6];
no [38,16,12]<limited secondary kill>;

type [38,12,14_2];
kill y38 by x_14;
status: weights = {14,16,18,20,22,24,26,28,30,32,34,36};

no [39,13,14]<auto joint test, homebrew, precision=2>;

no [37,9,16];
type [38,9,16_2];
{    kill y38, y36, y34 by (x_12_4, x_13_3);
     show (joint:5) y32 = 0;
     show (joint:5) y30 = 0    };
status: weights = {16,18,20,22,24,26,28};
kill y26 by (x79, x_8_10, x99, x_9_11, x_10_10, x_11_7, x_12_12);
kill jy16y22y28, jy18y18y28, jy18y20y28, jy18y22y22, jy18y22y28, jy18y24y28, 
     jy22y22y22, jy16y18y28, jy18y18y18, jy18y18y22, jy18y24y24
     <adjoin extra brouwer constraints>;
show (joint:5) 192 <= y16 <= 225, y18 <= 85, 88 <= y20 <= 206, y22 <= 64,
     83 <= y24 <= 102, y28 <= 2, div4 >= 372;
infer div4 >= 384;
kill jy16y18y24, jy16y22y24, jy18y18y20, jy18y18y24, jy18y20y20, jy18y20y22
     <adjoin extra brouwer constraints>;
show (joint:5) y18 = 0, y22 = 0;
status: weights = {16,20,24,28};
type [38,9,16]; status: weights = {16,17,20,21,24,28};

type [38,12,14_2];
show (joint:0) y36 = 0;
status: weights = 14_2 - {36,38};

type [38,19,10_2]; status: weights = 10_2 - {36};

psheadx(60)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=37, k >= 2: 24, 20, 19, 18, 17, 16, 16, 15coderef(hill traynor), 14, quest1()14, quest1()13, 12, 12, newdquest1()11, newd1()10, quest1()10, newdquest()9,  newd()8,  8; sn
n=38, k >= 2: 25, 21, 20, 18, 18, 16, 16, 16, quest1()15, 14, quest1()14, newd1()12, 12, quest1()12, newdquest1()11, newd1()10, quest1()10, newdquest()9,  newd()8; sn
n=39, k >= 2: 26, 22, 20, 19, 18, 17, 16, 16, quest1()16, newd1()14, 14, newdquest1()13, newd1()12, 12, quest1()12, newdquest1()11, newd1()10, quest1()10,  newdquest()9;
pstail

pshead(60)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38
psnext
n=37, k >=21:  8,  quest()8,  quest()7,  6,  6,  quest()6,  newd()4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=38, k >=21:  8,  8,  quest()8,  quest()7,  6,  6,  newd()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=39, k >=21:  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  5coderef(hill traynor),  4,  4,  4,  4,  3,  2,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}

data_block(There is no $[42,27,8]$ code)
type [42,15,14]{mu1=0, mu2=0, mu3=0, mu4=0, mu5=0, mu6=0, mu7=0, y42=1};
{    =config 42 : {1};
     config from x_14;
     kill x_0_14, x_1_13    };
via lp [current] = ;

type [42,27,8_2];
via dual nonexistence infer [base] = ;
no [42,27,8];

data_block(Table for codes of length $40$ through $45$)

no [41,6,20];
no [43,13,16]<auto joint test, homebrew, precision=2, limited secondary kill>;
no [43,20,12]<auto joint test, use dual dual for joint = 7>;
no [45,18,14]<auto joint test, use dual dual for joint = 7>;

[42_8_18] type [42,8,18];
credit: existence due to Blokh and Zyablov [.blokh zyablov.];
kill y41 by x_17_1, y39 by (x_17_1, x_19_1, x_18_1, x_19_2, x_16_2), y37 by 
     (x_16_5, x_15_5, x_18_5, x_13_5, x_17_5, x_18_0), y35 by (x_14_7, x_16_7, 
     x_13_6, x_15_6, x_17_6, x_12_6, x_16_6, x_14_6), jy19y23y38, jy19y23y40, 
     jy19y25y38, jy19y29y34, jy19y30y33, jy19y31y32, jy20y31y33, jy21y21y38, 
     jy21y21y40, jy21y23y38, jy21y23y40, jy21y25y38, jy21y27y34, jy21y27y36, 
     jy21y29y34, jy21y30y33, jy21y31y32, jy22y31y31, jy23y23y38, jy23y25y36, 
     jy23y30y31, jy19y19y36, jy19y27y36, jy21y21y36, jy21y23y36, jy21y25y36, 
     jy21y30y31, jy19y25y36, jy23y23y36, jy23y25y34, jy23y27y34;

no [41,12,16];
type [42,12,16_2];
kill y42 by x_16;
status: weights = {16,18,20,22,24,26,28,30,32,34,36,38,40};

type [44,5,22_2]; status: weights = {22,24,30,32};

type [44,10,18_2];
kill y44, y40 by (x_18_0, x_18_2, x_18_4, x_19_1, x_19_3, x_20_0);
status: weights = 18_2 - {40,42,44};

type [44,13,16_2]; status: weights = 16_2 - {44};

[9_7_2] type [9,7,2];
[x002] config from x2|x02|x002;
[base] <--> [x1..11] := Build( [9_7_2], [x002] );

[23_7_9] type [23,7,9];
[base] <--> [a1..29] := [24_7_10.{a,b1..3,e,f}] - column;

[15_7_5] type [15,7,5];
[base] <--> [a1..6] := [16_7_6.a1..3] - column;

[13_7_4] type [13,7,4];
[x04] config from x4|x04;
[base] <--> [a1..47] := Build( [13_7_4], [x04] );

[11_7_3] type [11,7,3];
[base] <--> [a1..3] := [12_7_4.a1..2] - column;

[20_7_8all] type [20,7,8];
[x0242] config from x8|x26|x0242;
[base] <--> [a1..27] := Build( [20_7_8all], [x0242] );

[19_7_7] type [19,7,7];
[base] <--> [a1..84] := [20_7_8all.a1..27] - column;

[45_8_20] type [45,8,20];
credit: existence due to Blokh and Zyablov [.blokh zyablov.];
note: [x1..200] is part of a much larger list of codes, creatable via
      Unresidue( [45_8_20], [de], [13_7_4.a1..47] );
kill y45, y43, y44, y41, y42, y27, y37 by (x_12_8, x_17_8, x_16_8), y38 by 
     (x_13_7, x_14_6, x_16_4), y33 by (x_13_12, x_16_12, x_12_12, x_11_10);

[29] config 45 ::: {y29 != 0};
classification of [29]: Unresidue( [45_8_20], [29], [16_7_6.a1..3] ) --> ;
@[base] infer y29 = 0;

[25] config 45 ::: {y25 != 0};
classification of [25]: Unresidue( [45_8_20], [25], [20_7_8all.a1..27] ) --> ;
@[base] infer y25 = 0;

kill y21 by x_3_18;

[34] config 45 ::: {y34 != 0};
classification of [34]: Unresidue( [45_8_20], [34], [11_7_3.a1..3] ) --> ;
@[base] infer y34 = 0;

[26] config 45 ::: {y26 != 0};
classification of [26]: Unresidue( [45_8_20], [26], [19_7_7.a1..84] ) --> ;
@[base] infer y26 = 0;

status: weights = {20,22,24,28,30,32,36,40};

% Unresidue( [45_8_20], [base], [15_7_5.a1..6] )
% yields only code [a], so that is the only code having a word of weight 30.
% Unresidue( [45_8_20], [base],[23_7_9.a1..29] )
% yields only code [a], so that is the only code having a word of weight 22.
% Its WE is 1 + 99t^20 + 90t^22 + 15t^24 + 45t^28 + 6t^30.

at [base];
[40] subdivide along x_40;
config from x_20_0|x_10_10_0;
show (common) y20 = 129, y24 = 90, y28 = 35, y32 = 0, y36 = 0, y40 = 1, mu2 = 0;
kill jy28y28y28;

type [45,11,18_2]; 
status: weights = 18_2 - {38..45};
kill jy18y20y36, jy18y24y36, jy18y36y36, jy20y22y36, jy20y26y36, jy20y30y36,
     jy20y32y36, jy20y34y36, jy22y22y36, jy22y24y36, jy22y26y36, jy22y28y36
     <adjoin extra brouwer constraints>;
show (joint:5) y36 = 0;
status: weights = 18_2 - {36..45};

psheadx(90)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=40, k >= 2: 26, 22, 20, 20, 18coderef(baumert mceliece), 18, 16, 16, 16, newdquest1()15, 14, quest1()14, newdquest1()13, newd1()12, 12, quest1()12, newdquest1()11, newd1()10, quest1()10; sn
n=41, k >= 2: 27, 23, 21, 20, 19, 18, 17, 16, 16, quest1()16, quest1()15coderef(hill traynor), quest1()14, quest1()14, newdquest1()13, 12, 12, quest1()12, newdquest1()11, newd1()10; sn
n=42, k >= 2: 28, 24, 22, 20, 20, 19, 18, quest1()17, 16, 16, quest1()16, newd1()14, quest1()14, quest1()14, quest1()13coderef(brouwer linear programming bound), 12, 12, quest1()12, newd1()10; sn
n=43, k >= 2: 28, 24, 22, 21, 20, 20, 18, quest1()18, quest1()17, 16, 16, newdquest1()15, newd1()14, quest1()14, quest1()14, quest1()13, 12, 12, newd1()11; sn
n=44, k >= 2: 29, 24, 23, 22, 21, 20, 19coderef(dodunekov manev 1985), 18, quest1()18, quest1()17, 16, 16, newdquest1()15, newd1()14, quest1()14, quest1()14, newd1()12, 12, 12; sn
n=45, k >= 2: 30, 25, 24, 22, 22, 20, 20, quest1()19, 18, quest1()18, newd1()16, 16, 16, newdquest1()15, quest1()14, quest1()14, newdquest1()13, newd1()12, 12;
pstail

pshead(90)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=40, k >=21:  newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=41, k >=21: quest1()10,  newdquest()9,  newd()8,  8,  quest()8,  quest()8,  newd()6,  6,  6,  5,  4,  4,  4,  4,  3,  2,  2,  2,  2; sn
n=42, k >=21: 10, quest1()10,  newdquest()9,  newd()8,  8,  quest()8,  newdquest()7,  newd()6,  6,  6,  5,  4,  4,  4,  4,  3,  2,  2,  2; sn
n=43, k >=21: newd1()10, quest1()10, quest1()10,  newdquest()9,  newd()8,  8,  quest()8,  newdquest()7,  newd()6,  6,  6,  5,  4,  4,  4,  4,  3,  2,  2; sn
n=44, k >=21: newd1()11, newd1()10, quest1()10, quest1()10,  newdquest()9,  newd()8,  8,  quest()8,  newdquest()7,  6,  6,  6,  5,  4,  4,  4,  4,  3,  2; sn
n=45, k >=21: 12, newd1()11, newd1()10, quest1()10, quest1()10,  newdquest()9,  newd()8,  8,  quest()8,  quest()7coderef(brouwer linear programming bound),  6,  6,  6,  5,  4,  4,  4,  4,  3;
pstail

pshead(80)
// k =        40  41  42  43  44
psnext
n=41, k>=40:   2; sn
n=42, k>=40:   2,  2; sn
n=43, k>=40:   2,  2,  2; sn
n=44, k>=40:   2,  2,  2,  2; sn
n=45, k>=40:   2,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}

data_comment( ![ \block{There is a unique $[48,8,22]$ code} ]! )

no [46,7,22];
[48_8_22] type [48,8,22];
CREDIT(existence due to Dodunekov and Manev, dodunekov manev 1985)
DHIDE( ![ DC1P#, D3#, DC1.7# done for ]! )
[a] := {100000000001111101111111111000001111100000000001,
     010000001110001101110000111011110001100001111000,
     001000001101101001001110100010001001111101110100,
     000100001011010100101101010001000101111011101010,
     000010011101010000111011010111011000101000010110,
     000001010100011101010100011000011010101111001110,
     000000111111111100000011111111111111111111000000,
     000000000000000011111111111111111111111111111111};
CREDIT(existence due to Dodunekov and Manev, dodunekov manev 1985)
(* [a] := Cyclic(6, 48, 8, 00111111001110101011011011010000110001001) *);
(* [a] := [51_8_24.a] - dual word of weight 3 *);

at [base];
show y48 = 0;
show (joint:0) y22 = 144, y24 = 60, y28 = 0, y30 = 48, y32 = 3;
config 32,16 : {10};
kill x_16_14;
show (common) y22 = 144, y24 = 60, y30 = 48, y32 = 3;
config from x_16_16|x_6_6_10;
via building [current] implies [a];
classification of [base]: [a];
STATUS_UNIQUE_WE(1 + 144t^22 + 60t^24 + 48t^30 + 3t^32)

data_block(There is no $[48,11,20]$ code}\label{section-48-11)
type [48,11,20_2];
{    show y42 = 0, y44 = 0, y46 = 0, y48 = 0;
     kill y40, y38, y34, y26;
     show y32 != 0;
     config 32,16 : {10};
     kill x_16_16, x_12_16, x_10_14;
     via lp [current] =    };
no [48,11,20];

data_block(Table for codes of length $46$ through $50$)

type [51,9,22_2];
show (joint:5) y50 = 0;
status: weights = 22_2 - {50};

no [51,10,22]<full secondary kill>;
no [49,18,16]<auto joint test, use dual dual for joint = 7>;

type [46,9,20_2];
kill y46, y30, y40;
status: weights = {20,24,28,32,36};
type [46,9,20]; status: weights = {20,24,28,32,36};

type [47,7,22]; 
status: weights = {22,24,30,32};
status: enumerator = 1 + 78t^22 + 30t^24 + 18t^30 + t^32;

type [47,10,20];
status: weights = {20,24,28,32,36}, constraints = {418 <= y20 <= 419, 
     313 <= y24 <= 318, 278 <= y28 <= 284, 5 <= y32 <= 9, y36 <= 1};

type [48,13,18_2]; status: weights = 18_2 - {48};

no [48,11,20];
type [49,11,20_2];
kill y46 by x_20_0 <precision=2>;
status: weights = {20,22,24,26,28,30,32,34,36,38,40,42,44,48};
kill jy20y26y42, jy20y26y44, jy20y28y42, jy20y30y42, jy20y30y44, jy20y32y42,
     jy20y34y42, jy20y34y44, jy20y36y42, jy20y38y40, jy22y22y42, jy22y24y42
     <adjoin extra brouwer constraints>;
show (joint:5) y42 = 0;
kill jy22y32y44, jy24y26y44, jy24y30y44, jy26y26y44, jy26y28y44
     <adjoin extra brouwer constraints>;
status: weights = {20,22,24,26,28,30,32,34,36,38,40,44,48};

type [50,4,26_2]; status: weights = {26,28,30,32};

no [49,9,22];
no [50,9,22] <full secondary kill, secondary kill maxvars = 200>;

type [50,12,20];
kill y50 by x_20, y48 by x_18_2, y38, y34, y30, y26;
status: weights = {20,24,28,32,36,40,44};

TYPE_WE(50,7,24,1 + 108t^24 + 19t^32)

psheadx(80)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=46, k >= 2: 30, 26, 24, 23, 22, 21, 20, quest1()20, quest1()19, quest1()18, newdquest1()17, newd1()16, 16, quest1()16, quest1()15coderef(daskalov kapralov), quest1()14, quest1()14, newdquest1()13, newd1()12; sn
n=47, k >= 2: 31, 26, 24, 24, 23, 22, 21, 20, quest1()20, newd1()18, quest1()18, newdquest1()17, 16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13; sn
n=48, k >= 2: 32, 27, 24, 24, 24, 22, 22, 20, quest1()20, newdquest1()19, quest1()18, quest1()18, quest1()17, 16, quest1()16, quest1()16, newdquest1()14, quest1()14, quest1()14; sn
n=49, k >= 2: 32, 28, 25, 24, 24, 23, 22, newdquest1()20, 20, quest1()20, quest1()19coderef(hill traynor), quest1()18, quest1()18, quest1()17, 16, quest1()16, newdquest1()15, newdquest1()14, quest1()14; sn
n=50, k >= 2: 33, 28, 26, 24, 24, 24, 23, newdquest1()21, newd1()20, 20, quest1()20, quest1()19, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, newdquest1()15, newdquest1()14;
pstail

pshead(80)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=46, k >=21: 12, 12, newd1()11, newd1()10, quest1()10, quest1()10,  newdquest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  5,  4,  4,  4,  4; sn
n=47, k >=21: newd1()12, 12, 12, newd1()11, newdquest1()10, quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  5,  4,  4,  4; sn
n=48, k >=21: newdquest1()13, newd1()12, 12, 12, newdquest1()11, newdquest1()10, quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6, quest()5,  4,  4; sn
n=49, k >=21: quest1()14, newdquest1()13, newd1()12, 12, quest1()12, newdquest1()11, newdquest1()10, quest1()10, quest1()10,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()5,  4; sn
n=50, k >=21: quest1()14, quest1()14, newdquest1()13, newd1()12, quest1()12, quest1()12, newdquest1()11, newdquest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()5;
pstail

pshead(80)
// k =        40  41  42  43  44  45  46  47  48  49
psnext
n=46, k>=40:   3,  2,  2,  2,  2,  2; sn
n=47, k>=40:   4,  3,  2,  2,  2,  2,  2; sn
n=48, k>=40:   4,  4,  3,  2,  2,  2,  2,  2; sn
n=49, k>=40:   4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=50, k>=40:   4,  4,  4,  4,  3,  2,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}

data_block(There is a unique $[51,8,24]$ code)

[51_8_24] type [51,8,24];
[a] := Cyclic(1, 51, 8, 001010111001100111111010011110101111011111011011) ::
     {y24 = 204, y32 = 51};
alt Act( { (1,2,3,4,5,6,7,8)(1) }, {00011101,00100101,00101111,00111011,
     00111111,01010101,01111111} ) + check;
CLASSIFICATION_OF([base], x_32|x_16_16|x_6_6_10_2|x15155511, [a])
STATUS_UNIQUE_WE(1 + 204t^24 + 51t^32)

data_block(There is no $[55,39,8]$ code)
type [55,16,13] {y55=1, mu1=0, mu2=0, mu3=0, mu4=0, mu5=0, mu6=0, mu7=0};
=config 55 : {1};
kill y13, y14, y15, y16, y17 by x_0_18, y18 by x_0_18, y19;
kill [current] by x_20;

type [55,39,8_2];
via dual nonexistence infer [base] = ;
no [55,39,8];

data_block(Table for codes of length $51$ through $55$)

type [51,13,20_2]; status: weights = {20,24,28,32,36,40};
type [51,13,20];   status: weights = {20,24,28,32,36,40};

type [52,5,26_2]; status: weights = {26,28,30,32};

type [52,10,22_2];
kill y52 by x_22;
status: weights = {22,24,26,28,30,32,34,36,38,40,42,44,46,48};

no [52,11,22];

no [53,9,24];

type [53,11,22_2];
kill y48 by (x_22_0, x_22_2, x_18_4);
status: weights = {22,24,26,28,30,32,34,36,38,40,42,44,46};

type [53,14,20_2];
show (joint:0) y52 = 0 <homebrew>;
status: weights = {20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50};

no [53,18,18]<auto joint test, use dual dual for joint = 0>;
no [54,7,26];

type [54,9,24_2];  status: weights = {24,26,28,32,34,36,40,44,48};
type [54,9,24];    status: weights = {24,25,26,28,32,33,34,36,40,44,48};

type [54,12,22_2];
{    kill y54, y46 by (x_14_8, x_15_7, x_16_6, x_16_8),
          y44 by (x_12_10, x_13_9, x_14_10, x_15_7, x_15_9, x_17_7),
          y42 by (x_11_11, x_12_10, x_13_9, x_13_11, x_14_8, x_14_10),
          y40 by (x_11_11, x_12_10, x_12_12, x_13_9, x_13_11, x_14_8)    };
status: weights = 22_2 - {26,40..54};
kill jy30y36y38, jy30y38y38, jy34y36y36, jy34y36y38, jy36y36y36, jy24y38y38,
     jy28y36y38, jy28y38y38, jy30y34y38, jy32y32y38, jy32y34y38, jy32y36y38
     <adjoin extra brouwer constraints>;
via lp (joint:5) [current] = ;
no [54,12,22];

no [54,19,18]<limited secondary kill>;

[55_5_28] type [55,5,28];
[a] config 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1 :
{1001011001101001011010011001011,0101010101010101101010101010101,
0011001100110011110011001100110,0000111100001111111100001111000,
0000000011111111111111110000000} :: {1 + 28t^28 + 3t^32};
at [base];
show y40 = 0;
via building [current] implies [a];
classification of [base]: [a];
STATUS_UNIQUE_WE(1 + 28t^28 + 3t^32)

type [55,10,24_2];
kill y26, y34, y48;
status: weights = {24,28,32,36,40,44};
type [55,10,24]; status: weights = {24,28,32,36,40,44};

no [55,13,22]<full secondary kill>;

type [56,11,24_2];
kill y56 by x_28 <dual constraint bound = 5, auto projection>;
status: weights = {24,28,32,36,40};

type [56,13,22_2]; status: weights = 22_2 - {56};

psheadx(80)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=51, k >= 2: 34, 28, 26, 25, 24, 24, 24, quest1()22, newdquest1()21, newd1()20, quest1()20, quest1()20, newdquest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, newdquest1()15; sn
n=52, k >= 2: 34, 29, 27, 26, 25, 24, 24, 22, quest1()22, newdquest1()21, newd1()20, quest1()20, newdquest1()19, newdquest1()18, quest1()18, quest1()18, newdquest1()16, quest1()16, quest1()16; sn
n=53, k >= 2: 35, 30, 28, 26, 26, 24, 24, quest1()23coderef(dodunekov encheva ivanov), 22, quest1()22, newdquest1()20, 20, quest1()20, newdquest1()19, newdquest1()18, quest1()18, newdquest1()17, newdquest1()16, quest1()16; sn
n=54, k >= 2: 36, 30, 28, 27, 26, 24, 24, quest1()24, quest1()23, quest1()22, newdquest1()21, newd1()20, 20, quest1()20, newdquest1()19, newdquest1()18, quest1()18, newdquest1()17, newdquest1()16; sn
n=55, k >= 2: 36, 31, 28, 28, 27, 25coderef(tilborg 1979), 24, 24, quest1()24, quest1()23, quest1()22, newdquest1()21, newd1()20, 20, quest1()20, newdquest1()19, quest1()18, quest1()18, newdquest1()17;
pstail

pshead(80)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=51, k >=21: newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, newdquest1()11, quest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6; sn
n=52, k >=21: newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, quest1()11coderef(brouwer linear programming bound), quest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6; sn
n=53, k >=21: quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6; sn
n=54, k >=21: quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8,  quest()8,  newd()6; sn
n=55, k >=21: newdquest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8,  newdquest()7;
pstail

pshead(80)
// k =        40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
psnext
n=51, k >=40:  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=52, k >=40:  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=53, k >=40:  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=54, k >=40:  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=55, k >=40:  newd()6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}

data_comment( ![ \block{Table for codes of length $56$ through 
$71$}\label{section-56-71} ]! )

no [64,21,22];
no [58,27,16]<limited secondary kill>;
no [58,9,26]<full secondary kill>;
no [58,7,28];
no [67,8,32];
no [67,10,30]<auto joint test>;

type [57,4,30_2]; status: weights = {30,32};

no [57,12,24];
type [58,12,24_2];
kill y58, y54, y50, y46, y42, y38 by (x_5_19, x_6_20, x_7_17, x_8_18, x_9_15),
     y34 by (x_1_23, x_2_24, x_3_21, x_4_22, x_5_19, x_5_23, x_6_20, x_7_17, 
          x_7_21, x_8_18, x_9_15, x_9_19) <precision = 3>;
show (joint) y26 = 0;
show (joint:0) y56 = 0;
status: weights = 24_4 - {56};

type [57,18,20_2];
kill y56 by x_26_0, y54 by x_17_3, y52 by (x_15_5, x_17_3) <precision = 3>;
status: weights = 20_2 - {22,52..57};

type [58,19,20_2];
kill y58 by x_20, y50 by (x_16_8, x_18_8, x_20_0) <precision = 3>;
status: weights = 20_2 - {22,50..58};

no [60,36,12] <allowed failures = 3, dual constraint bound = -1>;

type [59,5,30_2]; status: enumerator = 1 + 24t^30 + 7t^32;

type [59,9,26_2]; 
status: weights = 26_2 - {58};
kill y56 by x_26_0 <adjoin extra brouwer constraints>;
status: weights = 26_2 - {56,58};

no [57,12,24];
type [59,13,24];   status: weights = {24,28,32,36,40,44,48};

no [58,9,26];
type [60,10,26_2];
status: weights = {26,28,30,32,34,36,38,40,42,44,46,48,50,52,54};

type [61,8,28_2]; status: weights = 28_2 - {50,56..61};

no [60,18,22];
type [61,18,22_2];
kill y60, y58, y56 by (x_17_5, x_27_5, x_25_5), y54 by (x_15_7, x_16_6, x_17_7, 
     x_18_6), y52 by (x_13_9, x_15_9, x_19_9, x_21_9, x_22_0);
status: weights = {22,24,28,30,32,34,36,38,40,42,44,46,48,50};

type [60,21,20_2];
kill y60,y42,y38,y34,y48,y46,y44 <precision = 3>;
via lp [current] = ;
no [60,21,20];

type [60,32,14_2];  
show y60 = 1;
status: weights = 14_2 - {48..58}, constraints = {y60 = 1};

type [61,11,26_2];
kill y54 by (x_21_5, x_23_5, x_23_7, x_24_2);
status: weights = 26_2 - {54..61};
kill y52 by (x_17_9, x_19_9, x_21_9, x_23_9, x_25_9, x_26_0)
     <adjoin extra brouwer constraints>;
status: weights = 26_2 - {52..61};

type [62,19,22_2];
kill y62 by x_22, y50 by (x_12_12, x_16_12, x_18_12, x_22_12, x_20_12,
     x_24_12, x_11_11, x_13_11, x_22_0), y48;
status: weights = {22,24,28,30,32,34,36,38,40,42,44,46};

TYPE_WE(62,7,30_2,1 + 63t^30 + 63t^32 + t^62)
type [62,7,30]; status: weights = {30,31,32,62};

no [61,9,28];
type [62,9,28_2];
kill y62, y54;
status: weights = {28,30,32,34,36,40,42,44,46,48,52};
kill jy28y28y46, jy28y30y46, jy28y30y48, jy28y30y52, jy28y32y46, jy28y34y46, 
     jy28y34y52, jy28y36y46, jy28y40y46, jy28y42y46, jy28y42y48, jy30y30y46;
show (joint:5) y46 = 0;
kill jy30y30y48, jy30y30y52, jy30y32y48, jy30y34y44, jy32y32y34, jy32y34y34, 
     jy32y34y40, jy32y34y42, jy32y34y48;
show (joint:5) y34 = 0;
status: weights = {28,30,32,36,40,42,44,48,52};
kill jy30y30y44, jy32y42y44, jy36y42y42;

type [62,55,4_2]; 
status: weights = 4_2 - {62} <homebrew, precision=2>;

TYPE_WE(63,6,32,1 + 63t^32)

type [63,10,28];   
status: weights = {28,32,36,40,44,48};
kill jy28y48y48, jy32y44y48, jy28y44y48 
     <adjoin extra brouwer constraints, precision = 2>;

type [63,20,22_2]; status: weights = 22_2 - {26,48,50,52,54,56,58,60,62};

set auto mu1;

type [63,31,16_2]; status: weights = 16_2 - {62};

type [64,11,28_2]; 
status: weights = {28,32,36,40,44};
kill y44 by x_18_10, y40 by x_16_12 <auto projection>;
no [64,11,28];

psheadx(110)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=56, k >= 2: 37, 32, 29, 28, 28, 26, 24, 24, 24, quest1()24, newdquest1()22, quest1()22, newdquest1()21, newd1()20, 20, quest1()20, quest1()19coderef(brouwer linear programming bound), quest1()18, quest1()18; sn
n=57, k >= 2: 38, 32, 30, 28, 28, 26, 25, newd1()24, 24, quest1()24, newdquest1()23, quest1()22, quest1()22, newdquest1()21, 20, quest1()20, quest1()20, quest1()19, quest1()18; sn
n=58, k >= 2: 38, 32, 30, 29, 28, 27coderef(tilborg 1981 discrete), 26, newdquest1()25, 24, 24, quest1()24, quest1()23coderef(hill traynor), quest1()22, quest1()22, quest1()21coderef(brouwer linear programming bound), quest1()20, quest1()20, quest1()20, quest1()19; sn
n=59, k >= 2: 39, 33, 31, 30, 29, 28, 26, quest1()26, quest1()25, 24, quest1()24, quest1()24, newdquest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20; sn
n=60, k >= 2: 40, 34, 32, 30, 30, 28, 27, 26, quest1()26, newd1()24, 24, quest1()24, newdquest1()23, newdquest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20; sn
n=61, k >= 2: 40, 34, 32, 31, 30, 29coderef(logacev improvement), 28, quest1()27coderef(dodunekov encheva ivanov), 26, newdquest1()25, newd1()24, 24, quest1()24, newdquest1()23, quest1()22, quest1()22, quest1()22, newdquest1()20, quest1()20; sn
n=62, k >= 2: 41, 35, 32, 32, 31, 30, 28, quest1()28, quest1()27, quest1()26, newdquest1()25, newd1()24, 24, quest1()24, quest1()23coderef(brouwer linear programming bound), quest1()22, quest1()22, newdquest1()21, newdquest1()20; sn
n=63, k >= 2: 42, 36, 32, 32, 32, 31, 28, 28, quest1()28, newd1()26, quest1()26, newdquest1()25, newd1()24, 24, quest1()24, quest1()23, quest1()22, quest1()22, newdquest1()21;
pstailx

type [64,32,16_2];
kill y60,y58,y56,y54,y52,y50;
show y64 = 1 <homebrew, precision=2>;
status: weights = 16_2 - {50..62}, constraints = {y64 = 1};

set dual constraint bound = 3;

type [66,9,30_2];

{    kill y66,y64,y62,y60,y58;
     show (joint:0) y56 = 0;
     kill y54 by (x_18_12, x_20_10, x_21_11)    };
status: weights = {30,32,34,36,38,40,44,46,48};
kill jy36y38y48, jy36y44y46, jy36y44y48, jy36y48y48, jy38y40y44, jy40y44y44, 
     jy44y44y44, jy34y34y48, jy34y38y44, jy32y38y44, jy32y44y48, jy34y34y38,
     jy30y34y48, jy30y44y46, jy30y44y48, jy30y48y48, jy32y34y46, jy32y34y48,
     jy32y36y48, jy32y44y44, jy32y44y46, jy32y46y48, jy32y48y48, jy34y34y44, 
     jy34y34y46, jy34y36y38, jy34y36y44, jy34y36y48, jy34y40y44, jy34y40y46,
     jy36y36y44, jy36y36y48, jy36y40y44, jy36y40y48, jy36y44y44, jy36y46y46,
     jy40y40y44, jy40y40y46, jy40y40y48, jy30y30y44, jy30y32y44, jy30y32y48
     <adjoin extra brouwer constraints>;
show (joint:5) y44 = 0;
kill jy30y34y46, jy30y36y46, jy30y36y48, jy30y40y48, jy32y32y46, jy32y36y38, 
     jy32y36y46, jy32y40y46, jy34y34y34, jy34y34y36, jy34y36y36, jy34y36y40,
     jy34y36y46, jy34y40y40, jy36y36y36, jy36y36y40, jy36y36y46, jy36y38y40,
     jy36y40y40, jy36y40y46, jy30y30y34, jy30y30y36, jy30y32y32, jy30y32y34
     <adjoin extra brouwer constraints>;
show (joint:5) y34 = 0, y36 = 0;
kill jy30y32y40, jy30y40y40 <adjoin extra brouwer constraints>;

status: weights = {30,32,38,40,46,48},
     constraints = {243 <= y30 <= 244, 107 <= y32 <= 108, 136 <= y38 <= 138,
     18 <= y40 <= 20, 3 <= y46 <= 4, y48 <= 1, div4 = 128, 24 <= mu3 <= 26};

set dual constraint bound = -1;

type [66,9,30]; status: weights = {30,32,38,40,46,48};

type [65,4,34_2]; status: weights = {34,36,38,40};

type [65,8,30_2];
kill y64, y60 by x_30_0, y62 by x_27_3, y58;
status: weights = {30,32,34,36,38,40,42,44,46,48,50,52,54,56};
type [65,8,30];
kill y57, y53, y45, y37, y49 by (x_22_14, x_16_14, x_23_10, x_20_10);
status: weights = {30,31,32,33,34,36,38,39,40,41,42,44,46,47,48,50,52,54,56};

type [65,11,28_2]; status: weights = 28_2 - {58,62};

type [65,14,26_2];
kill y64 by x_26_0 <dual constraint bound = 5>;
status: weights = 26_2 - {64};

type [65,18,24_2];
kill y64, y60 by x_24_0;
kill y62 by x_21_3 <dual constraint bound = -1>;
status: weights = 24_2 - {30,60..65};

type [66,9,30_2];  status: weights = 30_2 - {34,36,42,44,50..66};
type [66,12,28_2]; status: weights = {28,32,36,40,44,48,52,56,60};
type [66,19,24_2]; status: weights = 24_2 - {30,60..66};

type [67,13,28_2]; 
status: weights = {28,32,36,40,44,48,52,56};
kill y56 by (x_18_10, x_22_6) <dual constraint bound = 5>;
status: weights = {28,32,36,40,44,48,52};

type [68,5,34_2];  status: weights = 34_2 - {50..68};

type [68,8,32_2];  
status: weights = {32,34,36,40,42,44,48,50,52,64};
kill jy32y48y50, jy32y48y52, jy34y42y48, jy36y36y52, jy40y40y52
     <adjoin extra brouwer constraints>;
type [68,8,32];    
status: weights = {32,33,34,36,40,41,42,44,48,50,52,64};

type [68,10,30_2];
kill y68, y66 by x_30_0;
kill y62 by (x_27_3, x_27_5, x_28_2), y60 by x_30_0
     <dual constraint bound = 3>;
status: weights = 30_2 - {60,62,66,68};

no [65,12,28];
type [68,14,28_2]; status: weights = {28,32,36,40,44,48};
type [68,14,28];   status: weights = {28,32,36,40,44,48};

type [68,17,26_2];
kill y64 by x_24_2;
status: weights = 26_2 - {64};

type [69,9,32_2];
credit: nonexistence due to Bouyukliev, Guritman, and Vavrec;
kill y64, y52, y50, y34, y36 by (x_10_22, x_16_20);
STATUS_WE(1 + 351t^32 + 156t^40 + 4t^48)
[69_9_32] type [69,9,32];
status: enumerator = 1 + 351t^32 + 156t^40 + 4t^48;
classification of [base]:
     Unresidue( [69_9_32], [base], [21_8_8.{a1..7,b,c}] ) --> ;
no [69,9,32];

type [69,11,30_2];
kill y58 by (x_19_11, x_20_10, x_21_9, x_21_11, x_22_8, x_22_10, x_23_9,
     x_23_11, x_24_6);
status: weights = 30_2 - {58,60,62,66,68};
kill y64 by (x_25_5, x_27_3, x_27_5, x_29_1, x_29_3, x_29_5, x_30_0,
     x_30_2, x_30_4, x_31_1, x_31_3, x_31_5)
     <adjoin extra brouwer constraints>;
status: weights = 30_2 - {58..69};

type [69,18,26_2]; status: weights = 26_2 - {34,56..69};

set dual constraint bound = 3;

type [70,6,34_2];
status: weights = {34,36,38,40,42,44,46,48,50,52,54,56,60,64,70};
status: weights = {34,36,38,40,42,44,46,48,50,52,54,56,60,64};

set dual constraint bound = -1;

type [70,12,30_2];
kill y56 by (x_16_14, x_17_13, x_18_12, x_18_14, x_20_10, x_20_12, x_22_10, 
     x_22_12, x_22_14, x_23_7) <precision = 2>;
status: weights = {30,32,34,36,38,40,44,46,48,50,52,54,70};

type [70,15,28_2];
kill y70 by x_28, y68 by x_26_2;
status: weights = {28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66};


type [70,26,22_2];
kill y70, y68 by x_20_2;
status: weights = 22_2 - {68,70};

type [70,30,20_2];
kill y70 by x_20, y68 by x_20_0;
status: weights = 20_2 - {68,70};

type [70,45,12_2];
status: weights = 12_2 - {70};

[71_5_36] type [71,5,36];
kill y56, ndiv4;
[a] config 2,2,3,3,2,2,3,3,2,2,3,3,2,2,3,3,2,2,2,2,2,2,2,2,3,3,1,1,3,3,1 : 
     {1001011001101001011010011001011,0101010101010101101010101010101,
     0011001100110011110011001100110,0000111100001111111100001111000,
     0000000011111111111111110000000} :: {1 + 27t^36 + 3t^40 + t^44};
[b] config 2,2,3,3,2,2,3,3,2,2,3,3,2,2,3,3,3,3,1,1,3,3,1,1,3,3,1,1,3,3,1 : 
     {1001011001101001011010011001011,0101010101010101101010101010101,
     0011001100110011110011001100110,0000111100001111111100001111000,
     0000000011111111111111110000000} :: {1 + 28t^36 + 2t^40 + t^48};
[c] config 2,2,3,3,2,2,3,3,2,2,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,1 : 
     {1001011001101001011010011001011,0101010101010101101010101010101,
     0011001100110011110011001100110,0000111100001111111100001111000,
     0000000011111111111111110000000} :: {1 + 26t^36 + 5t^40};
at [base];
status: weights = {36,40,44,48};
config from x_40|x_20_16;
reduce variable set;
config from x_10_10_8_8;
via building [current] implies [a], [b], [c]; 
classification of [base]: [a], [b], [c];

type [71,10,32_2];
status: weights = {32,34,36,40,42,44,48,52,64};
kill y42 by (x_17_19, x_21_15, x_13_19, x_14_20, x_21_19), y34 by x_9_27;
status: weights = {32,36,40,44,48,52,64}, constraints = {525 <= y32 <= 595,
     y36 <= 162, 266 <= y40 <= 448, y44 <= 70, y48 <= 17, y52 <= 6, y64 <= 1};
kill jy32y36y64, jy36y36y64, jy36y40y64
     <adjoin extra brouwer constraints, dual constraint bound = 3>;

type [71,13,30_2]; status: weights = {30,32,34,36,38,40,44,46,48,50,52,54};
no [71,13,30]<auto joint test, use dual dual for joint = 0, homebrew, 
     precision=2>;

no [69,6,34];

type [71,16,28_2];
kill y66 by (x_30_0, x_32_0);
status: weights = {28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64};

type [71,23,24_2];
kill y70 by x_24_0;
status: weights = 24_2 - {70};

type [71,31,20_2]; status: weights = 20_2 - {22,68,70};
type [72,4,38_2];  status: weights = {38,40};

type [72,11,32];
kill y52 by (x_18_18, x_16_16, x_24_20, x_22_14, x_20_12, x_22_10),
     y44, y36 by (x_0_36, x_18_31) <auto projection>;
status: weights = {32,40,48,64};

unset auto mu1;

psheadx(110)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=64, k >= 2: 42, 36, 33, 32, 32, 32, 29, 28, 28, newdquest1()27, newdquest1()26, quest1()26, newdquest1()25, 24, 24, quest1()24, newdquest1()22, quest1()22, quest1()22; sn
n=65, k >= 2: 43, 36, 34, 32, 32, 32, 30, quest1()29coderef(dodunekov encheva ivanov), 28, quest1()28, newdquest1()27, quest1()26, quest1()26, quest1()25, 24, quest1()24, newdquest1()23, newdquest1()22, quest1()22; sn
n=66, k >= 2: 44, 37, 34, 32, 32, 32, 30, quest1()30, newd1()28, 28, quest1()28, quest1()27coderef(daskalov 66_13_28), quest1()26, quest1()26, quest1()25, 24, quest1()24, newdquest1()23, newdquest1()22; sn
n=67, k >= 2: 44, 38, 35, 33, 32, 32, 31coderef(dodunekov ytrehus 1987), 30, newd1()29, newd1()28, quest1()28, quest1()28, quest1()27, quest1()26, quest1()26, quest1()25, 24, quest1()24, newdquest1()23; sn
n=68, k >= 2: 45, 38, 36, 34, 32, 32, 32, 30, 30, newdquest1()29, newdquest1()28, quest1()28, quest1()28, newdquest1()26, quest1()26, quest1()26, newd1()24, quest1()24, quest1()24; sn
n=69, k >= 2: 46, 39, 36, 34, 33, 32, 32, 31, 30, quest1()30, newdquest1()29, quest1()28, quest1()28, newdquest1()27, newdquest1()26, quest1()26, newdquest1()25, newdquest1()24, quest1()24; sn
n=70, k >= 2: 46, 40, 36, 35, 34, 33, 32, 32, 31coderef(hill traynor), quest1()30, quest1()30, newd1()28, quest1()28, quest1()28, newdquest1()27, newdquest1()26, quest1()26, newdquest1()25, newdquest1()24; sn
n=71, k >= 2: 47, 40, 37, 36, 34, 34, 32, 32, 32, quest1()31, quest1()30, newdquest1()29, newdquest1()28, quest1()28, quest1()28, newdquest1()27, quest1()26, quest1()26, newdquest1()25;
pstailx

no [68,36,16];
no [67,36,15];
no [67,31,18];

psheadx(110)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=56, k >=21: newdquest1()17, newdquest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, newdquest()9,  newd()8,  8,  quest()8; sn
n=57, k >=21: quest1()18, newdquest1()17, newdquest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10,  newdquest()9,  newd()8,  8; sn
n=58, k >=21: quest1()18, quest1()18, newdquest1()17, newdquest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10,  newdquest()9,  8; sn
n=59, k >=21: newdquest1()18, quest1()18, quest1()18, newdquest1()17, quest1()16, quest1()16, quest1()16, newdquest1()15, quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, newdquest1()10, quest1()10, quest1()10,  quest()9; sn
n=60, k >=21: newdquest1()19, newdquest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()14, newdquest1()12, quest1()12, quest1()12, newdquest1()11, newdquest1()10, quest1()10, quest1()10; sn
n=61, k >=21: quest1()20, newdquest1()19, newdquest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, newdquest1()11, newdquest1()10, quest1()10; sn
n=62, k >=21: quest1()20, quest1()20, newdquest1()19, newdquest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, newdquest1()11, quest1()10; sn
n=63, k >=21: newdquest1()20, quest1()20, quest1()20, newdquest1()19, newdquest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, quest1()11coderef(brouwer linear programming bound)  ;
pstail

pshead(110)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=64, k >=21: newdquest1()21, newdquest1()20, quest1()20, quest1()20, newdquest1()19, quest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12; sn
n=65, k >=21: quest1()22, newdquest1()21, newdquest1()20, quest1()20, quest1()20, quest1()19coderef(brouwer linear programming bound), quest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12; sn
n=66, k >=21: quest1()22, quest1()22, newdquest1()21, newdquest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, quest1()18, newdquest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13, newdquest1()12; sn
n=67, k >=21: newdquest1()22, quest1()22, quest1()22, newdquest1()21, newdquest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, newdquest1()17, quest1()17, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, newdquest1()13; sn
n=68, k >=21: newdquest1()23, newdquest1()22, quest1()22, quest1()22, newdquest1()21, quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, newdquest1()17, newdquest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14; sn
n=69, k >=21: quest1()24, newdquest1()23, newdquest1()22, quest1()22, quest1()22, quest1()21coderef(brouwer linear programming bound), quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, newdquest1()17, newdquest1()16, quest1()16, quest1()16, newdquest1()15, quest1()14, quest1()14; sn
n=70, k >=21: quest1()24, quest1()24, newdquest1()23, newdquest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, newdquest1()17, newdquest1()16, quest1()16, quest1()16, quest1()15coderef(brouwer linear programming bound), quest1()14; sn
n=71, k >=21: newdquest1()24, quest1()24, quest1()24, newdquest1()23, newdquest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, newdquest1()17, newdquest1()16, quest1()16, quest1()16, quest1()15;
pstail

pshead(110)
// k =        40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58
psnext
n=56, k >=40:  newdquest()7,  newd()6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=57, k >=40:  quest()8,  newdquest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=58, k >=40:  8,  quest()8,  quest()7coderef(brouwer linear programming bound),  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=59, k >=40:  8,  8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=60, k >=40:  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2; sn
n=61, k >=40:  quest1()10,  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  newd()4,  4,  4,  4,  4,  3,  2,  2,  2; sn
n=62, k >=40:  quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  newd()5,  4coderef(brouwer linear programming bound),  4,  4,  4,  4,  3,  2,  2; sn
n=63, k >=40:  quest1()10, quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  5,  4,  4,  4,  4,  4,  3,  2;
pstail

pshead(110)
// k =        40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58
psnext
n=64, k >=40: quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()7,  6,  6,  6,  5,  4,  4,  4,  4,  4,  2; sn
n=65, k >=40: quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7,  6,  6,  6,  5,  4,  4,  4,  4,  3; sn
n=66, k >=40: quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7,  6,  6,  6,  quest()5,  4,  4,  4,  4; sn
n=67, k >=40: quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()5,  4,  4,  4; sn
n=68, k >=40: quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()5,  4,  4; sn
n=69, k >=40: quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10,  newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()5,  4; sn
n=70, k >=40: quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, newdquest1()10, quest1()10, quest1()10,  newdquest()9,  8coderef(brouwer linear programming bound),  quest()8,  quest()8,  quest()8,  newd()6,  6,  6,  quest()6,  quest()5; sn
n=71, k >=40: quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, newdquest1()11, newdquest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  newdquest()7,  6,  6,  6,  quest()6;
pstail

pshead(180)
// k =        59  60  61  62  63  64  65  66  67  68  69  70
psnext
n=60, k >=59:  2; sn
n=61, k >=59:  2,  2; sn
n=62, k >=59:  2,  2,  2; sn
n=63, k >=59:  2,  2,  2,  2; sn
n=64, k >=59:  2,  2,  2,  2,  2; sn
n=65, k >=59:  2,  2,  2,  2,  2,  2; sn
n=66, k >=59:  3,  2,  2,  2,  2,  2,  2; sn
n=67, k >=59:  4,  3,  2,  2,  2,  2,  2,  2; sn
n=68, k >=59:  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=69, k >=59:  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=70, k >=59:  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=71, k >=59:  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}

data_comment(\block{There is no $[81,12,36]$ code}\label{81-12-36-section})

no [77,9,36];   (* new result *);

type [81,12,36_2];
{    show y66 = 0, y68 = 0, y70 = 0, y72 = 0, y74 = 0, y76 = 0, y78 = 0, y80=0;
     kill y64, y60, y58, y56;
     show y50 = 0;
     kill y48 by (x_24_24, x_24_20);
     via lp [base] =     };
no [81,12,36];

data_comment(![\block{There is no $[73,12,32]$ code}\label{73-12-32}]!)

type [73,12,32_2];
{    kill y64;
     !config 24,24,24,1 : {1100,0110};
     !config 18,30,18,7 : {1100,0110};
     at [base];
     ??show jy48y48y48 = 0, jy48y48y36 = 0;
     via lp (joint:5) [current] =    };
no [73,12,32];

data_comment(![ \block{Table for codes of length $72$ through 
   $85$}\label{section-72-80} ]!)

type [73,8,34_2];
kill y72, y68, y66, y70;
kill y64 by x_27_9 <dual constraint bound = 5>;
status: weights = 34_2 - {62..73};
type [73,8,34];
kill y61, y55, y57, y47, y49, y53, y41, y45, y37, y39;
status: weights = 34_2 - {62..73};

type [73,14,30_2];
kill y72, y70, y68 by x_30_0;
status: weights = {30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66};

type [73,18,28_2]; status: weights = {28,30,32,34,36,40,44,48,52,56,60};

no [72,6,36];
type [74,7,36_2];
show y72 = 0, y74 = 0, y36 != 0;
kill y36 <auto projection>;
no [74,7,36];

type [74,12,32_2];
kill y70, y66 by (x_28_6, x_29_5, x_30_2), y62 by
     (x_23_11, x_24_10, x_28_10, x_30_10, x_30_12, x_31_1);
status: weights = {32,34,36,38,40,42,44,48,50,52,54,56,58,60,64,68,72,74};

type [74,15,30_2]; status: weights = 30_2 - {68..74};
type [74,26,24_2]; status: weights = 24_2 - {72,74};
type [74,30,22_2]; status: weights = 22_2 - {70..74};
type [75,5,38_2];  status: weights = {38,40,46,48};

type [75,9,34_2];
kill y74, y72 by x_31_3, y70 by (x_31_3, x_31_5, x_32_4, x_33_1, x_33_3,
     x_33_5, x_34_0);
kill y68 by x_34_0 <dual constraint bound = 5>;
status: weights = 34_2 - {68..75};

type [75,13,32_2];
kill y64 by (x_21_11, x_23_9, x_24_10, x_25_9, x_25_11, x_27_5, x_27_7, x_28_6, 
     x_29_3, x_29_5, x_29_7, x_30_4, x_30_8, x_31_1, x_31_3, x_31_5, x_31_7, 
     x_31_9, x_32_2, x_32_6) <dual constraint bound = 5>;
status: weights = {32,34,36,38,40,42,44,48,50,52,54,56,58,60};

type [75,23,26_2]; status: weights = 26_2 - {74};

set auto mu1;

type [79,10,36_2]; 
status: weights = {36,40,44,48,52,56,60}, constraints = {542 <= y36 <= 578, 
     56 <= y40 <= 164, 210 <= y44 <= 330, 35 <= y48 <= 107, y52 <= 18, 
     y56 <= 6, y60 <= 2};

type [79,19,30_2];
kill y78, y76 by x_30_0;
status: weights = 30_2 - {76,78};

type [79,23,28_2]; status: weights = 28_2 - {74..79};
type [79,27,26_2]; status: weights = 26_2 - {66..79};

no [81,9,38];       no [81,7,40];

type [81,14,34_2]; status: weights = 34_2 - {76..81};

unset auto mu1;

type [83,8,40_2];
{    kill y64;
     [56bound] config 83 ::: {y56 <= 5};
     at [base];
     via building [current] implies [56bound];
     via lp [56bound] = ;
     classification of [base]:     };
no [83,8,40];  (* Dodunekov et. al., 1987 *);

no [84,6,42];

type [86,7,42_2];
{    show y84 = 0, y86 = 0;
     kill y68, y60, y56;
     show div4 <= 47;
     infer div4 = 32;
     kill y42;
     via lp [current] =     };
no [86,7,42];

set auto mu1;

no [72,25,24];
type [72,28,22_2];
kill y72 by x_22;
status: weights = 22_2 - {68..72};

type [72,32,20_2];
kill y72 by x_20;
status: weights = 20_2 - {22,68..72};

type [73,6,36_2];
kill y72, ndiv4;
status: weights = {36,40,44,48,52,56};
kill y56 by x_26_10 <adjoin extra brouwer constraints>;
status: weights = {36,40,44,48,52};

type [73,18,28_2]; status: weights = 28_2 - {38,42,46,50,54,58,62..73};

type [74,19,28_2];
kill y74,y34;
no [74,19,28]<auto joint test, use dual dual for joint = 5, homebrew>;

type [75,19,28_2];
kill y74 by x_28_0;
status: weights = 28_2 - {74};

type [76,10,34_2];
kill y76, y66 by (x_27_7, x_27_9, x_28_8, 
     x_28_10, x_29_5, x_29_7, x_29_9, x_30_4);
status: weights = {34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64};

type [76,14,32];   status: weights = {32,36,40,44,48,52};

type [76,17,30_2];
kill y76 by x_30;
status: weights = {30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66};

type [76,20,28_2];
kill y76 by x_28;
status: weights = 28_2 - {74,76};

type [77,6,38_2];
kill y76, y60 by x_28_12;
status: weights = {38,40,44,46,48,50,52,54,56,62};
status: weights = {38,40,46,48,54,56,62};

no [74,9,34];

type [77,11,34_2]; 
status: weights = 34_2 - {66..77};
kill y64 by (x_23_13, x_24_12, x_25_13, x_27_13,
     x_28_10, x_28_12, x_30_8, x_30_12, x_31_13, x_32_2)
     <dual constraint bound = 3>;
status: weights = 34_2 - {64..77};

type [77,18,30_2]; status: weights = 30_2 - {42,66..77};
type [78,9,36_2];  status: weights = {36,40,44,48,52,56,60,64};
type [78,12,34_2]; status: weights = {34,36,38,40,42,44,46,48,52,54,56,58,60};
type [78,15,32_2]; status: weights = 32_2 - {74..78};
type [78,26,26_2]; status: weights = 26_2 - {70..78};

unset auto mu1;
set dual constraint bound = -1;

type [80,4,42_2]; status: weights = {42,44,46,48};

type [80,6,{40,48,56}];
show (joint:5) y40 <= 59, y48 >= 3, y56 <= 1;
show (joint:5) 58 <= y40 <= 59, 3 <= y48 <= 5, y56 <= 1;

type [80,10,36_2];
kill y80, y78, y76, y74 by (x_30_6, x_31_5, x_33_3, x_34_2);
status: weights = {36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72};

type [80,24,28_2]; status: weights = 28_2 - {62,66,70..80};

psheadx(105)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=72, k >= 2: 48, 40, 38, 36, 35, 34, 32, 32, 32, quest1()32, newdquest1()30, quest1()30, newdquest1()29, quest1()28, quest1()28, quest1()28, newdquest1()26coderef(brouwer linear programming bound), quest1()26, quest1()26; sn
n=73, k >= 2: 48, 41, 38, 36, 36, 34, 33, newd1()32, 32, quest1()32, newdquest1()31, newdquest1()30, quest1()30, quest1()29coderef(brouwer linear programming bound), quest1()28, quest1()28, newdquest1()27, newdquest1()26, quest1()26; sn
n=74, k >= 2: 49, 42, 39, 37, 36, 35coderef(tilborg griesmer 1980), 34, newdquest1()33, 32, 32, quest1()32, newdquest1()31, quest1()30, quest1()30, quest1()29, quest1()28, quest1()28, newdquest1()27, newdquest1()26; sn
n=75, k >= 2: 50, 42, 40, 38, 36, 36, 34, quest1()34, quest1()33, 32, quest1()32, quest1()32, quest1()31, quest1()30, quest1()30, quest1()29, quest1()28, quest1()28, newdquest1()27; sn
n=76, k >= 2: 50, 43, 40, 38, 37, 36, 35, newdquest1()34, quest1()34, quest1()33, 32, quest1()32, quest1()32, newdquest1()30, quest1()30, quest1()30, newdquest1()28, quest1()28, quest1()28; sn
n=77, k >= 2: 51, 44, 40, 39, 38, 36, 36, newdquest1()35, quest1()34, quest1()34, quest1()33, quest1()32, quest1()32, newdquest1()31, quest1()30, quest1()30, newdquest1()29, newdquest1()28, quest1()28; sn
n=78, k >= 2: 52, 44, 40, 40, 38, 37, 36, quest1()36, quest1()35, quest1()34, quest1()34, newd1()32, quest1()32, quest1()32, quest1()31coderef(brouwer linear programming bound), quest1()30, quest1()30, newdquest1()29, quest1()28;
pstailx

no [81,9,38];
no [83,10,38]<homebrew, auto joint test, use dual dual for joint = 5>;

type [80,13,34_2];
kill y76 by x_34_0;
status: weights = 34_2 - {76};

type [80,17,32_2]; status: weights = 32_2 - {74,76,78};
type [80,20,30_2]; status: weights = 30_2 - {76,78,80};

type [81,11,36_2];
kill y70 by (x_25_11, x_27_9, x_29_11, x_30_10, x_31_9, x_31_11, 
     x_32_8, x_32_10, x_33_3, x_33_5, x_33_7, x_33_9, x_33_11, x_34_2);
status: weights = {36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,72};
kill y72 by (x_27_9, x_31_9, x_33_9, x_34_8, x_35_1, x_35_9, x_36_0)
     <adjoin extra brouwer constraints>;
status: weights = {36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68};

type [81,14,34_2];
kill y74 by (x_34_0, x_36_0);
status: weights = {34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72};
kill y72 by (x_26_8, x_27_7) <dual constraint bound = 5>;
status: weights = 34_2 - {72..81};

type [81,18,32_2]; status: weights = 32_2 - {46,66..81};

type [82,9,38_2];
status: weights = {38,40,44,46,48,50,52,54,56,60,62,64,66};
show (joint:0) y66 = 0;
status: weights = {38,40,44,46,48,50,52,54,56,60,62,64};
kill jy38y40y64, jy38y44y64, jy38y52y64, jy40y44y64, jy40y46y64, jy40y48y62,
     jy40y50y62, jy40y52y64, jy40y56y60, jy40y56y62, jy40y56y64, jy44y44y60,
     jy44y44y62, jy44y44y64, jy44y46y62, jy44y46y64, jy44y48y64, jy44y52y60,
     jy44y52y62, jy44y52y64, jy44y56y56, jy46y46y64, jy46y48y64, jy46y52y62,
     jy46y52y64, jy48y48y60, jy48y48y62, jy48y48y64, jy48y52y56, jy48y52y64,
     jy52y52y52, jy38y44y62, jy40y40y62, jy40y48y60, jy40y52y56, jy44y48y56,
     jy44y52y52, jy48y48y52 
     <adjoin extra brouwer constraints, dual constraint bound = 3>;

type [82,12,36_2];
     kill y68 by (x_23_13, x_29_11, x_29_13, x_30_12, x_30_14, x_31_11, 
          x_31_13, x_32_12, x_32_14, x_33_3, x_33_9, x_33_11, x_33_13, x_34_2);
status: weights = {36,38,40,42,44,46,48,50,52,56,58,60,62,64,66,82};
kill y82 by x_36;
status: weights = {36,38,40,42,44,46,48,50,52,56,58,60,62,64,66};

type [82,15,34_2]; status: weights = 34_2 - {72..82};
type [83,5,42_2];  status: weights = {42,44,46,48};

type [83,13,36_2];
kill y66,y62,y58,y50,y46,y42;
status: weights = {36,40,44,48,52,56,60,64};
kill jy36y64y64, jy40y60y64, jy44y56y64, jy44y60y60, jy48y52y64
     <adjoin extra brouwer constraints, dual constraint bound = 3>;

type [83,16,34_2]; status: weights = 34_2 - {70..83};
type [83,19,32_2]; status: weights = 32_2 - {78..83};
type [83,23,30_2]; status: weights = 30_2 - {72..83};
type [83,38,22_2]; status: weights = 22_2 - {76..83};
type [84,8,40_2];  status: weights = {40,42,44,48,50,52,56,58,60,64};
type [84,8,40];    status: weights = {40,41,42,44,48,49,50,52,56,57,58,60,64};

type [84,10,38_2];
kill y84, y82, y80, y78 by x_38_0, y76 by x_38_0,
     y74 by (x_28_10, x_29_9, x_30_8, x_30_10, x_31_7, x_31_9, x_32_6);
status: weights = {38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72};

no [79,13,34];
type [84,14,36_2]; status: weights = {36,40,44,48,52,56,60};

type [84,17,34_2]; status: weights = 34_2 - {68..84};
type [84,20,32_2]; status: weights = 32_2 - {78..84};
type [84,31,26_2]; status: weights = 26_2 - {82,84};
type [84,35,24_2]; status: weights = 24_2 - {82,84};

type [85,6,42_2];
kill y84, y68 by x_32_12;
status: weights = {42,44,46,48,52,54,56,58,60,62,64,70};
show (joint:0) y52 = 0;
kill y70 <dual constraint bound = 5>;
status: weights = {42,44,46,48,54,56,58,60,62,64};

type [85,9,40];
kill y49, ndiv4, y64, y52 by x_20_20;
STATUS_WE(1 + 361t^40 + 135t^48 + 15t^56)

type [85,11,38_2];
{    kill y72 by (x_25_13, x_27_11, x_27_13, x_28_10, x_28_12, x_29_9, x_29_11, 
          x_30_8), y70 by (x_23_15, x_24_14, x_25_15, x_26_12, x_27_11, 
          x_27_13, x_29_15, x_30_14, x_31_15, x_32_12, x_32_14, x_33_9, 
          x_33_13, x_34_10, x_34_12)    };
status: weights = {38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68};

type [85,14,36_2];
kill y84, y82, y80, y78 by x_36_0,
     y76 by (x_27_9, x_30_8, x_31_7, x_31_9, x_33_7, x_34_8, 
     x_35_1, x_35_3, x_35_5, x_35_7, x_35_9, x_36_2, x_36_6, x_37_1, x_37_3, 
     x_37_5, x_37_7, x_37_9, x_38_0, x_38_4);
status: weights = {36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74};

type [85,21,32_2]; status: weights = 32_2 - {74..85};
type [85,28,28_2]; status: weights = 28_2 - {84};

psheadx(105)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=79, k >= 2: 52, 44, 41, 40, 39, 38, 36, quest1()36, quest1()36, newdquest1()34, quest1()34, newdquest1()33, newdquest1()32, quest1()32, quest1()32, quest1()31, quest1()30, quest1()30, quest1()29coderef(brouwer linear programming bound) ; sn
n=80, k >= 2: 53, 45, 42, 40, 40, 38, 37, 36, quest1()36, newdquest1()35, newdquest1()34, quest1()34, newdquest1()33, quest1()32, quest1()32, quest1()32, newdquest1()30, quest1()30, quest1()30; sn
n=81, k >= 2: 54, 46, 42, 40, 40, 39, 38, quest1()37, 36, quest1()36, newdquest1()35, quest1()34, quest1()34, quest1()33, quest1()32, quest1()32, newdquest1()31, newdquest1()30, quest1()30; sn
n=82, k >= 2: 54, 46, 43, 41, 40, 40, 38, quest1()38, newd1()36, quest1()36, quest1()36, quest1()35, quest1()34, quest1()34, quest1()33, quest1()32, quest1()32, newdquest1()31, quest1()30; sn
n=83, k >= 2: 55, 47, 44, 42, 40, 40, 39coderef(dodunekov ytrehus 1987), 38, newdquest1()37, newdquest1()36, quest1()36, quest1()36, quest1()35, quest1()34, quest1()34, quest1()33, quest1()32, quest1()32, quest1()31coderef(brouwer linear programming bound) ; sn
n=84, k >= 2: 56, 48, 44, 42, 41, 40, 40, quest1()39, quest1()38, newdquest1()37, newdquest1()36, quest1()36, quest1()36, newdquest1()34, quest1()34, quest1()34, newdquest1()32, quest1()32, quest1()32; sn
n=85, k >= 2: 56, 48, 44, 43, 42, 40, 40, quest1()40, 38, quest1()38, newdquest1()37, quest1()36, quest1()36, newdquest1()35, quest1()34, quest1()34, newdquest1()33, quest1()32, quest1()32;
pstail

pshead(105)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=72, k >=21: newdquest1()25, newdquest1()24, quest1()24, quest1()24, newdquest1()23, quest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, newdquest1()17, quest1()16, quest1()16, quest1()16; sn
n=73, k >=21: quest1()26, newdquest1()25, quest1()24, quest1()24, quest1()24, quest1()23coderef(brouwer linear programming bound), quest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20, quest1()18, quest1()18, quest1()18, quest1()17coderef(brouwer linear programming bound), quest1()16, quest1()16; sn
n=74, k >=21: quest1()26, quest1()26, quest1()25coderef(brouwer linear programming bound), quest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22, quest1()22, newdquest1()20, quest1()20, quest1()20, quest1()19coderef(brouwer linear
 programming bound), quest1()18, quest1()18, quest1()18, quest1()17, quest1()16; sn
n=75, k >=21: newdquest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, quest1()24, newdquest1()22, quest1()22, quest1()22, newdquest1()21, newdquest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, quest1()18, quest1()17; sn
n=76, k >=21: newdquest1()27, quest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, newdquest1()23, newdquest1()22, quest1()22, quest1()22, newdquest1()21, quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, quest1()18; sn
n=77, k >=21: quest1()28, quest1()27coderef(brouwer linear programming bound), quest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, newdquest1()23, newdquest1()22, quest1()22, quest1()22, quest1()21coderef(brouwer linear programming bound), quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18; sn
n=78, k >=21: quest1()28, quest1()28, quest1()27, quest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, newdquest1()23, quest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20, quest1()19, quest1()18;
pstail

pshead(105)
// k =        21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39
psnext
n=79, k >=21: quest1()28, quest1()28, quest1()28, quest1()27, quest1()26, quest1()26, quest1()26, newdquest1()24, quest1()24, quest1()24, quest1()23coderef(brouwer linear programming bound), quest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20, quest1()19; sn
n=80, k >=21: quest1()29, quest1()28, quest1()28, quest1()28, newdquest1()26, quest1()26, quest1()26, newdquest1()25, newdquest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20, quest1()20; sn
n=81, k >=21: quest1()30, quest1()29, quest1()28, quest1()28, newdquest1()27, newdquest1()26, quest1()26, quest1()26, newdquest1()25, quest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22, quest1()22, quest1()21, quest1()20, quest1()20; sn
n=82, k >=21: quest1()30, quest1()30, quest1()29, quest1()28, quest1()28, newdquest1()27, quest1()26, quest1()26, quest1()26, quest1()25coderef(brouwer linear programming bound), quest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22, quest1()22, quest1()21, quest1()20; sn
n=83, k >=21: quest1()30, quest1()30, quest1()30, quest1()28, quest1()28, quest1()28, quest1()27coderef(brouwer linear programming bound), quest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22, quest1()22, newdquest1()20; sn
n=84, k >=21: quest1()31, quest1()30, quest1()30, quest1()29coderef(brouwer linear programming bound), quest1()28, quest1()28, quest1()28, quest1()27, quest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22, newdquest1()21; sn
n=85, k >=21: 32, quest1()31, quest1()30, quest1()30, quest1()29, quest1()28, quest1()28, quest1()28, quest1()27, quest1()26, quest1()26, quest1()26, quest1()25, quest1()24, quest1()24, quest1()24, quest1()23, quest1()22, quest1()22;
pstailx

no [74,46,14];

psheadx(105)
// k =        40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58
psnext
n=72, k >=40: quest1()15, quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, newdquest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7,  6,  6,  6; sn
n=73, k >=40: quest1()16, quest1()15, quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7,  6,  6; sn
n=74, k >=40: quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()14, newdquest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7,  6; sn
n=75, k >=40: quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8,  quest()7; sn
n=76, k >=40: quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8,  quest()8; sn
n=77, k >=40: quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  quest()8; sn
n=78, k >=40: quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, newdquest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8;
pstail

pshead(45)
// k =        40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58
psnext
n=79, k >=40: quest1()18, quest1()18, quest1()18, quest1()16, quest1()16, quest1()16, newdquest1()15, newdquest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, quest1()11, quest1()10, quest1()10, quest1()10,  quest()9; sn
n=80, k >=40: quest1()19, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, newdquest1()15, quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, quest1()12, newdquest1()10, quest1()10, quest1()10, quest1()10; sn
n=81, k >=40: quest1()20, quest1()19, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, newdquest1()11, newdquest1()10, quest1()10, quest1()10;
pstailx

set price refinement count = 2;

psheadx(60)
// k =        40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58
psnext
n=82, k >=40: quest1()20, quest1()20, newdquest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()14, quest1()13, quest1()12, quest1()12, newdquest1()11, quest1()10, quest1()10; sn
n=83, k >=40: quest1()20, quest1()20, newdquest1()19, quest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, quest1()14, newdquest1()12, quest1()12, quest1()12, quest1()11, quest1()10; sn
n=84, k >=40: quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13, newdquest1()12, quest1()12, quest1()12, quest1()11; sn
n=85, k >=40: quest1()21coderef(brouwer linear programming bound), quest1()20, quest1()20, quest1()20, quest1()19, quest1()18, quest1()18, quest1()18, quest1()17, quest1()16, quest1()16, quest1()16, quest1()15, quest1()14, quest1()14, newdquest1()13, quest1()13, quest1()12, quest1()12;
pstailx

psheadx(105)
// k =        59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77
psnext
n=72, k >=59:  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=73, k >=59:  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=74, k >=59:  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=75, k >=59:  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=76, k >=59:  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=77, k >=59:  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2; sn
n=78, k >=59:  quest()8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2,  2;
pstail

pshead(105)
// k =        59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77
psnext
n=79, k >=59:  8,  quest()8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2,  2; sn
n=80, k >=59:  quest()9,  8,  quest()8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2,  2; sn
n=81, k >=59: quest1()10,  newd()8,  8,  quest()8, quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2,  2; sn
n=82, k >=59: quest1()10, newdquest()9,  newd()8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2,  2; sn
n=83, k >=59: quest1()10, quest1()10, newdquest()9,  8coderef(brouwer linear programming bound),  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()6,  quest()5,  4,  4,  4,  4,  3,  2; sn
n=84, k >=59: quest1()10, quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()6,  quest()5,  4,  4,  4,  4,  3; sn
n=85, k >=59: quest1()11, quest1()10, quest1()10, quest1()10,  quest()9,  8,  8,  quest()8,  quest()8,  quest()7,  6,  6,  quest()6,  quest()6,  quest()5,  4,  4,  4,  4;
pstail

pshead(105)
// k =        78  79  80  81  82  83  84
psnext
n=79, k >=78:  2; sn
n=80, k >=78:  2,  2; sn
n=81, k >=78:  2,  2,  2; sn
n=82, k >=78:  2,  2,  2,  2; sn
n=83, k >=78:  2,  2,  2,  2,  2; sn
n=84, k >=78:  2,  2,  2,  2,  2,  2; sn
n=85, k >=78:  3,  2,  2,  2,  2,  2,  2;
pstailx

data_comment( ![ 
\block{Partial tables for codes of length between $86$ and $228$}

For these tables, we have not given references where credit is due, nor
have we attached the question mark tag to results which may not be optimal. ]! )

set price refinement count = 1;

type [86,5,44_2]; status: weights = {44,48};

type [86,12,38_2];
kill y86 by x_38;
status: weights = {38,40,42,44,46,48,50,52,54,56,60,62,64,66,68};

type [87,4,46_2]; status: weights = {46,48};

type [87,10,40_2];
kill y86,y84,y82,y80,y76,y74,y72,y70;
show (joint:5) y66 = 0;
kill y58 by (x_22_20, x_24_16);
status: weights = {40,42,44,48,50,52,56,60,64,68};
kill jy40y42y64, jy40y44y50, jy40y50y52, jy40y50y64, jy40y64y68, jy42y42y48
     <dual constraint bound = 3, adjoin extra brouwer constraints>;
show (joint:5) y42 = 0, y50 = 0;
status: weights = {40,44,48,52,56,60,64,68};

type [87,13,38_2];
status: weights = {38,40,44,46,48,50,52,54,56,60,62,64,66};
kill y66 <dual constraint bound = 3>;
via lp (joint:5) [current] = ;
no [87,13,38];

type [88,6,44_2]; status: weights = {44,48,56,60,64};

type [88,11,40_2];
kill y88,y68,y64,y60;
status: weights = {40,44,48,52,56};
type [88,11,40]; status: weights = {40,44,48,52,56};
no [88,11,40]<full secondary kill, secondary kill maxvars = 300,
     dual constraint bound = 3>;

type [89,8,42_2];
kill y88, y84 by x_42_0;
kill y82 by x_41_1 <dual constraint bound = 3>;
kill y86 <dual constraint bound = 5>;
status: weights = 42_2 - {82..89};
type [89,8,42];
kill y81, y77, y71, y73, y65, y69, y57;
status: weights = {42..50,52..56,58,60..64,66,68,70,72,74,76,78,80};

type [89,11,40_2];
kill y88, y86, y84, y82 by (x_33_7, x_34_6, x_35_5, x_35_7, x_36_4), y80 by
     (x_31_9, x_32_8, x_33_7, x_33_9, x_34_6, x_34_8), y78, y76 by (x_27_13, 
     x_28_12, x_29_11, x_29_13, x_30_10, x_30_12, x_31_9, x_31_11, x_31_13, 
     x_32_8), y74 by (x_25_15, x_27_13, x_27_15, x_28_12, x_28_14, 
     x_29_11, x_29_13, x_29_15, x_30_12, x_30_14, x_31_11, x_31_13,
     x_32_12, x_33_9, x_33_11, x_33_15, x_34_6) <dual constraint bound = 3>;
status: weights = {40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72};

type [89,14,38_2]; 
status: weights = 38_2 - {82,84,86,88};
kill y80 by (x_30_8, x_37_1, x_38_0, x_39_1) <dual constraint bound = 3>;
kill y78 by (x_27_11, x_28_10, x_29_11, x_32_10, x_33_11,
     x_36_10, x_37_1, x_37_11, x_38_0);
status: weights = 38_2 - {78..89};

psheadx(60)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14
psnext
n=86, k >= 2: 57, 48, 45, 44, 42, 41, 40, 40, 39, 38, 38, newd1()36, 36; sn
n=87, k >= 2: 58, 49, 46, 44, 43, 42, 40, 40, 40, newd1()38, 38, newd1()37, newd1()36; sn
n=88, k >= 2: 58, 50, 46, 44, 44, 42, 41, newd1()40, 40, newd1()39, newd1()38, 38, newd1()37; sn
n=89, k >= 2: 59, 50, 47, 45, 44, 43, 42, newd1()41, 40, 40, newd1()39, 38, 38;
pstailx

type [90,5,46_2]; status: weights = {46,48};

type [90,9,42_2]; 
status: weights = {42,44,46,48,52,54,56,58,60,62,64,68,70,72};
kill y72 by (x_27_15, x_28_16, x_29_13, x_30_12) <dual constraint bound = 3>;
status: weights = 42_2 - {50,66,72..90};

type [90,12,40_2];
kill y90 by x_40;
status: weights = {40,42,44,46,48,50,52,54,56,58,60,64,66,68,70,72};

no [91,10,42];

type [91,13,40_2];
kill y70,y42,y66,y58,y54,y50, y72 by (x_22_18, x_24_16);
status: weights = {40,44,48,52,56,60,64,68};

no [91,8,44];

type [92,6,46_2];
kill y92, y76, y68, y60, y52;
status: weights = {46,48,62,64};

type [92,8,44_2]; status: weights = {44,46,48,52,56,60,64,68,72,76};

type [92,10,42_2]; 
status: weights = 42_2 - {86..92};
kill y84 by (x_36_6, x_36_8, x_37_5), y82 by (x_34_8, x_34_10, x_35_7),
     y80 by (x_32_10, x_33_9, x_33_11, x_34_8) <dual constraint bound = 3>;
status: weights = {42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78};

type [92,14,40_2]; status: weights = {40,44,48,52,56,60,64};

no [91,6,46];
no [91,8,44];

type [93,9,44]; 
status: weights = {44,48,56,60};
via lp (joint) [current] = ;
no [93,9,44];

type [94,9,44_2];
status: weights = 44_2 - {54,70,78..94};

type [93,11,42_2];
kill y78;
status: weights = {42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76};
kill y76 by (x_27_17, x_28_14, x_28_16, x_29_15, x_29_17, x_30_16, x_31_15,
     x_31_17, x_32_14, x_32_16, x_33_13, x_33_15, x_34_14, x_35_13,
     x_35_17, x_36_16, x_37_15, x_37_17, x_38_12, x_38_14)
     <dual constraint bound = 3>;
status: weights = {42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74};

no [92,11,42];
no [94,10,44];
type [94,12,42_2];
status: weights = {42,44,46,48,50,52,54,56,58,60,62,64,68,70,72,74};

type [95,4,50_2]; status: weights = {50,52,54,56};

TYPE_WE(95,6,48,1 + 62t^48 + t^64)

type [95,10,44_2];
kill y74,y66,y50,y58;
status: weights = {44,48,52,56,60,64,68,72,76};

no [94,8,46];
type [95,8,46_2];
kill y94, y92, y76, y68, y46;
via lp [base] = ;
no [95,8,46];

no [94,6,48];

type [96,8,46_2];
kill y96,y94,y88,y84,y80, y92, y78 by x_35_11;
status: weights = {46,48,50,52,54,56,62,64,70,72};
kill jy46y46y50, jy46y48y50, jy46y50y50, jy46y50y52, jy46y50y64, jy48y48y50, 
     jy48y50y50, jy48y52y56, jy48y52y62, jy48y52y64, jy48y52y70, jy48y52y72
     <adjoin extra brouwer constraints, dual constraint bound = 3>;
show (joint:5) y50 = 0, y52 = 0;
kill jy54y54y72, jy46y48y48
     <adjoin extra brouwer constraints, dual constraint bound = 3>;
status: weights = {46,48,54,56,62,64,70,72}, constraints = {148 <= y46 <= 157, 
     57 <= y48 <= 63, 20 <= y54 <= 39, y56 <= 6, 3 <= y62 <= 15, y64 <= 3, 
     y70 <= 1, y72 <= 1, 266 <= mu3 <= 404, div4 = 64, co <= 128};

type [96,13,42_2];
kill y94 by x_42_0, y92 by x_42_0, y90 by x_42_0;
status: weights = 42_2 - {90,92,94};
kill y88 by (x_36_6, x_40_2) <dual constraint bound = 3>;
status: weights = 42_2 - {88..94};

type [97,11,44_2];
kill y96, y94, y92, y90, y86, y84, y82, y88 by x_44_0;
status: weights = {44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80};

type [97,14,42_2]; 
status: weights = 42_2 - {88,90,92,94,96};
kill y86 by (x_32_10, x_36_10, x_42_0) <dual constraint bound = 3>;
status: weights = 42_2 - {86..97};

type [98,9,46_2];  
status: weights = 46_2 - {58,74,82,84,86,88,90,92,94,96,98};
kill y80 by (x_29_17, x_30_18, x_31_15, x_32_14, x_32_16, x_33_13, x_33_15), 
     y78 by (x_28_18, x_31_15, x_31_17, x_32_14, x_32_16, x_32_18, x_33_15, 
     x_33_17, x_34_18, x_35_11, x_35_17, x_36_10, x_36_12, x_36_14, x_37_9, 
     x_37_11, x_38_8) <dual constraint bound = 3>;
status: weights = {46,48,50,52,54,56,60,62,64,66,68,70,72,76};

type [98,12,44_2];
status: weights = {44,46,48,50,52,54,56,58,60,62,64,66,68,72,74,76,78,80};
kill y80 by (x_26_18, x_28_16, x_30_18, x_31_17, x_32_16, x_32_18, x_33_17, 
     x_34_18, x_35_17, x_36_16, x_38_18, x_39_17, x_40_16, x_40_18),
     y78 by (x_24_20, x_25_19, x_29_19, x_30_20, x_31_19, x_32_20, x_33_19,
     x_36_20, x_37_19, x_38_20) <dual constraint bound = 3>;
status: weights = {44,46,48,50,52,54,56,58,60,62,64,66,68,72,74,76};

type [99,5,50_2]; 
status: weights = 50_2 - {66,68,74..99};
status: weights = {50,52,54,56,58,60,62,64};

type [99,8,48]; status: weights = {48,56,64,72};

type [99,10,46_2]; 
via lp (joint:0) [current] = <homebrew>;
no [99,10,46];

type [99,13,44_2];
kill ndiv4,y76;
status: weights = {44,48,52,56,60,64,68,72};

type [100,10,46_2]; 
kill y100, y98, y96, y94, y92 by (x_38_8, x_40_8, x_44_8, 
     x_45_7, x_46_0), y90 by (x_36_10, x_38_10);
status: weights = 46_2 - {90..100};
kill y88 by (x_34_12, x_35_11, x_36_10, x_36_12, x_37_9), y86 by (x_32_14, 
     x_33_13, x_35_11, x_37_9, x_37_11, x_38_10, x_38_12, x_38_14, x_39_7, 
     x_39_9, x_39_11, x_39_13, x_40_6) <dual constraint bound = 3>;
status: weights = 46_2 - {86..100};

type [101,6,50_2];
kill y100, y84 by x_40_12;
status: weights = {50,52,54,56,58,60,62,64};

type [101,9,48_2];
kill y100,y98,y96,y92,y88,y84,y82,y80;
show (joint:5) y66 = 0;
kill y68 <auto projection>;
status: weights = {48,50,52,54,56,64,72};

no [118,8,58];
no [119,8,58];

no [100,6,50];

type [101,11,46_2]; status: weights = 46_2 - {84..101};

type [101,14,44_2]; 
status: weights = 44_2 - {92,94,96,98,100};
kill y90 by (x_36_10, x_40_10, x_44_0) <dual constraint bound = 3>; 
status: weights = 44_2 - {90..101};

type [102,4,54_2];
STATUS_WE(1 + 12t^54 + 3t^56)

type [102,5,52_2]; status: weights = {52,56,60,64};

type [102,12,46_2];
kill y82, y102 by x_46;
status: weights = {46,48,50,52,54,56,58,60,62,64,66,68,70,72,76,78,80};
kill y80 by (x_24_22, x_25_21, x_26_22, x_28_20, x_30_22, 
     x_31_21, x_32_20, x_32_22, x_33_21, x_34_22, x_35_21, x_36_20, 
     x_38_22, x_39_21, x_40_20, x_40_22) <dual constraint bound = 3>;
status: weights = {46,48,50,52,54,56,58,60,62,64,66,68,70,72,76,78};

psheadx(195)
// k =          2   3   4   5   6   7   8   9  10  11  12  13  14
psnext
n= 90, k >= 2: 60, 51, 48, 46, 44, 44, 42, 42, newd1()40, 40, 40, 39, 38; sn
n= 91, k >= 2: 60, 52, 48, 46, 45, 44, 43, 42, newd1()41, newd1()40, 40, 40, 39; sn
n= 92, k >= 2: 61, 52, 48, 47, 46, 45, 44, newd1()42, 42, newd1()41, newd1()40, 40, 40; sn
n= 93, k >= 2: 62, 52, 48, 48, 46, 46, 44, newd1()43, 42, 42, newd1()41, 40, 40; sn
n= 94, k >= 2: 62, 53, 49, 48, 47, 46, 44, 44, 43, 42, 42, newd1()40, 40; sn
n= 95, k >= 2: 63, 54, 50, 48, 48, 47, 45, 44, 44, 42, 42, newd1()41, newd1()40; sn
n= 96, k >= 2: 64, 54, 50, 48, 48, 48, 46, newd1()44, 44, 43, 42, 42, newd1()41; sn
n= 97, k >= 2: 64, 55, 51, 48, 48, 48, 46, newd1()45, 44, 44, 43, 42, 42; sn
n= 98, k >= 2: 65, 56, 52, 49, 48, 48, 47, 46, newd1()44, 44, 44, 43, 42; sn
n= 99, k >= 2: 66, 56, 52, 50, 48, 48, 48, 46, newd1()45, newd1()44, 44, 44, newd1()42; sn
n=100, k >= 2: 66, 56, 52, 50, 49, 48, 48, 47, 46, newd1()45, newd1()44, 44, newd1()43; sn
n=101, k >= 2: 67, 57, 53, 51, 50, 49, 48, 48, 46, 46, newd1()45, newd1()44, 44; sn
n=102, k >= 2: 68, 58, 54, 52, 50, 50, 48, 48, 47, 46, 46, newd1()44, 44;
pstailx

type [104,6,52_2];
show (joint:0) y58 = 0, y74 = 0;
kill y104,y88;
status: weights = {52,56,60,64,72,76,80};
status: weights = {52,56,60,64};

type [104,11,48_2];
kill y104,y102,y100,y98,y96,y94,y92,y90,y88,y84,y82,y80,y76,y74,y72,y66,y58;
via lp [current] = ;
no [104,11,48];

type [104,13,46_2];
kill y102 by x_46_0, y100 by x_46_0;
status: weights = 46_2 - {100,102};

type [103,10,48_2]; 
status: weights = 48_2 - {54,62,70,78,84..103};
kill y82 <dual constraint bound = 3>;
status: weights = {48,50,52,56,58,60,64,66,68,72,74,76,80};

(* Oops -- this should be combined with the previous type [104,13,46_2]. *);
type [104,13,46_2];
kill y98 by x_46_0, y96 by (x_46_0, x_48_0);
status: weights = 46_2 - {96,98,100,102};
kill y94 by (x_45_1, x_46_0) <dual constraint bound = 3>;
status: weights = 46_2 - {94..102};

no [103,6,52];

no [103,13,46];    no [104,8,50];

type [105,11,48_2]; status: weights = 48_2 - {86..105};

type [105,14,46_2]; 
status: weights = 46_2 - {94..105};
kill y92 <adjoin extra brouwer constraints>;
status: weights = 46_2 - {92..105};

type [106,5,54_2];  status: weights = {54,56,60,62,64};

no [106,9,50];  

type [106,12,48_2]; 
status: weights = 48_2 - {78,86..106};
kill y84 by (x_26_22, x_28_20, x_29_21, x_30_20, x_30_22, x_31_21, x_32_20,
     x_34_22, x_35_21, x_36_20, x_36_22, x_37_21, x_38_22, x_39_21, x_40_20,
     x_42_22) <dual constraint bound = 3>;
status: weights = {48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,80,82};

type [107,13,48_2];
kill y82,y58,y50,ndiv4;
status: weights = {48,52,56,60,64,68,72,76,80};
kill y80 by (x_24_24, x_26_22, x_26_26, x_28_20, x_28_24, x_30_18, x_30_22),
     y76 by (x_24_24, x_26_26, x_28_20, x_28_24, x_28_28, x_30_18, x_30_22,
     x_30_26, x_30_30, x_32_16) <dual constraint bound = 3>;
status: weights = {48,52,56,60,64,68,72};

type [108,6,54_2];  
status: weights = {54,56,62,64,78,80};
status: weights = {54,56,62,64};

type [108,8,52_2];  
status: weights = 52_4 - {108};
kill y104 <adjoin extra brouwer constraints>;
status: weights = 52_4 - {104,108};

type [108,10,50_2]; 
status: weights = 50_2 - {98,100,102,104,106,108};
kill y96, y94 by (x_38_14, x_39_13) <dual constraint bound = 3>;
status: weights = 50_2 - {94..108};

no [108,14,48]<dual constraint bound = -1>;

no [107,6,54];
no [107,8,52];
no [109,9,52];

type [109,11,50_2]; 
kill y88 <adjoin extra brouwer constraints>;
status: weights = 50_2 - {88..109};

type [109,14,48_2];
status: weights = 48_2 - {100,102,104,108};
kill y106 by x_48_0;
kill y98 by (x_37_11, x_39_11, x_40_10, x_41_11, x_44_10, x_45_11,
     x_47_1, x_48_0) <dual constraint bound = 3>;
status: weights = 48_2 - {98..109};

type [110,4,58_2]; status: weights = {58,60,62,64};

no [107,10,50];

type [110,9,52_2];
status: weights = {52,56,60,64,68,72,76,80,84,88,92}
     <adjoin extra brouwer constraints>;

no [110,10,52]; 
no [110,12,50];

no [110,6,56];
type [111,6,56];
kill y80 <adjoin extra brouwer constraints>;
status: weights = {56,64};

type [111,10,52_2]; 
status: weights = {52,56,60,64,68,72,76,80,84,88};
show (joint:0) y88 = 0;
status: weights = {52,56,60,64,68,72,76,80,84};

type [112,8,54_2];
status: weights = {54,56,60,62,64,66,68,70,72,76,78,80,84,86,88,92,94,96,100,
     108,110};
kill y108, y100 by x_44_12, y92 by (x_36_20, x_42_14, x_42_18, x_44_12, 
     x_44_16, x_44_20);
status: weights = {54,56,60,62,64,66,68,70,72,76,78,80,84,86,88,94,96,110};
kill y110, y84, y76, y68, y66 <dual constraint bound = 5>;
kill jy54y56y60, jy54y60y64, jy56y56y62, jy56y60y62, jy56y60y70, jy56y60y72
     <adjoin extra brouwer constraints, dual constraint bound = 3>;
show (joint:0) y60 = 0;
status: weights = {54,56,62,64,70,72,78,80,86,88,94,96};

type [112,11,52_2]; status: weights = {52,56,60,64,68,72};
no [112,11,52]<full secondary kill, secondary kill maxvars = 300,
     dual constraint bound = 3>;

type [112,13,50_2];
kill y108, y106, y112 by x_50, y110 by x_50_0, y104 by x_50_0;
kill y102 by (x_40_10, x_41_9, x_42_8, x_42_10, x_43_9, x_44_8, x_44_10,
     x_45_7, x_45_9, x_46_8), y100 by (x_38_12, x_42_12, x_44_12, x_46_12,
     x_48_12, x_50_0), y98 by (x_36_14, x_37_13, x_38_14, x_39_13, x_40_14,
     x_41_13, x_42_14, x_43_13, x_44_14, x_45_13, x_46_14, x_47_13, x_48_14,
     x_49_1, x_49_13) <dual constraint bound = 3>;
status: weights = 50_2 - {98..112};

no [111,8,54];
no [113,8,56];
no [113,9,54];

type [113,11,52_2];
kill y112,y110,y108,y106,y104,y102,y100,y98,y96,y94 <dual constraint bound = 3>;
status: weights = 52_2 - {94..113};

type [113,14,50_2]; status: weights = 50_2 - {98..112};
type [114,5,58_2];  status: weights = {58,60,62,64};

type [114,9,54_2];  
status: weights = 54_2 - {58,74,90,98..114};
kill y96 by x_38_18, y94 <dual constraint bound = 3>;
status: weights = 54_2 - {58,74,90,94..114};

type [114,12,52_2]; status: weights = 52_2 - {54,86,90..114};

set auto mu1;
type [115,8,56_2];
kill y114,ndiv4,y112;
show (joint:0) 204 <= y56 <= 220, 2 <= y64 <= 50, y68 <= 35, y72 <= 18,
     y80 <= 9, y88 <= 3, y96 <= 2;
show (joint:0) y56 <= 217, y64 >= 5, y68 <= 32, y72 <= 15, y80 <= 7, y88 <= 2, 
     y96 <= 1;
show (joint:0) div8 > 224;
infer div8 = 256;
status: weights = {56,64,72,80,88,96};
type [115,8,56]; status: weights = {56,64,72,80,88,96};

unset auto mu1;

type [115,10,54_2];
status: weights = {54,56,60,62,64,68,70,72,76,78,80,84,86,88};
kill y86 by x_35_19 <dual constraint bound = 3>;
kill y84, y76 <dual constraint bound = 5>;
kill y88 by x_36_18 <adjoin extra brouwer constraints,
     dual constraint bound = 3>;
status: weights = {54,56,60,62,64,68,70,72,78,80};

type [115,13,52_2];
kill y82,y78,y74,y66,y58,y88;
status: weights = {52,56,60,64,68,72,76,80,84};
kill y84 by (x_26_26, x_28_24, x_28_28, x_30_22, x_30_26, x_30_30, x_32_20,
     x_32_24, x_32_28, x_34_18, x_34_22), y80 by (x_26_26, x_28_28, x_30_26,
     x_30_30, x_32_24, x_32_28, x_32_32, x_34_22, x_34_26, x_34_30, x_34_34,
     x_36_16) <dual constraint bound = 3>;
status: weights = {52,56,60,64,68,72,76};

type [116,6,58]; status: weights = {58,60,62,64};

no [116,14,52]<dual constraint bound = -1>;

no [115,6,58];

type [117,4,62_2];  status: weights = {62,64};
type [117,5,60_2];  status: weights = {60,64};

type [117,9,56_2];  
status: weights = {56,64,66,68,70,72,80,84,88};
kill y88 <auto projection>;
show (joint:0) y70 = 0, y84 = 0;
status: weights = {56,64,66,68,72,80};

type [117,11,54_2]; status: weights = 54_2 - {96..117};

type [117,14,52_2]; 
status: weights = 52_2 - {100,102,106,108,110,112,114};
kill y116 by (x_54_0, x_57_1) <dual constraint bound = 5>;
kill y104 <adjoin extra brouwer constraints, dual constraint bound = 3>;
status: weights = 52_2 - {100..117};

psheadx(205)
// k =          2   3   4   5   6   7   8   9  10  11  12  13  14
psnext
n=103, k >= 2: 68, 58, 54, 52, 51, 50, 48, 48, 48, newd1()46, 46, newd1()45, newd1()44; sn
n=104, k >= 2: 69, 59, 55, 52, 52, 51, 49, 48, 48, newd1()47, newd1()46, 46, newd1()45; sn
n=105, k >= 2: 70, 60, 56, 53, 52, 52, 50, newd1()48, 48, 48, newd1()47, 46, 46; sn
n=106, k >= 2: 70, 60, 56, 54, 52, 52, 50, newd1()49, newd1()48, 48, 48, 47, 46; sn
n=107, k >= 2: 71, 60, 56, 54, 53, 52, 51, 50, newd1()49, 48, 48, 48, newd1()46; sn
n=108, k >= 2: 72, 61, 56, 55, 54, 53, 52, newd1()50, 50, 49, 48, 48, newd1()47; sn
n=109, k >= 2: 72, 62, 57, 56, 54, 54, 52, newd1()51, newd1()50, 50, newd1()48, 48, 48; sn
n=110, k >= 2: 73, 62, 58, 56, 55, 54, 52, 52, newd1()51, 50, newd1()49, newd1()48, 48; sn
n=111, k >= 2: 74, 63, 58, 56, 56, 55, 53, 52, 52, newd1()50, 50, newd1()49, newd1()48; sn
n=112, k >= 2: 74, 64, 59, 56, 56, 56, 54, newd1()52, 52, newd1()51, 50, 50, newd1()49; sn
n=113, k >= 2: 75, 64, 60, 57, 56, 56, 54, newd1()53, 52, 52, 51, 50, 50; sn
n=114, k >= 2: 76, 64, 60, 58, 56, 56, 55, 54, 53, 52, 52, 51, 50; sn
n=115, k >= 2: 76, 65, 60, 58, 57, 56, 56, 54, 54, newd1()52, 52, 52, newd1()50; sn
n=116, k >= 2: 77, 66, 61, 59, 58, 57, 56, 55, 54, newd1()53, 52, 52, newd1()51; sn
n=117, k >= 2: 78, 66, 62, 60, 58, 58, 56, 56, 55, 54, 53, 52, 52;
pstailx

no [116,9,56];
type [118,10,56_2];
kill y118;
show (joint:0) 719 <= y56 <= 722;
status: weights = {56,64,72,80};
show (joint:5) 719 <= y56 <= 720, 215 <= y64 <= 219;
show (joint:5) y64 <= 218, 85 <= y72 <= 88, y80 <= 1;
status: weights = {56,64,72,80}, constraints = {719 <= y56 <= 720,
     215 <= y64 <= 218, 85 <= y72 <= 88, y80 <= 1};

type [118,12,54_2]; status: weights = 54_2 - {58,90..118};

TYPE_WE(119,6,60,1 + 56t^60 + 7t^64)

no [116,11,54];
no [116,9,56];
no [119,13,54];

no [118,6,60];

type [120,8,58_2];
kill y116, y112, y108, y104 by x_44_16, y102 by (x_42_16, x_45_15), y100 by 
     (x_41_17, x_42_18, x_44_14, x_44_20, x_46_14, x_46_18, x_48_10, x_48_20);
status: weights = 58_2 - {66,82,90,98,100,102,104,106,108,110,112,114,116};
kill y120, y96, y94 by x_38_20, y88 by (x_34_26, x_36_24, x_36_26, x_38_22), 
     y84 <dual constraint bound = 5>;
kill y92 by (x_36_22, x_37_21, x_38_22, x_40_18, x_40_20, x_40_24, x_41_21, 
     x_42_18, x_42_22, x_42_26, x_44_14, x_44_16, x_44_20, x_44_24, x_44_28, 
     x_45_13) <dual constraint bound = 3, adjoin extra brouwer constraints>;
status: weights = 58_2 - {66,82,84,88..116,120};

type [120,11,56_2]; 
status: weights = {56,60,64,68,72,76,80,84};
kill y84 <dual constraint bound = 5, auto projection>;
kill jy68y80y80, jy72y76y80, jy72y80y80, jy76y76y76, jy80y80y80, jy60y80y80,
     jy64y76y80, jy64y80y80, jy68y68y80, jy68y72y80, jy56y56y80, jy56y60y80, 
     jy56y64y80, jy56y68y80, jy56y72y80, jy56y76y80, jy56y80y80, jy60y60y80
     <adjoin extra brouwer constraints, dual constraint bound = 3>;
show (joint:0) y80 = 0;
kill jy60y76y76, jy64y68y76, jy64y72y76, jy64y76y76, jy68y68y68, jy68y68y72
     <adjoin extra brouwer constraints, dual constraint bound = 3>;
via lp (joint:5) [current] = ;
no [120,11,56];

type [120,13,54_2];
kill y118,y116,y114,y112,y106,y104, y120 by x_54, y110 by (x_44_10, x_46_10);
status: weights = 54_2 - {104,106,110,112,114,116,118,120};
kill y108 by x_54_0;
status: weights = 54_2 - {104..120};

type [121,5,62_2];  status: weights = {62,64};
type [121,14,54_2]; status: weights = 54_2 - {102..121};
type [122,9,58_2];  status: weights = 58_2 - {66,82,98,102..122};
type [122,12,56_2]; status: weights = 56_2 - {62,90,94..122};

TYPE_WE(123,6,62,1 + 48t^62 + 15t^64)

no [122,8,60];

no [121,9,58];

type [123,10,58_2]; 
status: weights = 58_2 - {66,74,82,90,94..123};
kill y88, y84 <dual constraint bound = 5>;
status: weights = {58,60,62,64,68,70,72,76,78,80,86,92};
status: weights = {58,60,62,64,68,70,72,76,78,80};

type [123,13,56_2]; 
status: weights = {56,60,64,68,72,76,80,84,88,92};
kill y92 by (x_28_28, x_30_30, x_32_28, x_34_30, x_36_28, x_38_30)
     <dual constraint bound = 5>;
status: weights = {56,60,64,68,72,76,80,84,88};

no [121,12,56];
no [124,14,56];

type [125,4,66_2]; status: weights = {66,68,70,72};

set auto mu1;
type [125,9,60_2]; 
status: weights = {60,64,72,76,80,88,92,96};
kill y96 by x_40_20;
show (joint:0) y92 = 0;
status: weights = {60,64,72,76,80,88};
unset auto mu1;

type [125,11,58_2]; status: weights = 58_2 - {102..125};
type [125,14,56_2]; 
status: weights = 56_2 - {102..122};
kill y124 <dual constraint bound = 5>;
status: weights = 56_2 - {102..125};

TYPE_WE(126,6,64,1 + 63t^64)

type [126,8,62_2];
kill y124,y76;
show (joint:5) y62 = 127, y64 = 127, y126 = 1;
STATUS_WE(1 + 127t^62 + 127t^64 + t^126)
type [126,8,62]; status: weights = {62,63,64,126};

no [124,9,60];
type [126,10,60_2];
set dual constraint bound = -1;
kill y126,y88,y72;
via lp [current] = ;
no [126,10,60];
set dual constraint bound = 3;

no [124,9,60];
no [124,11,58];
type [126,12,58_2];
kill y126,y100,y94,y90,y86,y96,y92,y82,y78,y74,y58;
via lp [current] = ;
no [126,12,58];

TYPE_WE(127,7,64,1 + 127t^64)

type [127,10,60_2]; 
status: weights = 60_2 - {70,78,86,94,98,102..127};
kill y90 <dual constraint bound = 5>;
status: weights = {60,62,64,66,68,72,74,76,80,82,84,88,92,96,100};

type [127,12,58_2]; 
kill y126, y124, y122, y120, y114, y112, y110, y118 by x_58_0, y116 by x_58_0;
status: weights = 58_2 - {110..127};

TYPE_WE(128,8,64,1 + 254t^64 + t^128)

type [128,11,60_2];
kill y128,ndiv4,y100,y96;
status: weights = {60,64,68,72,76,80,84,88,92};
kill y92 <dual constraint bound = 5, auto projection>;

set adjoin extra brouwer constraints;

kill jy68y88y88, jy72y84y88, jy72y88y88, jy76y80y88, jy76y84y84, jy80y80y84, 
     jy80y80y88, jy80y88y88, jy60y88y88, jy64y84y88, jy64y88y88, jy68y80y88,
     jy68y84y84, jy68y84y88, jy72y72y88, jy72y76y88, jy72y80y84, jy72y80y88, 
     jy72y84y84, jy76y76y84, jy76y76y88;
show (joint:5) y88 = 0;
kill jy60y84y84, jy64y80y84, jy64y84y84, jy68y68y84, jy68y72y84, jy68y76y84,
     jy68y80y80, jy68y80y84, jy72y72y84, jy72y76y80, jy72y76y84, jy72y80y80;
show (joint:5) y84 = 0;
kill jy76y76y76, jy76y76y80, jy76y80y80, jy80y80y80, jy60y64y80, jy60y72y80,
     jy60y76y80, jy60y80y80, jy64y64y80, jy64y68y80;
show (joint:5) y80 = 0;
kill jy64y72y76, jy68y68y76, jy68y76y76, jy72y72y76, jy72y76y76;

config 76,52 : {10};
show (iterate) 1309 <= y60 <= 1313, y64 <= 15, 122 <= y68 <= 141, 
     588 <= y72 <= 600, 1 <= y76 <= 4, 19 <= mu3 <= 20, 115 <= x_36_32 <= 116, 
     808 <= x_38_22 <= 818, 472 <= x_32_28 <= 484, 4 <= x_34_26 <= 25;
show (joint:5) y64 >= 1;
kill x_32_32, x_30_30, x_36_32;
via lp [current] = ;
@[base] infer y76 = 0;

kill jy60y60y68, jy60y64y68, jy60y64y72, jy60y68y68, jy60y68y72, jy60y72y72;
via lp (joint:0) [current] = ;
no [128,11,60];

unset adjoin extra brouwer constraints;

type [128,13,58_2]; status: weights = 58_2 - {108..128};

type [129,9,62_2];  
status: weights = {62,64,68,76,78,80,82,84,92};
kill y92 <dual constraint bound = 3>;
kill y76 <dual constraint bound = 5>;
status: weights = {62,64,68,78,80,82,84};

type [129,14,58_2]; status: weights = 58_2 - {106..129};
type [130,5,66_2];  status: weights = {66,68,70,72,74,76,78,80};

type [130,12,60_2];
kill y130,y128,y126,y124,y122,y120,y118,y116,y114,y112,y110,y108,y106,y104,
     y100,y98,y94,y90,y86,y62,y66,y82,y78,y74;
status: weights = {60,64,68,72,76,80,84,88,92,96};

type [131,10,62_2]; 
status: weights = 62_2 - {74,82,90,98,102..131};
kill y100, y92 <dual constraint bound = 5>;
status: weights = {62,64,66,68,70,72,76,78,80,84,86,88,94,96};

type [132,4,70_2]; status: weights = {70,72};

no [131,9,64];

type [132,9,64]; 
status: weights = {64,80};
via lp (joint) [current] = ;
no [132,9,64];

no [129,12,60];
type [132,14,60_2];
{    kill y96,y92,y88,y84,y80,y76;
     show y132 = 1;
     config from x_132|x_60|x_24_36;
     via lp [current] = <dual constraint bound = -1>    };
no [132,14,60];

type [133,5,68_2]; status: weights = {68,72,76,80};

type [133,6,66_2];
kill y132, y116 by x_56_12;
status: weights = 66_2 - {98,114,116,120..133};
kill y100 <dual constraint bound = 3>;
status: weights = 66_2 - {98,100,114,116,120..133};
status: weights = 66_2 - {98..133};

type [133,11,62_2]; status: weights = 62_2 - {108..133};
type [133,14,60_2]; status: weights = 60_2 - {108..130};

type [134,10,64_2];
status: weights = {64,68,72,80,88};
type [134,10,64];
show (joint:5) y65 = 0;
status: weights = {64,68,72,80,88};

type [135,7,66_2];
kill y132;
status: weights = 66_2 - {114,122,126,130,132};
kill y134 <dual constraint bound = 3>;
kill y124, y116 <dual constraint bound = 5>;
status: weights = 66_2 - {114,116,122..126,130..135};

type [135,12,62_2]; 
status: weights = 62_2 - {114..122,126..135};
kill y124 by x_62_0 <dual constraint bound = 3>;
status: weights = 62_2 - {114..135};

type [136,6,68_2];
kill y106,ndiv4,y136,y120;
status: weights = {68,72,76,80,84,88,92,96,104,108,112};
status: weights = {68,72,76,80,84,88,92,96};

no [134,7,66];

type [136,8,66_2];  
status: weights = 66_2 - {82,98,106,114,116,122,124,126,130..136};
kill y120,y118,y112,y110,y108,y104,y102,y100,y96,y94,y92,y90,y88,y86,
     y84,y80,y78,y76,y74;
status: weights = {66,68,70,72,128};

type [136,11,64_2]; 
status: weights = {64,68,72,76,80,84,88,92,96,100};
kill y100 <dual constraint bound = 5, auto projection>;
status: weights = {64,68,72,76,80,84,88,92,96};

type [136,13,62_2]; status: weights = 62_2 - {114..136};
type [137,5,70_2];  status: weights = {70,72,76,78,80};
type [137,14,62_2]; status: weights = 62_2 - {110..137};

psheadx(275)
// k =          2   3   4   5   6   7   8   9  10  11  12  13  14
psnext
n=118, k >= 2: 78, 67, 62, 60, 59, 58, 56, 56, 56, 54, 54, newd1()52, 52; sn
n=119, k >= 2: 79, 68, 63, 60, 60, 59, 57, newd1()56, 56, newd1()54, 54, newd1()53, newd1()52; sn
n=120, k >= 2: 80, 68, 64, 61, 60, 60, 58, newd1()56, 56, newd1()55, 54, 54, newd1()53; sn
n=121, k >= 2: 80, 68, 64, 62, 60, 60, 58, 57, 56, 56, 55, 54, 54; sn
n=122, k >= 2: 81, 69, 64, 62, 61, 60, 58, 58, 57, 56, 56, 55, 54; sn
n=123, k >= 2: 82, 70, 64, 63, 62, 61, 59, 58, 58, newd1()56, 56, 56, newd1()54; sn
n=124, k >= 2: 82, 70, 65, 64, 62, 62, 60, 59, 58, newd1()57, 56, 56, newd1()55; sn
n=125, k >= 2: 83, 71, 66, 64, 63, 62, 61, 60, newd1()58, 58, newd1()56, 56, 56; sn
n=126, k >= 2: 84, 72, 66, 64, 64, 63, 62, 60, newd1()59, 58, newd1()57, newd1()56, 56; sn
n=127, k >= 2: 84, 72, 67, 64, 64, 64, 63, 60, 60, newd1()58, 58, newd1()57, newd1()56; sn
n=128, k >= 2: 85, 72, 68, 64, 64, 64, 64, 61, 60, newd1()59, 58, 58, newd1()57; sn
n=129, k >= 2: 86, 73, 68, 65, 64, 64, 64, 62, newd1()60, 60, 59, 58, 58; sn
n=130, k >= 2: 86, 74, 68, 66, 64, 64, 64, 62, newd1()61, 60, 60, 59, 58; sn
n=131, k >= 2: 87, 74, 69, 66, 64, 64, 64, newd1()62, 62, newd1()60, 60, 60, newd1()58; sn
n=132, k >= 2: 88, 75, 70, 67, 65, 64, 64, newd1()63, newd1()62, newd1()61, 60, 60, newd1()59; sn
n=133, k >= 2: 88, 76, 70, 68, 66, 64, 64, 64, newd1()63, 62, newd1()60, 60, 60; sn
n=134, k >= 2: 89, 76, 71, 68, 66, 65, 64, 64, 64, 62, newd1()61, newd1()60, 60; sn
n=135, k >= 2: 90, 76, 72, 68, 67, 66, 65, 64, 64, 63, 62, newd1()61, newd1()60; sn
n=136, k >= 2: 90, 77, 72, 69, 68, 66, 66, 64, 64, 64, 62, 62, newd1()61; sn
n=137, k >= 2: 91, 78, 72, 70, 68, 67, 66, newd1()64, 64, 64, 63, 62, 62;
pstailx

type [138,7,68_2];
kill y106,y94,y90,y86,y82,y78,y74,y138;
status: weights = {68,72,76,80,84,88,92,96,100,104,108,112,120,136};
show (joint:0) y136 = 0;
status: weights = {68,72,76,80,84,88,92,96,100,104,108,112,120};

no [138,9,66]; 

type [138,12,64_2];
kill y138,y136,y134,y132,y130,y128,y126,y124,y122,y120,y118,y116,y114,y112,
     y108,y106,y102,y98,y94,y90,y86,y82,y74,ndiv4;
status: weights = {64,68,72,76,80,84,88,92,96,100,104};

type [139,8,68_2];
kill y120 by x_56_12, y112, y104 by 
     (x_52_28, x_44_28), y96 by (x_36_36, x_44_36);
via lp (joint) [current] = ;
no [139,8,68];

type [140,4,74_2]; status: weights = {74,76,78,80};

set auto mu1;

type [140,6,70_2];  
status: weights = 70_2 - {74,90,98..106,114..140};
show (joint:0) y76 = 0, y92 = 0, y108 = 0;
status: weights = {70,72,78,80,82,84,86,88,94,96,110,112};
status: weights = {70,72,78,80,82,84,86,88,94,96};

type [140,8,68_2];
kill y138,y122,y114,y106,y98,y94,y90,y82 <dual constraint bound = 5>;
status: weights = 68_2 - {82,86,90,94,98,102,106,110,114,118,122,126,130,134,
     138};
kill y136 <adjoin extra brouwer constraints>;
status: weights = 68_2 - {82,86,90,94,98,102,106,110,114,118,122,126,130,134,
     136,138};

type [140,10,66_2]; 
status: weights = 66_2 - {122..140};
kill y120,y118 <dual constraint bound = 5>;
status: weights = 66_2 - {116..140};

type [139,13,64_2]; status: weights = 64_4 - {104..139};

type [140,14,64_2];
kill y100,y96,y92,y88,y84,y80;
kill [current] by (x_140|x_64|x_26_38);
no [140,14,64];

type [141,11,66_2]; status: weights = 66_2 - {112..141};

type [141,14,64_2];
kill y138,y136,y134,y132,y130,y128,y124,y122,y120,y118,y116,y114,y112,y126;
status: weights = 64_2 - {112..138};

type [142,7,70_2];
status: weights = 70_2 - {74,102,106,114,118..122,126..140};
kill y142,y124,y116,y98,y90,y100,y108,y92,y82,y84,y76;
??kill y112 by (x_48_30, x_56_30), y104 by x_52_20 <auto projection>;
status: weights = {70,72,78,80,86,88,94,96,110};

type [142,9,68_2];
status: weights = {68,72,74,76,78,80,82,84,88,90,92,94,96,100,104,108,
     100,104,108,112,116,120,136};

type [143,6,72_2];  
status: weights = {72,80,84,88,96,112};
type [143,6,72];  
status: weights = {72,80,84,88,96,112};
kill y84 <dual constraint bound = 5, auto projection>;
status: weights = {72,80,88,96,112};
status: weights = {72,80,88,96};

type [143,10,68_2]; status: weights = 68_4 - {112,116..143};
type [143,12,66_2]; status: weights = 66_2 - {120..143};

type [144,8,70_2];
status: weights = 70_2 - {90,106,114,122,130,134,138,140};
kill y144,y142,y132,y124,y116,y108,y100,y98,y92 <dual constraint bound = 5>;
kill y136 <adjoin extra brouwer constraints>;
status: weights = 
     {70,72,74,76,78,80,82,84,86,88,94,96,102,104,110,112,118,120,126,128};

type [144,11,68_2]; 
status: weights = 68_4 - {112..144};
kill y108 <auto projection>;
status: weights = {68,72,76,80,84,88,92,96,100};

type [144,13,66_2]; status: weights = 66_2 - {118..144};
type [145,5,74_2];  status: weights = {74,76,78,80};

type [145,7,72_2];
kill y144,ndiv4,y112;
show (joint:0) y92 = 0, y100 = 0;
show div8 > 112;
infer div8 = 128;
status: weights = {72,80,88,96};
type [145,7,72]; status: weights = {72,80,88,96};

type [146,9,70_2]; status: weights = 70_2 - {74,90,106,122,126..146};

type [147,10,70_2];
kill y116,y112,y110,y108,y100,y92,y84,y82,y76 <dual constraint bound = 5>;
status: weights = {70,72,78,80,86,88,94,96,102,104};

no [143,8,70];

type [145,14,66_2]; status: weights = 66_2 - {114..145};

type [146,12,68_2];
kill y146,y144,y142,y140,y138,y136,y134,y132,y130,y128,y126,y124,y122,y120,
     y116,y114,y112,y110,y106,y102,y98,y94,y90,y82,ndiv4;
status: weights = 68_4 - {112..146};

type [147,4,78_2]; status: weights = {78,80};

type [147,8,72_2];
kill y146,ndiv4;
status: weights = 72_4 - {92,108,116,124,132..140};
show (joint:0) y100 = 0, y144 = 0;
kill jy72y72y84, jy72y84y84, jy76y84y120, jy80y80y84, jy80y84y84, jy80y84y96, 
     jy84y84y104, jy84y84y112, jy84y84y88, jy84y84y96
     <adjoin extra brouwer constraints>;
show (joint:5) y84 = 0;
status: weights = {72,76,80,88,96,104,112,120,128};

type [147,13,68_2]; status: weights = 68_4 - {112..147};
type [148,5,76_2];  status: weights = {76,80};

type [148,6,74_2];  
status: weights = 74_2 - {82,98,106..114,122..148};
kill y116, y100 <dual constraint bound = 5>;
status: weights = {74,76,78,80,84,86,88,90,92,94,96,102,104,118,120};
status: weights = {74,76,78,80,84,86,88,90,92,94,96};

no [148,9,72];

type [149,9,72_2];  
status: weights = 72_2 - {74,76,78,86,90,92,94,106,108,110,118,120..149};
type [149,11,70_2]; status: weights = 70_2 - {122..149};
type [149,14,68_2]; status: weights = 68_2 - {118..146};

type [150,7,74_2];
kill y148;
status: weights = 74_2 - {82,110,114,122,126..130,134..148};
kill y150,y132,y120,y118,y116,y104,y102,y100,y98,y88,y86,y84,y124
     <dual constraint bound = 5>;
status: weights = {74,76,78,80,90,92,94,96,106,108,112};

type [150,10,72_2]; status: weights = {72,80,88,96};

type [151,6,76_2];
kill y90,y120,y104;
status: weights = {76,80,88,92,96};
type [151,6,76]; 
status: weights = {76,80,88,92,96};

type [151,12,70_2]; status: weights = 70_2 - {126..151};
type [152,5,78_2];  status: weights = {78,80};

type [152,8,74_2];
kill y148;
status: weights = 74_2 - {98,114,122,130,138,142,146,148};
kill y152,y150,y144,y140,y136,y134,y132,y120,y118,y116;
status: weights =
  {74,76,78,80,82,84,86,88,90,92,94,96,100,102,104,106,108,110,112,124,126,128};

type [152,11,72_2]; status: weights = {72,76,80,84,88,92,96,100,104,108,112};
type [152,13,70_2]; status: weights = 70_2 - {122..152};
type [153,7,76];    status: weights = {76,80,92,96,108};
type [153,14,70_2]; status: weights = 70_2 - {118..153};
type [154,9,74_2];  status: weights = 74_2 - {82,98,114,126,130,134..154};

type [154,12,72_2];
kill y154,y152,y150,y148,y146,y144,y142,y140,y138,y136,y134,y132,y130,y128,
     y124,y122,y120,y118,y116,y114,y110,y106,y102,y98,y90,y86,ndiv4;
status: weights = {72,76,80,84,88,92,96,100,104,108,112};

type [155,4,82_2]; status: weights = {82,84,86,88};
type [155,6,78];   status: weights = {78,80,94,96};

type [155,8,76_2];
kill y154,ndiv4;
status: weights = {76,80,84,88,92,96,104,108,112,120,128,136,152};
show (joint:0) y120 = 0, y136 = 0, y152 = 0;
show (joint:5) y104 = 0;
status: weights = {76,80,84,88,92,96,108,112,128};

type [155,10,74_2]; 
status: weights = 74_2 - {82,98,106,114,122..155};
kill y120,y118,y116;
status: weights = 74_2 - {82,98,106,114..155};

type [156,13,72_2]; status: weights = 72_2 - {126..156};
type [157,7,78];    status: weights = {78,80,94,96,110,112,126};

type [157,9,76_2];
status: weights = 76_2 - {78,82,84,86,94,98,100,102,114..118,122,126..157};
kill y124 <auto projection, dual constraint bound = 3>;
kill y106,y90 <dual constraint bound = 5>;
status: weights = {76,80,88,92,96,104,108,112,120};

type [157,11,74_2]; status: weights = 74_2 - {128..157};

no [155,13,72];
type [157,14,72_2]; 
status: weights = 72_2 - {122..157} <dual constraint bound = -1>;

unset auto mu1;

type [158,10,76]; 
status: weights = {76,80,92,96};
show (joint) y92 != 0;
kill [current] by (x_92|x_44_48) <auto projection, dual constraint bound = 3>;

psheadx(280)
// k =            2    3   4   5   6   7   8   9  10  11  12  13  14
psnext
n =138, k >= 2:  92,  78, 72, 70, 68, 68, 66, newd1()65, newd1()64, 64, 64, 63, 62; sn
n =139, k >= 2:  92,  79, 73, 71, 69, 68, 67, 66, newd1()65, 64, 64, 64, newd1()62; sn
n =140, k >= 2:  93,  80, 74, 72, 70, 68, 68, newd1()66, 66, 65, 64, 64, newd1()63; sn
n =141, k >= 2:  94,  80, 74, 72, 70, 69, 68, newd1()67, newd1()66, 66, newd1()64, 64, 64; sn
n =142, k >= 2:  94,  80, 75, 72, 71, 70, 68, 68, newd1()67, 66, newd1()65, newd1()64, 64; sn
n =143, k >= 2:  95,  81, 76, 72, 72, 70, 69, 68, 68, 67, 66, newd1()65, newd1()64; sn
n =144, k >= 2:  96,  82, 76, 73, 72, 71, 70, newd1()68, 68, 68, 66, 66, newd1()65; sn
n =145, k >= 2:  96,  82, 76, 74, 72, 72, 70, newd1()69, newd1()68, 68, 67, 66, 66; sn
n =146, k >= 2:  97,  83, 77, 74, 72, 72, 71, 70, newd1()69, 68, 68, 67, 66; sn
n =147, k >= 2:  98,  84, 78, 75, 73, 72, 72, newd1()70, 70, newd1()68, 68, 68, newd1()66; sn
n =148, k >= 2:  98,  84, 78, 76, 74, 72, 72, newd1()71, newd1()70, newd1()69, 68, 68, newd1()67; sn
n =149, k >= 2:  99,  84, 79, 76, 74, 73, 72, 72, newd1()71, 70, newd1()68, 68, 68; sn
n =150, k >= 2: 100,  85, 80, 76, 75, 74, 72, 72, 72, 70, newd1()69, newd1()68, 68; sn
n =151, k >= 2: 100,  86, 80, 77, 76, 74, 73, 72, 72, 71, 70, newd1()69, newd1()68; sn
n =152, k >= 2: 101,  86, 80, 78, 76, 75, 74, newd1()72, 72, 72, 70, 70, newd1()69; sn
n =153, k >= 2: 102,  87, 80, 78, 76, 76, 74, newd1()73, 72, 72, 71, 70, 70; sn
n =154, k >= 2: 102,  88, 81, 79, 77, 76, 75, 74, 73, 72, 72, 70, 70; sn
n =155, k >= 2: 103,  88, 82, 80, 78, 76, 76, newd1()74, 74, newd1()72, 72, 71, 70; sn
n =156, k >= 2: 104,  88, 82, 80, 78, 77, 76, newd1()75, 74, newd1()73, 72, 72, 71; sn
n =157, k >= 2: 104,  89, 83, 80, 79, 78, 76, 76, newd1()74, 74, newd1()72, 72, 72;
pstailx

set auto mu1;

TYPE_WE(158,6,80,1 + 62t^80 + t^96)

type [159,8,78_2];
kill y158, y156;
kill y88 <auto projection>;
status: weights = {78,80,84,92,94,96,98,100,108,110,112,116,124,132,140};
show (joint:0) y84 = 0, y92 = 0, y98 = 0, y100 = 0, y108 = 0, y116 = 0,
     y124 = 0, y132 = 0, y140 = 0;
status: weights = {78,80,94,96,110,112};
type [159,8,78]; status: weights = {78,80,94,96,110,112};

type [159,12,74_2]; status: weights = 74_2 - {130..159};
type [160,7,80];    status: weights = {80,96,112,128};
type [160,11,76_2]; status: weights = {76,80,84,88,92,96,100,104,108,112,116};
type [160,13,74_2]; status: weights = 74_2 - {126..160};
type [161,5,82_2]; status: weights = {82,84,86,88,90,92,94,96};

type [161,9,78_2];  
status: weights = 78_2 - {82,86,88,90,98,102,104,106,118..161};
kill y116 by (x_40_40, x_44_40), y114;
kill y108, y92 <dual constraint bound = 5>;
status: weights = {78,80,84,94,96,100,110,112};

type [161,14,74_2]; status: weights = 74_2 - {122,126..161};


psheadx(55)
// k =            2    3    4    5    6   7   8   9  10  11  12  13  14
psnext
n =158, k >= 2: 105,  90,  84,  80,  80, 78, 77, 76, newd1()75, 74, newd1()73, 72, 72; sn
n =159, k >= 2: 106,  90,  84,  80,  80, 79, 78, 76, 76, 75, 74, 73, 72; sn
n =160, k >= 2: 106,  91,  84,  81,  80, 80, 78, 77, 76, 76, 74, 74, 73; sn
n =161, k >= 2: 107,  92,  85,  82,  80, 80, 79, 78, newd1()76, 76, 75, 74, 74;
pstailx

type [162,4,86_2]; status: weights = {86,88};

type [162,8,80_2];
kill y162,ndiv4,y160,y100;
status: weights = {80,96,112};
type [162,8,80]; 
show (joint:5) 234 <= y80 <= 239, 11 <= y96 <= 21, y112 <= 5;
show (joint:5) y80 <= 237, y96 >= 14, y112 <= 3;
show (joint:5) y80 <= 236, y96 >= 16, y112 <= 2;
show (joint:5) 234 <= y80 <= 235, y96 >= 18, y112 <= 1;
show (joint:5) y96 >= 19;
status: weights = {80,96,112}, 
     constraints = {234 <= y80 <= 235, 19 <= y96 <= 21, y112 <= 1};

no [162,10,78];

type [162,12,76_2];
kill y162,y160,y158,y156,y154,y152,y150,y148,y146,y144,y142,y140,y138,y136,y132,
     y130,y128,y126,y124,y122,y120,y118,y114,y110,y106,y98,y94,y90,ndiv4;
status: weights = {76,80,84,88,92,96,100,104,108,112,116};

type [163,10,78_2]; status: weights = 78_2 - {90,106,114,122..163};
type [164,5,84_2];  status: weights = {84,88,92,96};

type [164,6,82_2];
status: weights = 82_2 - {98,114,122..130,138..164};
kill y132, y116 <dual constraint bound = 5>;
status: weights = 82_2 - {98,114,116,122..132,138..164};
status: weights = 82_2 - {98..164};

type [164,9,80_2];
kill y164, ndiv4, y160, y144, y128, y116;
status: weights = {80,96,112};
type [164,9,80]; status: weights = {80,96,112};

type [164,11,78_2];
status: weights = {78,80,84,88,92,94,96,100,104,108,112,116};
kill y94,y92,y88;
via lp [current] = ;
no [164,11,78];

type [164,13,76_2]; status: weights = 76_2 - {130..164};

no [165,10,80];

type [165,11,78_2]; status: weights = 78_2 - {134..165};
type [165,14,76_2]; status: weights = 76_2 - {126..165};

type [166,7,82_2];
kill y166,y164,y148,y140,y136,y134,y132,y102,y100 <dual constraint bound = 3>;
status: weights = 82_2 - {98,100,102,126,130..166};

type [166,10,80_2]; 
status: weights = {80,82,84,88,96,100,104,112};

type [167,6,84_2];
kill y106,ndiv4,y136,y120;
status: weights = {84,88,92,96,104,108,112};
type [167,6,84]; status: weights = {84,88,92,96,104,108,112};
type [167,6,84]; status: weights = {84,88,92,96};

type [167,12,78_2]; status: weights = 78_2 - {134..167};
type [168,5,86_2];  status: weights = {86,88,92,94,96};

type [168,8,82_2];
kill y168,y166,y164,y160,y156,y152,y150,y148,y136,y134,y132
     <dual constraint bound = 3>;
status: weights = 82_2 - {114,130..138,146..168};

type [168,11,80_2]; status: weights = 80_4 - {128..168};
type [168,13,78_2]; status: weights = 78_2 - {132..168};

type [169,7,84_2];
kill y168,ndiv4;
status: weights = {84,88,92,96,104,108,112,116,120,124,136};
show (joint:0) y104 = 0, y136 = 0;
status: weights = {84,88,92,96,108,112,116,120,124};
type [169,7,84]; status: weights = {84,88,92,96,108,112,116,120,124};

type [170,4,90_2]; status: weights = {90,92,94,96};

type [170,9,82_2]; 
status: weights = 82_2 - {98,114,130,146,150..162,166..170};
kill y164 <dual constraint bound = 3>;
status: weights = 82_2 - {98,114,130,142,146,150..170};

no [167,8,82];
no [169,9,82];

type [170,12,80_2];
kill y170,y168,y166,y164,y162,y160,y158,y156,y154,y152,y150,y148,y146,y144,
     y140,y138,y136,y134,y132,y130,y128,y126,y124,y122,y118,y114,y106,y102,
     y98,y94,ndiv4,y120;
status: weights = {80,84,88,92,96,100,104,108,112,116};

type [171,6,86_2];  
status: weights = {86,88,92,94,96,108,110,112};
show (joint:0) y92 = 0, y108 = 0;
status: weights = {86,88,94,96,110,112};
type [171,6,86];  status: weights = {86,88,94,96,110,112};
type [171,6,86];  status: weights = {86,88,94,96};

type [171,8,84_2];  
status: weights = 84_4 - {116,132,140,148,156..164};
show (joint:0) y136 = 0, y152 = 0, y168 = 0;
status: weights = {84,88,92,96,100,104,108,112,120,124,128,144};
kill jy100y108y120, jy104y104y120, jy104y108y108, jy104y112y112, jy108y108y112,
     jy108y108y120;
config 120,51 : {10};
kill x_52_44, x_48_40, x_44_44, x_56_40;
at [base];
kill y144 by x_68_20;
at [base];
kill jy88y104y128, jy88y112y112, jy88y112y128, jy96y104y128, jy96y112y112;
status: weights = {84,88,92,96,100,104,108,112,120,124,128};

type [171,10,82_2]; status: weights = 82_2 - {98,114,122..171};

no [172,9,84];
no [172,11,82];

type [172,13,80_2];
kill y172,y170,y168,y166,y164,y162,y160,y158,y156,y154,y152,y150,y148,y146;
kill y144 <dual constraint bound = -1>;
kill y142,y140,y138,y136,y134,y82,y130;
kill y126 <dual constraint bound = -1>;
kill y118,y114,y110,y106,y122,y102,y94,ndiv4;
status: weights = 80_4 - {136..172};

type [173,7,86_2];
kill y172;
show (joint:0) y92 = 0, y100 = 0, y108 = 0, y114 = 0, y116 = 0, y124 = 0,
     y140 = 0, y142 = 0;
status: weights = {86,88,94,96,110,112,118,120,126,128};

type [173,9,84_2];  
status: weights = 84_4 - {100,116,132,144..173};
kill y140 <auto projection, dual constraint bound = 3>;
status: weights = {84,88,92,96,104,108,112,120,124,128,136};

type [173,11,82_2]; status: weights = 82_2 - {140..173};
type [173,14,80_2]; status: weights = 80_4 - {132..173};
type [174,6,88_2];  status: weights = {88,96};

type [174,10,84_2]; 
status: weights = {84,88,92,96,104,108,112};
show (joint:0) y112 = 0;
status: weights = {84,88,92,96,104,108};
type [174,10,84]; status: weights = {84,88,92,104,108};

type [175,8,86_2];
kill y172, y174;
status: weights = {86,88,92,94,96,100,104,108,110,112,114,116,124,126,128,132,
     140,148,156};
kill y156,y148,y140,y132;
kill y124,y116,y114,y108,y104,y100 <dual constraint bound = 3>;
status: weights = {86,88,92,94,96,110,112,126,128};

type [175,12,82_2]; status: weights = 82_2 - {140..175};
type [176,5,90_2];  status: weights = {90,92,94,96};
type [176,7,88_2];  status: weights = {88,96,112,120,128};
type [176,11,84_2]; status: weights = 84_4 - {132..176};

type [176,13,82_2];
kill y176,y138,y136,y134,y102,y98,y96;
via lp [current] = ;
no [176,13,82];

psheadx(195)
// k =            2    3    4    5    6   7   8   9  10  11  12  13  14
psnext
n =162, k >= 2: 108,  92,  86,  82,  80, 80, 80, 78, newd1()77, 76, 76, 74, 74; sn
n =163, k >= 2: 108,  92,  86,  83,  81, 80, 80, 79, 78, newd1()76, 76, 75, 74; sn
n =164, k >= 2: 109,  93,  87,  84,  82, 80, 80, 80, 78, newd1()77, 76, 76, 75; sn
n =165, k >= 2: 110,  94,  88,  84,  82, 81, 80, 80, 79, 78, newd1()76, 76, 76; sn
n =166, k >= 2: 110,  94,  88,  84,  83, 82, 80, 80, 80, newd1()78, newd1()77, newd1()76, 76; sn
n =167, k >= 2: 111,  95,  88,  85,  84, 82, 81, 80, 80, newd1()79, newd1()78, newd1()77, newd1()76; sn
n =168, k >= 2: 112,  96,  88,  86,  84, 83, 82, newd1()80, 80, 80, newd1()78, 78, newd1()76; sn
n =169, k >= 2: 112,  96,  89,  86,  84, 84, 82, newd1()81, newd1()80, 80, newd1()79, 78, newd1()77; sn
n =170, k >= 2: 113,  96,  90,  87,  85, 84, 83, 82, newd1()81, 80, 80, 78, 78; sn
n =171, k >= 2: 114,  97,  90,  88,  86, 84, 84, newd1()82, 82, newd1()80, 80, 79, 78; sn
n =172, k >= 2: 114,  98,  91,  88,  86, 85, 84, newd1()83, newd1()82, newd1()81, 80, 80, 79; sn
n =173, k >= 2: 115,  98,  92,  88,  87, 86, 84, 84, newd1()83, 82, newd1()80, 80, 80; sn
n =174, k >= 2: 116,  99,  92,  88,  88, 86, 85, 84, 84, newd1()82, newd1()81, 80, 80; sn
n =175, k >= 2: 116, 100,  92,  89,  88, 87, 86, 84, 84, newd1()83, 82, newd1()80, 80; sn
n =176, k >= 2: 117, 100,  93,  90,  88, 88, 86, 85, 84, 84, newd1()82, newd1()81, newd1()80;
pstailx

type [170,14,78_2]; 
status: weights = 78_2 - {142..168} <dual constraint bound = -1>;

type [177,4,94_2]; status: weights = {94,96};

type [177,9,86_2];
status: weights = 86_2 - {90,98,102,104,106,114,118,120,122,134..138,142..177};
kill y140,y132,y130,y124,y116,y108,y100 <dual constraint bound = 3>;
status: weights = {86,88,92,94,96,110,112,126};

type [177,13,82_2];
kill y176,y174,y172,y170,y168,y166,y160,y158,y156,y154,y150,y162;
status: weights = 82_2 - {150,154..162,166,168,170,172,174,176};

type [178,8,88];
STATUS_WE(1 + 216t^88 + 38t^96 + t^128)

no [178,10,86];

type [178,12,84_2];
kill y178,y176,y174,y172,y170,y168,y166,y164,y162,y160,y158,y156,y154,y152,
     y148,y146,y144,y142,y140,y138,y136,y134,y132,y130,y128,y126,y124,y122,
     y114,y110,y106,y102,y98,ndiv4,y120;
status: weights = {84,88,92,96,100,104,108,112,116};

type [178,14,82_2];
kill y178 by x_82,y164,y152,y148;
status: weights = 82_2 - {148..178};

type [179,5,92_2]; status: weights = {92,96};

type [179,6,90_2];  
status: weights = {90,92,94,96,100,102,104,116,118,120};
show (joint:0) y100 = 0, y116 = 0;
status: weights = {90,92,94,96,102,104,118,120};
type [179,6,90];  status: weights = {90,92,94,96,102,104,118,120};
type [179,6,90];  status: weights = {90,92,94,96};

type [179,10,86_2]; 
status: weights = 86_2 - {106,122,130,136,138,142..179};
kill y140 <dual constraint bound = 5>;
status: weights = 86_2 - {106,122,130,136..179};

type [180,11,86_2]; 
status: weights = 86_2 - {90,98,106,114,122,130..178};
kill y180,y128,y126,y124,y116,y108,y100,y92 <dual constraint bound = 3>;
status: weights = {86,88,94,96,102,104,110,112,118,120};

psheadx(40)
// k =            2    3    4    5    6   7   8   9  10  11  12  13  14
psnext
n =177, k >= 2: 118, 100,  94,  90,  88, 88, 87, 86, newd1()84, 84, newd1()83, 82, newd1()81; sn
n =178, k >= 2: 118, 101,  94,  91,  89, 88, 88, 86, newd1()85, 84, 84, 82, 82; sn
n =179, k >= 2: 119, 102,  95,  92,  90, 88, 88, 87, 86, 85, 84, 83, 82;
pstailx

type [180,9,88_2];
kill y180,ndiv4,y176,y160,y144;
kill y132 <auto projection>;
type [180,9,88]; status: weights = {88,96,112};

type [180,13,84_2];
kill y180,y178,y176,y174,y172,y170,y168,y166,y164,y162,y160,y158,y156;
kill y154 <dual constraint bound = -1>;
kill y152,y150,y148;
kill y146 <dual constraint bound = -1>;
kill y144,y142,y140,y138,y134,y130,y126,y122,y118,y114,
     y110,y106,y102,y98,ndiv4,y136;
status: weights = {84,88,92,96,100,104,108,112,116,120,124,128,132};

type [181,7,90_2];
kill y180,y150,y148,y136,y134,y132,y120,y118,y116,y108,y104,y102,y100
     <dual constraint bound = 3>;
status: weights = {90,92,94,96,122,124,126,128};

type [181,14,84_2]; status: weights = 84_4 - {128..181};

TYPE_WE(182,6,92,1 + 56t^92 + 7t^96)

no [180,7,90];
no [182,8,90];

type [182,10,88_2]; status: weights = {88,92,96,98,100,104,112,116,120,128};
type [183,5,94_2];  status: weights = {94,96};

type [183,8,90_2];
kill y180,y182,y164,y156,y148,y140,y132,y116,y112,y108 
     <dual constraint bound = 3>;
status: weights = {90,92,94,96,100,102,104,118,120,122,124,134,136};

type [183,11,88_2];
kill y128,y120 <dual constraint bound = 3>;
kill y104 <dual constraint bound = 5, auto projection>;
via lp [current] = ;
no [183,11,88];

type [183,12,86_2]; status: weights = 86_2 - {146..183};
type [184,7,92];    status: weights = {92,96,124,128};

type [184,11,88_2];
kill y184,y182,y180,y178,y176,y174,y172,y170,y168,y164,y162,y160,y156,y154,
     y152,y148,y146,y144,y140,y138 <dual constraint bound = 3>;
status: weights = {88,90,92,96,98,100,104,106,108,112,114,116,120,122,124,
     128,130,132,136};

type [185,4,98_2]; status: weights = {98,100,102,104};

type [185,9,90_2];
kill y148,y140,y138,y136,y134,y132,y120,y118,y116 <dual constraint bound = 3>;
status: weights = {90,92,94,96,100,102,104,108,124};

type [185,13,86_2]; status: weights = 86_2 - {156..185};

TYPE_WE(186,6,94,1 + 48t^94 + 15t^96)

type [186,8,92_2];
show (joint:0) y104 = 0, y122 = 0, y136 = 0, y184 = 0, y186 = 0;
status: weights = {92,94,96,120,124};

type [186,12,88_2];
kill y186,y184,y182,y180,y178,y176,y174,y172,y170,y168,y166,y164,y162,y160,
     y156,y154,y152,y150,y148,y146,y144,y142,y140,y138,y136,y134,y132,y130,
     y128,y122,y118,y114,y110,y106,y102,ndiv4,y124;
status: weights = 88_4 - {124..186};

no [184,13,86];
type [186,14,86_2];
kill y186 by x_86;
kill y154 <dual constraint bound = -1>;
status: weights = 86_2 - {154..186};

type [187,10,90_2]; 
status: weights = 90_2 - {114,130,138,142..187};
kill y140 <dual constraint bound = 3>;
status: weights = 90_2 - {114,130,138..187};

type [188,7,94_2];  
status: weights = {94,96,124,126,128};
show (joint:0) y124 = 0;
status: weights = {94,96,126,128};
type [188,7,94];  status: weights = {94,96,126,128};

type [188,9,92_2];
kill y188,ndiv4,y184,y168,y152,y140;
status: weights = {92,96,104,120,136};
no [188,9,92]<auto joint test>;

no [188,11,90];

type [188,13,88_2];
kill y188,y186,y184,y182,y180,y178,y176,y174,y172,y170,y168,y166;
kill y164 <dual constraint bound = -1>;
kill y160,y158,y156,y152,y150,y148,y146,y144,y142,y140,y138,y136,y134,y130,
     y126,y122,y118,y114,y110,y106,y102,y98,y94,ndiv4,y132,y128,y124;
status: weights = {88,92,96,100,104,108,112,116,120};

TYPE_WE(189,6,96, 1 + 63t^96)

TYPE_WE(189,8,94,1 + 189t^94 + 63t^96 + 3t^126)

type [189,9,92_2]; status: weights = {92,94,96,98,100,104,106,108,112,
     120,122,124,128,136,138,140,142,144,152,156};

type [189,11,90_2];
kill y188,y186,y184,y182,y180,y178,y176,y174,y172,y170,y168,y166,y164,y162,
     y160,y158,y156,y154,y152 <dual constraint bound = 3>;
status: weights = 90_2 - {152..189};

type [190,10,92_2]; status: weights = {92,96,100,104,108,112,124};

type [190,14,88_2];
kill y190 by x_88,y188,y186,y184,y182,y180,y178,y174,y172,y170,y168,y164,
     y162,y160,y158,y156;
kill y176,y166 <dual constraint bound = -1>;
status: weights = 88_2 - {156..190};

TYPE_WE(191,7,96, 1 + 126t^96 + t^128)

type [191,12,90_2]; status: weights = 90_2 - {152..191};

no [190,7,96];
TYPE_WE(192,8,96,1 + 252t^96 + 3t^128)

type [192,4,102_2]; status: weights = {102,104};
type [192,5,98_2];  status: weights = {98,100,102,104,106,108,110,112};

type [192,9,94_2]; status: weights = {94,96,100,108,124};
no [192,9,94]<auto joint test>;

type [192,11,92_2]; 
status: weights = 92_2 - {94,102,110,114,118,126,130,134,138,142,146..192};

type [193,9,94_2];
kill y192,y190,y188,y184,y180,y176,y174,y172,y164,y160,y158,y156,y140
     <dual constraint bound = 3>;
status: weights = 94_2 - {106,114,118,120,122,130,134,136,138,140,148,150..193};

type [193,13,90_2]; status: weights = 90_2 - {160..193};
type [194,10,94_2]; status: weights = 94_2 - {98,102,106,114,118..122,126..194};

type [194,12,92_2];
kill y194,y192,y190,y188,y186,y184,y182,y180,y178,y176,y174,y172,y170,y168,
     y164,y162,y160,y158,y156,y154,y152,y150,y148,y146,y144,y142,y140,y138,
     y136,y130,y126,y122,y118,y114,y110,y106,ndiv4;
status: weights = 92_4 - {136..194};

type [194,14,90_2];
kill y194 by x_90, y158;
status: weights = 90_2 - {158..194};

type [195,5,100_2]; status: weights = {100,104,108,112};

type [195,10,94_2];
kill y194,y192,y190,y188,y186,y184,y182,y180,y178,y176,y174,y172,y168,y166,
     y164,y160,y158,y156,y152,y150 <dual constraint bound = 3>;
status: weights = 94_2 - {122,138,146,150..195};

type [196,6,98_2]; 
status: weights = 98_2 - {130,146,154..162,170..196};
kill y164,y148 <dual constraint bound = 3>;
status: weights = 98_2 - {130,146,148,154..164,170..196};
status: weights = 98_2 - {130..196};

type [196,9,96_2];
status: weights = {96,98,100,104,112,128,144,148};
show (joint:0) y148 = 0;
status: weights = {96,98,100,104,112,128,144};

type [196,11,94_2];
kill y144,y142,y140,y132,y124 <dual constraint bound = 3>;
status: weights = {94,96,100,102,104,108,110,112,116,118,120,126,128,134,136};

type [197,13,92_2]; 
kill y196,y194,y192,y190,y188,y186,y184,y182,y180,y178;
kill y176 <dual constraint bound = -1>;
kill y174,y172,y170,y168,y166,y164,y162;
status: weights = 92_2 - {162..197};

type [198,7,98_2];
kill y196 <dual constraint bound = 3>;
kill y198, y180, y172 by (x_80_20, x_84_20), y168, y164, y166
     <dual constraint bound = 5>;
status: weights = 98_2 - {130,158,162..198};
status: weights = 98_2 - {130..198};

set purge joints on type exit;

type [198,10,96_2];
status: weights = {96,98,100,104,108,112,114,116,120,128,132,136};

type [198,14,92_2];
kill y198 by x_92;
status: weights = 92_2 - {162..198};

type [199,5,102_2]; status: weights = {102,104,108,110,112};

type [199,6,100_2];
kill y138,ndiv4,y168,y152;
status: weights = {100,104,108,112,116,120,124,128,136,140,144};
status: weights = {100,104,108,112,116,120,124,128};

no [197,7,98];

type [199,8,98_2];  
status: weights = 98_2 - {114,122,126,130..199};
kill y124 <dual constraint bound = 3>;
status: weights = {98,100,102,104,106,108,110,112,116,118,120,128};

type [199,11,96_2]; status: weights = {96,104,112,120,128};
type [199,12,94_2]; status: weights = 94_2 - {158..199};

type [200,4,106_2]; status: weights = {106,108,110,112};

(* No credits have been added for 201,..204. *);

type [201,7,100];
status: weights = 100_4 - {129..201};

type [202,8,100];
status: weights = {100,104,108,112,120};
show (joint:0) 196 <= y100 <= 206, 20 <= y104 <= 47, y108 <= 21, 
     2 <= y112 <= 10, 1 <= y120 <= 3;
show (joint:0) 199 <= y100 <= 205, 23 <= y104 <= 39, 7 <= y108 <= 20,
     4 <= y112 <= 9, y120 = 2;
show (joint:0) 202 <= y100 <= 203, 27 <= y104 <= 30, 14 <= y108 <= 17,
     6 <= y112 <= 7;
via lp (joint:0) [current] = ;
no [202,8,100];

type [201,13,94_2]; status: weights = 94_2 - {165..201};
type [202,9,98_2];  status: weights = 98_2 - {130,146,162,178,190..194,200,202};
type [202,12,96_2]; status: weights = 96_4 - {137..202};
type [202,14,94_2]; status: weights = 94_2 - {161..202};
type [203,6,102_2]; status: weights = 102_2 - {106,122,129..203};

type [203,8,100_2];
status: weights = 100_2 - {118,126,130,134,146,148,150,158,162,164,166,170,
     172,174,178,180,182,185..199,201..203};

no [203,10,98];

unset auto mu1;

psheadx(300)
// k =            2    3    4    5    6   7   8   9  10  11  12  13  14
psnext
n =180, k >= 2: 120, 102,  96,  92,  90, 89, 88, 88, newd1()86, 86, 84, 84, 83; sn
n =181, k >= 2: 120, 103,  96,  92,  91, 90, 88, 88, newd1()87, 86, newd1()84, 84, 84; sn
n =182, k >= 2: 121, 104,  96,  93,  92, 90, 89, 88, 88, newd1()86, newd1()85, 84, 84; sn
n =183, k >= 2: 122, 104,  96,  94,  92, 91, 90, 88, 88, newd1()87, 86, newd1()84, 84; sn
n =184, k >= 2: 122, 104,  97,  94,  92, 92, 90, 89, 88, 88, 86, newd1()85, newd1()84; sn
n =185, k >= 2: 123, 105,  98,  95,  93, 92, 91, 90, newd1()88, 88, 87, 86, newd1()85; sn
n =186, k >= 2: 124, 106,  98,  96,  94, 92, 92, 90, newd1()89, 88, 88, 86, 86; sn
n =187, k >= 2: 124, 106,  99,  96,  94, 93, 92, newd1()90, 90, newd1()88, 88, 87, 86; sn
n =188, k >= 2: 125, 107, 100,  96,  95, 94, 93, newd1()91, newd1()90, newd1()89, 88, 88, newd1()86; sn
n =189, k >= 2: 126, 108, 100,  96,  96, 94, 94, 92, newd1()91, 90, newd1()88, 88, newd1()87; sn
n =190, k >= 2: 126, 108, 100,  96,  96, 95, 94, 92, 92, newd1()90, newd1()89, 88, 88; sn
n =191, k >= 2: 127, 108, 101,  97,  96, 96, 95, newd1()92, 92, newd1()91, 90, newd1()88, 88; sn
n =192, k >= 2: 128, 109, 102,  98,  96, 96, 96, newd1()93, 92, 92, 90, newd1()89, newd1()88; sn
n =193, k >= 2: 128, 110, 102,  98,  96, 96, 96, 94, newd1()92, 92, 91, 90, newd1()89; sn
n =194, k >= 2: 129, 110, 103,  99,  96, 96, 96, 94, newd1()93, 92, 92, 90, 90; sn
n =195, k >= 2: 130, 111, 104, 100,  97, 96, 96, 95, 94, 93, 92, newd1()90, 90; sn
n =196, k >= 2: 130, 112, 104, 100,  98, 96, 96, 96, newd1()94, 94, 92, newd1()91, newd1()90; sn
n =197, k >= 2: 131, 112, 104, 100,  98, 97, 96, 96, newd1()95, 94, newd1()92, 92, newd1()91; sn
n =198, k >= 2: 132, 112, 104, 101,  99, 98, 97, 96, 96, 95, newd1()93, 92, 92; sn
n =199, k >= 2: 132, 113, 105, 102, 100, 98, 98, 96, 96, 96, 94, newd1()92, 92; sn
n =200, k >= 2: 133, 114, 106, 102, 100, 99, 98, 96, 96, 96, 94, newd1()93, 93; sn
n =201, k >= 2: 134, 114, 106, 103, 100,100, 98, 97, 96, 96, 95, 94, 93; sn
n =202, k >= 2: 134, 115, 107, 104, 101,100, 99, 98, newd1()96, 96, 96, 94, 94; sn
n =203, k >= 2: 135, 116, 108, 104, 102,100,100, 98, newd1()97, 96, 96, newd1()94, 94; sn
n =204, k >= 2: 136, 116, 108, 104, 102,101,100, 99, 98, 97, 96, newd1()95, 94; sn
n =205, k >= 2: 136, 116, 108, 104, 103,102,100,100, 99, 98, newd1()96, 96, 95; sn
n =206, k >= 2: 137, 117, 109, 105, 104,102,101,100,100, 98, newd1()97, 96, 96;
pstailx

data_comment( ![\block{Computer-generated tables for
$207 \leq n \leq 300$, $k \leq 14$}

In the this section we give computer-generated restrictions on weights and 
bounds on minimum distance for $207 \leq n \leq 300$, $k \leq 14$, obtained
via the command sequence:

\begin{verbatim}
     accept (tables only) inputs/code.data;  
     set dual constraint bound = 3;
     set repeat loop;
     set allowed failures = 10;
     build tables for 207 <= n <= 300, 2 <= k <= 14;
\end{verbatim}

where {\tt code.data} was the {\it old\/} {\tt code.data}, before inclusion
of this section.  (There was some minor editing by hand done afterwards.)
These bounds are not likely to be particularly sharp.
They have not been compared with Brouwer's tables. ]! )

set dual constraint bound = 3;

type [207,8,102_2];
status: weights = 102_2 - {122,130..134,138,140,150..156,162..206};
type [207,10,100_2];
status: weights = 
     100_2 - {102,126,130,134,138,142,146,150,154,158,162,166..206};
type [208,11,100_2];
status: weights = 100_4 - {148..208};
type [207,12,98_2];
status: weights = 98_2 - {166..206};
type [207,14,96_2];
status: weights = 96_2 - {182..190,194..204};
n = 207, k >= 2: 138, 118, 110, 106, 104, 103, 102, 100, 100, 99, 98, 96, 96;
type [208,8,102_2];
status: weights = 102_2 - {154,170,172,178,186,188,194..198,202,204};
type [209,9,102_2];
status: weights = 102_2 - {106,122,130,134..138,146..156,162..208};
type [208,10,100_2];
status: weights = 100_2 - {178..208};
type [208,12,98_2];
status: weights = 98_2 - {178..208};
type [209,13,98_2];
status: weights = 98_2 - {170..208};
n = 208, k >= 2: 138, 118, 110, 106, 104, 104, 102, 101, 100, 100, 98, 97, 96;
type [210,8,104_2];
status: weights = {104,106,108,112,116,120,128,144,160,208};
type [209,10,100_2];
status: weights = 100_2 - {190..198,202..208};
type [209,11,100_2];
status: weights = 100_2 - {170..208};
type [210,12,100_2];
status: weights = 100_4 - {148..208};
type [210,14,98_2];
status: weights = 98_2 - {168..210};
n = 209, k >= 2: 139, 119, 111, 107, 104, 104, 103, 102, 100, 100, 99, 98, 97;
type [210,9,102_2];
status: weights = 102_2 - {138,154,170,186,208,210};
type [211,10,102_2];
status: weights = 
     {102,104,110,112,116,118,120,126,128,134,136,142,144,150,152,158};
type [210,11,100_2];
status: weights = 100_2 - {182..210};
type [210,13,98_2];
status: weights = 98_2 - {190..194,200..210};
n = 210, k >= 2: 140, 120, 112, 108, 105, 104, 104, 102, 101, 100, 100, 98, 98;
type [212,9,104_2];
status: weights = {104,112,120,128,144,160};
type [212,11,102_2];
status: weights = {102,104,110,112,118,120,126,128,134,136,142,144};
type [211,12,100_2];
status: weights = 100_2 - {170..210};
type [211,14,98_2];
status: weights = 98_2 - {186..194,198..210};
n = 211, k >= 2: 140, 120, 112, 108, 106, 104, 104, 103, 102, 101, 100, 98, 98;
type [212,10,102_2];
status: weights = 102_2 - {178,182..212};
type [212,12,100_2];
status: weights = 100_2 - {182..212};
type [213,13,100_2];
status: weights = 100_2 - {170..212};
n = 212, k >= 2: 141, 120, 112, 108, 106, 105, 104, 104, 102, 102, 100, 99, 98;
type [214,8,106_2];
status: weights = {106,108,110,112,122,124};
type [213,9,104_2];
status: weights = 104_2 - {110,126,134,138..142,150,154..158,166,170..174,178,
     182,186..190,194..206,210,212};
type [214,10,104_2];
status: weights = {104,112,120,128,136,144,152};
type [213,11,102_2];
status: weights = 102_2 - {174..212};
type [213,12,100_2];
status: weights = 100_2 - {198,202..212};
type [214,14,100_2];
status: weights = 100_2 - {170..214};
n = 213, k >= 2: 142, 121, 112, 109, 107, 106, 105, 104, 103, 102, 100, 100, 99;
type [215,11,104_2];
status: weights = {104,112,120,128,136};
type [215,12,102_2];
status: weights = 102_2 - {170..214};
type [214,13,100_2];
status: weights = 100_2 - {190,194..198,202..214};
n = 214, k >= 2: 142,122, 113, 110, 108, 106, 106, 104, 104, 103, 101, 100, 100;
type [215,8,106_2];
status: weights = 106_2 - {130,138..142,146,158..164,170..212};
type [215,10,104_2];
status: weights = 104_2 - {110,142,158,166,170..214};
type [215,14,100_2];
status: weights = 100_2 - {186..198,202..214};
n = 215, k >= 2: 143,122, 114, 110, 108, 107, 106, 104, 104, 104, 102, 100, 100;
type [217,8,108_2];
status: weights = {108,112,124};
type [217,9,106_2];
status: weights = {106,108,110,112,120,122,124,126,128,136,140,152,156,170};
type [216,10,104_2];
status: weights = 104_2 - {182,186..216};
type [216,11,104_2];
status: weights = 104_2 - {110,118,126,134,142,150,158,162..216};
type [216,12,102_2];
status: weights = 102_2 - {184..216};
type [217,13,102_2];
status: weights = 102_2 - {174..216};
n = 216, k >= 2: 144,123, 114, 111, 108, 108, 107, 105, 104, 104, 102, 101, 100;
type [217,10,104_2];
status: weights = 104_2 - {198..206,210..216};
type [217,11,104_2];
status: weights = 104_2 - {174,178..216};
type [218,12,104_2];
status: weights = 104_4 - {156..216};
type [218,14,102_2];
status: weights = 102_2 - {154,158,162,166,170..218};
n = 217, k >= 2: 144,124, 115, 112, 109, 108, 108, 106, 104, 104, 103, 102, 101;
type [218,8,108_2];
status: weights = {108,110,112,114,116,120,124,126,128,136,152,156,168,216};
type [219,10,106_2];
status: weights = 106_2 - {114,146,162,166..218};
type [218,11,104_2];
status: weights = 104_2 - {188..218};
type [218,13,102_2];
status: weights = 102_2 - {190,194..202,206..218};
n = 218, k >= 2: 145,124, 116, 112, 110, 108, 108, 106, 105, 104, 104, 102, 102;
type [220,11,106_2];
status: weights = 106_2 - {114,116,122,130..134,138,142..220};
type [219,12,104_2];
status: weights = 104_2 - {174..218};
type [219,13,102_2];
status: weights = 102_2 - {216};
type [219,14,102_2];
status: weights = 102_2 - {190..218};
n = 219, k >= 2: 146,124, 116, 112, 110, 109, 108, 106, 106, 105, 104, 102, 102;
type [221,8,110_2];
status: weights = {110,112,126,128};
type [221,9,108_2];
status: weights = 108_2 - {118,122,134,138,142,146..150,154,158,162..166,170,
     178..182,186,190,194..198,202,206..214,218,220};
type [220,10,106_2];
status: weights = 106_2 - {186,190..220};
type [220,12,104_2];
status: weights = 104_2 - {186..220};
type [221,13,104_2];
status: weights = 104_2 - {174..220};
n = 220, k >= 2: 146,125, 116, 112, 111, 110, 109, 107, 106, 106, 104, 103, 102;
type [222,10,108_2];
status: weights = 108_4 - {116,148,160..220};
type [221,11,106_2];
status: weights = 106_2 - {178..220};
type [221,12,104_2];
status: weights = 104_2 - {206..220};
type [222,14,104_2];
status: weights = 104_4 - {176..220};
n = 221, k >= 2: 147,126, 117, 112, 112, 110, 110, 108, 107, 106, 104, 104, 103;
type [222,8,110_2];
status: weights = 110_2 - {122,124,134..156,162..220};
type [222,10,108_2];
status: weights = 108_4 - {116,144..220};
type [222,11,106_2];
status: weights = 106_2 - {190..222};
type [223,12,106_2];
status: weights = 106_2 - {178..222};
type [222,13,104_2];
status: weights = 104_2 - {194..222};
n = 222, k >= 2: 148,126, 118, 113, 112, 111, 110, 108, 108, 106, 105, 104, 104;
type [223,10,108_2];
status: weights = 108_2 - {118,150,166,170,174,178..222};
type [224,11,108_2];
status: weights = 108_2 - {118,126,134,142,146,150,154,158,162,166,170..224};
type [223,13,104_2];
status: weights = 104_2 - {220,222};
type [223,14,104_2];
status: weights = 104_2 - {190..222};
n = 223, k >= 2: 148,127, 118, 114, 112, 112, 111, 108, 108, 107, 106, 104, 104;
type [225,9,110_2];
status: weights = 
     110_2 - {122,138,146,150..154,162,166..172,182..188,194..204,208..224};
type [224,10,108_2];
status: weights = 108_2 - {190,194..224};
type [224,12,106_2];
status: weights = 106_2 - {190..224};
type [225,13,106_2];
status: weights = 106_2 - {178..224};
type [224,14,104_2];
status: weights = 104_2 - {218..222};
n = 224, k >= 2: 149,128, 119, 114, 112, 112, 112, 109, 108, 108, 106, 105, 104;
type [225,8,112_2];
status: weights = {112,114,116,120,128,130,132,160,224};
type [226,10,110_2];
status: weights = {110,112,126,128,132,136,142};
type [225,11,108_2];
status: weights = 108_2 - {182,186..224};
type [226,12,108_2];
status: weights = 108_4 - {160..224};
n = 225, k >= 2: 150,128, 120, 115, 112, 112, 112, 110, 109, 108, 107, 106, 104;
type [227,10,110_2];
status: weights = 110_2 - {122,154,170,174..226};
type [226,11,108_2];
status: weights = 108_2 - {194..226};
type [226,13,106_2];
status: weights = 106_2 - {194..226};
n = 226, k >= 2: 150,128, 120, 116, 113, 112, 112, 110, 109, 108, 108, 106, 105;
type [228,9,112_2];
status: weights = {112,114,116,120,128,130,132,136,144,160,176,180,192};
type [228,11,110_2];
status: weights = 110_2 - {122,124,130,138,140,146,154,156,162..228};
type [227,12,108_2];
status: weights = 108_2 - {182..226};
type [227,13,106_2];
status: weights = 106_2 - {222..226};
n = 227, k >= 2: 151,129, 120, 116, 114, 112, 112, 111, 110, 109, 108, 106, 106;
type [228,10,110_2];
status: weights = 110_2 - {194..228};
type [228,12,108_2];
status: weights = 108_2 - {194..228};
type [229,13,108_2];
status: weights = 108_2 - {180..228};
type [228,14,106_2];
status: weights = 106_2 - {220..226};
n = 228, k >= 2: 152,130, 120, 116, 114, 113, 112, 112, 110, 110, 108, 107, 106;
type [230,8,114_2];
status: weights = 114_2 - {130..230};
type [229,9,112_2];
status: weights = 112_2 - 
     {126,142,150,154..158,166,170..174,186..190,198,202..206,214,218,222,228};
type [230,10,112_2];
status: weights = 112_2 - {118,122..126,134,138,142,150,154..158,162,166..230};
type [229,11,110_2];
status: weights = 110_2 - {182..228};
type [229,12,108_2];
status: weights = 108_2 - {210..228};
type [230,14,108_2];
status: weights = 108_4 - {176..228};
n = 229, k >= 2: 152,130, 121, 117, 115, 114, 113, 112, 111, 110, 108, 108, 107;
type [231,11,112_2];
status: weights = {112,116,120,128,136,144};
type [231,12,110_2];
status: weights = 110_2 - {186..230};
type [230,13,108_2];
status: weights = 108_2 - {198..230};
n = 230, k >= 2: 153,131, 122, 118, 116, 114, 114, 112, 112, 111, 109, 108, 108;
type [231,8,114_2];
status: weights = 114_2 - {146,154..158,162,174..180,186..228};
type [231,10,112_2];
status: weights = 112_2 - {126,158,174,178,182,186..230};
type [231,13,108_2];
status: weights = 108_2 - {226..230};
type [231,14,108_2];
status: weights = 108_2 - {194..230};
n = 231, k >= 2: 154,132, 122, 118, 116, 115, 114, 112, 112, 112, 110, 108, 108;
type [233,8,116_2];
status: weights = {116,120,124,128};
type [233,9,114_2];
status: weights = 114_2 - {130,146,154,158..166,170,174..232};
type [232,10,112_2];
status: weights = 112_2 - {198,202..232};
type [232,11,112_2];
status: weights = 112_2 - {126,134,142,150,158,166,170,174..232};
type [232,12,110_2];
status: weights = 110_2 - {198..232};
type [233,13,110_2];
status: weights = 110_2 - {182..232};
type [232,14,108_2];
status: weights = 108_2 - {224..230};
n = 232, k >= 2: 154,132, 123, 119, 116, 116, 115, 113, 112, 112, 110, 109, 108;
type [233,10,112_2];
status: weights = 112_2 - {210,214..222,226..232};
type [233,11,112_2];
status: weights = 112_2 - {186,190,194..232};
type [234,12,112_2];
status: weights = 112_4 - {172..232};
n = 233, k >= 2: 155,132, 124, 120, 117, 116, 116, 114, 112, 112, 111, 110, 108;
type [234,8,116_2];
status: weights = 
     116_2 - {134,138,142,146..150,154..166,170,174..182,186..230,234};
type [235,10,114_2];
status: weights = 114_2 - {130,162,174..178,182..234};
type [234,11,112_2];
status: weights = 112_2 - {202..234};
type [234,13,110_2];
status: weights = 110_2 - {200..234};
type [235,14,110_2];
status: weights = 110_2 - {198..234};
n = 234, k >= 2: 156,133, 124, 120, 118, 116, 116, 114, 113, 112, 112, 110, 109;
type [236,9,116_2];
status: weights = 116_4 - {132,148,156..236};
type [236,11,114_2];
status: weights = 114_2 - {130,132,138,142..236};
type [235,12,112_2];
status: weights = 112_2 - {186..234};
type [235,13,110_2];
status: weights = 110_2 - {228..234};
n = 235, k >= 2: 156,134, 124, 120, 118, 117, 116, 115, 114, 113, 112, 110, 110;
type [237,8,118_2];
status: weights = {118,120,126,128};
type [236,10,114_2];
status: weights = 114_2 - {202..236};
type [236,12,112_2];
status: weights = 112_2 - {200..236};
type [237,13,112_2];
status: weights = 112_2 - {186..236};
type [236,14,110_2];
status: weights = 110_2 - {226..236};
n = 236, k >= 2: 157,134, 125, 120, 119, 118, 117, 116, 114, 114, 112, 111, 110;
type [237,9,116_2];
status: weights = 116_2 - {134,150,158,162..166,170,174,178..182,186,190,
     194..198,202,206,210..214,218,222,226,230,234};
type [238,10,116_2];
status: weights = 116_4 - {132,164,172..236};
type [237,11,114_2];
status: weights = 114_2 - {190..236};
type [237,12,112_2];
status: weights = 112_2 - {216..236};
n = 237, k >= 2: 158,135, 126, 121, 120, 118, 118, 116, 115, 114, 112, 112, 110;
type [238,8,118_2];
status: weights = 118_2 - {138,140,150..172,178..236};
type [239,11,116_2];
status: weights = {116,120,124,136};
type [239,12,114_2];
status: weights = 114_2 - {190..238};
type [238,13,112_2];
status: weights = 112_2 - {202..238};
type [239,14,112_2];
status: weights = 112_2 - {198..238};
n = 238, k >= 2: 158,136, 126, 122, 120, 119, 118, 116, 116, 115, 113, 112, 111;
type [239,10,116_2];
status: weights = 116_2 - {134,166,178,182,186,190..238};
type [239,13,112_2];
status: weights = 112_2 - {232..238};
n = 239, k >= 2: 159,136, 127, 122, 120, 120, 119, 116, 116, 116, 114, 112, 112;
type [241,9,118_2];
status: weights = 118_2 - 
     {138,154,162,166..170,178,182..188,198..204,210..220,224..230,234,236};
type [240,10,116_2];
status: weights = 116_2 - {202,206..240};
type [240,11,116_2];
status: weights = 116_2 - {134,142,146,150,154,158,162,166,170,174,178..240};
type [240,12,114_2];
status: weights = 114_2 - {204..240};
type [241,13,114_2];
status: weights = 114_2 - {186..240};
type [240,14,112_2];
status: weights = 112_2 - {222,230..238};
n = 240, k >= 2: 160,136, 128, 123, 120, 120, 120, 117, 116, 116, 114, 113, 112;
type [241,8,120_2];
status: weights = {120,122,124,128,130,132,136,144,148,176,240};
type [242,10,118_2];
status: weights = {118,120,126,128,142,152};
type [241,11,116_2];
status: weights = 116_2 - {190,194..240};
type [242,12,116_2];
status: weights = 116_4 - {176..240};
n = 241, k >= 2: 160,137, 128, 124, 121, 120, 120, 118, 117, 116, 115, 114, 112;
type [242,11,116_2];
status: weights = 116_2 - {206,210..242};
type [242,13,114_2];
status: weights = 114_2 - {206..242};
type [243,14,114_2];
status: weights = 114_2 - {202..242};
n = 242, k >= 2: 161,138, 128, 124, 122, 120, 120, 118, 118, 116, 116, 114, 113;
type [244,9,120_2];
status: weights = {120,124,128,132,136,144,148,152,160,176,192,208,224,240};
type [243,10,118_2];
status: weights = 118_2 - {138,170,172,178,186..242};
type [244,11,118_2];
status: weights = 118_2 - {138,140,146,154,156,162,164,168..244};
type [243,12,116_2];
status: weights = 116_2 - {194..242};
type [243,13,114_2];
status: weights = 114_2 - {234..242};
n = 243, k >= 2: 162,138, 128, 124, 122, 121, 120, 119, 118, 117, 116, 114, 114;
type [245,8,122_2];
status: weights = {122,124,126,128};
type [244,10,118_2];
status: weights = 118_2 - {206,210..244};
type [244,12,116_2];
status: weights = 116_2 - {206..244};
type [245,13,116_2];
status: weights = 116_2 - {190..244};
type [244,14,114_2];
status: weights = 114_2 - {226,232..244};
n = 244, k >= 2: 162,139, 129, 125, 123, 122, 121, 120, 118, 118, 116, 115, 114;
type [246,10,120_2];
status: weights = 
     120_2 - {126,134,138..142,150,154,158,162,166,170..174,178..246};
type [245,11,118_2];
status: weights = 118_2 - {194..244};
type [246,12,118_2];
status: weights = 118_2 - {170..246};
n = 245, k >= 2: 163,140, 130, 126, 124, 122, 122, 120, 119, 118, 117, 116, 114;
type [246,8,122_2];
status: weights = 122_2 - {146,148,158..180,186..244};
type [247,11,120_2];
status: weights = {120,124,128,136,144,152,160};
type [246,13,116_2];
status: weights = 116_2 - {206..246};
type [247,14,116_2];
status: weights = 116_2 - {202..246};
n = 246, k >= 2: 164,140, 130, 126, 124, 123, 122, 120, 120, 119, 118, 116, 115;
type [248,8,124_2];
status: weights = {124,128};
type [248,9,122_2];
status: weights = {122,124,128,132,134,136,150,152,156};
type [247,10,120_2];
status: weights = 120_2 - {142,174,182,190,194,198..246};
type [247,12,118_2];
status: weights = 118_2 - {196..246};
type [247,13,116_2];
status: weights = 116_2 - {230,238..246};
n = 247, k >= 2: 164,140, 131, 127, 124, 124, 123, 121, 120, 120, 118, 116, 116;
type [248,10,120_2];
status: weights = 120_2 - {210,214..248};
type [248,11,120_2];
status: weights = 120_2 - {142,150,158,166,174,178,182..248};
type [248,12,118_2];
status: weights = 118_2 - {210..248};
type [249,13,118_2];
status: weights = 118_2 - {190,194..248};
type [248,14,116_2];
status: weights = 116_2 - {230,236..246};
n = 248, k >= 2: 165,141, 132, 128, 125, 124, 124, 122, 120, 120, 118, 117, 116;
type [249,8,124_2];
status: weights = {124,126,128,130,132,136,140,144,152,156,184,248};
type [249,9,122_2];
status: weights = 
     122_2 - {146,162,170,174..178,186,190..196,206..212,216..228,232..244};
type [249,10,120_2];
status: weights = 120_2 - {226,230..238,242..248};
type [249,11,120_2];
status: weights = 120_2 - {198,202..248};
type [250,12,120_2];
status: weights = 120_2 - {174,178,182..250};

type [250,10,122_2];
kill y250, y230, y204, y246, y248, y188, y184, y166, y172, y180, y150, y168,
     y164, y160, y140, y152, y148, y132, y156;
via lp [current] = ;
no [250,10,122];

n = 249, k >= 2: 166,142, 132, 128, 126, 124, 124, 122, 120, 120, 119, 118, 116;
type [251,10,122_2];
status: weights = 122_2 - {146,178,180,190..250};
type [250,11,120_2];
status: weights = 120_2 - {214..250};
type [250,13,118_2];
status: weights = 118_2 - {210..250};
type [251,14,118_2];
status: weights = 118_2 - {206..250};
n = 250, k >= 2: 166,142, 132, 128, 126, 125, 124, 122, 121, 120, 120, 118, 117;
type [252,8,126_2];
status: weights = {126,128};
type [252,9,124_2];
status: weights = 
     124_2 - {130,134,142,146..150,158,162..166,170..182,186..200,206..246};
type [252,11,122_2];
status: weights = 122_2 - {146,148,154,162..170,174..252};
type [251,12,120_2];
status: weights = 120_2 - {198..250};
type [251,13,118_2];
status: weights = 118_2 - {234,240..250};
n = 251, k >= 2: 167,143, 133, 128, 127, 126, 125, 123, 122, 121, 120, 118, 118;
type [252,10,122_2];
status: weights = 122_2 - {214,218..252};
type [252,12,120_2];
status: weights = 120_2 - {212..252};
type [253,13,120_2];
status: weights = 120_2 - {194,198..252};
type [252,14,118_2];
status: weights = 118_2 - {230..234,240..252};
n = 252, k >= 2: 168,144, 134, 128, 128, 126, 126, 124, 122, 122, 120, 119, 118;
type [253,8,126_2];
status: weights = 126_2 - {138,140,146..156,162..188,192..252};
type [254,10,124_2];
status: weights = 124_2 - {134,142,146..150,154,158,162,166,170,174,178..254};
type [253,11,122_2];
status: weights = 122_2 - {198..252};
type [254,12,122_2];
status: weights = 122_2 - {178..254};

type [254,14,120_2];
kill y254, y196, y192, y190, y188, y186, y184, y182, y180, y178, y176, y174,
     y172, y170, y168, y166, y164, y162, y160, y158, y154, y150, y146, y138,
     y142, y134, y122, y126, y130;
status: weights = {120,124,128,132,136,140,144,148,152,156};

n = 253, k >= 2: 168,144, 134, 129, 128, 127, 126, 125, 123, 122, 121, 120, 119;
type [254,11,122_2];
status: weights = 122_2 - {214,218..254};
type [254,13,120_2];
status: weights = 120_2 - {210..254};
n = 254, k >= 2: 169,144, 135, 130, 128, 128, 127, 126, 124, 122, 122, 120, 120;
type [255,10,124_2];
status: weights = 124_2 - {150,182,194,198,202..254};
type [256,11,124_2];
status: weights = 124_2 - {150,158,166,170,174,178,182,186,190..256};
type [255,12,122_2];
status: weights = 122_2 - {202..254};
type [255,13,120_2];
status: weights = 120_2 - {234,238,244..254};
type [255,14,120_2];
status: weights = 120_2 - {206..254};
n = 255, k >= 2: 170,145, 136, 130, 128, 128, 128, 127, 124, 123, 122, 120, 120;
type [256,10,124_2];
status: weights = 124_2 - {218,222..256};
type [256,12,122_2];
status: weights = 122_2 - {214..256};
type [257,13,122_2];
status: weights = 122_2 - {194,198..256};
type [256,14,120_2];
status: weights = 120_2 - {230,234..238,242..254};
n = 256, k >= 2: 170,146, 136, 131, 128, 128, 128, 128, 124, 124, 122, 121, 120;
type [258,10,126_2];
status: weights = 126_2 - {138,146..156,162..170,176..258};
type [257,11,124_2];
status: weights = 124_2 - {202,206..256};
type [258,12,124_2];
status: weights = 124_2 - {182,186..258};
n = 257, k >= 2: 171,146, 136, 132, 128, 128, 128, 128, 125, 124, 123, 122, 120;
type [258,11,124_2];
status: weights = 124_2 - {218,222..258};
type [258,13,122_2];
status: weights = 122_2 - {214..258};
type [259,14,122_2];
status: weights = 122_2 - {210..258};
n = 258, k >= 2: 172,147, 136, 132, 129, 128, 128, 128, 126, 124, 124, 122, 121;
type [259,10,126_2];
status: weights = 126_2 - {154,186,188,198..258};
type [260,11,126_2];
status: weights = 126_2 - {154,156,162,170,172,178,182..260};
type [259,12,124_2];
status: weights = 124_2 - {206..258};
type [259,13,122_2];
status: weights = 122_2 - {234,238..242,246..258};
n = 259, k >= 2: 172,148, 137, 132, 130, 128, 128, 128, 126, 125, 124, 122, 122;
type [261,10,128_2];
status: weights = {128,132,136,144,160};
type [260,12,124_2];
status: weights = 124_2 - {218..260};
type [261,13,124_2];
status: weights = 124_2 - {198,202..260};
type [260,14,122_2];
status: weights = 122_2 - {230,234,238..242,246..260};
n = 260, k >= 2: 173,148, 138, 133, 130, 128, 128, 128, 127, 126, 124, 123, 122;
type [261,11,126_2];
status: weights = 126_2 - {206..260};
type [262,12,126_2];
status: weights = 126_2 - {186..262};
n = 261, k >= 2: 174,148, 138, 134, 131, 129, 128, 128, 128, 126, 125, 124, 122;
type [262,10,128_2];
status: weights = 128_2 - {142,150,154..158,166,170,174,182,186..190,194..262};
type [263,11,128_2];
status: weights = {128,130,132,136,140,144,146,148,152,160,168};
type [262,13,124_2];
status: weights = 124_2 - {218..262};
type [263,14,124_2];
status: weights = 124_2 - {210..262};
n = 262, k >= 2: 174,149, 139, 134, 132, 130, 128, 128, 128, 127, 126, 124, 123;
type [263,10,128_2];
status: weights = 128_2 - {158,190,202,206,210..262};
type [263,12,126_2];
status: weights = 126_2 - {206..262};
type [263,13,124_2];
status: weights = 124_2 - {238,242..246,250..262};
n = 263, k >= 2: 175,150, 140, 135, 132, 130, 129, 128, 128, 128, 126, 124, 124;
type [265,9,130_2];
status: weights = 130_2 - {142..254,258..264};
type [264,10,128_2];
status: weights = 128_2 - {230..254,258..264};
type [264,11,128_2];
status: weights = 128_2 - {158,166,174,182,186,190,194..264};
type [264,12,126_2];
status: weights = 126_2 - {222..264};
type [265,13,126_2];
status: weights = 126_2 - {198..264};
type [264,14,124_2];
status: weights = 124_2 - {230,234,238,242..246,250..262};
n = 264, k >= 2: 176,150, 140, 136, 132, 131, 130, 129, 128, 128, 126, 125, 124;
type [265,10,128_2];
status: weights = 128_2 - {242,246..254,260..264};
type [265,11,128_2];
status: weights = 128_2 - {206,210..264};
type [266,12,128_2];
status: weights = 128_2 - {190,194..266};
type [265,14,124_2];
status: weights = 124_2 - {262};
n = 265, k >= 2: 176,151, 140, 136, 133, 132, 130, 130, 128, 128, 127, 126, 124;
type [266,10,128_2];
status: weights = 128_2 - {254,262..266};
type [266,11,128_2];
status: weights = 128_2 - {226..266};
type [266,13,126_2];
status: weights = 126_2 - {218..266};
type [267,14,126_2];
status: weights = 126_2 - {214..266};
n = 266, k >= 2: 177,152, 141, 136, 134, 132, 131, 130, 128, 128, 128, 126, 125;
type [268,10,130_2];
status: weights = 130_2 - {230..268};
type [267,11,128_2];
status: weights = 128_2 - {242..266};
type [267,12,128_2];
status: weights = 128_2 - {210..266};
type [267,13,126_2];
status: weights = 126_2 - {238,242..266};
n = 267, k >= 2: 178,152, 142, 136, 134, 132, 132, 130, 129, 128, 128, 126, 126;
type [269,9,132_2];
status: weights = 132_2 - {158,162,166,174,178,182,186,190,194..198,202,206,
     210..214,218,222,226..230,234,238,242..246,250,254,258,262,266};
type [269,11,130_2];
status: weights = 130_2 - {192..268};
type [268,12,128_2];
status: weights = 128_2 - {224..268};
type [269,13,128_2];
status: weights = 128_2 - {198,202,206..268};
type [268,14,126_2];
status: weights = 126_2 - {234..268};
n = 268, k >= 2: 178,152, 142, 137, 135, 133, 132, 131, 130, 129, 128, 127, 126;
type [269,10,130_2];
status: weights = 130_2 - {246,250..258,264..268};
type [270,12,130_2];
status: weights = 130_2 - {174,178..270};
type [269,14,126_2];
status: weights = 126_2 - {262..266};
n = 269, k >= 2: 179,153, 143, 138, 136, 134, 132, 132, 130, 130, 129, 128, 126;
type [271,10,132_2];
status: weights = 132_2 - {134,166,190,194,198,206,210,214,218..270};
type [270,11,130_2];
status: weights = 130_2 - {226,230..270};
type [270,13,128_2];
status: weights = 128_2 - {222..270};
type [271,14,128_2];
status: weights = 128_2 - {214..270};
n = 270, k >= 2: 180,154, 144, 138, 136, 134, 133, 132, 131, 130, 130, 128, 127;
type [272,11,132_2];
status: weights = {132,136,140,142,144,148,152,156,160,164,168,172,176,180,184};
type [271,12,130_2];
status: weights = 130_2 - {214..270};
type [271,13,128_2];
status: weights = 128_2 - {242..254,258..270};
n = 271, k >= 2: 180,154, 144, 139, 136, 135, 134, 132, 132, 131, 130, 128, 128;
type [273,9,134_2];
status: weights = 
     134_2 - {162,170,178,186,194..204,210..220,226..236,242..252,258..272};
type [272,10,132_2];
status: weights = 132_2 - {234,238..262,266..272};
type [272,12,130_2];
status: weights = 130_2 - {226..272};
type [273,13,130_2];
status: weights = 130_2 - {202..272};
type [272,14,128_2];
status: weights = 128_2 - {234..254,258..272};
n = 272, k >= 2: 181,155, 144, 140, 136, 136, 134, 133, 132, 132, 130, 129, 128;
type [273,10,132_2];
status: weights = 132_2 - {250,254..262,268..272};
type [273,11,132_2];
status: weights = 132_2 - {210,214,218..272};
type [274,12,132_2];
status: weights = 132_2 - {194,198..274};
type [273,14,128_2];
status: weights = 128_2 - {266..270};
n = 273, k >= 2: 182,156, 144, 140, 137, 136, 135, 134, 132, 132, 131, 130, 128;
type [275,10,134_2];
status: weights = 134_2 - {138,170,194,196,202,204,210..274};
type [274,11,132_2];
status: weights = 132_2 - {230,234..274};
type [274,13,130_2];
status: weights = 130_2 - {224..274};
type [275,14,130_2];
status: weights = 130_2 - {214,218..274};
n = 274, k >= 2: 182,156, 145, 140, 138, 136, 136, 134, 133, 132, 132, 130, 129;
type [276,9,136_2];
status: weights = {136,140,144,148,152,156,160,168,176,184,192,208,224,240,256};
type [276,11,134_2];
status: weights = {134,136,142,144,150,152,158,160,166,168,174,176,182};
type [275,12,132_2];
status: weights = 132_2 - {214,218..274};
type [275,13,130_2];
status: weights = 130_2 - {242,246..274};
n = 275, k >= 2: 183,156, 146, 141, 138, 136, 136, 135, 134, 133, 132, 130, 130;
type [276,10,134_2];
status: weights = 134_2 - {238..276};
type [276,12,132_2];
status: weights = 132_2 - {230..276};
type [277,13,132_2];
status: weights = 132_2 - {202,206,210..276};
type [276,14,130_2];
status: weights = 130_2 - {238..276};
n = 276, k >= 2: 184,157, 146, 142, 139, 137, 136, 136, 134, 134, 132, 131, 130;
type [277,9,136_2];
status: weights = 136_2 - 
     {174,190,198,202..206,214,218..222,234..238,246,250..254,262,266,270,274};
type [278,10,136_2];
status: weights = 136_4 - {140,172,196,204..276};
type [277,11,134_2];
status: weights = 134_2 - {214..276};
type [278,12,134_2];
status: weights = 134_2 - {198..278};
type [277,14,130_2];
status: weights = 130_2 - {268..276};
n = 277, k >= 2: 184,158, 147, 142, 140, 138, 136, 136, 135, 134, 133, 132, 130;
type [279,11,136_2];
status: weights = {136,144,152,160,168};
type [278,13,132_2];
status: weights = 132_2 - {226..278};
type [279,14,132_2];
status: weights = 132_2 - {210,214,218..278};
n = 278, k >= 2: 185,158, 148, 143, 140, 138, 137, 136, 136, 135, 134, 132, 131;
type [279,10,136_2];
status: weights = 136_2 - {142,174,198,206,214,218,222,226..278};
type [279,12,134_2];
status: weights = 134_2 - {218..278};
type [279,13,132_2];
status: weights = 132_2 - {246..278};
n = 279, k >= 2: 186,159, 148, 144, 140, 139, 138, 136, 136, 136, 134, 132, 132;
type [281,9,138_2];
status: weights = 
     138_2 - {178..182,194..198,202,206..218,222..232,238..250,254..280};
type [280,10,136_2];
status: weights = 136_2 - {242,246..270,274..280};
type [280,11,136_2];
status: weights = 136_2 - {142,174,182,190,194,198,202..280};
type [281,12,136_2];
status: weights = 136_4 - {176..280};
type [281,13,134_2];
status: weights = 134_2 - {206..280};
type [280,14,132_2];
status: weights = 132_2 - {238..280};
n = 280, k >= 2: 186,160, 148, 144, 141, 140, 138, 137, 136, 136, 135, 133, 132;
type [281,10,136_2];
status: weights = 136_2 - {258,262..270,276..280};
type [281,11,136_2];
status: weights = 136_2 - {218,222..280};
type [281,14,132_2];
status: weights = 132_2 - {272..280};
n = 281, k >= 2: 187,160, 149, 144, 142, 140, 139, 138, 136, 136, 136, 134, 132;
type [283,10,138_2];
status: weights = 138_2 - {146,178,210,212,222..282};
type [282,11,136_2];
status: weights = 136_2 - {238,242..282};
type [282,12,136_2];
status: weights = 136_2 - {202,206..282};
type [282,13,134_2];
status: weights = 134_2 - {230..282};
type [283,14,134_2];
status: weights = 134_2 - {206,210,214..282};
n = 282, k >= 2: 188,160, 150, 144, 142, 140, 140, 138, 137, 136, 136, 134, 133;
type [284,9,140_2];
status: weights = 140_4 - {148,180,184,196..232,240..284};
type [284,11,138_2];
status: weights = 138_2 - {146..152,162..168,178..284};
type [283,12,136_2];
status: weights = 136_2 - {222..282};
type [283,13,134_2];
status: weights = 134_2 - {250..282};
n = 283, k >= 2: 188,161, 150, 144, 143, 141, 140, 139, 138, 137, 136, 134, 134;
type [284,10,138_2];
status: weights = 138_2 - {246..284};
type [284,12,136_2];
status: weights = 136_2 - {238..284};
type [285,13,136_2];
status: weights = 136_2 - {206,210,214..284};
type [284,14,134_2];
status: weights = 134_2 - {242..284};
n = 284, k >= 2: 189,162, 151, 145, 144, 142, 140, 140, 138, 138, 136, 135, 134;
type [285,9,140_2];
status: weights = 140_2 - {182,198,202,206,210..214,218,222,226..230,234,
     242..246,250,254,258..262,266,270,274,278,282};
type [286,10,140_2];
status: weights = 140_4 - {148,180,208..284};
type [285,11,138_2];
status: weights = 138_2 - {218,222..284};
type [286,12,138_2];
status: weights = 138_2 - {206..286};
type [285,14,134_2];
status: weights = 134_2 - {274..284};
n = 285, k >= 2: 190,162, 152, 146, 144, 142, 141, 140, 139, 138, 137, 136, 134;
type [287,11,140_2];
status: weights = {140,144,156,160,172};
type [286,13,136_2];
status: weights = 136_2 - {234..286};
type [287,14,136_2];
status: weights = 136_4 - {224..284};
n = 286, k >= 2: 190,163, 152, 146, 144, 143, 142, 140, 140, 139, 138, 136, 135;
type [288,9,142_2];
status: weights = {142,144,158,160,174,176,190,192,238,240};
type [287,10,140_2];
status: weights = 140_2 - {150,182,214,226,230..286};
type [287,12,138_2];
status: weights = 138_2 - {226..286};
type [287,13,136_2];
status: weights = 136_2 - {250..286};
n = 287, k >= 2: 191,164, 152, 147, 144, 144, 142, 141, 140, 140, 138, 136, 136;
type [288,10,140_2];
status: weights = 140_2 - {250,254..278,282..288};
type [288,11,140_2];
status: weights = 140_2 - {150,154,166,170,182,186,190,198,202,206,210..288};
type [289,12,140_2];
status: weights = 140_4 - {188..288};
type [289,13,138_2];
status: weights = 138_2 - {206,210..288};
type [288,14,136_2];
status: weights = 136_2 - {242..288};
n = 288, k >= 2: 192,164, 152, 148, 144, 144, 143, 142, 140, 140, 139, 137, 136;
type [289,9,142_2];
status: weights = 
     142_2 - {186,202,210,214..218,226,230..236,246..252,258,262..268,274..284};
type [290,10,142_2];
status: weights = {142,144,158,160,162,164,166,168,174,176,190,192,200,204};
type [289,11,140_2];
status: weights = 140_2 - {222,226,230..288};
type [289,14,136_2];
status: weights = 136_2 - {278..288};
n = 289, k >= 2: 192,164, 153, 148, 145, 144, 144, 142, 141, 140, 140, 138, 136;
type [291,9,144_2];
status: weights = {144,160,176,192,240};
type [290,11,140_2];
status: weights = 140_2 - {242,246..290};
type [290,12,140_2];
status: weights = 140_2 - {206,210..290};
type [290,13,138_2];
status: weights = 138_2 - {236..290};
n = 290, k >= 2: 193,165, 154, 148, 146, 144, 144, 143, 142, 140, 140, 138, 136;
type [291,10,142_2];
status: weights = 142_2 - {154,186,218,220,230..290};
type [292,11,142_2];
status: weights = 142_2 - {154,186,188,194,200..292};
type [291,12,140_2];
status: weights = 140_2 - {226,230..290};
type [291,13,138_2];
status: weights = 138_2 - {254..290};
type [292,14,138_2];
status: weights = 138_2 - {244..292};
n = 291, k >= 2: 194,166, 154, 149, 146, 144, 144, 144, 142, 141, 140, 138, 137;
type [292,9,144_2];
status: weights = 144_2 - {150,154,158,170,174,182,186..190,198,202..206,
     210..222,226..238,246..254,258..270,274..286,290,292};
type [293,10,144_2];
status: weights = {144,160,164,168,176,192};
type [292,12,140_2];
status: weights = 140_2 - {242..292};
type [293,13,140_2];
status: weights = 140_2 - {210,214,218,222..292};
n = 292, k >= 2: 194,166, 155, 150, 147, 145, 144, 144, 143, 142, 140, 139, 138;
type [293,11,142_2];
status: weights = 142_2 - {226..292};
type [294,12,142_2];
status: weights = 142_2 - {210..294};
type [293,14,138_2];
status: weights = 138_2 - {282..292};
n = 293, k >= 2: 195,167, 156, 150, 148, 146, 144, 144, 144, 142, 141, 140, 138;
type [294,10,144_2];
status: weights = 
     144_2 - {150,154..158,174,182,186..190,198,202,206,210,214,218..294};
type [295,11,144_2];
status: weights = 144_2 - {150,154..158,166,170,174,182,186..190,194..294};
type [294,13,140_2];
status: weights = 140_2 - {238..294};
type [295,14,140_2];
status: weights = 140_4 - {208..292};
n = 294, k >= 2: 196,168, 156, 151, 148, 146, 145, 144, 144, 143, 142, 140, 139;
type [295,10,144_2];
status: weights = 144_2 - {158,190,222,234,238..294};
type [295,12,142_2];
status: weights = 142_2 - {230..294};
type [295,13,140_2];
status: weights = 140_2 - {254,258..294};
n = 295, k >= 2: 196,168, 156, 152, 148, 147, 146, 144, 144, 144, 142, 140, 140;
type [297,9,146_2];
status: weights = 146_2 - {194,210,218,222..226,230..242,254..296};
type [296,10,144_2];
status: weights = 144_2 - {258,262..286,290..296};
type [296,11,144_2];
status: weights = 144_2 - {158,190,198,206,210,214..296};
type [297,12,144_2];
status: weights = 144_4 - {200..296};
type [297,13,142_2];
status: weights = 142_2 - {210,214..296};
type [296,14,140_2];
status: weights = 140_2 - {246..296};
n = 296, k >= 2: 197,168, 157, 152, 149, 148, 146, 145, 144, 144, 143, 141, 140;
type [297,10,144_2];
status: weights = 144_2 - {274,278..286,292..296};
type [297,11,144_2];
status: weights = 144_2 - {226,230,234..296};
type [297,14,140_2];
status: weights = 140_2 - {284..296};
n = 297, k >= 2: 198,169, 158, 152, 150, 148, 147, 146, 144, 144, 144, 142, 140;
type [299,10,146_2];
status: weights = 146_2 - {162,194,226..230,234,238..298};
type [298,11,144_2];
status: weights = 144_2 - {246,250,254..298};
type [298,12,144_2];
status: weights = 144_2 - {214,218..298};
type [298,13,142_2];
status: weights = 142_2 - {242..298};
n = 298, k >= 2: 198,170, 158, 152, 150, 148, 148, 146, 145, 144, 144, 142, 140;
type [300,9,148_2];
status: weights = 148_4 - {196,212,220..244,256..300};
type [300,11,146_2];
status: weights = 146_2 - {162,194..300};
type [299,12,144_2];
status: weights = 144_2 - {234,238..298};
type [299,13,142_2];
status: weights = 142_2 - {258..298};
type [300,14,142_2];
status: weights = 142_2 - {248..300};
n = 299, k >= 2: 199,170, 159, 153, 151, 149, 148, 147, 146, 145, 144, 142, 141;
type [300,10,146_2];
status: weights = 146_2 - {262..300};
type [300,12,144_2];
status: weights = 144_2 - {250..300};
type [301,13,144_2];
status: weights = 144_2 - {214,218,222,226..300};
n = 300, k >= 2: 200,171, 160, 154, 152, 150, 148, 148, 146, 146, 144, 143, 142;

data_comment( ![ One gets a few improvements if the procedure is repeated.
Perhaps some of the improvements are due to modifications to {\tt Split}
in the interim. ]! )

type [209,9,102_2];
status: weights = {102,104,110,112,118,120,126,128,142,144,158,160};
type [210,8,104_2];
status: weights = {104,106,108,112,116,120,128,144,160};
type [225,10,108_2];
status: weights = 108_2 - {202,206..214,218..224};
n = 225, k >= 2: 150,128, 120, 115, 112, 112, 112, 110, 108, 108, 107, 106, 104;
type [228,11,110_2];
status: weights = 110_2 - {122,124,130,138,140,146,154..158,162..228};
type [233,11,112_2];
status: weights = 112_2 - {186,190..232};
type [247,11,120_2];
status: weights = {120,124,128,136,144,152};
type [252,11,122_2];
status: weights = 122_2 - {146,148,154,162..252};

data_comment( ![ The following segment was created with
\begin{verbatim}
     set repeat loop;
     set allowed failures = 6;
     build tables for 86 <= n <= 177, 15 <= k <= 25;
\end{verbatim}
except that on $n = 138$, I got some error messages from the simplex method,
and when I restarted with $n = 138$, they went away. ]! )

set dual constraint bound = -1;
set allowed failures = 6;
set repeat loop;

type [86,15,36_2]; status: weights = 36_2 - {76..86};
type [87,16,36_2]; status: weights = 36_2 - {64..86};
type [87,19,34_2]; status: weights = 34_2 - {80..86};
type [86,22,32_2]; status: weights = 32_2 - {66,70..84};
n = 86, k >= 15: 36, 35, 34, 34, 33, 32, 32, 32, 30, 30, 30;
type [88,20,34_2]; status: weights = 34_2 - {78..88};
n = 87, k >= 15: 36, 36, 35, 34, 34, 33, 32, 32, 31, 30, 30;
type [89,24,32_2]; status: weights = 32_2 - {86,88};
n = 88, k >= 15: 36, 36, 36, 34, 34, 34, 32, 32, 32, 31, 30;
type [90,15,38_2]; status: weights = 38_2 - {78..90};
type [90,25,32_2]; status: weights = 32_2 - {86..90};
n = 89, k >= 15: 37, 36, 36, 35, 34, 34, 33, 32, 32, 32, 31;
type [91,16,38_2]; status: weights = 38_2 - {64..90};
type [91,19,36_2]; status: weights = 36_2 - {80..90};
n = 90, k >= 15: 38, 37, 36, 36, 35, 34, 34, 33, 32, 32, 32;
type [91,15,38_2]; status: weights = 38_2 - {90};
type [92,20,36_2]; status: weights = 36_2 - {74..92};
n = 91, k >= 15: 38, 38, 36, 36, 36, 35, 34, 34, 33, 32, 32;
type [92,16,38_2]; status: weights = 38_2 - {90,92};
type [93,24,34_2]; status: weights = 34_2 - {86..92};
n = 92, k >= 15: 38, 38, 37, 36, 36, 36, 34, 34, 34, 33, 32;
type [94,15,40_2]; status: weights = 40_2 - {82..94};
type [93,20,36_2]; status: weights = 36_2 - {92};
type [94,21,36_2]; status: weights = 36_2 - {92,94};
n = 93, k >= 15: 39, 38, 38, 37, 36, 36, 35, 34, 34, 34, 32;
type [95,16,40_2]; status: weights = 40_2 - {66..94};
type [95,19,38_2]; status: weights = 38_2 - {80..94};
n = 94, k >= 15: 40, 39, 38, 38, 37, 36, 36, 35, 34, 34, 33;
type [95,15,40_2]; status: weights = 40_2 - {94};
type [96,23,36_2]; status: weights = 36_2 - {90..94};
n = 95, k >= 15: 40, 40, 38, 38, 38, 36, 36, 36, 35, 34, 34;
type [96,16,40_2]; status: weights = 40_2 - {94,96};
type [97,17,40_2]; status: weights = 40_2 - {92..96};
type [97,20,38_2]; status: weights = 38_2 - {94,96};
type [97,24,36_2]; status: weights = 36_2 - {84..96};
n = 96, k >= 15: 40, 40, 39, 38, 38, 37, 36, 36, 36, 35, 34;
type [98,15,42_2]; status: weights = 42_2 - {82..98};
type [98,18,40_2]; status: weights = 40_2 - {90..96};
type [98,21,38_2]; status: weights = 38_2 - {94..98};
n = 97, k >= 15: 41, 40, 40, 39, 38, 38, 37, 36, 36, 36, 34;
type [99,19,40_2]; status: weights = 40_2 - {80..98};
type [99,22,38_2]; status: weights = 38_2 - {92..98};
type [99,25,36_2]; status: weights = 36_2 - {98};
n = 98, k >= 15: 42, 40, 40, 40, 39, 38, 38, 37, 36, 36, 35;
type [99,15,42_2]; status: weights = 42_2 - {96,98};
type [100,16,42_2]; status: weights = 42_2 - {94..100};
type [100,23,38_2]; status: weights = 38_2 - {82,86..98};
n = 99, k >= 15: 42, 41, 40, 40, 40, 38, 38, 38, 37, 36, 36;
type [101,17,42_2]; status: weights = 42_2 - {90..100};
type [101,20,40_2]; status: weights = 40_2 - {94..100};
type [101,24,38_2]; status: weights = 38_2 - {78..100};
n = 100, k >= 15: 42, 42, 41, 40, 40, 39, 38, 38, 38, 37, 36;
type [102,15,44_2]; status: weights = 44_2 - {86..102};
type [102,18,42_2]; status: weights = 42_2 - {86..100};
type [102,21,40_2]; status: weights = 40_2 - {92..102};
n = 101, k >= 15: 43, 42, 42, 41, 40, 40, 39, 38, 38, 38, 36;
type [103,19,42_2]; status: weights = 42_2 - {78..102};
type [103,22,40_2]; status: weights = 40_2 - {78..102};
type [103,25,38_2]; status: weights = 38_2 - {98..102};
n = 102, k >= 15: 44, 42, 42, 42, 41, 40, 40, 39, 38, 38, 37;
type [103,15,44_2]; status: weights = 44_2 - {98..102};
type [104,16,44_2]; status: weights = 44_2 - {96..104};
n = 103, k >= 15: 44, 43, 42, 42, 42, 40, 40, 40, 38, 38, 38;
type [105,17,44_2]; status: weights = 44_2 - {86,90..104};
type [105,20,42_2]; status: weights = 42_2 - {96..104};
n = 104, k >= 15: 44, 44, 43, 42, 42, 41, 40, 40, 39, 38, 38;
type [106,15,46_2]; status: weights = 46_2 - {84..106};
type [106,21,42_2]; status: weights = 42_2 - {88..106};
n = 105, k >= 15: 45, 44, 44, 43, 42, 42, 41, 40, 40, 39, 38;
type [107,25,40_2]; status: weights = 40_2 - {98..106};
n = 106, k >= 15: 46, 44, 44, 44, 42, 42, 42, 40, 40, 40, 39;
type [107,15,46_2]; status: weights = 46_2 - {100..106};
type [108,16,46_2]; status: weights = 46_2 - {98..108};
n = 107, k >= 15: 46, 45, 44, 44, 43, 42, 42, 41, 40, 40, 40;
type [109,17,46_2]; status: weights = 46_2 - {86..108};
type [109,20,44_2]; status: weights = 44_2 - {96..108};
n = 108, k >= 15: 46, 46, 45, 44, 44, 43, 42, 42, 41, 40, 40;
type [110,15,48_2]; status: weights = 48_2 - {86..110};
type [110,18,46_2]; status: weights = 46_2 - {84..110};
type [110,21,44_2]; status: weights = 44_2 - {82..110};
n = 109, k >= 15: 47, 46, 46, 45, 44, 44, 43, 42, 42, 41, 40;
type [111,25,42_2]; status: weights = 42_2 - {98..110};
n = 110, k >= 15: 48, 46, 46, 46, 44, 44, 44, 42, 42, 42, 41;
type [111,15,48_2]; status: weights = 48_2 - {102..110};
type [112,16,48_2]; status: weights = 48_2 - {100..112};
type [111,21,44_2]; status: weights = 44_2 - {110};
n = 111, k >= 15: 48, 47, 46, 46, 45, 44, 44, 43, 42, 42, 42;
type [113,17,48_2]; status: weights = 48_2 - {82..112};
type [113,20,46_2]; status: weights = 46_2 - {96..112};
n = 112, k >= 15: 48, 48, 47, 46, 46, 45, 44, 44, 43, 42, 42;
type [114,15,50_2]; status: weights = 50_2 - {88..114};
type [113,16,48_2]; status: weights = 48_2 - {112};
type [114,18,48_2]; status: weights = 48_2 - {82..114};
type [114,21,46_2]; status: weights = 46_2 - {78..114};
type [114,24,44_2]; status: weights = 44_2 - {98..110};
n = 113, k >= 15: 49, 48, 48, 47, 46, 46, 45, 44, 44, 43, 42;
type [114,17,48_2]; status: weights = 48_2 - {112,114};
type [115,25,44_2]; status: weights = 44_2 - {92..114};
n = 114, k >= 15: 50, 48, 48, 48, 46, 46, 46, 44, 44, 44, 43;
type [115,15,50_2]; status: weights = 50_2 - {104..114};
type [116,16,50_2]; status: weights = 50_2 - {102..116};
type [115,18,48_2]; status: weights = 48_2 - {110..114};
type [115,21,46_2]; status: weights = 46_2 - {110..114};
type [116,22,46_2]; status: weights = 46_2 - {106..116};
n = 115, k >= 15: 50, 49, 48, 48, 47, 46, 46, 45, 44, 44, 44;
type [116,15,50_2]; status: weights = 50_2 - {116};
type [117,20,48_2]; status: weights = 48_2 - {94..116};
type [116,25,44_2]; status: weights = 44_2 - {114,116};
n = 116, k >= 15: 50, 50, 48, 48, 48, 47, 46, 46, 45, 44, 44;
type [118,15,52_2]; status: weights = 52_2 - {90..118};
type [117,16,50_2]; status: weights = 50_2 - {114,116};
type [118,17,50_2]; status: weights = 50_2 - {114..118};
type [118,24,46_2]; status: weights = 46_2 - {90..116};
n = 117, k >= 15: 51, 50, 49, 48, 48, 48, 46, 46, 46, 45, 44;
type [119,18,50_2]; status: weights = 50_2 - {112..118};
type [118,20,48_2]; status: weights = 48_2 - {118};
type [119,21,48_2]; status: weights = 48_2 - {110..118};
n = 118, k >= 15: 52, 50, 50, 49, 48, 48, 47, 46, 46, 46, 44;
type [119,15,52_2]; status: weights = 52_2 - {106..118};
type [120,16,52_2]; status: weights = 52_2 - {104..120};
type [120,19,50_2]; status: weights = 50_2 - {106,110..118};
type [120,22,48_2]; status: weights = 48_2 - {102,106..120};
type [120,25,46_2]; status: weights = 46_2 - {116..120};
n = 119, k >= 15: 52, 51, 50, 50, 49, 48, 48, 47, 46, 46, 45;
type [121,20,50_2]; status: weights = 50_2 - {94..120}; 
type [121,23,48_2]; status: weights = 48_2 - {94,98..120};
n = 120, k >= 15: 52, 52, 50, 50, 50, 49, 48, 48, 47, 46, 46;
type [122,15,54_2]; status: weights = 54_2 - {92..122};
type [121,16,52_2]; status: weights = 52_2 - {116..120};
type [122,17,52_2]; status: weights = 52_2 - {112..122};
n = 121, k >= 15: 53, 52, 51, 50, 50, 50, 48, 48, 48, 46, 46;
type [123,18,52_2]; status: weights = 52_2 - {110..122};
type [123,21,50_2]; status: weights = 50_2 - {110..122};
n = 122, k >= 15: 54, 52, 52, 51, 50, 50, 49, 48, 48, 47, 46;
type [123,15,54_2]; status: weights = 54_2 - {106..122};
type [124,16,54_2]; status: weights = 54_2 - {104..124};
type [124,19,52_2]; status: weights = 52_2 - {102..122};
type [124,22,50_2]; status: weights = 50_2 - {90,94,98..124};
type [124,25,48_2]; status: weights = 48_2 - {116..124};
n = 123, k >= 15: 54, 53, 52, 52, 51, 50, 50, 49, 48, 48, 47;
type [124,15,54_2]; status: weights = 54_2 - {124};
type [125,20,52_2]; status: weights = 52_2 - {92..124};
type [124,21,50_2]; status: weights = 50_2 - {124};
n = 124, k >= 15: 54, 54, 52, 52, 52, 51, 50, 50, 48, 48, 48;
type [126,15,56_2]; status: weights = 56_2 - {94..126};
type [125,16,54_2]; status: weights = 54_2 - {118..124};
type [126,17,54_2]; status: weights = 54_2 - {114..126};
n = 125, k >= 15: 55, 54, 53, 52, 52, 52, 50, 50, 49, 48, 48;
type [127,18,54_2]; status: weights = 54_2 - {106,110..126};
type [127,21,52_2]; status: weights = 52_2 - {110..126};
n = 126, k >= 15: 56, 54, 54, 53, 52, 52, 51, 50, 50, 49, 48;
type [127,15,56_2]; status: weights = 56_2 - {108..126};
type [128,16,56_2]; status: weights = 56_2 - {106..128};
type [128,19,54_2]; status: weights = 54_2 - {102..126};
type [128,22,52_2]; status: weights = 52_2 - {86..128};
type [128,25,50_2]; status: weights = 50_2 - {112..128};
n = 127, k >= 15: 56, 55, 54, 54, 53, 52, 52, 51, 50, 50, 49;
type [128,21,52_2]; status: weights = 52_2 - {126,128};
n = 128, k >= 15: 56, 56, 54, 54, 54, 52, 52, 52, 50, 50, 50;
type [130,15,58_2]; status: weights = 58_2 - {94..130};
type [129,16,56_2]; status: weights = 56_2 - {118..128};
type [130,17,56_2]; status: weights = 56_2 - {114..130};
type [130,23,52_2]; status: weights = 52_2 - {122..130};
n = 129, k >= 15: 57, 56, 55, 54, 54, 53, 52, 52, 51, 50, 50;
type [130,16,56_2]; status: weights = 56_2 - {130};
type [131,18,56_2]; status: weights = 56_2 - {102..130};
type [131,21,54_2]; status: weights = 54_2 - {110..130};
n = 130, k >= 15: 58, 56, 56, 55, 54, 54, 53, 52, 52, 51, 50;
type [131,15,58_2]; status: weights = 58_2 - {110..130};
type [132,16,58_2]; status: weights = 58_2 - {108..132};
type [132,25,52_2]; status: weights = 52_2 - {106..132};
n = 131, k >= 15: 58, 57, 56, 56, 55, 54, 54, 52, 52, 52, 51;
type [132,15,58_2]; status: weights = 58_2 - {132};
type [132,21,54_2]; status: weights = 54_2 - {126..132};
n = 132, k >= 15: 58, 58, 56, 56, 56, 54, 54, 53, 52, 52, 52;
type [134,15,60_2]; status: weights = 60_2 - {98..134};
type [133,16,58_2]; status: weights = 58_2 - {122..132};
type [134,17,58_2]; status: weights = 58_2 - {116..134};
type [134,23,54_2]; status: weights = 54_2 - {118..134};
n = 133, k >= 15: 59, 58, 57, 56, 56, 55, 54, 54, 53, 52, 52;
type [134,16,58_2]; status: weights = 58_2 - {134};
type [135,18,58_2]; status: weights = 58_2 - {100..134};
type [135,21,56_2]; status: weights = 56_2 - {110..134};
type [135,24,54_2]; status: weights = 54_2 - {116..134};
n = 134, k >= 15: 60, 58, 58, 57, 56, 56, 55, 54, 54, 53, 52;
type [135,15,60_2]; status: weights = 60_2 - {114..134};
type [136,16,60_2]; status: weights = 60_2 - {110..136};
type [136,19,58_2]; status: weights = 58_2 - {98..134};
n = 135, k >= 15: 60, 59, 58, 58, 57, 56, 56, 54, 54, 54, 52;
type [136,21,56_2]; status: weights = 56_2 - {128..136};
type [137,22,56_2]; status: weights = 56_2 - {126..136};
n = 136, k >= 15: 60, 60, 58, 58, 58, 56, 56, 55, 54, 54, 53;
type [138,15,62_2]; status: weights = 62_2 - {96..138};
type [137,16,60_2]; status: weights = 60_2 - {122..136};
type [138,17,60_2]; status: weights = 60_2 - {116..138};
type [137,19,58_2]; status: weights = 58_2 - {130,134};
type [138,23,56_2]; status: weights = 56_2 - {106..138};
n = 137, k >= 15: 61, 60, 59, 58, 58, 57, 56, 56, 55, 54, 54;
type [138,16,60_2]; status: weights = 60_2 - {136,138};
type [139,21,58_2]; status: weights = 58_2 - {108..138};
type [138,22,56_2]; status: weights = 56_2 - {138};
type [139,24,56_2]; status: weights = 56_2 - {100..138};
n = 138, k >= 15: 62, 60, 60, 58, 58, 58, 57, 56, 56, 55, 54;
type [139,15,62_2]; status: weights = 62_2 - {114..138};
type [140,16,62_2]; status: weights = 62_2 - {110..140};
type [139,17,60_2]; status: weights = 60_2 - {134..138};
n = 139, k >= 15: 62, 61, 60, 59, 58, 58, 58, 56, 56, 56, 54;
type [140,15,62_2]; status: weights = 62_2 - {140};
type [141,19,60_2]; status: weights = 60_2 - {126..138};
type [140,21,58_2]; status: weights = 58_2 - {128..140};
type [141,22,58_2]; status: weights = 58_2 - {126..140};
n = 140, k >= 15: 62, 62, 60, 60, 59, 58, 58, 57, 56, 56, 55;
type [142,15,64_2]; status: weights = 64_2 - {98,102..142};
type [141,16,62_2]; status: weights = 62_2 - {126..140};
type [142,17,62_2]; status: weights = 62_2 - {118..142};
type [142,20,60_2]; status: weights = 60_2 - {114..118,122..138};
type [142,23,58_2]; status: weights = 58_2 - {96..142};
n = 141, k >= 15: 63, 62, 61, 60, 60, 59, 58, 58, 57, 56, 56;
type [142,16,62_2]; status: weights = 62_2 - {138..142};
type [143,21,60_2]; status: weights = 60_2 - {108..142};
type [142,22,58_2]; status: weights = 58_2 - {140,142};
n = 142, k >= 15: 64, 62, 62, 60, 60, 60, 59, 58, 58, 56, 56;
type [143,15,64_2]; status: weights = 64_2 - {118..142};
type [144,16,64_2]; status: weights = 64_2 - {110..144};
type [144,18,62_2]; status: weights = 62_2 - {130..134,138..144};
type [143,23,58_2]; status: weights = 58_2 - {138..142};
n = 143, k >= 15: 64, 63, 62, 61, 60, 60, 60, 58, 58, 57, 56;
type [145,19,62_2]; status: weights = 62_2 - {130..144};
type [144,21,60_2]; status: weights = 60_2 - {128..144};
type [145,22,60_2]; status: weights = 60_2 - {126..144};
type [145,25,58_2]; status: weights = 58_2 - {136..142};
n = 144, k >= 15: 64, 64, 62, 62, 61, 60, 60, 59, 58, 58, 57;
type [145,16,64_2]; status: weights = 64_2 - {126..144};
type [146,17,64_2]; status: weights = 64_2 - {118..146};
type [146,20,62_2]; status: weights = 62_2 - {112..144};
n = 145, k >= 15: 64, 64, 63, 62, 62, 61, 60, 60, 58, 58, 58;
type [147,15,66_2]; status: weights = 66_2 - {120..146};
type [146,16,64_2]; status: weights = 64_2 - {142..146};
type [147,21,62_2]; status: weights = 62_2 - {108..146};
type [146,22,60_2]; status: weights = 60_2 - {140..146};
type [147,23,60_2]; status: weights = 60_2 - {138..146};
n = 146, k >= 15: 65, 64, 64, 62, 62, 62, 61, 60, 59, 58, 58;
type [148,16,66_2]; status: weights = 66_2 - {112..148};
type [147,17,64_2]; status: weights = 64_2 - {138..146};
type [148,18,64_2]; status: weights = 64_2 - {132..148};
type [148,24,60_2]; status: weights = 60_2 - {136..148};
n = 147, k >= 15: 66, 65, 64, 63, 62, 62, 62, 60, 60, 59, 58;
type [149,19,64_2]; status: weights = 64_2 - {130..148};
type [148,21,62_2]; status: weights = 62_2 - {128..148};
type [149,22,62_2]; status: weights = 62_2 - {126..148};
type [149,25,60_2]; status: weights = 60_2 - {128..148};
n = 148, k >= 15: 66, 66, 64, 64, 63, 62, 62, 61, 60, 60, 59;
type [150,15,68_2]; status: weights = 68_2 - {102,106..150};
type [149,16,66_2]; status: weights = 66_2 - {126..148};
type [150,17,66_2]; status: weights = 66_2 - {122..150};
type [150,20,64_2]; status: weights = 64_2 - {114..148};
n = 149, k >= 15: 67, 66, 65, 64, 64, 63, 62, 62, 60, 60, 60;
type [150,16,66_2]; status: weights = 66_2 - {142,146..150};
type [150,22,62_2]; status: weights = 62_2 - {140..150};
type [151,23,62_2]; status: weights = 62_2 - {138..150};
n = 150, k >= 15: 68, 66, 66, 64, 64, 64, 62, 62, 61, 60, 60;
type [151,15,68_2]; status: weights = 68_2 - {122..150};
type [152,16,68_2]; status: weights = 68_2 - {114..152};
type [151,17,66_2]; status: weights = 66_2 - {140..150};
type [152,18,66_2]; status: weights = 66_2 - {130..152};
type [152,21,64_2]; status: weights = 64_2 - {130..152};
type [152,24,62_2]; status: weights = 62_2 - {126..152};
n = 151, k >= 15: 68, 67, 66, 65, 64, 64, 63, 62, 62, 61, 60;
type [152,17,66_2]; status: weights = 66_2 - {152};
type [153,19,66_2]; status: weights = 66_2 - {122..152};
type [153,22,64_2]; status: weights = 64_2 - {124..152};
type [153,25,62_2]; status: weights = 62_2 - {114..152};
n = 152, k >= 15: 68, 68, 66, 66, 65, 64, 64, 63, 62, 62, 61;
type [153,16,68_2]; status: weights = 68_2 - {128..152};
type [154,17,68_2]; status: weights = 68_2 - {124..154};
type [154,20,66_2]; status: weights = 66_2 - {110..152};
n = 153, k >= 15: 68, 68, 67, 66, 66, 65, 64, 64, 62, 62, 62;
type [155,15,70_2]; status: weights = 70_2 - {126..154};
type [154,16,68_2]; status: weights = 68_2 - {146..154};
type [154,22,64_2]; status: weights = 64_2 - {142..154};
type [155,23,64_2]; status: weights = 64_2 - {136..154};
n = 154, k >= 15: 69, 68, 68, 66, 66, 66, 64, 64, 63, 62, 62;
type [156,16,70_2]; status: weights = 70_2 - {114..156};
type [155,17,68_2]; status: weights = 68_2 - {142..154};
type [156,18,68_2]; status: weights = 68_2 - {126..156};
type [156,21,66_2]; status: weights = 66_2 - {128..156};
type [156,24,64_2]; status: weights = 64_2 - {112..156};
n = 155, k >= 15: 70, 69, 68, 67, 66, 66, 65, 64, 64, 63, 62;
type [156,17,68_2]; status: weights = 68_2 - {154,156};
type [157,19,68_2]; status: weights = 68_2 - {118..156};
type [157,22,66_2]; status: weights = 66_2 - {122..156};
type [156,23,64_2]; status: weights = 64_2 - {156};
n = 156, k >= 15: 70, 70, 68, 68, 67, 66, 66, 65, 64, 64, 62;
type [158,15,72_2]; status: weights = 72_4 - {108..156};
type [157,16,70_2]; status: weights = 70_2 - {130..156};
type [158,17,70_2]; status: weights = 70_2 - {126..158};
n = 157, k >= 15: 71, 70, 69, 68, 68, 66, 66, 66, 64, 64, 63;
type [158,16,70_2]; status: weights = 70_2 - {146..158};
type [158,19,68_2]; status: weights = 68_2 - {152..156};
type [159,20,68_2]; status: weights = 68_2 - {150..156};
type [158,22,66_2]; status: weights = 66_2 - {142..158};
type [159,23,66_2]; status: weights = 66_2 - {134..158};
n = 158, k >= 15: 72, 70, 70, 68, 68, 67, 66, 66, 65, 64, 64;
type [159,15,72_2]; status: weights = 72_2 - {130..158};
type [160,16,72_2]; status: weights = 72_2 - {118..160};
type [159,17,70_2]; status: weights = 70_2 - {142..158};
type [160,18,70_2]; status: weights = 70_2 - {126..160};
type [160,21,68_2]; status: weights = 68_2 - {126..160};
type [159,22,66_2]; status: weights = 66_2 - {158};
type [160,24,66_2]; status: weights = 66_2 - {104..160};
n = 159, k >= 15: 72, 71, 70, 69, 68, 68, 67, 66, 66, 65, 64;
type [160,17,70_2]; status: weights = 70_2 - {156..160};
type [161,19,70_2]; status: weights = 70_2 - {114,118..160};
type [161,22,68_2]; status: weights = 68_2 - {122..160};
type [160,23,66_2]; status: weights = 66_2 - {156..160};
n = 160, k >= 15: 72, 72, 70, 70, 69, 68, 68, 67, 66, 66, 64;
type [161,16,72_2]; status: weights = 72_2 - {130..150,154..160};
type [162,17,72_2]; status: weights = 72_2 - {130..162};
type [162,25,66_2]; status: weights = 66_2 - {152..160};
n = 161, k >= 15: 72, 72, 71, 70, 70, 68, 68, 68, 66, 66, 65;
type [163,15,74_2]; status: weights = 74_2 - {132..162};
type [162,16,72_2]; status: weights = 72_2 - {150..162};
type [162,19,70_2]; status: weights = 70_2 - {154..160};
type [163,20,70_2]; status: weights = 70_2 - {146..160};
type [162,22,68_2]; status: weights = 68_2 - {142..162};
type [163,23,68_2]; status: weights = 68_2 - {130..162};
n = 162, k >= 15: 73, 72, 72, 70, 70, 69, 68, 68, 67, 66, 66;
type [164,16,74_2]; status: weights = 74_2 - {118..164};
type [163,17,72_2]; status: weights = 72_2 - {146..162};
type [164,18,72_2]; status: weights = 72_2 - {126..164};
type [164,21,70_2]; status: weights = 70_2 - {126..164};
type [163,22,68_2]; status: weights = 68_2 - {160,162};
n = 163, k >= 15: 74, 73, 72, 71, 70, 70, 69, 68, 68, 66, 66;
type [164,17,72_2]; status: weights = 72_2 - {158..164};
type [165,22,70_2]; status: weights = 70_2 - {122..164};
type [164,23,68_2]; status: weights = 68_2 - {156..164};
type [165,24,68_2]; status: weights = 68_2 - {152..164};
n = 164, k >= 15: 74, 74, 72, 72, 70, 70, 70, 69, 68, 67, 66;
type [165,16,74_2]; status: weights = 74_2 - {132..164};
type [166,17,74_2]; status: weights = 74_2 - {130..166}; 
type [165,18,72_2]; status: weights = 72_2 - {154..164};
type [166,19,72_2]; status: weights = 72_2 - {150..166};
type [166,25,68_2]; status: weights = 68_2 - {150..164};
n = 165, k >= 15: 74, 74, 73, 72, 71, 70, 70, 70, 68, 68, 67;
type [167,15,76_2]; status: weights = 76_2 - {136..162};
type [166,16,74_2]; status: weights = 74_2 - {152..166};
type [167,20,72_2]; status: weights = 72_2 - {142,146..166};
type [166,22,70_2]; status: weights = 70_2 - {144..166};
type [167,23,70_2]; status: weights = 70_2 - {124..166};
n = 166, k >= 15: 75, 74, 74, 72, 72, 71, 70, 70, 69, 68, 68;
type [168,16,76_2]; status: weights = 76_2 - {118..168};
type [167,17,74_2]; status: weights = 74_2 - {146..166};
type [168,18,74_2]; status: weights = 74_2 - {126..168};
type [168,21,72_2]; status: weights = 72_2 - {126..168};
type [167,22,70_2]; status: weights = 70_2 - {160..166};
n = 167, k >= 15: 76, 75, 74, 73, 72, 72, 71, 70, 70, 68, 68;
type [168,17,74_2]; status: weights = 74_2 - {160..168};
type [169,22,72_2]; status: weights = 72_2 - {118..168};
type [168,23,70_2]; status: weights = 70_2 - {158..168};
type [169,24,70_2]; status: weights = 70_2 - {146..168};
n = 168, k >= 15: 76, 76, 74, 74, 72, 72, 72, 71, 70, 69, 68;
type [169,16,76_2]; status: weights = 76_2 - {134..168};
type [170,17,76_2]; status: weights = 76_2 - {132..170};
type [169,18,74_2]; status: weights = 74_2 - {156..168};
type [170,19,74_2]; status: weights = 74_2 - {150..170};
type [170,25,70_2]; status: weights = 70_2 - {140..170};
n = 169, k >= 15: 76, 76, 75, 74, 73, 72, 72, 72, 70, 70, 69;
type [171,15,78_2]; status: weights = 78_2 - {136..168};
type [170,16,76_2]; status: weights = 76_2 - {154..170};
type [171,20,74_2]; status: weights = 74_2 - {142..170};
type [170,22,72_2]; status: weights = 72_2 - {142..170};
type [171,23,72_2]; status: weights = 72_2 - {122..170};
n = 170, k >= 15: 77, 76, 76, 74, 74, 73, 72, 72, 71, 70, 70;
type [172,16,78_2]; status: weights = 78_2 - {120..172};
type [171,17,76_2]; status: weights = 76_2 - {146..170};
type [172,18,76_2]; status: weights = 76_2 - {130..172};
type [172,21,74_2]; status: weights = 74_2 - {126..172};
type [171,22,72_2]; status: weights = 72_2 - {162..170};
n = 171, k >= 15: 78, 77, 76, 75, 74, 74, 73, 72, 72, 70, 70;
type [172,17,76_2]; status: weights = 76_2 - {162..172};
type [172,23,72_2]; status: weights = 72_2 - {158..172};
type [173,24,72_2]; status: weights = 72_2 - {142..172};
n = 172, k >= 15: 78, 78, 76, 76, 74, 74, 74, 72, 72, 71, 70;
type [173,16,78_2]; status: weights = 78_2 - {136..172};
type [174,17,78_2]; status: weights = 78_2 - {134..174};
type [173,18,76_2]; status: weights = 76_2 - {158..172};
type [174,19,76_2]; status: weights = 76_2 - {146,150..174};
type [174,22,74_2]; status: weights = 74_2 - {142..174};
type [173,23,72_2]; status: weights = 72_2 - {172};
type [174,25,72_2]; status: weights = 72_2 - {126..174};
n = 173, k >= 15: 78, 78, 77, 76, 75, 74, 74, 73, 72, 72, 71;
type [175,15,80_2]; status: weights = 80_2 - {142..172};
type [174,16,78_2]; status: weights = 78_2 - {154..174};
type [174,18,76_2]; status: weights = 76_2 - {174};
type [175,20,76_2]; status: weights = 76_2 - {142..174};
n = 174, k >= 15: 79, 78, 78, 76, 76, 75, 74, 74, 72, 72, 72;
type [176,16,80_2]; status: weights = 80_2 - {122..176};
type [175,17,78_2]; status: weights = 78_2 - {150..174};
type [176,18,78_2]; status: weights = 78_2 - {126,130..176};
type [175,22,74_2]; status: weights = 74_2 - {164..174};
type [176,23,74_2]; status: weights = 74_2 - {160..176};
n = 175, k >= 15: 80, 79, 78, 77, 76, 76, 74, 74, 73, 72, 72;
type [176,17,78_2]; status: weights = 78_2 - {164..176};
type [177,21,76_2]; status: weights = 76_2 - {170,174};
type [177,24,74_2]; status: weights = 74_2 - {132..176};
n = 176, k >= 15: 80, 80, 78, 78, 76, 76, 75, 74, 74, 73, 72;
type [177,16,80_2]; status: weights = 80_2 - {138..176};
type [178,17,80_2]; status: weights = 80_2 - {136..178};
type [177,18,78_2]; status: weights = 78_2 - {158..176};
type [178,19,78_2]; status: weights = 78_2 - {142,146..178};
type [178,22,76_2]; status: weights = 76_2 - {142..178};
type [177,23,74_2]; status: weights = 74_2 - {172..176};
n = 177, k >= 15: 80, 80, 79, 78, 77, 76, 76, 75, 74, 74, 72;

data_comment( ![ \block{A menagerie of codes}\label{menagerie-section}
This section contains a huge list of codes, including a few with 
previously unknown parameters.  The whole list is in transition, as I try
to find simpler (or better) descriptions of the codes.  Because many of 
the codes are derived from other codes in the list, the list has gotten to
be a bit of a tangle.  It will in due course be cleaned up!  

In particular, I barely started the project of replacing many of the codes by
codes described with the {\tt cyclic} command.  Some codes have been replaced
by generator matrices, which has the advantage of reducing
interdependency, but the disadvantage that pages and pages are now filled with
matrices.  Hopefully better descriptions of these codes will be found.

Note also that there is a certain amount of nonsense in this section resulting 
from uniqueness statements that should be proved by the methods of van Tilborg
[.tilborg griesmer 1980.].  These have not yet been formalized in the 
{\tt Split} language.  ]! )

DHIDE( ![
   "done" notations for the following.  Always look for all isomorphism types 

H: auto group residual transform, with nzv length and group size max
   specified
K: auto group residual transform alt, with nzv length and group size max
   specified

C: LAST column deleted
E: each column deleted

suffix P: done with "double column pairs" option
suffix G: done with "double column groups" option

Versions:
suffix S: done after code shortening added
suffix *: semifinal version
suffix #: "final" version
suffix !: done with "delete pairs = 5" added

*); ]! )

unset auto joint list;

[2_1_1] type [2,1,1];
[a] := {10};

DHIDE( ![
Some good seed codes:

D1# run on everything in DATA_F2_1 except [31,13,9]
D2#: [31,13,9] and [28_10_10.c-g2] skipped
D3#: the above, [16,11,4], the [21,8,8]'s, the [24,14,6], and all the
   [28,10,10]'s skipped, [28,14,8], [29,8,12] --> end
O(28)# done for the [28,14,8]

(* DC1P#, D2PG#, O(30)#, DC1.7# done for *);
]! ) 
[18_9_6x] type [18,9,6];
[a] := Cyclic(2, 18, 9, 000101010000001101);
(* isomorphic to [18_9_6.a] *);

DHIDE( ![
(* DC2#, O(26)#, DC1.7# done for [20_8_8.a] *);

(* DC1#, D3#, O(30)# done for [21_9_8.a] *);

(* D3#, DC2P#, D1G, O(24)#, DC1.7# done for [21_8_8.b] *);

(* DC4S(26/5,12), D4S(38/5,11)(stopped after 560 minutes), DC1#  done
for [24,12,8] *);
]! )

DHIDE( ![ DC1#, OE(26)#, DC1.7# done for [a] ]! )
DHIDE( ![ PertTwo tried on [a] -- [k] ]! )
[45_8_20] type [45,8,20];  (* to be continued later *);
CREDIT(existence due to Blokh and Zyablov, blokh zyablov)
DUAL_TRANSFORM([a], [48_8_22.a], ![30_{1,-17},30_{17}]!)
(* [a] := [48_8_22.a] - dual word of weight 3 *);
(* this code is generalized-cyclic *);
[b] := Cyclic(5, 45, 8, 000111100000111111011010010101100100001011111);

DHIDE( ![ (* DC2#, D3#, O(26)#, DC1.7# *); ]! )
[178_8_88] type [178,8,88];
DUAL_TRANSFORM_CH([a], [20_8_8.a-1], ![7,11,12,15,16]!)
alt P( [51_8_24.a] ~ column 1 );
status: realizable;

DHIDE( ![ (* DE1.7# done for [12,7,4] *); ]! )

(* ****************** SOME SIX-DIMENSIONAL CODES ************************** *);

type [53,6,{26,28,30,32}];
config from x_26;
show y32 != 0;
(* This implies that [a], [b] is a complete list. *);

(* **************** JUNK TO AVOID RE-ENTERING A CODE TYPE. **************** *);

[75_7_36x] type [75,7,36];
DUAL_TRANSFORM([a], [178_8_88.a-1], ![88_{41},96]!)
(* the above iso. to [75_7_36.a], but not equal *);
DUAL_TRANSFORM([b], [178_8_88.a-1], ![88_{49},96]!)
(* the above iso. to [75_7_36.b], but not equal *);
[82_7_40x] type [82,7,40];
[a] := P( [18_6_8.a] );
[87_7_42x] type [87,7,42];
DUAL_TRANSFORM_PLUS([d], [75_7_36x.a-2],
     ![35_{10},36_{10},37,38_{10},39,40,41_{-10},42_{10},63_{10}]!,
     ![+ column 65]!)
[105_8_50x] type [105,8,50];
DUAL_ORBIT_PLUS([b], [21_9_8.a], ![$2,$3,$4]!,
     ![000000110,000010001,001111101,010001011,010101111]!,
     ![- column 3 - column 40]!)
[140_8_68y] type [140,8,68];
[d] := [21_8_8.b]^T using {$1,$2,$3 : 00001001,00010001,00011101,00100000,
     00100011,00110000,00110100,01101000,01101010,01111000,01111110,10110101};
[42_8_18y] type [42,8,18];
DUAL_ORBIT([d], [140_8_68y.d], ![$2,$5]!, 
     ![00000111,00001100,00101010,01101011]!)
[147_8_72y] type [147,8,72];
DUAL_ORBIT([b], [21_8_8.b], ![$1, $2, $3]!,
     ![00000101,00001001,00001101,00010001,00011101,00100011,00110100,01101000,
     01101010]!)

(* ************** PUTATIVELY OPTIMAL SEVEN-DIMENSIONAL CODES *************** *);

[40_7_18] type [40,7,18];  (* to be continued later *);
% Delete if possible, redundant:
DUAL_TRANSFORM_PLUS([ax], [87_7_42x.d-1],
     ![42_{85},43_{-85},45_{-85},47_{-85},48_{-85},49_{85},63_{85}]!,
     ![+ column 38]!)
% Delete if possible, redundant:
DUAL_ORBIT([cx], [24_7_10.f], ![$1,$3]!,
     ![0000001,0001001,0001111,0010011,1001001,1001010]!)

at type [56_7_26];

[kk] := 
{10001000111010011011011101010010010100110011011001010000,0100101100101110010001
1110010001101100101100111001001110,001010011100010101011011000001111001101000010
01010011011,00011010100001001001110101001001101010110110001101010110,00000111111
000000111111111000000011111111000000001111111,0000000000011111111111111100000000
0000000111111111111111,00000000000000000000000000111111111111111111111111111111}
;

[nn] := 
{10000111000111111000001111010100011010100010001001011010,0100011100011100011100
1100001111110000011111000001111111,001001000110011011000010001101101111000101100
10010110011,00010101010101100010010101101100100110010011101010011001,00001110001
100110001011110100101101010000101000111010101,0000000011111111111100000000000000
1111111111111111111111,00000000000000000000111111111111111111111111111111111111}
;

[oo1..17] := PertTwo( Act( { (1,2)(3,5)(6,8), (3,8)(4,5)(6,7) }, {00000001,
     00001101,00010101,00010111,11000000,11000001,11000111,11001111,11011110,
     11011111,11111111} ) + check );

[r] := Act( { (2,4)(5,6), (1,8)(2,6,4,5), (2,5)(3,6) }, {00000101,00000111,
     00001110,00011111,00111110,10000001,10111101,10111111} );

[x] := Act( { (1,8)(2,3)(4,7), (1,9,2)(3,5,4)(6,8,7) }, 
     {000101111,000111101,001011111,011101111,111111111} ) + check;

DUAL_ORBIT_CH([58], [40_7_18.cx], ![$1,$2]!,
     ![0000001,0000101,0000110,0001011,0001101,0001110,0100000,0100001,0100010,
     0100011,0100101,0100111,0110010,0110110,0110111,0111011,1100000,1100100,
     1100101,1101000]!)

DUAL_ORBIT_CH([59], [40_7_18.cx], ![$1,$2]!,
     ![0000001,0000010,0001011,0010100,0100000,0100111,0101000,0101101,0101110,
     0110010,0110110,0110111,0111010,0111011,1100001,1100011,1100100,1100101,
     1101000,1101100]!)

DUAL_ORBIT_PLUS([z], [40_7_18.ax], ![$3,$4]!, ![0000101,0001000,0010100,0011000,
     0011001,0011010,0100011,0100100,0111101,1011111]!, ![+ column 42]!)

[XX2_1..12] := PertTwo( [40_7_18.ax]^T using {$4:0000001,0000010,0000100,
     0000111,0001001,0001011,0001101,0010001,0010010,0010111,0011010,0011110,
     0101000,0110001,0110101,0110111,0111111,1010011,1011111} + check );

[XX10_1..8] := PertTwo( [40_7_18.ax]^T using {$4:0000001,0000011,0000101,
     0010000,0010010,0010111,0011000,0011001,0011010,0011110,0100011,0100100,
     0101000,0110101,1010001,1010011,1010101,1010111,1011101,1011111,1111100} 
     + column 12 );

[XX13_1..8] := PertTwo( [40_7_18.ax]^T using {$4:0000010,0000100,0001001,
     0001111,0010000,0010001,0010100,0100000,0100100,0101000,0101011,0101100,
     0110001,0110101,0111011,0111101,1010001,1010011,1010111,1011111,1111100} 
     + check );

[XX19_1..20] := PertTwo( [40_7_18.ax]^T using {$4:0000001,0000010,0000110,
     0001000,0001001,0010001,0010100,0011111,0100000,0100011,0100100,0101000,
     0101011,0101100,0110101,0110111,0111011,0111101,1010011,1010111,1011101} 
     + column 42 );

DUAL_ORBIT_CH([XX22], [40_7_18.ax], ![$4]!,
     ![0000001,0000011,0000100,0000101,0000111,0001000,0001001,0010111,0011000,
     0011010,0011110,0100011,0100100,0101000,0101100,0110001,0110101,1010001,
     1010111,1011101,1110100]!)

DUAL_ORBIT([XX26], [40_7_18.ax], ![$4]!,
     ![0000010,0000100,0000111,0001000,0001001,0001011,0010000,0010001,0010111,
     0011010,0011110,0011111,0100011,0101000,0101011,0101100,0111101,0111111,
     1010011,1010101,1010111,1111100]!)

[XX27_1..8] := PertTwo( [40_7_18.ax]^T using {$4:0000010,0000011,0000110,
     0000111,0001000,0001001,0001011,0001101,0001111,0010100,0011110,0011111,
     0100011,0101000,0101100,0111101,0111111,1010011,1010101,1011101} );

DUAL_ORBIT_PLUS([XX40], [40_7_18.ax], ![$4]!,
     ![0000001,0000110,0001000,0001001,0001011,0001111,0010001,0010010,0010111,
     0011001,0011100,0011110,0011111,0100000,0101011,0101100,1010011,1010101,
     1010111,1011101,1110100]!, ![+ column 51]!)

[XXX1..5] := PertTwo( [40_7_18.ax]^T using {$4:
     0000001,0000100,0000101,0000110,0000111,0001000,0001011,0010000,0010001,
     0010010,0010100,0011001,0011111,0100100,0101011,0110001,0110111,1010001,
     1010011,1011111,1111100} + check );

DUAL_TRANSFORM_PLUS([k], [40_7_18.ax-2],
     ![17,19_{-33},20_{33},21_{33},28_{-33},32_{33}]!, 
     ![+ column 13 + column 54]!)

[f1..9] := PertTwo( [24_7_10.f-2]^T using {9,11,13_{-21},14_{21},16_{21},
     18_{-21}} - column 55 );

DUAL_ORBIT([rr], [75_7_36x.b], ![$6]!, ![0001110,0100000,0100001,0100100,
     0100101,0100111,0101000,0101111,0110100,0110101,0110110]!)

[Q1..5] := PertTwo( {10001010000110001011111110011110010010010010011001111010,
     01000110000111100101101001010110100111110010110110001010,0010100000100111
     1111000000011111110010100111101101001001,00010100001100011111111100111100
     100100100100110011100101,000000010001001000100001100110011011101110111010
     10110111,00000000100010010001010011001100110111011101110101010111,0000000
     0010001001000111001100110011011101110101010110111} );
[Q6..21] := PertTwo({10000000010010010001110011001100110111011101010101101111,
     01000101001111000011000111111000101101111100010011111001,0010000101010111
     1100011010011010010000101111000011001101,00010101011010001010000110000110
     100111100011100111100101,000010010011011101111010011010010000101111010011
     00110000,00000010001001000000011001100110111011101110101010101111,0000000
     0100101101010100110011001101110111011101010101110} );
[Q22..77] := PertTwo( {1000100001110101110110010101101001111100101001100110110
     1,01000000011111100011001011001011110100001011000110010101,00101001010110
     110100100110100110001011110100110000101100,000100010111000111110111111000
     01100111010010001101110011,0000010001000100000001100110011111101100111010
     1010101111,00000010001000100110001100110011011101110111010101100110,00000
     000100010010001110011001101110111111101010101000110} );
[Q78..107] := PertTwo( {100001000011111100001001011001011110100001011000111101
     00,01000100101101111000010110101001001111011000010110111010,0010010011100
     1001110101110110001011100101001101000111111,00010000110000110001110011110
     011110010010010001111111011,000010000111011010110110000001111000010101100
     10011010111,00000010101010101000111111111111101010101010100000000010,0000
     0001010101010101011111111111110111010101000000000000} );
[Q108] := {10001000001110100100110010101101001111110101011001001110,0100010010
     0101011100111010011010000100111111000110110101,00101000100011110110011101
     100000001100011101011010011001,000101000001001010011100000011111110010100
     11101101111000,00000010101010101101011101111111101010101010100000001000,0
     0000001101110111011011011100110000100000001010101100111,00000000010001000
     000111001100110011011111110110101100111};
[Q109] := {10000010000110000110111111011110010010010010011011010001,0100010001
     1110110000101110010011100001101011001011001010,00100010000001111001001110
     011100101111010000111000011110,000101000111010011100000101110101111110010
     10011010100011,00001010001000100111001110000011011101110111010110000110,0
     0000001010101010101110111111111110101010101000000000010,00000000100010001
     100001001101100110111011101110110110101};
[Q110] := {10001000111111011000011000000111100011010110010110001010,0100000001
     0001111100100000101111000101001111111100001101,00101000101010101000010011
     010011000101111010011000111101,000100000100100010101110011101100110111011
     10101101101010,00000100001100011111111100101100100100100100110111010010,0
     0000010101001010001011111111111101010101010100000000110,00000001010110100
     010111111101111110101110101000000000100};
[Q111..121] := PertTwo( {10001000011101000010110010101100011111000000011001011
     111,01000100011111100000100101100101110100000011000110110111,001010000100
     10111111000000111111000101000111011010000011,0001010001100001001111110011
     1101001001001011100111001110,00000010011001101010001010100010100110111011
     111111001011,00000001000110010100010011001101001110111011101010001111,000
     00000100010000101111001100110010111011111010101100110} );
[Q122..138] := PertTwo( {10001000001110100011010010101101001110100101001101011
     001,01000100011110101101011100000011100001101011001011001001,001010000010
     01011111101000011111110011110111101110000001,0001010001110101011110010101
     1010111110001010011010101000,00000010001000100101000100110011011101100111
     010110111110,00000001010101000011011111111111110100010101000000110100,00
     000000100010011001010011001100110111011101110110011010} );
[Q139] := {10100010101110101000010111011110010111001010010010110100,0110011011
     0100101110110011010100100010000101000101100110,00010110100110110011010011
     001000111001101001110011000111,000011100111100100001100001110000001111001
     11110000111111,00000001111110001111110000000111111111100000001111111111,0
     0000000000001111111110000000000000000011111111111111111,00000000000000000
     000001111111111111111111111111111111111};
[Q140..144] := PertTwo( {10010100100011101100110010111001010110101001000011101
     000,01010010110001100010101010010100010101110100101101001101,001101100010
     00100110011001110000110000110011111011100100,0000111000011110011110000111
     1100001100001111100011000111,00000001111111100000011111111100000011111111
     100000111111,00000000000000011111111111111100000000000000011111111111,000
     00000000000000000000000000011111111111111111111111111} );

disjoint [x], [r], [oo1..17], [nn], [kk], [a1..19549], [58..59], [z], 
     [XX2_1..12], [XX10_1..8], [XX13_1..8], [XX19_1..20], [XX22], [XX26], 
     [XX27_1..8], [XX40], [XXX1..5], [k], [f1..9], [rr], [Q1..144];

(* ********************* DIMENSION EIGHT AND HIGHER ********************* *);

DHIDE( ![ "PertTwo" tried on [a], [b] ]! )
[63_11_26] type [63,11,26];
CREDIT(existence due to Kasami and Tokura, kasami tokura)
[a] := Act( { (3,9)(4,6)(7,8)(10,11), (1,9,8)(2,4,3)(5,7,6) }, 
     {00000001110,00001011011,00010010111,00010111110,00101100111,01011101101,
     11111111101} ) - column 64 - column 64;
[b] := Act( { (3,9)(4,6)(7,8)(10,11), (1,9,8)(2,4,3)(5,7,6) }, 
     {00000000001,00000011101,00001001100,00001110010,00010010100,00011001101,
     01111111111} ) - column 1 - column 1;
disjoint [a], [b];
status: realizable;

DHIDE( ![ PertTwo tried on [a], [b], [c], [d] ]! )
[112_10_52] type [112,10,52];
CREDIT(existence due to Bierbrauer and Edel, bierbrauer edel some low codes)
[a] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0000011101,0010000011,0010011111,0110011011,0110111011,
     1110000001,1110111111} );
[b] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0000011101,0010010011,0010101011,0110010101,0110111111,
     1110000001,1110111111} );
[c] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0010001010,0010011011,0010101111,0110111011,1110000001,
     1110010111,1110111111} );
[d] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001110,0000111111,0010000101,0010101111,0110000011,0110000111,
     1110000001,1110111111} );
disjoint [a], [b], [c], [d];
status: realizable;

[116_10_54] type [116,10,54];
[a] := [112_10_52.a] + dual word of weight 4;
[b] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0000011101,0010010011,0010101011,0110010101,0110111111,
     1110000001,1110111111} ) + dual word of weight 4;
[c] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001110,0000111111,0010000101,0010101111,0110000011,0110000111,
     1110000001,1110111111} ) + dual word of weight 4;
disjoint [a], [b], [c];
status: realizable;

[153_10_72] type [153,10,72];
CREDIT(existence due to Blokh and Zyablov, blokh zyablov)
[a] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000000,0000001110,0010000000,0010000011,0010000111,0010011011,
     0110010101,0110111011,0110111111,0111111111,1110000001,1110011101} )
     - column 1;
status: realizable;

[146_10_68] type [146,10,68];
credit: existence due to Jaffe;
[a1..11] := Pert( Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0010000000,0010000101,0010010101,0010111111,0110010011,
     0110011111,0110101011,0111111111,1110011101} ) );
disjoint [a1..11];
status: realizable;

[143_10_66] type [143,10,66];
CREDIT(existence due to Groneick and Grosse, groneicke grosse)
note: More [143,10,66] codes are obtainable by deleting dual words of weight
     three from various [146,10,68] codes.;
flags: find no more;
[e1..159] := [146_10_68.a5] - dual word of weight 3;
disjoint [e1..159];
status: realizable;

[150_10_70] type [150,10,70];
CREDIT(existence due to Blokh and Zyablov, blokh zyablov)
[a1..53] := Pert( [146_10_68.a1] + dual word of weight 4 );
disjoint [a1..53];
status: realizable;

type [162,9,78];
credit: existence due to Jaffe;
[a] := Act( { (1,4)(2,3)(5,9), (1,9,2)(3,4,5)(6,8,7), (1,2,9)(3,7,4,6,5,8) }, 
     {000000001,000001011,000001101,000010011,000011101,000101011,000101101,
     000111110,001011101,001011111,010110111,011111111,111111111} ) 
     - column 1 - column 161 + column 161;
status: realizable;

DHIDE( ![ tried PertTwo on [a] ]! )
type [165,9,80];
credit: existence due to Jaffe;
[a] := Act( { (1,4)(2,3)(5,9), (1,9,2)(3,4,5)(6,8,7), (1,2,9)(3,7,4,6,5,8) }, 
     {000000001,000001011,000001101,000010011,000011101,000101011,000101101,
     000111110,001011101,001011111,010110111,011111111,111111111} )
     + column 163 + column 163;
status: realizable;

[136_10_64] type [136,10,64];
CREDIT(existence due to Groneick and Grosse, groneicke grosse)
DUAL_ORBIT([a], [22_10_8.a], ![$5,$7,$8,$9]!,
     ![0011001100,0011001101,0011011111,0011100100,0111000101,0111000110,
     0111001011,0111100000,1111000011]!)
status: realizable;

[133_10_62] type [133,10,62];
CREDIT(existence due to Groneick and Grosse, groneicke grosse)
[a] := [136_10_64.a] - dual word of weight 3;
status: realizable;

[91_12_40] type [91,12,40];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(7, 91, 12, 000100100000010000100110110011100100011010010011001101
     1011001100000110011111010111110001);
credit: existence due to Aaron Gulliver;
status: realizable;

[169_11_78] type [169,11,78];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(12, 168, 11, 0001001000001011010110101110100101100011100001101010
     00010110100101110101000001110011100111110001000000100111000011011010001111
     10011010101111100100111001011011111110111) + check;
credit: existence due to Aaron Gulliver;
status: realizable;

[172_11_80] type [172,11,80];
credit: existence due to Jaffe;
[a] := [169_11_78.a] + dual word of weight 3;
status: realizable;

DHIDE( ![ tried PertTwo on [a] ]! )
[120_8_58] type [120,8,58];
credit: existence due to I. Boukliev;
[a] :=
{0110001111001100111101010101001010001100110001011110100010100110000011001101110
11011100101111010100110111010101011111000,
01001111100000000101111011111011110001010111100110011000110011000011110100101010
0001101100111101010001010010100000011000,
11101010011011111110000110110001100001010000000110010010000011110001010010100110
0110010100011110101011110011000101001111,
11011000001111001010001101010010100001011001000110110001110100000001101100011011
1111001111110000111111000100100100100110,
10100100010101010001111101110111101101000100111000111011111010100001010101000110
1100001111001101101111000111101100001001,
00011111010110010001100100101001010101110000000101111010000010001101111011100101
0101011110110000111110001010100111111000,
01100110001010010111010100000000000111010111101001010100110001010101111000100101
1110101111101110010111000101001000110001,
01001000000101000110111010110001100000111000111101101111010000000111011011101001
0101000101101110010110111100011100011101};
credit: existence due to I. Boukliev;
status: realizable;

[132_11_60] type [132,11,60];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(12, 132, 11, 0000001000010001001011000011011010110010101111110011
     01110111101010010010101011110100010001100011000001100010101000111100010110
     101);
credit: existence due to Aaron Gulliver;
status: realizable;

[154_11_70] type [154,11,70];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(14, 154, 11, 0001001000011101101110101111101111001010011010101111
     11001001010110001101111011111110011100001011011000110011111101010101101000
     1101010010110011001001111);
credit: existence due to Aaron Gulliver;
status: realizable;

[159_8_78] type [159,8,78];
credit: existence due to I. Boukliev;
[a1..9] := PertTwo(
{0000000000000000000000000000000000000000000000000000000000000000000000000000111
11111111111111111111111111111111111111111111111111111111111111111111111100000111
,
00000000000000000000000000000000000000111111111111111111111111111111111111110000
0000000000000000000000000000000000111111111111111111111111111111111111100011001,
00000000000000000000111111111111111111000000000000000000011111111111111111110000
0000000000000011111111111111111111000000000000000000011111111111111111101101000,
00000000000111111111000000000111111111000000000111111111100000000011111111110000
0000011111111100000000001111111111000000000111111111100000000001111111110100010,
00000011111000011111000011111000011111000001111000001111100001111100000111110000
0111100000111100000111110000011111000011111000001111100000111110000011100010110,
00111100111001100111001100011000100011001110111001110001100110011100011000010000
1001100111001100011001110111100111000100001000110011100111000110011101101010001,
11001101011010000001011101101001100100000111011000110110101000101101100001110011
1010101011010101101010011001101001001000110011011101100001001010101110111001000,
01010100001010101010010100111010101001011011001010011011000011110100101010110101
1100011101010000111010100010110011011001011101100100101010010110000111110100100}
 );
status: realizable;

[165_11_76] type [165,11,76];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(15, 165, 11, 0000000000100101100001010101101101100011110010001100
     00100001011001110100101110111110000011110110100111100000100100110100000100
     0101001111010100101111001101101101011);
credit: existence due to Aaron Gulliver;
status: realizable;

type [156,11,72];
credit: existence due to Jaffe;
[a] := Cyclic( {11,11,11,11,11,11,11,11,11,11,11,11,11,11}, 156, 11, 0110000000
     01111001010000100111111001110101001111000111111000011001100010111000010010
     010010101101000000101100100101010010111101110001111100000101001100000011 );
status: realizable;

[129_11_58] type [129,11,58];
credit: existence due to Jaffe;
[1..3] := [132_11_60.a] - dual word of weight 3;
disjoint [1..3];
status: realizable;

[162_11_74] type [162,11,74];
credit: existence due to Jaffe;
[1..10] := [165_11_76.a] - dual word of weight 3;
disjoint [1..10];
status: realizable;

type [45,14,16];
credit: existence due to I. Boukliev;
[a] := Cyclic(3, 45, 14, 0000000100000100111011001001010111011001);
credit: existence due to I. Boukliev;
status: realizable;

[12_7_4x] type [12,7,4];
[a] := {100000001110,010000001101,001001001001,000101001010,000011001100,
     000000101011,000000010111};
[b] := Dual( Even(3) # Even(4) );

DHIDE( ![ Tried PertTwo on [a], [d], [e], [f], [g], [h], [j], [k] ]! )
[140_8_68] type [140,8,68];  (* to be continued later *);
[a],[c] := P( [12_7_4x.{b,a}] );
DUAL_TRANSFORM([b], [178_8_88.a], ![88_{172},96_{1,-172},96_{-1,172}]!)
[d] := [21_8_8.b]^T using {$1,$2,$3 : 00001001,00010001,00011101,00100000,
     00100011,00110000,00110100,01101000,01101010,01111000,01111110,10110101};
alt Cyclic( {15,15,15,15,15,15,15,15,15,5}, 140, 8, 001111100101111010111110110
     10101111111100001100101100000001001110101000110101001000011111101110011011
     011101010110110011001001111000111001111 );

[203_8_100] type [203,8,100];  (* to be continued later *);
DUAL_ORBIT([l], [140_8_68.c], ![$2,$4,$5,$6]!,
     ![00000001,00000010,00000101,00001000,00001010,00010011,00011101,00101001,
     00101011,00111111,01100101,11101001]!)

DHIDE( ![ tried PertTwo on [a] ]! )
[105_8_50] type [105,8,50];  (* to be continued later *);
CREDIT(existence due to Jaffe and Simonis, jaffe simonis dual transform)
DUAL_ORBIT([a], [48_8_22.a], ![$5]!,
     ![00000101,00000111,00001000,00001110,00010100,00111000,00111001]!)
DUAL_ORBIT_PLUS([b], [21_9_8.a], ![$2,$3,$4]!,
     ![000000110,000010001,001111101,010001011,010101111]!,
     ![- column 3 - column 40]!)
DUAL_ORBIT_PLUS([c], [140_8_68.d], ![$1,$2,$3,$4]!, ![00000010,
     00000011,00000100,00000101,00001011,00010101,01101001]!, ![+ column 1]!)
alt Act( { (1,2)(3,5)(6,8), (3,8)(4,5)(6,7) }, {00000001,00010111,01000001,
     01000110,01001111,01010011,01010111,01111111,11000001,11000011,11001100,
     11001101,11001111,11010101,11010111,11111111} ) + check;
DUAL_ORBIT([d], [120_8_58.a], ![$6,$7]!,
     ![00000001,00000010,00010000,00010001,00100000,00100101]!)
alt Cyclic( {10,10,10,10,10,10,10,5,10,10,10}, 105, 8, 000000010100010101010111
     01110001110110010011011000001100110001110010000101001000010110111111110011
     1111011 );
DUAL_ORBIT([e], [120_8_58.a], ![$6]!,
     ![00010000,00010011,00011010,00011011,00011100,00011101,00011111,00100010,
     00100011,00100101,00100110,00100111,00101110,00101111,01110100,01110101,
     01110110,01110111,01111000,01111011,01111110]!)

DHIDE( ![ {D3.7#, OE(32).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ OE(28).7!(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[64_10_28] type [64,10,28];
[a] := BCH(6, 63, 1..23) + check;
DUAL_ORBIT_CH([b], [64_10_28.a], ![$3,$4]!,
     ![0010001010,0010011111,0110100111,0110110110,1110001101,1110010110]!)
alt Act( { (3,9)(4,6)(7,8)(10,11), (1,9,8)(2,4,3)(5,7,6) }, {00001011011,
     00001110111,00010010100,00111100100,01011101111,01011111111} ) + check;
[c] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0000001011,0010010011,0110011111,1110001110} ) + check;
[d] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0010000000,0010001010,0010010011,0011111111,1110001110,1110111111,
     1111111111} ) + check;
[e] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0001111111,0010000000,0010001010,0010010011,0111111111,1110000000,
     1110001011,1110111111} );
[f] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0010000000,0010010011,0011111111,0110011111,1110001110,
     1111111111} ) + check;
disjoint [a], [b], [c], [d], [e], [f];
status: realizable;

[56_10_24] type [56,10,24];
CREDIT(existence due to Blokh and Zyablov, blokh zyablov)
[a] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) },
     {0000000001,0010101011,0110111011,1110011101} );
[b] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) },
     {0010001010,0010010011,0011111111,0111111111,1110111111} ) + check;
[c] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) },
     {0010000000,0010000011,0010000111,0011111111,1110111111} ) + check;
[d] := [64_10_28.b] - columns {45..48,50,52,62,64};
[e] := [64_10_28.c] - columns {1,17,26,31,39,43,56,63};
[f] := [64_10_28.d] - columns {13,14,21,25,34,41,55,59};
disjoint [a], [b], [c], [d], [e], [f];
status: realizable;

[61_10_26] type [61,10,26];
CREDIT(existence due to Cheng, cheng new linear codes)
[a] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001110,0001111111,0010000101,0011111111,0110010011,1110111111} )
     + check;
[b] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001110,0010000011,0110010101,0111111111,1110000000,1110111111} )
     + check;
[c] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001011,0001111111,0010000000,0010000011,0110010101,1110111111,
     1111111111} );
[d] := [64_10_28.b] - columns {46,64} - column 45 - column 45 + check;
[e] := [64_10_28.b] - columns {46,64} - column 45 - column 48 + check;
[f] := [64_10_28.b] - columns {46,64} - column 45 - column 50 + check;
[g] := [64_10_28.c] - columns {1,63} - column 16 - column 24 + check;
[h] := [64_10_28.c] - columns {1,63} - column 16 - column 29 + check;
[i] := [64_10_28.c] - columns {5,14} - column 6 - column 7 + check;
[j] := [64_10_28.d] - columns {13,55} - column 13 - column 19 + check;
[k] := [64_10_28.d] - columns {1,63} - column 15 - column 15 + check;
disjoint [a], [b], [c], [d], [e], [f], [g], [h], [i], [j], [k];
status: realizable;

[53_10_22] type [53,10,22];
CREDIT(existence due to van Pul, van Pul thesis)
[a1..4] := PertTwo(
                Sub( { L(%1) := AllSubIso( %1, Col(1,2) | Col(1,3) ) },
                     Cycle({1,2,3,4,5,6,7}) # {1,0,0} |
                     Cycle({1,3,5,7,2,4,6}) # {0,1,0} |
                     Cycle({1,4,7,3,6,2,5}) # {0,0,1} |
                     L( Cycle({1,2,3,4,5,6,7}) ) # {1,0,1} |
                     L( Cycle({1,3,5,7,2,4,6}) ) # {1,1,0} |
                     L( Cycle({1,4,7,3,6,2,5}) ) # {0,1,1} 
                     | Choose( 7, {0,6} ) # Choose(3,3) 
                     | Choose( 7,7 ) # Choose(3,1) ) );
note: The definition of [a1] involves a partition of K_7 into three Hamiltonian
     cycles.;
disjoint [a1..4];
status: realizable;

[71_10_32] type [71,10,32];
DUAL_ORBIT_CH([a], [64_10_28.a], ![$3,$4]!,
     ![0000000111,0000001010,0010000010,0010000111,0010001100,0011010111,
     1110000000,1110000011,1111111111]!)
[b] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001110,0010000000,0010101111,0110000000,0110010011,1110000000,
     1110000001,1110001011} ) + check;
[c] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000000001,0000010111,0001111111,0010000000,0010101011,0110111011,
     0111111111,1110000000,1110011101} );
disjoint [a], [b], [c];
status: realizable;

[119_10_56] type [119,10,56];
DUAL_ORBIT_CH([a], [64_10_28.a], ![$3,$4]!,
     ![0000001000,0000001101,0000011011,0010001000,0010001010,0010110110,
     0011011010,0110001111,0110010011,1110000001,1110001101]!)
[b] := Act( { (1,2)(3,4)(6,7), (1,7,3,2,6,4)(8,10,9), (1,6)(2,3)(4,5) }, 
     {0000001000,0000001111,0000111001,0000111101,0001111100,0011101000,
     0111111011,0111111111} );
disjoint [a], [b];
status: realizable;

[64_16_24] type [64,16,24];
[a] := BCH(6, 63, 1..21) + check;
status: realizable;

type [128,15,56];
(* Don't try to compute the automorphism group of this configuration: *);
[a] := BCH(7, 127, 1..50) + check;
status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
DHIDE( ![ tried PertTwo on [a] ]! )
[45_10_18] type [45,10,18];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(3, 45, 10, 000000101011000111000010010111111000101001);
credit: existence due to Aaron Gulliver;
status: realizable;

DHIDE( ![ OE(32).7#(allowing length up to 495) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
type [48,10,20];
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
[a] := Cyclic(4, 48, 10, 00000000111100101010001011101000001100111010011);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
[b] := Act( { (3,9)(4,6)(7,8)(10,11), (1,9,8)(2,4,3)(5,7,6) },
     {00001111110,00101000101,00111101111,01011101111} );
disjoint [a], [b];
status: realizable;

DHIDE( ![ OE(32).7#(allowing length up to 495) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[81_10_36] type [81,10,36];
CREDIT(existence due to Gulliver and Bhargava, two new rate 1994)
(* I think that the following code should have a cyclic description, but
   it does not respond to the cyclic command. *);
[a] := 
{1000100000000110000011110010011110110100010011101101100011110111111000010101101
10,01001000001001000000100011110100011111101110100110010101100011000101000111100
1100,001010000001010000000011010111011001101110111110000100100011000111001011101
110000,0001100000001100000011101100101101101001100101011111000111101111010001101
00101110,00000100000111100101011111100101101100000111100100110110010011010011101
0001110110,000000100010111011011011100011101100100010111111010001011101100100011
111000000101,0000000100110110100111011011100101100100110110000111110000011011010
01101100111100,00000000101110101011111011100010101000101110101111100000111110100
1100100110100001,000000000111110010101111010011110100000111110010001011101000101
011110000011101110,0000000000000001111100000111110000000000000001111111111111111
11110000000000111111};
CREDIT(existence due to Gulliver and Bhargava, two new rate 1994)
[b] := Act( { (1,5,4,3,2)(6,10,9,8,7), (1,10,3,6)(2,8)(4,9,5,7) }, 
     {0000000001,0000100101,0000111111,0011100111,0101101110,0101111011,
     0111110111} ) + check;
disjoint [a], [b];

status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[78_10_34] type [78,10,34];
CREDIT(existence due to Bierbrauer and Edel, bierbrauer edel twisted 1997)
[a] := [81_10_36.a] - dual word of weight 3;
[b] := Act( { (1,5,4,3,2)(6,10,9,8,7), (1,10,3,6)(2,8)(4,9,5,7) }, 
     {0000000111,0000011111,0000110000,0000110010,0001101011,0011101110} )
     + check;
disjoint [a], [b];
status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[96_10_44] type [96,10,44];
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
[a] := Cyclic(8, 96, 10, 000000000101010001001111011000001100100011011111010010
     000011001100110101011011100111110001011001);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
status: realizable;

DHIDE( ![ O(28).7#(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[68_10_30] type [68,10,30];
[a] := [64_10_28.a] + dual word of weight 4;
[c1..3] := [64_10_28.c] + dual word of weight 4;
[d] := [64_10_28.d] + dual word of weight 4;
disjoint [a], [c1..3], [d];
status: realizable;

DHIDE( ![ K(24,25000) done for [1..3] ]! )
[100_10_46] type [100,10,46];
[1..3] := [96_10_44.a] + dual word of weight 4;
disjoint [1..3];
status: realizable;

DHIDE( ![ OE(28).7#(allowing length up to 256) done for [a] ]! )
[103_10_48] type [103,10,48];
[a] := [100_10_46.1] + dual word of weight 3;
(* this code is generalized-cyclic *);
status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[93_10_42] type [93,10,42];
CREDIT(existence due to Bierbrauer and Edel, bierbrauer edel twisted 1997)
[a] := [96_10_44.a] - dual word of weight 3;
status: realizable;

DHIDE( ![ OE(32).7#(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
type [100,11,44];
CREDIT(existence due to Gulliver and Bhargava, some best rate 1991)
[a] := Cyclic(9, 99, 11, 00000000001000010110100000110111000001110010000110010
     100011010101001001011110011110101100111110101) + check;
CREDIT(existence due to Gulliver and Bhargava, some best rate 1991)
status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[108_12_46] type [108,12,46];
CREDIT(existence due to Gulliver and Bhargava, some best rate 1991)
[a] := Cyclic(9, 108, 12, 00000000000100111100111000010011111000100100101000000
     000011000101110111000101111101000111011001000110101101);
CREDIT(existence due to Gulliver and Bhargava, some best rate 1991)
status: realizable;

DHIDE( ![ K(24,25000) done for [a] ]! )
DHIDE( ![ OE(28).7#(allowing length up to 256) done for [a] ]! )
[111_12_48] type [111,12,48];
credit: existence due to B. Groneick and S. Grosse;
[a] := [108_12_46.a] + dual word of weight 3;
status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
DHIDE( ![ tried PertTwo on [a] ]! )
[140_9_66] type [140,9,66];
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
[a] := Cyclic(14, 140, 9, 00010010000000001010000101110000010011010101011101001
     11111000011101101100011001011110000001100110011100111010111101100011010110
     000001101111);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
[b] := Cyclic( {10,10,10,10,5,10,10,10,10,10,10,10,10,10,5}, 140, 9, 0011000000
     00000100100011001010001101000100010000101001101110110100111000001011101001
     10111001011010101100001111110000111111011010111001101110 );
disjoint [a], [b];
status: realizable;

DHIDE( ![ O(28).7#(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
[141_11_64] type [141,11,64];
CREDIT(existence due to Gulliver and Bhargava,
     gulliver bhargava improvements 1996)
[a] := Cyclic(10, 140, 11, 0100011000010001111001111001110000101110011000000101
     01100101100001011000110010101000000110110111100111010111111110001101110111
     110111000011) + check;
CREDIT(existence due to Gulliver and Bhargava,
     gulliver bhargava improvements 1996)
status: realizable;

DHIDE( ![ OE(28).7!, DC1# done for [b] ]! )
DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ K(24,25000) done for [a] ]! )
DHIDE( ![ tried PertTwo on [a] ]! )
type [144,9,68];
credit: existence due to Aaron Gulliver;
flags: find no more;
note: "[147_9_70.{1..68}] - dual word of weight 3" is at least 765 
     [144,9,68] codes.;
[a] := Cyclic(16, 144, 9, 00000000100100110011010000011111100110110101000010100
     10110000001110110001001011000011011110101011101001110100011100000010110101
     1110110101011101);
credit: existence due to Aaron Gulliver;
[b] := Cyclic(12, 144, 9, 00011001011101110100110000010010110000011011010101010
     11011000001001111010101111001000001101001000000101001010101111010110110111
     101100000101101);
status: realizable;

[147_11_66] type [147,11,66];  (* to be continued later *);
CREDIT(existence due to Gulliver and Bhargava,
     gulliver bhargava improvements 1996)
[a] := Cyclic(7, 147, 11, 00000101001000001100101110011001011100100010001000100
     01011110111001100100011110001010100001101000001000101111101110010011100000
     00111100111011011100);
CREDIT(existence due to Gulliver and Bhargava,
     gulliver bhargava improvements 1996)

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ OE(28).7#(allowing length up to 256) done for [b] ]! )
[150_11_68] type [150,11,68];
CREDIT(existence due to Gulliver and Bhargava,
     gulliver bhargava improvements 1996)
[a] := Cyclic(10, 150, 11, 0000000000111111001010000000101001001100000011001110
     11111011001001110100110011111101101011001100001011011101001001000110011100
     010010101100010111);
CREDIT(existence due to Gulliver and Bhargava,
     gulliver bhargava improvements 1996)
[b] := [147_11_66.a] + dual word of weight 3;
disjoint [a], [b];
status: realizable;

DHIDE( ![ {D1.7#, O(28).7#}(allowing length up to 256) done for [a] ]! )
DHIDE( ![ OE(28).7#(allowing length up to 256) done for [1..5] ]! )
[147_11_66] type [147,11,66];  (* continued from earlier *);
[1..5] := [150_11_68.a] - dual word of weight 3;
disjoint [a], [1..5];
status: realizable;

DHIDE( ![ O(28).7#(allowing length up to 256) done for [a] ]! )
[160_10_74] type [160,10,74];
credit: existence due to Aaron Gulliver;
[a] := Cyclic(16, 160, 10, 0000000101111110000111100101010001011011100101010101
     00001010010100100110011011111001110010011101100001000001110010011001111101
     01101101101101100000011010101);
credit: existence due to Aaron Gulliver;
status: realizable;

DHIDE( ![ OE(28).7#(allowing length up to 256) done for [a],[b],[c],[d],[e] ]! )
[40_10_16] type [40,10,16];
[a] := Cyclic(4, 40, 10, 000000000101101101100111011100011111101);
[b] := Cyclic(4, 40, 10, 0100000000010101101000001111011101101);
[c] := Cyclic(4, 40, 10, 010100000001100011110000111101001101);
[d] := Cyclic(4, 40, 10, 0000000101011110001101011110001111100101);
[e] := Cyclic(4, 40, 10, 0000000101010000101001000001111101101101);
DUAL_ORBIT([f], [22_10_8.a], ![$3,$6,$9]!,
     ![0100110011,0110000010,1100000110,1100101101,1100111110,1110100111]!)
DUAL_ORBIT([g], [22_10_8.a], ![$2,$3,$4,$5,$9]!,
     ![0100000010,0110000000,1100000100,1100111110,1110000000]!)
DUAL_ORBIT([h], [40_10_16.f], ![$4,$7]!, ![0001000000,0011011100,0111011101]!)
DUAL_ORBIT_CH([i], [40_10_16.f], ![$4,$7]!, 
     ![0000000100,0000111001,0000111010,0001011110,0111000000]!)
DUAL_ORBIT([j], [40_10_16.f], ![$4,$7]!, 
     ![0000000110,0000000111,0000111010,0001000010,0111011110,1111000110]!)
DUAL_ORBIT([k], [40_10_16.g], ![$5,$7]!, ![0000111010,0001000001,0001010010]!)
DUAL_ORBIT([l], [40_10_16.g], ![$5,$7]!, ![0001010010,0001111000,0101110010]!)
[m] := Act( { (1,3,2)(4,10,6)(7,9,8), (1,3,2)(5,8,6)(7,10,9) }, 
     {0000001110,0001111111,0010010101,0011111111,1110000000,1110011101} );
disjoint [a], [b], [c], [d], [e], [f], [g], [h], [i], [j], [k], [l], [m];
status: realizable;

[165_10_78] type [165,10,78];  (* to be continued later *);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
flags: find no more;
note: "[162,10.{1..34}] + dual word of weight 3" is 34 [165,10,78] codes.;
[a] := Cyclic(11, 165, 10, 0000011001110010000010100101001111110000011110110100
     11101010101001010100001110110110010111100100001110001000010000100000110111
     011001101101110011110000101010110111);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)

[156_9_74] type [156,9,74];  (* to be continued later *);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)
flags: find no more;
[a] := Cyclic(13, 156, 9, 00000001000110011001111110101100100101000011100000001
     10111010001110011011111010110100101101000001111101101001010101011111011011
     1001101011110010011111111);
CREDIT(existence due to Gulliver and Bhargava, gulliver bhargava 1997)

DHIDE( ![ OE(32).7#(allowing length up to 256) done for [a] ]! )
[168_10_80] type [168,10,80];
credit: existence due to me;
[a] := [165_10_78.a] + dual word of weight 3;
(* this code is generalized-cyclic *);
status: realizable;

DHIDE( ![ O(28).7#(allowing length up to 256) done for [a], [b] ]! )
DHIDE( ![ D1.7#(allowing length up to 256) done for [a] ]! )
[165_10_78] type [165,10,78];  (* continued from earlier *);
[b] := [168_10_80.a] - columns {155,160,165};
disjoint [a], [b];
status: realizable;

[162_10_76] type [162,10,76];
credit: existence due to me;
[1..34] := [165_10_78.a] - dual word of weight 3;
disjoint [1..34];
status: realizable;

(* Eliminate: there is a [165,11,76]. *);

[166_11_76] type [166,11,76];
[a] := Cyclic(15, 165, 11, 0100000000010111110110011000100000100100010000011100
     01111111100101010101100001001110011000000111011111010101011111100010100011
     011011110011101010011101101101111101) + check;

[228_9_112] type [228,9,112];  (* to be continued later *);
CREDIT(existence due to Bierbrauer and Edel, bierbrauer edel twisted 1997)
DUAL_ORBIT_PLUS([a], [64_10_28.a], ![$2,$4]!, 
     ![0000000011,1100000000,1100100001,1111111111]!, 
     ![+ column 225 + column 225 + column 225]!)
DUAL_ORBIT([b], [64_10_28.a], ![$1,$2]!, 
     ![0000000011,1000000001,1000000111,1000001001,1000010111]! )

(* All the [166,9,80]'s should be deleted. *);

[166_9_80] type [166,9,80];  (* to be continued later *);
DUAL_ORBIT_PLUS([b], [228_9_112.a], ![$8]!, 
     ![000000001,000000010,000000100,000000110,000001001,000001101,000001110,
     000011011,000100100,000100101,000101100,000111100,001110001,001111111,
     111111110]!, ![+ column 164]!)

(* The following should be deleted: *);

[163_9_78] type [163,9,78];
[a] := Cyclic(18, 162, 9, 00000000110100000101100100100101110111011110101110101
     00011001001111101100101110111100100111001010110110001000010001010101000010
     10011000101010110011110000111011) + check;
[1..67] := [166_9_80.b] - dual word of weight 3;

DHIDE( ![ OE(32).7#(allowing length up to 256) done for [a] ]! )
[159_9_76] type [159,9,76];
credit: existence due to me;
[a] := [156_9_74.a] + dual word of weight 3;
(* this code is generalized-cyclic *);
DUAL_ORBIT_PLUS([b], [21_9_8.a], ![$2,$3,$5]!,
     ![001000111,001010000,001111101,011000011,011000110,011000111,011011110,
     100000010,100010110,101000111,101001100,101001110,111000010,111000110,
     111100001]!, ![+ column 148]!)
[c] := Sub( { Triangles(%1) := AllSubIso( %1, Choose(3,2) ),
            M1 := Cycle({1,2,3,4,5,6}),
            M2 := Cycle({1,2,5,6,3,4}),
            M3 := DelDup(M1|M2),
            M0 := Off(M1|M2),
            G(%1) := Un(%1) | Triangles(%1) - Triangles(M0) },
          {1,0,0} # Un(M1) | {0,1,0} # Un(M2) | {0,0,1} # Un(M3) |
          {0,0,0} # ( Un(M0) | Triangles(M0) ) |
          {1,1,0} # G( DelDup(M0|M1|M2) ) |
          {0,1,1} # G( DelDup(M0|M2|M3) ) |
          {1,0,1} # G( DelDup(M0|M1|M3) ) |
          Choose( 3, {1,2} ) # Choose( 6, {5,6} ) |
          Choose( 3, 3 ) # Choose( 6, {3,4,6,6} ) );
DUAL_ORBIT_PLUS([d], [21_9_8.a], ![$1,$2,$3,$6]!,
     ![000000110,001000001,001001100,001011100,010000001,010001011,010101111,
     011000000,011000110,011010010,110001100,110001101,110011111,111001101,
     111100001]!, ![+ column 153]!)
DUAL_ORBIT([e], [163_9_78.a], ![$1]!,
     ![000000111,000001111,000010001,000011101,000100011,000101001,000101011,
     000101111,000111001,001001001,001011101,001101011,001101101,010110111,
     010111011,010111111,011011011,011011111,011111111]!)
(* this code is generalized-cyclic *);
[f] := Act( { (2,7)(4,6)(8,9), (1,9,5,4,3,2)(6,8,7) },
     {000000101,000000111,000001101,000001111,000011101,000111101,001000111,
     001010111,001101011,001111011,010111111,011111111} )
     - column 27 - column 141 - column 32 - column 137 + check;
[g] := Act( { (2,7)(4,6)(8,9), (1,9,5,4,3,2)(6,8,7) },
     {000000101,000000111,000001101,000001111,000011101,000111101,001000111,
     001010111,001101011,001111011,010111111,011111111} )
     - column 27 - column 141 - column 39 - column 132 + check;
[h] := Act( { (2,7)(4,6)(8,9), (1,9,5,4,3,2)(6,8,7) },
     {000000101,000000111,000001101,000001111,000011101,000111101,001000111,
     001010111,001101011,001111011,010111111,011111111} )