set cmd_args(\\dotfill) [list]
  set cmd_args(\\doublerulesep) [list m]

  set cmd_args(\\em) [list]
  set cmd_args(\\emph) [list m]
  set cmd_args(\\encl) [list m]
  set cmd_args(\\end) [list m]
  set cmd_args(\\endfirsthead) [list]
  set cmd_args(\\endfoot) [list]
  set cmd_args(\\endhead) [list]
  set cmd_args(\\endlastfoot) [list]
  set cmd_args(\\evensidemargin) [list m]
  set cmd_args(\\extracolsep) [list m]

  set cmd_args(\\fbox) [list m]
  set cmd_args(\\fboxrule) [list m]
  set cmd_args(\\fboxsep) [list m]
  set cmd_args(\\fill) [list]

  set cmd_args(\\typeout) [list m]

  set cmd_args(\\unboldmath) [list]
  set cmd_args(\\underbrace) [list m]
  set cmd_args(\\underline) [list m]
  set cmd_args(\\unitlength) [list m]
  set cmd_args(\\usebox) [list m]
  set cmd_args(\\usepackage) [list o m]

  set cmd_args(\\value) [list m]
  set cmd_args(\\vec) [list m]
  set cmd_args(\\vector) [list p2 m]
  set cmd_args(\\verb) [list m]
  set cmd_args(\\verb*) [list m]
  set cmd_args(\\vfill) [list]

  set cmd_package(\\dotfill) [list]
  set cmd_package(\\doublerulesep) [list]

  set cmd_package(\\em) [list]
  set cmd_package(\\emph) latex
  set cmd_package(\\encl) [list]
  set cmd_package(\\end) [list]
  set cmd_package(\\endfirsthead) [list]
  set cmd_package(\\endfoot) [list]
  set cmd_package(\\endhead) [list]
  set cmd_package(\\endlastfoot) [list]
  set cmd_package(\\evensidemargin) [list]
  set cmd_package(\\extracolsep) [list]

  set cmd_package(\\fbox) [list]
  set cmd_package(\\fboxrule) [list]
  set cmd_package(\\fboxsep) [list]
  set cmd_package(\\fill) [list]

  set cmd_package(\\typeout) [list]

  set cmd_package(\\unboldmath) [list]
  set cmd_package(\\underbrace) [list]
  set cmd_package(\\underline) [list]
  set cmd_package(\\unitlength) [list]
  set cmd_package(\\usebox) [list]
  set cmd_package(\\usepackage) [list]

  set cmd_package(\\value) [list]
  set cmd_package(\\vec) [list]
  set cmd_package(\\vector) [list]
  set cmd_package(\\verb) [list]
  set cmd_package(\\verb*) [list]
  set cmd_package(\\vfill) [list]

    incr eval_level
if {$eval_stmt_debug > 0} {
puts "EVALOBJ 1a level!$eval_level![$script_obj_ptr toDebugString]!"
if {$eval_stmt_debug > 1} {
puts "EVALOBJ 1b level!$eval_level![$script_obj_ptr mySelf]!"
}
}

    set ::Interp::error_flag false












    $script_obj_ptr incrRefCount "I_EVAL_STATEMENT_4";     # Make sure it's shared.
    set script [$::Interp::script_obj_type getScript $script_obj_ptr]
#puts "Evalobj2!$script!"
    if {$script eq ""} {
      ::Interp setResultString "error in parsing script: \"$script_obj_ptr\""



      incr eval_level -1
      return [::Interp::string2ReturnCode ERROR]
    }

    # Reset the interpreter result. This is useful to
    # return the empty result in the case of empty program.
    ::Interp setEmptyResult













puts "EVALOBJ3"






















    # Now we have to make sure the internal repr will not be
    # freed on shimmering.
    #
    # Think for example to this:
    #
    # set x {llength $x; ... some more code ...}; eval $x
    #
    # In order to preserve the internal rep, we increment the
    # inUse field of the script internal rep structure. 
    [$script getScriptObject] setRefCount [expr {[[$script getScriptObject] getRefCount] + 1}]
    set token [[$script getScriptObject] getTokens]
    # Execute every command sequentially until the end of the script
    # or an error occurs.
