Modulo:pate

El Vikivortaro
Salti al navigilo Salti al serĉilo
 MODULO
Memtesto disponeblas sur la paĝo Ŝablono:pate.

--[===[

MODULE "PATE" (proxy for analysis of template output)

"id.wikipedia.org/wiki/Modul:pate" <!--2023-Jul-16-->
"eo.wiktionary.org/wiki/Modulo:pate"

Purpose: call template indirectly with various extra features
         for debugging and documentation purposes

Utilo: nerekte alvokas sxablonon kun diversaj ...

Manfaat: panggilan templat tidak langsung dengan bermacam-macam
         fungsi tambah untuk penghilangan kekutu dan dokumentasi

Syfte: indirekt anropar en mall ...

Used by templates / Uzata far sxablonoj:
- only "pate" (not to be called from any other place)

Required submodules / Bezonataj submoduloj / Submodul yang diperlukan:
- NONE

Required images:
- "File:Return arrow.svg", Public Domain

Name: "pate" is an abbreviation of "PAnggilan TEmplat" = "template
      call", idea born 2018-Dec at ID wikipedia, alternatively
      "Proxy for Analysis of TEmplate output"

This module can accept parameters whether sent to itself (own frame) or
to the caller (caller's frame). If there is a parameter "caller=true"
on the own frame then that own frame is discarded in favor of the
caller's one.

Incoming: * one anonymous and obligatory parameter:
            * can be one of 4 types:
              * bare name of the target template (no walls)
              * complete call of the target template protected by
                rectangular brackets (at least one wall required)
              * more than call, wikitext containing calls to multiple
                templates, or one template + something more, only
                for "nsm=2", always requires rectangular brackets, inside
                them requires "enhanced" curly brackets "{({" ... "})}"
                (except for degenerated case with ZERO template calls)
              * special value
                * special value ":top" begins the table (HTML code
                  and title row)
                * special value ":end" ends the table (HTML code)
            * notes:
              * for target name the default "Template:" or "Templat:" prefix
                can be omitted, other namespace prefix is possible, extra
                colon for namespace ZERO is NOT permitted, use "zer=1" then
              * complete call must be enclosed in double rectangular brackets
                "[["..."]]" instead of traditional double curly brackets
                "{{"..."}}" used for direct calls, inner wikilinks
                with rectangular brackets permitted
              * if no wall is present then double rectangular
                brackets are prohibited, a violation like
                {{#invoke:pate|ek|[[mall-test]]|sel=111-111}} gives #E04
              * length 1...10'000 octet:s
          * 14 named and optional parameters:
            * notes:
              * some are relevant for special work ":top" too, namely
                "sel=" "tit=" "war=" "bor="
              * none are relevant for ":end"
              * number bigger than "1" in the control string "sel=" is used
                to hold a value instead of another named parameter if:
                * there is a low number of possible discrete values
                * the issue is specific to a column of the table
                * the issue is about display only, not about operation
              * following display details are "built-in" into "sel=":
                * column "call" : small text size (boolean -> tristate)
                * column "cat" : omit sorting hints (boolean -> tristate)
                * column "debug" : type of display (black text, coloured
                  text, map) (tristate -> fourstate)
            * "tab=" HTML table type, prohibited for special work, one digit,
              can be "0"..."5", default is "2":
              * "0" raw style, do NOT add any table elements (gives #E25
                if parameter "sel=" requests more than 1 table cell)
              * "1" brew one or several table cells with "<td>" and "</td>"
                but no "<tr>" and "</tr>" (this is rarely useful)
              * "2" brew one or several table cells with "<td>" and "</td>"
                together inside a table row delimited by "<tr>" and "</tr>"
              * "3" generate a complete horizontal table with 1+1 rows (one
                row for titles, one row for one target) and 1...6 columns
              * "4" generate a complete horizontal table with 1 row only
                (no titles, one target) and 1...6 columns
              * "5" generate a complete vertical table with 1+1 columns
                (one column for titles, one column for one target) and
                1...6 rows (this is useful for "big" target templates)
            * "sel=" cell control string, always 6 + 1 digits boolean tristate
              fourstate, for "tab=0" the default is "010-000" (show only
              parsed result), otherwise it is "111-110" (show all except
              debug), value "000-000" (do not show anything at all) is
              prohibited, relevant also for ":top", the digits (left
              to right) correspond to:
              * X..-... # calling code, with link to the target template if
                "call"    not same page, showed even if the template doesn't
                          exist, the link can be red, with all parameters,
                          text without link if same page, value "1" to enable,
                          "2" for small text
              * .X.-... # parsed result from the target template (called
                "parsed"  with all possible example parameters and hidden
                          parameters) displayed, or whining if problem (target
                          not found, returned empty (ZERO octet:s), returned
                          invalid (see below) content)
              * ..X-... # remark ie extra usage information from parameter
                "rem"     "rem=", or placehodler string "--" if not supplied,
                          showed even if target not found
              * ...-X.. # links to categories resulting from category
                "cat"     insertions generated by the template with sorting
                          hints (every of them split into 2 lines, all
                          categories are counted, up to 12 listed), or
                          whining if problem, value "1" to enable, "2"
                          to omit sorting hints
              * ...-.X. links to list of backlinks and redirects to the target
                        template (showed even if template is not found, links
                        to these services cannot be red), "back"
              * ...-..X technical information for debug purposes including
                        bloat of the result brewed by the template, findings,
                        full raw wikitext (always unparsed, either simple
                        "hard nowiki" or coloured "hard nowiki" or coloured
                        map), fourstate ("0" omit column, "1" show per "hard
                        nowiki", "2" show per coloured "hard nowiki", "3" show
                        map, no difference between "1" and "2" "3" for ":top",
                        thus use always "1" to enable column), "debug"
            * "tit=" defines the titles for the table, 1...6 title strings
              have to be attached together by double at-signs "@@", relevant
              if the anonymous parameter is ":top" or the "tab=" parameter
              is "3" or "5", otherwise ignored, the default or specified
              "sel=" value determines the size of the table, only selected
              columns (for "tab=3" "sel=100-003" and "tit=calling@@insanity"
              there will be 2 columns, the latter one named "insanity"
              containing the debug map), superfluous title strings are
              ignored, missing ones are replaced by
              default names hardcoded in "contabcolumns", note that equal
              sign "=" and wall "|" are problematic (see below), total
              length 1...200
            * "war=" table line color, always 6 hex digits without
              cross "#", default is "60A0A0" AKA bluegreen
            * "bor=" CSS "border:" value, legal range "05" ... "80" becomes
              "0.05em"..."0.80em", default is "20" becoming "0.20em",
              always 2 digits
            * "mod=" target is a module, value is the name of function ("1"
              prohibited), prohibited for special work, prohibited together
              with "zer=1", prohibited for "nsm=2"
            * "zer=1" allow target in ns ZERO (prefix for ns 10 will NOT
              get added, instead check whether it indeed is in ns ZERO),
              prohibited for special work, prohibited together with
              "mod=", prohibited for "nsm=2"
            * "nsm=" activate workaround for nested template calls, references
              in parameters or more/multi mode, "1" to enable nesting, "2" for
              more/multi mode, prohibited for special work, see "Notes on
              protection" below
            * "hid=" list of 1...8 hidden named parameters, 2...16 (even
              number) strings in the list of names and values have to be
              attached together by 1...15 (odd number) double at-signs "@@",
              note that we rarely have more than one hidden parameter, total
              length 4...1000, minimal content "a@@b" becomes "a=b",
              prohibited for special work, hidden parameters must NOT
              contain wikilinks, also no nested templates even with "nsm=1"
            * "rem=" remark ie extra usage information for the target
              template, note that equal sign "=" and wall "|" are problematic
              (see below), LF is prohibited (LF + star "*" or cross "#" would
              break layout), total length 1...1000, plain cross "#" at begin
              is safe (such as "#T99") ie no begin-of-line-specific rules
              apply, prohibited for special work
            * "ref=" eat away references, name of group or "1" for default one
            * "reg=" eat away references, name of group or "1" for default one
            * "hlt=1" send "trackingcategorieshiglow=true" to the target
              and activate bypassing, prohibited for special work, note that
              literal "trackingcategorieshiglow=true" will NOT work, see
              below "Notes on tracking categories"
            * "ncf=1" (deprecated) send "nocat=false" to a legacy target
              template, prohibited for special work, note that literal
              "nocat=false" will NOT work, see below "Notes on category
              suppression"

Returned: * large and complicated string as documented below, may or may
            not contain part of a HMTL table or a complete such

------------------------------------------------------------------------

### Usage (user manual)

Features:
* calls a target (usually template) and separates cat insertions
  from remaining wikitext, performs category suppression, on one
  place for all templates in a wiki
* drastically simplifies tasks like template and module documentation and
  self-testing, template debugging, listing of multiple template results
  (like userboxes) in a table, provides easy linking to templates
  with parameters
* completely replaces all other legacy category suppression tricks (except
  title page rule) thus greatly simplifies template design and reduces
  risk of miscategorizations
* allows to show the generated category insertions including sorting hints
* can handle hidden parameters (special parameters that can pretend to the
  target facts that it detects and depends on, like pagename, namespace,
  protection level, preview-vs-submit, existence of a file or page,
  date, ...)
* preserves the sortorder and formatting of parameters
* works with misplaced templates ie templates in other namespaces
  such as "User:" (still namespaces 14 "Category:" as well as 6 and -2
  "File:" and "Media:" are prohibited), works even for target in ns
  ZERO (needs "zer=1")
* can usually work even with legacy templates internally still relying
  on legacy category suppression tricks
* can handle nested template callls (needs "nsm=1")
* can "fire" and analyze wikitext consisting of more than just one
  template call (needs "nsm=2")
* accepts most of same and less sane content that templates can generate,
  can handle "<pre>" and HTML comments
* can handle references generated by the target in a decent and useful
  manner, see below "Notes on references"
* detects and reports various errors in output from templates, severe
  errors result in early rejection ie no separation, but still at least
  partial report

Limitations and caveats:
* uncommon syntax of the template call with double rectangular brackets
  (note: this is due to some rules or priciples in the MediaWiki parser
  that are old and inherent, thus this will NOT get "fixed" to "standard"
  double curly brackets, see below "Notes on protection")
* nested template calls will NOT work out of the box since the innermost
  template is expanded at the earliest, but there is a solution, see below
  "Notes on protection"
* references passed as template parameters don't work out of the box, but
  there is a solution, see below "Notes on protection"
* uncommon syntax of nested inner template calls using {({ })} (same here,
  this will NOT get "fixed" to "standard" double curly brackets)
* intermediate type template parameters ie holes in anonymous parameter
  chain are not supported (for example "{{mytemplate|junk|4=green}}" is bad)    !!!FIXME!!! is this true at all ??
* there is NO LIMIT for number of forwarded parameters ("pate" does NOT
  bother with them one at a time), but there is a size limit max 10'000
  octet:s resulting in a theoretical limit a bit below 5'000 anonymous
  parameters, also there IS a limit of MAX 8 HIDDEN parameters, note that
  chess needs only slightly more than 64 parameters for a standard chessboard
* equal sign "=" and wall "|" are prohibited (must be html-dec-encoded) in
  title strings (parameter "tit=") and remark (parameter "rem=") (limitation
  comes from the wiki parser), and several titles have to be separated by
  "@@" and must NOT be empty
* due to MediaWiki parser again, testing broken call syntax like {{doit|}}
  is a problem, written as [[doit|]] it gets victim of the "pipe trick",
  but there is a solution, see below "Notes on protection"
* uncommon syntax of the hidden forwarded parameters (parameter "hid=")
  that have to be separated by "@@" instead of "|" or "=" and any single
  parameter must NOT be empty (limitation comes from the wiki parser)
* may cause problems with some legacy templates (try the "ncf=1"
  ie "nocat=false" trick)
* fires one expensive request and thus must be used less than 500 times         !!!FIXME!!!
  on one page
* some aggressive tags rarely used in templates result in strip markers
  showed and detected here (but no strip markers arise if the content
  comes from a module), they make debug output less informative but parsed
  output still looks OK, see also "Notes on protection" and "Notes on
  references" below
* <syntaxhighlight lang="text"> does not work (rejected as error)               !!!FIXME!!!
* "<nowiki>" does NOT work (rejected as error), note that "<nowiki>" does       !!!FIXME!!!
  NOT work at all in output from a module thus modules must NOT emit such
  content even if "pate" is not involved, still "<nowiki>" could be useful
  in output from an old-style template, for now <nowiki> is prohibited,
  <pre> works strangely when coming from a module but we fix it
* augmented <pre> such as <pre style="overflow:auto;"> does not work
* other augmented tags don't work either
* upperCASE and malformed tags such as "<NOWIKI>" or "<nowiki  >" don't work    !!!FIXME!!!

Notes on protection:
* some char:s, most notably equal sign "=" and wall "|", are problematic
  in template calls, while particularly equal sign is common in url:s
* the traditional workarounds are parser functions {{=}} and {{!}}
  (note the exclam instead of wall in the latter) and html-dec-encoding
  "&#61;" and "&#124;"
* the MediaWiki parser has an inherent and old principle "expand and
  process from inside outwards"
* this means that for example with {{umbox|text=NO WE{{br}}CAN'T}} the outer
  template "umbox" will NOT find "{{br}}" in the incoming parameter, instead
  it gets the result of expansion such as "<br>", "(Breton)" or similar
* similar applies to some aggressive tags, for example
  {{umbox|text=There is a God|ref=<ref>The Bible</ref>}} will NOT find
  "<ref>" in the incoming parameter, instead it gets a useless strip marker,
  and the relevant text "The Bible" is gone too
* this principle is bad for "pate" and and thus we must workaround it,
  otherwise the concept of "pate" will NOT work at all
* the main workaround is to place the forwarded template call into double
  rectangular brackets: [[umbox|text=NO WE CAN'T]] for
  {{umbox|text=NO WE CAN'T}}, this "protects" walls and equal signs
  used to delimit template parameters, but not such in the content
  of those parameters, from premature expansion
* in some cases a further layer of protection must be added:
  * for nested templates such as {{umbox|text=NO WE{{br}}CAN'T}} we must
    prevent premature expansion of {{br}}, the way to do it is to write
    [[umbox|text=NO WE{({br})}CAN'T]], and let "pate" replace {({...})}
    by ordinary {{...}} after it has been smuggled in behind the back of
    the parser, the "nsm=1" or "nsm=2" parameter activates this
  * for very rarely used references in parameters, we have to do a similar
    thing, write <renef>...</renef> and let "pate" fix it back to
    <ref>...</ref>, this is activated by "nsm=1" or "nsm=2" too, this
    works even for "<ref group=" and "<ref name="
  * when forwarding broken call syntax like {{doit|}} written as [[doit|]]
    it gets victim of the "pipe trick" highly undesirable in the context,
    again, "nsm=2" helps (not "nsm=1" here), write [[{({doit|})}]]
  * with "pate" in forwarded parameters inside [[ ]] parser functions {{=}}
    and {{!}} DO NOT WORK, they give same bad result as raw "=" and "|",
    valid solutions are either "&#61;" and "&#124;", or modified {({=})}
    and {({|})} together with "nsm=1" or "nsm=2"
* with "pate" in "rem=" both parser functions {{=}} and {{!}} and
  html-dec-encoding do work

Notes on category suppression:
* All active cat insertions are carefully cut out from the output coming from
  the target, whereas links to categories such as "[[:Category:Chemistry]]"
  and commented-out cat insertions are kept. This works even for malformed
  cat insertions with wrong letter case or redundant spaces, untranslated
  prefix "Category:" on non-English wikis, and cat insertions with
  sorting hints.
* The target template should NOT use any other type of category
  suppression like the infamous "CategoryHandler", namespace detection,
  "nocat=" parameter, or similar tricks. Reasonably behaving legacy
  templates have a good chance to work with "pate", though (try the
  "ncf=1" ie "nocat=false" trick).
* Do NOT submit "nocat=" or similar into this template, neither directly, nor
  indirectly ie as the [[-]]-protected parameter or via "hid=" intended for
  target template. Doing so in any of those 3 manners (as long as the name
  is "nocat") is an error. If the "ncf=1" ie "nocat=false" trick is used
  then "nocat=false" will be sent to the target template.
* The target template still may avoid categorizing when finding itself
  on the title page, but even here there is a better way: send the
  transclusion through "pate" with "nsm=2", or through other module
  "Suppress Categories" limited to the core task category suppression.

Notes on tracking categories:
* A tracking category is there to collect pages suffering from a certain
  type of problem, or even technical feature.
* Tracking categories are separated from content categories of a wiki,
  and may be hidden, or not created ie red.
* Insertion into a tracking cat is done by MediaWiki, or by
  templates and modules.
* Usually a tracking cat is populated by pages (articles, lemmas, even
  appendixes) using a temlate in a wrong way. "pate" perfectly supports
  this use, and allows to check that the tracking categorization works
  as supposed. Then templates and modules do NOT have to bother at all
  with "nocat" nor "pate".
* Rarely there is a need for a tracking cat collecting high level templates
  using a low level template in a wrong way. This is more difficult to
  accomplish, since we do NOT want that pages using the broken high level
  template "get caught" too. "pate" has a solution for this in the form
  of "hlt=1" that sends "trackingcategorieshiglow=true" to the target
  and activate bypassing. Then the low level template must help "pate"
  in following way:
  * evaluate the parameter "trackingcategorieshiglow=true"
  * if this is NOT true, do NOT emit the tracking cat insertions
  * if this applies, then do emit the tracking cat insertions, but
    embed EVERY SINGLE CAT (of not many anyway) in:
    * <span title="bypass-pate">
    * </span>
    for example like this:
    * <span title="bypass-pate">[[Kategori:Tracking-ubx-text-too-long]]</span>
  If "hlt=1" is used then "pate" will find those markers and bypass the
  strict cat suppression, if favor of BOTH displaying the tracking cat,
  AND letting the page get caught into it, exactly as intended. This method
  is not as trivial and straightforward as one might dream of, but it is
  still the probably easiest approach, and definitely better than the legacy
  way ie "CategoryHandler" (ns detection + caller detection + whitelists +
  blackists + greylists + ...) + "nocat" + overuse of <includeonly> +
  other obscure tricks.

Notes on namespaces:
* the "Template:" namespace is the preferred one for templates
* it is possible to transclude pages in other namespaces including ns ZERO
* MediaWiki adds automatically the ns prefix "Template:" if no other
  prefix is present, for ns ZERO the title must be prefixed with an
  extra colon ":"
* "pate" supports other namespaces including ns ZERO, the extra colon
  must NOT be fed into "pate" since it is added automatically if needed
* some namespaces are prohibited by "pate", most notably "Category:" and
  "File:", they cannot be used in the anonymous and obligatory parameter,
  a violation gives #E05

Notes on references:
* templates can theoretically generate references, this is a troublesome
  habit, but there are templates that indeed do so
* for reasons hardcoded into MediaWiki, "pate" cannot detect or capture
  accumulated references, but it can let MediaWiki dump them below the
  parsed result if manually instructed to do so
* there can be several groups of references
* failure to request MediaWiki harvest the default group results in it
  being dumped at the bottom of the screen in an uncontrolled manner
* failure to request MediaWiki harvest any additional group results in
  a red error message displayed at the bottom of the screen
* the parameter "ref=" of "pate" can be used if the template generates
  references, failure to use it results in a messy output, if it is used
  then there must NOT be any accumulated references from before, parameter
  "reg=" for an additional group
* for reasons hardcoded into MediaWiki, passing the syntax <ref>...</ref>
  with a template parameter is a problem and causes a mess (strip markers),
  this can affect the target template or a possible inner nested template,
  the only solution is "nsm=1" or "nsm=2" alowing to encode both {{...}}
  and <ref>...</ref> and that way hide it from MediaWiki parser, see
  above "Notes on protection"

------------------------------------------------------------------------

### Mapping of wikitext

The mapping is performed by "lfhparsemap" and is a crucial step towards
a reliable parsing. See separate document "Mapping of wikitext". The map
essentially reveals for every position in wikitext what type of content
is located there: plain wikitext, inside wikilink of specified depth,
inside template call (not used here), inside HTML comment, inside
"nowiki", etc.

Some of such content areas are nestable:
* wikilink [[ ]]
* template call {{ }}
* template parameter {{{ }}}

Whereas others are not:
* external HTTP link [http ... ]
* nowiki
* pre
* HTML comment "<!--" ... "-->"
* ...

For the mapping following area types are defined:
* #A00 0 ordinary plain wikitext no link
* 1...9 wikilink of given depth
* #A14 14 strip marker pre nowiki ref !!!FIXME!!! not yet
* #A15 15 strip marker other
* #A17 17 "<syntaxhighlight"
* #A22 22 pre
* #A23 23 nowiki
* #A24 24 ref
* #A27 27 HTML comment "<!--" ... "-->"
* #AFF 255 invalid

Here we fully ignore:
* template call {{ ... }}
* template parameter {{{ ... }}}
* external HTTP link [http ... ]

Nested wikilinks are inherently dubious, but MediaWiki does not discourage
them sufficiently vigorously. They appear particularly in image syntax
with depth 2, and that's the limit we tolerate for ordinary links, still
a cat insertion on a level different from ONE is unacceptable. Since we
ignore template calls and template parameters, we could miscount the
levels of [[ ]], but a template generating such stuff is an error anyway.

MediaWiki will handle many types of areas and nesting in a particular
way. For example comments can get stripped off during some types of
transclusion (most notably the "frame" service "preprocess"), but kept
in other contexts (most notable dumping the content of a template
onto a wiki page by means of "subst:"). This happens irrespective
whether located inside links and cat insertions
[[Category:Chemis<!--don't-->try]] or elsewhere.

"lfhparsemap" returns a nested table containing 3 subtables:
* [0] findings ie status fields #M?? (see list below)
* [1] main map of area types
* [2] boundary map with tristate flags

The full nested table is handled by:
* lfhparsemap -- brew
* lfhtablewithmap -- read only
* lfysplitkat -- read only

Only the subtable [0] is used by:
* lfhreportfindings -- read only

Note that on error the main map and the boundary map can be incomplete
ie contain type "nil" in some positions (particularly relevant for the
main map, whereas the boundary map is full of "nil" anyway).

------------------------------------------------------------------------

### Error handling and statuses

- this module CANNOT produce insertions to a tracking category
- missing target template, or existing template returning empty or garbage
  is NOT fatal, partial results (in a table if requested) will be showed
- red error-like text coming from the target template is possible
  and considered as ordinary output

Error codes in "numerr" (order: tab= sel= tit= war= bor= mod= zer=
nsm= hid= rem= ref= reg= hlt= ncf=):
* #E01 internal
* #E02 unknown param fed din
* #E03 obviously bad anon param (some problems land in #E04 instead)
* #E04 bad use of [[ | ]] [ ] in anon param
* #E05 bad or nonstandard target title or ns (on wikipedia this typically
       results from wrong capitalization, ie "Mall:bo" instead of "Mall:Bo")
* #E06 named parameter used together with ":end"                                !!!FIXME!!! detect all
* #E07 named parameter other than sel=, tit=,                                   !!!FIXME!!! detect all
       war=, bor= used together with ":top"
* #E09 "sel=" bad
* #E10 "tit=" bad
* #E11 "war=" bad
* #E12 "bor=" bad
* #E13 "nsm=" bad
* #E14 "hid=" bad (bad char:s, ...)
* #E15 "rem=" bad (contains LF, ...)
* #E17 "mod=" bad (equal "1", ...)
* #E18 "zer=" bad (target NOT in ns ZERO)
* #E19 "hlt=" bad
* #E21 "ncf=" bad
* #E22 "ref=" "reg=" bad (both same, "reg=" without "ref=", ...)
* #E25 "sel=" conflicts with "tab=" since no raw with multi columns
* #E26 "mod=" and "zer=1" must NOT be used together
* #E29 "tab=" bad
* #E30 "trackingcategorieshiglow=" sent into "pate" in at least ONE of 3 ways
* #E31 "nocat=" sent into "pate" in at least ONE of 3 ways

Status codes from expand mm ie "arxframent:preprocess" mm in "numpexpasta":
* #X00 NOT attempted yet
* #X01 exists but expand NOT attempted yet
* #X70 success
* #X80 target (template or page) does NOT exist
* #X81 no string ie expand failure
* #X82 empty string from expansion by "arxframent:preprocess", note that
       a size of ONE is perfectly valid, no chance for a cat insertion,
       but consider for example the old template {{=}}

Status fields from parse&map done in sub "lfhparsemap" stored
in "tabpaarsemap" subtable [0]:
* [0]  #M00 mapping attempted
* [1]  #M01 unclosed inactive area (no other discovery possible)
* [2]  #M02 unclosed strip marker (impossible unless deliberately
            constructed) (no other discovery possible)
* [3]  #M03 unbalanced [[ ]] in active areas (no other discovery possible)
* [4]  #M04 strip markers (pre nowiki ref)                                      !!!FIXME!!!
* [5]  #M05 strip markers (other)
* [6]  #M06 "<syntaxhighlight" ...
* [8]  #M08 pre
* [9]  #M09 nowiki
* [10] #M10 ref
* [11] #M11 HTML comment "<!--","-->"
* [12] #M12 <includeonly>,</includeonly>,<onlyinclude>,</onlyinclude>,          !!!FIXME!!!
            <noinclude>,</noinclude> detected
* [20] #M20 max wikilink depth (counting aborts at 9->10, special value 97
            is an underflow error, and special value 98 is an overflow error)
* [22] #M22 treacherous space attached to inner side of double rectangular
            brackets "[[ " and " ]]", different from #S02

Do NOT use extraneous spaces in cat insertions:
[[Category:Crime]]    OK
[[Category: Crime]]   bad, accepted with complaint #S02
[[Category:  Crime]]  rejected by "lfysplitkat" with #S27
[[Category :Crime]]   bad, will fail to find the category
[[ Category:Crime]]   rejected by "lfhparsemap" with #M22
[[  Category:Crime]]  rejected by "lfhparsemap" with #M22
[[Category:Crime ]]   rejected by "lfhparsemap" with #M22

Do NOT put cat insertions on a level different from ONE:
[[Category:Crime]]                              OK
[[Category:Crime|Crime]]                        OK
[[CRIME|indeed [[Category:Crime]] yes we can]]  bad

Status codes from split ie "lfysplitkat" in
"numzsplitsta" ZERO OK vs 2...6 (non-fatal) vs 20...40 (fatal):
* #S00 OK
* #S02 single extra space attached after colon (still split success,
       different from #M22)
* #S03 empty cat hint "[[Category:|]]" or "[[Category:| ]]" (still split
       success, former fault apparently cannot even be created by
       ordinary wiki editing)
* #S20 split NOT attempted due to other #M06 #M09 #M12 or or #M22 !!!FIXME!!!
* #S21 split NOT attempted due to nesting #M01 #M02 #M03 #M20>2
* #S23 broken wikilink lacking left part "[[]]" or like "[[|crap]]"
* #S24 cat insertion on level different from ONE
* #S25 invalid title (empty "[[Category:]]" etc)
* #S27 more than one space "[[Category:  Crap]]" !!!FIXME!!!

------------------------------------------------------------------------

### Alignment, centering, newline-sensitivity, overlong lines

The alignment is fixed for the sake of simplicity.

The whole big table is positioned left on the screen,
outside left, CSS "margin:0.6em;" (this is top).

Text is centered in all cells of the title row
"call", "parsed", "rem", "cat", "back", "debug".

Text is theoretically centered in all content cells, but this
is later workarounded in some cells:
* in "call" an inner table outside left inside left "lfipretable"
* in "parsed" an inner <div> (NOT table) outside left inside
  left hog full width "lfilefqdivqlefqtxt"
* in "cat" an inner table only if more than 2 cat:s "lficenqtabqlefqtxt"
  via "lfhtabletohtmllist" outside center inside left, other
  text above centered
* in "debug" upper text centered, findings via "lfhtabletohtmllist"
  outside center inside left, finally lower text either "hard nowiki"
  outside center inside left, or map with table outside center
  inside many small cells

In "call" we need left alignment because this is how code is always showed.

In "parsed" we need left alignment for both text and block elements because
that is the default behaviour of wiki that we mimic there. Further we need
a newline before the generated content to make sure that "#" ":" "*" and
wikitables do work as supposed, again we mimic default behaviour. This
newline does NOT consume any vertical space due to the "single LF in HTML
is ignored" rule.

In "rem" we do NOT add any newline thus no begin-of-line-specific
rules apply.

In "cat" there is NO risk of overlong lines due to underscores "_" since
we standardize the titles by means of "lfwsplit3title" which includes
replacing of underscores by spaces.

In "debug" we can get overlong lines due to underscores "_" but this doesn't
matter since overlong lines appear there anyway an we force-break them.

------------------------------------------------------------------------

### Misc technical stuff

We do NOT use any "pairs" in this module.

Storage of parameter chains:
* Raw string such as "nope|center=YES" used in incoming anonymous
  parameter together with the name of the target, with rectangular
  brackets and adjacent whitespace later removed, equal sign is
  protected inside [[ ]] thus "{{=}}" is NOT needed.
* Simplified string "hiddendate@@1999-12-31@@hiddentime@@23:59" only
  named parameters supported (but try "1="), used in "hid=", converted
  in "lfipairxatxalt" into ordinary raw string form for expansion
  beginning with a wall.
* We do NOT use a table with parameters for a call.
* Still we must look for "trackingcategorieshiglow=" or "nocat=" and
  whine if found.
* We apply "partial preservation of trimmed whitespace" unless in the
  more/multi mode by "nsm=2". Then [[ ]] serve as replacement of {{ }}
  and we preserve ONE SPACE or ONE LF separately on every side, but NOT
  more. This is needed to preserve the arrangement of the call (see below).

For "nsm=2" ie "boo3nsm2m" following changes apply:
* column "call": the call is never linked
* column "back": backlinks are not showed, if the column is enabled
  then it will contain the standard placeholder instead
* operation:
  * [[ ]] must always be used, and do NOT serve as replacement
    of {{ }}, extra {({ })} must be used inside
  * partial preservation of trimmed whitespace does NOT apply
  * check for the existence of target is skipped, "#X80" cannot occur
  * many sanity checks skipped
  * "zer=1" does NOT work, bad old extra colon ":" must be used
  * "hid=" does NOT work
  * "hlt=1" and "ncf=1" do NOT work

Handling of ns prefixes:
* the {{-}}-syntax (indirectly used here) defaults to ns 10
  ie "Template:", other prefix still possible
* parser function "arxframent:expandTemplate" (not used
  here) defaults to ns 10 too
* unless "zer=1" we have to always add the prefix for the purpose
  of linking by means of [[-]]-syntax and backlink evaluation by
  means of "Special:WhatLinksHere"
* if "zer=1" then we must add an extra colon for the {{-}}-syntax for
  both expansion and display

The "<pre>" tag is insanely useful in plain wikitext, but behaves
inconsistently when coming from a template or module. We want it
to work for via "pate" in the rare cases when it's needed, and must
then care about it by html-dec-encoding.

Both <ref> and <references/> do NOT work in output from a module. We need
the latter only and must workaround it by "frame:extensionTag".

Link to the target template is showed without a possible default "Template:"
prefix, other prefixes are visible, even if template not found. Internal
structure of the link:
* a) "[[" (not visible, do NOT encode)
* b) name of the template always with prefix (not visible, link target)
* c) wall "|" (not visible, do NOT encode)
* d) "{{" (visible) (works without encoding)
* e) name of the template without default prefix + parameter chain (visible)
* f) "}}" (visible) (works without encoding)
* g) "]]" (not visible, do NOT encode)
Note that the HTML parser can split the string into multiple lines
(or more lines than requested by EOL:s) if there are spaces in                  !!!FIXME!!! EOL to <br> and underscore to space
but not if underscores "_" are used instead.

Encoding of text:
* For backlinks and redirects we have to urlencode the parameter,
  "lfwbrew3url" with help of "{{canonicalurl:...}}" does encode the
  service page "Special:WhatLinksHere" but the target parameter
  must be encoded separately by "mw.uri.encode".
* For the call column, we must preserve the layout of preformatted text
  and block all parsing, but we want to have all the stuff in a link to the
  template, with optionally reduced font size, "lfidecencodbr" does the
  encoding natively blocking all wikilink parsing, HTML tag parsing and HTML
  entity parsing, output from it must be placed into a special inner table
  (see below) ensuring monospace.
* For the output column, we disallow "<nowiki>" and "<syntaxhighlight
  lang="text">" in content coming from the template, further we need special
  handling for "<pre>" where we must encode all "[" "]" "&" to prevent parsing
  of wikilinks (this phenomenon may indeed occur in some cases) and HTML
  entities. Cat insertions inside areas poorly inactivated by "<pre>" are NOT
  caught, they are fixed by encoding in "lfysplitkat" instead.
* For the debug column, we must avoid any parsing, and make spaces, LF:s and
  broken char:s visible, "lfiultencode" provides this natively.

There are several possible ways to display monospaced preformatted text:
* "<pre>" (NOT used for the call)
  + nice appearance with box
  + simple syntax
  - aggressive high-priority tag with inconsistent and dangerous
    behaviour when coming from a template, can cause strip markers
* "<code><nowiki>" (NOT used for the call)
  + less aggressive tag
  + can be combined with "<small>"
  + can be placed into a link
  - "<nowiki>" does not work when coming from a template, still can
    cause strip markers
  - needs manual fixing of spaces and LF:s
  - bad appearance for multiline text, particularly if it
    contains empty lines, no box
* do all manually, use a HTML table for the box (used here for the call)
  + nice appearance with box
  + no aggressive or dangerous tags
  + can vary text size
  + can be placed into a link
  - needs manual fixing of spaces and LF:s
  - needs complicated HTML+CSS

There are several imaginable ways to submit a call to a target
template into a calling proxy ie "pate". None of them is perfect,
and none of them will support plain nested template calls.
* submit target as an anonymous parameter followed by forwarded
  parameters and seize them by "pairs" (NOT used)
  + nice syntax, no extra brackets
  - sortorder of parameters NOT preserved
  - formatting of the call NOT preserved
  - needs some "ultrahidden" parameters for submitting instructions
    into the calling proxy
  - nested template calls will not work and cannot be supported
* complete call protected by rectangular brackets (used here)
  + fairly nice syntax, only 4 extra brackets [[ ]]
  + sortorder of parameters preserved
  + formatting of the call preserved
  + nested template calls can be supported with a workaround
  - syntax is a bit strange with a faked wikilink

There are several ways how to expand a template:
* arxframent:expandTemplate (eats title + table, adds ns prefix, crashes
  on the spot if template does not exist) (NOT used)
* arxframent:preprocess (eats raw string, adds ns prefix if {{ }} is used,
  does NOT work with substitution but this doesn't really matter here)
  (used here)
Note that above methods for expanding a template are NOT expensive whereas
wiki's native "ifexist" and LUA's "getContent()" are. Unfortunately we have
to expand two times, but both are free. In order to get free "ifexist" we
need "msgnw:", but for the main work we must avoid "msgnw:".
Another problem are strip markers deeply buried in the design of MediaWiki.
Some aggressive tags such as <pre> and <nowiki> in a classic template being
expanded result in strip markers, whereas this does NOT occur if a module
generates such content. The function "mw.text.unstrip" is inherently useless
since it returns raw text for <nowiki> (with the tags removed), and a
completely empty string in all other cases including <pre>.

------------------------------------------------------------------------

### Arrangements

There are several useful styles to arrange template calls.

Inline compact:
  {{doall|now|priority=urgent}}

Inline with spaces:
  {{ doall | now | priority = urgent }}

Multiline with spaces:
  {{ taxobox
  | domain = none
  | kingdom = fungi
  | phylum = unknown
  }}

Chess:
  {{chessboard
  |--|--|--|--|kd|--|--|rd
  |--|--|--|--|--|--|--|--
  |--|--|--|--|--|bl|--|pl
  |--|--|--|rl|--|kl|pd|pl
  |--|--|--|--|--|--|--|--
  |--|--|--|--|--|--|--|--
  |--|--|--|--|--|--|--|--
  |--|--|--|--|--|--|--|--
  |btm = deliver checkmate in two moves
  }}

We do NOT really bother, and keep the complete call to the target template
as-is except replacing outer [[ ]] by {{ }}. We must, however, isolate
the target title (since we link to it in various ways), and strip
all possible whitespace around it.

------------------------------------------------------------------------

### Examples of usage

Two templates (by default tab=2 and sel=111-110):
  {{pate|:top}}
  {{pate|hr3}}
  {{pate|hr4}}
  {{pate|:end}}

Two templates with manually selected some columns (by default tab=2):
  {{pate|sel=110-110|:top}}
  {{pate|sel=110-110|hr3}}
  {{pate|sel=110-110|hr4}}
  {{pate|:end}}

Two templates with manually selected all columns (by default tab=2):
  {{pate|sel=111-111|:top}}
  {{pate|sel=111-111|hr3}}
  {{pate|sel=111-111|hr4}}
  {{pate|:end}}

One template suboptimal way horizontal table (by default tab=2):
  {{pate|sel=110-100|:top}}
  {{pate|sel=110-100|Pengguna transportasi publik}}
  {{pate|:end}}

One template better way horizontal table:
  {{pate|tab=3|sel=110-100|Pengguna transportasi publik}}

One template better way horizontal table without title row:
  {{pate|tab=4|sel=110-100|Pengguna transportasi publik}}

One template better way vertical table (no way to show multiple templates):
  {{pate|tab=5|sel=110-100|Pengguna transportasi publik}}

One template minimal use no table, used only to suppress
categorization (tab=0 brings default sel=010-000):
  {{pate|tab=0|Pengguna transportasi publik}}

One template reduced output show only parsed result and categories:
  {{pate|tab=3|sel=010-100|Pengguna transportasi publik}}

One template reduced output show only parsed result
and categories, and without title row:
  {{pate|tab=4|sel=010-100|Pengguna transportasi publik}}

Two different calls to one template with custom title (by default tab=2):
  {{pate|sel=110-111|:top|tit=CALL@@PARSED@@REM@@CAT@@BACK-LINKS@@DEBUG}}
  {{pate|sel=110-111|[[ambox|text=this is a test|bgcolor=FF8080]]}}
  {{pate|sel=110-111|[[ambox|text=this is a test|bgcolor=#FF8080]]|rem=invalid usage}}
  {{pate|:end}}

One template suboptimal way horizontal table small text (by default tab=2):
  {{pate|sel=111-000|:top}}
  {{pate|sel=211-000|[[
    taxobox
    | domain = none
    | kingdom = fungi
    | phylum = unknown
  ]]}}
  {{pate|:end}}

One template better way horizontal table small text:
  {{pate|tab=3|sel=211-000|[[
    taxobox
    | domain = none
    | kingdom = fungi
    | phylum = unknown
  ]]}}

* make sure to use same value for "sel=" for the ":top" call and
  all core calls below it
* do NOT feed "tab=" or "sel=" into the final ":end" call
* make sure to use the colon in ":top" and ":end", this convention allows
  to call templates named "top" and "end"
* the order of named parameters relative to each other and to the only
  anonymous parameter technically does not matter, but the style above
  with "tab=" and "sel=" preceding the big anonymous parameter and all other
  named parameters following it is strongly encouraged for best readability

------------------------------------------------------------------------

]===]

local exporttable = {}

------------------------------------------------------------------------

---- CONSTANTS [O] ----

------------------------------------------------------------------------

  -- uncommentable constant strings (lang and core site-related features)

  -- local constrpriv = "en"                   -- EN (privileged site language) !!!FIXME!!! peek this
  local constrpriv = "eo"                   -- EO (privileged site language)
  -- local constrpriv = "id"                   -- ID (privileged site language)
  -- local constrpriv = "sv"                   -- SV (privileged site language)

  local constrprli = "Special:WhatLinksHere" -- EN worx everywhere (must NOT end with a blackslash, must NOT be urlencoded)

  -- uncommentable constant table (error messages)                              !!!FIXME!!! incomplete and no "constrkoll" yet

  -- #E02...#E99, holes permitted
  -- note that #E00 and #E01 are NOT supposed to be included here

  local contaberaroj = {}
  -- contaberaroj[ 2] = 'Unknown parameter'                                     -- EN #E02 !!!FIXME!!! incomplete
  contaberaroj[ 2] = 'Nekonata parametro'                                    -- EO #E02
  -- contaberaroj[ 2] = 'Parameter tidak dikenal'                               -- ID #E02
  -- contaberaroj[ 2] = 'Ok\aend parameter'                                     -- SV #E02
  -- contaberaroj[ 3] = 'Bad anonymous parameter'                               -- EN #E03
  contaberaroj[ 3] = 'Erara anonima parametro'                               -- EO #E03
  -- contaberaroj[ 3] = 'Parameter anonim salah'                                -- ID #E03
  -- contaberaroj[ 3] = 'Felaktig anonym parameter'                             -- SV #E03
  -- contaberaroj[ 4] = 'Wrong use of [[ | ]] in anonymous parameter'           -- EN #E04
  contaberaroj[ 4] = 'Erara uzo de [[ | ]] en anonima parametro'             -- EO #E04
  -- contaberaroj[ 4] = 'Penggunaan [[ | ]] salah dalam parameter anonim'       -- ID #E04
  -- contaberaroj[ 4] = 'Felaktig anv\\aendning av [[ | ]] i anonym parameter'  -- SV #E04
  -- contaberaroj[ 5] = 'Bad or nonstandard target title or namespace'             -- EN #E05
  contaberaroj[ 5] = 'Erara aux nestandarda cela titolo aux nomspaco'           -- EO #E05
  -- contaberaroj[ 5] = 'Judul atau ruang nama sasaran salah atau takbaku'         -- ID #E05
  -- contaberaroj[ 5] = 'Felaktig eller icke-standardiserad titel eller namnrymd'  -- SV #E05
  -- contaberaroj[ 9] = '"sel=" bad'                                               -- EN #E09
  contaberaroj[ 9] = '"sel=" erara'                                             -- EO #E09
  -- contaberaroj[ 9] = '"sel=" salah'                                             -- ID #E09
  -- contaberaroj[25] = '"sel=" conflicts with "tab="'      -- EN #E25
  contaberaroj[25] = '"sel=" konfliktas kun "tab="'      -- EO #E25
  -- contaberaroj[25] = '"sel=" tidak sesuai dengan "tab="' -- ID #E25

  -- constant strings (error circumfixes)

  local constrelabg = '<span class="error"><b>'  -- lagom whining begin
  local constrelaen = '</b></span>'              -- lagom whining end
  local constrlaxhu = '&nbsp;&#42;&#42;&nbsp;'   -- lagom -> huge circumfix " ** "

  -- uncommentable constant strings (messages)

  local constrbalik = "Backlinks<br>Ligioj cxi tien"  -- EO
  -- local constrbalik = "Backlinks<br>Pranala balik"    -- ID
  local constrredir = "Redirects<br>Alidirektiloj"    -- EO
  -- local constrredir = "Redirects<br>Pengalihan"       -- ID

  -- local constrca3d = "(no category)"            -- EN
  local constrca3d = "(ne estas kategorio)"     -- EO
  -- local constrca3d = "(tidak ada kategori)"     -- ID
  -- local constrca3d = "(ingen kategori)"         -- SV
  local constrca4d = "Eniras"                   -- EO
  -- local constrca4d = "Masuk ke"                 -- ID
  -- local constrca4d = "Fastnar i"                -- SV
  local constrca5d = "kategoriojn"              -- EO
  -- local constrca5d = "kategori"                 -- ID
  -- local constrca5d = "kategorier"               -- SV

  -- default column names (short, always English, one bare word)

  local contabcolumns = {[0]="call","parsed","rem","cat","back","debug"} -- [0]...[5] see "lfhatmergetab"

  -- cell background colors (2 or 6 hex digits) for "lfhtablewithmap" only

  local contabbk = {}
  contabbk[ 0] = "FF"     -- white no link
  contabbk[ 1] = "E9"     -- -22 grey
  contabbk[ 2] = "D4"     -- -21 grey
  contabbk[ 3] = "C4"     -- -16 grey
  contabbk[ 4] = "B4"     -- -16 grey
  contabbk[ 5] = "A8"     -- -12 grey
  contabbk[ 6] = "9C"     -- -12 grey
  contabbk[ 7] = "92"     -- -10 grey
  contabbk[ 8] = "88"     -- -10 grey
  contabbk[ 9] = "7E"     -- -10 grey
  contabbk[15] = "FF7070" -- deep red strip markers
  contabbk[16] = "FF8000" -- orange nowiki
  contabbk[17] = "C06090" -- violet syntaxhighlight
  contabbk[22] = "2020FF" -- blue pre
  contabbk[23] = "20FF20" -- green comment

  -- uncommentable constant strings (more messages, #M00 omitted here, for "lfiexplain" only)

  local contabxxplain = {}
  -- contabxxplain ['#X80'] = 'target (template or page) does NOT exist'     -- EN
  contabxxplain ['#X80'] = 'celo (sxablono aux pagxo) NE ekzistas'        -- EO
  -- contabxxplain ['#X80'] = 'sasaran (templat atau halaman) TIDAK ada'     -- ID
  -- contabxxplain ['#X82'] = 'empty string from expansion'                  -- EN
  contabxxplain ['#X82'] = 'maplena signocxeno el ekspando'               -- EO
  -- contabxxplain ['#X82'] = 'string kosong dari ekspansi'                  -- ID
  -- contabxxplain ['#M01'] = 'unclosed inactive area'                       -- EN
  contabxxplain ['#M01'] = 'nefermita neaktiva areo'                      -- EO
  -- contabxxplain ['#M01'] = 'wilayah nonaktif tidak ditutup'               -- ID
  contabxxplain ['#M02'] = 'unclosed strip marker'
  contabxxplain ['#M03'] = 'unbalanced [[ ]] in active areas'
  contabxxplain ['#M04'] = 'strip markers (pre nowiki ref)'
  contabxxplain ['#M05'] = 'strip markers (other)'
  contabxxplain ['#M06'] = 'syntaxhighlight'
  contabxxplain ['#M08'] = 'pre'
  contabxxplain ['#M09'] = 'nowiki'
  contabxxplain ['#M10'] = 'ref'
  contabxxplain ['#M11'] = 'HTML comment'
  contabxxplain ['#M12'] = '<includeonly> et al'
  contabxxplain ['#M20'] = 'max wikilink depth' -- follows number
  contabxxplain ['#M22'] = 'treacherous space'
  contabxxplain ['#S20'] = 'split not attempted due to other'             -- EN
  contabxxplain ['#S21'] = 'split not attempted due to nesting'           -- EN
  contabxxplain ['#S23'] = 'broken wikilink lacking left part'            -- EN
  contabxxplain ['#S24'] = 'cat insertion on level different from ONE'    -- EN

  -- for "lfiultencode" only

  local constrpilen = '[[File:Return arrow.svg|20px|link=]]' -- the file is Public Domain
  local contabempatwarna = {[0]='FFA0A0','D0FFD0','A0A0FF','D0D0D0'} -- red, light green, blue, light grey

  -- prohibited stuff -- see above under "Limitations and caveats" why          !!!FIXME!!! unused

  local tabprohi = {[0]="<includeonly>","</includeonly>","<noinclude>","</noinclude>"}

  -- constant LUA tables for HTML tables with CSS

  local contabtabeg = {[0]='<table style="margin:0.6em;border:0.','em solid #',';border-collapse:collapse;">'} -- [0]...[2]
  local contabtdbeg = {[0]='<td style="border:0.','em solid #',';padding:0.5em;text-align:center;">'} -- [0]...[2]

  -- surrogate transcoding table (only needed for EO)

  local contabtransluteo = {}
  contabtransluteo[ 67] = 0xC488 -- CX
  contabtransluteo[ 99] = 0xC489 -- cx
  contabtransluteo[ 71] = 0xC49C -- GX
  contabtransluteo[103] = 0xC49D -- gx
  contabtransluteo[ 74] = 0xC4B4 -- JX
  contabtransluteo[106] = 0xC4B5 -- jx
  contabtransluteo[ 83] = 0xC59C -- SX
  contabtransluteo[115] = 0xC59D -- sx
  contabtransluteo[ 85] = 0xC5AC -- UX breve
  contabtransluteo[117] = 0xC5AD -- ux breve

  -- surrogate transcoding table (only needed for SV)

  local contabtranslutsv = {}
  contabtranslutsv['AA'] = 0xC385 -- Aring
  contabtranslutsv['Aa'] = 0xC385 -- Aring
  contabtranslutsv['aa'] = 0xC3A5 -- aring
  contabtranslutsv['AE'] = 0xC384
  contabtranslutsv['Ae'] = 0xC384
  contabtranslutsv['ae'] = 0xC3A4
  contabtranslutsv['EE'] = 0xC389 -- rarely used
  contabtranslutsv['Ee'] = 0xC389 -- rarely used
  contabtranslutsv['ee'] = 0xC3A9 -- rarely used
  contabtranslutsv['OE'] = 0xC396
  contabtranslutsv['Oe'] = 0xC396
  contabtranslutsv['oe'] = 0xC3B6

  -- constant strings (misc)

  local constrempt = '--' -- placeholder for empty table cell "rem=" or "back"

  -- math constants and boolean switches

  local contabboo2int = {[false]=0,[true]=1}
  local contabboo2siz = {[false]='100',[true]='70'}

------------------------------------------------------------------------

---- SPECIAL STUFF OUTSIDE MAIN [B] ----

------------------------------------------------------------------------

  -- SPECIAL VAR:S

local qbooguard = false  -- only for the guard test, pass to other var ASAP
local qstrtabegin = ''   -- from "contabtabeg" added col & wi, begin of table
local qstrtdbegin = ''   -- from "contabtdbeg" added col & wi, begin of cell
local qstrtdendus = ''   -- end of cell
local qstrtaendus = ''   -- end of table
local qtabmy6columns = {} -- based on "contabcolumns" used in "lficondicelrow"

  -- GUARD AGAINST INTERNAL ERROR

qbooguard = ((type(constrpriv)~='string') or (type(constrprli)~='string'))

------------------------------------------------------------------------

---- MATH FUNCTIONS [E] ----

------------------------------------------------------------------------

local function mathintrange (numinpoot, numzmin, numzmax)
  numinpoot = math.floor (numinpoot) -- no transcendental
  numinpoot = math.max (numinpoot,numzmin) -- not below minimum
  numinpoot = math.min (numinpoot,numzmax) -- no trillions
  return numinpoot -- same var for input and output
end--function mathintrange

local function mathdiv (xdividens, xdivisero)
  local resultdiv = 0 -- DIV operator lacks in LUA :-(
  resultdiv = math.floor (xdividens / xdivisero)
  return resultdiv
end--function mathdiv

local function mathmod (xdividendo, xdivisoro)
  local resultmod = 0 -- MOD operator is "%" and bitwise AND operator lack too
  resultmod = xdividendo % xdivisoro
  return resultmod
end--function mathmod

------------------------------------------------------------------------

-- Local function MATHBITTEST

-- Find out whether single bit selected by ZERO-based index is "1" / "true".

-- Result has type "boolean".

-- Depends on functions :
-- [E] mathdiv mathmod

local function mathbittest (numincoming, numbitindex)
  local boores = false
  while true do
    if ((numbitindex==0) or (numincoming==0)) then
      break -- we have either reached our bit or run out of bits
    end--if
    numincoming = mathdiv(numincoming,2) -- shift right
    numbitindex = numbitindex - 1 -- count down to ZERO
  end--while
  boores = (mathmod(numincoming,2)==1) -- pick bit
  return boores
end--function mathbittest

------------------------------------------------------------------------

---- NUMBER CONVERSION FUNCTIONS [N] ----

------------------------------------------------------------------------

-- Local function LFDEC1DIGIT

-- Convert 1 decimal ASCII digit to integer 0...9 (255 if invalid).

local function lfdec1digit (num1digit)
  num1digit = num1digit - 48 -- may become invalid
  if ((num1digit<0) or (num1digit>9)) then
    num1digit = 255 -- report ERROR on invalid input digit
  end--if
  return num1digit
end--function lfdec1digit

------------------------------------------------------------------------

-- Local function LFSTRONDIG2INT

-- Convert string with 1 decimal ASCII digit
-- to integer 0...9 (255 if invalid).

-- Depends on functions :
-- [N] lfdec1digit

local function lfstrondig2int (strmasukk)
  local numalone = 255 -- preASSume guilt
  if (string.len(strmasukk)==1) then
    numalone = string.byte (strmasukk,1,1)
    numalone = lfdec1digit (numalone) -- 255 if invalid, ZERO would be valid
  end--if
  return numalone
end--function lfstrondig2int

------------------------------------------------------------------------

-- Local function LFSTRTWDIG2INT

-- Convert string with always 2 decimal ASCII digit:s
-- to integer 0...99 (255 if invalid).

-- Depends on functions :
-- [N] lfdec1digit

local function lfstrtwdig2int (strmasuuk)
  local numleft = 255 -- preASSume guilt
  local numrayt = 0
  if (string.len(strmasuuk)==2) then
    numleft = string.byte (strmasuuk,1,1)
    numleft = lfdec1digit (numleft) -- 255 if invalid, ZERO would be valid
    numrayt = string.byte (strmasuuk,2,2)
    numrayt = lfdec1digit (numrayt) -- 255 if invalid, ZERO would be valid
    if (numrayt==255) then
      numleft = 255 -- 255 is invalid, note that ZERO would be valid
    else
      numleft = numleft * 10 + numrayt -- valid integer number 0...99 now
    end--if
  end--if
  return numleft
end--function lfstrtwdig2int

------------------------------------------------------------------------

-- Local function LFNONEHEXTOINT

-- Convert single quasi-digit (ASCII HEX "0"..."9" "A"..."F") to
-- integer (0...15, 255 invalid).

-- Only uppercase accepted.

local function lfnonehextoint (numdigit)
  local numresult = 255
  if ((numdigit>47) and (numdigit<58)) then
    numresult = numdigit-48
  end--if
  if ((numdigit>64) and (numdigit<71)) then
    numresult = numdigit-55
  end--if
  return numresult
end--function lfnonehextoint

------------------------------------------------------------------------

-- Local function LFNUMTO2DIGIT

-- Convert integer 0...99 to decimal ASCII string always 2 digits "00"..."99".

-- Depends on functions :
-- [E] mathdiv mathmod mathintrange

local function lfnumto2digit (numzerotoninetynine)
  local strtwodig = '??' -- always 2 digits
  if (mathintrange(numzerotoninetynine,0,99)==numzerotoninetynine) then
    strtwodig = tostring(mathdiv(numzerotoninetynine,10)) .. tostring(mathmod(numzerotoninetynine,10))
  end--if
  return strtwodig
end--function lfnumto2digit

------------------------------------------------------------------------

-- Local function LFUINT8TOHEX

-- Convert UINT8 (0...255) to a 2-digit hex string.

-- Depends on functions :
-- [E] mathdiv mathmod

local function lfuint8tohex (numinclow)
  local strheksulo = ''
  local numhajhaj = 0
  numhajhaj = mathdiv (numinclow,16)
  numinclow = mathmod (numinclow,16)
  if (numhajhaj>9) then
    numhajhaj = numhajhaj + 7 -- now 0...9 or 17...22
  end--if
  if (numinclow>9) then
    numinclow = numinclow + 7 -- now 0...9 or 17...22
  end--if
  strheksulo = string.char (numhajhaj+48) .. string.char (numinclow+48)
  return strheksulo
end--function lfuint8tohex

------------------------------------------------------------------------

---- LOW LEVEL STRING FUNCTIONS [G] ----

------------------------------------------------------------------------

-- test whether char is an ASCII digit "0"..."9", return boolean

local function lfgtestnum (numkaad)
  local boodigit = false
  boodigit = ((numkaad>=48) and (numkaad<=57))
  return boodigit
end--function lfgtestnum

------------------------------------------------------------------------

-- test whether char is an ASCII uppercase letter, return boolean

local function lfgtestuc (numkode)
  local booupperc = false
  booupperc = ((numkode>=65) and (numkode<=90))
  return booupperc
end--function lfgtestuc

------------------------------------------------------------------------

-- test whether char is an ASCII lowercase letter, return boolean

local function lfgtestlc (numcode)
  local boolowerc = false
  boolowerc = ((numcode>=97) and (numcode<=122))
  return boolowerc
end--function lfgtestlc

------------------------------------------------------------------------

-- Local function LFGIS62SAFE

-- Test whether incoming ASCII char is very safe (0...9 A...Z a...z).

-- Depends on functions :
-- [G] lfgtestnum lfgtestuc lfgtestlc

local function lfgis62safe (numcxair)
  local booguud = false
  booguud = lfgtestnum (numcxair) or lfgtestuc (numcxair) or lfgtestlc (numcxair)
  return booguud
end--function lfgis62safe

------------------------------------------------------------------------

-- Local function LFGTRIMWHITE

-- Input  : * strputihsekali -- string, empty tolerable, but type "nil" is NOT

local function lfgtrimwhite (strputihsekali)
  local numtrimthemall = 0
  local boodonenow = false
  while true do
    if (strputihsekali=='') then
      break
    end--if
    boodonenow = true
    numtrimthemall = string.byte(strputihsekali,1,1)
    if ((numtrimthemall==32) or (numtrimthemall==10)) then
      strputihsekali = string.sub (strputihsekali,2,-1)
      boodonenow = false
    end--if
    numtrimthemall = string.byte(strputihsekali,-1,-1)
    if ((numtrimthemall==32) or (numtrimthemall==10)) then
      strputihsekali = string.sub (strputihsekali,1,-2)
      boodonenow = false
    end--if
    if (boodonenow) then
      break
    end--if
  end--while
  return strputihsekali -- same var for input and output
end--function lfgtrimwhite

------------------------------------------------------------------------

-- Local function LFGDELETEALLWHITE

local function lfgdeleteallwhite (strin52in)
  local strut52ut = ''
  local numlen52len = 0
  local numind52ind = 0
  local numchr52chr = 0
  numlen52len = string.len(strin52in)
  while true do -- genuine loop
    if (numind52ind>=numlen52len) then
      break
    end--if
    numchr52chr = string.byte(strin52in,(numind52ind+1),(numind52ind+1))
    if ((numchr52chr~=10) and (numchr52chr~=32)) then
      strut52ut = strut52ut .. string.char(numchr52chr)
    end--if
    numind52ind = numind52ind + 1
  end--while
  return strut52ut
end--function lfgdeleteallwhite

------------------------------------------------------------------------

---- UTF8 FUNCTIONS [U] ----

------------------------------------------------------------------------

-- Local function LFULNUTF8CHAR

-- Evaluate length of a single UTF8 char in octet:s.

-- Input  : * numbgoctet  -- beginning octet of a UTF8 char

-- Output : * numlen1234x -- number 1...4 or ZERO if invalid

-- Does NOT thoroughly check the validity, looks at 1 octet only.

local function lfulnutf8char (numbgoctet)
  local numlen1234x = 0
    if (numbgoctet<128) then
      numlen1234x = 1 -- $00...$7F -- ANSI/ASCII
    end--if
    if ((numbgoctet>=194) and (numbgoctet<=223)) then
      numlen1234x = 2 -- $C2 to $DF
    end--if
    if ((numbgoctet>=224) and (numbgoctet<=239)) then
      numlen1234x = 3 -- $E0 to $EF
    end--if
    if ((numbgoctet>=240) and (numbgoctet<=244)) then
      numlen1234x = 4 -- $F0 to $F4
    end--if
  return numlen1234x
end--function lfulnutf8char

------------------------------------------------------------------------

---- HIGH LEVEL STRING FUNCTIONS [I] ----

------------------------------------------------------------------------

-- Local function LFIDECENCODBR

-- Moderately encode char:s to prevent parsing (all wikilink parsing, HTML tag
-- parsing, HTML entity parsing), and optionally apply special treatment to
-- LF:s turning them into <br> as well as to spaces preventing reduction. This
-- is intended for showing sane UTF8 text, NOT for debugging purposes.

-- Input  : * strinkkkkin -- string, empty tolerable, but type "nil" is NOT
--          * boopreformat -- true for special treatment preserving
--                            preformatted text

-- Output : * strbrbrcod -- string, empty in worst case

local function lfidecencodbr (strinkkkkin, boopreformat)

  local strwanchar = ''
  local strbrbrcod = ''
  local numsrtlen = 0
  local numpekkinx = 1 -- ONE-based index
  local numchmuar = 0
  local boonbtp = true -- "true" needed for junk lines containing only space

  numsrtlen = string.len (strinkkkkin)

  while true do -- outer genuine loop
    if (numpekkinx>numsrtlen) then
      break
    end--if
    numchmuar = string.byte (strinkkkkin,numpekkinx,numpekkinx)
    numpekkinx = numpekkinx + 1
    while true do -- inner fake loop
      if (numchmuar==9) then
        numchmuar = 32 -- TAB to SPACE always
      end--if
      if ((numchmuar==10) and boopreformat) then -- special treatment
        strwanchar = '<br>'
        boonbtp = true -- "true" needed for junk lines containing only space
        break
      end--if
      if ((numchmuar==32) and boopreformat) then -- special treatment
        if (boonbtp) then
          strwanchar = '&nbsp;' -- this prevents space reduction
        else
          strwanchar = ' '
        end--if
        boonbtp = not boonbtp
        break
      end--if
      if ((numchmuar==10) or (numchmuar==32) or (numchmuar>127)) then
        strwanchar = string.char (numchmuar) -- pass LF SPACE UTF8 untouched
        break
      end--if
      if (numchmuar<32) then
        numchmuar = 63 -- filter away crap to "?" -- then encode it below
      end--if
      strwanchar = '&#' .. tostring (numchmuar) .. ';' -- encode all ASCII
      break -- finally to join mark
    end--while -- inner fake loop -- join mark
    strbrbrcod = strbrbrcod .. strwanchar
  end--while -- outer genuine loop

  return strbrbrcod

end--function lfidecencodbr

------------------------------------------------------------------------

-- Local function LFIULTENCODE

-- Generously encode char:s to prevent parsing and show hex if needed, make
-- single chars visible, bypass all wiki parsing and HTML parsing. Our cool
-- module has brewed something with "[["..."]]" and repeated spaces but we
-- want to see plain text for debugging purposes. Thus we dec-encode some
-- char:s, use NBSP to fix spaces, workaround EOL, and maybe add colour.

-- Input  : * strkrampuj  : string, empty tolerable, but type "nil" is NOT
--          * nummxwidth  : maximal width of text (20...200, default 80)
--          * boowarrna   : "true" to enable color
--          * boosplitutf : "true" to split UTF8 char:s into hex numbers

-- Output : * strkood     : string, empty in worst case

-- Depends on functions :
-- [U] lfulnutf8char
-- [G] lfgtestnum lfgtestuc lfgtestlc lfgis62safe
-- [N] lfuint8tohex
-- [E] mathdiv mathmod

-- Depends on constants :
-- * string constrpilen [[File:...]]
-- * table contabempatwarna 0...3

-- This helps with:
-- * "[["..."]]", "["..."]", "*", "#", ":" (note that there is no
--   problem with plain "{{"..."}}")
-- * multiple spaces (they are no longer reduced to one piece due to HTML)
-- * EOL:s (they do not vanish in favor of spaces due to HTML, instead
--   the EOL arrow is showed)
-- * too long lines (they are force-broken)
-- * codes below 32 other than EOL

-- There is also "mw.text.nowiki" with some limitations, most notably
-- about multiple spaces and EOL:s.

-- In order to fix EOL we show the EOL arrow (preceded by space) for every
-- incoming LF, but do a "<br>" only once after multiple subsequent LF:s.

-- We must be UTF8-aware. A UTF8 char must be either split into hex codes,
-- or preserved over its complete length ie not split nor encoded at all.

-- Note that this causes BLOAT. The caller is responsible for
-- adding "<big>"..."</big>" if desired.

local function lfiultencode (strkrampuj,nummxwidth,boowarrna,boosplitutf)

  local stronechar = ''
  local strkolorr = ''
  local strkood = ''
  local numstrlne = 0
  local numpeekynx = 1 -- ONE-based index
  local numcahr = 0
  local numcxxhr = 0
  local numutf8len = 0
  local numaccuwidth = 0 -- accumulated width
  local numcolour = 0 -- 0,1,2,3 -- R,G,B,Y
  local boonbsp = true -- "true" needed for junk lines containing only space
  local boosplnow = false -- allow forced split in some cases
  local boofickpilen = false -- true after LF arrow causes "<br>" later

  if (type(nummxwidth)~='number') then
    nummxwidth = 80
  end--if
  if ((nummxwidth<20) or (nummxwidth>200)) then
    nummxwidth = 80
  end--if
  numstrlne = string.len (strkrampuj)

  while true do -- outer genuine loop

    if (numpeekynx>numstrlne) then
      break
    end--if
    numcahr = string.byte (strkrampuj,numpeekynx,numpeekynx)
    numpeekynx = numpeekynx + 1 -- ONE-based index

    while true do -- inner fake loop
      if (numcahr==10) then
        break -- to join mark -- inner fake loop -- special processing for LF
      end--if
      if (numcahr==32) then
        if (boonbsp) then
          stronechar = '&nbsp;' -- this prevents space reduction
        else
          stronechar = ' '
        end--if
        boonbsp = not boonbsp
        break -- to join mark -- inner fake loop
      end--if
      if (numcahr<32) then
        stronechar = '{$' .. lfuint8tohex (numcahr) .. '}' -- always as hex
        break -- to join mark -- inner fake loop
      end--if
      if (numcahr>127) then
        boosplnow = boosplitutf
        numutf8len = lfulnutf8char (numcahr)
        if (numutf8len==0) then
          boosplnow = true -- forced split for broken UTF8 sequence
        else
          numutf8len = numutf8len - 1 -- more char:s to pick
        end--if
        if ((numpeekynx+numutf8len)>(numstrlne+1)) then
          boosplnow = true -- forced split for truncated UTF8 sequence
        end--if
        if (boosplnow) then
          stronechar = '{$' .. lfuint8tohex (numcahr) .. '}'
        else
          stronechar = string.char (numcahr) -- preserve "numcahr" below
          while true do -- deep loop copy UTF8 char
            if (numutf8len==0) then
              break
            end--if
            numcxxhr = string.byte (strkrampuj,numpeekynx,numpeekynx)
            numpeekynx = numpeekynx + 1
            numutf8len = numutf8len - 1
            stronechar = stronechar .. string.char (numcxxhr)
          end--while -- deep loop copy UTF8 char
        end--if
        break -- to join mark
      end--if (numcahr>127) then
      if (lfgis62safe(numcahr)) then -- safe ASCII ie 0...9 A...Z a...z
        stronechar = string.char (numcahr) -- do NOT encode safe char:s
        break -- to join mark
      end--if
      stronechar = '&#' .. tostring (numcahr) .. ';' -- dec-encode some ASCII
      break -- finally to join mark
    end--while -- inner fake loop -- join mark

    if (numcahr==10) then
      if (numaccuwidth>=nummxwidth) then
        strkood = strkood .. '<br>'
        numaccuwidth = 0
        boonbsp = true -- "true" needed for junk lines containing only space
      end--if
      strkood = strkood .. '&nbsp;' .. constrpilen
      numaccuwidth = numaccuwidth + 2 -- counts doubly
      boofickpilen = true
    else
      if (boofickpilen or (numaccuwidth>=nummxwidth)) then
        strkood = strkood .. '<br>'
        numaccuwidth = 0
        boonbsp = true -- "true" needed for junk lines containing only space
      end--if
      if (boowarrna) then
        strkolorr = contabempatwarna [numcolour]
        numcolour = mathmod ((numcolour+1),4) -- index 0...3
        strkood = strkood .. '<span style="background-color:#' .. strkolorr .. ';">' .. stronechar .. '</span>'
      else
        strkood = strkood .. stronechar
      end--if
      numaccuwidth = numaccuwidth + 1
      boofickpilen = false
    end--if (numcahr==10) else

  end--while -- outer genuine loop

  return strkood

end--function lfiultencode

------------------------------------------------------------------------

-- Local function LFISPACUNDR !!!FIXME!!! unused -- column "call" ??

-- Spaces to underscores or vice-versa.

-- Incoming boolean "true" for underscores and "false" for spaces.

local function lfispacundr (strxxin, boounderlig)
  local numleang = 0
  local numandex = 0 -- ZERO-based
  local numcxarr = 0
  local strkatrol = ''
  numleang = string.len (strxxin)
  while true do -- genuine loop
    if (numandex==numleang) then
      break
    end--if
    numcxarr = string.byte (strxxin,(numandex+1),(numandex+1))
    if ((numcxarr==32) or (numcxarr==95)) then
      if (boounderlig) then
        numcxarr = 95
      else
        numcxarr = 32
      end--if
    end--if
    strkatrol = strkatrol .. string.char (numcxarr)
    numandex = numandex + 1
  end--while
  return strkatrol
end--function lfispacundr

------------------------------------------------------------------------

-- Local function LFIKATPALDIGU

-- Brew cat insertion (no extra colon ":") or link to cat (with extra
-- colon ":") or link to page (appendix, other ns, even ns ZERO) from
-- 3 elements with optimization.

-- Input  : * strprephyx -- ns prefix without colon, empty or
--                          non-string if not desired ie ns ZERO
--          * strkataldnomo
--          * strhintvisi -- right part, empty or non-string if not desired
--          * numkattxtrakol -- ZERO for non-cat, ONE for cat insertion
--                              (needed for optimization), TWO for extra
--                              colon ie "colon rule" link to cat

local function lfikatpaldigu (strprephyx, strkataldnomo, strhintvisi, numkattxtrakol)
  local strtigatipwiki = ''
  if (type(strprephyx)~="string") then -- optional
    strprephyx = ''
  end--if
  if (type(strhintvisi)~="string") then -- optional
    strhintvisi = ''
  end--if
  if ((numkattxtrakol==1) and (strhintvisi==strkataldnomo)) then
    strhintvisi = '' -- optimize: default is without ns prefix for cat:s
  end--if
  if (strprephyx~='') then
    strkataldnomo = strprephyx .. ':' .. strkataldnomo -- now prefix plus name
  end--if
  if ((numkattxtrakol~=1) and (strhintvisi==strkataldnomo)) then
    strhintvisi = '' -- optimize: default is with ns prefix if such is present
  end--if
  if (numkattxtrakol==2) then
    strkataldnomo = ':' .. strkataldnomo -- ":Category"... apply "colon rule"
  end--if
  if (strhintvisi=='') then
    strtigatipwiki = '[[' .. strkataldnomo .. ']]'
  else
    strtigatipwiki = '[[' .. strkataldnomo .. '|' .. strhintvisi .. ']]'
  end--if
  return strtigatipwiki
end--function lfikatpaldigu

------------------------------------------------------------------------

-- Local function LFIGETLEFTRIGHT

-- Split wikilink (in wide sense including cat insertions) into left
-- and right part detecting some common errors.

-- Input  : * strinasy -- like " Category :  Crime in Rhodesia | rho  "

-- Output : * numlerikodo, strinasy, strhinto

-- Depends on functions :
-- [G] lfgtrimwhite

-- Status values:
-- *  0 : OK (also if no wall)
-- * 75 : empty string or wall only (both invalid per MediaWiki)
-- * 76 : left empty or whitespace only (both invalid per MediaWiki)
-- * 77 : wall YES and right empty (dubious: "[[gluon|]]")
-- * 78 : right whitespace only (common: "[[Category:Time machines| ]]")
-- * 79 : junk spaces left or right (dubious: "[[Wiktionary:Bots |bot]]")

local function lfigetleftright (strinasy)

  local vartrovumuron = 0
  local strhinto = '' -- preASSume no right part
  local str9tmp = ''
  local numlerikodo = 0 -- preASSume innocence

  if ((strinasy=='') or (strinasy=='|')) then
    numlerikodo = 75
    strinasy = '' -- invalid
  else
    vartrovumuron = string.find(strinasy,'|',1,true)
    if (vartrovumuron) then
      if (vartrovumuron<(string.len(strinasy))) then
        strhinto = string.sub (strinasy,(vartrovumuron+1),-1)
      else
        numlerikodo = 77 -- right empty, overrides right whitespace only
      end--if
      if (vartrovumuron>1) then
        strinasy = string.sub (strinasy,1,(vartrovumuron-1))
      else
        numlerikodo = 76 -- left empty, overrides right empty (theoretically)
        strinasy = '' -- left part empty, invalid
      end--if
    end--if (vartrovumuron) then
  end--if ((strinasy=='') or (strinasy=='|')) else

  if (strinasy~='') then -- possible codes 0 77 so far
    str9tmp = lfgtrimwhite (strinasy) -- left
    if (str9tmp=='') then
      numlerikodo = 76 -- left empty or whitespace only, overrides right empty
    end--if
    if (strinasy~=str9tmp) then
      strinasy = str9tmp
      if (numlerikodo==0) then
        numlerikodo = 79 -- junk spaces
      end--if
    end--if
  end--if

  if (strhinto~='') then
    str9tmp = lfgtrimwhite (strhinto) -- right
    if ((str9tmp=='') and (numlerikodo==0)) then
      numlerikodo = 78 -- right whitespace only, overrides junk spaces left
    end--if
    if (strhinto~=str9tmp) then
      strhinto = str9tmp
      if (numlerikodo==0) then
        numlerikodo = 79 -- junk spaces
      end--if
    end--if
  end--if

  return numlerikodo, strinasy, strhinto

end--function lfigetleftright

------------------------------------------------------------------------

-- Local function LFIVALIDATE6HEX

-- Validate a 6-digit HEX colour, only uppercase.

-- Output : * booh6hisvalid -- true if string is valid

-- Depends on functions :
-- [N] lfnonehextoint

-- Criteria:
-- * length 6 chars
-- * "0"..."9" and "A"..."F"

local function lfivalidate6hex (strmyhexsixcolor)
  local numuuinx = 0 -- ZERO-based
  local numcyyaar = 0
  local booh6hisvalid = false -- preASSume guilt -- will be the final verdict
  if (string.len(strmyhexsixcolor)==6) then
    booh6hisvalid = true -- preASSume innocence
    while true do
      if (numuuinx==6) then
        break -- done search, all OK
      end--if
      numcyyaar = string.byte(strmyhexsixcolor,(numuuinx+1),(numuuinx+1))
      if (lfnonehextoint(numcyyaar)>15) then
        booh6hisvalid = false -- guilt proven
        break -- abort search
      end--if
      numuuinx = numuuinx + 1 -- ZERO-based
    end--while
  end--if
  return booh6hisvalid
end--function lfivalidate6hex

------------------------------------------------------------------------

-- Local function LFIVALIUMDCTLSTR

-- Validate control string against restrictive pattern (dec).

-- Input  : * strresdpat -- restrictive pattern (max 200 char:s)
--          * strctldstr -- incoming suspect

-- Output : * numbadpos -- bad position, or 254 wrong length, or 255 success

-- Depends on functions :
-- [N] lfdec1digit

-- Content of restrictive pattern:
-- * "."                           -- skip check
-- * "-" and "?"                   -- must match literally
-- * digit "1"..."9" ("0" invalid) -- inclusive upper limit (min ZERO)

local function lfivaliumdctlstr (strresdpat, strctldstr)

  local numlenresdpat = 0
  local numldninkom = 0
  local numcomperindex = 0 -- ZERO-based
  local numead2 = 0
  local numead3 = 0
  local numbadpos = 254 -- preASSume guilt (len differ or too long or ...)
  local booddaan = false

  numlenresdpat = string.len(strresdpat)
  numldninkom = string.len(strctldstr)
  if ((numlenresdpat<=200) and (numlenresdpat==numldninkom)) then
    while true do
      if (numcomperindex==numlenresdpat) then
        numbadpos = 255
        break -- success
      end--if
      numead2 = string.byte(strresdpat,(numcomperindex+1),(numcomperindex+1)) -- rest
      numead3 = string.byte(strctldstr,(numcomperindex+1),(numcomperindex+1)) -- susp
      booddaan = false
      if ((numead2==45) or (numead2==63)) then
        if (numead2~=numead3) then
          numbadpos = numcomperindex
          break -- "-" and "?" must match literally
        end--if
        booddaan = true -- position OK
      end--if
      if (numead2==46) then -- skip for dot "."
        booddaan = true -- position OK
      end--if
      if (not booddaan) then
        numead2 = lfdec1digit(numead2) -- rest
        if (numead2>9) then -- limit defined or bad ??
          numbadpos = 254
          break -- bad restrictive pattern
        else
          numead3 = lfdec1digit(numead3) -- susp
          if (numead3>numead2) then
            numbadpos = numcomperindex
            break -- value limit violation
          end--if
        end--if (numead2>9) else
      end--if (not booddaan) then
      numcomperindex = numcomperindex + 1
    end--while
  end--if ((numlenresdpat<=200) and (numlenresdpat==numldninkom)) then

  return numbadpos

end--function lfivaliumdctlstr

------------------------------------------------------------------------

-- Local function LFICHKPARAM

-- Check one incoming param against type and range.

-- Input  : * varmyparam
--          * numtypeofparam -- 0 string | 1 one-digit dec | 2 two-digit dec
--                              6 hex six-digit colour
--                              8 hex integer                                   !!!FIXME!!! incomplete
--          * numzzmin, numzzmax -- relevant for all types except 6

-- Output : * numverdictparam -- 0 nope | 1 exists invalid | 2 exists valid
--          * varparvalue -- copy (for types ZERO and 6) or converted value
--                           (for other types) or type "nil", do NOT use to
--                           check validity

-- Depends on functions :
-- [I] lfivalidate6hex
-- [N] lfdec1digit lfstrondig2int lfstrtwdig2int lfnonehextoint

local function lfichkparam (varmyparam, numtypeofparam, numzzmin, numzzmax)

  local varparvalue = 0 -- preASSume nope

  local numverdictparam = 0 -- preASSume nope
  local numlenof66param = 0
  local num66temp = 0

  if (type(varmyparam)=='string') then
    numverdictparam = 1 -- preASSume guilt
    numlenof66param = string.len(varmyparam)
    if ((numtypeofparam==0) and (numlenof66param>=numzzmin) and (numlenof66param<=numzzmax)) then -- 0 string
      numverdictparam = 2 -- type ZERO OK !!!
      varparvalue = varmyparam
    end--if
    if (numtypeofparam==1) then -- 1 one-digi
      num66temp = lfstrondig2int (varmyparam)
      if ((num66temp>=numzzmin) and (num66temp<=numzzmax)) then
        numverdictparam = 2 -- type ONE OK !!!
        varparvalue = num66temp -- converted
      end--if
    end--if
    if (numtypeofparam==2) then -- 2 two-digi
      num66temp = lfstrtwdig2int (varmyparam)
      if ((num66temp>=numzzmin) and (num66temp<=numzzmax)) then
        numverdictparam = 2 -- type 2 OK !!!
        varparvalue = num66temp -- converted
      end--if
    end--if
    if (numtypeofparam==6) then -- 6 hex six-digit colour
      if (lfivalidate6hex(varmyparam)) then
        numverdictparam = 2 -- type 6 OK !!!
        varparvalue = varmyparam
      end--if
    end--if
  end--if (type(varmyparam)=='string') then

  if (numverdictparam~=2) then
    varparvalue = nil
  end--if

  return numverdictparam, varparvalue

end--function lfichkparam

------------------------------------------------------------------------

-- Local function LFIFILLNAME

-- Replace placeholder "\@" "\\@" by augmented name of the caller.

-- To be called ONLY from "lfhfillsurrstrtab".

-- The name of the caller is submitted to us as a parameter thus we
-- do NOT access any constants and do NOT have to peek it either.

local function lfifillname (strmessage, strcaller)

  local strhasill = ''
  local numstrloen = 0
  local numindfx = 1 -- ONE-based
  local numcjar = 0
  local numcjnext = 0

  numstrloen = string.len (strmessage)

  while true do
    if (numindfx>numstrloen) then
      break -- empty input is useless but cannot cause major harm
    end--if
    numcjar = string.byte (strmessage,numindfx,numindfx)
    numindfx = numindfx + 1
    numcjnext = 0 -- preASSume no char
    if (numindfx<=numstrloen) then
      numcjnext = string.byte (strmessage,numindfx,numindfx)
    end--if
    if ((numcjar==92) and (numcjnext==64)) then
      strhasill = strhasill .. strcaller -- invalid input is caller's risk
      numindfx = numindfx + 1 -- skip 2 octet:s of the placeholder
    else
      strhasill = strhasill .. string.char (numcjar)
    end--if
  end--while

  return strhasill

end--function lfifillname

------------------------------------------------------------------------

-- Local function LFIKODEOSG

-- Transcode eo X-surrogates to cxapeloj in a single string (eo only).

-- Input  : * streosurr -- ANSI string (empty is useless but cannot
--                                      cause major harm)

-- Output : * strutf8eo -- UTF8 string

-- Depends on functions :
-- [E] mathdiv mathmod

-- Depends on constants :
-- * table "contabtransluteo" inherently holy

-- To be called ONLY from "lfhfillsurrstrtab".

-- * the "x" in a surr pair is case insensitive,
--   for example both "kacxo" and "kacXo" give same result
-- * avoid "\", thus for example "ka\cxo" would get converted but the "\" kept
-- * double "x" (both case insensitive) prevents conversion and becomes
--   reduced to single "x", for example "kacxxo" becomes "kacxo"

local function lfikodeosg (streosurr)

  local vareopeek = 0
  local strutf8eo = ''
  local numeoinplen = 0
  local numinpinx = 0 -- ZERO-based source index
  local numknar0k = 0 -- current char
  local numknaf1x = 0 -- next char (ZERO is NOT valid)
  local numknaf2x = 0 -- post next char (ZERO is NOT valid)
  local boonext1x = false
  local boonext2x = false
  local boosudahdone = false

  numeoinplen = string.len(streosurr)

  while true do

    if (numinpinx>=numeoinplen) then
      break
    end--if

    numknar0k = string.byte(streosurr,(numinpinx+1),(numinpinx+1))
    numknaf1x = 0 -- preASSume no char
    numknaf2x = 0 -- preASSume no char
    if ((numinpinx+1)<numeoinplen) then
      numknaf1x = string.byte(streosurr,(numinpinx+2),(numinpinx+2))
    end--if
    if ((numinpinx+2)<numeoinplen) then
      numknaf2x = string.byte(streosurr,(numinpinx+3),(numinpinx+3))
    end--if

    boonext1x = ((numknaf1x==88) or (numknaf1x==120)) -- case insensitive
    boonext2x = ((numknaf2x==88) or (numknaf2x==120)) -- case insensitive
    boosudahdone = false
    if (boonext1x and boonext2x) then -- got "xx"
      strutf8eo = strutf8eo .. string.char(numknar0k,numknaf1x) -- keep one "x" only
      numinpinx = numinpinx + 3 -- eaten 3 written 2
      boosudahdone = true
    end--if
    if (boonext1x and (not boonext2x)) then -- got yes-"x" and no-"x"
      vareopeek = contabtransluteo[numknar0k] -- UINT16 or type "nil"
      if (type(vareopeek)=='number') then
        strutf8eo = strutf8eo .. string.char(mathdiv(vareopeek,256),mathmod(vareopeek,256)) -- add UTF8 char
        numinpinx = numinpinx + 2 -- eaten 2 written 2
        boosudahdone = true
      end--if
    end--if
    if (not boosudahdone) then
      strutf8eo = strutf8eo .. string.char(numknar0k) -- copy char
      numinpinx = numinpinx + 1 -- eaten 1 written 1
    end--if

  end--while

  return strutf8eo

end--function lfikodeosg

------------------------------------------------------------------------

-- Local function LFIKODSVSG

-- Transcode sv blackslash-surrogates in a single string (sv only).

-- Input  : * strsvsurr -- ANSI string (empty is useless but cannot
--                                      cause major harm)

-- Output : * strutf8sv -- UTF8 string

-- Depends on functions :
-- [E] mathdiv mathmod

-- Depends on constants :
-- * table "contabtranslutsv" inherently holy

-- To be called ONLY from "lfhfillsurrstrtab".

-- * the latter letter in a surr triple is case insensitive,
--   for example both "\AEgare" and "\Aegare" give same result

local function lfikodsvsg (strsvsurr)

  local varsvpeek = 0
  local strutf8sv = ''
  local strsvdouble = ''
  local numsvinplen = 0
  local numinpinx = 0 -- ZERO-based source index
  local numsvonechar = 0 -- current char

  numsvinplen = string.len(strsvsurr)

  while true do

    if (numinpinx>=numsvinplen) then
      break
    end--if

    numsvonechar = string.byte(strsvsurr,(numinpinx+1),(numinpinx+1))
    strsvdouble = '' -- preASSume no dblchar
    if ((numsvonechar==92) and ((numinpinx+2)<numsvinplen)) then
      strsvdouble = string.sub(strsvsurr,(numinpinx+2),(numinpinx+3))
    end--if

    varsvpeek = contabtranslutsv[strsvdouble] -- UINT16 or type "nil"
    if (type(varsvpeek)=='number') then
      strutf8sv = strutf8sv .. string.char(mathdiv(varsvpeek,256),mathmod(varsvpeek,256)) -- add UTF8 char
      numinpinx = numinpinx + 3 -- eaten 3 written 2
    else
      strutf8sv = strutf8sv .. string.char(numsvonechar) -- copy char
      numinpinx = numinpinx + 1 -- eaten 1 written 1
    end--if

  end--while

  return strutf8sv

end--function lfikodsvsg

------------------------------------------------------------------------

-- Local function LFICENQTABQLEFQTXT

-- Outside center inside left, invisible.

local function lficenqtabqlefqtxt (strwhatever)
  strwhatever = '<table style="margin:auto;"><tr><td style="text-align:left;">' .. strwhatever .. '</td></tr></table>'
  return strwhatever
end--function lficenqtabqlefqtxt

------------------------------------------------------------------------

-- Local function LFILEFQDIVQLEFQTXT

-- Outside left inside left, invisible.

local function lfilefqdivqlefqtxt (strwhootever)
  strwhootever = '<div style="text-align:left;">' .. strwhootever .. '</div>'
  return strwhootever
end--function lfilefqdivqlefqtxt

------------------------------------------------------------------------

-- Local function LFIPRETABLE

-- Outside left inside left, visible.

local function lfipretable (strpredabletext, numfontsizepercent)
  strpredabletext = '<table><tr><td style="border:1px solid #E0E0E0;padding:0 0.15em 0 0.15em;background:#F8F8F8;font-family:monospace;text-align:left;font-size:' .. tostring(numfontsizepercent) .. '%;">' .. strpredabletext .. '</td></tr></table>'
  return strpredabletext
end--function lfipretable

------------------------------------------------------------------------

-- Local function LFIPAIRXATXALT

-- In multifield string convert "@@" to equal sign "=" and wall "|".

-- Input  : * strdblinutat -- empty NOT legal

-- Output : * strdblinutat -- empty on error

-- Number of parts must be even, thus number of separators "@@" must be
-- odd, at least ONE. The incoming string must NOT begin or end with "@@",
-- length must be 4...1'000. This is applied on "hid=".

local function lfipairxatxalt (strdblinutat)

  local varfyynndd = 0
  local tabswitchwaltrue = {[false]='=',[true]='|'}
  local numlimytkauntr = 0
  local boonowwall = false
  local boocrapss = false

  while true do
    varfyynndd = string.find (strdblinutat, "@@", 1, true)
    if (not varfyynndd) then
      break -- good or baad, decide below
    end--if
    if ((varfyynndd==1) or (varfyynndd==(string.len(strdblinutat)-1))) then
      boocrapss = true -- baad, found at begin or end
      break
    end--if
    if (numlimytkauntr==16) then
      boocrapss = true -- baad, exceeded max 8 pairs
      break
    end--if
    strdblinutat = string.sub(strdblinutat,1,(varfyynndd-1)) .. tabswitchwaltrue[boonowwall] .. string.sub(strdblinutat,(varfyynndd+2),-1)
    boonowwall = not boonowwall
    numlimytkauntr = numlimytkauntr + 1
  end--while

  if (boocrapss or (not boonowwall)) then
    strdblinutat = '' -- more than 16 parts or odd number of parts or ...
  else
    strdblinutat = '|' .. strdblinutat -- begin with wall
  end--if

  return strdblinutat -- same var for in and out

end--function lfipairxatxalt

------------------------------------------------------------------------

-- Local function LFIRESTOREFROMEXTRA

-- Restore ordinary form from extra level of protection.

local function lfirestorefromextra (strin99ut)

  local varfiindnes = 0
  local booalreadydone = false

  while true do -- genuine loop but no index

    booalreadydone = true

    varfiindnes = string.find(strin99ut,'<renef>',1,true)
    if (varfiindnes) then
      strin99ut = string.sub(strin99ut,1,(varfiindnes+1)) .. string.sub(strin99ut,(varfiindnes+4),-1)
      booalreadydone = false
    end--if
    varfiindnes = string.find(strin99ut,'<renef name=',1,true)
    if (varfiindnes) then
      strin99ut = string.sub(strin99ut,1,(varfiindnes+1)) .. string.sub(strin99ut,(varfiindnes+4),-1)
      booalreadydone = false
    end--if
    varfiindnes = string.find(strin99ut,'<renef group=',1,true)
    if (varfiindnes) then
      strin99ut = string.sub(strin99ut,1,(varfiindnes+1)) .. string.sub(strin99ut,(varfiindnes+4),-1)
      booalreadydone = false
    end--if
    varfiindnes = string.find(strin99ut,'</renef>',1,true)
    if (varfiindnes) then
      strin99ut = string.sub(strin99ut,1,(varfiindnes+2)) .. string.sub(strin99ut,(varfiindnes+5),-1)
      booalreadydone = false
    end--if

    varfiindnes = string.find(strin99ut,'{({',1,true)
    if (varfiindnes) then
      strin99ut = string.sub(strin99ut,1,varfiindnes) .. string.sub(strin99ut,(varfiindnes+2),-1)
      booalreadydone = false
    end--if
    varfiindnes = string.find(strin99ut,'})}',1,true)
    if (varfiindnes) then
      strin99ut = string.sub(strin99ut,1,varfiindnes) .. string.sub(strin99ut,(varfiindnes+2),-1)
      booalreadydone = false
    end--if

    if (booalreadydone) then
      break
    end--if

  end--while

  return strin99ut -- same var for in and out

end--function lfirestorefromextra

------------------------------------------------------------------------

-- Local function LFIBREWCURLYCALL

local function lfibrewcurlycall (boonsiszero, strcurlytemcall, numbeeg, numennd)
  if (boonsiszero) then
    strcurlytemcall = ':' .. strcurlytemcall -- add colon for ns ZERO
  end--if
  if ((numbeeg==10) or (numbeeg==32)) then
    strcurlytemcall = string.char (numbeeg) .. strcurlytemcall
  end--if
  if ((numennd==10) or (numennd==32)) then
    strcurlytemcall = strcurlytemcall .. string.char (numennd)
  end--if
  strcurlytemcall = '{{' .. strcurlytemcall .. '}}'
  return strcurlytemcall
end--function lfibrewcurlycall

------------------------------------------------------------------------

local function lfiexpandstatus (numpexpaste)
  return '#X' .. lfnumto2digit(numpexpaste)
end--function lfiexpandstatus

local function lfisplitstatus (numzsplitste)
  return '#S' .. lfnumto2digit(numzsplitste)
end--function lfisplitstatus

------------------------------------------------------------------------

-- Local function LFICOMBOSTATUS

-- Depends on functions :
-- [I] lfisplitstatus lfiexpandstatus
-- [N] lfnumto2digit
-- [E] mathdiv mathmod mathintrange

local function lficombostatus (num3exp, num3spl)
  local strcomplaint = '' -- keep empty on success
  if (num3exp==70) then -- #X70
    if (num3spl>=20) then -- #S20
      strcomplaint = lfisplitstatus (num3spl) -- exp pass split fail
    end--if
  else
    strcomplaint = lfiexpandstatus (num3exp) -- exp fail split irrelevant
  end--if
  return strcomplaint
end--function lficombostatus

------------------------------------------------------------------------

-- Local function LFIEXPLAIN

-- Depends on constants :
-- * table "contabxxplain" with string keys

local function lfiexplain (strrezultinut)
  local varriskofnil = 0
  varriskofnil = contabxxplain[strrezultinut]
  if (type(varriskofnil)=='string') then
    strrezultinut = strrezultinut .. ' ' .. varriskofnil
  end--if
  return strrezultinut -- same var for in and out
end--function lfiexplain

------------------------------------------------------------------------

-- Local function LFICONDICELROW

-- Brew either raw or cell <td>...</td> or row <tr>...</tr>.

-- Depends on upvalues :
-- * 2 strings "qstrtdbegin" and "qstrtdendus"
-- * table "qtabmy6columns"

local function lficondicelrow (strmytext, numtype0of5table, numindexofcell)
  if (numtype0of5table~=0) then -- add cell "td" for all except ZERO
    strmytext = qstrtdbegin .. strmytext .. qstrtdendus
  end--if
  if (numtype0of5table==5) then -- row of vertical table
    strmytext = '<tr>' .. qstrtdbegin .. qtabmy6columns[numindexofcell] .. qstrtdendus .. strmytext .. '</tr>'
  end--if
  return strmytext -- same var for in and out
end--function lficondicelrow

------------------------------------------------------------------------

-- Local function LFICHECKFORBAD

-- Output : * booisbaad -- true if string is bad

local function lficheckforbad (streniro)
  local booisbaad = false
  booisbaad = (string.find(streniro,"''",1,true)~=nil) -- dbl apo
  booisbaad = booisbaad or (string.find(streniro,"[[",1,true)~=nil)
  booisbaad = booisbaad or (string.find(streniro,"]]",1,true)~=nil)
  booisbaad = booisbaad or (string.find(streniro,"{{",1,true)~=nil)
  booisbaad = booisbaad or (string.find(streniro,"}}",1,true)~=nil)
  booisbaad = booisbaad or (string.find(streniro,"{({",1,true)~=nil) -- pate
  booisbaad = booisbaad or (string.find(streniro,"})}",1,true)~=nil) -- pate
  return booisbaad
end--function lficheckforbad

------------------------------------------------------------------------

---- HIGH LEVEL FUNCTIONS [H] ----

------------------------------------------------------------------------

-- Local function LFHBREWERROR

-- Input  : * numerrorcode

-- Depends on functions :
-- [N] lfnumto2digit
-- [E] mathdiv mathmod mathintrange

-- Depends on constants :
-- * 3 strings constrelabg constrelaen constrlaxhu
-- * table contaberaroj TWO-based (may be holy)

-- #E02...#E99, note that #E00 and #E01 are NOT supposed to be included here.

local function lfhbrewerror (numerrorcode)
  local vardeskrip = 0
  local strytsux = '#E'
  if (mathintrange(numerrorcode,2,99)==numerrorcode) then
    strytsux = strytsux .. lfnumto2digit(numerrorcode) .. ' '
    vardeskrip = contaberaroj[numerrorcode] -- risk of type "nil"
    if (type(vardeskrip)=='string') then
      strytsux = strytsux .. vardeskrip
    else
      strytsux = strytsux .. '??' -- no text
    end--if
  else
    strytsux = strytsux .. '??' -- no valid error code
  end--if
  strytsux = constrlaxhu .. constrelabg .. strytsux .. constrelaen .. constrlaxhu
  return strytsux
end--function lfhbrewerror

------------------------------------------------------------------------

-- Local function LFHFILLSURRSTRTAB

-- Process (fill in, transcode surr) either a single string, or all string
-- items in a table using any type of keys/indexes (such as a holy number
-- sequence and non-numeric ones). Items with a non-string value are kept
-- as-is. For filling in own name, and converting eo and sv surrogates
-- (via 3 separate sub:s).

-- Input  : * varinkommen -- type "string" or "table"
--          * varfyllo -- string, or type "nil" if no filling-in desired
--          * strlingkod -- "eo" or "sv" to convert surrogates, anything
--                          else (preferably type "nil") to skip this

-- Depends on functions :
-- [I] lfifillname (only if filling-in desired)
-- [I] lfikodeosg (only if converting of eo X-surrogates desired)
-- [I] lfikodsvsg (only if converting of sv blackslash-surrogates desired)
-- [E] mathdiv mathmod (via "lfikodeosg" and "lfikodsvsg")

-- Depends on constants :
-- * table "contabtransluteo" inherently holy (via "lfikodeosg")
-- * table "contabtranslutsv" inherently holy (via "lfikodsvsg")

local function lfhfillsurrstrtab (varinkommen, varfyllo, strlingkod)

  local varkey = 0 -- variable without type
  local varele = 0 -- variable without type
  local varutmatning = 0
  local boodone = false

  if (type(varinkommen)=='string') then
    if (type(varfyllo)=='string') then
      varinkommen = lfifillname (varinkommen,varfyllo) -- fill-in
    end--if
    if (strlingkod=='eo') then
      varinkommen = lfikodeosg (varinkommen) -- surr
    end--if
    if (strlingkod=='sv') then
      varinkommen = lfikodsvsg (varinkommen) -- surr
    end--if
    varutmatning = varinkommen -- copy, risk for no change
    boodone = true
  end--if

  if (type(varinkommen)=='table') then
    varutmatning = {} -- brew new table
    varkey = next (varinkommen) -- try to pick 0:th (in no order) key/index
    while true do
      if (varkey==nil) then
        break -- empty table or end reached
      end--if
      varele = varinkommen[varkey] -- pick element of unknown type
      if (type(varele)=='string') then
        varele = lfhfillsurrstrtab (varele, varfyllo, strlingkod) -- RECURSION
      end--if
      varutmatning[varkey] = varele -- write at same place in dest table
      varkey = next (varinkommen, varkey) -- try to pick next key/index
    end--while
    boodone = true
  end--if

  if (not boodone) then
    varutmatning = varinkommen -- copy as-is whatever it is
  end--if

  return varutmatning

end--function lfhfillsurrstrtab

------------------------------------------------------------------------

-- Local function LFHTABLETOHTMLLIST

-- Convert LUA table into a HTML list.

-- Input  : * tabsomeitems -- ZERO-based LUA table, empty legal
--          * booaddtable

-- Output : * strhotomolo -- * empty string if table is empty
--                           * raw string if table has ONE element
--                           * else HTML list optionally inside
--                             an invisible HTML table

-- Depends on functions :
-- [I] lficenqtabqlefqtxt

-- <li></li> for single items in list
-- <ul></ul> for complete list

local function lfhtabletohtmllist (tabsomeitems, booaddtable)

  local var3elemento = 0
  local strhotomolo = ''
  local numindekso = 0 -- ZERO-based

  while true do -- genuine loop over incoming table
    var3elemento = tabsomeitems [numindekso]
    if (type(var3elemento)~='string') then
      break -- done
    end--if
    if (numindekso==0) then
      strhotomolo = var3elemento
    end--if
    if (numindekso==1) then
      strhotomolo = '<li>' .. strhotomolo .. '</li>' -- postponed work for #0
    end--if
    if (numindekso>=1) then
      strhotomolo = strhotomolo .. '<li>' .. var3elemento .. '</li>'
    end--if
    numindekso = numindekso + 1
  end--while

  if (numindekso>=2) then
    strhotomolo = '<ul>' .. strhotomolo .. '</ul>'
    if (booaddtable) then
      strhotomolo = lficenqtabqlefqtxt(strhotomolo) -- outsid cent insid left
    end--if
  end--if

  return strhotomolo

end--function lfhtabletohtmllist

------------------------------------------------------------------------

-- Local function LFHATMERGETAB

-- Merge multifield string into table.

-- Input  : * streniroat -- string with some "@@", empty legal
--          * tabcolspan -- [0]...[5] booleans whether col active, no holes
--          * tabdefaultat -- [0]...[5] default names, ZERO-based, no holes

-- Output : * tabeliroat -- new table [0]...[5] may have holes,
--                          special [9] true on error

-- This is applied on "tit=". Maximally 5 separators "@@" and 6 substrings.

local function lfhatmergetab (streniroat, tabcolspan, tabdefaultat)

  local varfiinndd = 0

  local tabfromtit = {} -- temp, can be too small or too big, but no holes
  local tabeliroat = {} -- final, [0]...[5] may have holes

  local numcxeloj0x5x = 0 -- ZERO-based
  local numwithholes = 0

  local bootitisbad = false -- preASSume innocence

  while true do
    varfiinndd = string.find (streniroat, "@@", 1, true)
    if (not varfiinndd) then
      if (streniroat~='') then
        tabfromtit[numcxeloj0x5x] = streniroat -- take the last one
      end--if
      break -- good
    end--if
    if ((varfiinndd==1) or (varfiinndd==(string.len(streniroat)-1))) then
      bootitisbad = true -- baad, found at begin or end
      break
    end--if
    if (numcxeloj0x5x==5) then -- OFF-BY-ONE here the last one is added elsewhere
      bootitisbad = true -- baad, exceeded max 6 substrings
      break
    end--if
    tabfromtit[numcxeloj0x5x] = string.sub(streniroat,1,(varfiinndd-1))
    streniroat = string.sub(streniroat,(varfiinndd+2),-1)
    numcxeloj0x5x = numcxeloj0x5x + 1 -- NOT valid on exit from loop
  end--while

  if (bootitisbad) then
    tabeliroat[9] = true -- baad
  else
    numcxeloj0x5x = 0
    numwithholes = 0
    while true do
      if (numcxeloj0x5x==6) then
        break
      end--if
      if tabcolspan[numcxeloj0x5x] then -- fill in only if used
        if (tabfromtit[numwithholes]) then -- take only if available
          tabeliroat[numcxeloj0x5x] = tabfromtit[numwithholes] -- custom
          numwithholes = numwithholes + 1
        else
          tabeliroat[numcxeloj0x5x] = tabdefaultat[numcxeloj0x5x] -- default
        end--if
      end--if tabcolspan[numcxeloj0x5x] then
      numcxeloj0x5x = numcxeloj0x5x + 1 -- INC this irrespective of tabcolspan
    end--while
  end--if

  return tabeliroat

end--function lfhatmergetab

------------------------------------------------------------------------

-- Local function LFHPARSEMAP

-- Parse and map the wikitext and record findings.

-- Output : * tabmy3table -- nested: [0] findings | [1] main map |
--                           [2] boundary map

-- We can avoid maintaining a stack since we count wikilinks only and
-- give a f**k about template calls that could be mixed with them.

-- The embedded function takes ONE-based index.

-- There is a problem with markers like "[[" and "]]". If they are nested
-- and adjacent like "[[[[" or "]]]]" then we must prevent the same char
-- from being shared among two hits.

local function lfhparsemap (strwiki7text)

  local tabmy3table = {} -- nested
  local tabmainmap = {}
  local tabbouncer = {} -- tristate
  local tabfindings = {[0]=true,[1]=false,[2]=false,[3]=false} -- heterogeneous
  local numwiki7len   = 0      -- also for embedded func -- upper limit
  local numlower7li   = 1      -- only for embedded func -- lower limit
  local numparseindex = 1      -- also for embedded func -- ONE-based
  local numareatype   = 0
  local numyyyhitlng  = 0      -- also for embedded func -- length of hit
  local numareabykp   = 0      -- only types 0...9 can be backuped
  local nummaxdepth   = 0      -- 97 under | 98 over
  local boogotstp     = false
  local boogotshl     = false  -- !!!FIXME!!! not yet evaluated
  local boogotpre     = false
  local boogotnwk     = false
  local boogotref     = false
  local boogotkom     = false
  local bootreaspace  = false  -- !!!FIXME!!! not yet evaluated

    -- embedded function ie procedure, no output value, includes current char
    -- IN PRARAM: stryyyfind
    -- IN SHARED: strwiki7text numwiki7len numlower7li numparseindex
    -- UT SHARED: numyyyhitlng
    local function compareforwards (stryyyfind)
      local booyyyfaund = false -- preASSume NOT found
      numyyyhitlng = string.len(stryyyfind) -- searched string
      if (numyyyhitlng>=1) then
        if ((numparseindex>=numlower7li) and ((numparseindex+numyyyhitlng-1)<=numwiki7len)) then
          booyyyfaund = (string.sub(strwiki7text,numparseindex,(numparseindex+numyyyhitlng-1))==stryyyfind)
        end--if
      end--if
      if (not booyyyfaund) then
        numyyyhitlng = 0
      end--if
    end--function compareforwards

    -- embedded function ie procedure, no output value, fill
    -- IN PRARAM: numyyydx (ONE-based)     -- numyyyaratyp
    --            triyyybgen (1 beg 2 end) -- numyyysize
    -- CH SHARED: tabbouncer tabmainmap
    local function filldesti (numyyydx, numyyyaratyp, triyyybgen, numyyysize)
      if (numyyysize~=0) then
        if (triyyybgen==1) then
          tabbouncer [numyyydx] = 1 -- begin flag
        end--if
        while true do -- genuine loop, at least ONE iteration
          tabmainmap [numyyydx] = numyyyaratyp
          numyyysize = numyyysize - 1
          if (numyyysize==0) then
            break
          end--if
          numyyydx = numyyydx + 1 -- do this AFTER exit check
        end--while genuine loop
        if (triyyybgen==2) then
          tabbouncer [numyyydx] = 2 -- end flag
        end--if
      end--if (numyyysize~=0) then
    end--function filldesti

  numwiki7len = string.len(strwiki7text) -- quasi-const
  numlower7li = 1 -- const

  while true do -- outer genuine loop over wikitext, char after char

    if (numparseindex>numwiki7len) then -- ONE-based
      break -- completed
    end--if
    numyyyhitlng = 0 -- preASSume no hit for every position

    while true do -- fake loop

      if (numareatype==15) then -- !!!FIXME!!! 14 not yet supported
        compareforwards ('QINU'..string.char(96,34,39,127))
        if (numyyyhitlng~=0) then
          filldesti (numparseindex, numareatype, 2, numyyyhitlng) -- old type
          numareatype = numareabykp -- after filling
          break
        end--if
      end--if (numareatype==15) then

      if (numareatype==22) then
        compareforwards ('</pre>')
        if (numyyyhitlng~=0) then
          filldesti (numparseindex, numareatype, 2, numyyyhitlng) -- old type
          numareatype = numareabykp -- after filling
          break
        end--if
      end--if (numareatype==22) then

      if (numareatype==23) then
        compareforwards ('</nowiki>')
        if (numyyyhitlng~=0) then
          filldesti (numparseindex, numareatype, 2, numyyyhitlng) -- old type
          numareatype = numareabykp -- after filling
          break
        end--if
      end--if (numareatype==23) then

      if (numareatype==27) then
        compareforwards ('-->')
        if (numyyyhitlng~=0) then
          filldesti (numparseindex, numareatype, 2, numyyyhitlng) -- old type
          numareatype = numareabykp -- after filling
          break
        end--if
      end--if (numareatype==27) then

      if (numareatype>=10) then
        break -- no more chance for a hit at this position
      end--if

      compareforwards (']]')
      if (numyyyhitlng~=0) then
        filldesti (numparseindex, numareatype, 2, numyyyhitlng) -- old type
        if (numareatype==0) then
          nummaxdepth = 97 -- special value for underflow, recoverable
        else
          numareatype = numareatype - 1 -- inclusive limit from ONE to ZERO
        end--if
        break
      end--if

      compareforwards ('[[')
      if (numyyyhitlng~=0) then
        if (numareatype==9) then
          nummaxdepth = 98 -- special value for overflow, FATAL
          numareatype = 0 -- avoid #M03 below
        else
          numareatype = numareatype + 1 -- inclusive limit from 8 to 9
          nummaxdepth = math.max(nummaxdepth,numareatype)
          filldesti (numparseindex, numareatype, 1, numyyyhitlng) -- new type
        end--if
        break
      end--if

      compareforwards (string.char(127,39,34,96)..'UNIQ') -- &#127;'"&#96;UNIQ--pre-00000002-QINU&#96;"'&#127;
      if (numyyyhitlng~=0) then
        numareabykp = numareatype
        numareatype = 15
        boogotstp = true -- never to false again
        filldesti (numparseindex, numareatype, 1, numyyyhitlng) -- new type
        break
      end--if

      compareforwards ('<pre>')
      if (numyyyhitlng~=0) then
        numareabykp = numareatype
        numareatype = 22
        boogotpre = true -- never to false again
        filldesti (numparseindex, numareatype, 1, numyyyhitlng) -- new type
        break
      end--if

      compareforwards ('<nowiki>')
      if (numyyyhitlng~=0) then
        numareabykp = numareatype
        numareatype = 23
        boogotnwk = true -- never to false again
        filldesti (numparseindex, numareatype, 1, numyyyhitlng) -- new type
        break
      end--if

      compareforwards ('<!--')
      if (numyyyhitlng~=0) then
        numareabykp = numareatype
        numareatype = 27
        boogotkom = true -- never to false again
        filldesti (numparseindex, numareatype, 1, numyyyhitlng) -- new type
        break
      end--if

      break -- finally to join mark
    end--while -- fake loop -- join mark

    if (nummaxdepth==98) then
      break -- FATAL
    end--if

    if (numyyyhitlng==0) then
      filldesti (numparseindex, numareatype, 0, 1) -- current type, no hit
      numparseindex = numparseindex + 1 -- ONE-based, no hit
    else
      numparseindex = numparseindex + numyyyhitlng -- ONE-based, YES hit
    end--if

  end--while outer genuine loop over wikitext, char after char

  if (numparseindex<=numwiki7len) then -- ONE-based
    filldesti (numparseindex, 255, 0, (numwiki7len-numparseindex+1)) -- fill up on FATAL
  end--if

  while true do -- lower fake loop

    if ((numareatype>=16) and (numareatype<=30)) then -- do NOT incl 14 15 her
      tabfindings [1] = true -- #M01 no other discovery possible
      break -- to join mark
    end--if
    if ((numareatype==14) or (numareatype==15)) then
      tabfindings [2] = true -- #M02 no other discovery possible
      break -- to join mark
    end--if
    if (numareatype~=0) then
      tabfindings [3] = true -- #M03 no other discovery possible
      break -- to join mark
    end--if
    tabfindings [20] = nummaxdepth -- #M20 value 97 or 98 is an error
    if (nummaxdepth>=10) then
      break -- to join mark -- no other discovery possible for both 97 and 98
    end--if
    tabfindings [ 4] = boogotstp    -- #M04  !!!FIXME!!! does not work yet fully 4 vs 5
    tabfindings [ 5] = boogotstp    -- #M05
    tabfindings [ 6] = boogotshl    -- #M06  !!!FIXME!!! does not work yet
    tabfindings [ 8] = boogotpre    -- #M08
    tabfindings [ 9] = boogotnwk    -- #M09
    tabfindings [10] = boogotref    -- #M10  !!!FIXME!!! does not work yet
    tabfindings [11] = boogotkom    -- #M11
    tabfindings [22] = bootreaspace -- #M22  !!!FIXME!!! does not work yet

    break -- finally to join mark
  end--while -- lower fake loop -- join mark

  tabmy3table = {[0]=tabfindings,[1]=tabmainmap,[2]=tabbouncer}

  return tabmy3table

end--function lfhparsemap

------------------------------------------------------------------------

-- Local function LFHTABLEWITHMAP

-- Visualize the map by brewing a HTML table from wikitext plus parallel map.

-- Input  : * stralltextm -- must NOT be empty
--          * tabthismap -- nested: [0] findings | [1] main map |
--                          [2] boundary map -- MUST MATCH !!!

-- Depends on functions :
-- [G] lfgtestnum lfgtestuc lfgtestlc lfgis62safe

-- Depends on constants :
-- * table "contabbk" for background colors

-- length 01...08 -> width  8 & 1 row
-- length 09...18 -> width  6 & 2 or 3 rows
-- length 19...64 -> width  8 & 3...8 rows
-- length >=65    -> width 10 & >=6 rows

local function lfhtablewithmap (stralltextm, tabthismap)

  local strvisualizedmap = ''
  local strhex6color = ''
  local stronecell = ''

  local numlencofwikitext = 0
  local numwidthincells = 0 -- 6 or 8 or 10
  local numasciizindex = 0 -- ZERO-based
  local numxcoordinate = 0 -- ZERO-based
  local numkodchar = 0
  local numfrommap = 0
  local tribegiend = 0

  numlencofwikitext = string.len(stralltextm)
  numwidthincells = 8 -- preASSume
  if ((numlencofwikitext>=9) and (numlencofwikitext<=18)) then
    numwidthincells = 6
  end--if
  if (numlencofwikitext>=65) then
    numwidthincells = 10
  end--if

  while true do -- genuine loop over double content
    if ((numasciizindex==numlencofwikitext) or (numxcoordinate==numwidthincells)) then
      strvisualizedmap = '<tr>' .. strvisualizedmap .. '</tr>'
    end--if
    if (numasciizindex==numlencofwikitext) then
      break -- done whole table
    end--if
    if (numxcoordinate==numwidthincells) then
      numxcoordinate = 0 -- done row only
    end--if
    numkodchar = string.byte(stralltextm,(numasciizindex+1),(numasciizindex+1))
    numfrommap = tabthismap[1][numasciizindex+1] -- get area type
    tribegiend = tabthismap[2][numasciizindex+1] -- get "B" or "E" maybeee
    strhex6color = contabbk[numfrommap] or "58" -- dark grey if bad
    if (string.len(strhex6color)==2) then
      strhex6color = strhex6color .. strhex6color .. strhex6color -- 2->6 digits ;-)
    end--if
    stronecell = '<td style="border:1px solid #000000;padding:0 0.2em 0 0.2em;background:#' .. strhex6color .. ';">'
    if (tribegiend==1) then
      stronecell = stronecell .. '<b>B</b>&nbsp;'
    end--if
    if (tribegiend==2) then
      stronecell = stronecell .. '<b>E</b>&nbsp;'
    end--if
    stronecell = stronecell .. tostring(numfrommap) .. ':<br>' .. tostring(numkodchar) .. '&nbsp;'
    if (lfgis62safe(numkodchar)) then
      stronecell = stronecell .. string.char(numkodchar) .. '</td>'
    else
      if ((numkodchar>=33) and (numkodchar<=126)) then
        stronecell = stronecell .. '&#' .. tostring(numkodchar) .. ';</td>'
      else
        stronecell = stronecell .. '?</td>'
      end--if
    end--if (lfgis62safe(numkodchar)) else
    strvisualizedmap = strvisualizedmap .. stronecell
    numasciizindex = numasciizindex + 1
    numxcoordinate = numxcoordinate + 1
  end--while

  strvisualizedmap = '<table style="margin:auto;">' .. strvisualizedmap .. '</table>' -- done whole table

  return strvisualizedmap

end--function lfhtablewithmap

------------------------------------------------------------------------

-- Local function LFHREPORTFINDINGS

-- Input  : * tabhugemap -- theoretically ZERO-based, only findings

-- Output : * streirreport -- empty impossible

-- Depends on functions :
-- [H] lfhtabletohtmllist
-- [I] lfiexplain
-- [N] lfnumto2digit
-- [E] mathdiv mathmod mathintrange

-- Depends on constants :
-- * table "contabxxplain" with string keys

local function lfhreportfindings (tabhugemap)

  local varfinding = 0
  local tabtemp77q = {}
  local numconsecutiveindex = 1 -- ZERO valid but skip #M00
  local numdestindex = 0
  local streirreport = ''

  while true do -- genuine loop 1...40
    if (numconsecutiveindex==41) then
      break
    end--if
    varfinding = tabhugemap [numconsecutiveindex] -- type "nil" or "boolean" or "number"
    if (varfinding) then
      tabtemp77q[numdestindex] = lfiexplain('#M' .. lfnumto2digit(numconsecutiveindex)) .. ':&nbsp;' .. tostring(varfinding)
      numdestindex = numdestindex + 1
    end--if
    numconsecutiveindex = numconsecutiveindex + 1
  end--while

  streirreport = 'Mapping done, '
  if (numdestindex==0) then
    streirreport = streirreport .. 'no finddings'
  end--if
  if (numdestindex==1) then -- <br> needed
    streirreport = streirreport .. 'finding:<br>' .. lfhtabletohtmllist(tabtemp77q,true) .. '<br>'
  end--if
  if (numdestindex>=2) then -- no <br> here
    streirreport = streirreport .. 'findings:' .. lfhtabletohtmllist(tabtemp77q,true)
  end--if

  return streirreport

end--function lfhreportfindings

------------------------------------------------------------------------

---- MEDIAWIKI INTERACTION FUNCTIONS [W] ----

------------------------------------------------------------------------

-- Local function LFWISTITLESAFE

-- Check whether title is safe (valid, not cat, not file,
-- no interwiki, standard form) returning a boolean.

-- Input  : * strsftitle

-- Output : * bootitlecxsafe -- true if safe (false also
--                              for non-string and invalid title)

-- Function "mw.title.new":
-- * returns type "nil" on invalid title string, and crashes if
--   input type is not string
-- * is NOT expensive (for our use) and works for non-existent titles too
-- * some useful fields:
--   * ".interwiki" is always a string, empty if no interwiki included
--   * ".namespace" is always a number, values <0 and 6 and 14
--     are unsafe ("Media:" gives -2)
--   * ".nsText" only bare ns prefix such as "Mall"
--   * ".prefixedText" {{FULLPAGENAME}} + maybe interwiki; veryfullpagename
--     including ns prefix and interwiki, a strictly standardized
--     form of title:
--     * adjusts letter case
--     * replaces underscores by spaces
--     * "Category:" becomes "Kategori:" in some languages
--     * removes extraneous spaces around colon ":"
--   * ".fullText" {{FULLPAGENAME}} + maybe interwiki + HTML section "#"

local function lfwistitlesafe (strsftitle)
  local tabtitleobject = {}
  local numnsoftheobject = 0
  local bootitlecxsafe = false -- preASSume guilt
  if (type(strsftitle)=='string') then
    tabtitleobject = mw.title.new(strsftitle) -- type "nil" for invalid
    if (type(tabtitleobject)=='table') then
      numnsoftheobject = tabtitleobject.namespace
      bootitlecxsafe = ((tabtitleobject.interwiki=='') and (numnsoftheobject>=0) and (numnsoftheobject~=6) and (numnsoftheobject~=14) and (tabtitleobject.prefixedText==strsftitle))
    end--if
  end--if
  return bootitlecxsafe
end--function lfwistitlesafe

------------------------------------------------------------------------

-- Local function LFWGETNSOFTITLE

local function lfwgetnsoftitle (strnstitle)
  local tabtitlensobject = {}
  local numnsoftheobjk = 65535 -- preASSume guilt
  if (type(strnstitle)=='string') then
    tabtitlensobject = mw.title.new(strnstitle) -- type "nil" for invalid
    if (type(tabtitlensobject)=='table') then
      numnsoftheobjk = tabtitlensobject.namespace
    end--if
  end--if
  return numnsoftheobjk
end--function lfwgetnsoftitle

------------------------------------------------------------------------

-- Local function LFWSPLIT3TITLE

local function lfwsplit3title (strsptitle)
  local tabtitlespobject = {}
  local strunfull = '' -- without prefix
  local strnstoxt = ''
  local numnsdetheobjk = 65535 -- preASSume guilt
  if (type(strsptitle)=='string') then
    tabtitlespobject = mw.title.new(strsptitle) -- type "nil" for invalid
    if (type(tabtitlespobject)=='table') then
      numnsdetheobjk = tabtitlespobject.namespace -- number
      if (numnsdetheobjk<=2000) then
        strunfull = tabtitlespobject.text -- string
        strnstoxt = tabtitlespobject.nsText -- string, can be empty, no colon
      else
        numnsdetheobjk = 65535
      end--if
    end--if
  end--if
  return numnsdetheobjk, strunfull, strnstoxt
end--function lfwsplit3title

------------------------------------------------------------------------

-- Local function LFWBREW3URL

-- Brew httplink to current project from title + http parameters + visible
-- text, making it look like an ordinary wikilink.

-- Input  : * arxinp4
--          * strwikipage -- title ie {{FULLPAGENAME}} or
--                           for example "Special:WhatLinksHere"
--          * strhttpparam -- for example "hidetrans=1&hidelinks=1" or empty
--          * strvisible -- for example "do NOT click here" or empty
--          * boozordinary -- "true" to look like an ordinary wikilink,
--                            "false" if this is undesirable or done outside

-- URL structure:
-- * https://en.wiktionary.org/wiki/Category:Vulgarities
-- * https://en.wiktionary.org/wiki/Category:Vulgarities?action=purge
-- * https://en.wiktionary.org/w/index.php?title=Category:Vulgarities
-- * https://en.wiktionary.org/w/index.php?title=Category:Vulgarities&action=purge
-- * https://en.wiktionary.org/wiki/Special:AllPages
-- * https://en.wiktionary.org/wiki/Special:AllPages?namespace=5
-- * https://en.wiktionary.org/wiki/Special:WhatLinksHere/Template:Bugger
-- * https://en.wiktionary.org/wiki/Special:WhatLinksHere/Template:Bugger?hidetrans=1&hidelinks=1
-- * https://en.wiktionary.org/w/index.php?title=Special:WhatLinksHere/Template:Bugger&hidetrans=1&hidelinks=1
-- * https://en.wiktionary.org/w/index.php?title=Special:WhatLinksHere&target=Template:Bugger&hidetrans=1&hidelinks=1

-- Only 4 ways to brew a URL:
-- * {{canonicalurl:{{FULLPAGENAME}}|action=purge}}
--       we use this one via ":preprocess", will work on any project
-- * {{SERVER}}{{SCRIPTPATH}}/index.php?title={{urlencode:{{FULLPAGENAME}}}}&action=purge
--       unnecessarily complicated
-- * LUA field "canonicalUrl" or "fullUrl" on "mw.uri" or "title object"
--       complicated and dubious
-- * manually
--       where to take project URL from ?? plus routine would land in [I] then

-- <span class="plainlinks">...</span>

local function lfwbrew3url (arxinp4, strwikipage, strhttpparam, strvisible, boozordinary)

  local strourresult = ''

  if (strhttpparam~='') then
    strwikipage = strwikipage .. '|' .. strhttpparam
  end--if
  strourresult = arxinp4:preprocess ('{{canonicalurl:' .. strwikipage .. '}}')
  if (strvisible=='') then
    strourresult = '[' .. strourresult .. ' ' .. strourresult .. ']'
  else
    strourresult = '[' .. strourresult .. ' ' .. strvisible .. ']'
  end--if
  if (boozordinary) then
    strourresult = '<span class="plainlinks">' .. strourresult .. '</span>'
  end--if
  return strourresult

end--function lfwbrew3url

------------------------------------------------------------------------

-- Local function LFWEATREFERENCES

-- Input  : * arxinp5
--          * strgroupname -- "1" for default group

local function lfweatreferences (arxinp5, strgroupname)
  local strzxcvbn = '<br><b>References '
  if (strgroupname=='1') then
    strzxcvbn = strzxcvbn .. 'main group'
  else
    strzxcvbn = strzxcvbn .. 'group "' .. strgroupname .. '"'
  end--if
  strzxcvbn = strzxcvbn .. '&nbsp;:</b>'
  if (strgroupname=='1') then
    strzxcvbn = strzxcvbn .. arxinp5:extensionTag('references')
  else
    strzxcvbn = strzxcvbn .. arxinp5:extensionTag('references','',{group=strgroupname})
  end--if
  return strzxcvbn
end--function lfweatreferences

------------------------------------------------------------------------

-- Local function LFWIFEXISIM !!!FIXME!!! use the tightfisted one

-- Simple check whether a wiki page exists. The caller must use "pcall". Here
-- we can crash on the spot if we violate the limit of 500 expensive requests.

-- Input  : * strpgnamsi   -- fullpagename (default NS 0, not template NS 10)

-- Output : * boomemangada -- "true" on success

local function lfwifexisim (strpgnamsi)
  local boomemangada = false
  local metaa = 0
  metaa = mw.title.new (strpgnamsi) -- 1 param
  boomemangada = metaa.exists -- expensive here
  return boomemangada
end--function lfwifexisim

------------------------------------------------------------------------

---- VERY HIGH LEVEL FUNCTIONS [Y] ----

------------------------------------------------------------------------

-- Local function LFYSPLITKAT

-- Split wikitext into two parts, namely cat insertions vs originally
-- visible remainder, format those cat insertions into a list, and
-- maybe brew an extra part too.

-- Input  : * strwikitextin
--          * tabparsmap -- nested: [0] findings | [1] main map |
--                          [2] boundary map -- MUST MATCH !!!
--          * boonohynts
--          * boobypass -- allow bypassing "hlt=1"

-- Output : * tabsplout -- 7 elements [0] str | [1] str | [2] str
--                         [3] num err | [4] num | [5] num dupes | [6] bypass

-- Depends on functions :
-- [W] lfwsplit3title
-- [H] lfhtabletohtmllist
-- [I] lfikatpaldigu lfigetleftright

-- Depends on constants :
-- * 3 strings (plain text) "constrca3d" "constrca4d" "constrca5d"

-- This is our holy core ;-)

-- We take one string and produce 2 strings, one of them for the cat
-- insertions, and the other one for the remaining ie originally visible
-- content. We walk forwards through string "strwikitextin" char after char
-- from begin of string to the end and take care of all "[[" (maybe a cat
-- insertion that needs to be cut out) and of "<pre>" (#A22, needs special
-- encoding of the affected area). All found cat insertions (except dupes
-- ie same name) are placed into two temporary tables (name and hint) and
-- skipped (also dupes, including both [[ and ]]) from copying as the main
-- visible content. Subsequently we walk through that table and postprocess
-- all those cat insertions. Finally we format them with help of
-- "lfhtabletohtmllist" into "strkattfinal".

-- A template can produce same cat insertion multiple times. This is not
-- optimal but possible. Even worse, the repetitive cat insertions may vary in
-- the sorting hint, or syntax details such as translated vs non-translated,
-- letter case or extra spaces. We grant a dupe if the names are identical,
-- irrespective of ns prefixes and hints. A target template producing
-- differing dupes would be highly dubious.

-- Visible wikilinks on level 2 are tolerated:
-- [[File:Shoplifting.PNG|thumb|a [[shoplifter]] in [[action]]]]
-- Cat insertions on level 2 are not, they give #S24:
-- [[File:Shoplifting.PNG|thumb|a shoplifter in action [[Category:Crime]]]]
-- We must also defend (with same #S24 on violation) against ordinary
-- wikilink inside a cat insertion:
-- [[Category:Crime|I [[be|am]] criminal]]

-- On a level 1...9 we skip from copying and collect instead into 2
-- destinations parallelly, namely "tabcollectlevel" separated by levels,
-- and into "strflatcoll" in a flat manner. At every "[[" the level is
-- increased (done by previous mapping, above 9 impossible). At level ONE
-- we empty "strflatcoll" and assign "boowasnested" to false. At every
-- level 2...9 we set "boowasnested" to true. It remains true when we
-- later drop back to level ONE. At every "]]" we close a level and
-- check title from "tabcollectlevel" invoking "lfwsplit3title" caring
-- about possible ":" whether it's a cat insertion assigning "boocathere".
-- A cat on level different from ONE gives immediate abort with #S24. When
-- closing level ONE going back to ZERO and
-- cat and "boowasnested" true then we abort with #S24, else ("boowasnested"
-- false) we try to store the cat, note that "tabcollectlevel[1]" and
-- "strflatcoll" had same content in that situation (sinking from ONE
-- to ZERO, cat here, and "boowasnested" false). If no cat then we dump
-- the accumulated text inside [[ ]] into "strmainout" instead.

-- The upper loop uses 4 tables, 3 of them are parallel and limited
-- to 12 cat:s (names, hints, bypass flags). A bypassed cat must look like:
-- <span title="bypass-pate">[[Kategori:Tracking-ubx-text-too-long]]</span>
-- Only if parameter "boobypass" requests it, we check for bypassed cat:s.
-- Only if bypass and not dupe, we count it in "booisbypas".
-- Up to 4 such are added into "strallbypass" standardized with possible hint.  !!!FIXME!!! imp incomplete

-- Sorting hints are displayed after the categories. For
-- example "[[Category:Crap|tujuh]]" gives visible text
-- "Category:<br>Crap| (<small>tujuh</small>)" where the visible wall must
-- be encoded (there is one more wall before that is NOT encoded). Spaces
-- in the hint are converted to underscores "_". The brackets make              !!!FIXME!!! underscores and why this ??
-- hints with spaces (like "[[Category:Crap| tujuh]]") more visible.

-- The cat insertions are formatted here (empty result impossible), whereas
-- the remaining ie originally visible content is raw (empty result possible).

local function lfysplitkat (strwikitextin, tabparsmap, boonohynts, boobypass)

  local tabcollectlevel = {} -- for upper loop, collect all wikilinks [[]]
  local tabnodupect = {} -- for upper loop, all cat names stored
  local tabtmpcatnm = {} -- for upper & lower loop, max 12 cat:s
  local tabtmpcathi = {} -- for upper & lower loop, max 12 cat:s
  local tabtmpcatby = {} -- for upper & lower loop, only "true", max 12 cat:s
  local tabsplout = {} -- 3 strings plus 4 integers inside, our final result
  local strkattfinal = '' -- for lower loop, all cat:s formatted -- for caller
  local strmainout = '' -- for upper loop, never reset -- for caller
  local strallbypass = '' -- for caller
  local strmy4left = '' -- for upper loop, split on wall "|"
  local strmy4rajt = '' -- for upper loop, split on wall "|"
  local strflatcoll = '' -- for upper loop, single cat, regularly reset
  local strwancxar = '' -- for upper loop
  local strtitfrom3sub = '' -- for upper loop, unfull title
  local strnstfrom3sub = '' -- for upper loop, nstext
  local strtajtl = '' -- for lower loop
  local strhiint = '' -- for lower loop
  local strvisible = '' -- for lower loop
  local numsperrorko = 0 -- split status / error code -- for caller
  local numkcount = 0 -- found cat:s excl dupes, count all -- for caller
  local numdupes = 0 -- number of dupes -- for caller
  local numbypass = 0 -- number of bypasses -- for caller
  local numwallstatus = 0 -- for upper loop, split on wall "|"
  local numnsfrom3sub = 0 -- for upper loop
  local numstrilen = 0 -- for upper loop
  local numchariix = 0 -- for upper loop, current
  local numtypearr = 0 -- for upper loop, current
  local numbounbb = 0 -- for upper loop, 1 for "B"
  local numbounee = 0 -- for upper loop, 2 for "E"
  local numreadonepos = 1 -- for upper loop -- ONE-based
  local numcnntcat = 0 -- for lower loop
  local booisbypass = false -- for upper loop
  local booinsidewili = false -- for upper loop
  local boowasnested = false -- for upper loop
  local boocathere = false -- for upper loop
  local booskiptwo = false -- for upper loop

  numstrilen = string.len (strwikitextin)

  if (tabparsmap[0][6] or tabparsmap[0][9] or tabparsmap[0][12] or tabparsmap[0][22]) then
    numsperrorko = 20 -- #S20 split NOT attempted due to other #M06 #M09 ...
  end--if
  if (tabparsmap[0][1] or tabparsmap[0][2] or tabparsmap[0][3] or (tabparsmap[0][20]>2)) then
    numsperrorko = 21 -- #S21 split NOT attempted due to nesting #M01 #M02 #M03 #M20>2
  end--if

  while true do -- upper genuine loop -- index is "numreadonepos"

    if ((numreadonepos>numstrilen) or (numsperrorko>=20)) then
      break -- no further hits possible or already f**ked
    end--if

    booskiptwo = false -- preASSume again for every iteration
    numbounee = 0 -- preASSume, worx even for "]]" at end of text
    numchariix = string.byte(strwikitextin,numreadonepos,numreadonepos)
    numtypearr = tabparsmap[1][numreadonepos] -- current type
    numbounbb = tabparsmap[2][numreadonepos] -- maybe "B" from current
    if (numreadonepos<numstrilen) then
      numbounee = tabparsmap[2][numreadonepos+1] -- maybe "E" on next
    end--if

    if (booinsidewili and (numbounee==2)) then -- "]]"
      numwallstatus, strmy4left, strmy4rajt = lfigetleftright (tabcollectlevel[numtypearr])
      tabcollectlevel[numtypearr] = nil -- kick after use
      if (numwallstatus==77) then
        numsperrorko = 3 -- #S03 wall + empty right, accept with complaint
      end--if
      if ((numwallstatus==75) or (numwallstatus==76)) then
        numsperrorko = 23 -- #S23 all empty or empty left, give up
        break
      end--if
      if (numwallstatus==79) then
        numsperrorko = 2 -- #S02 junk spaces, accept with complaint
      end--if
      numnsfrom3sub, strtitfrom3sub, strnstfrom3sub = lfwsplit3title (strmy4left)
      if (numnsfrom3sub>1024) then
        numsperrorko = 25 -- invalid title (empty "[[Category:]]" etc) #S25
        break -- give up
      end--if
      boocathere = ((numnsfrom3sub==14) and (string.byte(strmy4left,1,1)~=58))
      if (boocathere and (numtypearr~=1)) then
        numsperrorko = 24 -- #S24 cat insertion on level different from ONE
        break -- give up
      end--if
      if (numtypearr==1) then -- down from ONE to ZERO here
        if (boocathere) then
          if (boowasnested) then
            numsperrorko = 24 -- #S24 link inside cat insertion is bad too
            break -- give up
          else
            if (tabnodupect[strtitfrom3sub]) then
              numdupes = numdupes + 1 -- already in
            else
              tabnodupect[strtitfrom3sub] = true -- store it
              if (numkcount<=11) then
                tabtmpcatnm [numkcount] = strtitfrom3sub -- table ZERO-based
                tabtmpcathi [numkcount] = strmy4rajt -- table ZERO-based
              end--if
              numkcount = numkcount + 1 -- ZERO-based for return & table, NOT loop
            end--if (tabnodupect[strtitfrom3sub]) then
          end--if (boowasnested) else
        else
          strmainout = strmainout .. '[[' .. strflatcoll .. ']]' -- dump all the skipped stuff
        end--if (boocathere) else
        strflatcoll = '' -- decommission after use
        booinsidewili = false -- copy char:s into "strmainout" again
      end--if (numtypearr==1) then
      booskiptwo = true
    end--if

    if ((numbounbb==1) and (numtypearr<=9)) then -- "[["
      if (numtypearr==1) then
        booinsidewili = true -- do NOT copy char:s into "strmainout" for now
        boowasnested = false -- will get true on level 2, false only at ZERO
        strflatcoll = '' -- reset now and begin collecting here, incl "[["
      else
        boowasnested = true
      end--if
      tabcollectlevel[numtypearr] = '' -- reset on every level
      booskiptwo = true
    end--if

    if (booskiptwo) then

      numreadonepos = numreadonepos + 2 -- nothing copied

    else

      if ((numtypearr==22) and ((numchariix==38) or (numchariix==91) or (numchariix==93))) then
        strwancxar = "&#" .. tostring (numchariix) .. ";" -- dec-encode #A22
      else
        strwancxar = string.char(numchariix) -- pass
      end--if
      if (booinsidewili) then
        strflatcoll = strflatcoll .. strwancxar -- only unencoded possible
        tabcollectlevel[numtypearr] = tabcollectlevel[numtypearr] .. strwancxar
      else
        strmainout = strmainout .. strwancxar -- html-dec-encoded for <pre> only
      end--if
      numreadonepos = numreadonepos + 1

    end--if (booskiptwo) else

  end--while -- upper genuine loop

  numcnntcat = 0 -- counts up
  strkattprefix = mw.site.namespaces[14].name -- "Kategori:" on a sv wiki

  while true do -- lower genuine loop over collected cat:s -- postprocess them

    if (numsperrorko>=20) then
      break -- #S20
    end--if

    strtajtl = tabtmpcatnm [numcnntcat] -- table is ZERO-based
    strhiint = tabtmpcathi [numcnntcat] -- table is ZERO-based
    if (type(strtajtl)~='string') then
      break -- done
    end--if
    strvisible = strkattprefix .. ':<br>' .. strtajtl
    if (strhiint~='') then
      strvisible = strvisible .. ' &#124; (<small>' .. strhiint .. '</small>)'
    end--if
    tabtmpcatnm [numcnntcat] = lfikatpaldigu (strkattprefix, strtajtl, strvisible, 2) -- table is ZERO-based
    numcnntcat = numcnntcat + 1

  end--while -- lower genuine loop

  if (numsperrorko>=20) then
    strmainout = '' -- #S20 FATAL, delete possible partial result
    numkcount = 0 -- here too
  else
    if (numkcount==0) then
      strkattfinal = constrca3d -- no cat:s -- this MUST NOT be left empty
    else
      strkattfinal = lfhtabletohtmllist(tabtmpcatnm,true)
    end--if
    if (numkcount>=2) then -- no extra boast for ONE
      strkattfinal = '<small>' .. constrca4d .. ' ' .. tostring (numkcount) .. ' ' .. constrca5d .. ' :<br></small>' .. strkattfinal
    end--if
  end--if

  tabsplout[0] = strkattfinal -- catlist (cannot be empty unless we are FATAL)
  tabsplout[1] = strmainout -- main/noncat (can be empty)
  tabsplout[2] = strallbypass -- [[Category:Track-CO2]][[Category:Track-KCN]]
  tabsplout[3] = numsperrorko -- split status / error code
  tabsplout[4] = numkcount -- number of cat insertions
  tabsplout[5] = numdupes -- number of dupes
  tabsplout[6] = numbypass

  return tabsplout

end--function lfysplitkat

------------------------------------------------------------------------

---- VARIABLES [R] ----

------------------------------------------------------------------------

function exporttable.ek (arxframent)

  -- special type "args" AKA "arx"

  local arxsomons = 0  -- metaized "args" from our own or caller's "frame"

  -- tab

  local tabpaarsemap = {}   -- nested
  local tabkolom = {}       -- [0]...[5] from "sel=" still dupe of individual

  -- str from parameters

  local strmainanon = ''  -- incoming, later [[ ]] removed
  local strsel = ''       -- 7 char:s ctl string
  local strtit = ''       -- title chain to replace values in "contabcolumns"
  local strwar = ''
  local strmod = ''       -- name of function, "1" prohibited
  local strhid = ''       -- either empty or 4...1'000, see "lfipairxatxalt"
  local strrem = ''
  local strref = ''
  local strreg = ''

  -- str from expansion and split

  local strzzfullrs = ''  -- full result of expansion before split
  local strzzcatlst = ''  -- catlist part after split
  local strzznoncat = ''  -- noncat part after split
  local strzzbypass = ''  -- bypass part raw chained cat insertions or empty

  -- str misc

  local strtmplnwp = ''     -- target, always with prefix unless "zer=1"
  local strfullono = ''     -- fullpagename from MediaWiki
  local strbigexpander = '' -- for "arxframent:preprocess"
  local strvorurefojn = ''  -- from "strref" & "strreg" with some text & HTML

  local strtymp = ''

  local strvisgud = ''  -- visible good output
  local strviserr = ''  -- visible error message
  local strret    = ''  -- final result string

  -- num from parameters

  local numspec = 0       -- ZERO not special | 7 ":top" | 8 res | 9 ":end"
  local numxcolumns = 0   -- number of columns requested (1...6, ZERO invalid)
  local numtabtype = 0    -- from "tab=" 0...5
  local numborwidt = 0    -- from "bor=" 5...80 ("0.05em"..."0.80em")

  -- num from anon param

  local numwhitebeg = 0   -- 10 or 32 for whitespace at begin after {{
  local numwhiteend = 0   -- 10 or 32 for whitespace at end before }}

  -- num from expansion and split

  local numpexpasta = 0   -- expand sta (0 no att | 70 OK ...)
  local numzfullrs = 0    -- len of full result of expansion before split
  local numzsplitsta = 20 -- preASSume split status #S20 (ZERO 2...6 20...40)
  local numzjumlahkt = 0  -- number of categories (all non-dupes counted)
  local numzjumlahdp = 0  -- number of dupes
  local numznoncat = 0    -- len of noncat part after split

  -- num status

  local numerr = 0        -- ZERO OK | 1 ?? | 2 anon | 3 adv anon | 4 "sel="

  -- boo from "sel="

  local boocall = false        -- column "call"
  local boosmall = false       -- small text, from "2" in "sel=" colu "call"
  local booparsed = false      -- column "parsed"
  local boorem = false         -- column "rem" (see also "strrem")
  local boocat = false         -- column "cat"
  local boonohints = false     -- omit hints, from "2" in "sel=" colu "cat"     !!!FIXME!!!
  local booback = false        -- column "back"
  local boodebug = false       -- column "debug"
  local booyescolour = false   -- have "2" in the digit for "debug"
  local boomapinstead = false  -- have "3" in the digit for "debug"

  -- boo from single parameters

  local boozer = false         -- have "zer=1"
  local boo3nsm12 = false      -- have "nsm=1" or "nsm=2" process {({ })}
  local boo3nsm2m = false      -- have "nsm=2"
  local boohlt = false         -- have "hlt=1"
  local booncf = false         -- have "ncf=1"

  -- boo subsequent from parameters

  local bootitrow = false      -- title row only for ":top" & table type 3
  local boousetit = false      -- titles only for ":top" & table types 3 & 5
  local boodoexpand = false    -- request from "parsed" or "cat" or "debug"

  -- boo misc

  local boosamepage = false    -- keep false for special mode "numspec" too

------------------------------------------------------------------------

---- MAIN [Z] ----

------------------------------------------------------------------------

  ---- GUARD AGAINST INTERNAL ERROR AGAIN ----

  if (qbooguard) then
    numerr = 1 -- #E01 internal
  end--if

  ---- PROCESS MESSAGES, FILL IN NEVER, SURR ONLY IF NEEDED ----

  if (numerr==0) then
    contaberaroj  = lfhfillsurrstrtab (contaberaroj, constrkoll, constrpriv)
    contabxxplain = lfhfillsurrstrtab (contabxxplain, constrkoll, constrpriv)
    constrbalik   = lfhfillsurrstrtab (constrbalik, nil, constrpriv)
    constrredir   = lfhfillsurrstrtab (constrredir, nil, constrpriv)
  end--if

  ---- GET THE ARX (ONE OF TWO) ----

  -- must be seized independently on "numerr" even if we already suck

  -- give a f**k in possible params other than "caller=true"

  arxsomons = arxframent.args -- "args" from our own "frame"
  if (type(arxsomons)~='table') then
    arxsomons = {} -- guard against indexing error from our own
    numerr = 1 -- #E01 internal
  end--if
  if (arxsomons['caller']=='true') then
    arxsomons = arxframent:getParent().args -- "args" from caller's "frame"
  end--if
  if (type(arxsomons)~='table') then
    arxsomons = {} -- guard against indexing error again
    numerr = 1 -- #E01 internal
  end--if

  ---- WHINE IF YOU MUST #E01 ----

  -- reporting of this error #E01 must NOT depend on
  -- uncommentable stuff such as "constrkoll" and "contaberaroj"

  -- do NOT use sub "lfhbrewerror", report our name (NOT of template), in EN

  if (numerr==1) then -- !!!FIXME!!! seizing pagename below
    strtymp = '#E01 Internal error in module "pate".'
    strviserr = constrlaxhu .. constrelabg .. strtymp .. constrelaen .. constrlaxhu
  end--if

  ---- SEIZE TWO UNDESIRABLE NAMED PARAMETERS ----

  if (type(arxsomons['trackingcategorieshiglow'])=='string') then
    numerr = 30 -- #E30 NOT appreciated like this (use "hlt=1")
  end--if
  if (type(arxsomons['nocat'])=='string') then
    numerr = 31 -- #E31 NOT appreciated like this (use "ncf=1") or avoid
  end--if

  ---- SEIZE ONE ANONYMOUS AND OBLIGATORY PARAMETER ----

  -- ":top" or ":end" or raw (no wall) or protected (at least one wall)
  -- #E03 param absent or wrong length
  -- #E04 more advanced faults (namely [[ | ]] [ ] see section below)
  -- assign "numspec" to 0,7,8,9
  -- assign "strmainanon" (preliminary content, see below)

  strmainanon = '' -- preASSume guilt
  if (numerr==0) then
    do -- scope
      local vartutpum = 0
      local numlunng = 0
      vartutpum = arxsomons[1] -- required
      if (type(vartutpum)=='string') then
        numlunng = string.len (vartutpum)
        if ((numlunng>0) and (numlunng<10001)) then
          strmainanon = lfgtrimwhite (vartutpum) -- wiki does NOT strip anon
        end--if
      end--if
    end--do scope
  end--if (numerr==0) then
  if ((numerr==0) and (strmainanon=='')) then
    numerr = 3 -- #E03
  end--if

  if (numerr==0) then
    if (strmainanon==':top') then
      numspec = 7 -- top with title row
    end--if
    if (strmainanon==':end') then
      numspec = 9 -- end
    end--if
  end--if (numerr==0) then

  ---- SEIZE UP TO 14 NAMED PARAMETERS ----

  -- tab= (*), sel=, tit=, war=, bor=
  -- mod= (*), zer= (*), nsm= (*), hid= (*), rem= (*)
  -- ref= (*), reg= (*), hlt= (*), ncf= (*)
  -- * 8 give string, two of them "strsel" "strtit" pluprocessed
  --   later, one of them "tit=" additionally gives boolean
  -- * 2 give integer ("tab=" and "bor=")
  -- * 1 is tristate and gives 2 booleans ("nsm=")
  -- * 3 give boolean ("zer=1" "hlt=1" "ncf=1")
  -- those marked with (*) are prohibited for ":top"
  -- all are prohibited for ":end"

  -- this must follow the seizure of the anonymous parameter due to
  -- "numspec" that we query here, and this must precede pluprocessing
  -- of the anonymous parameter (call string) due to "zer=1"

  if (numerr==0) then
    do -- scope

      local var38pom = 0
      local var38valu = 0
      local num38stat = 0
      local numluung = 0 -- !!!FIXME!!!

      numtabtype = 2 -- preASSume default
      var38pom = arxsomons['tab'] -- 1 digit, can be "0"..."5", default is "2"
      num38stat, var38valu = lfichkparam (var38pom, 1, 0, 5)
      if (num38stat==1) then
        numerr = 29 -- #E29 "tab=" bad
      end--if
      if (num38stat==2) then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          if (numspec~=0) then
            numerr = 7 -- #E07 "tab=" prohi for ":top"
            break
          end--if
          numtabtype = var38valu
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

      var38pom = arxsomons['sel'] -- 6 + 1 control string column control
      num38stat, var38valu = lfichkparam (var38pom, 0, 7, 7)
      if (num38stat==1) then
        numerr = 9 -- #E09 "sel=" bad -- more checks below
      end--if
      if (num38stat==2) then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          strsel = var38valu -- there are 2 defaults, bother about them later
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

      var38pom = arxsomons['tit'] -- length 1...200 and 1...6 title strings
      num38stat, var38valu = lfichkparam (var38pom, 0, 1, 200)
      if (num38stat==1) then
        numerr = 10 -- #E10 "tit=" bad -- more checks below
      end--if
      if (num38stat==2) then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          strtit = var38valu -- default empty here & more in "contabcolumns"
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

      strwar = '60A0A0' -- preASSume default bluegreen
      var38pom = arxsomons['war'] -- table line color, always 6 hex digits
      num38stat, var38valu = lfichkparam (var38pom, 6, 0, 0)
      if (num38stat==1) then
        numerr = 11 -- #E11 "war=" bad
      end--if
      if (num38stat==2) then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          strwar = var38valu
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

      numborwidt = 20 -- preASSume default "0.20em"
      var38pom = arxsomons['bor'] -- 2 digits
      if (type(var38pom)=='string') then
        numborwidt = lfstrtwdig2int(var38pom)
        if ((numborwidt<5) or (numborwidt>80)) then
          numerr = 12 -- #E12 "bor=" bad
        end--if
      end--if (type(var38pom)=='string') then

      var38pom = arxsomons['mod'] -- name of LUA function
      num38stat, var38valu = lfichkparam (var38pom, 0, 1, 60)
      if (num38stat==1) then
        numerr = 17 -- #E17 "mod=" bad
      end--if
      if (num38stat==2) then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          if (numspec~=0) then
            numerr = 7 -- #E07 "mod=" prohi for ":top"
            break
          end--if
          if (var38valu=='1') then
            numerr = 17 -- #E17 "mod=" bad, need name of function, not "1"
            break
          end--if
          strmod = var38valu
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

      var38pom = arxsomons['zer'] -- length 1 only, prohibited for special
      if (type(var38pom)=='string') then
        if ((string.len(var38pom)==1) and (numspec==0)) then
          boozer = (var38pom=="1")
        else
          numerr = 7 -- #E07 "zer=" prohi for ":top"
          numerr = 18 -- #E18 "zer=" bad
        end--if
      end--if

      var38pom = arxsomons['nsm'] -- length 1 only, prohibited for special
      if (type(var38pom)=='string') then
        if ((string.len(var38pom)==1) and (numspec==0)) then -- tristate
          boo3nsm2m = (var38pom=="2")
          boo3nsm12 = boo3nsm2m or (var38pom=="1")
        else
          numerr = 7 -- #E07 "nsm=" prohi for ":top"
          numerr = 13 -- #E13 "nsm=" bad
        end--if
      end--if

      var38pom = arxsomons["hid"] -- length 4...1000, prohibited for special
      if (type(var38pom)=='string') then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          numluung = string.len (var38pom)
          if ((numluung<4) or (numluung>1000) or (numspec~=0)) then
            numerr = 7 -- #E07 "hid=" prohi for ":top"
            numerr = 14 -- #E14 "hid=" bad early detect
            break
          end--if
          if (lficheckforbad(var38pom)) then
            numerr = 14 -- #E14 "hid=" bad [[ ]] {({ })} ''
            break
          end--if
          strhid = lfipairxatxalt (var38pom)
          if (strhid=='') then -- empty legal but NOT here
            numerr = 14 -- #E14 "hid=" bad due to @@
          end--if
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

      strrem = constrempt -- preASSume placeholder
      var38pom = arxsomons["rem"] -- length 1...1000, prohibited for special
      if (type(var38pom)=='string') then
        numluung = string.len (var38pom)
        if ((numluung>=1) and (numluung<=1000) and (numspec==0)) then
          strrem = var38pom
        else
          numerr = 7 -- #E07 "rem=" prohi for ":top"
          numerr = 15 -- #E15 "rem=" bad
        end--if
      end--if

      var38pom = arxsomons["ref"] -- length 1...20, prohibited for special
      if (type(var38pom)=='string') then
        numluung = string.len (var38pom)
        if ((numluung>=1) and (numluung<=20) and (numspec==0)) then
          strref = var38pom
        else
          numerr = 7 -- #E07 "ref=" prohi for ":top"
          numerr = 22 -- #E22 "ref=" bad
        end--if
      end--if
      var38pom = arxsomons["reg"] -- length 1...20, prohibited for special
      if (type(var38pom)=='string') then
        numluung = string.len (var38pom)
        if ((numluung>=1) and (numluung<=20) and (numspec==0) and (strref~='') and (var38pom~=strref)) then
          strreg = var38pom
        else
          numerr = 7 -- #E07 "reg=" prohi for ":top"
          numerr = 22 -- #E22 "reg=" bad
        end--if
      end--if

      var38pom = arxsomons["hlt"] -- length 1 only, prohibited for special
      if (type(var38pom)=='string') then
        if ((string.len(var38pom)==1) and (numspec==0)) then -- boolean
          boohlt = (var38pom=="1")
        else
          numerr = 7 -- #E07 "hlt=" prohi for ":top"
          numerr = 19 -- #E19 "hlt=" bad
        end--if
      end--if

      var38pom = arxsomons['ncf'] -- length 1 only, prohibited for special
      num38stat, var38valu = lfichkparam (var38pom, 1, 0, 1)
      if (num38stat==1) then
        numerr = 21 -- #E21 "ncf=" bad
      end--if
      if (num38stat==2) then
        while true do -- fake loop
          if (numspec==9) then
            numerr = 6 -- #E06 no named param legal for ":end"
            break
          end--if
          if (numspec~=0) then
            numerr = 7 -- #E07 "ncf=" prohi for ":top"
            break
          end--if
          booncf = (var38valu==1)
          break -- finally to join mark
        end--while -- fake loop -- join mark
      end--if

    end--do scope
  end--if (numerr==0) then

  ---- PICK ONE OF 2 DEFAULTS ----

  -- this must follow seizure of anon (-> "numspec") and
  -- named ("numtabtype", "strsel")

  -- do this for special work ":top" too

  if ((numerr==0) and (numspec~=9) and (strsel=='')) then
    if (numtabtype==0) then
      strsel = '010-000' -- show only parsed result
    else
      strsel = '111-110' -- show all except debug
    end--if
  end--if

  ---- PLUPROCESS CONTROL STRING TO 6 BOOLEANS ----

  -- this must follow assigning default value to "sel="

  -- do this for special work ":top" too

  -- assign 6 + 4 booleans as well as tabkolom
  -- assign "numxcolumns" to 1...6 (ZERO is illegal)
  -- assign "boodoexpand"

  if ((numerr==0) and (numspec~=9)) then
    do -- scope
      local numsilur = 0
      while true do -- fake loop
        numsilur = lfivaliumdctlstr ('211-213',strsel)
        if (numsilur~=255) then
          break -- less than 255 is bad above, 777 would be good below
        end--if
        numsilur = string.byte (strsel,1,1) -- tristate "call"
        boocall = (numsilur~=48)
        boosmall = (numsilur==50)
        tabkolom[0] = boocall
        numxcolumns = numxcolumns + contabboo2int[boocall]
        numsilur = string.byte (strsel,2,2)
        booparsed = (numsilur==49)
        tabkolom[1] = booparsed
        numxcolumns = numxcolumns + contabboo2int[booparsed]
        numsilur = string.byte (strsel,3,3)
        boorem = (numsilur==49)
        tabkolom[2] = boorem
        numxcolumns = numxcolumns + contabboo2int[boorem]
        numsilur = string.byte (strsel,5,5) -- tristate "cat"
        boocat = (numsilur~=48)
        boonohints = (numsilur==50)
        tabkolom[3] = boocat
        numxcolumns = numxcolumns + contabboo2int[boocat]
        numsilur = string.byte (strsel,6,6)
        booback = (numsilur==49)
        tabkolom[4] = booback
        numxcolumns = numxcolumns + contabboo2int[booback]
        numsilur = string.byte (strsel,7,7) -- fourstate "debug"
        boodebug = (numsilur~=48)
        booyescolour = (numsilur==50) -- not useful for ":top"
        boomapinstead = (numsilur==51) -- not useful for ":top"
        tabkolom[5] = boodebug
        numxcolumns = numxcolumns + contabboo2int[boodebug]
        if (numxcolumns==0) then -- empty table not legal
          break -- 777 would be good below, 48 or 49 is bad too
        end--if
        boodoexpand = booparsed or boocat or boodebug
        numsilur = 777 -- magic for "all OK"
        break -- finally to join mark
      end--while -- fake loop -- join mark
      if (numsilur~=777) then
        numerr = 9 -- #E09 "sel=" bad
      end--if
    end--do scope
  end--if ((numerr==0) and (numspec~=9)) then

  ---- CATCH SOME TOXIC MIXTURES ----

  if ((numerr==0) and (numxcolumns>=2) and (numtabtype==0)) then
    numerr = 25 -- #E25 "sel=" conflicts with "tab="
  end--if

  if ((numerr==0) and (strmod~='') and boozer) then
    numerr = 26 -- #E26 "mod=" and "zer=1" must NOT be used together
  end--if

  ---- PLUPROCESS THE HOLY CALL STRING FOR MORE/MULTI ----

  -- minimal content is "[[{({a})}]]" or "[[a]]" (degenerated but valid)

  if ((numerr==0) and (numspec==0) and boo3nsm2m) then -- "nsm=2"
    while true do -- fake loop
      if (string.len(strmainanon)<5) then
        numerr = 4 -- #E04
        break -- to join mark
      end--if
      if ((string.sub(strmainanon,1,2)~='[[') or (string.sub(strmainanon,-2,-1)~=']]')) then
        numerr = 4 -- #E04
        break -- to join mark
      end--if
      strmainanon = lfgtrimwhite(string.sub(strmainanon,3,-3)) -- strip [[ ]] + trim white
      break -- finally to join mark
    end--while -- fake loop -- join mark
  end--if

  ---- PLUPROCESS THE HOLY CALL STRING FOR SINGLE TARGET ----

  -- separate bare name from complete template call inside
  -- unorthodox brackets, and bother with namespace prefixes

  -- not needed for "special" mode ":top" & ":end"
  -- not needed for more/multi mode

  -- incoming "strmainanon", length is 1...10'000, we do NOT alter it
  -- in any way except strip off [[ ]] and adjacent whitespace if present

  -- this depends on "numspec" and "zer=1"

  -- to assess the string as complete template call:
  -- * 3 discoveries [[ | ]] must be consistently true
  -- * length must be over 7 -- minimal content is "[[a|b]]"

  -- output:
  -- * complete template call "strmainanon" -- possible prefix for ns 10 is
  --   not added and not stripped either, other prefix possible, used for
  --   both expansion and display
  -- * prefixed name "strtmplnwp" -- always has a ns prefix (unless "zer=1")

  -- order of work:
  -- * do some checks on "strmainanon" and assign scoped
  --   "boohavparip", risk of #E04
  -- * if param then strip off [[ ]] + ws from "strmainanon" and do
  --   more checks, split off parameter chain + ws, result is
  --   "strcommon", risk of #E04
  -- * else (if no param) no strip no split but perform other checks,
  --   "strcommon" copied from "strmainanon", and "strmainanon"
  --   unchanged, risk of #E04
  -- * check whether the title is safe, risk of #E05
  -- * split off ns prefix and assign "strtmplnwp" re-adding it

  -- for both expansion and display we will later possibly add ":" and
  -- always add {{ }} , but there are some intermediate steps for expansion
  -- thus we MUST NOT do it here, and before that we will fix nesting for both

  if ((numerr==0) and (numspec==0) and (not boo3nsm2m)) then
    do -- scope

      local varfindwall = 0
      local strcommon = ''
      local strunfu7ll = ''
      local strnom7spaco = ''
      local numthisleen = 0
      local numnonsens = 0
      local boohavbigwall = false
      local boorectabegin = false
      local boorectaakhir = false
      local boohavparip = false  -- have param inside anon param thus [[ | ]]

      while true do -- fake loop

        numthisleen = string.len(strmainanon)
        numnonsens = string.byte(strmainanon,1,1) -- string cannot be empty
        if ((numnonsens==58) or (numnonsens==93) or (numnonsens==123) or (numnonsens==124) or (numnonsens==125)) then
          numerr = 4 -- #E04
          break -- to join mark -- invalid char at begin :]{|}
        end--if
        if (strmainanon=='[') then
          numerr = 4 -- #E04
          break -- to join mark -- invalid one-char name "["
        end--if
        if (numthisleen>=2) then -- chk consistency
          boohavbigwall = (string.find(strmainanon,'|',1,true)~=nil)
          boorectabegin = (string.sub(strmainanon,1,2)=='[[')
          boorectaakhir = (string.sub(strmainanon,-2,-1)==']]')
          if ((boohavbigwall~=boorectabegin) or (boohavbigwall~=boorectaakhir) or (boorectabegin~=boorectaakhir)) then
            numerr = 4 -- #E04
            break -- to join mark -- inconsistent discoveries
          end--if
          boohavparip = boohavbigwall
          if (boohavparip and (numthisleen<7)) then
            numerr = 4 -- #E04
            break -- to join mark -- below minimal content "[[a|b]]"
          end--if
        end--if (numthisleen>=2) then

        if (boohavparip) then -- length at least 7 guaranteed
          strmainanon = string.sub(strmainanon,3,-3) -- strip [[ ]] no ws yet
          numwhitebeg = string.byte(strmainanon,1,1)   -- & will later recover
          numwhiteend = string.byte(strmainanon,-1,-1) -- & ws to sane degree
          strmainanon = lfgtrimwhite(strmainanon) -- !!!CRUCIAL!!! trim white
          if (string.len(strmainanon)<3) then
            numerr = 4 -- #E04
            break -- to join mark -- below minimal content "a|b"
          end--if
          if ((string.byte(strmainanon,1,1)==124) or (string.byte(strmainanon,-1,-1)==124)) then
            numerr = 4 -- #E04
            break -- to join mark -- wall misplaced
          end--if
          varfindwall = string.find(strmainanon,'|',1,true) -- must find it
          strcommon = lfgtrimwhite(string.sub(strmainanon,1,(varfindwall-1))) -- isolate name
        else
          if ((string.find(strmainanon,'[',1,true)) or (string.find(strmainanon,']',1,true))) then
            numerr = 4 -- #E04
            break -- to join mark -- illegal [ ] in raw template name
          end--if
          strcommon = strmainanon
        end--if (boohavparip) else

        if (not lfwistitlesafe (strcommon)) then
          numerr = 5 -- #E05 invalid title
          break
        end--if

        numnonsens, strunfu7ll, strnom7spaco = lfwsplit3title (strcommon)
        if (numnonsens>200) then
          numerr = 5 -- #E05 invalid title
          break
        end--if
        if ((numnonsens~=0) and boozer) then
          numerr = 18 -- #E18 bad use of "zer=1"
          break
        end--if
        if ((numnonsens==0) and (not boozer)) then -- add prefix for ns 10
          strcommon = mw.site.namespaces[10].name .. ':' .. strcommon
          numnonsens, strunfu7ll, strnom7spaco = lfwsplit3title (strcommon)
          if (numnonsens==0) then -- hopefully impossible
            numerr = 5 -- #E05 invalid title
            break
          end--if
        end--if
        if (boozer) then
          strtmplnwp = strunfu7ll -- would have prefix but there is none
        else
          strtmplnwp = strnom7spaco .. ':' .. strunfu7ll -- add prefix
        end--if

        break -- finally to join mark
      end--while -- fake loop -- join mark

    end--do scope
  end--if ((numerr==0) and (numspec==0) and (not boo3nsm2m)) then

  ---- SEIZE FULLPAGENAME AND COMPARE ----

  -- not needed for "special" mode ":top" & ":end"

  -- note that "prefixedText" contains translated ns prefix, thus
  -- "strtmplnwp" must use same pattern

  -- flag "boosamepage" affects the structure of the "call"
  -- cell to avoid self-link

  if ((numerr==0) and (numspec==0)) then
    strfullono = mw.title.getCurrentTitle().prefixedText
    boosamepage = (strfullono==strtmplnwp) -- both are standardized ;-)
  end--if

  ---- PREPARE TITLES ----

  -- titles are needed for ":top" (also HTML row) and table
  -- type 3 (hor) (also HTML row) and type 5 (ver) (but no HTML row)

  -- split "tit=" in "strtit" at "@@" and merge into
  -- "qtabmy6columns" using defaults from "contabcolumns"

  -- do this for special work ":top" too

  if (numerr==0) then
    bootitrow = (numspec==7) or (numtabtype==3) -- ":top" or compete hor table
    boousetit = bootitrow or (numtabtype==5) -- titles yes but no row for 5
  end--if

  if (boousetit) then
    qtabmy6columns = lfhatmergetab (strtit, tabkolom, contabcolumns) -- "strtit" can be empty
    if (qtabmy6columns[9]) then
      numerr = 10 -- #E10 "tit=" bad
    end--if
  end--if

  ---- PREPARE FOR EXPANSION ----

  -- * complete template call "strmainanon" -- possible prefix for ns 10 is
  --   not added and not stripped either, other prefix possible, used for
  --   both expansion and display
  -- * prefixed name "strtmplnwp" -- always has a ns prefix (unless "zer=1")

  -- * "strbigexpander" is for "arxframent:preprocess" only
  -- * "strhid" is either empty or begins with a wall

  -- here we restore ordinary form from extra protection ie "{({"..."})}"
  -- and variations of "renef", even if we don't expand, on "strmainanon"
  -- without "strhid", this affetcs both the showed text and the string
  -- fed into expansion

  if ((numerr==0) and (numspec==0) and boo3nsm12) then
    strmainanon = lfirestorefromextra (strmainanon)
  end--if

  if ((numerr==0) and (numspec==0) and boodoexpand and boo3nsm2m) then
    strbigexpander = strmainanon
  end--if

  if ((numerr==0) and (numspec==0) and boodoexpand and (not boo3nsm2m)) then
    strbigexpander = strmainanon .. strhid
    strtymp = lfgdeleteallwhite(strbigexpander)
    if (string.find(strtymp,'|trackingcategorieshiglow=',1,true)) then
     numerr = 30 -- #E30 NOT appreciated
    end--if
    if (string.find(strtymp,'|nocat=',1,true)) then
     numerr = 31 -- #E31 NOT appreciated
    end--if
    if (numerr==0) then
      if (boohlt) then
        strbigexpander = strbigexpander .. '|trackingcategorieshiglow=true' -- add after check
      end--if
      if (booncf) then
        strbigexpander = strbigexpander .. '|nocat=false' -- add after check
      end--if
      strbigexpander = lfibrewcurlycall (boozer,strbigexpander,0,0) -- last step
    end--if (numerr==0) then
  end--if

  ---- CHECK WHETHER THE TARGET PAGE (TEMPLATE) EXISTS AT ALL ----

  -- here YES "msgnw:" !!!FIXME!!!

  if (boodoexpand and (numerr==0) and (numspec==0)) then
    if (boo3nsm2m) then
      numpexpasta = 1 -- #X01 skip check for "nsm=2"
    else
      if (lfwifexisim(strtmplnwp)) then
        numpexpasta = 1 -- #X01 good so far
      else
        numpexpasta = 80 -- #X80 target does NOT exist
      end--if
    end--if
  end--if

  ---- EXPAND THE TEMPLATE AND SPLIT THE OUTPUT IF NEEDED ----

  -- here use "arxframent:preprocess" and NO "msgnw:"

  -- * the {{-}}-syntax assumes ns 10 if no prefix and no colon
  -- * if the split fails and the "debug" column is available then we must NOT
  --   brew any FATAL, instead show the full text plus the status code there

  -- "strzzfullrs" full result of expansion, len is "numzfullrs"
  -- "strzzcatlst" catlist part after split, no len, see "numzjumlahkt"
  -- "strzznoncat" noncat part after split, len is "numznoncat"
  -- "numzsplitsta" split status (ZERO or 2...6 or 20...40)
  -- "numzjumlahkt" number of categories (all non-dupes counted)
  -- "numzjumlahdp"

  if (numpexpasta==1) then -- expand requested and target exists
    do -- scope
      local tabrezu3v = {}
      strzzfullrs = arxframent:preprocess (strbigexpander)
      if ((type(strzzfullrs))=='string') then
        numpexpasta = 70 -- preASSume expand success #X70
        numzfullrs = string.len(strzzfullrs) -- total bloat
        if (numzfullrs==0) then
          numpexpasta = 82 -- #X82 empty string
        end--if
      else
        numpexpasta = 81 -- #X81 expand failure in wiki parser
      end--if ((type(strzzfullrs))=='string') else
      if (numpexpasta==70) then
        tabpaarsemap = lfhparsemap (strzzfullrs) -- BIG MAP HERE
        tabrezu3v = lfysplitkat (strzzfullrs, tabpaarsemap, boonohints, boohlt) -- BIG SPLIT HERE
        numzsplitsta = tabrezu3v[3] -- split status
        numzjumlahkt = tabrezu3v[4] -- number of cat:s (all non-dupes counted)
        numzjumlahdp = tabrezu3v[5] -- dupes
        if (numzsplitsta<=6) then -- ZERO OK | 2...6 non-fatal | 20...40 bad
          strzzcatlst = tabrezu3v[0] -- cat:s
          strzznoncat = tabrezu3v[1] -- main/noncat
          strzzbypass = tabrezu3v[2] -- empty string if not used
          numznoncat = string.len(strzznoncat) -- len of main/noncat part
        end--if
      end--if (numpexpasta==70) then
    end--do scope
  end--if (numpexpasta==1) then

  ---- ASSIGN ---

  -- insert 2 digits then 6 digits, whereas margin is fixed
  -- <table style="margin:0.6em;border:0.20em solid #60A0A0;border-collapse:collapse;">
  -- <td style="border:0.20em solid #60A0A0;padding:0.5em;text-align:center;">

  -- "qstrtdbegin" and "qstrtdendus" used in "lficondicelrow"

  qstrtabegin = contabtabeg[0] .. lfnumto2digit(numborwidt) .. contabtabeg[1] .. strwar .. contabtabeg[2]
  qstrtdbegin = contabtdbeg[0] .. lfnumto2digit(numborwidt) .. contabtdbeg[1] .. strwar .. contabtdbeg[2]
  qstrtdendus = '</td>'
  qstrtaendus = '</table>'

  ---- BOTHER WITH REFERENCES ----

  -- if "strvorurefojn" is non-empty then it will be later
  -- showed in the "parsed" cell

  if ((numerr==0) and (strref~='')) then
    strvorurefojn = lfweatreferences (arxframent, strref)
    if (strreg~='') then
      strvorurefojn = strvorurefojn .. lfweatreferences (arxframent, strreg)
    end--if
  end--if

  ---- BREW TITLE ROW FOR SPECIAL 7 OR TYPE 3 BUT NOT TYPE 5 ----

  if ((numerr==0) and bootitrow) then
    strtymp = '' -- important to start with empty
    if (boocall) then
      strtymp = strtymp .. qstrtdbegin .. qtabmy6columns[0] .. qstrtdendus
    end--if
    if (booparsed) then
      strtymp = strtymp .. qstrtdbegin .. qtabmy6columns[1] .. qstrtdendus
    end--if
    if (boorem) then
      strtymp = strtymp .. qstrtdbegin .. qtabmy6columns[2] .. qstrtdendus
    end--if
    if (boocat) then
      strtymp = strtymp .. qstrtdbegin .. qtabmy6columns[3] .. qstrtdendus
    end--if
    if (booback) then
      strtymp = strtymp .. qstrtdbegin .. qtabmy6columns[4] .. qstrtdendus
    end--if
    if (boodebug) then
      strtymp = strtymp .. qstrtdbegin .. qtabmy6columns[5] .. qstrtdendus
    end--if
    if (numtabtype==3) then
      strtymp = strtymp .. '</tr><tr>' -- separate rows now, outer <tr> later
    end--if
    strvisgud = strtymp
  end--if ((numerr==0) and bootitrow) then

  ---- BREW THE RESULT ORDINARY ----

  -- "call", "parsed", "rem", "cat", "back", "debug"

  -- 0 raw | 1 bunch of cells | 2 (defa) row | 3 compl hori 1+1 rows
  -- 4 compl hori 1 row | 5 compl vert 1...6 rows

  -- note that in output from a module {{ }} is NO LONGER processed
  -- by wiki parser but [[ ]] still is

  if ((numerr==0) and (numspec==0)) then
    do -- scope
      local strkombo = ''
      local strt7mp = ''
      local strt8mp = ''
      local strrezord = '' -- important to start with empty
      local boogoodresult = false
      strkombo = lficombostatus (numpexpasta,numzsplitsta) -- empty string on success
      boogoodresult = (strkombo=='')
      if (boocall) then
        strt8mp = strmainanon
        if (not boo3nsm2m) then
          strt8mp = lfibrewcurlycall (boozer,strt8mp,numwhitebeg,numwhiteend) -- maybe ":" SPC LF always {{ }}
        end--if
        strt8mp = lfidecencodbr (strt8mp,true) -- see "Encoding of text"
        if (boosamepage or boo3nsm2m) then
          strt7mp = strt8mp -- avoid selflink or link to more/multi text
        else
          strt7mp = '[[' .. strtmplnwp .. '|' .. strt8mp .. ']]' -- "}}" is visible but "]]" is NOT
        end--if
        strt7mp = lfipretable (strt7mp,contabboo2siz[boosmall]) -- inner table with font size
        strrezord = strrezord .. lficondicelrow (strt7mp,numtabtype,0)
      end--if (boocall) then
      if (booparsed) then
        if (boogoodresult) then
          strt7mp = strzznoncat .. strvorurefojn -- both can be empty, no #X82
          if (numtabtype~=0) then
            strt7mp = lfilefqdivqlefqtxt(string.char(10) .. strt7mp) -- add LF due wiki parser, outside left inside left full width
          end--if
        else
          strt7mp = lfiexplain (strkombo)
        end--if
        strrezord = strrezord .. lficondicelrow (strt7mp,numtabtype,1)
      end--if (booparsed) then
      if (boorem) then
        strrezord = strrezord .. lficondicelrow (strrem,numtabtype,2)
      end--if (boorem) then
      if (boocat) then
        if (boogoodresult) then
          strt7mp = strzzcatlst -- already formatted
        else
          strt7mp = strkombo -- do NOT explain again, keep code only
        end--if
        strrezord = strrezord .. lficondicelrow (strt7mp,numtabtype,3)
      end--if (boocat) then
      if (booback) then
        if (boo3nsm2m) then
          strt7mp = constrempt -- placeholder for "nsm=2"
        else
          strt8mp = 'target=' .. mw.uri.encode (strtmplnwp, "WIKI")  -- no quest "?" and no and "&" here
          strt7mp =            lfwbrew3url (arxframent, constrprli, strt8mp, constrbalik, true) .. '<br><br>' -- all
          strt8mp = strt8mp .. '&hidetrans=1&hidelinks=1'
          strt7mp = strt7mp .. lfwbrew3url (arxframent, constrprli, strt8mp, constrredir, true) -- redirects
          strt7mp = '<small>' .. strt7mp .. '</small>'
        end--if
        strrezord = strrezord .. lficondicelrow (strt7mp,numtabtype,4)
      end--if (booback) then
      if (boodebug) then
        strt7mp = 'Same page:&nbsp;' .. tostring(boosamepage) .. '<br>' -- always
        strt7mp = strt7mp .. 'Expand status:&nbsp;' .. lfiexpandstatus(numpexpasta) .. '<br>' -- always
        if (numpexpasta==70) then
          strt7mp = strt7mp .. 'Total out size:&nbsp;' .. tostring(numzfullrs) .. '<br>' -- only on expand success #X70
          strt7mp = strt7mp .. lfhreportfindings (tabpaarsemap[0]) -- only on expand success #X70
          strt7mp = strt7mp .. 'Split status:&nbsp;' .. lfisplitstatus(numzsplitsta) .. '<br>' -- only on expand success #X70
          if (numzsplitsta<20) then
            strt7mp = strt7mp .. 'Number of cat insertions:&nbsp;' .. tostring(numzjumlahkt) .. '<br>' -- only on
            strt7mp = strt7mp .. 'Number of cat dupes:&nbsp;' .. tostring(numzjumlahdp) .. '<br>' -- split success
            strt7mp = strt7mp .. 'Decategorized size:&nbsp;' .. tostring(numznoncat) .. '<br>' -- less than #S20
          end--if
          if (boomapinstead) then
            strt8mp = lfhtablewithmap(strzzfullrs,tabpaarsemap) -- only on expand success #X70
          else
            strt8mp = lfiultencode(strzzfullrs,48,booyescolour,false) -- only on expand success #X70
            strt8mp = lficenqtabqlefqtxt(strt8mp) -- outsid cent insid left
          end--if
          strt7mp = strt7mp .. '<br>' .. strt8mp
        end--if
        strrezord = strrezord .. lficondicelrow (strt7mp,numtabtype,5) -- always
      end--if (boodebug) then
      strvisgud = strvisgud .. strrezord
    end--do scope
  end--if ((numerr==0) and (numspec==0)) then

  ---- FINALIZE ROW OR COMPLETE TABLE IF WE HAVE SUCH ----

  -- 0 raw | 1 bunch of cells | 2 (defa) row | 3 compl hori 1+1 rows
  -- 4 compl hori 1 row | 5 compl vert 1...6 rows

  if (numerr==0) then
    if ((numspec==7) or (numtabtype==2) or (numtabtype==3) or (numtabtype==4)) then
      strvisgud = '<tr>' .. strvisgud .. '</tr>' -- finalize row
    end--if
    if ((numspec==0) and (numtabtype>=3)) then
      strvisgud = qstrtabegin .. strvisgud .. qstrtaendus -- finalize table
    end--if
    if (numspec==7) then
      strvisgud = qstrtabegin .. strvisgud -- begin table only, have one row
    end--if
    if (numspec==9) then
      strvisgud = qstrtaendus -- terminate table only, no other content
    end--if
  end--if

  ---- WHINE IF YOU MUST #E02...#E99 ----

  -- reporting of errors #E02...#E99 depends on uncommentable stuff
  -- and name of the caller filled in from "constrkoll"

  if (numerr>1) then
    strviserr = lfhbrewerror(numerr)
  end--if

  ---- RETURN THE JUNK STRING ----

  -- on #E02 and higher we risk partial results in "strvisgud"

  if (numerr==0) then
    strret = strvisgud
  else
    strret = strviserr
  end--if
  return strret

end--function

  ---- RETURN THE JUNK TABLE ----

return exporttable