puts "EVALOBJ4"

    set i 0
    while {$i < [[$script getScriptObject] getLen] && $retcode == [::Interp::string2ReturnCode OK]} {
      set num_comments 0

      set next_token [[lindex $token $i] getToken]
puts "TOK![::Parser::Token::token2String $next_token]!"
      if {$next_token == [::Parser::Token::string2Token "TOKEN_COMMENT"]} {
        incr i
	continue
      }
      # First token of the line is always TOKEN_LINE 
      if {$next_token != [::Parser::Token::string2Token "TOKEN_LINE"]} {
puts stderr "unexpected token in evalObj at begin of loop!"
      }
puts "I0!$i!"
      if {$next_token == [::Parser::Token::string2Token "TOKEN_LINE"]} {
        set argc [[[lindex $token $i] getObjPtr] scriptLineValue_GetArgc]
#puts "I!$i!$argc![::Parser::Token::token2String [[lindex $token $i] getToken]]![[[lindex $token $i] getObjPtr] toDebugString]!"
        set line_no [[[lindex $token $i] getObjPtr] scriptLineValue_GetLine]
        # Skip the TOKEN_LINE token 
        incr i
      }
      # Populate the arguments objects.
      # If an error occurs, retcode will be set and
      # 'j' will be set to the number of args expanded
      
      set had_comment false
      set j 0
while {$j < $argc} {
if {$eval_stmt_debug > -2} {
puts "all J!$j![::Parser::Token::token2String [[lindex $token [expr {$j + $i}]] getToken]]![lindex $token [expr {$j + $i}] getObjPtr]!"
}              
incr j
}
      set j 0
      set next_token [[lindex $token [expr {$j + $i}]] getToken]
puts "TOK![::Parser::Token::token2String $next_token]!"
      if {$next_token == [::Parser::Token::string2Token "TOKEN_COMMENT"]} {
        incr i
	continue
      }
      if {$next_token == [::Parser::Token::string2Token "TOKEN_TAG_NAME"]} {
        # check if it is a valid command and if yes check for the correct arguments
        set my_obj_ptr [[lindex $token [expr {$j + $i}]] getObjPtr]
	set tag_name [$my_obj_ptr getString]
puts "TAG!$tag_name![::LaTeX::CommandInfo::isCommand $tag_name]![::LaTeX::CommandInfo::getCommandArgsInfo $tag_name]!"
        if {[::LaTeX::CommandInfo::isCommand $tag_name]} {
          set args_info [::LaTeX::CommandInfo::getCommandArgsInfo $tag_name]
	  switch $tag_name {
          "\\begin" {
            # special handling
            lappend argv [[lindex $token [expr {$j + $i}]] getObjPtr]
            incr j
            while {true} {
                set arg_token [[lindex $token [expr {$j + $i}]] getToken]
		if {$arg_token != [::Parser::Token::string2Token "TOKEN_BRACE"] && $arg_token != [::Parser::Token::string2Token "TOKEN_BRACKET"]} {
                  set returncode [uplevel #0 [list $tag_name] [lrange $argv 1 end]]
	          set argv [list]
                  incr i $j
                  break
                }
                lappend argv [[lindex $token [expr {$j + $i}]] getObjPtr]
                incr j
            }
	    continue
            }
          default {
puts "argc!$tag_name!$argc![llength $args_info]!"
            lappend argv [[lindex $token [expr {$j + $i}]] getObjPtr]
            incr j
            foreach arg_type $args_info {
              switch -glob $arg_type {
              m {
                # mandatory argument
                set arg_token [[lindex $token [expr {$j + $i}]] getToken]
                if {$arg_token eq [::Parser::Token::string2Token "TOKEN_BRACE"]} {
                  if {$j > $argc} {
puts stderr "$tag_name: parsing $argc tokens, need $j tokens!"
                  }
                  lappend argv [[lindex $token [expr {$j + $i}]] getObjPtr]
                  incr j
                } else {
puts stderr "missing mandatory token for $tag_name!"
                }
                }
              o {
                # optional argument
                set arg_token [[lindex $token [expr {$j + $i}]] getToken]
                if {$arg_token == [::Parser::Token::string2Token "TOKEN_BRACKET"]} {
                  if {$j > $argc} {
                  }
                  lappend argv [[lindex $token [expr {$j + $i}]] getObjPtr]
                  incr j
                } else {
                  lappend argv [list]
                }
                }
              p* {
                }
              x {
                puts stderr "unexpected arg type: $arg_type in evalObj for none \\end command!"
                }
              default {
                puts stderr "funny arg type: $arg_type in evalObj!"
                }
              }
	    }
#puts "command!$tag_name!$argv!"
            set returncode [uplevel #0 [list $tag_name] [lrange $argv 1 end]]
	    set argv [list]
            incr i $j
	    continue
            }
          }
	} else {
puts "no such latex command!$tag_name!"
          incr i
          continue
        }
      } else {
        # no tag_name
puts "additional token![::Parser::Token::token2String $next_token]!"
        incr i
	continue
      }
      while {$j < $argc} {
puts "J!$j!$argc!$argv!"
        set word_tokens 1
        set expand false
        set word_obj_ptr [list]

if {$eval_stmt_debug > -2} {

            }
          TOKEN_BRACE {
            set word_obj_ptr [[lindex $token $i] getObjPtr]
puts "BRACE reached![$word_obj_ptr toDebugString]!"
            }
          TOKEN_TAG_NAME {
            set word_obj_ptr [[lindex $token $i] getObjPtr]
#puts "TAG_NAME reached![$word_obj_ptr toDebugString]!"
            }
          default {
            ::Interp::panic true "default token type reached in evalObj(): [::Parser::Token::token2String [[lindex $token $i] getToken]]"
            }
          }
        } else {
          # For interpolation we call a helper

            }
            break
          }
          $word_obj_ptr incrRefCount "I_EVAL_STATEMENT_6"
          if {!$expand} {
            if {!$had_comment} {
              lappend argv $word_obj_ptr
# puts "lappend argv![$word_obj_ptr toDebugString]!"
            }
          } else {
            # Need to expand word_obj_ptr into multiple args from argv[j] ... 
            set len [$::Interp::list_obj_type listLength $word_obj_ptr]
            int k;
  
//print(">>>EXPAND!"+argc+"!"+len+"!"+newargc+"!"+word_obj_ptr.toDebugString()+"!");

    $obj_ptr strValue_SetCharLength $len
    $obj_ptr strValue_SetMaxLength $len
    if {$len == 0} {
      $obj_ptr setLen 0
      $obj_ptr setBytes ""
    } else {
      $obj_ptr setBytes ""
      $obj_ptr setBytes "[$obj_ptr getBytes][string range $str 0 [expr {$len - 1}]]"
      $obj_ptr setLen $len
    }

    # No obj_type field for the vanilla string object. 
    $obj_ptr setObjType [::Interp::string2ObjType OBJ_TYPE_STRING]
    $obj_ptr setAllocated $where
    $obj_ptr setFreed ""

# *
# * Released under same BSD license as Tcl.
# * (Tcl BSD license found at <http://www.tcl.tk/software/tcltk/license.html>)
# *
# * Copyright 2012 Arnulf P. Wiedemann
#=====================================================

if {0} {
set latex_cmds_info [list \
  [list \\+ [list] [list latex]] \
  [list \\= [list] [list latex]] \
  [list \\| [list] [list latex]] \
  [list \\< [list] [list latex]] \
  [list \\> [list] [list latex]] \
  [list "\\\(" [list] [list latex]] \

  [list \\vfill [list] [list]] \
  [list \\vline [list] [list]] \
  [list \\voffset [list m] [list]] \
  [list \\vspace [list m] [list]] \
  [list \\vspace* [list m] [list]] \
  [list \\widehat [list m] [list]] \
  [list \\widetilde [list m] [list]] \


]

set latex_environment_cmds_info [list \
  [list \\abstract [list] [list]] \
  [list \\appendix [list] [list]] \
  [list \\array [list] [list]] \
  [list \\center [list] [list]] \

  [list \\tabular [list] [list]] \
  [list \\thebibliography [list] [list]] \
  [list \\titlepage [list] [list]] \
  [list \\verbatim [list] [list]] \
  [list \\verbatim* [list] [list]] \
  [list \\verse [list] [list]] \
]
}

global gState
global gCmds
global gPackages
global gCurr




if {0} {









proc parseMandatoryArg {} {
  global gCurr gState

  set argStr ""
  set LC "{"
  set RC "}"
  set hadLC false

      incr gCurr(idx)
      }
    }
  }
  # not reached
  return true
}
}

proc parseLine {line} {
  global gState gCmds gCurr

#puts "parseLine!$line!"
  if {!$gState(inCommand)} {
    set curr_buffer [list]

    set gCurr(idx) 0
    set gCurr(lst) [split $line ""]
    set gCurr(lgth) [llength $gCurr(lst)]
  }
  return true
}



::Parser::Token::Init
::Interp::Init
::LaTeX::CommandInfo::Init
set fname [lindex $argv 0]
set fd [open $fname r]
set str [read $fd]
close $fd

#=====================================================
# latex_parse_fcn.tcl 
# *
# * ALDT (Arnulf's Latex Documentation Tool)
# * A Tcl parser for LaTeX files for generating document output (for example html)
# *
# * Implementation of the latex commands in tcl
# *
# * Released under same BSD license as Tcl.
# * (Tcl BSD license found at <http://www.tcl.tk/software/tcltk/license.html>)
# *
# * Copyright 2012 Arnulf P. Wiedemann
#=====================================================

proc showArgs {args} {
  set str ""
  foreach arg $args {
    if {$arg eq ""} {
      append str "!"
    } else {
      append str "![$arg toString]"
    }
  }
  return $str
}

proc \\abovedisplayskip {args} {
puts "\\abovedisplayskip called![uplevel #0 showArgs $args]!"
}

proc \\abovedisplayshortskip {args} {
puts "\\abovedisplayshortskip called![uplevel #0 showArgs $args]!"
}

proc \\acute {args} {
puts "\\acute called![uplevel #0 showArgs $args]!"
}

proc \\addcontentsline {args} {
puts "\\addcontentsline called![uplevel #0 showArgs $args]!"
}

proc \\addcounter {args} {
puts "\\addcounter called![uplevel #0 showArgs $args]!"
}

proc \\address {args} {
puts "\\address called![uplevel #0 showArgs $args]!"
}

proc \\addtocontents {args} {
puts "\\addtocontents called![uplevel #0 showArgs $args]!"
}

proc \\addtocounter {args} {
puts "\\addtocounter called![uplevel #0 showArgs $args]!"
}

proc \\addtolength {args} {
puts "\\addtolength called![uplevel #0 showArgs $args]!"
}

proc \\addvspace {args} {
puts "\\addvspace called![uplevel #0 showArgs $args]!"
}

proc \\Alph {args} {
puts "\\Alph called![uplevel #0 showArgs $args]!"
}

proc \\alph {args} {
puts "\\alph called![uplevel #0 showArgs $args]!"
}

proc \\and {args} {
puts "\\and called![uplevel #0 showArgs $args]!"
}

proc \\arabic {args} {
puts "\\arabic called![uplevel #0 showArgs $args]!"
}

proc \\arraycolsep {args} {
puts "\\arraycolsep called![uplevel #0 showArgs $args]!"
}

proc \\arrayrulewidth {args} {
puts "\\arrayrulewidth called![uplevel #0 showArgs $args]!"
}

proc \\arraystretch {args} {
puts "\\arraystretch called![uplevel #0 showArgs $args]!"
}

proc \\author {args} {
puts "\\author called![uplevel #0 showArgs $args]!"
}

proc \\bar {args} {
puts "\\bar called![uplevel #0 showArgs $args]!"
}

proc \\baselineskip {args} {
puts "\\baselineskip called![uplevel #0 showArgs $args]!"
}

proc \\begin {args} {
puts "\\begin called![uplevel #0 showArgs $args]!"
}

proc \\baselinestretch {args} {
puts "\\baselinestretch called![uplevel #0 showArgs $args]!"
}

proc \\belowdisplayskip {args} {
puts "\\belowdisplayskip called![uplevel #0 showArgs $args]!"
}

proc \\bf {args} {
puts "\\bf called![uplevel #0 showArgs $args]!"
}

proc \\bibitem {args} {
puts "\\bibitem called![uplevel #0 showArgs $args]!"
}

proc \\bigskip {args} {
puts "\\bigskip called![uplevel #0 showArgs $args]!"
}

proc \\bigskipamount {args} {
puts "\\bigskipamount called![uplevel #0 showArgs $args]!"
}

proc \\boldmath {args} {
puts "\\boldmath called![uplevel #0 showArgs $args]!"
}

proc \\bottomfraction {args} {
puts "\\bottomfraction called![uplevel #0 showArgs $args]!"
}

proc \\breve {args} {
puts "\\breve called![uplevel #0 showArgs $args]!"
}

proc \\cal {args} {
puts "\\cal called![uplevel #0 showArgs $args]!"
}

proc \\caption {args} {
puts "\\caption called![uplevel #0 showArgs $args]!"
}

proc \\cc {args} {
puts "\\cc called![uplevel #0 showArgs $args]!"
}

proc \\centering {args} {
puts "\\centering called![uplevel #0 showArgs $args]!"
}

proc \\centerline {args} {
puts "\\centerline called![uplevel #0 showArgs $args]!"
}

proc \\chapter {args} {
puts "\\chapter called![uplevel #0 showArgs $args]!"
}

proc \\chapter* {args} {
puts "\\chapter called![uplevel #0 showArgs $args]!"
}

proc \\check {args} {
puts "\\check called![uplevel #0 showArgs $args]!"
}

proc \\circle {args} {
puts "\\circle called![uplevel #0 showArgs $args]!"
}

proc \\cite {args} {
puts "\\cite called![uplevel #0 showArgs $args]!"
}

proc \\cleardoublepage {args} {
puts "\\cleardoublepage called![uplevel #0 showArgs $args]!"
}

proc \\clearpage {args} {
puts "\\clearpage called![uplevel #0 showArgs $args]!"
}

proc \\cline {args} {
puts "\\cline called![uplevel #0 showArgs $args]!"
}

proc \\closing {args} {
puts "\\closing called![uplevel #0 showArgs $args]!"
}

proc \\columnsep {args} {
puts "\\columnsep called![uplevel #0 showArgs $args]!"
}

proc \\columnseprule {args} {
puts "\\columnseprule called![uplevel #0 showArgs $args]!"
}

proc \\dashbox {args} {
puts "\\dashbox called![uplevel #0 showArgs $args]!"
}

proc \\date {args} {
puts "\\date called![uplevel #0 showArgs $args]!"
}

proc \\dblfloatpagefraction {args} {
puts "\\dblfloatpagefraction called![uplevel #0 showArgs $args]!"
}

proc \\dblfloatsep {args} {
puts "\\dblfloatsep called![uplevel #0 showArgs $args]!"
}

proc \\dbltextfloatsep {args} {
puts "\\dbltextfloatsep called![uplevel #0 showArgs $args]!"
}

proc \\dbltopfraction {args} {
puts "\\dbltopfraction called![uplevel #0 showArgs $args]!"
}

proc \\dbltopnumber {args} {
puts "\\dbltopnumber called![uplevel #0 showArgs $args]!"
}

proc \\ddot {args} {
puts "\\ddot called![uplevel #0 showArgs $args]!"
}

proc \\description {args} {
puts "\\description called![uplevel #0 showArgs $args]!"
}

proc \\discretionary {args} {
puts "\\discretionary called![uplevel #0 showArgs $args]!"
}

proc \\displaymath {args} {
puts "\\displaymath called![uplevel #0 showArgs $args]!"
}

proc \\displaystyle {args} {
puts "\\displaystyle called![uplevel #0 showArgs $args]!"
}

proc \\document {args} {
puts "\\document called![uplevel #0 showArgs $args]!"
}

proc \\documentclass {args} {
puts "\\documentclass called![uplevel #0 showArgs $args]![llength $args]!"
#puts "\\documentclass called![uplevel #0 showArgs $args]!"
}

proc \\documentstyle {args} {
puts "\\documentstyle called![uplevel #0 showArgs $args]!"
}

proc \\dot {args} {
puts "\\dot called![uplevel #0 showArgs $args]!"
}

proc \\dotfill {args} {
puts "\\dotfill called![uplevel #0 showArgs $args]!"
}

proc \\doublerulesep {args} {
puts "\\doublerulesep called![uplevel #0 showArgs $args]!"
}

proc \\em {args} {
puts "\\em called![uplevel #0 showArgs $args]!"
}

proc \\encl {args} {
puts "\\encl called![uplevel #0 showArgs $args]!"
}

proc \\end {args} {
puts "\\end called![uplevel #0 showArgs $args]!"
}

proc \\endfirsthead {args} {
puts "\\endfirsthead called![uplevel #0 showArgs $args]!"
}

proc \\endfoot {args} {
puts "\\endfoot called![uplevel #0 showArgs $args]!"
}

proc \\endhead {args} {
puts "\\endhead called![uplevel #0 showArgs $args]!"
}

proc \\endlastfoot {args} {
puts "\\endlastfoot called![uplevel #0 showArgs $args]!"
}

proc \\enumerate {args} {
puts "\\enumerate called![uplevel #0 showArgs $args]!"
}

proc \\eqnarray {args} {
puts "\\eqnarray called![uplevel #0 showArgs $args]!"
}

proc \\equation {args} {
puts "\\equation called![uplevel #0 showArgs $args]!"
}

proc \\evensidemargin {args} {
puts "\\evensidemargin called![uplevel #0 showArgs $args]!"
}

proc \\extracolsep {args} {
puts "\\extracolsep called![uplevel #0 showArgs $args]!"
}

proc \\fbox {args} {
puts "\\fbox called![uplevel #0 showArgs $args]!"
}

proc \\fboxrule {args} {
puts "\\fboxrule called![uplevel #0 showArgs $args]!"
}

proc \\fboxsep {args} {
puts "\\fboxsep called![uplevel #0 showArgs $args]!"
}

proc \\figure {args} {
puts "\\figure called![uplevel #0 showArgs $args]!"
}

proc \\fill {args} {
puts "\\fill called![uplevel #0 showArgs $args]!"
}

proc \\floatpagefraction {args} {
puts "\\floatpagefraction called![uplevel #0 showArgs $args]!"
}

proc \\floatsep {args} {
puts "\\floatsep called![uplevel #0 showArgs $args]!"
}

proc \\flushbottom {args} {
puts "\\flushbottom called![uplevel #0 showArgs $args]!"
}

proc \\flushleft {args} {
puts "\\flushleft called![uplevel #0 showArgs $args]!"
}

proc \\flushright {args} {
puts "\\flushright called![uplevel #0 showArgs $args]!"
}

proc \\fnsymbol {args} {
puts "\\fnsymbol called![uplevel #0 showArgs $args]!"
}

proc \\footheight {args} {
puts "\\footheight called![uplevel #0 showArgs $args]!"
}

proc \\footnote {args} {
puts "\\footnote called![uplevel #0 showArgs $args]!"
}

proc \\footnotemark {args} {
puts "\\footnotemark called![uplevel #0 showArgs $args]!"
}

proc \\footnotesep {args} {
puts "\\footnotesep called![uplevel #0 showArgs $args]!"
}

proc \\footnotesize {args} {
puts "\\footnotesize called![uplevel #0 showArgs $args]!"
}

proc \\footnotetext {args} {
puts "\\footnotetext called![uplevel #0 showArgs $args]!"
}

proc \\footskip {args} {
puts "\\footskip called![uplevel #0 showArgs $args]!"
}

proc \\frac {args} {
puts "\\frac called![uplevel #0 showArgs $args]!"
}

proc \\frame {args} {
puts "\\frame called![uplevel #0 showArgs $args]!"
}

proc \\framebox {args} {
puts "\\framebox called![uplevel #0 showArgs $args]!"
}

proc \\frenchspacing {args} {
puts "\\frenchspacing called![uplevel #0 showArgs $args]!"
}

proc \\fussy {args} {
puts "\\fussy called![uplevel #0 showArgs $args]!"
}

proc \\fussypar {args} {
puts "\\fussypar called![uplevel #0 showArgs $args]!"
}

proc \\grave {args} {
puts "\\grave called![uplevel #0 showArgs $args]!"
}

proc \\hat {args} {
puts "\\hat called![uplevel #0 showArgs $args]!"
}

proc \\headheight {args} {
puts "\\headheight called![uplevel #0 showArgs $args]!"
}

proc \\headsep {args} {
puts "\\headsep called![uplevel #0 showArgs $args]!"
}

proc \\hfill {args} {
puts "\\hfill called![uplevel #0 showArgs $args]!"
}

proc \\hline {args} {
puts "\\hline called![uplevel #0 showArgs $args]!"
}

proc \\hoffset {args} {
puts "\\hoffset called![uplevel #0 showArgs $args]!"
}

proc \\hrulefill {args} {
puts "\\hrulefill called![uplevel #0 showArgs $args]!"
}

proc \\hspace {args} {
puts "\\hspace called![uplevel #0 showArgs $args]!"
}

proc \\Huge {args} {
puts "\\Huge called![uplevel #0 showArgs $args]!"
}

proc \\huge {args} {
puts "\\huge called![uplevel #0 showArgs $args]!"
}

proc \\imath {args} {
puts "\\imath called![uplevel #0 showArgs $args]!"
}

proc \\include {args} {
puts "\\include called![uplevel #0 showArgs $args]!"
}

proc \\includeonly {args} {
puts "\\includeonly called![uplevel #0 showArgs $args]!"
}

proc \\indent {args} {
puts "\\indent called![uplevel #0 showArgs $args]!"
}

proc \\input {args} {
puts "\\input called![uplevel #0 showArgs $args]!"
}

proc \\intextsep {args} {
puts "\\intextsep called![uplevel #0 showArgs $args]!"
}

proc \\it {args} {
puts "\\it called![uplevel #0 showArgs $args]!"
}

proc \\item {args} {
puts "\\item called![uplevel #0 showArgs $args]!"
}

proc \\itemize {args} {
puts "\\itemize called![uplevel #0 showArgs $args]!"
}

proc \\itemsep {args} {
puts "\\itemsep called![uplevel #0 showArgs $args]!"
}

proc \\jmath {args} {
puts "\\jmath called![uplevel #0 showArgs $args]!"
}

proc \\jot {args} {
puts "\\jot called![uplevel #0 showArgs $args]!"
}

proc \\kill {args} {
puts "\\kill called![uplevel #0 showArgs $args]!"
}

proc \\label {args} {
puts "\\label called![uplevel #0 showArgs $args]!"
}

proc \\LARGE {args} {
puts "\\LARGE called![uplevel #0 showArgs $args]!"
}

proc \\Large {args} {
puts "\\Large called![uplevel #0 showArgs $args]!"
}

proc \\large {args} {
puts "\\large called![uplevel #0 showArgs $args]!"
}

proc \\LaTeX {args} {
puts "\\LaTeX called![uplevel #0 showArgs $args]!"
}

proc \\letter {args} {
puts "\\letter called![uplevel #0 showArgs $args]!"
}

proc \\line {args} {
puts "\\line called![uplevel #0 showArgs $args]!"
}

proc \\linebreak {args} {
puts "\\linebreak called![uplevel #0 showArgs $args]!"
}

proc \\linethickness {args} {
puts "\\linethickness called![uplevel #0 showArgs $args]!"
}

proc \\listoffigures {args} {
puts "\\listoffigures called![uplevel #0 showArgs $args]!"
}

proc \\listoftables {args} {
puts "\\listoftables called![uplevel #0 showArgs $args]!"
}

proc \\makebox {args} {
puts "\\makebox called![uplevel #0 showArgs $args]!"
}

proc \\maketitle {args} {
puts "\\maketitle called![uplevel #0 showArgs $args]!"
}

proc \\marginpar {args} {
puts "\\marginpar called![uplevel #0 showArgs $args]!"
}

proc \\marginparpush {args} {
puts "\\marginparpush called![uplevel #0 showArgs $args]!"
}

proc \\marginparsep {args} {
puts "\\marginparsep called![uplevel #0 showArgs $args]!"
}

proc \\marginparwidth {args} {
puts "\\marginparwidth called![uplevel #0 showArgs $args]!"
}

proc \\markboth {args} {
puts "\\markboth called![uplevel #0 showArgs $args]!"
}

proc \\markright {args} {
puts "\\markright called![uplevel #0 showArgs $args]!"
}

proc \\math {args} {
puts "\\math called![uplevel #0 showArgs $args]!"
}

proc \\mathindent {args} {
puts "\\mathindent called![uplevel #0 showArgs $args]!"
}

proc \\mbox {args} {
puts "\\mbox called![uplevel #0 showArgs $args]!"
}

proc \\medskip {args} {
puts "\\medskip called![uplevel #0 showArgs $args]!"
}

proc \\medskipamount {args} {
puts "\\medskipamount called![uplevel #0 showArgs $args]!"
}

proc \\minipage {args} {
puts "\\minipage called![uplevel #0 showArgs $args]!"
}

proc \\multicolumn {args} {
puts "\\multicolumn called![uplevel #0 showArgs $args]!"
}

proc \\multiput {args} {
puts "\\multiput called![uplevel #0 showArgs $args]!"
}

proc \\name {args} {
puts "\\name called![uplevel #0 showArgs $args]!"
}

proc \\newcommand {args} {
puts "\\newcommand called![uplevel #0 showArgs $args]!"
}

proc \\newcounter {args} {
puts "\\newcounter called![uplevel #0 showArgs $args]!"
}

proc \\newenvironment {args} {
puts "\\newenvironment called![uplevel #0 showArgs $args]!"
}

proc \\newfont {args} {
puts "\\newfont called![uplevel #0 showArgs $args]!"
}

proc \\newlength {args} {
puts "\\newlength called![uplevel #0 showArgs $args]!"
}

proc \\newline {args} {
puts "\\newline called![uplevel #0 showArgs $args]!"
}

proc \\newpage {args} {
puts "\\newpage called![uplevel #0 showArgs $args]!"
}

proc \\newsavebox {args} {
puts "\\newsavebox called![uplevel #0 showArgs $args]!"
}

proc \\newtheorem {args} {
puts "\\newtheorem called![uplevel #0 showArgs $args]!"
}

proc \\noindent {args} {
puts "\\noindent called![uplevel #0 showArgs $args]!"
}

proc \\nolinebreak {args} {
puts "\\nolinebreak called![uplevel #0 showArgs $args]!"
}

proc \\nonfrenchspacing {args} {
puts "\\nonfrenchspacing called![uplevel #0 showArgs $args]!"
}

proc \\nonumber {args} {
puts "\\nonumber called![uplevel #0 showArgs $args]!"
}

proc \\nopagebreak {args} {
puts "\\nopagebreak called![uplevel #0 showArgs $args]!"
}

proc \\normalmarginpar {args} {
puts "\\normalmarginpar called![uplevel #0 showArgs $args]!"
}

proc \\normalsize {args} {
puts "\\normalsize called![uplevel #0 showArgs $args]!"
}

proc \\numberline {args} {
puts "\\numberline called![uplevel #0 showArgs $args]!"
}

proc \\oddsidemargin {args} {
puts "\\oddsidemargin called![uplevel #0 showArgs $args]!"
}

proc \\onecolumn {args} {
puts "\\onecolumn called![uplevel #0 showArgs $args]!"
}

proc \\opening {args} {
puts "\\opening called![uplevel #0 showArgs $args]!"
}

proc \\oval {args} {
puts "\\oval called![uplevel #0 showArgs $args]!"
}

proc \\overbrace {args} {
puts "\\overbrace called![uplevel #0 showArgs $args]!"
}

proc \\overline {args} {
puts "\\overline called![uplevel #0 showArgs $args]!"
}

proc \\pagebreak {args} {
puts "\\pagebreak called![uplevel #0 showArgs $args]!"
}

proc \\pagenumbering {args} {
puts "\\pagenumbering called![uplevel #0 showArgs $args]!"
}

proc \\pageref {args} {
puts "\\pageref called![uplevel #0 showArgs $args]!"
}

proc \\pagestyle {args} {
puts "\\pagestyle called![uplevel #0 showArgs $args]!"
}

proc \\par {args} {
puts "\\par called![uplevel #0 showArgs $args]!"
}

proc \\paragraph {args} {
puts "\\paragraph called![uplevel #0 showArgs $args]!"
}

proc \\parbox {args} {
puts "\\parbox called![uplevel #0 showArgs $args]!"
}

proc \\parindent {args} {
puts "\\parindent called![uplevel #0 showArgs $args]!"
}

proc \\parsep {args} {
puts "\\parsep called![uplevel #0 showArgs $args]!"
}

proc \\parskip {args} {
puts "\\parskip called![uplevel #0 showArgs $args]!"
}

proc \\part {args} {
puts "\\part called![uplevel #0 showArgs $args]!"
}

proc \\picture {args} {
puts "\\picture called![uplevel #0 showArgs $args]!"
}

proc \\poptabs {args} {
puts "\\poptabs called![uplevel #0 showArgs $args]!"
}

proc \\protect {args} {
puts "\\protect called![uplevel #0 showArgs $args]!"
}

proc \\ps {args} {
puts "\\ps called![uplevel #0 showArgs $args]!"
}

proc \\pushtabs {args} {
puts "\\pushtabs called![uplevel #0 showArgs $args]!"
}

proc \\put {args} {
puts "\\put called![uplevel #0 showArgs $args]!"
}

proc \\quotation {args} {
puts "\\quotation called![uplevel #0 showArgs $args]!"
}

proc \\quote {args} {
puts "\\quote called![uplevel #0 showArgs $args]!"
}

proc \\raggedbottom {args} {
puts "\\raggedbottom called![uplevel #0 showArgs $args]!"
}

proc \\raggedleft {args} {
puts "\\raggedleft called![uplevel #0 showArgs $args]!"
}

proc \\raggedright {args} {
puts "\\raggedright called![uplevel #0 showArgs $args]!"
}

proc \\raisebox {args} {
puts "\\raisebox called![uplevel #0 showArgs $args]!"
}

proc \\ref {args} {
puts "\\ref called![uplevel #0 showArgs $args]!"
}

proc \\refstepcounter {args} {
puts "\\refstepcounter called![uplevel #0 showArgs $args]!"
}

proc \\renewcommand {args} {
puts "\\renewcommand called![uplevel #0 showArgs $args]!"
}

proc \\renewenvironment {args} {
puts "\\renewenvironment called![uplevel #0 showArgs $args]!"
}

proc \\reversemarginpar {args} {
puts "\\reversemarginpar called![uplevel #0 showArgs $args]!"
}

proc \\rm {args} {
puts "\\rm called![uplevel #0 showArgs $args]!"
}

proc \\Roman {args} {
puts "\\Roman called![uplevel #0 showArgs $args]!"
}

proc \\roman {args} {
puts "\\roman called![uplevel #0 showArgs $args]!"
}

proc \\rule {args} {
puts "\\rule called![uplevel #0 showArgs $args]!"
}

proc \\samepage {args} {
puts "\\samepage called![uplevel #0 showArgs $args]!"
}

proc \\savebox {args} {
puts "\\savebox called![uplevel #0 showArgs $args]!"
}

proc \\sbox {args} {
puts "\\sbox called![uplevel #0 showArgs $args]!"
}

proc \\sc {args} {
puts "\\sc called![uplevel #0 showArgs $args]!"
}

proc \\scriptscriptstyle {args} {
puts "\\scriptscriptstyle called![uplevel #0 showArgs $args]!"
}

proc \\scriptsize {args} {
puts "\\scriptsize called![uplevel #0 showArgs $args]!"
}

proc \\scriptstyle {args} {
puts "\\scriptstyle called![uplevel #0 showArgs $args]!"
}

proc \\section {args} {
puts "\\section called![uplevel #0 showArgs $args]!"
}

proc \\setcounter {args} {
puts "\\setcounter called![uplevel #0 showArgs $args]!"
}

proc \\setlanguage {args} {
puts "\\setlanguage called![uplevel #0 showArgs $args]!"
}

proc \\setlength {args} {
puts "\\setlength called![uplevel #0 showArgs $args]!"
}

proc \\settowidth {args} {
puts "\\settowidth called![uplevel #0 showArgs $args]!"
}

proc \\sf {args} {
puts "\\sf called![uplevel #0 showArgs $args]!"
}

proc \\shortstack {args} {
puts "\\shortstack called![uplevel #0 showArgs $args]!"
}

proc \\signature {args} {
puts "\\signature called![uplevel #0 showArgs $args]!"
}

proc \\sl {args} {
puts "\\sl called![uplevel #0 showArgs $args]!"
}

proc \\sloppy {args} {
puts "\\sloppy called![uplevel #0 showArgs $args]!"
}

proc \\sloppypar {args} {
puts "\\sloppypar called![uplevel #0 showArgs $args]!"
}

proc \\small {args} {
puts "\\small called![uplevel #0 showArgs $args]!"
}

proc \\smallskip {args} {
puts "\\smallskip called![uplevel #0 showArgs $args]!"
}

proc \\smallskipamount {args} {
puts "\\smallskipamount called![uplevel #0 showArgs $args]!"
}

proc \\sqrt {args} {
puts "\\sqrt called![uplevel #0 showArgs $args]!"
}

proc \\stackrel {args} {
puts "\\stackrel called![uplevel #0 showArgs $args]!"
}

proc \\stepcounter {args} {
puts "\\stepcounter called![uplevel #0 showArgs $args]!"
}

proc \\subparagraph {args} {
puts "\\subparagraph called![uplevel #0 showArgs $args]!"
}

proc \\subsection {args} {
puts "\\subsection called![uplevel #0 showArgs $args]!"
}

proc \\subsubsection {args} {
puts "\\subsubsection called![uplevel #0 showArgs $args]!"
}

proc \\symbol {args} {
puts "\\symbol called![uplevel #0 showArgs $args]!"
}

proc \\tabbing {args} {
puts "\\tabbing called![uplevel #0 showArgs $args]!"
}

proc \\tabbingsep {args} {
puts "\\tabbingsep called![uplevel #0 showArgs $args]!"
}

proc \\tabcolsep {args} {
puts "\\tabcolsep called![uplevel #0 showArgs $args]!"
}

proc \\table {args} {
puts "\\table called![uplevel #0 showArgs $args]!"
}

proc \\tableofcontents {args} {
puts "\\tableofcontents called![uplevel #0 showArgs $args]!"
}

proc \\tabular {args} {
puts "\\tabular called![uplevel #0 showArgs $args]!"
}

proc \\TeX {args} {
puts "\\TeX called![uplevel #0 showArgs $args]!"
}

proc \\textfraction {args} {
puts "\\textfraction called![uplevel #0 showArgs $args]!"
}

proc \\textfloatsep {args} {
puts "\\textfloatsep called![uplevel #0 showArgs $args]!"
}

proc \\textheight {args} {
puts "\\textheight called![uplevel #0 showArgs $args]!"
}

proc \\textstyle {args} {
puts "\\textstyle called![uplevel #0 showArgs $args]!"
}

proc \\textwidth {args} {
puts "\\textwidth called![uplevel #0 showArgs $args]!"
}

proc \\thanks {args} {
puts "\\thanks called![uplevel #0 showArgs $args]!"
}

proc \\thebibliography {args} {
puts "\\thebibliography called![uplevel #0 showArgs $args]!"
}

proc \\thicklines {args} {
puts "\\thicklines called![uplevel #0 showArgs $args]!"
}

proc \\thinlines {args} {
puts "\\thinlines called![uplevel #0 showArgs $args]!"
}

proc \\thispagestyle {args} {
puts "\\thispagestyle called![uplevel #0 showArgs $args]!"
}

proc \\tilde {args} {
puts "\\tilde called![uplevel #0 showArgs $args]!"
}

proc \\tiny {args} {
puts "\\tiny called![uplevel #0 showArgs $args]!"
}

proc \\title {args} {
puts "\\title called![uplevel #0 showArgs $args]!"
}

proc \\titlepage {args} {
puts "\\titlepage called![uplevel #0 showArgs $args]!"
}

proc \\today {args} {
puts "\\today called![uplevel #0 showArgs $args]!"
}

proc \\topfraction {args} {
puts "\\topfraction called![uplevel #0 showArgs $args]!"
}

proc \\topmargin {args} {
puts "\\topmargin called![uplevel #0 showArgs $args]!"
}

proc \\topnumber {args} {
puts "\\topnumber called![uplevel #0 showArgs $args]!"
}

proc \\topsep {args} {
puts "\\topsep called![uplevel #0 showArgs $args]!"
}

proc \\topskip {args} {
puts "\\topskip called![uplevel #0 showArgs $args]!"
}

proc \\totalnumber {args} {
puts "\\totalnumber called![uplevel #0 showArgs $args]!"
}

proc \\tt {args} {
puts "\\tt called![uplevel #0 showArgs $args]!"
}

proc \\twocolumn {args} {
puts "\\twocolumn called![uplevel #0 showArgs $args]!"
}

proc \\typein {args} {
puts "\\typein called![uplevel #0 showArgs $args]!"
}

proc \\typeout {args} {
puts "\\typeout called![uplevel #0 showArgs $args]!"
}

proc \\unboldmath {args} {
puts "\\unboldmath called![uplevel #0 showArgs $args]!"
}

proc \\underbrace {args} {
puts "\\underbrace called![uplevel #0 showArgs $args]!"
}

proc \\underline {args} {
puts "\\underline called![uplevel #0 showArgs $args]!"
}

proc \\unitlength {args} {
puts "\\unitlength called![uplevel #0 showArgs $args]!"
}

proc \\usebox {args} {
puts "\\usebox called![uplevel #0 showArgs $args]!"
}

proc \\usepackage {args} {
puts "\\usepackage called![uplevel #0 showArgs $args]!"
}

proc \\value {args} {
puts "\\value called![uplevel #0 showArgs $args]!"
}

proc \\vec {args} {
puts "\\vec called![uplevel #0 showArgs $args]!"
}

proc \\vector {args} {
puts "\\vector called![uplevel #0 showArgs $args]!"
}

proc \\verb {args} {
puts "\\verb called![uplevel #0 showArgs $args]!"
}

proc \\verbatim {args} {
puts "\\verbatim called![uplevel #0 showArgs $args]!"
}

proc \\verse {args} {
puts "\\verse called![uplevel #0 showArgs $args]!"
}

proc \\vfill {args} {
puts "\\vfill called![uplevel #0 showArgs $args]!"
}

proc \\vline {args} {
puts "\\vline called![uplevel #0 showArgs $args]!"
}

proc \\voffset {args} {
puts "\\voffset called![uplevel #0 showArgs $args]!"
}

proc \\vspace {args} {
puts "\\vspace called![uplevel #0 showArgs $args]!"
}

proc \\widehat {args} {
puts "\\widehat called![uplevel #0 showArgs $args]!"
}

proc \\widetilde {args} {
puts "\\widetilde called![uplevel #0 showArgs $args]!"
}